学習コースLearn

自然言語処理（NLP）

テキストデータをコンピュータで扱うための基礎技術を、概要から理論、そして実際に動かせるコードまで、順を追って学ぶモジュールです。各ステップは「概要 → 仕組み（座学）→ コードで動かす」の3層で進みます。ページ内には手を動かせるデモを3つ用意しました。

この教材は日本語のみで提供していますThis learning material is available in Japanese only.

学びはじめるStart learning まず手を動かす（トークナイザ体験）Jump to the tokenizer demo

はじめにIntroduction

このモジュールの全体像

自然言語処理（NLP: Natural Language Processing）とは、私たちが普段使う言葉（自然言語）をコンピュータで解析・生成する技術の総称です。検索エンジン、機械翻訳、迷惑メールの判定、チャットボット、そして大規模言語モデル（LLM）まで、身のまわりの多くのサービスがこの技術の上に成り立っています。

ただし、テキストはそのままでは計算できません。多くの手法に共通するのが、次のような処理の流れ（パイプライン）です。生のテキストを整え、数値（特徴量）に変換し、モデルで分析し、応用へつなげます。

NLPの基本パイプライン

テキスト Raw text 前処理 Preprocess 特徴量化 Vectorize モデル・分析 Model 応用 Application 正規化・トークン化 BoW・TF-IDF・埋め込み 分類・類似度・生成

このモジュールは、上のパイプラインを左から順にたどります。各ステップは次の3層で構成します。

  • 概要：その技術が何のためにあるのか、あらましをつかむ。
  • 仕組み（座学）：背後にある理論・定義・式を、ていねいに理解する。
  • コードで動かす：Python の定番ライブラリや、ページ内デモで実際に動かして確かめる。

手を動かす題材には、実在の公開データセット（20 Newsgroups、livedoorニュースコーパスなど）や、ページ内の小さなサンプル文だけを使います。特別な環境がなくても、読みながら試せる構成です。

1

自然言語処理とは

What is NLP

概要Overview

自然言語処理は「人間の言葉」と「コンピュータの計算」の橋渡しをする分野です。私たちは次のような場面で、すでにその成果に触れています。

  • 検索：キーワードから関連文書を並べ替える。
  • 機械翻訳：ある言語の文を別の言語へ変換する。
  • 分類：メールを迷惑/通常に、レビューを肯定/否定に振り分ける。
  • 対話：チャットボットや音声アシスタントが応答する。
  • 大規模言語モデル（LLM）：文章の生成・要約・質問応答をこなす。

仕組みHow it works

言葉をコンピュータで扱うのが難しいのは、自然言語が本質的に曖昧で文脈依存だからです。代表的な難しさを3つ挙げます。

  • 曖昧性：一つの語が複数の意味を持つ。たとえば「はし」は「橋」「箸」「端」のどれか、文脈がなければ決まりません。
  • 文脈依存：「それ」「彼」などの指示語や省略は、前後の文がないと解釈できません。同じ「大丈夫」でも肯定にも辞退にもなります。
  • 表記ゆれ：「コンピュータ / コンピューター」「Apple / apple」「令和6年 / 2024年」のように、同じものが違う表記で現れます。

そこで多くの手法は、いきなり意味を扱うのではなく、まずテキストを機械が処理しやすい形に整え（前処理）、次に数値へ変換し（特徴量化）、その数値に対して統計や機械学習を適用する、という段階を踏みます。このモジュールの Step 2 以降は、まさにこの流れを一つずつ体験していきます。

この Step のまとめ

NLP は言葉をコンピュータで扱う技術の総称。曖昧性・文脈・表記ゆれという難しさがあるため、「整える → 数値化する → モデルにかける」というパイプラインで少しずつ攻略していきます。

2

テキストの前処理

Preprocessing & tokenization

概要Overview

前処理は、生のテキストを「そろえて、区切る」工程です。ここで質が決まると言ってよいほど大切で、後段の特徴量化やモデルの精度に直結します。おおまかに、正規化・トークン化・不要語の除去・語形のまとめ、という作業があります。

