スマホのカメラで写真を撮ると、AIが自動的に「これは犬」「これは猫」と判定してくれますよね。
でも、AIの内部では、実は数字で答えを出しているんです。
例：画像認識AIの内部
- 犬の可能性：85%
- 猫の可能性：10%
- 鳥の可能性：3%
- その他：2%
この「確率」に変換する魔法のような計算がSoftmax（ソフトマックス）関数なんです。
Softmaxは、ニューラルネットワークで分類問題を解くときに、ほぼ必ず使われる重要な関数です。この記事では、Softmaxの仕組みや使い方について、初心者の方にも分かるように詳しく解説していきます。
分類問題とは？基礎から理解する
分類問題の例
分類問題とは、入力をいくつかのカテゴリ（クラス）に分けるタスクです。
日常生活の例：
画像認識
- 入力：写真
- 出力：「犬」「猫」「鳥」などのラベル
迷惑メール判定
- 入力：メールの文章
- 出力：「迷惑メール」または「通常のメール」
音声認識
- 入力：音声データ
- 出力：「はい」「いいえ」「わかりません」など
手書き数字認識
- 入力：手書きの数字画像
- 出力：0〜9のいずれか
機械学習での分類
機械学習で分類問題を解くとき、ニューラルネットワークは以下のように動作します。
ステップ1：特徴を抽出
入力データから重要な特徴を取り出します。
ステップ2：スコアを計算
各クラスに対して「生のスコア」を計算します。
例：3クラス分類
犬のスコア：2.5
猫のスコア：1.0
鳥のスコア：-0.5このスコアは実数値（正でも負でもOK）で、範囲もバラバラです。
ステップ3：確率に変換（Softmaxの役割）
スコアを確率に変換します。
犬の確率：85%
猫の確率：12%
鳥の確率：3%確率の特徴：
- すべて0から1の範囲
- 合計すると100%（1.0）になる
- 大きい値ほど「その可能性が高い」
このスコアから確率への変換を行うのが、Softmax関数なんです。
Softmaxの基本：数式と動作原理
Softmax関数の定義
数式：
n個のクラスがある場合、i番目のクラスの確率は以下のように計算されます。
P(クラスi) = e^(zi) / Σ(e^(zj)) （jは1からnまで）
または
Softmax(zi) = e^(zi) / (e^(z1) + e^(z2) + ... + e^(zn))記号の意味：
- zi：i番目のクラスの入力スコア（ロジット）
- e：自然対数の底（約2.718）
- Σ：合計を表す記号
計算の流れ
具体的な例で理解しましょう。
例：3クラス分類（犬・猫・鳥）
入力スコア：
z1（犬）= 2.0
z2（猫）= 1.0
z3（鳥）= 0.1ステップ1：各スコアを指数化
e^2.0 ≈ 7.389
e^1.0 ≈ 2.718
e^0.1 ≈ 1.105ステップ2：合計を計算
合計 = 7.389 + 2.718 + 1.105 = 11.212ステップ3：各値を合計で割る
P(犬) = 7.389 / 11.212 ≈ 0.659（65.9%）
P(猫) = 2.718 / 11.212 ≈ 0.242（24.2%）
P(鳥) = 1.105 / 11.212 ≈ 0.099（9.9%）確認：
0.659 + 0.242 + 0.099 = 1.000（100%）✓ちゃんと合計が1になりましたね！
なぜ指数関数（e^x）を使うの？
Softmaxで指数関数を使う理由は、いくつかあります。
理由1：常に正の値になる
- e^x は常に正の値（0より大きい）
- 負のスコアも正の値に変換される
- 確率（0〜1の範囲）に変換しやすい
理由2：差を強調する
- 大きなスコアは非常に大きな値になる
- 小さなスコアは相対的に小さくなる
- 「一番可能性の高いクラス」がはっきりする
例：差の強調
スコアが [2.0, 1.0, 0.1] の場合：
e^2.0 : e^1.0 : e^0.1 = 7.4 : 2.7 : 1.1比率が分かりやすくなります。
理由3：数学的な美しさ
- 微分が簡単（勾配計算がしやすい）
- 情報理論との関係が深い
- 最尤推定と整合性がある
Softmaxの性質
性質1：出力は0〜1の範囲
0 ≤ Softmax(zi) ≤ 1すべての出力が確率として解釈できます。
性質2：出力の合計は1
Σ Softmax(zi) = 1確率分布を表現できます。
性質3：単調性
入力が大きいほど、出力も大きくなります。
zi > zj ならば Softmax(zi) > Softmax(zj)順序関係が保たれます。
性質4：相対的な大きさに依存
すべてのスコアに同じ値を足しても、相対的な関係は変わりません。
Softmax([2, 1, 0]) = Softmax([3, 2, 1]) = Softmax([102, 101, 100])Softmaxとシグモイドの関係
シグモイド関数の復習
シグモイド関数：
σ(x) = 1 / (1 + e^(-x))シグモイドは、1つの値を0〜1の範囲に変換します。
用途：
- 2クラス分類（二値分類）
- 「YesかNo」のような判定
Softmaxは多クラス版シグモイド
実は、2クラス分類のSoftmaxは、シグモイド関数と同等なんです。
2クラスの場合：
スコアが [z1, z2] のとき：
P(クラス1) = e^z1 / (e^z1 + e^z2)
= 1 / (1 + e^(z2-z1))
= σ(z1 - z2)これはシグモイド関数と同じ形です。
つまり：
- シグモイド：2クラス分類用
- Softmax：多クラス（3クラス以上）分類用
Softmaxは、シグモイドを多クラスに拡張したものと考えられます。
ニューラルネットワークでの使用例
典型的な構造
Softmaxは、通常ニューラルネットワークの最後の層（出力層）で使われます。
構造：
入力層
↓
隠れ層1（ReLUなど）
↓
隠れ層2（ReLUなど）
↓
...
↓
出力層（線形）
↓
Softmax関数
↓
確率分布手書き数字認識（MNIST）の例
タスク：
0〜9の手書き数字を分類する（10クラス分類）
ネットワーク構造：
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
layers.Flatten(input_shape=(28, 28)), # 画像を1次元に変換
layers.Dense(128, activation='relu'), # 隠れ層1
layers.Dense(64, activation='relu'), # 隠れ層2
layers.Dense(10), # 出力層（10クラス）
layers.Softmax() # Softmax関数
])
model.summary()出力の解釈：
出力 = [0.001, 0.002, 0.95, 0.01, 0.005, 0.003, 0.01, 0.001, 0.015, 0.003]
解釈：
数字「2」である確率が95%
→ この画像は「2」と予測画像分類（ImageNet）の例
タスク：
1000種類の物体を分類
ネットワーク構造（ResNetなど）：
from tensorflow.keras.applications import ResNet50
# 事前学習済みモデル
base_model = ResNet50(weights='imagenet', include_top=False)
# 自分のモデルを構築
model = keras.Sequential([
base_model,
layers.GlobalAveragePooling2D(),
layers.Dense(512, activation='relu'),
layers.Dropout(0.5),
layers.Dense(1000), # 1000クラス
layers.Softmax() # Softmax
])自然言語処理の例
タスク：
文章の感情分析（ポジティブ・ネガティブ・中立）
ネットワーク構造：
from tensorflow.keras.layers import Embedding, LSTM
model = keras.Sequential([
Embedding(input_dim=10000, output_dim=128), # 単語の埋め込み
LSTM(64), # LSTM層
layers.Dense(3), # 3クラス
layers.Softmax() # Softmax
])出力例：
入力："この映画は最高でした！"
出力：[0.90, 0.05, 0.05]
→ ポジティブ90%、ネガティブ5%、中立5%Softmaxの実装
実際にプログラムで実装してみましょう。
Pythonでの基本実装
NumPyを使った実装：
import numpy as np
def softmax(x):
"""
Softmax関数
引数:
x: 入力配列（1次元または2次元）
戻り値:
確率分布
"""
# 数値安定性のために最大値を引く
exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
return exp_x / np.sum(exp_x, axis=-1, keepdims=True)
# 使用例
scores = np.array([2.0, 1.0, 0.1])
probs = softmax(scores)
print("入力スコア:", scores)
print("確率:", probs)
print("合計:", probs.sum())
# 出力:
# 入力スコア: [2. 1. 0.1]
# 確率: [0.65900114 0.24243297 0.09856589]
# 合計: 1.0バッチ処理対応版：
def softmax_batch(x):
"""
バッチ処理対応のSoftmax関数
引数:
x: 入力配列（shape: [batch_size, num_classes]）
戻り値:
確率分布（shape: [batch_size, num_classes]）
"""
# 各サンプルごとに最大値を引く
exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
return exp_x / np.sum(exp_x, axis=1, keepdims=True)
# 使用例（バッチサイズ2、3クラス分類）
scores_batch = np.array([
[2.0, 1.0, 0.1], # サンプル1
[1.0, 3.0, 0.2] # サンプル2
])
probs_batch = softmax_batch(scores_batch)
print("確率（バッチ）:")
print(probs_batch)
print("各サンプルの合計:", probs_batch.sum(axis=1))TensorFlow / Kerasでの使用
方法1：層として使う
import tensorflow as tf
from tensorflow.keras import layers
model = tf.keras.Sequential([
layers.Dense(128, activation='relu'),
layers.Dense(10), # 出力層（スコア）
layers.Softmax() # Softmax層
])方法2：活性化関数として使う
model = tf.keras.Sequential([
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax') # Softmax付き出力層
])方法3：関数として使う
import tensorflow as tf
logits = tf.constant([[2.0, 1.0, 0.1], [1.0, 3.0, 0.2]])
probs = tf.nn.softmax(logits)
print(probs.numpy())PyTorchでの使用
方法1：nn.Softmax層
import torch
import torch.nn as nn
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Linear(128, 10),
nn.Softmax(dim=1) # Softmax層（次元1に対して）
)方法2：関数として使う
import torch.nn.functional as F
logits = torch.tensor([[2.0, 1.0, 0.1], [1.0, 3.0, 0.2]])
probs = F.softmax(logits, dim=1) # 次元1に対してSoftmax
print(probs)手動実装での注意点
Softmaxを手動実装する場合、数値安定性に注意が必要です。
問題：
スコアが大きいと、e^x がオーバーフローします。
import numpy as np
# 問題のある実装
def softmax_naive(x):
exp_x = np.exp(x) # オーバーフローの危険！
return exp_x / np.sum(exp_x)
# 大きな値を入れてみる
scores = np.array([1000, 1001, 1002])
print(softmax_naive(scores)) # nan（計算できない）解決策：最大値を引く
数学的には、すべての値から同じ値を引いても結果は変わりません。
def softmax_stable(x):
# 最大値を引く（数値安定化）
x_shifted = x - np.max(x)
exp_x = np.exp(x_shifted)
return exp_x / np.sum(exp_x)
# 安定した計算
scores = np.array([1000, 1001, 1002])
print(softmax_stable(scores)) # [0.09003057 0.24472847 0.66524096]これで正しく計算できます。
Softmax温度パラメータ
Softmaxには、温度（Temperature）という調整パラメータがあります。
温度付きSoftmax
数式：
Softmax_T(zi) = e^(zi/T) / Σ(e^(zj/T))Tは温度パラメータです。
温度による変化
T = 1（標準）：
通常のSoftmax
T → 0（低温）：
- 最大値のクラスの確率が1に近づく
- 他のクラスの確率が0に近づく
- Hard（硬い）な分布
T → ∞（高温）：
- すべてのクラスの確率が均等に近づく
- Soft（柔らかい）な分布
具体例
import numpy as np
def softmax_with_temperature(x, T=1.0):
"""温度パラメータ付きSoftmax"""
x_scaled = x / T
exp_x = np.exp(x_scaled - np.max(x_scaled))
return exp_x / np.sum(exp_x)
# 同じスコア
scores = np.array([2.0, 1.0, 0.1])
print("T=0.5（低温）:", softmax_with_temperature(scores, T=0.5))
print("T=1.0（標準）:", softmax_with_temperature(scores, T=1.0))
print("T=2.0（高温）:", softmax_with_temperature(scores, T=2.0))
print("T=5.0（超高温）:", softmax_with_temperature(scores, T=5.0))
# 出力:
# T=0.5（低温）: [0.84202176 0.14227926 0.01569898]
# T=1.0（標準）: [0.65900114 0.24243297 0.09856589]
# T=2.0（高温）: [0.50650298 0.31062078 0.18287624]
# T=5.0（超高温）: [0.39880059 0.33222499 0.26897442]観察：
- T=0.5：最大値のクラス（犬）が84%と非常に高い
- T=5.0：各クラスが近い確率になり、均等に近づく
温度の応用
1. 知識の蒸留（Knowledge Distillation）
- 大きなモデル（教師）の知識を小さなモデル（生徒）に転移
- 高温Softmaxで「柔らかい」確率を使う
2. 生成モデル
- テキスト生成で多様性を制御
- 低温→確実な生成、高温→多様な生成
3. 探索と利用のバランス
- 強化学習で行動選択
- 温度で探索の度合いを調整
クロスエントロピー損失関数との関係
Softmaxは、通常クロスエントロピー損失関数と組み合わせて使います。
クロスエントロピー損失
数式：
Loss = -Σ(yi × log(ŷi))
yi：正解ラベル（one-hotエンコーディング）
ŷi：Softmaxの出力（予測確率）具体例
正解：犬（クラス0）
正解ラベル（one-hot）: [1, 0, 0]
予測確率（Softmax）: [0.7, 0.2, 0.1]
Loss = -(1×log(0.7) + 0×log(0.2) + 0×log(0.1))
= -log(0.7)
≈ 0.357良い予測の場合：
予測確率: [0.95, 0.03, 0.02]
Loss = -log(0.95) ≈ 0.051 ← 損失が小さい悪い予測の場合：
予測確率: [0.1, 0.5, 0.4]
Loss = -log(0.1) ≈ 2.303 ← 損失が大きいSoftmax + クロスエントロピーの実装
TensorFlowの場合：
import tensorflow as tf
# 方法1：別々に定義
model = tf.keras.Sequential([
tf.keras.layers.Dense(10), # 出力層
tf.keras.layers.Softmax() # Softmax
])
model.compile(
optimizer='adam',
loss='categorical_crossentropy' # クロスエントロピー損失
)方法2：統合版を使う（推奨）
数値安定性のため、Softmaxとクロスエントロピーを統合した関数を使うのが推奨されます。
# 推奨：from_logits=True を使う
model = tf.keras.Sequential([
tf.keras.layers.Dense(10) # Softmaxなし
])
model.compile(
optimizer='adam',
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True)
# from_logits=True: ロジット（スコア）を直接受け取る
)PyTorchの場合：
PyTorchでは、nn.CrossEntropyLossがSoftmaxを内部で自動的に適用します。
import torch
import torch.nn as nn
# モデル（Softmaxは不要！）
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Linear(128, 10) # Softmaxなし
)
# 損失関数（Softmax + クロスエントロピー）
criterion = nn.CrossEntropyLoss()
# 使用例
logits = model(input_data)
loss = criterion(logits, target) # Softmaxは自動適用注意：PyTorchでは出力層にSoftmaxを付けない！
よくある間違いとトラブルシューティング
間違い1：推論時にSoftmaxを忘れる
問題：
訓練時と推論時で処理が違う場合、推論時にSoftmaxを忘れることがあります。
例（TensorFlow）：
# 訓練時（from_logits=True を使用）
model = tf.keras.Sequential([
tf.keras.layers.Dense(10) # Softmaxなし
])
model.compile(
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True)
)
# 推論時：Softmaxが必要！
predictions_logits = model.predict(x_test) # ロジットのまま
predictions_probs = tf.nn.softmax(predictions_logits) # 確率に変換解決策：
推論専用のモデルを作る
# 推論用モデル（Softmax付き）
inference_model = tf.keras.Sequential([
model,
tf.keras.layers.Softmax()
])
predictions_probs = inference_model.predict(x_test) # 直接確率が得られる間違い2：PyTorchでSoftmaxを二重に適用
問題：nn.CrossEntropyLossはSoftmaxを内部で適用するのに、モデルの出力層にもSoftmaxを付けてしまう。
悪い例：
import torch.nn as nn
# 間違い：Softmaxが二重に適用される
model = nn.Sequential(
nn.Linear(784, 10),
nn.Softmax(dim=1) # これは不要！
)
criterion = nn.CrossEntropyLoss() # 内部でSoftmaxを適用
# 結果：間違った学習
loss = criterion(model(x), target)正しい例：
# 正しい：Softmaxは損失関数に任せる
model = nn.Sequential(
nn.Linear(784, 10) # Softmaxなし
)
criterion = nn.CrossEntropyLoss() # Softmaxを内部で適用
# 正しい学習
loss = criterion(model(x), target)間違い3：数値不安定性
問題：
大きなスコアでオーバーフローが発生する。
解決策：
最大値を引いてから計算する（前述）。
間違い4：次元の指定ミス
問題：
バッチ処理で、Softmaxを適用する次元を間違える。
例：
import torch
import torch.nn.functional as F
# shape: [batch_size=2, num_classes=3]
logits = torch.tensor([[2.0, 1.0, 0.1],
[1.0, 3.0, 0.2]])
# 間違い：次元0に適用（バッチ方向）
probs_wrong = F.softmax(logits, dim=0)
print(probs_wrong.sum(dim=0)) # [1.0, 1.0, 1.0] ← 縦方向の合計が1
# 正しい：次元1に適用（クラス方向）
probs_correct = F.softmax(logits, dim=1)
print(probs_correct.sum(dim=1)) # [1.0, 1.0] ← 横方向の合計が1ルール：
- TensorFlow:
axis=-1（最後の次元） - PyTorch:
dim=1またはdim=-1
実践例：MNISTでの分類
実際にSoftmaxを使った分類モデルを作ってみましょう。
TensorFlowでの実装
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
# データの準備
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype('float32') / 255
x_test = x_test.reshape(-1, 784).astype('float32') / 255
# モデルの構築
model = keras.Sequential([
layers.Dense(128, activation='relu', input_shape=(784,)),
layers.Dropout(0.2),
layers.Dense(64, activation='relu'),
layers.Dense(10) # 出力層（Softmaxなし）
])
# コンパイル（from_logits=True を使用）
model.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy']
)
# 訓練
history = model.fit(
x_train, y_train,
batch_size=128,
epochs=5,
validation_split=0.1
)
# 評価
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"テスト精度: {test_acc:.4f}")
# 推論（確率を得る）
inference_model = keras.Sequential([
model,
layers.Softmax() # Softmaxを追加
])
# いくつかのサンプルで予測
samples = x_test[:5]
predictions = inference_model.predict(samples)
for i, pred in enumerate(predictions):
predicted_class = np.argmax(pred)
confidence = pred[predicted_class]
print(f"サンプル{i}: 予測={predicted_class}, 確信度={confidence:.2%}")PyTorchでの実装
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# データの準備
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)
# モデルの定義
class MNISTClassifier(nn.Module):
def __init__(self):
super(MNISTClassifier, self).__init__()
self.fc1 = nn.Linear(784, 128)
self.relu1 = nn.ReLU()
self.dropout = nn.Dropout(0.2)
self.fc2 = nn.Linear(128, 64)
self.relu2 = nn.ReLU()
self.fc3 = nn.Linear(64, 10)
# Softmaxは損失関数に含まれるので不要
def forward(self, x):
x = x.view(-1, 784)
x = self.relu1(self.fc1(x))
x = self.dropout(x)
x = self.relu2(self.fc2(x))
x = self.fc3(x)
return x
model = MNISTClassifier()
# 損失関数と最適化器
criterion = nn.CrossEntropyLoss() # Softmax + クロスエントロピー
optimizer = optim.Adam(model.parameters())
# 訓練
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
for epoch in range(5):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
if batch_idx % 100 == 0:
print(f'Epoch {epoch+1}, Batch {batch_idx}, Loss: {loss.item():.4f}')
# 評価
model.eval()
correct = 0
total = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
_, predicted = torch.max(output, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
accuracy = correct / total
print(f'テスト精度: {accuracy:.4f}')
# 推論（確率を得る）
model.eval()
sample_data, sample_target = next(iter(test_loader))
sample_data = sample_data[:5].to(device)
with torch.no_grad():
logits = model(sample_data)
probs = torch.nn.functional.softmax(logits, dim=1)
for i, prob in enumerate(probs):
predicted_class = torch.argmax(prob).item()
confidence = prob[predicted_class].item()
print(f"サンプル{i}: 予測={predicted_class}, 確信度={confidence:.2%}")Softmaxの微分（勾配計算）
機械学習では、勾配（微分）の計算が重要です。
単一出力の微分
i番目の出力に関する、j番目の入力の微分：
∂yi/∂zj = {
yi(1 - yi) (i = j のとき)
-yiyj (i ≠ j のとき)
}
yi = Softmax(zi)ヤコビ行列
すべての組み合わせをまとめると、ヤコビ行列になります。
J = [
y1(1-y1) -y1y2 -y1y3 ...
-y2y1 y2(1-y2) -y2y3 ...
-y3y1 -y3y2 y3(1-y3) ...
...
]実装例
import numpy as np
def softmax_gradient(softmax_output):
"""
Softmaxのヤコビ行列を計算
引数:
softmax_output: Softmaxの出力（1次元配列）
戻り値:
ヤコビ行列
"""
s = softmax_output.reshape(-1, 1)
return np.diagflat(s) - np.dot(s, s.T)
# 使用例
probs = np.array([0.7, 0.2, 0.1])
jacobian = softmax_gradient(probs)
print("Softmax出力:", probs)
print("\nヤコビ行列:")
print(jacobian)まとめ：Softmaxは分類問題の必須ツール
Softmax（ソフトマックス）関数は、ニューラルネットワークで分類問題を解く際の必須要素です。
この記事のポイント：
- Softmaxの役割：スコアを確率分布に変換する
- 数式：Softmax(zi) = e^(zi) / Σ(e^(zj))
- 性質：出力は0〜1、合計は1、確率として解釈可能
- 用途：多クラス分類問題（画像認識、自然言語処理など）
- シグモイドとの関係：Softmaxは多クラス版のシグモイド
- ネットワーク構造：通常は出力層の最後に配置
- 数値安定性：最大値を引いてからe^xを計算
- 温度パラメータ：分布の「硬さ」を調整できる
- クロスエントロピー：通常はクロスエントロピー損失と組み合わせて使用
- 実装の注意：TensorFlowとPyTorchで扱いが異なる
- よくある間違い：PyTorchでSoftmaxを二重適用、次元の指定ミス
ディープラーニングで分類問題に取り組むとき、Softmaxの理解は欠かせません。
単なる数式ではなく、「AIがどうやって『これは犬だ』と判断しているのか」という根本的な仕組みを表しています。
実装はとてもシンプルですが、その背後には情報理論や統計学の深い理論があります。まずは基本的な使い方をマスターして、徐々に理解を深めていきましょう。
画像認識AIを作るとき、自然言語処理モデルを構築するとき、Softmaxは必ずどこかで活躍しています。この小さな関数が、現代のAIを支えているんです。
コメント