機械学習アルゴリズムの演習（2）：PythonとTensorflowはそれぞれ単純なニューラルネットワークを実装します

Tensorflowは3層ニューラルネットワークを実装しています

import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

#生成数据
np.random.seed(12)
num_observations = 5000
#高斯分布数据
x1 = np.random.multivariate_normal([0, 0], [[2, .75],[.75, 2]], num_observations)
x2 = np.random.multivariate_normal([1, 4], [[1, .75],[.75, 1]], num_observations)
x3 = np.random.multivariate_normal([2, 8], [[0, .75],[.75, 0]], num_observations)

simulated_separableish_features = np.vstack((x1, x2, x3)).astype(np.float32)
simulated_labels = np.hstack((np.zeros(num_observations),
                np.ones(num_observations), np.ones(num_observations) + 1))

plt.figure(figsize=(12,8))
plt.scatter(simulated_separableish_features[:, 0], simulated_separableish_features[:, 1],
            c = simulated_labels, alpha = .4)

データを準備する

Tensorflowは、各特徴ラベルを個別にエンコードされたベクトルにしたいので、シミュレーションラベルを再フォーマットします。
モデルのデータへの一般化を評価するためのトレーニングとテストセットを作成します。

labels_onehot = np.zeros((simulated_labels.shape[0], 3)).astype(int)
labels_onehot[np.arange(len(simulated_labels)), simulated_labels.astype(int)] = 1

train_dataset, test_dataset, \
train_labels, test_labels = train_test_split(
    simulated_separableish_features, labels_onehot, test_size = .1, random_state = 12)

Tensorflowに基づくシンプルなニューラルネットワークの構築

入力層、非表示層（5ニューロン）および出力層

#隐含层单元数
hidden_nodes = 5
num_labels = train_labels.shape[1]
#批处理大小
batch_size = 100
num_features = train_dataset.shape[1]
#学习率
learning_rate = .01

graph = tf.Graph()
with graph.as_default():

    # 数据
    tf_train_dataset = tf.placeholder(tf.float32, shape = [None, num_features])
    tf_train_labels = tf.placeholder(tf.float32, shape = [None, num_labels])
    tf_test_dataset = tf.constant(test_dataset)

    # 权重和偏置
    layer1_weights = tf.Variable(tf.truncated_normal([num_features, hidden_nodes]))
    layer1_biases = tf.Variable(tf.zeros([hidden_nodes]))

    layer2_weights = tf.Variable(tf.truncated_normal([hidden_nodes, num_labels]))
    layer2_biases = tf.Variable(tf.zeros([num_labels]))

    # 三层的神经网络
    def three_layer_network(data):
        input_layer = tf.matmul(data, layer1_weights)
        hidden = tf.nn.relu(input_layer + layer1_biases)
        output_layer = tf.matmul(hidden, layer2_weights) + layer2_biases
        return output_layer

    # Model Scores
    model_scores = three_layer_network(tf_train_dataset)

    #损失值
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=model_scores, labels=tf_train_labels))

    # 优化器
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

    # 预测
    train_prediction = tf.nn.softmax(model_scores)
    test_prediction = tf.nn.softmax(three_layer_network(tf_test_dataset))

#定义准确率
def accuracy(predictions, labels):
    preds_correct_boolean =  np.argmax(predictions, 1) == np.argmax(labels, 1)
    correct_predictions = np.sum(preds_correct_boolean)
    accuracy = 100.0 * correct_predictions / predictions.shape[0]
    return accuracy

#开始训练
num_steps = 10001

with tf.Session(graph=graph) as session:
    tf.global_variables_initializer().run()
    for step in range(num_steps):
        offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
        minibatch_data = train_dataset[offset:(offset + batch_size), :]
        minibatch_labels = train_labels[offset:(offset + batch_size)]

        feed_dict = {tf_train_dataset : minibatch_data, tf_train_labels : minibatch_labels}

        _, l, predictions = session.run(
            [optimizer, loss, train_prediction], feed_dict = feed_dict
            )

        if step % 1000 == 0:
            print( 'Minibatch loss at step {0}: {1}'.format(step, l))

    print ('Test accuracy: {0}%'.format(accuracy(test_prediction.eval(), test_labels)))

测试集准确率：
2.359832763671875：ステップ0でMinibatch損失
0.2925601303577423：ステップ1000においてMinibatch損失
0.17718014121055603：ステップ2000においてMinibatch損失
0.16064541041851044：ステップ3000においてMinibatch損失
0.14011278748512268：ステップ4000においてMinibatch損失
0.12705211341381073：ステップ5000においてMinibatch損失
Minibatch損失でステップ6000：0.12798947095870972
ステップ7000での
ミニバッチ損失：0.08461454510688782 ステップ8000での
ミニバッチ損失：0.07145170122385025ステップ9000での
ミニバッチ損失：0.09841442108154297ステップ10000でのミニバッチ損失：0.09960160404443741
テスト精度：96.4％

