１．畳み込みとは
　畳み込み（たたみこみ、英: Convolution）とは、２つの関数を合わせて新しい関数を作る数学的な操作です。主に信号処理や画像処理、機械学習（特に畳み込みニューラルネットワーク、CNN）で広く使用されます。
　畳み込みの基本的な概念を理解するために、１次元の畳み込みについて説明します。２つの関数fとgの連続的な畳み込み（畳み込み積分）は、以下のように定義されます。

２．連続的な畳み込み（畳み込み積分）
　畳み込みは２つの関数を操作して新しい関数を生成する数学的な操作です。

畳み込みを視覚的に理解するために、例として、次の関数の畳み込みを考えます。

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import quad

# Parameters
t = np.linspace(-10, 10, 800)  # Time range
tau_shift = 5  # Shift for the g(τ - t) plot
a = 1  # Parameter for the exponential function

# Define the functions
def f(t, a):
    return np.exp(-a * t) * (t >= 0)

def g(t):
    return np.heaviside(t, 1)

# Numerical convolution using scipy's quad
def numerical_convolution(t, a):
    result = np.zeros_like(t)
    for i in range(len(t)):
        if t[i] >= 0:
            result[i], _ = quad(lambda tau: f(tau, a) * g(t[i] - tau), 0, t[i])
    return result

# Compute the functions
f_tau = f(t, a)
g_tau = g(t)
y_t = numerical_convolution(t, a)

# Compute g(τ - t)
g_tau_t = g(tau_shift - t)

# Plot the functions
plt.figure(figsize=(10, 10))

# Plot f(τ)
plt.subplot(4, 1, 1)
plt.plot(t, f_tau, label=r'$f(\tau) = e^{-a\tau}$')
plt.xlabel('Time $\tau$')
plt.ylabel(r'$f(\tau)$')
plt.title(r'Function $f(\tau)$')
plt.legend()
plt.grid(True)

# Plot g(τ)
plt.subplot(4, 1, 2)
plt.plot(t, g_tau, label=r'$g(\tau) = u(\tau)$')
plt.xlabel('Time $\tau$')
plt.ylabel(r'$g(\tau)$')
plt.title(r'Step Function $g(\tau)$')
plt.legend()
plt.grid(True)

# Plot g(τ - t)
plt.subplot(4, 1, 3)
plt.plot(t, g_tau_t, label=r'$g(\tau - t)$ with $\tau = ' + str(tau_shift) + r'$')
plt.xlabel('Time $t$')
plt.ylabel(r'$g(\tau - t)$')
plt.title(r'Reversed and Shifted Step Function $g(\tau - t)$ with $\tau = ' + str(tau_shift) + r'$')
plt.legend()
plt.grid(True)

# Plot y(t) (Convolution result)
plt.subplot(4, 1, 4)
plt.plot(t, y_t, label=r'$y(t)$ (Numerical Convolution)', linestyle='--')
plt.xlabel('Time $t$')
plt.ylabel('$y(t)$')
plt.title(r'Convolution of $f(t)$ and Step Function $g(t)$')
plt.legend()
plt.grid(True)

# Adjust layout
plt.tight_layout()
plt.show()

３．離散的な畳み込み（畳み込み和）

y=[0. 1. 2.5 4. 5.5 7. 2.5]

# -*- coding: utf-8 -*-
import numpy as np

f = np.array([1, 2, 3, 4, 5])
g = np.array([0, 1, 0.5])

# 畳み込みの計算
conv_result = np.convolve(f, g, mode='full')
print(conv_result)

１．概要
　単純パーセプトロンは、最も基本的な形式のニューラルネットワークで、１つのニューロンから構成されます。入力ベクトルと重みベクトルの内積にバイアスを加え、その結果を活性化関数（しきい値関数）によって出力します。線形分離可能な問題に対して適していますが、非線形問題には対応できません。
　すなわち、入力データが線形平面で２つのクラスに分けられる場合にのみ分類が可能となり、非線形な問題や複雑なクラスの境界線を持つ問題には対応できません。多クラス分類問題に対応するには、複数の単純パーセプトロンを組み合わせたり、他の手法（例えば多クラスロジスティック回帰や多層パーセプトロン）を使用する必要があります。
　雑なモデルや手法を検討する必要があります。

