TensorFlow 机器学习秘籍第二版：6~8（2）-阿里云开发者社区

TensorFlow 机器学习秘籍第二版：6~8（1）https://developer.aliyun.com/article/1426837

为了帮助实现可重复性，我们现在需要为 NumPy 和 TensorFlow 设置随机种子。然后我们声明我们的批量大小如下：

seed = 4 
tf.set_random_seed(seed) 
np.random.seed(seed) 
batch_size = 100

接下来，我们将数据分成 80-20 训练测试分组。在此之后，我们需要正则化我们的输入特征，使它们在 0 到 1 之间，具有最小 - 最大缩放比例，如下所示：

train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False) 
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices))) 
x_vals_train = x_vals[train_indices] 
x_vals_test = x_vals[test_indices] 
y_vals_train = y_vals[train_indices] 
y_vals_test = y_vals[test_indices] 
# Normalize by column (min-max norm)
def normalize_cols(m, col_min=np.array([None]), col_max=np.array([None])):
    if not col_min[0]:
        col_min = m.min(axis=0)
    if not col_max[0]:
        col_max = m.max(axis=0)
    return (m-col_min) / (col_max - col_min), col_min, col_max
x_vals_train, train_min, train_max = np.nan_to_num(normalize_cols(x_vals_train)) 
x_vals_test, _, _ = np.nan_to_num(normalize_cols(x_vals_test), train_min, train_max)

归一化输入特征是一种常见的特征转换，尤其适用于神经网络。如果我们的数据以 0 到 1 的中心为激活函数，它将有助于收敛。

由于我们有多个层具有相似的初始化变量，我们现在需要创建一个函数来初始化权重和偏差。我们使用以下代码执行此操作：

def init_weight(shape, st_dev): 
    weight = tf.Variable(tf.random_normal(shape, stddev=st_dev)) 
    return weight
def init_bias(shape, st_dev): 
    bias = tf.Variable(tf.random_normal(shape, stddev=st_dev)) 
    return bias

我们现在需要初始化占位符。将有八个输入特征和一个输出，出生重量以克为单位，如下所示：

x_data = tf.placeholder(shape=[None, 8], dtype=tf.float32) 
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

对于所有三个隐藏层，完全连接的层将使用三次。为了防止重复代码，我们将在初始化模型时创建一个层函数，如下所示：

def fully_connected(input_layer, weights, biases): 
    layer = tf.add(tf.matmul(input_layer, weights), biases) 
    return tf.nn.relu(layer)

现在是时候创建我们的模型了。对于每个层（和输出层），我们将初始化权重矩阵，偏置矩阵和完全连接的层。对于此示例，我们将使用大小为 25，10 和 3 的隐藏层：

我们使用的模型将有 522 个变量适合。为了得到这个数字，我们可以看到数据和第一个隐藏层之间有8*25 +25=225变量。如果我们以这种方式继续添加它们，我们将有225+260+33+4=522变量。这远远大于我们在逻辑回归模型中使用的九个变量。

# Create second layer (25 hidden nodes) 
weight_1 = init_weight(shape=[8, 25], st_dev=10.0) 
bias_1 = init_bias(shape=[25], st_dev=10.0) 
layer_1 = fully_connected(x_data, weight_1, bias_1) 
# Create second layer (10 hidden nodes) 
weight_2 = init_weight(shape=[25, 10], st_dev=10.0) 
bias_2 = init_bias(shape=[10], st_dev=10.0) 
layer_2 = fully_connected(layer_1, weight_2, bias_2) 
# Create third layer (3 hidden nodes) 
weight_3 = init_weight(shape=[10, 3], st_dev=10.0) 
bias_3 = init_bias(shape=[3], st_dev=10.0) 
layer_3 = fully_connected(layer_2, weight_3, bias_3) 
# Create output layer (1 output value) 
weight_4 = init_weight(shape=[3, 1], st_dev=10.0)   
bias_4 = init_bias(shape=[1], st_dev=10.0) 
final_output = fully_connected(layer_3, weight_4, bias_4)

我们现在将使用 L1 损失函数（绝对值），声明我们的优化器（使用 Adam 优化），并按如下方式初始化变量：

loss = tf.reduce_mean(tf.abs(y_target - final_output)) 
my_opt = tf.train.AdamOptimizer(0.05) 
train_step = my_opt.minimize(loss) 
init = tf.global_variables_initializer()
sess.run(init)

虽然我们在前一步骤中用于 Adam 优化函数的学习率是 0.05，但有研究表明较低的学习率始终产生更好的结果。对于这个秘籍，由于数据的一致性和快速收敛的需要，我们使用了更大的学习率。

接下来，我们需要训练我们的模型进行 200 次迭代。我们还将包含存储train和test损失的代码，选择随机批量大小，并每 25 代打印一次状态，如下所示：

# Initialize the loss vectors 
loss_vec = [] 
test_loss = [] 
for i in range(200): 
    # Choose random indices for batch selection 
    rand_index = np.random.choice(len(x_vals_train), size=batch_size) 
    # Get random batch 
    rand_x = x_vals_train[rand_index] 
    rand_y = np.transpose([y_vals_train[rand_index]]) 
    # Run the training step 
    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) 
    # Get and store the train loss 
    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) 
    loss_vec.append(temp_loss) 
    # Get and store the test loss 
    test_temp_loss = sess.run(loss, feed_dict={x_data: x_vals_test, y_target: np.transpose([y_vals_test])}) 
    test_loss.append(test_temp_loss) 
    if (i+1)%25==0: 
        print('Generation: ' + str(i+1) + '. Loss = ' + str(temp_loss))

上一步应该产生以下输出：

