複数LLMに分ける

複数LLMに分ける

演習C1: 複数の評価軸を別々で処理してみよう

• 独立している処理は分割できる
• 逐次実行と並列実行の実行時間を比較してみよう (エンジニアのみ)

演習C2: 評価結果を使って、記事を修正してみよう

• C1の4つの評価結果を受け取って記事を修正

演習C3: 修正・評価ループを作る（エンジニアのみ）

• C1を修正が必要かどうかも出力させてループを抜けるルートを作る
• 最大3回まで繰り返す（無限ループ注意）

解説A1~A3: 基本, 温度, 思考の設定（genai）

from google import genai
from google.genai.types import GenerateContentConfig, ThinkingConfig

client = genai.Client(vertexai=True)

input_text = "私はサッカーを趣味にしています。"
response = client.models.generate_content(
    model="gemini-2.5-flash", # A1: contentsにプロンプトを渡す（pythonの文法で変数は｛}で埋め込める）
    contents=f"""入力文から趣味を単語で抽出してください。
入力文: {input_text}
""",
    config=GenerateContentConfig(
        temperature=0.1,           # A2: 温度の調整
        thinking_config=ThinkingConfig(
            thinking_budget=0,     # A3: 思考の上限を0にする
            include_thoughts=True, # A3: レスポンスに思考過程を含める（thinking_budgetが0の場合は使えない）
        ),
    ),
)

このプロンプトを変えて実行するだけでWeb版Geminiとの差分を吸収できますね！

解説A1~A3: 基本, 温度, 思考の設定（LangChain）

from langchain_google_vertexai import ChatVertexAI
from langchain_core.prompts import PromptTemplate

llm = ChatVertexAI(
    temperature=1,         # A2: 温度の調整
    model="gemini-2.5-flash",
    thinking_budget=0,     # A3: 思考の上限を0にする
    include_thoughts=True, # A3: レスポンスに思考過程を含める（thinking_budgetが0の場合は使えない）
)
prompt = PromptTemplate.from_template( # A1: プロンプトを渡す（{}は自動で変数化される）
    """入力文から趣味を単語で抽出してください。
入力文: {input_text}"""
)
chain = prompt | llm

# 実行時に変数を渡す
result = chain.invoke({"input_text": "私はサッカーを趣味にしています。"})# A1: 実行時に変数へ代入できる
print(result.content)

LangChainだと事前に定義した変数を呼び出し時に埋める書き方が自然にできる

解説A4: 対話（genai）

history = []
while True:
    user_input = input("入力してください: ")
    history.append(types.Content(role="user", parts=[types.Part(text=user_input)]))

    response = client.models.generate_content(
        model="gemini-2.5-flash-lite",
        contents=history,
        config=types.GenerateContentConfig(system_instruction="必ず英語で応答してください"),
    )

    history.append(types.Content(role="model", parts=[types.Part(text=response.text)]))
    print(response.text)

同じセッションの対話は毎回すべてLLMに入力されているのを実感しよう
→ Web版Geminiで検証するときにコンテキストをリセットする大切さがわかりますね
（長くなるほど性能が落ちます）

解説A4: 対話（LangChain）

llm = ChatVertexAI(model="gemini-2.5-flash-lite")
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "必ず英語で応答してください"),
        MessagesPlaceholder(variable_name="history"),
    ]
)
chain = prompt | llm | StrOutputParser()

history = []
while True:
    user_input = input("入力してください: ")
    history.append(HumanMessage(content=user_input))
    response = chain.invoke({"history": history})
    history.append(AIMessage(content=response))
    print(response)

解説B1: 構造化出力（genai）

from pydantic import BaseModel, Field
class CommentAnalysis(BaseModel): # 出力したい形式をクラスで定義する
    sentiment: Literal["positive", "negative", "neutral"] = Field(
        description="判定結果。positive: ポジティブ、negative: ネガティブ、neutral: ニュートラル"
    )

input_text = "スマート加湿器を購入。静音性は期待通り。給水が面倒なのがマイナス。5点満点中3点といったところ。"
response = client.models.generate_content(
    model="gemini-2.5-flash-lite",
    contents=f"""次のコメントがポジティブかネガティブかニュートラルか判定してください。
`{input_text}`
""",
    config=GenerateContentConfig(
        response_mime_type="application/json",  # Json Output
        response_schema=CommentAnalysis,        # 構造化出力クラスを指定
    ),
)
comment_result = CommentAnalysis.model_validate_json(response.text)

プロンプトで出力を指示するのではなく、APIとして構造化出力をサポートしている！

解説B1: 構造化出力（LangChain）

from pydantic import BaseModel, Field
class CommentAnalysis(BaseModel): # 出力したい形式をクラスで定義する
    sentiment: Literal["positive", "negative", "neutral"] = Field(
        description="判定結果。positive: ポジティブ、negative: ネガティブ、neutral: ニュートラル"
    )

llm = ChatVertexAI(model="gemini-2.5-flash-lite")
prompt = PromptTemplate.from_template(
    """次のコメントを分析して、商品名、ポジティブな点、ネガティブな点、5段階のスコアを返してください。
`{input_text}`
"""
)
chain = prompt | llm.with_structured_output(CommentAnalysis) # 構造化出力
result = chain.invoke(
    {
        "input_text": "スマート加湿器を購入。静音性は期待通り。給水が面倒なのがマイナス。5点満点中3点といったところ。"
    }
)

当然LangChainでもサポート。OpenAIでもOllamaでも同じ書き方できるのが嬉しい。

解説B2,B3: より複雑な構造化出力

