ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

LangChain は 大規模言語モデル（LLM, Large Language Models）を使ったアプリ開発を効率化するためのフレームワークです。

### LangChain とは？
– Python や JavaScript で使える オープンソースのライブラリ
– OpenAI GPT, Anthropic Claude, Llama などの LLM を 組み合わせて活用できる
– 単に「プロンプトを投げて応答をもらう」以上のことを簡単に構築できる

### 主な機能
– Prompt Management（プロンプト管理）
– Chains（チェーン）
「ユーザーの質問 → LLM 応答 → 外部データ検索 → さらに LLM 応答」みたいに処理をつなげられる
– Agents（エージェント）
LLM が「どのツールを使うか」を自分で判断して実行できる
例：Web検索、計算機、SQLデータベース などを LLM が使い分ける
– Memory（メモリ）
対話の履歴を覚えて、会話に文脈を持たせられる
– Retrieval（外部知識の利用）
RAG（Retrieval Augmented Generation）を簡単に構築できる
例：PDFやドキュメントをベクトルDBに格納して、質問に応じて検索し、LLMに渡す

### 必要なインストール
$ pip3 install langchain
$ pip3 install langchain-openai

from langchain_openai import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os
from dotenv import load_dotenv

load_dotenv()

llm = OpenAI(
    temperature=0.7,
    api_key=os.getenv("OPENAI_API_KEY")  # ← ここで明示的に渡す
)

# プロンプトのテンプレートを定義
template = "質問: {question}\n答えをわかりやすく説明してください。"
prompt = PromptTemplate(template=template, input_variables=["question"])

# LLMChain を作成
chain = prompt | llm

# 実行
response = chain.invoke({"question": "LangChainとは何ですか？"})
print(response)

$ python3 test_langchain.py

LangChain（言語チェーン）とは、さまざまな言語を繋げて利用することができるシステムのことを指します。つまり、複数の言語を一つのチェーン（連鎖）のようにつなげて、それぞれの言語を柔軟に切り替えて使うことができる仕組みです。これにより、異なる言語を話す人々がコミュニケーションを取る際に、よりスムーズに相手の言語を理解することができるようになります。また、翻訳や通訳の分野にも応用されています。

pip install -q google-generativeai

import google.generativeai as genai  # Googleの生成AIライブラリ
from google.colab import userdata  # Google Colabのユーザーデータモジュール

GOOGLE_API_KEY=userdata.get('GOOGLE_API_KEY')
genai.configure(api_key=GOOGLE_API_KEY)

print("使用可能なGeminiのモデル一覧：")
for model in genai.list_models():
    if "generateContent" in model.supported_generation_methods:
        print(model.name)

model = genai.GenerativeModel("models/gemini-2.0-flash-001")
print(f"選択されたモデル: {model.model_name}")

config = genai.GenerationConfig(
    max_output_tokens=2048,  # 生成されるトークンの最大数
    temperature=0.8,  # 出力のランダム性を制御
)

def generate_content(model, prompt):
    response = model.generate_content(prompt, generation_config=config)
    return response.text

user_input = input("質問を入力してください: ")
response = generate_content(model, user_input)
print(f"Gemini: {response}")

LLaMA-2の主要構造
1. Pythonコード (約1000行)　: llama
2. パラメータ : llama-2-7b 次の単語予想に使用
3. トークナイザ : 前処理でテキストを分割

step1: トークナイザで入力テキストを細かく分割する
step2: Transformerとパラメータを用いて次の単語を予測
step3: 予測結果を元に次の単語を選択し結合
※予測結果から単語を選ぶプロセスをサンプリングと呼ぶ

model.py

class Transformer(nn.Module):
    def __init__(self, params: ModelArgs):
        """
        Initialize a Transformer model.

        Args:
            params (ModelArgs): Model configuration parameters.

        Attributes:
            params (ModelArgs): Model configuration parameters.
            vocab_size (int): Vocabulary size.
            n_layers (int): Number of layers in the model.
            tok_embeddings (ParallelEmbedding): Token embeddings.
            layers (torch.nn.ModuleList): List of Transformer blocks.
            norm (RMSNorm): Layer normalization for the model output.
            output (ColumnParallelLinear): Linear layer for final output.
            freqs_cis (torch.Tensor): Precomputed cosine and sine frequencies.

        """
        super().__init__()
        self.params = params
        self.vocab_size = params.vocab_size
        self.n_layers = params.n_layers

        self.tok_embeddings = ParallelEmbedding(
            params.vocab_size, params.dim, init_method=lambda x: x
        )

        self.layers = torch.nn.ModuleList()
        for layer_id in range(params.n_layers):
            self.layers.append(TransformerBlock(layer_id, params))

        self.norm = RMSNorm(params.dim, eps=params.norm_eps)
        self.output = ColumnParallelLinear(
            params.dim, params.vocab_size, bias=False, init_method=lambda x: x
        )

        self.freqs_cis = precompute_freqs_cis(
            # Note that self.params.max_seq_len is multiplied by 2 because the token limit for the Llama 2 generation of models is 4096. 
            # Adding this multiplier instead of using 4096 directly allows for dynamism of token lengths while training or fine-tuning.
            self.params.dim // self.params.n_heads, self.params.max_seq_len * 2
        )

    @torch.inference_mode()
    def forward(self, tokens: torch.Tensor, start_pos: int):
        """
        Perform a forward pass through the Transformer model.

        Args:
            tokens (torch.Tensor): Input token indices.
            start_pos (int): Starting position for attention caching.

        Returns:
            torch.Tensor: Output logits after applying the Transformer model.

        """
        _bsz, seqlen = tokens.shape
        h = self.tok_embeddings(tokens)
        self.freqs_cis = self.freqs_cis.to(h.device)
        freqs_cis = self.freqs_cis[start_pos : start_pos + seqlen]

        mask = None
        if seqlen > 1:
            mask = torch.full(
                (seqlen, seqlen), float("-inf"), device=tokens.device
            )

            mask = torch.triu(mask, diagonal=1)

            # When performing key-value caching, we compute the attention scores
            # only for the new sequence. Thus, the matrix of scores is of size
            # (seqlen, cache_len + seqlen), and the only masked entries are (i, j) for
            # j > cache_len + i, since row i corresponds to token cache_len + i.
            mask = torch.hstack([
                torch.zeros((seqlen, start_pos), device=tokens.device),
                mask
            ]).type_as(h)

        for layer in self.layers:
            h = layer(h, start_pos, freqs_cis, mask)
        h = self.norm(h)
        output = self.output(h).float()
        return output