仕組みHow it works

1. 正規化（normalization）

表記のゆれをそろえます。英語なら大文字を小文字にする（Apple と apple を同一視）、日本語なら全角と半角、記号の統一などです。数字や記号を落とすかどうかは目的次第で決めます。

2. トークン化（tokenization）

文を語（トークン）の並びに区切ります。英語は単語が空白で区切られているので、空白と句読点で分けるのが基本です。一方、日本語は語の間に空白がありません。そこで形態素解析を使い、辞書と文法規則にもとづいて「分かち書き」します。日本語では MeCab や janome といったツールが定番です。

3. ストップワード（stop words）

「の」「は」「a」「the」のように、どの文書にも高頻度で現れ、内容の区別に寄与しにくい語をストップワードと呼び、目的に応じて除去します。ただし機械翻訳のように語順や機能語が重要な課題では、安易に消すと情報が失われる点に注意します。

4. ステミングとレンマ化

英語では、活用や語尾の違いを吸収して語をまとめる処理があります。ステミング（stemming）は規則で語尾を機械的に削る方法で、studies や studying を studi のような語幹にします（Porter ステマーが有名）。レンマ化（lemmatization）は辞書を使って正しい原形（見出し語）に戻す方法で、studies は study、better は good になります。

デモ 1Demo 1

トークナイザ体験

テキストを入力すると、トークン（語）に区切ってチップで表示します。英語は空白・句読点で分割、日本語は簡易的な分かち書き（小さな辞書＋最長一致）で区切ります。実務では MeCab や janome などの形態素解析器を使いますが、区切りの雰囲気をつかむには十分です。

例
内容語（名詞・動詞など） 助詞・語尾など 英数字

コードで動かすRun the code

英語の素朴な前処理は、標準ライブラリ re だけでも書けます。小文字化して、単語だけを取り出し、ストップワードを除きます。

Pythonenglish_preprocess.py
import re

text = "Cats are running and the dogs are barking!"
stop = {"the", "and", "are", "a", "is"}

# 小文字化して単語だけ取り出す（正規表現でトークン化）
tokens = re.findall(r"[a-z]+", text.lower())
# ストップワードを除去
tokens = [t for t in tokens if t not in stop]
print(tokens)
出力例 / Output
['cats', 'running', 'dogs', 'barking']

日本語は形態素解析が必要です。ここでは純 Python で動く janome を使います。有名な例文で分かち書きと品詞を確認しましょう。

Pythonjanome_tokenize.py
# pip install janome
from janome.tokenizer import Tokenizer

t = Tokenizer()
for token in t.tokenize("すもももももももものうち"):
    print(token.surface, token.part_of_speech.split(",")[0])
出力例 / Output
すもも 名詞
も 助詞
もも 名詞
も 助詞
もも 名詞
の 助詞
うち 名詞

分かち書きした語だけがほしいときは wakati=True が便利です。

Pythonjanome_wakati.py
from janome.tokenizer import Tokenizer

t = Tokenizer(wakati=True)
print(list(t.tokenize("自然言語処理は面白い分野です")))
出力例 / Output
['自然', '言語', '処理', 'は', '面白い', '分野', 'です']

この Step のまとめ

前処理は「そろえて、区切る」。英語は空白で区切れますが、日本語は形態素解析で分かち書きします。ここで作ったトークンの列が、次の Step で数値ベクトルに変わります。

3

テキストを数値にする（BoW・TF-IDF）

From text to numbers

概要Overview

機械学習の多くは数値ベクトルを入力とします。そこで、トークンの列を数のベクトルに変える必要があります。最も基本的な方法が Bag-of-Words（BoW） と、その改良である TF-IDF です。

仕組みHow it works

Bag-of-Words（BoW）