# 【B2】 str（文字列）の他にint（整数）も使える
class CommentAnalysis(BaseModel):
    product_name: str = Field(description="商品名")
    positive_points: str = Field(description="ポジティブな点")
    negative_points: str = Field(description="ネガティブな点")
    score: int = Field(description="5段階のスコア", ge=1, le=5)

# 【B3】 クラスを入れ子にもできる
class CategoryFeedback(BaseModel): # str（文字列）の他にint（整数）も使える
    category: Literal["機能", "品質", "価格", "デザイン", "使い勝手"] = Field(description="カテゴリ")
    positive_points: str = Field(description="そのカテゴリに関するポジティブな点")
    negative_points: str = Field(description="そのカテゴリに関するネガティブな点")
class CommentAnalysis(BaseModel):
    product_name: str = Field(description="商品名")
    categories: list[CategoryFeedback] = Field(description="カテゴリ別のフィードバック")
    overall_score: int = Field(description="5段階の総合スコア", ge=1, le=5)

任意の型を出力に定義できるので、「文字列で返ってきたらどうしよう」の心配が不要

解説C: 構造化出力の組み合わせ

LLM時代のデータ活用

プロダクト全体の最適化

• ファインチューニング（FT）
• 強化学習（RL）
• プロンプト最適化

ユーザー個人への最適化（パーソナライズ）

• コンテキストエンジニアリング
• RAG

ユーザーごとにモデル保持するのは非現実的なので、基本このパターンになるはず

モデル学習の種類とイメージ

STEP: 事前学習 → ファインチューニング → 強化学習

LLMを使う多くの企業は、プロンプトチューニングとファインチューニングだけやる

ファインチューニングと強化学習の比較

ファインチューニング

事前学習済みモデルを特定タスクに微調整する

低ランクの小さな重みを付け加えるPEFT（Parameter-Efficient Fine Tuning）のLoRA（Low-Rank Adaptation）が主流

強化学習（理解しなくて良い。飛ばします）

コンテキストエンジニアリングの必要性

LLMの限界

• コンテキストウィンドウ（入力上限）がある（小説8冊分とか入る）
• 詰め込みすぎると指示を無視したり、性能劣化する

↓ LLMに与える情報を管理してあげる必要がある

コンテキストエンジニアリング

無数に増えていく（ユーザーの）情報を

• どう保存するか（そのまま？ラベル付け？集計？圧縮？）
• どう検索するか（最新N件？関連度？重要度？）

プロダクト作りで気にするところ

• データ取得時の検索クエリ / データ保存時の加工処理が案件ごとの設計ポイント！

RAG（Retrieval-Augmented Generation）

• 外部データを検索して応答する

典型的なRAGシステムの全体像：

• RAGはコンテキストエンジニアリングの一種と言える
• LLMは応答インターフェースでしかない（いかにうまく情報取ってこれるか勝負）

RAGの構成要素: 1. クエリ拡張

• ユーザーの曖昧な入力を、LLM等を使って具体的かつ検索しやすい形に変換する

USER: 社内の経費精算の締め切りはいつ？
AI: 月末です
USER: それを過ぎたらどうなる？

USER: PCが重いときの対処法は？

RAGの構成要素: 2. ハイブリッド検索

• DBの情報すべてLLMに渡すのは無理なので、LLMに渡す情報の絞り込み

全文検索: 文字列完全一致で検索（インデックスで高速化）
ベクトル検索:

def get_current_temperature(location: str) -> str:
    """今日の気温を調べる関数"""   # docstringがコンテキストとして渡る
    return "今日の気温は25度です"
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(data=image_bytes, mime_type="image/png"), # D1: 画像入力
        "画像の内容を説明してください",
    ],
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(google_search=types.GoogleSearch()), # D2: Google検索
            types.Tool(code_execution=types.ToolCodeExecution), # D3: コード実行
            get_current_temperature, # D4: 自作関数も渡せれる
        ]
    ),
)

target_texts = ["漫画", "アニメ"]
result = client.models.embed_content(
    model="gemini-embedding-001",
    contents=target_texts,
    config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY"),
)

embedding1 = np.array(result.embeddings[0].values)
embedding2 = np.array(result.embeddings[1].values)

normed_embedding1 = embedding1 / np.linalg.norm(embedding1)
normed_embedding2 = embedding2 / np.linalg.norm(embedding2)
print("cosine similarity: ", np.dot(normed_embedding1, normed_embedding2))

target_texts = ["漫画", "アニメ"]
model = VertexAIEmbeddings(model="gemini-embedding-001")
results = model.embed(
    target_texts,
    embeddings_task_type="SEMANTIC_SIMILARITY",
)

embedding1 = np.array(results[0])
embedding2 = np.array(results[1])

normed_embedding1 = embedding1 / np.linalg.norm(embedding1)
normed_embedding2 = embedding2 / np.linalg.norm(embedding2)
print("cosine similarity: ", np.dot(normed_embedding1, normed_embedding2))

@tool
def func_add(a: int, b: int) -> int:     # 自作関数
    """足し算をする"""                     # Agentは、docstringを読んで判定してくれる
    print("called func_add")
    return a + b
@tool
def func_mul(a: int, b: int) -> int:
    """掛け算をする"""
    print("called func_mul")
    return a * b
agent = create_agent( # 関数を渡す
    model=ChatVertexAI(model="gemini-2.5-flash-lite"), tools = [func_add, func_mul]
)
result = agent.invoke(
    {"messages": [("human", "3と4を足した値に1+3を足した値同士を掛け算するとどうなる？")]}
)