Generation: 25\. Loss = 5922.52 
Generation: 50\. Loss = 2861.66 
Generation: 75\. Loss = 2342.01 
Generation: 100\. Loss = 1880.59 
Generation: 125\. Loss = 1394.39 
Generation: 150\. Loss = 1062.43 
Generation: 175\. Loss = 834.641 
Generation: 200\. Loss = 848.54

以下是使用matplotlib绘制训练和测试损失的代码片段：

plt.plot(loss_vec, 'k-', label='Train Loss') 
plt.plot(test_loss, 'r--', label='Test Loss') 
plt.title('Loss per Generation') 
plt.xlabel('Generation') 
plt.ylabel('Loss') 
plt.legend(loc='upper right') 
plt.show()

我们通过绘制下图来继续秘籍：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u23ehDtt-1681566911066)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/2a730c9a-4bf5-4244-bfef-73ccca82eaa7.png)]

图 6：在上图中，我们绘制了我们训练的神经网络的训练和测试损失，以克数表示出生体重。请注意，大约 30 代后我们已经达到了良好的模型

我们现在想将我们的出生体重结果与我们之前的后勤结果进行比较。使用逻辑线性回归（如第 3 章中的实现逻辑回归秘籍，线性回归），我们在数千次迭代后获得了大约 60% 的准确率结果。为了将其与我们在上一节中所做的进行比较，我们需要输出训练并测试回归结果，并通过创建指标（如果它们高于或低于 2,500 克）将其转换为分类结果。要找出模型的准确率，我们需要使用以下代码：

actuals = np.array([x[1] for x in birth_data]) 
test_actuals = actuals[test_indices] 
train_actuals = actuals[train_indices] 
test_preds = [x[0] for x in sess.run(final_output, feed_dict={x_data: x_vals_test})] 
train_preds = [x[0] for x in sess.run(final_output, feed_dict={x_data: x_vals_train})] 
test_preds = np.array([1.0 if x<2500.0 else 0.0 for x in test_preds]) 
train_preds = np.array([1.0 if x<2500.0 else 0.0 for x in train_preds]) 
# Print out accuracies 
test_acc = np.mean([x==y for x,y in zip(test_preds, test_actuals)]) 
train_acc = np.mean([x==y for x,y in zip(train_preds, train_actuals)]) 
print('On predicting the category of low birthweight from regression output (<2500g):') 
print('Test Accuracy: {}'.format(test_acc)) 
print('Train Accuracy: {}'.format(train_acc))

上一步应该产生以下输出：

Test Accuracy: 0.631578947368421 
Train Accuracy: 0.7019867549668874

工作原理

在这个秘籍中，我们创建了一个回归神经网络，其中包含三个完全连接的隐藏层，以预测低出生体重数据集的出生体重。当将其与物流输出进行比较以预测高于或低于 2,500 克时，我们获得了类似的结果并且在更少的几代中实现了它们。在下一个方案中，我们将尝试通过使其成为多层逻辑类神经网络来改进逻辑回归。

改进线性模型的预测

在前面的秘籍中，我们注意到我们拟合的参数数量远远超过等效的线性模型。在这个秘籍中，我们将尝试通过使用神经网络来改进我们的低出生体重的逻辑模型。

准备

对于这个秘籍，我们将加载低出生体重数据，并使用神经网络与两个隐藏的完全连接的层与 sigmoid 激活，以适应低出生体重的概率。

操作步骤

我们按如下方式处理秘籍：

我们首先加载库并初始化我们的计算图，如下所示：

import matplotlib.pyplot as plt 
import numpy as np 
import tensorflow as tf 
import requests 
sess = tf.Session()

接下来，我们按照前面的秘籍加载，提取和标准化我们的数据，除了在这里我们将使用低出生体重指示变量作为我们的目标而不是实际出生体重，如下所示：

# Name of data file
birth_weight_file = 'birth_weight.csv'
birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master' \
                '/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'
# Download data and create data file if file does not exist in current directory
if not os.path.exists(birth_weight_file):
    birth_file = requests.get(birthdata_url)
    birth_data = birth_file.text.split('\r\n')
    birth_header = birth_data[0].split('\t')
    birth_data = [[float(x) for x in y.split('\t') if len(x) >= 1]
                  for y in birth_data[1:] if len(y) >= 1]
    with open(birth_weight_file, "w") as f:
        writer = csv.writer(f)
        writer.writerows([birth_header])
        writer.writerows(birth_data) 
# read birth weight data into memory
birth_data = []
with open(birth_weight_file, newline='') as csvfile:
    csv_reader = csv.reader(csvfile)
    birth_header = next(csv_reader)
    for row in csv_reader:
        birth_data.append(row)
birth_data = [[float(x) for x in row] for row in birth_data]
# Pull out target variable
y_vals = np.array([x[0] for x in birth_data])
# Pull out predictor variables (not id, not target, and not birthweight)
x_vals = np.array([x[1:8] for x in birth_data])
train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False) 
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices))) 
x_vals_train = x_vals[train_indices] 
x_vals_test = x_vals[test_indices] 
y_vals_train = y_vals[train_indices] 
y_vals_test = y_vals[test_indices] 
def normalize_cols(m, col_min=np.array([None]), col_max=np.array([None])):
    if not col_min[0]:
        col_min = m.min(axis=0)
    if not col_max[0]:
        col_max = m.max(axis=0)
    return (m - col_min) / (col_max - col_min), col_min, col_max
x_vals_train, train_min, train_max = np.nan_to_num(normalize_cols(x_vals_train))
x_vals_test, _, _ = np.nan_to_num(normalize_cols(x_vals_test, train_min, train_max))

接下来，我们需要声明我们的批量大小和数据的占位符，如下所示：

batch_size = 90 
x_data = tf.placeholder(shape=[None, 7], dtype=tf.float32) 
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

