学習
AIと機械学習

ニューラルネットワークにおける正則化を理解する

Jul 22, 20243 分で読めます

正則化は、機械学習モデルが学習過程でオーバーフィットするのを防ぐ。正則化の概念と主な正則化テクニックについて説明する。

シリーズ全体を読む

モデルの過剰適合と正則化

実世界のアプリケーションで役に立つためには、機械学習モデルは、学習データを超えてその予測を一般化できなければならない。つまり、今まで見たことのない新しいデータを正確に予測する必要がある。

しかし、機械学習モデルが効果的に予測を汎化するのを妨げる要因はいくつかある。最も一般的な原因の1つは、モデルのオーバーフィッティングである。オーバーフィッティングは、モデルが学習データのパターンに適合させようとしすぎて、未知のデータに対するパフォーマンスが低下する場合に発生する。

例えるなら、基礎となる概念を理解する代わりに、教科書や模擬試験を一字一句暗記している学生を考えてみよう。このような生徒は、見慣れた問題が出題されれば完璧に答えを暗唱できるため、学習教材によく似たテストでは抜群の成績を収めるかもしれない。しかし、新しい問題に直面したり、異なる文脈で知識を応用するよう求められると、かなり苦戦します。同じことが、モデルが学習データをオーバーフィットさせたときにも起こります。

正則化とは、機械学習モデルの学習過程におけるオーバーフィットを防ぐために考案されたテクニックである。この記事では、様々な正則化テクニックについて説明する。しかしその前に、まずバイアスと分散の概念を理解する必要がある。

バイアス・分散とオーバーフィッティングの関係

バイアスと分散は、機械学習モデルの学習における2つの重要な概念である。この2つは、学習過程におけるモデルの振る舞いの異なる側面を測定する：

バイアスは、モデルの予測値の平均と学習データの実際の値との差を測定する。モデルが高いバイアスを持つ場合、それは通常、学習データのパターンを捉えるには単純すぎるためです。
分散(Variance):** 異なるトレーニングデータセットを使用した場合に、モデルの予測値がどの程度変化するかを測定します。分散が高いということは、モデルがトレーニングセットの小さな変動に対して過敏であることを示しており、オーバーフィッティングにつながる可能性があります。

バイアスと分散の概念は、アンダーフィットとオーバーフィッティングの問題と密接に関連しています。

アンダーフィッティングは、モデルがデータのパターンを捉えることができない場合に起こります。言い換えれば、バイアスが大きく分散が小さいため、トレーニングデータとテストデータのパフォーマンスが低下します。アンダーフィッティングの解決策は、ニューラルネットワークアーキテクチャにレイヤーを追加してモデルの複雑性を高めることである。