文書を「語の袋（bag）」とみなし、どの語が何回出たかだけで表します。語順は捨てます。語彙全体を列に並べ、各文書を出現回数のベクトルにします。たとえば語彙が [cat, dog, sat, the] のとき、文書「the cat sat」は [1, 0, 1, 1] です。単純ですが、分類などで驚くほどよく効きます。弱点は、語順や文脈を捨てること、そして「the」のようなありふれた語が大きな値を持ちやすいことです。

TF-IDF

後者の弱点に対処するのが TF-IDF です。その文書での出現頻度（TF）を、コーパス全体でのめずらしさ（IDF）で重み付けします。多くの文書に出る語ほど IDF が小さくなり、値が抑えられます。逆に、特定の文書に偏って出る語が強調されます。標準的な定義は次のとおりです。

tf-idf(t, d) = tf(t, d) × log( N / df(t) ) tf(t,d): 文書 d における語 t の頻度　N: 全文書数　df(t): 語 t を含む文書数
すべての文書に出る語は df = N なので log(N/df) = log(1) = 0 となり、重みが 0 になります。

TF の数え方（生の回数か相対頻度か）や IDF の底、平滑化（分母が 0 にならないよう +1 する等）には流儀があります。次のデモは「相対頻度 × 自然対数 log(N/df)」という素直な定義で計算します。いっぽう後述の scikit-learn は、平滑化した IDF と L2 正規化を組み合わせるため、同じ考え方でも数値は少し変わります。

デモ 2Demo 2

TF-IDF ミニ計算機

1 行に 1 文書を書きます（語は空白区切り、日本語は簡易分かち書き）。各語の df・idf と、文書ごとの tf-idf を計算して表にします。値が大きいほど濃い緑で強調します。すべての文書に出る語は idf = 0（重み 0）になる点に注目してください。

例

コードで動かすRun the code

scikit-learn を使えば、BoW も TF-IDF も数行で作れます。まず CountVectorizer で出現回数の行列を作ります。

Pythoncount_vectorizer.py
from sklearn.feature_extraction.text import CountVectorizer

corpus = [
    "the cat sat on the mat",
    "the dog sat on the log",
    "cats and dogs are friends",
]
cv = CountVectorizer()
X = cv.fit_transform(corpus)
print(cv.get_feature_names_out())
print(X.toarray())
出力例 / Output
['and' 'are' 'cat' 'cats' 'dog' 'dogs' 'friends' 'log' 'mat' 'on' 'sat' 'the']
[[0 0 1 0 0 0 0 0 1 1 1 2]
 [0 0 0 0 1 0 0 1 0 1 1 2]
 [1 1 0 1 0 1 1 0 0 0 0 0]]

語順は失われ、各文書が「語彙の長さのベクトル」になりました。the の列が 2 になっているのが分かります。続いて TfidfVectorizer で重み付けします。

Pythontfidf_vectorizer.py
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

corpus = [
    "the cat sat on the mat",
    "the dog sat on the log",
    "cats and dogs are friends",
]
tv = TfidfVectorizer()
X = tv.fit_transform(corpus)
np.set_printoptions(precision=3, suppress=True)
print(X.toarray())
出力例 / Output
[[0.    0.    0.428 0.    0.    0.    0.    0.    0.428 0.325 0.325 0.65 ]
 [0.    0.    0.    0.    0.428 0.    0.    0.428 0.    0.325 0.325 0.65 ]
 [0.447 0.447 0.    0.447 0.    0.447 0.447 0.    0.    0.    0.    0.   ]]

各行は L2 正規化され（長さ 1 のベクトルになり）、めずらしい語ほど大きな値になっています。scikit-learn の既定では IDF に平滑化が入るため、素朴な log(N/df) とは値が異なりますが、「よく出る語を抑え、特徴的な語を強調する」という狙いは同じです。

この Step のまとめ

BoW は語の出現回数ベクトル。TF-IDF は「その文書での頻度 × コーパスでのめずらしさ」で重み付けし、ありふれた語を抑えます。これで文書が数値ベクトルになり、次はベクトル同士の「近さ」を測れます。