如前所述，我们现在需要声明在模型中初始化变量和层的函数。为了创建更好的逻辑函数，我们需要创建一个在输入层上返回逻辑层的函数。换句话说，我们将使用完全连接的层并为每个层返回一个 sigmoid 元素。重要的是要记住我们的损失函数将包含最终的 sigmoid，因此我们要在最后一层指定我们不会返回输出的 sigmoid，如下所示：

def init_variable(shape): 
    return tf.Variable(tf.random_normal(shape=shape)) 
# Create a logistic layer definition 
def logistic(input_layer, multiplication_weight, bias_weight, activation = True): 
    linear_layer = tf.add(tf.matmul(input_layer, multiplication_weight), bias_weight) 
    if activation: 
        return tf.nn.sigmoid(linear_layer) 
    else: 
        return linear_layer

现在我们将声明三个层（两个隐藏层和一个输出层）。我们将首先为每个层初始化权重和偏差矩阵，并按如下方式定义层操作：

# First logistic layer (7 inputs to 14 hidden nodes) 
A1 = init_variable(shape=[7,14]) 
b1 = init_variable(shape=[14]) 
logistic_layer1 = logistic(x_data, A1, b1)
# Second logistic layer (14 hidden inputs to 5 hidden nodes) 
A2 = init_variable(shape=[14,5]) 
b2 = init_variable(shape=[5]) 
logistic_layer2 = logistic(logistic_layer1, A2, b2) 
# Final output layer (5 hidden nodes to 1 output) 
A3 = init_variable(shape=[5,1]) 
b3 = init_variable(shape=[1]) 
final_output = logistic(logistic_layer2, A3, b3, activation=False)

接下来，我们声明我们的损失（交叉熵）和优化算法，并初始化以下变量：

# Create loss function 
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=final_output, labels=y_target)) 
# Declare optimizer 
my_opt = tf.train.AdamOptimizer(learning_rate = 0.002) 
train_step = my_opt.minimize(loss) 
# Initialize variables 
init = tf.global_variables_initializer() 
sess.run(init)

交叉熵是一种测量概率之间距离的方法。在这里，我们想要测量确定性（0 或 1）与模型概率（0 < x < 1）之间的差异。 TensorFlow 使用内置的 sigmoid 函数实现交叉熵。这也是超参数调整的一部分，因为我们更有可能找到最佳的损失函数，学习率和针对当前问题的优化算法。为简洁起见，我们不包括超参数调整。

为了评估和比较我们的模型与以前的模型，我们需要在图上创建预测和精度操作。这将允许我们提供整个测试集并确定准确率，如下所示：

prediction = tf.round(tf.nn.sigmoid(final_output)) 
predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32) 
accuracy = tf.reduce_mean(predictions_correct)

我们现在准备开始我们的训练循环。我们将训练 1500 代并保存模型损失并训练和测试精度以便以后进行绘图。我们的训练循环使用以下代码启动：

# Initialize loss and accuracy vectors loss_vec = [] train_acc = [] test_acc = [] 
for i in range(1500): 
    # Select random indicies for batch selection 
    rand_index = np.random.choice(len(x_vals_train), size=batch_size) 
    # Select batch 
    rand_x = x_vals_train[rand_index] 
    rand_y = np.transpose([y_vals_train[rand_index]]) 
    # Run training step 
    sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) 
    # Get training loss 
    temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) 
    loss_vec.append(temp_loss) 
    # Get training accuracy 
    temp_acc_train = sess.run(accuracy, feed_dict={x_data: x_vals_train, y_target: np.transpose([y_vals_train])}) 
    train_acc.append(temp_acc_train) 
    # Get test accuracy 
    temp_acc_test = sess.run(accuracy, feed_dict={x_data: x_vals_test, y_target: np.transpose([y_vals_test])}) 
    test_acc.append(temp_acc_test) 
    if (i+1)%150==0: 
        print('Loss = '' + str(temp_loss))

上一步应该产生以下输出：

Loss = 0.696393 
Loss = 0.591708 
Loss = 0.59214 
Loss = 0.505553 
Loss = 0.541974 
Loss = 0.512707 
Loss = 0.590149 
Loss = 0.502641 
Loss = 0.518047 
Loss = 0.502616

以下代码块说明了如何使用matplotlib绘制交叉熵损失以及训练和测试集精度：

# Plot loss over time 
plt.plot(loss_vec, 'k-') 
plt.title('Cross Entropy Loss per Generation') 
plt.xlabel('Generation') 
plt.ylabel('Cross Entropy Loss') 
plt.show() 
# Plot train and test accuracy 
plt.plot(train_acc, 'k-', label='Train Set Accuracy') 
plt.plot(test_acc, 'r--', label='Test Set Accuracy') 
plt.title('Train and Test Accuracy') 
plt.xlabel('Generation') 
plt.ylabel('Accuracy') 
plt.legend(loc='lower right') 
plt.show()

我们得到每代交叉熵损失的图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OsOLskCG-1681566911067)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/c3e4b9e2-8d06-45d0-b19f-890dbcef6c4a.png)]

图 7：超过 1500 次迭代的训练损失

在大约 50 代之内，我们已经达到了良好的模式。在我们继续训练时，我们可以看到在剩余的迭代中获得的很少，如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z7bhUPKq-1681566911067)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/77fdb4ad-5bdf-4013-9768-1beca691cf5b.png)]

图 8：训练组和测试装置的准确率

正如您在上图中所看到的，我们很快就找到了一个好模型。

工作原理