２．パーセプトロンの構造と動作
　パーセプトロンは、ニューラルネットワークの最も基本的な単位であり、単層の線形分類器です。1950年代から1960年代にかけて、フランク・ローゼンブラットによって考案されました。パーセプトロンは、与えられた入力データを２つのクラスに分類するために使用されます。
（１）パーセプトロンの構造と動作
　パーセプトロンの基本的な構造は次の通りです。
　①入力層
　　特徴量ベクトルx=[x1,x2,・・・,xn]を入力します。各特徴量は重み付けされます。
　②重みとバイアス
　　各入力特徴量には対応する重み w=[w1,w2,・・・,wn]があります。
　　バイアスb は、入力に対する追加の定数項です。
　③線形結合
　　入力特徴量と重みのドット積にバイアスを加えて、線形出力zを計算します。
　　z = w・x+b　”・”はベクトル積
　④活性化関数
　　線形出力z に対して活性化関数を適用し、最終的な出力yを得ます。
　　パーセプトロンでは、ステップ関数（Heavisideステップ関数）が一般的に使用されます。

（２）パーセプトロンの学習
　パーセプトロンは、誤差修正アルゴリズム（パーセプトロン学習アルゴリズム）を使用して重みとバイアスを更新します。学習の手順は以下の通りです。
　①初期化:
　　重みベクトルw とバイアスb を小さなランダムな値で初期化します。
　②各トレーニングデータポイントの処理:
　　各トレーニングデータ（x,y_true）に対して、以下を行います
　・線形出力zを計算します
　　z = w・x+b　”・”はベクトル積
　・活性化関数を適用して予測ypredを得ます
　・誤差を計算します
　　error=ytrue－ypred
　・重みとバイアスを更新します

③エポック
　上記の処理を全てのトレーニングデータに対して行い、これを複数回（エポック）繰り返します。

３．単純パーセプトロンのサンプル

import numpy as np

class SimplePerceptron:
    def __init__(self, num_features, learning_rate=0.1, epochs=4):
        self.num_features = num_features
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = np.zeros(num_features)
        self.bias = 0.0
    
    def predict(self, x): #x:トレーニングデータ、又はテストデータ（特徴量ベクトル）
        linear_output = np.dot(self.weights, x) + self.bias #線形結合
        prediction = 1 if linear_output > 0 else 0 #活性化関数（ステップ関数）
        return prediction #予測結果を返す
    
    def train(self, X_train, y_train):
        for epoch in range(self.epochs):
            for x, y_true in zip(X_train, y_train):
                y_pred = self.predict(x)#予測結果
                error = y_true - y_pred #誤差の計算
                self.weights += self.learning_rate * error * x #重み更新（w←w+η（学習率）⋅error⋅x）
                self.bias += self.learning_rate * error #バイアス更新（b←b+η（学習率）⋅error）
                print("epoch:",epoch,"self.weights:",self.weights,"self.bias:",self.bias)
 
    def evaluate(self, X_test, y_test):
        print("*** evaluate ***")
        correct = 0
        for x, y_true in zip(X_test, y_test):
            y_pred = self.predict(x)
            if y_pred == y_true:
                correct += 1
        accuracy = correct / len(y_test)
        return accuracy

# Example usage:
if __name__ == "__main__":
    # Example dataset
    X_train = np.array([[0.9, 0.8], [0.7, 0], [0.3, 0.5], [0, 0]])
    y_train = np.array([1, 1, 0, 0])  # Binary labels (1 or 0)
    
    # Create and train the Simple Perceptron
    perceptron = SimplePerceptron(num_features=2)
    perceptron.train(X_train, y_train)
    
    # Example evaluation
    X_test = np.array([[0.6, 0.6], [0.7, 0.3], [0.2, 0.4], [0.6, 0.2]])
    y_test = np.array([1, 1, 0, 0])
    accuracy = perceptron.evaluate(X_test, y_test)
    
    print(f"Accuracy: {accuracy}")

#トレーニングデータ
#X_train = np.array([[0.9, 0.8], [0.7, 0], [0.3, #0.5], [0, 0]])
#y_train = np.array([1, 1, 0, 0])

#テストデータ    
#X_test = np.array([[0.6, 0.6], [0.7, 0.3], [0.2, #0.4], [0.6, 0.2]])
#y_test = np.array([1, 1, 0, 0])

