TF en la red neuronal multicapa

red neuronal multicapa

capas de red neural, es en términos del número de capas ocultas, generalmente no irá capa de entrada estadística y capa de salida; este documento es un simple capa totalmente conectada, la llamada totalmente conectado, es decir, en cada nivel de a once nodos a cada nodo conectado a la capa siguiente. Según sea el caso, será esencial para construir una red de múltiples capas, y darse cuenta de los datos mnist y clasificación.

conexión completa capa de constructor

# 定义全连接层构造函数
def fcn_layer(inputs,  # 输入的数据
              input_dim,  # 输入的维度
              output_dim,  # 输出的维度，也就是神经元数目
              activation=None  # 激活函数，可以不使用
              ):
    w = tf.Variable(tf.truncated_normal([input_dim, output_dim], stddev=0.1))
    b = tf.Variable(tf.zeros([output_dim]))
    xwb = tf.matmul(inputs, w) + b
    # 基于输入确定是否激活
    if activation is None:
        outputs = xwb
    else:
        outputs = activation(xwb)
    # 返回最终结果
    return outputs

Como la capa de conexión para establecer constructor completo, los datos de entrada dados, de entrada y salida dimensiones, y si la condición previa de la función de activación, el final completo al final puede ser implementado para establecer la capa de conexión; es decir, las neuronas de la capa de salida de dimensión en la red, cada neurona puede considerarse en un intento de extraer una característica de la muestra, como la red sigue profundizando, las características extraídas de la más avanzada, o ver de la humanidad no saben; pesos w generalmente no recomiendan el uso de la distribución completamente al azar, pero aquí truncado distribución aleatoria; selección de la función de activación hay muchos, sino más bien la capa oculta se utiliza generalmente relu s función de tipo o una función de tangente hiperbólica, ser problemática debido a la desaparición de la pendiente, y la capa de salida SoftMax utiliza generalmente, la cálculo de las puntuaciones asigna al dominio de probabilidad.

El uso de un constructor para la construcción de una doble red

# 利用模型函数进行双层多元网络构建
H1_nn = 256  # 首层神经元数
H2_nn = 64  # 次层神经元数
# 定义输入
x = tf.placeholder(tf.float32, [None, 784], name="X")
y = tf.placeholder(tf.float32, [None, 10], name="Y")
# 定义隐含1、2层，以及前向计算与输出层
h1 = fcn_layer(x, 784, H1_nn, tf.nn.relu)
h2 = fcn_layer(h1, 256, H2_nn, tf.nn.relu)
forward = fcn_layer(h2, H2_nn, 10)
preb = tf.nn.softmax(forward)

Como el establecimiento de una capa de salida de dos capa oculta; ya que el uso de la multiplicación de matrices, nota que las capas adyacentes relación de dimensión longitudinal, y las dimensiones de la capa de salida final es fija, es decir, el número de clasificación; se define por separado antes de calcular la capa de salida, donde la , con el fin de facilitar la definición de precisión después de la función de pérdida.

hyperparametric conjunto

# 设置超参与日志路径
train_epoch = 50
batch_size = 50
total_batch = int(mnist.train.num_examples/batch_size)
learning_rate = 0.01
display_step = 1
save_step = 5
ckpt_dir = "./ckpt_dir/"
if not os.path.exists(ckpt_dir):
    os.makedirs(ckpt_dir)

# 设置损失函数与优化器
loss_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=forward, labels=y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
# 设置准确率
correct_prediction = tf.equal(tf.argmax(preb, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

Como los parámetros de super-set. Tenga en cuenta que la función de pérdida utilizando TF está provisto de la función de pérdida de entropía cruzada softmax, así que cuando se define la función de pérdida, se calcula una entrada de avance.

la formación de inicio

# 启动会话并初始化
sess = tf.Session()
saver = tf.train.Saver()  # 初始化写入对象，要定义在变量初始化之前
sess.run(tf.global_variables_initializer())
start_time = time()  # 记录起始时间

# 开始训练
print("Start Train!")
for epoch in range(train_epoch):
    for batch in range(total_batch):
        xs, ys = mnist.train.next_batch(batch_size)
        sess.run(optimizer, feed_dict={x: xs, y: ys})
    loss, acc = sess.run([loss_function, accuracy], feed_dict={x: mnist.validation.images, y: mnist.validation.labels})  # 每训练一轮用验证集检测损失函数与准确率
    if (epoch+1) % display_step == 0:  # 以一定粒度显示loss与accuracy
        print("epoch: ", epoch+1, ",loss: ", loss, ",accuracy: ", acc)
    if(epoch+1) % save_step == 0:  # 以一定粒度保存模型
        saver.save(sess, os.path.join(ckpt_dir, 'Mnist_h256_model_{:06d}.ckpt'.format(epoch+1)))
        print('Mnist_h256_model_{:06d}.ckpt saved!'.format(epoch+1))
saver.save(sess, os.path.join(ckpt_dir, 'Mnist_h256_model_final.ckpt'))  # 保存最终模型
print("Model Saved!")
duration = time()-start_time  # 统计时长
print("duration: ", duration)

visualización ayudante

def print_predict_errs(labels,  # 标签集合
                       prediction  # 预测值集合
                       ):
    count = 0
    compare_list = (prediction == np.argmax(labels, 1))
    err_list = [i for i in range(len(compare_list)) if compare_list[i] == False]
    for x in err_list:
        print("index= "+str(x)+"标签值= ", np.argmax(labels[x]),"预测值= ", prediction[x])
        count = count+1
    print("总计： ", str(count))

Requisitos de entrada se establecen mnist la etiqueta, y el conjunto de resultados de predicción; conjunto requisitos llamados predictores ha cambiado para que se muestre directamente como un valor predicho de la codificada caliente, véase el modelo de código de detección específico.

Carga y modelos de prueba y visualización

# 载入最新的模型
saver = tf.train.Saver(tf.global_variables())
moudke_file = tf.train.latest_checkpoint('ckpt_dir')
saver.restore(sess, moudke_file)
print("Load model!")

# 测试模型，利用测试集数据
acc_test = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels})
print("Test Accuracy: ", acc_test)


# 利用可视化函数，将对于测试集的预测值与预测集的标签值进行比对，并输出不匹配列表
# 按顺序返回预测值，需按行取最大值，将独热编码转换为一列，所取得结果组成一个（1000，1）的元组
predicion_result = sess.run(tf.argmax(preb, 1), feed_dict={x: mnist.test.images})
print_predict_errs(mnist.test.labels,predicion_result)