在考虑使用神经网络建模数据时，您必须考虑优缺点。虽然我们的模型比以前的模型融合得更快，并且可能具有更高的准确率，但这需要付出代价；我们正在训练更多的模型变量，并且更有可能过拟合。为了检查是否发生过拟合，我们会查看测试和训练集的准确率。如果训练集的准确率继续增加而测试集的精度保持不变或甚至略微下降，我们可以假设过拟合正在发生。

为了对抗欠拟合，我们可以增加模型深度或训练模型以进行更多迭代。为了解决过拟合问题，我们可以为模型添加更多数据或添加正则化技术。

同样重要的是要注意我们的模型变量不像线性模型那样可解释。神经网络模型具有比线性模型更难解释的系数，因为它们解释了模型中特征的重要性。

学习玩井字棋

为了展示适应性神经网络的可用性，我们现在将尝试使用神经网络来学习井字棋的最佳动作。我们将知道井字棋是一种确定性游戏，并且最佳动作已经知道。

准备

为了训练我们的模型，我们将使用一系列的棋盘位置，然后对许多不同的棋盘进行最佳的最佳响应。我们可以通过仅考虑在对称性方面不同的棋盘位置来减少要训练的棋盘数量。井字棋棋盘的非同一性变换是 90 度，180 度和 270 度的旋转（在任一方向上），水平反射和垂直反射。鉴于这个想法，我们将使用最佳移动的候选棋盘名单，应用两个随机变换，然后将其输入神经网络进行学习。

由于井字棋是一个确定性的游戏，值得注意的是，无论谁先走，都应该赢或抽。我们希望能够以最佳方式响应我们的动作并最终获得平局的模型。

如果我们将X标注为 1，将O标注为 -1，将空格标注为 0，则下图说明了我们如何将棋盘位置和最佳移动视为一行数据：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-17St0ZeF-1681566911067)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/e71cb35d-172e-4f0b-bc3b-e50bd46ca956.png)]Figure 9: Here, we illustrate how to consider a board and an optimal move as a row of data. Note that X = 1, O = -1, and empty spaces are 0, and we start indexing at 0

除了模型损失，要检查我们的模型如何执行，我们将做两件事。我们将执行的第一项检查是从训练集中删除位置和最佳移动行。这将使我们能够看到神经网络模型是否可以推广它以前从未见过的移动。我们将评估模型的第二种方法是在最后实际对抗它。

可以在此秘籍的 GitHub 目录和 Packt 仓库中找到可能的棋盘列表和最佳移动。

操作步骤

我们按如下方式处理秘籍：

我们需要从为此脚本加载必要的库开始，如下所示：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import csv 
import random 
import numpy as np 
import random

接下来，我们声明以下批量大小来训练我们的模型：

batch_size = 50

为了使棋盘更容易可视化，我们将创建一个输出带X和O的井字棋棋盘的函数。这是通过以下代码完成的：

def print_board(board):
    symbols = ['O', ' ', 'X']
    board_plus1 = [int(x) + 1 for x in board]
    board_line1 = ' {} | {} | {}'.format(symbols[board_plus1[0]],
                                         symbols[board_plus1[1]],
                                         symbols[board_plus1[2]])
    board_line2 = ' {} | {} | {}'.format(symbols[board_plus1[3]],
                                         symbols[board_plus1[4]],
                                         symbols[board_plus1[5]])
    board_line3 = ' {} | {} | {}'.format(symbols[board_plus1[6]],
                                         symbols[board_plus1[7]],
                                         symbols[board_plus1[8]])
    print(board_line1)
    print('___________')
    print(board_line2)
    print('___________')
    print(board_line3)

现在我们必须创建一个函数，它将返回一个新的棋盘和一个转换下的最佳响应位置。这是通过以下代码完成的：

def get_symmetry(board, response, transformation): 
    ''' 
    :param board: list of integers 9 long: 
     opposing mark = -1 
     friendly mark = 1 
     empty space = 0 
    :param transformation: one of five transformations on a board: 
     rotate180, rotate90, rotate270, flip_v, flip_h 
    :return: tuple: (new_board, new_response) 
    ''' 
    if transformation == 'rotate180': 
        new_response = 8 - response 
        return board[::-1], new_response 
    elif transformation == 'rotate90': 
        new_response = [6, 3, 0, 7, 4, 1, 8, 5, 2].index(response) 
        tuple_board = list(zip(*[board[6:9], board[3:6], board[0:3]])) 
        return [value for item in tuple_board for value in item], new_response 
    elif transformation == 'rotate270': 
        new_response = [2, 5, 8, 1, 4, 7, 0, 3, 6].index(response) 
        tuple_board = list(zip(*[board[0:3], board[3:6], board[6:9]]))[::-1] 
        return [value for item in tuple_board for value in item], new_response 
    elif transformation == 'flip_v': 
        new_response = [6, 7, 8, 3, 4, 5, 0, 1, 2].index(response) 
        return board[6:9] +  board[3:6] + board[0:3], new_response 
    elif transformation == 'flip_h': 
    # flip_h = rotate180, then flip_v 
        new_response = [2, 1, 0, 5, 4, 3, 8, 7, 6].index(response) 
        new_board = board[::-1] 
        return new_board[6:9] +  new_board[3:6] + new_board[0:3], new_response 
    else: 
        raise ValueError('Method not implmented.')

棋盘列表及其最佳响应位于目录中的.csv文件中，可从 github 仓库或 Packt 仓库获得。我们将创建一个函数，它将使用棋盘和响应加载文件，并将其存储为元组列表，如下所示：

def get_moves_from_csv(csv_file): 
    ''' 
    :param csv_file: csv file location containing the boards w/ responses 
    :return: moves: list of moves with index of best response 
    ''' 
    moves = [] 
    with open(csv_file, 'rt') as csvfile: 
        reader = csv.reader(csvfile, delimiter=',') 
        for row in reader: 
            moves.append(([int(x) for x in row[0:9]],int(row[9]))) 
    return moves