#実行結果
#epoch: 1 self.weights: [ 0.03 -0.02] self.bias: -0.1
#epoch: 2 self.weights: [0.09 0.01] self.bias: -0.1
#epoch: 3 self.weights: [0.15 0.04] self.bias: -0.1
#Accuracy: 1.0

　トレーニングデータ、テストデータ、及びepoch毎の実行結果weights、biasの線形出力をグラフに表示します。
　ここで、トレーニングデータのラベル０：青×、ラベル１：青○、テストデータのラベル０：赤×、ラベル１：赤○とします。　

import matplotlib.pyplot as plt
import numpy as np

# データ
data_circle = [[0.9, 0.8], [0.7, 0]]
data_cross = [[0.3, 0.5], [0, 0]]
test_circle = [[0.6, 0.6], [0.7, 0.3]]
test_cross = [[0.2, 0.4], [0.6, 0.2]]

# データをX軸とY軸に分割
x_circle, y_circle = zip(*data_circle)
x_cross, y_cross = zip(*data_cross)
xt_circle, yt_circle = zip(*test_circle)
xt_cross, yt_cross = zip(*test_cross)

# プロット
plt.figure(figsize=(8, 6))
plt.scatter(x_circle, y_circle, marker='o', color='b', label='label:1')
plt.scatter(x_cross, y_cross, marker='x', color='b', label='label:0')
plt.scatter(xt_circle, yt_circle, marker='o', color='r', label='label:1')
plt.scatter(xt_cross, yt_cross, marker='x', color='r', label='label:0')

# 直線のプロット
x_line = np.linspace(-0.1, 1, 400)  # x範囲を設定
y_line1 = -0.15 * x_line / 0.04 + 0.1 / 0.04
y_line2 = -0.03 * x_line / (-0.02) + 0.1 / (-0.02)
y_line3 = -0.09 * x_line / 0.01 + 0.1 / 0.01
plt.plot(x_line, y_line1, color='g', label='epoch:3 y=-0.15*x/0.04+0.1/0.04')
plt.plot(x_line, y_line2, color='y', label='epoch:1 y=-0.03*x/(-0.02)+0.1/(-0.02)')
plt.plot(x_line, y_line3, color='m', label='epoch:2 y=-0.09*x/0.01+0.1/0.01')


plt.title('SimplePerceptron blue:train red:test')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.grid(True)
plt.show()

４．プログラムの解説
（１）SimplePerceptron クラスの初期化

def __init__(self, num_features, learning_rate=0.1, epochs=4):
        self.num_features = num_features
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = np.zeros(num_features)
        self.bias = 0.0

・特徴量の数 num_featuresを設定し、重みベクトルの初期化を行います。
　self.num_features: 2
　self.weights: [0. 0.]
・学習率 learning_rate、エポック数 epochs を設定します。

（２）predict メソッド（予測値を算出）

def predict(self, x): #x:トレーニングデータ、又はテストデータ（特徴量ベクトル）
        linear_output = np.dot(self.weights, x) + self.bias #線形結合
        prediction = 1 if linear_output > 0 else 0 #活性化関数（ステップ関数）
        return prediction #予測結果を返す

入力ベクトル（特徴量） x を用いて予測を行います。線形結合の結果を活性化関数として使い、閾値に基づいて予測を二値化します。
・linear_output = np.dot(self.weights, x) + self.bias
　重みと特徴量のベクトル積にバイアス値を加算（線形結合）　
・prediction = 1 if linear_output > 0 else 0
　三項演算子を使用しており、linear_output が 0 より大きい場合は 1 を、そうでない場合は 0 を prediction に代入します。

（３）train()メソッド（重み、バイアスの更新）

def train(self, X_train, y_train):
        for epoch in range(self.epochs):
            for x, y_true in zip(X_train, y_train):
                y_pred = self.predict(x)#予測結果
                error = y_true - y_pred #誤差の計算
                self.weights += self.learning_rate * error * x #重み更新（w←w+η（学習率）⋅error⋅x）
                self.bias += self.learning_rate * error #バイアス更新（b←b+η（学習率）⋅error）
                print("epoch:",epoch,"self.weights:",self.weights,"self.bias:",self.bias)