図1-アンダーフィット vs グッドフィット vs オーバーフィット](https://assets.zilliz.com/Figure_1_Underfitting_vs_Good_fit_vs_Overfitting_f5a38c7828.png)

図1：アンダーフィット vs グッドフィット vs オーバーフィット。画像ソース。

一方、オーバーフィッティングは、モデルが訓練データのパターンに従おうとしすぎて、未知のデータの汎化がうまくいかない場合に起こります。つまり、バイアスが低く、分散が大きいのです。オーバーフィッティングを避けるためには、正則化のテクニックを適用する必要があります。

上記のバイアスと分散の概念から、理想的な状況は、分散とバイアスの値が十分に低いモデルを持つことです。しかし、ノイズの多いデータ、不十分なデータ、計算リソースなど様々な理由により、これはしばしば実現不可能です。したがって、目標はむしろ、モデルが訓練データとテストデータの両方で妥当な精度を発揮する、バイアスと分散のトレードオフのスイートスポットを見つけることです。

図2- バイアスと分散のトレードオフ](https://assets.zilliz.com/Figure_2_Bias_and_variance_trade_off_1bf38cbdd3.png)

図2：バイアスと分散のトレードオフ。画像ソース.

次のセクションで説明する正則化のテクニックは、モデルの分散を減らし、未知のデータでもうまく汎化できるようにすることを目的としています。

正則化テクニックの種類

正則化テクニックには、未経験データに対するモデルの汎化を改善するために利用できるものがいくつかあります。このセクションでは、L1正則化、L2正則化、Elastic Net、Early Stopping、Dropout、Batch Normalization、Data Augmentationなど、最もよく使われる正則化について説明します。L1正則化とL2正則化から始めよう。

L1正則化とL2正則化

L1正則化とL2正則化の概念を理解するために、学習過程でニューラルネットワークの重みを最適化する方法を復習しましょう。

各エポック（学習ステップ）において、タスクの目的に応じてモデルの損失関数を計算する必要がある。分類問題であれば、通常はバイナリまたはカテゴリのクロスエントロピーを使用し、回帰問題であれば、通常は平均二乗誤差を使用する。

図3-モデルの損失関数を計算する](https://assets.zilliz.com/Figure_3_Compute_the_loss_function_of_our_model_b2ccd89402.png)

図3：モデルの損失関数を計算する_図3-モデルの損失関数を計算する

次に、ニューラルネットワークは勾配降下アルゴリズムによる最適化プロセスを経ます。このステップでは、まず重みに関する損失関数の偏導関数を計算します。次に、導出結果とあらかじめ定義した学習率(λ)を掛け合わせたものを各重みから差し引くことで、モデルの重みを更新します。

図4- 勾配降下アルゴリズムの実行](https://assets.zilliz.com/Figure_4_Perform_gradient_descent_algorithm_f9f9d75bb4.png)

図4: 勾配降下アルゴリズムの実行_(_Figure 4: Perform gradient descent algorithm)

L1正則化もL2正則化も、損失関数式の中にペナルティ項を追加することで機能する。この項は大きな重みにペナルティを課し、重みをゼロに近づける。ご想像の通り、もしニューラルネットワークがあり、重みのほとんどがゼロに近いか正確にゼロであれば、よりシンプルなニューラルネットワークが完成します。

オーバーフィッティングの一般的な原因の1つは、学習データからすると複雑すぎるモデルである。重みをゼロに近づけることでモデルの複雑さを減らし、分散を減らすことができます。

L1正則化とL2正則化の唯一の違いは、損失関数の計算の中で追加されるペナルティ項です。まずL1正則化から始めましょう。

L1正則化

L1正則化では、損失関数の中にペナルティ項が追加され、モデルのすべての重みの合計とペナルティパラメータαの乗算になります。このペナルティパラメータは事前に定義する必要があり、正則化効果の大きさを決定します。

この追加ペナルティ項の偏導関数をモデルの重みに関して計算すると、以下の式が得られます：

図5- L1正則化における追加ペナルティ項の偏導関数の計算](https://assets.zilliz.com/Figure_5_Compute_the_partial_derivative_of_the_additional_penalty_term_in_L1_regularization_3127dd02ca.png)

図5：L1正則化における追加ペナルティ項の偏導関数を計算する(Figure 5: Compute the partial derivative of the additional penalty term in L1 regularization)

ご覧のように、重みが正であれば、ペナルティ・パラメータは重みを減算し、正を小さくしてゼロに近づけます。一方、重みが負の場合、ペナルティ・パラメータは重みを加え、負の値を小さくし、ゼロに近づけます。

この正則化手法により、モデル内のほとんどの重みがゼロに近づくため、学習過程でデータを推定するモデルがより複雑でなくなる。

L2 正則化

L2正則化のペナルティ項はL1とは少し異なります。L2正則化は、以下の式に示されるように、ペナルティ項に2乗ノルムまたはL2ノルムを実装しています：

図6- L2正則化のペナルティ項の偏導関数の計算](https://assets.zilliz.com/Figure_6_Compute_the_partial_derivative_of_the_additional_penalty_term_in_L2_regularization_eaea2188ad.png)

図6: L2正則化における追加ペナルティ項の偏導関数の計算_」()

重みに関する損失関数の偏導関数を計算すると、以下の式になる：

図7：損失関数の偏導関数を計算する](https://assets.zilliz.com/Figure_7_Calculate_the_partial_derivative_of_the_loss_function_b827f8a8f0.png)

図7：損失関数の偏導関数を計算する_図7-損失関数の偏導関数を計算する

おわかりのように、L2正則化では、重みペナルティは重みそのものの符号だけでなく、その大きさによっても決まる。その結果、L1正則化のように積極的に重みがゼロになることはありません。ただし、この正則化の後でも重みがゼロになる可能性はある。

弾性ネット

Elastic Netは、L1正則化とL2正則化を組み合わせて、損失関数の内部に追加される1つの重み付きペナルティ項にする手法です。つまり、L1とL2のペナルティパラメータの合計が1になる。

図8- Elastic Net](https://assets.zilliz.com/Figure_8_Elastic_Net_c741c89cc4.png)

図8：エラスティック・ネット

Elastic Netの主な目的は、L1正則化とL2正則化の両方の長所を得られるようにすることです。L1のように特定の特徴を非常に効果的に削減しますが、積極的に重みをゼロに近づけるほどではありません。一方、L2正則化のように、あまり重要でない特徴の係数を効果的に削減することもできます。

それでは、L1、L2、Elastic Netを一度に実装してみよう。Elastic NetはL1とL2の組み合わせなので、主にElastic Netの実装に焦点を当てますが、コードの一部をコメントアウトするだけで、L1とL2のどちらにも切り替えることができます。この記事のコードはすべてこのノートブックにあります。

まず、ライブラリをインポートし、3層のニューラルネットワークを初期化しましょう。

インポート os
インポートトーチ
from torch import nn
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
from torchvision import transforms
from tqdm import tqdm
from torch.utils.data import データセット

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

class MLP(nn.Module)：

     def __init__(self)：
         super().__init__()
         self.layers = nn.Sequential(
         nn.Flatten()、
         nn.Linear(28 * 28 * 1, 64)、
         nn.ReLU()、
         nn.Linear(64, 32)、
         nn.ReLU()、
         nn.Linear(32, 10)
         )

      def forward(self, x)：
           return self.layers(x)

      def compute_l1_loss(self, w)：
           return torch.abs(w).sum()

      def compute_l2_loss(self, w)：
           return torch.square(w).sum()

上記のモデル・アーキテクチャでは、L1正則化とL2正則化の両方のペナルティ項の計算を実装した。次に、Elastic Netの学習手順を定義し、MNIST手書き数字データセットでモデルを学習してみましょう。L1またはL2のみに切り替えたい場合は、ノートブックまたは以下の実装でコードの特定の部分をコメントアウトしてください：

def train(model, dataset, epochs, lr)：

  train_loader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
  loss_function = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(model.parameters(), lr=lr)

  for epoch in range(epochs)：
    total_loss = 0

    for data in tqdm(train_loader)：

        inputs, targets = data
        optimizer.zero_grad()
        outputs = model(inputs.to(device))
        loss = loss_function(outputs, targets.to(device))
        
        l1_weight = 0.4 #L1正則化の場合は1.0
        l2_weight = 0.6 #L2正則化の場合は1.0

        # L1 と L2 の損失成分を計算する。
        # 使用する正則化に応じて、L1またはL2をコメントアウトする。
        # L1 を使用する場合は l2 をコメントアウトする。
        parameters = [] (パラメータ)
        for parameter in model.parameters()：
            parameters.append(parameter.view(-1))
        l1 = l1_weight * model.compute_l1_loss(torch.cat(parameters))
        l2 = l2_weight * model.compute_l2_loss(torch.cat(parameters))

        # ロスコンポーネントを追加
        # 使用する正則化によって L1 または L2 をコメントアウトする。
        # L1 を使う場合は l2 をコメントアウトし、その逆も同様。
        loss += l1
        loss += l2
        total_loss += loss.item()

        loss.backward()
        オプティマイザー.ステップ()

    print(f'Epochs: {epoch + 1}.| 損失: {total_loss / len(dataset)：.3f}')

# MNIST データでモデルを訓練する
エポック = 5
LEARNING_RATE = 1e-4
dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
model = MLP().to(device)
train(model, dataset, EPOCHS, LEARNING_RATE)

早期停止

オーバーフィッティングは、モデルが学習データのパターンに従おうとしすぎるために起こる。したがって、モデルのオーバーフィッティングを発見し緩和する1つの方法は、トレーニング中の検証データでのパフォーマンスを観察することです。

理想的なシナリオでは、トレーニングデータと検証データの両方におけるモデルの誤差が、トレーニングの反復ごとに減少することを望みます。しかし、訓練データの誤差が減少し続ける一方で、検証データの誤差が増加し始めたら、それはモデルが訓練データに過剰適合している明らかな兆候です。

この問題を解決する1つの方法は、ニューラルネットワークモデルを十分な反復回数だけ訓練することです。しかし、与えられたデータセットに最適なトレーニング反復回数を事前に知ることはほとんど不可能です。例えば、学習反復回数をハイパーパラメータとして設定し、様々な反復値でモデルを学習させ、検証データで最も良い結果を得たモデルを選ぶことができる。しかし、この方法は高価な計算資源を必要とするため非効率的であり、特にモデルが大きく複雑であり、データセットも膨大な場合はなおさらである。

図9- 早期停止戦略](https://assets.zilliz.com/Figure_9_Early_stopping_strategy_8bfda98553.png)

図9: 早期停止戦略._ ソース..

早期停止は上記の問題を解決する正則化手法である。コンセプトは単純で、各反復における検証損失を監視する。検証損失が増加し始めたら、直ちに学習プロセスを停止する**。

実際には、ある反復における検証損失は、訓練過程におけるランダム性のために、前の反復よりも高くなることがよくある。そのため、通常、早期停止を使用する際には許容値も設定します。例えば、許容値を 2 に設定すると、2 回の反復で検証誤差が改善されない場合、このメソッドは学習プロセスを停止します。

前のセクションで実装したのと同じモデルとデータで早期停止を実装してみましょう。検証誤差の許容誤差を2に設定し、検証誤差が2エポック連続で改善されない場合、学習を停止することを意味する。

実際には、学習過程におけるランダム性により、ある反復における検証誤差が前の反復よりも大きくなることはよくあることである。そのため、Early Stoppingを使用する際には、通常許容値を設定します。例えば、許容値を2に設定すると、検証誤差が2回の反復で改善されない場合、このメソッドは学習プロセスを停止します。

前のセクションで実装したのと同じモデルとデータで早期停止を実装してみましょう。検証誤差の許容誤差を2に設定し、検証誤差が2エポック連続で改善されなければ学習を停止するようにします。

def train_with_early_stopping(model, train_dataset, val_dataset, epochs, lr, patience)：

  train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=10, shuffle=True, num_workers=1)
  val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=10, shuffle=True, num_workers=1)

  loss_function = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(model.parameters(), lr=lr)

  best_loss = 100000
  best_epoch = 0
  for epoch in range(epochs)：

        for data in tqdm(train_loader)：
        
              inputs, targets = data
              optimizer.zero_grad()
        
              outputs = model(inputs.to(device))
              loss = loss_function(outputs, targets.to(デバイス))
        
              loss.backward()
              optimizer.step()
    
        torch.no_grad()：
              total_loss_val = 0
              for val_data in tqdm(val_loader)：
        
                  入力、ターゲット = val_data
                  出力 = model(inputs.to(device))
        
                  loss = loss_function(outputs, targets.to(デバイス))
                  total_loss_val += loss.item()
    
        avg_loss = total_loss_val / len(val_dataset)
        print(f'Epochs: {epoch + 1} | Val Loss: {avg_loss: .10f}')
    
        if avg_loss < best_loss：
            best_loss = avg_loss
            best_epoch = epoch
            torch.save(model.state_dict(), "best_model.pt")
    
        elif epoch - best_epoch > patience：
            print("Early stopped training at epoch %d" % epoch)
            break # 訓練ループを終了する