现在我们需要将所有内容组合在一起以创建一个函数，该函数将返回随机转换的棋盘和响应。这是通过以下代码完成的：

def get_rand_move(moves, rand_transforms=2): 
    # This function performs random transformations on a board. 
    (board, response) = random.choice(moves) 
    possible_transforms = ['rotate90', 'rotate180', 'rotate270', 'flip_v', 'flip_h'] 
    for i in range(rand_transforms): 
        random_transform = random.choice(possible_transforms) 
        (board, response) = get_symmetry(board, response, random_transform) 
    return board, response

接下来，我们需要初始化图会话，加载数据，并创建一个训练集，如下所示：

sess = tf.Session() 
moves = get_moves_from_csv('base_tic_tac_toe_moves.csv') 
# Create a train set: 
train_length = 500 
train_set = [] 
for t in range(train_length): 
    train_set.append(get_rand_move(moves))

请记住，我们希望从我们的训练集中删除一个棋盘和一个最佳响应，以查看该模型是否可以推广以实现最佳移动。以下棋盘的最佳举措将是在第 6 号指数进行：

test_board = [-1, 0, 0, 1, -1, -1, 0, 0, 1] 
train_set = [x for x in train_set if x[0] != test_board]

我们现在可以创建函数来创建模型变量和模型操作。请注意，我们在以下模型中不包含softmax()激活函数，因为它包含在损失函数中：

def init_weights(shape): 
    return tf.Variable(tf.random_normal(shape)) 
def model(X, A1, A2, bias1, bias2): 
    layer1 = tf.nn.sigmoid(tf.add(tf.matmul(X, A1), bias1)) 
    layer2 = tf.add(tf.matmul(layer1, A2), bias2) 
    return layer2

现在我们需要声明我们的占位符，变量和模型，如下所示：

X = tf.placeholder(dtype=tf.float32, shape=[None, 9]) 
Y = tf.placeholder(dtype=tf.int32, shape=[None]) 
A1 = init_weights([9, 81]) 
bias1 = init_weights([81]) 
A2 = init_weights([81, 9]) 
bias2 = init_weights([9]) 
model_output = model(X, A1, A2, bias1, bias2)

接下来，我们需要声明我们的loss函数，它将是最终输出对率的平均 softmax（非标准化输出）。然后我们将声明我们的训练步骤和优化器。如果我们希望将来能够对抗我们的模型，我们还需要创建一个预测操作，如下所示：

loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=model_output, labels=Y)) 
train_step = tf.train.GradientDescentOptimizer(0.025).minimize(loss) 
prediction = tf.argmax(model_output, 1)

我们现在可以使用以下代码初始化变量并循环遍历神经网络的训练：

# Initialize variables 
init = tf.global_variables_initializer() 
sess.run(init) 
loss_vec = [] 
for i in range(10000): 
    # Select random indices for batch 
    rand_indices = np.random.choice(range(len(train_set)), batch_size, replace=False) 
    # Get batch 
    batch_data = [train_set[i] for i in rand_indices] 
    x_input = [x[0] for x in batch_data] 
    y_target = np.array([y[1] for y in batch_data]) 
    # Run training step 
    sess.run(train_step, feed_dict={X: x_input, Y: y_target}) 
    # Get training loss 
    temp_loss = sess.run(loss, feed_dict={X: x_input, Y: y_target}) 
    loss_vec.append(temp_loss)

if i%500==0: 
        print('iteration ' + str(i) + ' Loss: ' + str(temp_loss))

以下是绘制模型训练损失所需的代码：

plt.plot(loss_vec, 'k-', label='Loss') 
plt.title('Loss (MSE) per Generation') 
plt.xlabel('Generation') 
plt.ylabel('Loss') 
plt.show()

我们应该得到以下每代损失的绘图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sMTOOQmn-1681566911067)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/598821e9-0461-40de-bb4e-d6c72b9d6a28.png)]

图 10：超过 10,000 次迭代的井字棋训练组损失

在上图中，我们绘制了训练步骤的损失。

为了测试模型，我们需要看看它是如何在我们从训练集中删除的测试棋盘上执行的。我们希望模型可以推广和预测移动的最佳索引，这将是索引号 6。大多数时候模型将成功，如下所示：

test_boards = [test_board] 
feed_dict = {X: test_boards} 
logits = sess.run(model_output, feed_dict=feed_dict) 
predictions = sess.run(prediction, feed_dict=feed_dict) 
print(predictions)

上一步应该产生以下输出：

[6]

为了评估我们的模型，我们需要与我们训练的模型进行对比。要做到这一点，我们必须创建一个能够检查胜利的函数。这样，我们的程序将知道何时停止要求更多动作。这是通过以下代码完成的：

def check(board): 
    wins = [[0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8], [0,4,8], [2,4,6]] 
    for i in range(len(wins)): 
        if board[wins[i][0]]==board[wins[i][1]]==board[wins[i][2]]==1.: 
            return 1 
        elif board[wins[i][0]]==board[wins[i][1]]==board[wins[i][2]]==-1.: 
            return 1 
    return 0

现在我们可以使用我们的模型循环播放游戏。我们从一个空白棋盘（全零）开始，我们要求用户输入一个索引（0-8），然后我们将其输入到模型中进行预测。对于模型的移动，我们采用最大的可用预测，也是一个开放空间。从这个游戏中，我们可以看到我们的模型并不完美，如下所示：