ニューラルネットワークの動作原理を深く理解するために、Tensorflowを使用して直接ニューラルネットワークを構築せずに、ゼロからニューラルネットワークを構築することを選択します

1.ネットワーク構造

2.パラメータ設定と機能選択

#隐含层单元数
hidden_nodes = 5
num_features = train_dataset.shape[1]
num_labels = train_labels.shape[1]

#初始化权重和偏置
layer1_weights_array = np.random.normal(0, 1, [num_features, hidden_nodes]) 
layer1_biases_array = np.zeros((1, hidden_nodes))

layer2_weights_array = np.random.normal(0, 1, [hidden_nodes, num_labels]) 
layer2_biases_array = np.zeros((1, num_labels))

3.隠れ層活性化機能

#ReLU激活函数 
def relu_activation(data_array):
    return np.maximum(data_array, 0)

4.出力層のソフトマックス機能

def softmax(output_array):
    logits_exp = np.exp(output_array.astype(np.float32))
    return logits_exp / np.sum(logits_exp, axis = 1, keepdims = True)

5.クロスエントロピー損失関数

def cross_entropy_softmax_loss_array(softmax_probs_array, y_onehot):
    indices = np.argmax(y_onehot, axis = 1).astype(int)
    predicted_probability = softmax_probs_array[np.arange(len(softmax_probs_array)), indices]
    log_preds = np.log(predicted_probability)
    loss = -1.0 * np.sum(log_preds) / len(log_preds)
    return loss

L2正則化を使用して過剰適合を回避する

def regularization_L2_softmax_loss(reg_lambda, weight1, weight2):
    weight1_loss = 0.5 * reg_lambda * np.sum(weight1 * weight1)
    weight2_loss = 0.5 * reg_lambda * np.sum(weight2 * weight2)
    return weight1_loss + weight2_loss

3.逆伝播におけるトレーニングプロセスとパラメーターの更新

data = train_dataset
labels = train_labels

hidden_nodes = 5
num_labels = labels.shape[1]
num_features = data.shape[1]
learning_rate = .01
reg_lambda = .01

for step in range(5001):

    input_layer = np.dot(data, layer1_weights_array)
    hidden_layer = relu_activation(input_layer + layer1_biases_array)
    output_layer = np.dot(hidden_layer, layer2_weights_array) + layer2_biases_array
    output_probs = softmax(output_layer)

    loss = cross_entropy_softmax_loss_array(output_probs, labels)
    loss += regularization_L2_softmax_loss(reg_lambda, layer1_weights_array, layer2_weights_array)
    #误差反向传播
    output_error_signal = (output_probs - labels) / output_probs.shape[0]

    error_signal_hidden = np.dot(output_error_signal, layer2_weights_array.T) 
    error_signal_hidden[hidden_layer <= 0] = 0
    #计算梯度
    gradient_layer2_weights = np.dot(hidden_layer.T, output_error_signal)
    gradient_layer2_bias = np.sum(output_error_signal, axis = 0, keepdims = True)

    gradient_layer1_weights = np.dot(data.T, error_signal_hidden)
    gradient_layer1_bias = np.sum(error_signal_hidden, axis = 0, keepdims = True)

    gradient_layer2_weights += reg_lambda * layer2_weights_array
    gradient_layer1_weights += reg_lambda * layer1_weights_array
    #权重以及阈值更新
    layer1_weights_array -= learning_rate * gradient_layer1_weights
    layer1_biases_array -= learning_rate * gradient_layer1_bias
    layer2_weights_array -= learning_rate * gradient_layer2_weights
    layer2_biases_array -= learning_rate * gradient_layer2_bias

    if step % 500 == 0:
            print ('Loss at step {0}: {1}'.format(step, loss))

损失值：
ステップ0における損失：4.032443656487327
ステップ500での損失：0.5982357882997374
ステップ1000での損失：0.48772191490059846
ステップ1500での損失：0.42160431744565374
ステップ2000での損失：0.3729775782531113
ステップ2500での損失：0.3371694890407784
ステップ3000での損失：0.3097917830393212
ステップ3500での損失。 0.2884371558611799
ステップ4000での
損失：0.27115358549993746 ステップ4500での
損失：0.2566227146885002 ステップ5000での損失：0.24359782822937304
収集された基準率：

input_layer = np.dot(test_dataset, layer1_weights_array)
hidden_layer = relu_activation(input_layer + layer1_biases_array)
scores = np.dot(hidden_layer, layer2_weights_array) + layer2_biases_array
probs = softmax(scores)
print (accuracy(probs, test_labels))

95.4666666667

4.予測結果：

labels_flat = np.argmax(test_labels, axis = 1)
predictions = np.argmax(probs, axis = 1)
plt.figure(figsize = (12, 8))
plt.scatter(test_dataset[:, 0], test_dataset[:, 1], c = predictions == labels_flat - 1, alpha = .8, s = 50)

青は正しい予測のデータを表し、赤は誤った予測のデータを表します