# モデルをトレーニングする
PATIENCE = 2
エポック = 1000
LEARNING_RATE = 1e-4
データセット = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
train_set, val_set = torch.utils.data.random_split(dataset, [50000, 10000])
model = MLP().to(device)
train_with_early_stopping(model, train_set, val_set, EPOCHS, LEARNING_RATE, PATIENCE)

ドロップアウト

要するに、Dropout はニューラルネットワーク・アーキテクチャで一般的に使用される正則化テクニックで、学習プロセス中にレイヤー内の1つまたは複数のニューロンをランダムにドロップする。つまり、学習中、ドロップされたニューロンの重みはバックプロパゲーション・プロセス中に更新されない。

ドロップアウトを実装するには、まず各レイヤーのドロップアウト確率を定義する必要がある。例として、あるレイヤーで50%のドロップアウト確率を設定するとしよう。これは、トレーニング中、そのレイヤーの各ニューロンが50％の確率でドロップアウトされることを意味する。このプロセスはトレーニング・バッチごとに独立して発生するため、同じ反復で異なるデータ・サブセットは、各レイヤーでランダムにニューロンが脱落するため、モデル・アーキテクチャが異なる可能性が高い。

図10-脱落前後のニューラルネットワークのアーキテクチャ](https://assets.zilliz.com/Figure_9_Architecture_of_a_neural_network_before_and_after_dropout_ee8c9e48d6.png)

図10：ドロップアウト前後のニューラルネットワークのアーキテクチャ。出典.

この正則化手法はかなり破壊的ですが、未知のデータに対するモデルの汎化を改善するのに有効であることが証明されています。前のセクションで述べたように、オーバーフィットの原因の1つはモデルが複雑すぎることです。各層のニューロンをランダムに削除すれば、より単純なモデルになることは想像できるだろう。

また、トレーニング中にニューロンをランダムに落とすと、トレーニングデータを正しく予測できるように、他のニューロンが介入して必要なウェイト調整を行う必要がある。その結果、モデル全体が特定の層のニューロンの特定の重みに影響されにくくなり、より優れた汎化能力を持つモデルになる。

注意すべき重要な点は、推論中にどの層のニューロンも落とすことはできないということです。したがって、PyTorchでは、学習中の特定の層のactivation出力を1/1-pでスケールダウンしています。我々は推論中に同一性関数を計算するだけでよい。

以下のコードでは、50%の確率でニューロンが脱落するDropout層を持つモデルを作成する。次に、前のセクションで示したように、普通に学習させる。

class MLP_Dropout(nn.Module)：

  def __init__(self)：
       super().__init__()
       self.layers = nn.Sequential()
         nn.Flatten()、
         nn.Linear(28 * 28 * 1, 64)、
         nn.Dropout(p=0.5)、
         nn.ReLU()、
         nn.Linear(64, 32)、
         nn.Dropout(p=0.5)、
         nn.ReLU()、
         nn.Linear(32, 10)
       )

  def forward(self, x)：
       return self.layers(x)