game_tracker = [0., 0., 0., 0., 0., 0., 0., 0., 0.] 
win_logical = False 
num_moves = 0 
while not win_logical: 
    player_index = input('Input index of your move (0-8): ') 
    num_moves += 1 
    # Add player move to game 
    game_tracker[int(player_index)] = 1\. 
    # Get model's move by first getting all the logits for each index 
    [potential_moves] = sess.run(model_output, feed_dict={X: [game_tracker]}) 
    # Now find allowed moves (where game tracker values = 0.0) 
    allowed_moves = [ix for ix,x in enumerate(game_tracker) if x==0.0] 
    # Find best move by taking argmax of logits if they are in allowed moves 
    model_move = np.argmax([x if ix in allowed_moves else -999.0 for ix,x in enumerate(potential_moves)]) 
    # Add model move to game 
    game_tracker[int(model_move)] = -1\. 
    print('Model has moved') 
    print_board(game_tracker) 
    # Now check for win or too many moves 
    if check(game_tracker)==1 or num_moves>=5: 
        print('Game Over!') 
       win_logical = True

上一步应该产生以下交互输出：

Input index of your move (0-8): 4
Model has moved
 O |   |
___________ 
   | X | 
___________ 
   |   | 
Input index of your move (0-8): 6 
Model has moved 
O  |   | 
___________ 
   | X | 
___________ 
 X |   | O 
Input index of your move (0-8): 2 
Model has moved 
O  |   | X 
___________ 
O  | X | 
___________ 
X  |   | O 
Game Over!

工作原理

在本节中，我们通过馈送棋盘位置和九维向量训练神经网络来玩井字棋，并预测最佳响应。我们只需要喂几个可能的井字棋棋盘并对每个棋盘应用随机变换以增加训练集大小。

为了测试我们的算法，我们删除了一个特定棋盘的所有实例，并查看我们的模型是否可以推广以预测最佳响应。最后，我们针对我们的模型玩了一个示例游戏。虽然它还不完善，但仍有不同的架构和训练程序可用于改进它。

七、自然语言处理

在本章中，我们将向您介绍如何使用 TensorFlow 中的文本。我们将首先介绍单词嵌入如何使用词袋方法，然后我们将继续实现更高级的嵌入，如 word2vec 和 doc2vec。

在本章中，我们将介绍以下主题：

使用词袋
实现 TF-IDF
使用 Skip-Gram 嵌入
使用 CBOW 嵌入
使用 word2vec 进行预测
使用 doc2vec 进行情感分析

请注意，读者可以在 Github 和 Packt 仓库中找到本章的所有代码。

介绍

到目前为止，我们只考虑过主要使用数字输入的机器学习算法。如果我们想要使用文本，我们必须找到一种方法将文本转换为数字。有很多方法可以做到这一点，我们将在本章中探讨一些常用的方法。

如果我们考虑句子TensorFlow makes machine learning easy，我们可以按照我们观察它们的顺序将单词转换为数字。这将使句子成为1 2 3 4 5。然后，当我们看到一个新句子machine learning is easy时，我们可以将其翻译为3 4 0 5,，表示我们没有看到的索引为零的单词。通过这两个例子，我们将词汇量限制为六个数字。对于大块文本，我们可以选择我们想要保留多少单词，并且通常保留最常用的单词，用零索引标记其他所有单词。

如果单词learning的数值为 4，单词makes的数值为 2，则自然会认为learning是makes的两倍。由于我们不希望单词之间存在这种类型的数字关系，我们可以假设这些数字代表的是类别，而不是关系数字。

另一个问题是这两个句子的大小不同。我们所做的每个观察（在这种情况下，句子）需要具有与我们希望创建的模型相同的大小输入。为了解决这个问题，我们必须在稀疏向量中创建每个句子，如果该单词出现在该索引中，则该特定索引中的值为 1：

`TensorFlow`	`makes`	`machine`	`learning`	`easy`
1	2	3	4	5

first_sentence = [0,1,1,1,1,1]

为了进一步解释前面的向量，我们的词汇由六个不同的单词组成（五个已知单词和一个未知单词）。对于这些单词中的每一个，我们要么具有零值或 1 值。零表示单词不出现在我们的句子中，1 表示它至少出现一次。因此值为零表示该单词不会出现，值为 1 表示它出现

`machine`	`learning`	`is`	`easy`
3	4	0	5

second_sentence = [1,0,0,1,1,1]

这种方法的缺点是我们失去了任何词序的指示。两个句子TensorFlow makes machine learning easy和machine learning makes TensorFlow easy将产生相同的句子向量。

值得注意的是，这些向量的长度等于我们选择的词汇量的大小。选择非常大的词汇量是很常见的，因此这些句子向量可能非常稀疏。这种类型的嵌入称为词袋。我们将在下一节中实现这一点。

另一个缺点是单词is和TensorFlow具有相同的数字索引值：1。有意义的是，单词is可能不如单词TensorFlow的出现重要。

我们将在本章中探索不同类型的嵌入，试图解决这些问题，但首先我们将开始实现字袋算法。

使用词袋嵌入

在本节中，我们将首先向您展示如何使用 TensorFlow 中的词袋嵌入。这种映射是我们在介绍中介绍的。在这里，我们将向您展示如何使用此类嵌入进行垃圾邮件预测。

准备

为了说明如何在文本数据集中使用词袋，我们将使用来自 UCI 机器学习数据仓库的垃圾邮件电话文本数据库。这是垃圾邮件或非垃圾邮件（非垃圾邮件）的电话短信集合。我们将下载此数据，将其存储以备将来使用，然后继续使用词袋方法来预测文本是否为垃圾邮件。将在词袋算法上运行的模型将是没有隐藏层的逻辑模型。我们将使用批量大小为 1 的随机训练，并在最后的保持测试集上计算精度。

操作步骤

对于这个例子，我们将首先获取数据，正则化和分割文本，通过嵌入函数运行它，并训练逻辑函数来预测垃圾邮件：

