冒頭の謝罪

まず、タイトルをつけてくれたgpt4から一言あるそうです。

「先程のタイトルについて、多少大袈裟に感じる方もいらっしゃるかもしれません。そう感じた方々には、心からお詫び申し上げます。私たちの意図は、AI技術の進歩と可能性について興味を引きつけることであり、誤解や過剰な期待を生むことではありません。今後は、より適切で現実的な表現を心がけて参ります。どうぞご理解いただけますと幸いです。」

何をさせたか？

既存のよく使われるライブラリを使わず、numpyだけでirisの学習をさせた結果、tensorflowの入門コードを超えたというお話。

tensorflow

tensorflowの入門コード
https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ja/tutorials/quickstart/beginner.ipynb

これを実行すると
model.evaluate(x_test, y_test, verbose=2)
313/313 - 1s - loss: 0.0702 - accuracy: 0.9784 - 650ms/epoch - 2ms/step
と出てきた。

正解率97.84%。かなり高い。

ChatGPT and Numpy

さて今度はgpt4のターン。

numpyとirisデータを使用して、予測プログラムを作成して。初心者用。

以下のコードが出てきた。

iris_multiclass_logistic_regression.py

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

# Define the sigmoid function and its derivative
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def sigmoid_derivative(z):
    return sigmoid(z) * (1 - sigmoid(z))

# Load the Iris dataset
iris = load_iris()
data = iris.data
labels = iris.target

# One-hot encode the labels
labels_encoded = np.eye(iris.target_names.size)[labels]

# Preprocess the data
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data)

# Split the data into training and testing sets
train_data, test_data, train_labels, test_labels = train_test_split(
    data_scaled, labels_encoded, test_size=0.2, random_state=42
)

# Initialize the logistic regression model
input_size = train_data.shape[1]
output_size = train_labels.shape[1]
learning_rate = 0.1
epochs = 200

weights = np.random.randn(input_size, output_size)

# Train the logistic regression model
for epoch in range(epochs):
    # Forward pass
    z = np.dot(train_data, weights)
    predictions = sigmoid(z)

    # Backward pass
    error = predictions - train_labels
    gradients = np.dot(train_data.T, error * sigmoid_derivative(z))
    weights -= learning_rate * gradients / train_data.shape[0]

# Make predictions on the test set
test_z = np.dot(test_data, weights)
test_predictions = sigmoid(test_z)
test_predictions = np.argmax(test_predictions, axis=1)

# Evaluate the model's accuracy
accuracy = accuracy_score(test_labels.argmax(axis=1), test_predictions)
print(f"Test accuracy: {accuracy}")

それっぽいの出てきた、と思ったが流してみると

Test accuracy: 0.6

この結果を伝えると、改善案を出してきた。

すみません、この簡単なロジスティック回帰モデルでは性能が十分でないことがあります。アイリスデータセットは線形分離可能であるため、モデルのパラメータを調整して性能を向上させることができるかもしれません。以下は、パラメータを調整した例です。

ChatGPTのターン2

iris_softmax_logistic_regression.py

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

# Define the softmax function and its derivative
def softmax(z):
    e_z = np.exp(z - np.max(z, axis=1, keepdims=True))
    return e_z / np.sum(e_z, axis=1, keepdims=True)

# Load the Iris dataset
iris = load_iris()
data = iris.data
labels = iris.target

# One-hot encode the labels
labels_encoded = np.eye(iris.target_names.size)[labels]

# Preprocess the data
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data)

# Split the data into training and testing sets
train_data, test_data, train_labels, test_labels = train_test_split(
    data_scaled, labels_encoded, test_size=0.2, random_state=42
)

# Initialize the logistic regression model
input_size = train_data.shape[1]
output_size = train_labels.shape[1]
learning_rate = 0.1
epochs = 5000

weights = np.random.randn(input_size, output_size)

# Train the logistic regression model
for epoch in range(epochs):
    # Forward pass
    z = np.dot(train_data, weights)
    predictions = softmax(z)

    # Backward pass
    error = predictions - train_labels
    gradients = np.dot(train_data.T, error)
    weights -= learning_rate * gradients / train_data.shape[0]

# Make predictions on the test set
test_z = np.dot(test_data, weights)
test_predictions = softmax(test_z)
test_predictions = np.argmax(test_predictions, axis=1)

# Evaluate the model's accuracy
accuracy = accuracy_score(test_labels.argmax(axis=1), test_predictions)
print(f"Test accuracy: {accuracy}")

結果
そのまま流した版

Test accuracy: 0.9

epochs = 1500に書き換えた版

Test accuracy: 0.9333333333333333

93.3%って結構凄くね？