model_dropout = MLP_Dropout().to(device)
EPOCHS = 5
train_with_early_stopping(model_dropout, train_set, val_set, EPOCHS, LEARNING_RATE, PATIENCE)

バッチ正規化

バッチ正規化とは、レイヤへの入力を訓練バッチごとの平均と標準偏差で正規化する技法である。

では、なぜバッチ正規化が正則化技法として機能するのかという疑問が生じる。

すでにご存知かもしれませんが、ニューラルネットワークは、学習率、バッチサイズ、重みの初期化、最適化アルゴリズムなど、学習アルゴリズムの設定に非常に敏感です。学習プロセス中、各層の重みは、前の層からの出力が与えられると、入力データを対応するグランドトゥルースに正確にマッピングするように更新される。

問題は、ほとんどの学習データが異なる分布を持っており、学習アルゴリズムが動く目標を追いかける原因となることだ。1つの層の重みは、前の層からの活性化出力が与えられた場合に、入力のラベルへのマッピングを最適化するために大幅に更新することができる。その結果、アルゴリズムは学習により多くの反復を必要とする。バッチ正規化は、入力を平均と標準偏差に正規化することで、学習プロセスを安定させ、スピードアップするのに役立つ。

学習プロセスの安定化とスピードアップに加えて、入力の正規化はランダム性も導入する。この方法は通常バッチごとに実行されるため、入力はバッチごとに独自の平均と標準偏差を持つ。したがって、ネットワークはバッチごとに異なる入力を見ることになり、学習データを記憶することを防ぎ、オーバーフィッティングを回避することができる。