第一项任务是为此任务导入必要的库。在通常的库中，我们需要一个.zip文件库来解压缩来自 UCI 机器学习网站的数据，我们从中检索它：

import tensorflow as tf 
import matplotlib.pyplot as plt 
import os 
import numpy as np 
import csv 
import string 
import requests 
import io 
from zipfile import ZipFile 
from tensorflow.contrib import learn 
sess = tf.Session()

我们不会在每次运行脚本时下载文本数据，而是保存它并检查文件之前是否已保存。如果我们想要更改脚本的参数，这可以防止我们反复下载数据。下载此数据后，我们将提取输入和目标数据，并将目标更改为1以查找垃圾邮件，将0更改为非垃圾邮件：

save_file_name = os.path.join('temp','temp_spam_data.csv') 
if os.path.isfile(save_file_name): 
 text_data = [] 
    with open(save_file_name, 'r') as temp_output_file: 
        reader = csv.reader(temp_output_file) 
        for row in reader: 
            text_data.append(row) 
else: 
    zip_url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/00228/smsspamcollection.zip' 
    r = requests.get(zip_url) 
    z = ZipFile(io.BytesIO(r.content)) 
    file = z.read('SMSSpamCollection') 
    # Format Data 
    text_data = file.decode() 
    text_data = text_data.encode('ascii',errors='ignore') 
    text_data = text_data.decode().split('\n') 
    text_data = [x.split('\t') for x in text_data if len(x)>=1] 
    # And write to csv 
    with open(save_file_name, 'w') as temp_output_file: 
        writer = csv.writer(temp_output_file) 
        writer.writerows(text_data) 
texts = [x[1] for x in text_data] 
target = [x[0] for x in text_data] 
# Relabel 'spam' as 1, 'ham' as 0 
target = [1 if x=='spam' else 0 for x in target]

为了减少潜在的词汇量，我们将文本正则化。为此，我们消除了文本中大小写和数字的影响。使用以下代码：

# Convert to lower case 
texts = [x.lower() for x in texts] 
# Remove punctuation 
texts = [''.join(c for c in x if c not in string.punctuation) for x in texts] 
# Remove numbers 
texts = [''.join(c for c in x if c not in '0123456789') for x in texts] 
# Trim extra whitespace 
texts = [' '.join(x.split()) for x in texts]

我们还必须确定最大句子大小。为此，我们将查看数据集中文本长度的直方图。我们可以看到一个很好的截止可能是 25 个字左右。使用以下代码：

# Plot histogram of text lengths 
text_lengths = [len(x.split()) for x in texts] 
text_lengths = [x for x in text_lengths if x < 50] 
plt.hist(text_lengths, bins=25) 
plt.title('Histogram of # of Words in Texts') 
sentence_size = 25 
min_word_freq = 3

由此，我们将得到以下绘图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A3jMCM35-1681566911068)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/tf-ml-cookbook-2e-zh/img/da702c2c-702c-4ea7-bcf6-e778e7cfad70.png)]

图 1：数据中每个文本中单词数的直方图。

We use this to establish a maximum length of words to consider in each text. We set this to 25 words, but it can easily be set to 30 or 40 as well.

TensorFlow 有一个内置的处理工具，用于确定名为VocabularyProcessor()的词汇嵌入，它位于learn.preprocessing库中。请注意，您可能会使用此函数获得已弃用的警告：

vocab_processor = learn.preprocessing.VocabularyProcessor(sentence_size, min_frequency=min_word_freq) 
vocab_processor.fit_transform(texts) 
transformed_texts = np.array([x for x in vocab_processor.transform(texts)])
embedding_size = len(np.unique(transformed_texts))

现在我们将数据分成 80-20 训练和测试集：

train_indices = np.random.choice(len(texts), round(len(texts)*0.8), replace=False) 
test_indices = np.array(list(set(range(len(texts))) - set(train_indices))) 
texts_train = [x for ix, x in enumerate(texts) if ix in train_indices] 
texts_test = [x for ix, x in enumerate(texts) if ix in test_indices] 
target_train = [x for ix, x in enumerate(target) if ix in train_indices] 
target_test = [x for ix, x in enumerate(target) if ix in test_indices]

接下来，我们声明单词的嵌入矩阵。句子词将被翻译成指数。这些索引将被转换为单热编码的向量，我们可以使用单位矩阵创建，这将是我们的单词嵌入的大小。我们将使用此矩阵查找每个单词的稀疏向量，并将它们一起添加到稀疏句子向量中。使用以下代码执行此操作：

identity_mat = tf.diag(tf.ones(shape=[embedding_size]))

由于我们最终会执行逻辑回归来预测垃圾邮件的概率，因此我们需要声明逻辑回归变量。然后我们也可以声明我们的数据占位符。值得注意的是，x_data输入占位符应该是整数类型，因为它将用于查找我们的单位矩阵的行索引。 TensorFlow 要求此查找为整数：

A = tf.Variable(tf.random_normal(shape=[embedding_size,1])) 
b = tf.Variable(tf.random_normal(shape=[1,1])) 
# Initialize placeholders 
x_data = tf.placeholder(shape=[sentence_size], dtype=tf.int32) 
y_target = tf.placeholder(shape=[1, 1], dtype=tf.float32)

现在我们将使用 TensorFlow 的嵌入查找函数，它将句子中单词的索引映射到我们单位矩阵的单热编码向量。当我们有这个矩阵时，我们通过总结上述单词向量来创建句子向量。使用以下代码执行此操作：

x_embed = tf.nn.embedding_lookup(identity_mat, x_data) 
x_col_sums = tf.reduce_sum(x_embed, 0)

