TensorFlow 教程 4：创建神经网络

作者：Dante Sblendorio

什么是神经网络？如何创建它？请继续阅读以了解详情。下面，我将解释使用 TensorFlow 设置神经网络的基本知识。

神经网络由三个关键组成部分组成：输入层、隐藏层（们）和输出层。每一层都有任意数量的节点（或神经元）。在上一节的示例中，输入层是 const1 和 const2。矩阵加法可以被认为是隐藏层，输出层是输出。对于我们的葡萄酒数据，输入数据是 13 个化学特征，输出层是 Class。隐藏层可以被认为是一组复杂的数学函数，它们充当过滤器，提取确定正确 Class 的相关特征。神经网络的结构受到生物学的启发，特别是人脑中的神经连接。为了本文的目的，我不会深入探讨隐藏层（们）的数学结构。将它视为从数据中提取隐藏含义的数学“黑盒”就足够了。（但是，如果您想了解更多信息，这里 是一本关于神经网络和深度学习的全面在线教科书。）

我们将数据集分为训练集和测试集。这使我们能够“训练”隐藏层内的数学运算符，使其收敛到理想值，从而根据每个观测值的 13 个特征正确预测正确的 Class。然后我们将测试集注入神经网络并评估准确性，以确定网络的训练程度。以这种方式分割数据提供了一种避免过度拟合或欠拟合数据的方法，从而给出网络准确性的真实估计。为了准备 TensorFlow 的数据，我们进行一些轻微的操作。

from sklearn.model_selection import train_test_split

#this prepares our Class variable for the NN
def convertClass(val):
   if val == 1:
       return [1, 0, 0]
   elif val == 2:
       return [0, 1, 0]
   else:
       return [0, 0, 1]
   
Y = wine_df.loc[:,'Class'].values
Y = np.array([convertClass(i) for i in Y])
X = wine_df.loc[:,'Alcohol':'Proline'].values

#we split the dataset into a test and training set
train_x, test_x, train_y, test_y = train_test_split(X,Y , test_size=0.3, random_state=0)
train_x = train_x.transpose()
train_y = train_y.transpose()
test_x = test_x.transpose()
test_y = test_y.transpose()

现在数据准备好了，我们定义几个函数，它们构成了神经网络的基础。首先，我们定义一个函数来建立网络的初始参数。在这里，我们还定义了每个隐藏层中的节点数量（我选择使用两个隐藏层）。由于 Class 有三个可能的值，因此输出层有三个节点。接下来，我们定义一个前向传播函数。这所做的全部就是将 13 个特征通过网络发送，并使它们受到隐藏层内的数学运算的影响。

我们还需要定义一个成本函数。这是一个关键函数，它使我们能够“训练”网络。它是一个单一的值，描述了网络预测正确 Class 的效果。如果成本值很高，数学运算符会进行调整，并且数据会再次馈送到网络中。数据会馈送到网络中，直到成本值收敛。

def init_parameters(num_input_features):

   num_hidden_layer =  32
   num_hidden_layer_2 = 16
   num_output_layer_1 = 3
   
   tf.set_random_seed(1)
   W1 = tf.get_variable("W1", [num_hidden_layer, num_input_features], initializer = tf.contrib.layers.xavier_initializer(seed=1))
   b1 = tf.get_variable("b1", [num_hidden_layer, 1], initializer = tf.zeros_initializer())
   W2 = tf.get_variable("W2", [num_hidden_layer_2, num_hidden_layer], initializer = tf.contrib.layers.xavier_initializer(seed=1))
   b2 = tf.get_variable("b2", [num_hidden_layer_2, 1], initializer = tf.zeros_initializer())
   W3 = tf.get_variable("W3", [num_output_layer_1, num_hidden_layer_2], initializer = tf.contrib.layers.xavier_initializer(seed=1))
   b3 = tf.get_variable("b3", [num_output_layer_1, 1], initializer = tf.zeros_initializer())
   
   parameters = {"W1": W1,
                 "b1": b1,
                 "W2": W2,
                 "b2": b2,
                 "W3": W3,
                 "b3": b3}
   
   return parameters
			
def for_prop(X, parameters):
			
   W1 = parameters['W1']
   b1 = parameters['b1']
   W2 = parameters['W2']
   b2 = parameters['b2']
   W3 = parameters['W3']
   b3 = parameters['b3']
   
   # propagates values through NN using Rectified Linear Unit as activation function          
   Z1 = tf.add(tf.matmul(W1, X), b1)                     
   A1 = tf.nn.relu(Z1)                                    
   Z2 = tf.add(tf.matmul(W2, A1), b2)                     
   A2 = tf.nn.relu(Z2)                                   
   Z3 = tf.add(tf.matmul(W3, A2), b3)                    
   return Z3

def c(Z3, Y):
   logits = tf.transpose(Z3)
   labels = tf.transpose(Y)
   cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=labels))
   return cost

我们还需要定义一个函数，该函数生成训练集内观测值的随机子集。我之前提到数据被馈送到神经网络中，直到成本值收敛；每次迭代都会从总训练集中选择一个随机子样本并注入到网络中。在这个函数中，我们创建子样本批次。

def rand_batches(X, Y, batch_size = 128, seed = 0):
   m = X.shape[1]
   batches = []
   np.random.seed(seed)
   
   # shuffle
   permutation = list(np.random.permutation(m))
   shuffled_X = X[:, permutation]
   shuffled_Y = Y[:, permutation].reshape((Y.shape[0],m))

   # partition the shuffled data
   num_batches = math.floor(m/batch_size)
   for k in range(0, num_batches):
       batch_X = shuffled_X[:, k * batch_size : k * batch_size + batch_size]
       batch_Y = shuffled_Y[:, k * batch_size : k * batch_size + batch_size]
       batch = (batch_X, batch_Y)
       batches.append(batch)
   
   # handle end case
   if m % batch_size != 0:
       batch_X = shuffled_X[:, num_batches * batch_size : m]
       batch_Y = shuffled_Y[:, num_batches * batch_size : m]
       batch = (batch_X, batch_Y)
       batches.append(batch)
   
   return batches

要生成挑战 4 的参赛代码，请将以下代码粘贴到您的 Jupyter notebook 中

member_number = 12345678

one = [member_number, int(member_number/5), int(member_number/100)]

two = [0.02, 0.05, 0.08]

a = tf.placeholder(tf.float32, shape=(3))

b = tf.placeholder(tf.float32, shape=(3))

result = tf.tensordot(a, b, 1)

with tf.Session() as sess:

   print(int(result.eval(feed_dict={a: one, b: two})))

在运行代码之前，将 12345678 替换为您的 CodeProject 会员号码。打印出的数字将是您本次挑战的参赛代码。请点击 这里 输入竞赛参赛代码。