Tensorflow 简明教程

TensorFlow - Single Layer Perceptron

要理解单层感知器，重要的是理解人工智能神经网络 (ANN)。人工智能神经网络是一种信息处理系统，其机制源于生物神经回路的功能。一个人工神经网络拥有许多彼此之间相连的处理单元。以下为人工神经网络的示意图 −

For understanding single layer perceptron, it is important to understand Artificial Neural Networks (ANN). Artificial neural networks is the information processing system the mechanism of which is inspired with the functionality of biological neural circuits. An artificial neural network possesses many processing units connected to each other. Following is the schematic representation of artificial neural network −

schematic representation

该图表表明隐藏单元与外部层进行通信。而输入和输出单元仅通过网络的隐藏层进行通信。

The diagram shows that the hidden units communicate with the external layer. While the input and output units communicate only through the hidden layer of the network.

节点的连接模式、层总数和输入与输出之间的节点级别以及每层神经元的数量定义了神经网络的架构。

The pattern of connection with nodes, the total number of layers and level of nodes between inputs and outputs with the number of neurons per layer define the architecture of a neural network.

有两种类型的架构。这些类型关注以下的人工神经网络功能 −

There are two types of architecture. These types focus on the functionality artificial neural networks as follows −

  1. Single Layer Perceptron

  2. Multi-Layer Perceptron

Single Layer Perceptron

单层感知器是创建的第一种提出的神经模型。神经元的局部存储器的内容包含一个权向量。单层感知器的计算在输入向量的总和计算上进行，每个向量值都乘以权向量的相应元素。输出中显示的值将是激活函数的输入。

Single layer perceptron is the first proposed neural model created. The content of the local memory of the neuron consists of a vector of weights. The computation of a single layer perceptron is performed over the calculation of sum of the input vector each with the value multiplied by corresponding element of vector of the weights. The value which is displayed in the output will be the input of an activation function.

single layer perceptron

让我们关注于使用 TensorFlow 对图像分类问题实现单层感知器。通过表示“逻辑回归”来说明单层感知器是最好的示例。

Let us focus on the implementation of single layer perceptron for an image classification problem using TensorFlow. The best example to illustrate the single layer perceptron is through representation of “Logistic Regression”.

logistic regression

现在，让我们考虑训练逻辑回归的以下基本步骤 −

Now, let us consider the following basic steps of training logistic regression −

  1. The weights are initialized with random values at the beginning of the training.

  2. For each element of the training set, the error is calculated with the difference between desired output and the actual output. The error calculated is used to adjust the weights.

  3. The process is repeated until the error made on the entire training set is not less than the specified threshold, until the maximum number of iterations is reached.

用于评估逻辑回归的完整代码如下所述 −

The complete code for evaluation of logistic regression is mentioned below −

# Import MINST data
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

import tensorflow as tf
import matplotlib.pyplot as plt

# Parameters
learning_rate = 0.01
training_epochs = 25
batch_size = 100
display_step = 1

# tf Graph Input
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes

# Create model
# Set model weights
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

# Construct model
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax

# Minimize error using cross entropy
cross_entropy = y*tf.log(activation)
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1))

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost)

#Plot settings
avg_set = []
epoch_set = []

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
   sess.run(init)

   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)

      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys})
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")

   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase')
   plt.ylabel('cost')
   plt.xlabel('epoch')
   plt.legend()
   plt.show()

   # Test model
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1))

   # Calculate accuracy
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

Output

以上代码会生成以下输出 −

The above code generates the following output −

evaluation of logistic regression

逻辑回归被认为是一种预测性分析。逻辑回归用于描述数据并解释一个因变量和一个或多个名义变量或自变量之间的关系。

The logistic regression is considered as a predictive analysis. Logistic regression is used to describe data and to explain the relationship between one dependent binary variable and one or more nominal or independent variables.

independent variables