・与えられた訓練データ X_train（特徴量ベクトル） と y_train（ラベル値） を用いてパーセプトロンを学習します。各訓練データに対して予測を行い、誤差を計算し重みとバイアスを更新します。これをエポック数繰り返します。
・for x, y_true in zip(X_train, y_train):
X_train, y_train　リストの要素を取り出す

（４）evaluate()メソッド（評価）

def evaluate(self, X_test, y_test):
        print("*** evaluate ***")
        correct = 0
        for x, y_true in zip(X_test, y_test):
            y_pred = self.predict(x)
            if y_pred == y_true:
                correct += 1
        accuracy = correct / len(y_test)
        return accuracy

・train()メソッドで算出した、weights（重みベクトル）、bias（バイアス値）を使って、予測値を算出し、ラベルの値と一致するか否かの評価を行う。

（５）main

# Example usage:
if __name__ == "__main__":
    # Example dataset
    X_train = np.array([[0.9, 0.8], [0.7, 0], [0.3, 0.5], [0, 0]])
    y_train = np.array([1, 1, 0, 0])  # Binary labels (1 or 0)
    
    # Create and train the Simple Perceptron
    perceptron = SimplePerceptron(num_features=2)
    perceptron.train(X_train, y_train)
    
    # Example evaluation
    X_test = np.array([[0.6, 0.6], [0.7, 0.3], [0.2, 0.4], [0.6, 0.2]])
    y_test = np.array([1, 1, 0, 0])
    accuracy = perceptron.evaluate(X_test, y_test)
    
    print(f"Accuracy: {accuracy}")

・if name == “main“
　　スクリプトが直接実行されたときにのみ、実行するための条件文
　・np.array()でndarrayオブジェクトに変換する
　・SimplePerceptron(num_features=2)でインスタンスを生成
　・train()メソッドで重みベクトル、バイアス値の更新
　・evaluate()で評価する

以上

１．概要
トランスフォーマーの元となるアーキテクチャは、以下の論文で発表されました：
　Title: Attention Is All You Need
　Authors: Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez,
　Łukasz Kaiser, and Illia Polosukhin
　Published in: NeurIPS 2017 (Conference on Neural Information Processing Systems)
　ChatGPTなどの自然言語処理、画像生成などモデルとして使用されて、主な特徴を以下に示します。

（１）自己注意機構（Self-Attention Mechanism）
　自己注意機構は、入力シーケンス（文章など）の各要素（トークン）のシーケンス全体の他の要素に対する重要性を評価する方法です。これにより、文中の単語同士の関係を捉えることができるようになり、文章の生成において、次に続く単語の選択するときの重みづけ（文脈によって動的に変化する）ができるようになります。

（２）位置エンコーディング（Positional Encoding）
　トランスフォーマーはリカレント（再帰的）な構造を持たないため、入力シーケンスの順序情報を明示的にモデルに提供する必要があります。位置エンコーディングはこの問題を解決するために使用されます。

（３）エンコーダ・デコーダ構造（Encoder-Decoder Structure）
　トランスフォーマーモデルはエンコーダとデコーダの２つの主要部分から構成されています。エンコーダーは、入力された文章を固定長のベクトル（文脈ベクトル）に変換する役割をもちます。デコーダはエンコーダーが生成した文脈ベクトルを元に推論した結果（出力）を生成する役割をもちます。

（４）並列計算の効率性
　トランスフォーマーは並列計算に適しており、従来のRNN（Recurrent Neural Networks）やLSTM（Long Short-Term Memory）に比べてトレーニング速度が速いという利点があります。これは特に大規模なデータセットでの学習においてメリットとなります。

（５）スケーラビリティ
　トランスフォーマーは非常に大規模なモデルにスケールさせることができ、多くのパラメータを持つことで高い表現力を持っています。例えば、BERTやGPTなどの大規模なトランスフォーマーモデルは数億から数十億のパラメータを持ち、非常に高い性能を発揮します。

（６）多用途性
　トランスフォーマーは機械翻訳、テキスト生成、要約、質問応答、画像認識など、さまざまなタスクに適用可能です。これは、トランスフォーマーがシーケンスの関係性をうまく捉えることができるためです。

２．トランスフォーマーの構成
　以上の特徴をモデルの各部分について考察していきます。
　大まかにトランスフォーマーはエンコーダーとデコーダに分けられます。エンコーダで入力データを埋め込みベクトル空間に変換します。