以下はPyTorchでバッチ正規化を実装する方法の例です。バッチ正規化でモデルを実装したら、先ほどと同じアプローチですぐに訓練できます。

class MLP_BN(nn.Module)：

  def __init__(self)：
       super().__init__()
       self.layers = nn.Sequential(
         nn.Flatten()、
         nn.Linear(28 * 28 * 1, 64)、
         nn.BatchNorm1d(64)、
         nn.ReLU()、
         nn.Linear(64, 32)、
         nn.BatchNorm1d(32)、
         nn.ReLU()、
         nn.Linear(32, 10)
       )

  def forward(self, x)：
       return self.layers(x)

model_bn = MLP_BN().to(device)
EPOCHS = 5
train_with_early_stopping(model_bn, train_set, val_set, EPOCHS, LEARNING_RATE, PATIENCE)

データの拡張

データ増強がオーバーフィッティングの防止に役立つ理由は明白である。前のセクションで述べたように、限られた訓練データで複雑すぎるモデルを訓練すると、オーバーフィッティングが起こる可能性がある。訓練データを何とか増やすことができれば、モデルの汎化誤差は減少します。

データを増やすために実行できる一般的なデータ増強法がいくつかある。画像を扱う場合、画像の回転、反転、拡大縮小、切り抜き、シフトなどを行うことができる。一方、テキストデータを扱っている場合は、単語を類義語に置き換えたり、生成AIを使って意味的に類似したテキストを生成したりすることができる。