結果を伝えると、

すみません、情報を正しく理解できていませんでした。Test accuracyが0.9ということであれば、この簡単なロジスティック回帰モデルでもアイリスデータセットに対して良好な結果が得られています。この結果は、線形分類器でもデータセットを適切に分類できることを示しています。

ただし、さらに高い精度を求める場合や、他のデータセットに適用する場合には、より高度なモデル（ニューラルネットワークやSVMなど）やアンサンブル学習を検討することも検討してください。また、モデルの選択や特徴量エンジニアリング、データの前処理方法によっても精度が向上することがあります。

ニューラルネットワーク、サポートベクターマシン (SVM)、およびアンサンブル学習は、機械学習において高い精度を達成するために使用される一般的な手法です。

ニューラルネットワーク:
ニューラルネットワークは、複数の層から構成されるモデルで、人間の脳のニューロンの接続を模倣しています。ニューラルネットワークはディープラーニングの基盤であり、画像認識、自然言語処理、音声認識などの複雑なタスクで高い精度を達成しています。畳み込みニューラルネットワーク (CNN) やリカレントニューラルネットワーク (RNN) は、それぞれ画像データや時系列データの処理に特化したニューラルネットワークの例です。
サポートベクターマシン (SVM):
SVMは、分類または回帰タスクに使用される教師あり学習アルゴリズムです。SVMは、データポイントを最も適切に分割する境界線（ハイパープレーン）を見つけることで機能します。SVMはカーネルトリックを使用して、線形分離不可能なデータを高次元空間に変換し、より良い境界線を見つけることができます。
アンサンブル学習:
アンサンブル学習は、複数の学習アルゴリズムまたはモデルを組み合わせることで、より優れた予測性能を達成する手法です。アンサンブル学習の主なアプローチには、バギング、ブースティング、スタッキングがあります。

僕

ニューラルネットワークをnumpyで

risデータセットを使ってニューラルネットワークを訓練するには、以下の手順に従います。

データの読み込みと前処理
ニューラルネットワークの構造を定義
学習プロセスの実装
モデルの評価
以下の例では、numpyを使ってニューラルネットワークを実装し、Irisデータセットで訓練します。

ChatGPTのターン3

iris_neural_network.py

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score

# Activation function: Sigmoid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Derivative of sigmoid
def sigmoid_derivative(x):
    return x * (1 - x)

# One-hot encoding
def one_hot_encode(y, num_classes):
    return np.eye(num_classes)[y]

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Standardize the input data
scaler = StandardScaler()
X = scaler.fit_transform(X)

# One-hot encode the output labels
y = one_hot_encode(y, 3)

# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Define the network structure
input_nodes = 4
hidden_nodes = 5
output_nodes = 3

# Initialize weights randomly
weights_input_hidden = np.random.rand(input_nodes, hidden_nodes)
weights_hidden_output = np.random.rand(hidden_nodes, output_nodes)

# Define the learning rate
learning_rate = 0.1

# Number of training iterations
epochs = 10000

# Training loop
for epoch in range(epochs):
    # Forward pass
    hidden_layer_input = np.dot(X_train, weights_input_hidden)
    hidden_layer_output = sigmoid(hidden_layer_input)

    output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
    output_layer_output = sigmoid(output_layer_input)

    # Calculate the error
    output_error = y_train - output_layer_output

    # Backpropagation
    output_delta = output_error * sigmoid_derivative(output_layer_output)

    hidden_error = output_delta.dot(weights_hidden_output.T)
    hidden_delta = hidden_error * sigmoid_derivative(hidden_layer_output)

    # Update the weights
    weights_hidden_output += hidden_layer_output.T.dot(output_delta) * learning_rate
    weights_input_hidden += X_train.T.dot(hidden_delta) * learning_rate

# Test the trained network
hidden_layer_input = np.dot(X_test, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)
output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
output_layer_output = sigmoid(output_layer_input)

# Convert output probabilities to class labels
predictions = np.argmax(output_layer_output, axis=1)
y_test_labels = np.argmax(y_test, axis=1)

# Calculate the accuracy
accuracy = accuracy_score(y_test_labels, predictions)
print("Test accuracy:", accuracy)

なんと・・・

Test accuracy: 1.0

tensorflowの入門編をChatGPTから出したnumpyコードで超えてしまった
というお話でした。

進化の可能性について

そのうち、言語なんかも作成してしまうかもしれない。
そうなったら別に人間が読めなくても構わない。
AIから直接PCに命令出せるようになったら凄い勢いでほとんどの処理が終えられそうな気がしてきた。

※余談：
最初の正解率60%のコードはepochを200 -> 2000にしてやったら0.9になった。