パーセプトロン 📖 Wikipedia

import random

class Neuron:
    """
    単純パーセプトロンの実装クラス
    """

    # class定義及び初期化部
    def __init__(self, size_integer):
        """
        重みの集合とニューロンは一対であるため、ニューロンを重みの配列として定義している。
        """
        # 重みの初期値は確率的勾配降下法に基づくため
        # 全要素を乱数(0.0～1.0)で初期化する必要がある。
        self.weights = [random.random() for _ in range(size_integer)]

    # 思考部
    def _activation_function(self, value):
        """
        出力値を整形する活性化関数を提供する。
        今回は論理値を返せれば良いので出力が0以下なら0、0超なら1を返す。
        """
        return 1 if value > 0 else 0

    def thought(self, input_values_collection):
        """
        学習結果に基づき、入力値から出力値を出す思考関数。
        パーセプトロンの本体といえる。

        入力値としては下記の形式の値を期待する。
        [ 0, 0 ]
        [ 0, 1 ]
        """
        # 入力値の数の制限。入力値の数は重みの数よりも1つ少なくなければならない。
        if len(self.weights) != len(input_values_collection) + 1:
            raise ValueError('input_values_collectionの長さはweightsの長さより1つ少なくなければなりません')

        # パーセプトロンの最重要部。入力値と重みをそれぞれ掛け合わせ、
        # その合計から出力値を出す。
        weighted_sum = sum(w * i for w, i in zip(self.weights, input_values_collection + [1]))

        return self._activation_function(weighted_sum)

    def _error_function(self, output_value, expected_number):
        """
        誤った値を正解の値に近づけるための誤差関数を提供する。
        正確には誤差関数そのものではないが、誤差関数は偏微分により
        誤差関数を構成する式の半分が消失するためここでは下記を誤差関数として扱う。
        """
        return expected_number - output_value

    # 学習部
    def learn_from(self, input_value_collection, expected_number):
        """
        1通り分の学習関数。
        [ 1, 1 ]であれば1であるべきという値を受け取り、
        そうなっていなければ重みを正解に近づくよう調整する。
        """
        # 現在の重みで思考する
        result = self.thought(input_value_collection)

        # 誤差を計算
        error = self._error_function(result, expected_number)

        # 0.001は精度と学習速度を調整する値で、それらを鑑みてちょうど良い値を指定する。
        learning_rate = 0.001

        # 上記の実行結果を正解の値に近づける。
        # 調整後の重みを更新し、結果と共に返す。
        new_weights = []
        for w, i in zip(self.weights, input_value_collection + [1]):
            # 重みの更新式: w = w + (誤差 * 入力 * 学習率)
            delta = error * i * learning_rate
            new_weights.append(w + delta)

        self.weights = new_weights

        # 調整後の重みと、実行結果(学習前の判定結果)を返す
        return self.weights, result

    def learn_all(self, expected_with_input_values_collection):
        """
        全通り分の学習関数。
        全ての条件が正解になるまで学習を繰り返す。
        1通り分の学習関数では、下記のうちどれか1つを満たす単純パーセプトロンしか作ることができない。
        この関数では下記すべてを満たす単純パーセプトロンを作る。

        [ 0, 0 ] であれば0。
        [ 0, 1 ] であれば0。
        [ 1, 0 ] であれば0。
        [ 1, 1 ] であれば1。

        入力値としては下記の形式の値を期待する。
        一番左の値は正解値となる。
        入力値形式:
        [
            ( 0, [ 0, 0 ] ),
            ( 1, [ 1, 1 ] ),
        ]
        """
        while True:
            results_check = []

            for expected, inputs in expected_with_input_values_collection:
                # 1つずつ学習を実行
                updated_weights, result = self.learn_from(inputs, expected)

                # 実行結果が正解になっているか確認する (True/Falseをリストに保存)
                results_check.append(expected == result)

            # 不正解(False)が残っているか確認し、残っていなければ終了
            if all(results_check):
                break

        return self.weights


# 使用部
if __name__ == '__main__':
    # 3つのパラメータ（2つの重みと1つのバイアス）を持つニューロンを生成
    and_neuron = Neuron(3)

    # 論理積(AND)を学習させる。
    # データ形式: (正解ラベル, [入力1, 入力2])
    training_data = [
        (0, [0, 0]),
        (0, [0, 1]),
        (0, [1, 0]),
        (1, [1, 1]),
    ]

    and_neuron.learn_all(training_data)

    # 結果確認
    print("論理積回路として動作する:")

    test_1 = [0, 1]
    result_1 = and_neuron.thought(test_1)
    print(f"Input: {test_1} -> {result_1}")  # → 0

    test_2 = [1, 1]
    result_2 = and_neuron.thought(test_2)
    print(f"Input: {test_2} -> {result_2}")  # → 1