arXiv:170 2 Aug 2023「Attention Is All You Need」から引用

文章の生成を行う場合を例に、エンコーダーとデコーダの働きについて見ていきます。

２．１　エンコーダーの働き
　Inputsで文章を入力し、入力済みの文章に続く単語（トークン）の予測の基となるベクトルを作成するまでがエンコーダーの機能となります。
　Inputsから順番に見ていきます。

①InputsとinputEmbedding
　文章を構成する全ての単語を事前学習したEmbededdingのデータで数値ベクトルに変換します。これを埋め込みベクトルといいます。ここでは単語から一意的にEmbededdingのデータに置き換えるだけで文脈は考慮されていません。

②PositionalEncoding
　①のinputの文章の各単語をEmbeddingベクトル空間に置き換えたベクトルデータに対して、文脈上の単語の位置情報を加えます。
　（位置エンコーディングの計算方法）
　位置エンコーディングは、サイン関数とコサイン関数を使用して計算されます。具体的には、次のような形で各次元ごとに計算されます：

この位置エンコーディングにおける各次元は、異なる周期や位相を持つ関数の値を表し、第一次元は高周波で周期的な情報を担い、第二次元は低周波で周期的な情報を担うといった役割をします。

③Multi-HeadAttention

（a）入力ベクトルV、K、Qの準備
　　入力シーケンスを受け取り、Query（Q）、Key（K）、Value（V）を生成します

（b）Linear変換
　Linear変換は、Q、K、Vそれぞれに対して線形変換（入力ベクトルに重み行列を掛け合わせ、バイアスベクトルを加える操作）を適用し、新しいQ’、K’、V’を得ます。線形変換は以下の式で表されます

Multi-Head Attentionでは、以下のようにQuery、Key、Valueそれぞれに異なる重み行列を適用します。

（c）ScaledDot-ProductAttention
　ScaledDot-ProductAttentionは、Queryベクトル（入力シーケンスで注意を払う単語）と入力シーケンスの他の要素のKeyベクトル、Valueベクトルから下記の計算により、スコアを求めます。

Scaled Dot-Product Attentionの出力は、入力のValue行列Vと同じ形状を持ちます。
　具体的には、出力の形状はVの形状（バッチサイズ、シーケンス長、埋め込み次元）と一致します。

　Multi-Head Attention機構においてはこれらの処理はヘッドが複数あり、各ヘッドは異なる部分空間（埋め込みベクトルの異なる次元）で独自のScaled Dot-Product Attentionを計算し、その結果を結合して最終的な出力を生成します。例として、埋め込み次元が8でヘッド数が4のときは各ヘッドの次元は8/4=2となります。

（c）Concat
　各ヘッドの出力を結合し、最終的な出力を得ます。

④Add＆Norm
（a）Add（残差接続）
　勾配消失問題を軽減し、トレーニングの安定性を高めるため入力（Query）をその層の出力に直接足し合わせます。
　Output=Layer Output+Input（ここではQuery）

（b）Norm（正規化）　
　正規化は各層の出力のスケールを調整しトレーニングの安定性と収束速度を向上させます。

⑤Feedward
　フィードフォワードニューラルネットワーク（Feedforward Neural Network、FFN）は、トランスフォーマーモデルの各エンコーダーおよびデコーダーブロック内で、トークンごとの情報を変換し、特徴抽出や複雑なパターンを学習するためのものです。自己注意機構が各トークン間の相関を捉えるのに対して、FFNは各トークンの特徴を独立に変換し、より高度な特徴を学習する役割を担います。具体的には最初の線形変換で高次元に変換し、非線形活性化関数を適用し、最後に線形変換で元の次元に戻します。

⑥Add＆Norm
（a）Add（残差接続）
　勾配消失問題を軽減し、トレーニングの安定性を高めるため入力（Query）をその層の出力に直接足し合わせます。
　Output=Layer Output+Input（ここではQuery）

（b）Norm（正規化）　
　正規化は各層の出力のスケールを調整しトレーニングの安定性と収束速度を向上させます。

