メインコンテンツへスキップ
見出し画像

LlamaIndexによる 埋め込みモデル のファインチューニングを試す

    合成データによる「埋め込みモデル」のファインチューニングを試したのでまとめました。

    【注意】Google Colab Pro/Pro+のA100を使って確認しました。

    1. 埋め込みモデルのファインチューニング

    「LlamaIndex」で、合成データによる「埋め込み」モデルのファインチューニングのColabが提供されてたので、それをベースに独自データで試してみました。

    「埋め込みモデル」のファインチューニングの手順は、次の3ステップです。

    (1) 合成データの作成
    (2) 埋め込みモデルのファインチューニング
    (3) ファインチューニングした埋め込みモデルの評価

    2. ドキュメントの準備

    今回は、マンガペディアの「ぼっち・ざ・ろっく!」のあらすじのドキュメントを使います。

    ・bocchi.txt

    画像

    3. セットアップ

    Colabでのセットアップ手順は、次のとおりです。

    (1) パッケージのインストール。

    # パッケージのインストール
    !pip install llama-index sentence-transformers

    (2) 環境変数の準備。
    以下のコードの <OpenAI_APIのトークン> にはOpenAI APIのトークンを指定します。(有料)

    import os
    import openai
    
    # 環境変数の設定
    os.environ["OPENAI_API_KEY"] = "<OpenAI_APIのトークン>"
    openai.api_key = os.environ["OPENAI_API_KEY"]

    (3) Colabにドキュメント「bocchi.txt」をアップロード。

    画像

    (4) ドキュメントの読み込み。

    from llama_index import SimpleDirectoryReader
    
    # ドキュメントの読み込み
    documents = SimpleDirectoryReader(
        input_files=["bocchi.txt"]
    ).load_data()

    4. 合成データの作成

    Colabでの合成データの作成手順は、次のとおりです。

    4-1. コーパスの作成

    LlamaIndexでテキストチャンクのコーパスを作成します。

    (1) ノードパーサーの準備。
    今回のドキュメント形式にあわせて、paragraph_separator に "\n\n" を指定しました。"\n\n" で段落別けする設定 (デフォルトは"\n\n\n") になります。

    from llama_index.text_splitter import SentenceSplitter
    from llama_index.node_parser import SimpleNodeParser
    
    # ノードパーサーの準備
    text_splitter = SentenceSplitter(
        paragraph_separator="\n\n",
    )
    node_parser = SimpleNodeParser.from_defaults(
        text_splitter=text_splitter
    )

    (2) ドキュメントをコーパスに変換して保存。

    from llama_index.schema import MetadataMode
    import json
    
    # ドキュメントをコーパスに変換
    nodes = node_parser.get_nodes_from_documents(documents)
    corpus = {node.node_id: node.get_content(metadata_mode=MetadataMode.NONE) for node in nodes}
    
    # コーパスの保存
    with open("corpus.json", "w+") as f:
        json.dump(corpus, f, ensure_ascii=False)

    「corpus.json」に、コーパスが保存されます。チャンクIDとチャンク本文のペアになります。

    画像

    4-2. 合成データの作成

    テキストチャンクのコーパスから「合成データ」を作成します。

    (1) 合成データの作成関数の定義。

    import re
    import uuid
    from llama_index.llms import OpenAI
    from tqdm.notebook import tqdm
    
    # 合成データの作成関数
    def generate_queries(
        corpus,
        num_questions_per_chunk=2,
        prompt_template=None,
        verbose=False,
    ):
        llm = OpenAI(model="gpt-3.5-turbo")
    
        prompt_template = prompt_template or """\
        文脈は以下のとおりです。
    
        ---------------------
        {context_str}
        ---------------------
    
        あなたは教師です。 あなたの仕事は、試験問題を作成することです。
        日本のアニメ作品に文脈から重要な事実を捉える{num_questions_per_chunk} 個の質問を、以下の条件で作成します。
        - 質問は必ず提供された文脈に限定
        - 質問は必ず日本語で記述
        - 代名詞は絶対に使用しない
        - 質問は文書全体にわたって本質的に多様である必要がある
        """
    
        queries = {}
        relevant_docs = {}
        for node_id, text in tqdm(corpus.items()):
            query = prompt_template.format(context_str=text, num_questions_per_chunk=num_questions_per_chunk)
            response = llm.complete(query)
    
            result = str(response).strip().split("\n")
            questions = [
                re.sub(r"^\d+[\).\s]", "", question).strip() for question in result
            ]
            questions = [question for question in questions if len(question) > 0]
    
            for question in questions:
                question_id = str(uuid.uuid4())
                queries[question_id] = question
                relevant_docs[question_id] = [node_id]
        return queries, relevant_docs

    (2) 合成データの作成。

    # 合成データの作成
    queries, relevant_docs = generate_queries(corpus)

    (3) 合成データを学習用と評価用に分割。

    # 合成データを学習用と評価用に分割
    train_queries = {}
    train_relevant_docs = {}
    val_queries = {}
    val_relevant_docs = {}
    idx = 0
    for query_id in relevant_docs.keys():
        if idx % 2 == 0:
            train_queries[query_id] = queries[query_id]
            train_relevant_docs[query_id] = relevant_docs[query_id]
        else:
            val_queries[query_id] = queries[query_id]
            val_relevant_docs[query_id] = relevant_docs[query_id]
        idx += 1

    (4) 合成データの保存。

    # 学習用の合成データの保存
    with open("train_queries.json", "w+") as f:
        json.dump(train_queries, f, ensure_ascii=False)
    with open("train_relevant_docs.json", "w+") as f:
        json.dump(train_relevant_docs, f, ensure_ascii=False)
    
    # 評価用の合成データの保存
    with open("val_queries.json", "w+") as f:
        json.dump(val_queries, f, ensure_ascii=False)
    with open("val_relevant_docs.json", "w+") as f:
        json.dump(val_relevant_docs, f, ensure_ascii=False)

    「train_queries.json」「val_queries.json」に、LLMで生成された質問データが保存されます。クエリIDとクエリ本文のペアになります。

    画像

    「train_relevant_docs.json」「val_relevant_docs.json」に、関連データが保存されます。クエリIDとチャンクIDのペアになります。

    画像

    4-3. データセットの作成

    コーパスと合成データをマージして、学習用と評価用のデータセットを作成します。

    (1) データセットの作成。

    # 学習用のデータセットの作成
    train_dataset = {
        "queries": train_queries,
        "corpus": corpus,
        "relevant_docs": train_relevant_docs,
    }
    
    # 評価用のデータセットの作成
    val_dataset = {
        "queries": val_queries,
        "corpus": corpus,
        "relevant_docs": val_relevant_docs,
    }

    (2) データセットの保存。

    # 学習用のデータセットの作成
    with open("train_dataset.json", "w+") as f:
        json.dump(train_dataset, f, ensure_ascii=False)
    
    # 評価用のデータセットの作成
    with open("val_dataset.json", "w+") as f:
        json.dump(val_dataset, f, ensure_ascii=False)

    「train_dataset.json」「val_dataset.json」に、データセットが保存されます。コーパスとクエリと関連データのリストを保持しています。

    5. 埋め込みモデルのファインチューニング

    Colabでの埋め込みモデルのファインチューニングの手順は、次のとおりです。

    (1) 事前学習モデルの読み込み。

    from sentence_transformers import SentenceTransformer
    
    # 事前学習モデルの読み込み
    model_id = "intfloat/multilingual-e5-large"
    model = SentenceTransformer(model_id)

    (2) データセットの読み込み。

    import json
    
    # 学習用のデータセットの読み込み
    with open("train_dataset.json", "r+") as f:
        train_dataset = json.load(f)
    
    # 評価用のデータセットの読み込み
    with open("val_dataset.json", "r+") as f:
        val_dataset = json.load(f)

    (3) バッチサイズの準備。
    通常、バッチ サイズが増加するとパフォーマンスが向上します。

    # バッチサイズの準備
    BATCH_SIZE = 2

    (4) データローダーの準備。

    from torch.utils.data import DataLoader
    from sentence_transformers import InputExample
    
    # 学習データの準備
    corpus = train_dataset["corpus"]
    queries = train_dataset["queries"]
    relevant_docs = train_dataset["relevant_docs"]
    examples = []
    for query_id, query in queries.items():
        node_id = relevant_docs[query_id][0]
        text = corpus[node_id]
        example = InputExample(texts=[query, text])
        examples.append(example)
    
    # データローダーの準備
    loader = DataLoader(
        examples, 
        batch_size=BATCH_SIZE
    )

    (5) 損失 (loss) の準備。
    「MultipleNegativesRankingLoss」は、正のペアだけがある場合、たとえば言い換えのペア、重複した質問のペア、(クエリ、レスポンス) のペア、または (ソース言語、ターゲット言語) のペアなど、類似したテキストのペアのみがある場合に優れた損失関数です。

    from sentence_transformers import losses
    
    # 損失の準備
    loss = losses.MultipleNegativesRankingLoss(model)

    (6) エバリュエーターの準備。
    学習中に埋め込みモデルがどの程度うまく機能しているかを監視します。

    from sentence_transformers.evaluation import InformationRetrievalEvaluator
    
    # エバリュエーターの準備
    corpus = val_dataset["corpus"]
    queries = val_dataset["queries"]
    relevant_docs = val_dataset["relevant_docs"]
    evaluator = InformationRetrievalEvaluator(
        queries, 
        corpus, 
        relevant_docs
    )

    (7) エポックの準備。
    今回は練習のため、非常に少数のエポックでモデルを学習します。 通常、パフォーマンスを向上させるには、これを高くする必要があります。

    # エポックの準備
    EPOCHS = 2

    (8) ファインチューニングの実行。

    # ファインチューニングの実行
    warmup_steps = int(len(loader) * EPOCHS * 0.1)
    model.fit(
        train_objectives=[(loader, loss)],
        epochs=EPOCHS,
        warmup_steps=warmup_steps,
        output_path="exp_finetune",
        show_progress_bar=True,
        evaluator=evaluator, 
        evaluation_steps=50,
    )

    「exp_finetune」フォルダに学習済みモデルが出力されます。

    6. ファインチューニングした埋め込みモデルの評価

    Colabでのファインチューニングした埋め込みモデルの評価手順は、次のとおりです。

    (1) 評価関数の定義。
    単純なヒット率メトリクスを使用します。(クエリ、チャンク) ペアごとに、クエリを使用して上位k個のドキュメントを取得します。結果にチャンクが含まれていればヒットとします。

    from tqdm.notebook import tqdm
    from llama_index import ServiceContext, VectorStoreIndex
    from llama_index.schema import TextNode
    
    # 評価関数
    def evaluate(
        dataset,
        embed_model,
        top_k=5,
        verbose=False,
    ):
        corpus = dataset["corpus"]
        queries = dataset["queries"]
        relevant_docs = dataset["relevant_docs"]
    
        service_context = ServiceContext.from_defaults(embed_model=embed_model)
        nodes = [TextNode(id_=id_, text=text) for id_, text in corpus.items()] 
        index = VectorStoreIndex(
            nodes, 
            service_context=service_context, 
            show_progress=True
        )
        retriever = index.as_retriever(similarity_top_k=top_k)
    
        eval_results = []
        for query_id, query in tqdm(queries.items()):
            retrieved_nodes = retriever.retrieve(query)
            retrieved_ids = [node.node.node_id for node in retrieved_nodes]
            expected_id = relevant_docs[query_id][0]
            is_hit = expected_id in retrieved_ids  # assume 1 relevant doc
            
            eval_result = {
                "is_hit": is_hit,
                "retrieved": retrieved_ids,
                "expected": expected_id,
                "query": query_id,
            }
            eval_results.append(eval_result)
        return eval_results

    (2) ファインチューニング後の埋め込みモデルの評価。

    import pandas as pd
    
    # ファインチューニングした埋め込みモデルの評価の実行
    finetuned = "local:exp_finetune"
    val_results = evaluate(val_dataset, finetuned)
    
    # is_hitの平均の計算
    df_finetuned = pd.DataFrame(val_results)
    hit_rate_finetuned = df_finetuned["is_hit"].mean()
    hit_rate_finetuned
    1.0

    (3) ファインチューニング前の埋め込みモデルの評価。

    import pandas as pd
    
    # ファインチューニングした埋め込みモデルの評価の実行
    finetuned = "local:intfloat/multilingual-e5-large"
    val_results = evaluate(val_dataset, finetuned)
    
    # is_hitの平均の計算
    df_finetuned = pd.DataFrame(val_results)
    hit_rate_finetuned = df_finetuned["is_hit"].mean()
    hit_rate_finetuned
    1.0

    (4) OpenAI APIの埋め込みモデル (ada) の評価。

    import pandas as pd
    from llama_index.embeddings import OpenAIEmbedding
    
    # ファインチューニングした埋め込みモデルの評価の実行
    ada = OpenAIEmbedding()
    val_results = evaluate(val_dataset, ada)
    
    # is_hitの平均の計算
    df_finetuned = pd.DataFrame(val_results)
    hit_rate_finetuned = df_finetuned["is_hit"].mean()
    hit_rate_finetuned
    0.9411764705882353


    本当は、埋め込みモデルの学習を感じられるサンプルにした方が良いですが、今回は練習までとしてまた今度にします。



     
     

    npaka

     
     
    プログラマー。iPhone / Android / Unity / ROS / AI / AR / VR / RasPi / ロボット / ガジェット。年2冊ペースで技術書を執筆。アニソン / カラオケ / ギター / 猫 twitter : @npaka123

    あなたへのおすすめ