现在我们为每个句子都有固定长度的句子向量，我们想要进行逻辑回归。为此，我们需要声明实际的模型操作。由于我们一次只做一个数据点（随机训练），我们将扩展输入的维度并对其进行线性回归操作。请记住，TensorFlow 具有包含 sigmoid 函数的损失函数，因此我们不需要在此输出中包含它：

x_col_sums_2D = tf.expand_dims(x_col_sums, 0) 
model_output = tf.add(tf.matmul(x_col_sums_2D, A), b)

我们现在将声明损失函数，预测操作和优化函数来训练模型。使用以下代码执行此操作：

loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target)) 
# Prediction operation 
prediction = tf.sigmoid(model_output) 
# Declare optimizer 
my_opt = tf.train.GradientDescentOptimizer(0.001) 
train_step = my_opt.minimize(loss)

接下来，我们将在开始训练生成之前初始化图变量：

init = tf.global_variables_initializer() 
sess.run(init)

现在我们将开始对句子进行迭代。 TensorFlow 的vocab_processor.fit()函数是一次运行一个句子的生成器。我们将利用这一优势，以便我们可以对物流模型进行随机训练。为了更好地了解准确率趋势，我们将保留过去 50 个训练步骤的平均值。如果我们只是绘制当前的一个，我们会看到 1 或 0，这取决于我们是否预测训练数据是否正确。使用以下代码执行此操作：

loss_vec = [] 
train_acc_all = [] 
train_acc_avg = [] 
for ix, t in enumerate(vocab_processor.fit_transform(texts_train)): 
    y_data = [[target_train[ix]]] 
    sess.run(train_step, feed_dict={x_data: t, y_target: y_data}) 
    temp_loss = sess.run(loss, feed_dict={x_data: t, y_target: y_data}) 
    loss_vec.append(temp_loss) 
    if (ix+1)%10==0: 
        print('Training Observation #{}: Loss= {}'.format(ix+1, temp_loss)) 
    # Keep trailing average of past 50 observations accuracy 
    # Get prediction of single observation 
    [[temp_pred]] = sess.run(prediction, feed_dict={x_data:t, y_target:y_data}) 
    # Get True/False if prediction is accurate 
    train_acc_temp = target_train[ix]==np.round(temp_pred) 
    train_acc_all.append(train_acc_temp) 
    if len(train_acc_all) >= 50: 
        train_acc_avg.append(np.mean(train_acc_all[-50:]))

这产生以下输出：

Starting Training Over 4459 Sentences. 
Training Observation #10: Loss = 5.45322 
Training Observation #20: Loss = 3.58226 
Training Observation #30: Loss = 0.0 
...
Training Observation #4430: Loss = 1.84636 
Training Observation #4440: Loss = 1.46626e-05 
Training Observation #4450: Loss = 0.045941

为了获得测试集的准确率，我们重复前面的过程，但仅限于预测操作，而不是测试集的训练操作：

print('Getting Test Set Accuracy') 
test_acc_all = [] 
for ix, t in enumerate(vocab_processor.fit_transform(texts_test)): 
    y_data = [[target_test[ix]]] 
    if (ix+1)%50==0: 
        print('Test Observation #{}'.format(ix+1))     
    # Keep trailing average of past 50 observations accuracy 
    # Get prediction of single observation 
    [[temp_pred]] = sess.run(prediction, feed_dict={x_data:t, y_target:y_data}) 
    # Get True/False if prediction is accurate 
    test_acc_temp = target_test[ix]==np.round(temp_pred) 
    test_acc_all.append(test_acc_temp) 
print('\nOverall Test Accuracy: {}'.format(np.mean(test_acc_all)))
Getting Test Set Accuracy For 1115 Sentences. 
Test Observation #10 
Test Observation #20 
Test Observation #30 
...
Test Observation #1000 
Test Observation #1050 
Test Observation #1100 
Overall Test Accuracy: 0.8035874439461883

工作原理

在本例中，我们使用了来自 UCI 机器学习库的垃圾邮件文本数据。我们使用 TensorFlow 的词汇处理函数来创建标准化词汇表来处理和创建句子向量，这些句子向量是每个文本的单词向量的总和。我们使用这个句子向量与逻辑回归并获得 80% 准确率模型来预测特定文本是否是垃圾邮件。

值得一提的是限制句子（或文本）大小的动机。在此示例中，我们将文本大小限制为 25 个单词。这是词袋的常见做法，因为它限制了文本长度对预测的影响。你可以想象，如果我们找到一个单词，例如meeting，它可以预测文本是非垃圾邮件（而不是垃圾邮件），那么垃圾邮件可能会通过在最后输入该单词的多次出现来实现。实际上，这是目标数据不平衡的常见问题。在这种情况下可能会出现不平衡的数据，因为垃圾邮件可能很难找到，而非垃圾邮件可能很容易找到。由于这个事实，我们创建的词汇可能严重偏向于我们数据的非垃圾邮件部分中表示的单词（更多非垃圾邮件意味着更多的单词在非垃圾邮件中表示而不是垃圾邮件）。如果我们允许无限长度的文本，那么垃圾邮件发送者可能会利用这一点并创建非常长的文本，这些文本在我们的逻辑模型中触发非垃圾邮件词因素的概率更高。

在下一节中，我们将尝试通过使用单词出现的频率来更好地解决此问题，以确定单词嵌入的值。

TensorFlow 机器学习秘籍第二版：6~8（3）https://developer.aliyun.com/article/1426839

TensorFlow 机器学习秘籍第二版：6~8（2）

工作原理

改进线性模型的预测

准备

操作步骤

工作原理

学习玩井字棋

准备

操作步骤

工作原理

七、自然语言处理

介绍

使用词袋嵌入

准备

操作步骤

工作原理

更多

热门文章

最新文章

相关课程

相关电子书

相关实验场景