Este documento describe ejemplos de algoritmo de red neuronal artificial implementado en Python. Compartir con usted para su referencia, de la siguiente manera:
Nota: Este programa utiliza python3 escritura, es necesario instalar el kit numpy adicional para operaciones de la matriz, no prueba si python2 puede correr.
Este programa implementa el algoritmo de propagación hacia atrás en el libro "aprendizaje automático" entrenamiento de la red neuronal artificial, por favor refiérase a la parte teórica de mis notas de estudio.
En este procedimiento, la función objetivo es una de dos entradas x y de salida y la composición,
x está en el intervalo [-3,14, 3,14] entre el número real generada al azar, y los dos valores de y corresponde a y1 = sin (x), y2 = 1.
Aleatoriamente generado 10.000 copias de ejemplos de entrenamiento, después de una red de datos de prueba después cinco generados al azar para verificar los resultados del entrenamiento de aprendizaje y formación, y.
Aprender algoritmo de ajuste de la tasa, y el número de capas ocultas, el tamaño de la capa oculta, el entrenamiento de la nueva red se pueden observar los parámetros que afectan a los resultados del estudio.
código del algoritmo de la siguiente manera:
#!usr/bin/env python3
# -*- coding:utf-8 -*-
import numpy as np
import math
# definition of sigmoid funtion
# numpy.exp work for arrays.
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# definition of sigmoid derivative funtion
# input must be sigmoid function's result
def sigmoid_output_to_derivative(result):
return result*(1-result)
# init training set
def getTrainingSet(nameOfSet):
setDict = {
"sin": getSinSet(),
}
return setDict[nameOfSet]
def getSinSet():
x = 6.2 * np.random.rand(1) - 3.14
x = x.reshape(1,1)
# y = np.array([5 *x]).reshape(1,1)
# y = np.array([math.sin(x)]).reshape(1,1)
y = np.array([math.sin(x),1]).reshape(1,2)
return x, y
def getW(synapse, delta):
resultList = []
# 遍历隐藏层每个隐藏单元对每个输出的权值，比如8个隐藏单元，每个隐藏单元对两个输出各有2个权值
for i in range(synapse.shape[0]):
resultList.append(
(synapse[i,:] * delta).sum()
)
resultArr = np.array(resultList).reshape(1, synapse.shape[0])
return resultArr
def getT(delta, layer):
result = np.dot(layer.T, delta)
return result
def backPropagation(trainingExamples, etah, input_dim, output_dim, hidden_dim, hidden_num):
# 可行条件
if hidden_num < 1:
print("隐藏层数不得小于1")
return
# 初始化网络权重矩阵，这个是核心
synapseList = []
# 输入层与隐含层1
synapseList.append(2*np.random.random((input_dim,hidden_dim)) - 1)
# 隐含层1与隐含层2, 2->3,,,,,,n-1->n
for i in range(hidden_num-1):
synapseList.append(2*np.random.random((hidden_dim,hidden_dim)) - 1)
# 隐含层n与输出层
synapseList.append(2*np.random.random((hidden_dim,output_dim)) - 1)
iCount = 0
lastErrorMax = 99999
# while True:
for i in range(10000):
errorMax = 0
for x, y in trainingExamples:
iCount += 1
layerList = []
# 正向传播
layerList.append(
sigmoid(np.dot(x,synapseList[0]))
)
for j in range(hidden_num):
layerList.append(
sigmoid(np.dot(layerList[-1],synapseList[j+1]))
)
# 对于网络中的每个输出单元k，计算它的误差项
deltaList = []
layerOutputError = y - layerList[-1]
# 收敛条件
errorMax = layerOutputError.sum() if layerOutputError.sum() > errorMax else errorMax
deltaK = sigmoid_output_to_derivative(layerList[-1]) * layerOutputError
deltaList.append(deltaK)
iLength = len(synapseList)
for j in range(hidden_num):
w = getW(synapseList[iLength - 1 - j], deltaList[j])
delta = sigmoid_output_to_derivative(layerList[iLength - 2 - j]) * w
deltaList.append(delta)
# 更新每个网络权值w(ji)
for j in range(len(synapseList)-1, 0, -1):
t = getT(deltaList[iLength - 1 -j], layerList[j-1])
synapseList[j] = synapseList[j] + etah * t
t = getT(deltaList[-1], x)
synapseList[0] = synapseList[0] + etah * t
print("最大输出误差:")
print(errorMax)
if abs(lastErrorMax - errorMax) < 0.0001:
print("收敛了")
print("####################")
break
lastErrorMax = errorMax
# 测试训练好的网络
for i in range(5):
xTest, yReal = getSinSet()
layerTmp = sigmoid(np.dot(xTest,synapseList[0]))
for j in range(1, len(synapseList), 1):
layerTmp = sigmoid(np.dot(layerTmp,synapseList[j]))
yTest = layerTmp
print("x:")
print(xTest)
print("实际的y:")
print(yReal)
print("神经元网络输出的y:")
print(yTest)
print("最终输出误差:")
print(np.abs(yReal - yTest))
print("#####################")
print("迭代次数:")
print(iCount)
if __name__ == '__main__':
import datetime
tStart = datetime.datetime.now()
# 使用什么样的训练样例
nameOfSet = "sin"
x, y = getTrainingSet(nameOfSet)
# setting of parameters
# 这里设置了学习速率。
etah = 0.01
# 隐藏层数
hidden_num = 2
# 网络输入层的大小
input_dim = x.shape[1]
# 隐含层的大小
hidden_dim = 100
# 输出层的大小
output_dim = y.shape[1]
# 构建训练样例
trainingExamples = []
for i in range(10000):
x, y = getTrainingSet(nameOfSet)
trainingExamples.append((x, y))
# 开始用反向传播算法训练网络
backPropagation(trainingExamples, etah, input_dim, output_dim, hidden_dim, hidden_num)
tEnd = datetime.datetime.now()
print("time cost:")
print(tEnd - tStart)
Por último, recomiendo una reunión buena reputación pitón [ Haga clic para entrar ], hay una gran cantidad de veteranos habilidades de aprendizaje, experiencia, habilidades de la entrevista, la experiencia laboral y otra cuota de aprendizaje, más que preparamos cuidadosamente la información introductoria de base cero en los datos reales del proyecto método, todos los días, los programadores explicar la tecnología de sincronización de Python, para compartir algunas de las letras y la necesidad de prestar atención a los pequeños detalles