4

単語の意味をベクトルに（分散表現）

Word embeddings

概要Overview

BoW や TF-IDF では、各語は「語彙の中の 1 か所だけが 1 の、とても長いベクトル（one-hot 表現）」に対応します。この表し方には限界があり、それを乗り越えるのが分散表現（word embeddings）です。

仕組みHow it works

one-hot の限界

one-hot では、語彙が 5 万語あればベクトルの次元も 5 万になり、しかもほとんどが 0 の疎なベクトルです。さらに致命的なのは、語と語の意味的な近さを表せないことです。「猫」と「犬」は動物として近いのに、one-hot ではどの 2 語も直交し（内積が 0）、「猫と犬」も「猫と自動車」も同じだけ無関係に見えてしまいます。

分布仮説

この問題への鍵が分布仮説（distributional hypothesis）です。言語学者 J.R. Firth の言葉、“You shall know a word by the company it keeps”（1957）に象徴されるように、似た文脈に現れる語は、似た意味を持つという考え方です。「犬が___を食べる」「猫が___を食べる」のように、周囲に現れる語が似ていれば、その 2 語も意味的に近いとみなします。

word2vec の考え方

この仮説をニューラルネットで実装したのが word2vec（Mikolov ら, 2013）です。大量の文から「語とその周辺語」の関係を学習し、各語を数十から数百次元の密なベクトルに割り当てます。学習方式は 2 つあります。

  • CBOW：周辺の語から中心の語を当てる。
  • Skip-gram：中心の語から周辺の語を当てる。

学習後は、意味の近い語のベクトルが近くに配置されます。有名なのが「king - man + woman ≒ queen」のような、意味の関係がベクトルの足し引きに現れる例です。文全体を表したいときは、単語ベクトルの平均を取る素朴な方法から、文脈を考慮した文埋め込みまで、さまざまな発展があります。

コサイン類似度

ベクトル同士の「近さ」はコサイン類似度で測るのが定番です。2 つのベクトルのなす角の余弦（cos）で、向きが同じなら 1、直交なら 0、逆向きなら -1 です（出現回数ベクトルのように成分が 0 以上なら 0 から 1 の範囲）。大きさではなく向きを見るので、文書の長さに左右されにくいのが利点です。

cos(A, B) = (A · B) / ( ‖A‖ × ‖B‖ ) A · B: 内積（成分ごとの積の和）　‖A‖: ベクトル A の長さ（各成分の二乗和の平方根）

コサイン類似度：向きが近いほど値は 1 に近づく

次元 1 次元 2 A =「猫」 B =「犬」 C =「自動車」

A（猫）と B（犬）は向きが近く、なす角（緑の弧）が小さいので、コサイン類似度は 1 に近づきます。いっぽうC（自動車）は向きが離れ、なす角（濃い弧）が大きいので、類似度は小さくなります。

デモ 3Demo 3

コサイン類似度

2 つの短い文を入力すると、それぞれを Bag-of-Words ベクトルに変換し、コサイン類似度を計算します。共通する語が多いほど 1 に近づきます。日本語は簡易分かち書き、英語は空白・句読点で区切ります。

例

コードで動かすRun the code

コサイン類似度そのものは、NumPy で数行です。デモと同じく、語彙をそろえた出現回数ベクトル同士で計算してみます。

Pythoncosine.py
import numpy as np

def cosine(a, b):
    a, b = np.array(a, dtype=float), np.array(b, dtype=float)
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))

# 語彙 [猫, 犬, 好き, 眠る] 上の Bag-of-Words
neko  = [1, 0, 1, 0]  # 「猫 好き」
inu   = [0, 1, 1, 0]  # 「犬 好き」
print(round(cosine(neko, inu), 3))
print(round(cosine(neko, neko), 3))
出力例 / Output
0.5
1.0