以下は、MNISTデータによる画像データ補強のいくつかの例です：

図11- MNIST手書き数字データセットの画像オーグメンテーションの例](https://assets.zilliz.com/Figure_10_Several_examples_of_image_augmentation_of_MNIST_handwritten_digits_dataset_8751176f5b.png)

図11: MNIST手書き数字データセットの画像補強のいくつかの例。

PyTorchではtorchvisionライブラリのtransforms.Compose()メソッドを使って画像データの補強を行うことができます。このメソッドの中で、実装したい画像データ補強の方法を指定することができます。

以下のコードでは、切り抜き、反転、回転の3種類の画像補強を実装します。他の画像補強方法を知りたい場合は、 this resource from PyTorch を参照してください。

transform_train = transforms.Compose([)
              transforms.ToTensor()、
              transforms.RandomCrop(28, padding=4)、
              transforms.RandomVerticalFlip()、
              transforms.RandomRotation(50)])

model = MLP().to(device)
EPOCHS = 5
LEARNING_RATE = 1e-4
dataset = MNIST(os.getcwd(), download=True, transform=transform_train)
train(model, dataset, EPOCHS, LEARNING_RATE)

結論

オーバーフィッティングとは、機械学習モデルが学習データのパターンに従おうとしすぎて、未知のデータに対するパフォーマンスが低下することである。正則化は、オーバーフィッティングを防ぐためにニューラルネットワークの学習過程で一般的に適用されるテクニックである。

実際によく適用される正則化には、L1正則化、L2正則化、Elastic Net、Early Stopping、Dropout、Batch Normalization、Data Augmentationなどがあります。これらの手法は機械学習モデルを正則化するためのアプローチは異なるが、その目的は同じである。こうすることで、モデルはバイアスと分散のトレードオフにおけるスイートスポットを達成することができる。

この記事で実装したコードはすべてこのノートブックにあります。

その他のリソース

クロスエントロピー損失：機械学習におけるその役割を解明する ](https://zilliz.com/learn/Cross-Entropy-Loss-Unraveling-its-Role-in-Machine-Learning)
レイヤー正規化 vs. バッチ正規化 - ニューラルネットワークの効率性を解き明かす](https://zilliz.com/learn/layer-vs-batch-normalization-unlocking-efficiency-in-neural-networks)
局所感度ハッシング(L.S.H.): 総合ガイド](https://zilliz.com/learn/Local-Sensitivity-Hashing-A-Comprehensive-Guide)
カラーヒストグラムの謎解き：画像処理と解析の手引き](https://zilliz.com/learn/demystifying-color-histograms)
BM25を使いこなす：Milvusにおけるアルゴリズムとその応用への深堀り ](https://zilliz.com/learn/mastering-bm25-a-deep-dive-into-the-algorithm-and-application-in-milvus)
TF-IDF - NLPにおける項頻度-逆文書頻度の理解 ](https://zilliz.com/learn/tf-idf-understanding-term-frequency-inverse-document-frequency-in-nlp)
検索拡張生成(RAG)とは](https://zilliz.com/learn/Retrieval-Augmented-Generation)
ベクトルデータベースとは](https://zilliz.com/learn/what-is-vector-database)

article.updateAt