いくつかの処理では、パラメータと呼ばれる数値を使用して演算が行われる
パラメータを繰り返し調整し、予想の精度を高める
※予想が誤っていた場合、パラメータを修正する (バックプロパゲーションと呼ばれる)
※LLMのパラメータ: 「Apple」という単語は、その単語が持つ意味、文脈、関連する概念（例えば、食べ物、会社名、色など）が、膨大な数値の集合（ベクトル）として表現されます。これらの数値の組み合わせによって、単語間の関係性が学習されています。
※単語のIDやトークンに対して数値ベクトルが割り当てられる
※モデルの大部分を占めるのは、単語間の関係性を理解し、次の単語を予測するための複雑な計算を行う、**アテンション機構やフィードフォワードネットワーク内の重み（weights）やバイアス（biases）**です。これらのパラメータが、文脈に応じた適切な単語の埋め込みベクトルを組み合わせ、最終的な出力を生成する。

### LLMの学習ステップ
学習ステップ1. 事前学習(Pre-training): 基盤モデル ただし、対話形式の学習が不足、不適切な質問にも答えてしまう
学習ステップ2. ファインチューニング(Fine-tuning): 特定のタスクや分野に特化させることができる
学習ステップ3. ヒューマンフィードバック(Human Feedback): 人間からのフィードバックを得る

### 事前学習に使われるデータ
モデルの用途によって、収集するデータ元(Webサイト、書籍、会話テキスト)の比率などが変わってくる。例えば、チャット用途の場合は、比較的会話データが多く学習される傾向にある。

### Transformer
Transformerの構造は主にEncoder(テキスト理解)とDecoder(テキスト生成)の要素から成り立つ

Attention機構の役割: 文中から関連度の高い単語を発見する

元画像

text
“This note is a personal reflection of a freelance engineer’s experience.”

動画生成

### モーションAIサービス
音声解析＋AIモーション生成
音声データから「発話のリズム・イントネーション」を自動解析
AIモデルが「口の開閉」「表情の変化」「頭や体の動き」を推定して生成
=> JSONやスクリプトの形で、「フレームごとに口パク・まばたき・首の動き」を指示するタイムラインを自動生成
=> 既存のアニメーションライブラリ（例えば Live2D、Unity、After Effects、Blender など）に食わせるデータを準備

Chat GPTと同じように、Canvaでも画像合成ができる。

背景を変えることもできる。

🔍 Canvaマジック編集の仕組みイメージ
ユーザーがマスクを指定（首から下など）
テキスト指示（例: “a black suit and tie”）を入力
Canvaのサーバー側で拡散モデルに送信
画像の「残す部分（顔）」を保持
マスク部分を inpainting（塗り直し）
出力候補を複数生成し、ユーザーに提示

つまり内部的には、Stable Diffusion の inpainting とほぼ同じ流れ
Canvaの服差し替えも「Diffusion Model の inpainting」と考えて良い。

なんだこれは、凄すぎる。。。

### 動画の合成技術
1. 共通点（画像と同じ部分）
生成モデルを使う
画像生成で使うDALL·EやStable Diffusionのように、動画合成もニューラルネットワーク（特に生成モデル）を使います。
条件付き生成が可能
画像: 「黒いスーツを着た人」というプロンプト
動画: 「黒いスーツを着た人が歩く」というプロンプト
→ プロンプトに応じてフレームごとに生成する点は共通
データ表現はピクセルや特徴量
動画も結局は連続した画像（フレーム）なので、フレーム単位での画像合成技術が応用されます。

2. 動画ならではの追加課題
時間方向の一貫性
画像は単独で完結しますが、動画はフレーム間で連続性が必要
例: 人の手が前のフレームから急に消えると不自然
→ 「時間方向のモデル（Temporal model）」や「フロー情報」を使う
フレーム数が多い
1秒で30フレームなら30枚の画像を生成する必要がある
単純にフレームごとに画像生成すると重くなる
→ 先読みや特徴量伝播で効率化
マスクや編集の複雑さ
動画編集では「同じ位置のオブジェクトを全フレームでマスク」する必要がある
画像編集よりマスク処理が大規模かつ複雑

3. 技術例
画像拡張型
Stable Diffusion をフレームごとに生成＋フレーム間のブレ補正
ビデオ特化型生成モデル
Imagen Video（Google）
Runway Gen-2
動画の時間方向情報も含めて生成する
既存動画の変換や編集
Deepfake や映像スタイル変換（例: 動画に別の服装や表情を合成）
元動画を入力として、時間方向に一貫した編集を行う

なるほど、なかなか勉強になるというか、面白いですね。