単語ベクトルそのものを学習したいときは gensim の Word2Vec が使えます。次は API の使い方の骨格です。意味のある類似度を得るには大きなコーパスが必要で、下のような数文だけの玩具コーパスでは値は安定しません（ベクトルの形だけ確認します）。

Pythonword2vec_gensim.py
# pip install gensim
from gensim.models import Word2Vec

# 実際は分かち書き済みの大量の文を与える
sentences = [["猫", "が", "好き"], ["犬", "が", "好き"],
             ["猫", "が", "眠る"], ["犬", "が", "走る"]]
model = Word2Vec(sentences, vector_size=50, window=2,
                 min_count=1, sg=1)  # sg=1: Skip-gram
print(model.wv["猫"].shape)   # 学習した単語ベクトルの次元
出力例 / Output
(50,)

注意

word2vec は「意味を理解している」わけではなく、大量のテキストから共起の統計を学んでいるだけです。学習データに含まれる偏りや差別的な関連づけも、そのままベクトルに反映されます。結果を使うときは、その出所と限界を意識することが大切です。

5

テキスト分類をやってみる

Text classification

概要Overview

ここまでの道具を組み合わせると、実用的な課題が解けます。代表例がテキスト分類です。迷惑メール判定、ニュースのカテゴリ分け、レビューの感情分析などが、同じ枠組みで実現できます。基本は「TF-IDF で特徴量にして、分類器にかける」だけです。

仕組みHow it works

特徴量と分類器

文書を TF-IDF ベクトルにし、教師あり学習の分類器を学習させます。テキスト分類で古くから強いのが、次の 2 つです。

  • ナイーブベイズ：各語の出現が「クラスが決まれば互いに独立」と仮定して確率を計算する。単純で高速、少データでも安定。
  • ロジスティック回帰：各語の重みを学習して、クラスの確率を出す線形モデル。解釈しやすく高精度。

学習データと検証データ

モデルの本当の実力は、学習に使っていないデータで測ります。データを学習用（train）と検証用（test）に分割し、train で学習し、test で評価します。データが少ないときは、分割を変えながら繰り返し評価する交差検証（cross-validation）で、偶然のばらつきをならします。

評価指標

「正解率（accuracy）」だけでは不十分な場合があります。たとえば 99% が通常メールのデータでは、全部を通常と答えるだけで正解率 99% になってしまいます。そこでクラスごとに次を見ます。

  • 適合率（precision）：陽性と予測したうち、本当に陽性だった割合。TP / (TP + FP)。
  • 再現率（recall）：本当の陽性のうち、正しく拾えた割合。TP / (TP + FN)。
  • F値（F1）：適合率と再現率の調和平均。2PR / (P + R)。両者のバランスを 1 つの数字で表す。

コードで動かすRun the code

scikit-learn の Pipeline を使うと、TF-IDF と分類器をひとまとめにできます。まずは、ダウンロード不要で手元で再現できる小さなサンプル（スポーツ 対 宇宙の英文各 15）で、分類の一連の流れを体験します。

Pythontext_classify.py
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

sport = ["the pitcher threw a fastball and the batter hit a home run",
         "our team won the baseball game in the ninth inning",
         # ... 合計 15 文（野球の話題）
         ]
space = ["the rocket launched into orbit around the earth",
         "astronauts on the space station study microgravity",
         # ... 合計 15 文（宇宙の話題）
         ]

texts  = sport + space
labels = ["sport"] * len(sport) + ["space"] * len(space)

X_tr, X_te, y_tr, y_te = train_test_split(
    texts, labels, test_size=0.4, random_state=1, stratify=labels)

clf = Pipeline([
    ("tfidf", TfidfVectorizer(stop_words="english")),
    ("clf", MultinomialNB()),
])
clf.fit(X_tr, y_tr)
pred = clf.predict(X_te)
print(classification_report(y_te, pred, digits=2))
print(clf.predict(["he hit a home run to win the game"]))
出力例 / Output
              precision    recall  f1-score   support

       space       0.86      1.00      0.92         6
       sport       1.00      0.83      0.91         6

    accuracy                           0.92        12
   macro avg       0.93      0.92      0.92        12