２．２　デコーダの働き
　トランスフォーマーモデルのデコーダは、エンコーダから得られたコンテキスト情報をもとに、逐次的に出力シーケンスを生成する役割を担います
①OutputsとOutputsEmbedding
　現在までに生成された部分シーケンスのトークンをベクトル表現に変換したものです。通常、これらのベクトルはEmbedding層を通じて得られます。
　Embedding層は、語彙内の各トークンを固定次元の連続値ベクトルにマッピングします。

②PositionalEncoding
　①のoutputの文章の各単語をEmbeddingベクトル空間に置き換えたベクトルデータに対して、文脈上の単語の位置情報を加えます。
　位置ベクトルの計算方法は２．１項と同じです。

③Masked Multi-Head Attention
　Masked Multi-Head Attention (Masked MHA) は、トランスフォーマーのデコーダで使用される自己注意機構の一部です。マスク付き自己注意機構は、未来の情報を見ないようにするためにマスクを適用します。

④Multi-Head Attention
　デコーダのMulti-Head Attentionの入力にエンコーダからの出力が入っている理由は、エンコーダが入力シーケンスの各トークンの特徴を含むコンテキスト情報を提供するためです。これにより、デコーダは現在生成しているトークンが入力シーケンスのどの部分と関係しているかを学習できます。

⑤Linear
　デコーダの出力は、通常、トークンの埋め込み次元を持つベクトルです。このベクトルを、単語サイズの次元に変換する必要があります。線形層は、デコーダの出力ベクトルに対して線形変換を適用し、単語サイズに対応するスコアベクトルを生成します。

⑥softmax
　線形層からの出力のスコアにソフトマックス関数を適用することで確率分布に変換します。ソフトマックス関数は、各スコアを指数関数的に変換し、全体のスコアの合計が1になるように正規化します。

３．サンプル
　トランスフォーマーのモデルを簡略化したエンコーダデコーダモデル（下記のブロック図）について実装し、確認を行います。

import numpy as np

# 単語の初期化
vocab = ["りんご", "赤い", "みかん", "黄色い", "の", "色", "は"]
inv_vocab = {i: word for i, word in enumerate(vocab)}

# 手動で設定されたエンベディングベクトル
embeddings = {
    "りんご": np.array([0.8, 0.0, 0.8, 0.2]),
    "赤い": np.array([0.8, 0.5, 0.8, 0.2]),
    "みかん": np.array([0.1, 0.9, 0.1, 0.8]),
    "黄色い": np.array([0.3, 0.8, 0.3, 0.8]),
    "の": np.array([0.2, 0.3, 0.1, 0.2]),
    "色": np.array([0.3, 0.2, 0.2, 0.3]),
    "は": np.array([0.1, 0.2, 0.2, 0.2])
}

# エンコーダの入力
encoder_input = ["りんご", "の", "色","は"]

# デコーダの入力
decoder_input = encoder_input

# 単語を埋め込みベクトルに変換
def embed_sequence(sequence):
    return np.array([embeddings[word] for word in sequence])

# 位置エンコーディングの生成
def positional_encoding(sequence_length, d_model):
    position = np.arange(sequence_length)[:, np.newaxis]
    div_term = np.exp(np.arange(0, d_model, 2) * -(np.log(10000.0) / d_model))
    pe = np.zeros((sequence_length, d_model))
    pe[:, 0::2] = np.sin(position * div_term)
    pe[:, 1::2] = np.cos(position * div_term)
    return pe

# マルチヘッドアテンション
def multi_head_attention(Q, K, V, num_heads):
    def attention(Q, K, V):
        d_k = Q.shape[-1]
        scores = np.dot(Q, K.T) / np.sqrt(d_k)
        weights = softmax(scores)
        print("weights:",weights,"V:",V)
        return np.dot(weights, V)
    
    d_model = Q.shape[-1]
    head_dim = d_model // num_heads
    
    heads = []
    for i in range(num_heads):
        Q_i = Q[:, i*head_dim:(i+1)*head_dim]
        print("i:",i,"Q_i:",Q_i)
        K_i = K[:, i*head_dim:(i+1)*head_dim]
        V_i = V[:, i*head_dim:(i+1)*head_dim]
        heads.append(attention(Q_i, K_i, V_i))
        print("④i:",i,"heads:",heads)
    return np.concatenate(heads, axis=-1) #ヘッドの出力を次元（埋め込みベクトルの次元）に沿って結合

