基本的な人工ニューラルネットワークの作り方
PythonとNumPyでニューラルネットワークをスクラッチから構築。ニューロン、層、活性化関数、トレーニングを簡単な例で理解。
ニューラルネットワークは、画像認識から言語翻訳まで、私たちが日常使用する多くのAIアプリケーションを動かしています。しかし、その核心では、データからパターンを学習する数学的関数に過ぎません。
ゼロから基本的なニューラルネットワークを構築する方法を理解することは、ディープラーニングの基礎を把握するための最良の方法の一つです。詳細を隠すブラックボックスライブラリに頼ることなく、モデルをトレーニングする際に舞台裏で何が起こっているかを正確に確認できます。
このチュートリアルでは、PythonとNumPyを使用して、ステップバイステップでシンプルなニューラルネットワークを構築します。ディープラーニングの経験は不要です—基本的なPythonの知識だけで十分です。
ニューラルネットワークとは?#
脳には数十億のニューロンと呼ばれる小さな細胞があり、互いに通信していると想像してください。猫を見ると、特定のニューロンが一緒に発火してパターンを認識します:尖った耳、ひげ、毛皮。このパターン認識は経験を通じて自動的に行われます。
人工ニューラルネットワークは、数学演算を使用してこのアイデアを模倣しています。以下で構成されています:
- ニューロン: 入力を受け取り、数学演算を行い、出力を生成する単純な処理ユニット
- 層: シーケンスに配置されたニューロンのグループ(入力層、隠れ層、出力層)
- 重み: 各入力の重要度を決定する数値(ニューロン間の接続の強さのようなもの)
- バイアス: 入力に依存せずにネットワークが決定を下すのを助ける数値
- 活性化関数: 非線形性を追加し、ネットワークが複雑なパターンを学習できるようにする数学関数
[!NOTE] ニューラルネットワークは本質的に、入力データを予測に変換する数学演算のチェーンです。
単一のニューロンの仕組み#
最も単純な構成要素から始めましょう:単一のニューロン。
ニューロンを意思決定マシンと考えてください。複数の入力を受け取り、それぞれに重み(重要度)を掛け、バイアスを加えて合計し、結果を活性化関数に通して「発火」するかどうか(値を出力するか)を決定します。
数学的には次のようになります:
出力 = 活性化(合計(入力 × 重み) + バイアス)textPythonで構築してみましょう:
import numpy as np
def sigmoid(x):
"""シグモイド活性化関数:値を0から1の間に圧縮"""
return 1 / (1 + np.exp(-x))
class Neuron:
def __init__(self, weights, bias):
self.weights = weights
self.bias = bias
def feedforward(self, inputs):
"""入力をニューロンに通す"""
# 入力に重みを掛け、バイアスを加え、活性化を適用
total = np.dot(self.weights, inputs) + self.bias
return sigmoid(total)
# 2つの入力を持つニューロンを作成
weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4 # b = 4
n = Neuron(weights, bias)
# 入力[2, 3]でテスト
x = np.array([2, 3]) # x1 = 2, x2 = 3
print(n.feedforward(x)) # 出力: 0.9990889488055994python何が起こったのでしょうか?
- 入力:
[2, 3] - 重み付き合計:
(2 × 0) + (3 × 1) + 4 = 7 - Sigmoid(7) ≈ 0.999(ほぼ1に圧縮)
シグモイド関数は活性化関数の一種に過ぎません。0から1の間の値を出力するため、確率として解釈できるため、分類に役立ちます。
シンプルなニューラルネットワークの構築#
単一のニューロンには限界があります—単純なパターンしか学習できません。より複雑な問題を解決するには、複数のニューロンを層に接続する必要があります。
以下のネットワークを構築しましょう:
- 2つの入力ニューロン
- 2つのニューロンを持つ1つの隠れ層
- 1つの出力ニューロン
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
class NeuralNetwork:
def __init__(self):
# 隠れ層の重みとバイアス(2入力 -> 2隠れニューロン)
self.weights1 = np.array([[0.1, 0.2], [0.3, 0.4]]) # 2x2行列
self.bias1 = np.array([0.1, 0.2]) # 2つのバイアス
# 出力層の重みとバイアス(2隠れ -> 1出力)
self.weights2 = np.array([0.5, 0.6]) # 1x2ベクトル
self.bias2 = np.array([0.3]) # 1つのバイアス
def feedforward(self, x):
"""ネットワークを通して順伝播"""
# 隠れ層
hidden_sum = np.dot(x, self.weights1) + self.bias1
hidden_output = sigmoid(hidden_sum)
# 出力層
output_sum = np.dot(hidden_output, self.weights2) + self.bias2
output = sigmoid(output_sum)
return output
# ネットワークをテスト
network = NeuralNetwork()
x = np.array([0.5, 0.7])
print(network.feedforward(x)) # 出力: ~0.7pythonこのネットワークは2つの入力を受け取り、隠れ層を通して処理し、1つの出力を生成します。しかし問題があります:重みがランダムです!ネットワークは何をしているのかわかっていません。
ニューラルネットワークのトレーニング#
トレーニングは、ネットワークが正確な予測を行えるように重みとバイアスを調整するプロセスです。以下のように動作します:
- 順伝播: 入力をネットワークに通して予測を取得
- 損失の計算: 予測を実際の答えと比較(どれくらい間違っているか?)
- 逆伝播(バックプロパゲーション): 各重みがエラーにどれだけ寄与したかを計算
- 重みの更新: エラーを減らすために重みを少し調整
- 繰り返し: ネットワークが学習するまでこれを何度も繰り返す
[!TIP] これは「勾配降下法」と呼ばれます—最適な重み(最低点)を見つけるために、丘(エラー)をゆっくり下って歩いています。
数値を「小さい」(< 0.5)または「大きい」(≥ 0.5)として分類するという単純なタスクのためにトレーニングを実装しましょう。
import numpy as np
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
"""バックプロパゲーション用のシグモイドの導関数"""
return x * (1 - x)
class NeuralNetwork:
def __init__(self):
# 重みをランダムに初期化
self.weights1 = np.random.rand(2, 2)
self.bias1 = np.random.rand(2)
self.weights2 = np.random.rand(2)
self.bias2 = np.random.rand(1)
def feedforward(self, x):
self.hidden_sum = np.dot(x, self.weights1) + self.bias1
self.hidden_output = sigmoid(self.hidden_sum)
self.output_sum = np.dot(self.hidden_output, self.weights2) + self.bias2
self.output = sigmoid(self.output_sum)
return self.output
def backpropagate(self, x, y, learning_rate=0.1):
"""1つの例でネットワークをトレーニング"""
# 順伝播
output = self.feedforward(x)
# エラーの計算
error = y - output
# バックプロパゲーション
# 出力層の勾配
d_output = error * sigmoid_derivative(output)
d_weights2 = np.dot(self.hidden_output.T, d_output)
# 隠れ層の勾配
d_hidden = np.dot(d_output, self.weights2) * sigmoid_derivative(self.hidden_output)
d_weights1 = np.outer(x, d_hidden)
# 重みとバイアスを更新
self.weights2 += learning_rate * d_weights2
self.bias2 += learning_rate * np.sum(d_output)
self.weights1 += learning_rate * d_weights1
self.bias1 += learning_rate * np.sum(d_hidden)
return np.mean(error ** 2) # 平均二乗誤差を返す
# トレーニングデータ:数値を小さい(0)または大きい(1)として分類
X = np.array([[0.1], [0.2], [0.3], [0.4], [0.6], [0.7], [0.8], [0.9]])
y = np.array([0, 0, 0, 0, 1, 1, 1, 1])
# Xを2つの特徴に拡張(2番目のランダムな特徴を追加)
X = np.hstack([X, np.random.rand(8, 1)])
# ネットワークを作成してトレーニング
network = NeuralNetwork()
epochs = 10000
for epoch in range(epochs):
total_error = 0
for i in range(len(X)):
error = network.backpropagate(X[i], y[i])
total_error += error
if epoch % 1000 == 0:
print(f"Epoch {epoch}, エラー: {total_error / len(X):.4f}")
# トレーニングされたネットワークをテスト
test_input = np.array([[0.25, 0.5]])
print(f"0.25の予測: {network.feedforward(test_input[0]):.4f}")
test_input = np.array([[0.75, 0.5]])
print(f"0.75の予測: {network.feedforward(test_input[0]):.4f}")pythonトレーニング後、ネットワークは小さい数には0に近い値、大きい数には1に近い値を予測するはずです。
コンポーネントの理解#
活性化関数#
活性化関数は非線形性を追加し、ニューラルネットワークが複雑なパターンを学習できるようにします。これらがないと、ニューラルネットワークは単なる線形回帰モデルになります。
一般的な活性化関数:
- シグモイド: 0から1の間の出力(二項分類に適している)
- ReLU: 負の入力には0を出力し、正の入力は変更せずに通す(隠れ層で最も一般的)
- ソフトマックス: 出力を確率に変換(多クラス分類に適している)
損失関数#
損失関数は、ネットワークの予測がどれくらい間違っているかを測定します。
- 平均二乗誤差(MSE): 予測とターゲットの間の二乗差の平均(回帰用)
- 交差エントロピー損失: 予測された分布と実際の分布の差を測定(分類用)
学習率#
学習率は、重みを更新する際のステップサイズを制御します。
- 高すぎる:最適解を超える可能性がある
- 低すぎる:トレーニングに永遠にかかる
- 典型的な値:0.001から0.1
実用的なアプリケーションへの移行#
ゼロからニューラルネットワークを構築することは学習には最適ですが、実際には、以下のようなディープラーニングフレームワークを使用します:
- TensorFlow/Keras: 業界標準、多くのチュートリアル
- PyTorch: 研究で人気、Pythonicな設計
- JAX: 高性能、構成可能
Kerasを使用した同じシンプルなネットワークは次のとおりです:
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
# トレーニングデータ
X = np.array([[0.1, 0.5], [0.2, 0.3], [0.3, 0.7], [0.4, 0.2],
[0.6, 0.8], [0.7, 0.4], [0.8, 0.6], [0.9, 0.1]])
y = np.array([0, 0, 0, 0, 1, 1, 1, 1])
# モデルを構築
model = keras.Sequential([
layers.Dense(2, activation='relu', input_shape=(2,)),
layers.Dense(1, activation='sigmoid')
])
# モデルをコンパイル
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# モデルをトレーニング
model.fit(X, y, epochs=100, verbose=0)
# モデルをテスト
print(model.predict(np.array([[0.25, 0.5]])))
print(model.predict(np.array([[0.75, 0.5]])))pythonKerasは、すべての数学、最適化、および管理を処理します。しかし今では、裏側で何が起こっているかを理解しています。
一般的な課題#
ニューラルネットワークを構築する際、いくつかの課題に遭遇します:
勾配消失#
深いネットワークでは、バックプロパゲーション中に勾配が極端に小さくなり、初期の層が非常にゆっくりと学習する可能性があります。解決策:ReLU活性化、慎重な重み初期化、または残差接続を使用する。
過学習#
ネットワークはトレーニングデータを記憶しますが、新しいデータに一般化できません。解決策:ドロップアウトを追加、より多くのトレーニングデータを使用、正則化を適用、または早期停止。
アーキテクチャの選択#
何層?何ニューロン?公式はありません—実験が鍵です。シンプルに始めて、必要に応じて複雑さを追加してください。
次のステップ#
基本を理解したので、以下のことができます:
- 異なるアーキテクチャを試す: より深いネットワーク、異なる活性化関数を試す
- 実際のデータセットで作業: MNIST(手書き数字)、CIFAR-10(画像)、IMDB(テキスト)
- 高度なテクニックを学ぶ: 画像用の畳み込みニューラルネットワーク(CNN)、シーケンス用のリカレントニューラルネットワーク(RNN)
- フレームワークを探索: TensorFlow、PyTorch、またはJAXを深く掘り下げる
結論#
ゼロからニューラルネットワークを構築すると、ディープラーニングの「魔法」が明らかになります。その核心では、データからパターンを学習するために巧妙に配置された数学—乗算、加算、関数合成—に過ぎないことがわかりました。
学んだ概念—ニューロン、層、活性化関数、順伝播/逆伝播—は、すべての現代のAIシステムの基礎です。画像分類器、言語モデル、推薦システムを構築する場合でも、これらの基本は変わりません。
シンプルに始めて、頻繁に実験し、物を壊すことを恐れないでください。それが学ぶ方法です。