weighted avg       0.93      0.92      0.92        12

['sport']

わずか数十文でも、TF-IDF とナイーブベイズで正解率 0.92 が得られました。より本格的に試すなら、実在の公開データセット 20 Newsgroups（約 2 万件のニュースグループ投稿を 20 カテゴリに分類）を scikit-learn から直接取得できます。2 カテゴリだけ抜き出して、まったく同じ枠組みで学習・評価できます。

Pythonnewsgroups.py
from sklearn.datasets import fetch_20newsgroups

cats = ["rec.sport.baseball", "sci.space"]  # 2カテゴリを抜粋
train = fetch_20newsgroups(subset="train", categories=cats,
            remove=("headers", "footers", "quotes"))
test  = fetch_20newsgroups(subset="test", categories=cats,
            remove=("headers", "footers", "quotes"))

# 上と同じ Pipeline（TfidfVectorizer + 分類器）を train で学習し、
# test で classification_report を出せば、実データで評価できる。
print(len(train.data), "training documents")

ヘッダやフッタ（差出人や署名）を除くのは、そこに含まれるカテゴリ名などを手がかりに「ずるをして」当ててしまうのを防ぐためです。前処理の設計が評価の妥当性を左右する、よい例です。

この Step のまとめ

テキスト分類は「TF-IDF で特徴量にして、分類器にかける」。train と test に分け、正解率だけでなく適合率・再現率・F値で評価します。ここまでが古典的 NLP の王道です。

6

これからのNLP

What comes next

概要Overview

BoW や TF-IDF は強力ですが、決定的な弱点があります。語順と文脈を捨てていることです。「犬が人を噛む」と「人が犬を噛む」は、BoW ではまったく同じベクトルになります。この壁を越える流れが、現代の NLP を形づくってきました。

仕組みHow it works

文脈を捉えるモデルの流れ

語の並びを扱うため、まずRNN（再帰型ニューラルネット）が使われました。単語を 1 つずつ順に読み、それまでの内容を「状態」として持ち越します。ただし長い文では前の情報が薄れやすく、逐次処理のため学習に時間がかかりました。

これを一変させたのが Transformer（Vaswani ら, 2017「Attention Is All You Need」）です。注意機構（attention）によって、文中のどの語とどの語が関係するかを直接・並列に捉えます。長い依存関係に強く、大規模な並列学習が可能になりました。

Transformer を土台に、BERT（Devlin ら, 2018）が登場します。文の両方向の文脈を使い、文章の一部を隠して当てる「マスク言語モデル」で事前学習します。同じ語でも文脈に応じて異なるベクトルになる（文脈化された表現）のが、TF-IDF や word2vec との大きな違いです。

事前学習と転移学習

近年の主役は事前学習（pre-training）と転移学習（transfer learning）という考え方です。まず大量のテキストで言語の一般的な性質を学ばせた汎用モデルを作り（事前学習）、その後、手元の小さなデータで目的の課題に合わせて微調整します（ファインチューニング）。ゼロから学習するより、少ないデータで高い性能に届きます。

LLM への橋渡し

この事前学習をさらに巨大なモデルとデータへ推し進めたのが、大規模言語モデル（LLM）です。文章生成・要約・翻訳・質問応答などを 1 つのモデルでこなします。仕組みの中心は、ここで見た Transformer と事前学習の延長線上にあります。BoW から始まった「テキストを数値にして扱う」という発想が、形を変えて今も生きているのです。

この Step のまとめ

BoW/TF-IDF の「語順・文脈を捨てる」限界を、RNN、そして Transformer と BERT が乗り越えました。事前学習＋転移学習という枠組みが、現在の LLM へとつながっています。より深い内容は、機械学習・深層学習・大規模言語モデル（LLM）のモジュールで扱います。

まとめWrap-up

学びの振り返りと、さらに学ぶために