# ソフトマックス関数
def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# エンコーダ
def encoder(encoder_input_emb, num_heads):
    print("# エンコーダのセルフアテンション")
    encoder_self_attention =multi_head_attention(encoder_input_emb, encoder_input_emb, encoder_input_emb, num_heads)
    print("encoder_self_attention:",encoder_self_attention)
    return encoder_self_attention

# デコーダ
def decoder(decoder_input_emb, encoder_output, num_heads):
    print("# デコーダのセルフアテンション")
    decoder_self_attention = multi_head_attention(decoder_input_emb, decoder_input_emb, decoder_input_emb, num_heads)
    print("decoder_self_attention:",decoder_self_attention)
    
    print("# エンコーダ-デコーダアテンション")
    encoder_decoder_attention = multi_head_attention(decoder_self_attention, encoder_output, encoder_output, num_heads)
    print("encoder_decoder_attention:",encoder_decoder_attention)
    return encoder_decoder_attention

# 埋め込みに変換
encoder_input_emb = embed_sequence(encoder_input)
print("①encoder_input_emb:",encoder_input_emb)
decoder_input_emb = embed_sequence(decoder_input)
print("①'decoder_input_emb:",decoder_input_emb)

# 位置エンコーディングの追加
## 位置エンコーディングの生成
encoder_pos_enc = positional_encoding(len(encoder_input), encoder_input_emb.shape[1])
print("②encoder_pos_enc:",encoder_pos_enc)
decoder_pos_enc = positional_encoding(len(decoder_input), decoder_input_emb.shape[1])
print("②'decoder_pos_enc:",decoder_pos_enc)
## 埋め込みベクトルに位置ベクトルを加算
encoder_input_emb += encoder_pos_enc
print("③encoder_input_emb:",encoder_input_emb)
decoder_input_emb += decoder_pos_enc
print("③'decoder_input_emb:",decoder_input_emb)

# エンコーダとデコーダの出力
num_heads = 2
encoder_output = encoder(encoder_input_emb, num_heads)
print("⑤encoder_output:",encoder_output)
decoder_output = decoder(decoder_input_emb, encoder_output, num_heads)
print("⑥decoder_output:",decoder_output)
# 次の単語の予測
def predict_next_word(decoder_output, embeddings, inv_vocab):
    last_output = decoder_output[-1]  # デコーダの出力の最後のベクトル
    print("last_output:",last_output)
    similarities = np.dot(np.array(list(embeddings.values())), last_output)
    print("similarities:",similarities)
    return inv_vocab[np.argmax(similarities)]

next_word = predict_next_word(decoder_output, embeddings, inv_vocab)
print("次に来る単語は:", next_word)

・前提条件
　単語のエンベディングベクトルは回答が合うように手動で設定した
　embeddings = {
“りんご”: np.array([0.8, 0.0, 0.8, 0.2]),
“赤い”: np.array([0.8, 0.5, 0.8, 0.2]),
“みかん”: np.array([0.1, 0.9, 0.1, 0.8]),
“黄色い”: np.array([0.3, 0.8, 0.3, 0.8]),
“の”: np.array([0.2, 0.3, 0.1, 0.2]),
“色”: np.array([0.3, 0.2, 0.2, 0.3]),
“は”: np.array([0.1, 0.2, 0.2, 0.2])
}

・実行環境
Windows 10 Pro
Python 3.12.4
numpy 1.26.4

・実行結果
：
similarities: [1.23933206 1.39950039 1.39310835 1.60962455 0.5542311 0.76903867
0.46902724]
次に来る単語は: 黄色い #単語の4番目

(パラメータ数)
（計算例）
ボキャブラリサイズ：7
エンベデイングサイズ：4
マルチヘッドアッテンションのヘッド数：2
エンコーダのマルチヘッドアッテンション層：1
デコーダのマルチヘッドアッテンション層：2
のときのパラメータ数を求める

１．エンベディング層のパラメータ数

２．マルチヘッドアテンション層のパラメータ数

３．フィードフォワードネットワーク層のパラメータ数（サンプルでは省略）

４．エンコーダ層のパラメータ数
　エンコーダ層はマルチヘッドアテンション層1つとフィードフォワード層1つ（仮定）を持ちます。

次に処理の順番に各ベクトルのパラメータの変化を示します。