このモジュールでは、テキストを扱う基本の道具を、パイプラインに沿って順に手に入れました。

  • 前処理：テキストをそろえ、トークンに区切る（日本語は形態素解析）。
  • 特徴量化：BoW と TF-IDF で、文書を数値ベクトルにする。
  • 分散表現：分布仮説にもとづき、語の意味を密なベクトルで表す。近さはコサイン類似度で測る。
  • テキスト分類：TF-IDF ＋ 分類器で実課題を解き、適合率・再現率・F値で評価する。
  • これから：Transformer と事前学習が、現代の LLM へつながる。

次に進むなら、下の道具と資料が役に立ちます。

公開データセット

  • 20 Newsgroups：英語のニュースグループ投稿 約2万件を20カテゴリに分類。scikit-learn から取得可能。
  • livedoor ニュースコーパス：日本語のニュース記事コーパス（RONDHUIT が公開）。日本語分類の定番。

ライブラリ

  • janome / MeCab：日本語の形態素解析。
  • scikit-learn：特徴量化・分類・評価の定番。
  • gensim：word2vec など分散表現。
  • spaCy：多言語の実務向け NLP。
  • Hugging Face Transformers：BERT・LLM などの事前学習モデル。

参考書

  • Daniel Jurafsky, James H. Martin『Speech and Language Processing』
  • 高村大也『言語処理のための機械学習入門』コロナ社
  • 岡崎直観 ほか『自然言語処理の基礎』オーム社

次のモジュールへ

おつかれさまでした

ここで学んだ「整える → 数値にする → モデルにかける」という流れは、テキストに限らずデータを扱う多くの場面で共通の考え方です。手元のサンプルを書き換えて、3 つのデモをもう一度動かしてみてください。値がどう変わるかを確かめると、理解がぐっと深まります。

発展トピックBeyond this module

このコースでは扱わない、関係する発展トピック

このモジュールでは、テキストを数値にしてモデルにかける「基礎の流れ」を扱いました。いっぽうで近年の自然言語処理は、より大きなモデルと事前学習を軸に急速に広がっています。ここでは、このコースでは踏み込まないものの、知っておくと視野が広がる発展的なトピックを、特に近年の主流を中心に紹介します。深掘りは各自の興味に合わせてどうぞ。大規模言語モデル（LLM）まわりは、大規模言語モデル（LLM）のモジュールで改めて扱います。

モダンなトークン化と表現

  • サブワード分割：単語より細かい単位で区切る方式（BPE・WordPiece・SentencePiece）。未知語や表記ゆれに強く、現代モデルの標準。
  • 文脈埋め込み：語の意味を文脈ごとに変えるベクトル（ELMo・BERT）。静的な word2vec の次の世代。

Transformer と大規模言語モデル

  • 自己注意機構と Transformer：文中の語どうしの関係を重みづけて捉える、現代 NLP の中核アーキテクチャ。
  • 大規模言語モデル（LLM）：GPT 系、指示チューニング、少数事例からの学習（few-shot・in-context learning）。大規模言語モデル（LLM）のモジュールで扱います。
  • 検索拡張生成（RAG）：外部の文書を検索し、その内容を根拠として LLM に答えさせる仕組み。

意味検索と応用タスク

  • 文埋め込みと意味検索：文をベクトル化して意味の近い文書を探す（Sentence-BERT・ベクトルデータベース・近似最近傍探索）。
  • 系列ラベリング：単語ごとにラベルを付けるタスク（固有表現抽出・品詞タグ付け。CRF や BiLSTM が定番）。
  • トピックモデル：教師なしで文書集合から話題を見つける（LDA など）。

生成タスクと評価・広がり

  • 生成タスクと評価：機械翻訳・要約・対話などの生成では、分類とは別の指標を使う（BLEU・ROUGE・パープレキシティ）。
  • 多言語・マルチモーダル：言語をまたぐモデルや、画像と言語を結ぶモデル（CLIP など）といった最新の広がり。