def load(file):
#instanciamos la red
neuralNet = nn.NeuralNetwork()
with open(file) as oFile:
#leemos el archivo en formato JSON
jsonF = json.load(oFile)
#Iteramos por capas y neuronas
for layer in jsonF['capas']:
nLayer = ntl.NetLayer()
for neuron in layer['neuronas']:
w = neuron['pesos']
#Añadimos la neurona como arreglos [baias, arregloPesos, g(n), delta)
nLayer.neurons.append([1, w, 0, 0])
#Añadimos la capa con las neuronas a la red
neuralNet.layers = np.append(neuralNet.layers, nLayer)
return neuralNet
def load(file):
neuralNet = nn.NeuralNetwork()
with open(file) as oFile:
jsonF = json.load(oFile)
for layer in jsonF['capas']:
nLayer = ntl.NetLayer()
for neuron in layer['neuronas']:
print(neuron['pesos'])
w = neuron['pesos']
nLayer.neurons.append([1, w, 0, 0])
neuralNet.layers = np.append(neuralNet.layers, nLayer)
for i in range(0, 2):
for j in range(0, 2):
vector = [i, j]
neuralNet.evaluar(vector)
neuralNet.printG(vector)
with open(fileO, 'w') as file:
json.dump(jsonF, file)
#solo inicia si es el proceso inicial#
if __name__ == "__main__":
#python t4_feed_forward.py part1.red.prueba.json part2_train_data.csv
file = ''
if len(sys.argv) == 1:
file = './Datos/part1_red_prueba.json'
else:
file = sys.argv[1]
#Instanciamos la red entera
neu_net = nn.NeuralNetwork()
#Generar Red con pesos aleatorios
neu_net.neuRandom(2, 2, 2)
for i in range(0, 2):
for j in range(0, 2):
vector = [i, j]
#Evaluamos los vectores
neu_net.evaluar(vector)
#Imprimimos en consola los resultados
neu_net.printG(vector)
#Guardamos la red en formato JSON
save(neu_net, 2, 'FeedFoward_Results/feed_forwards_random_results.json')
print("Guardado en 'FeedFoward_Results/feed_forwards_random_results.json'")
def BackPropagation(datat, cEpochMax, roundWithoutDecrement, epsilon,
validationfile, dataValidation):
data, roundSuccesful, nets = {}, 0, []
#Separamos de un solo la training data
ins = datat.iloc[:, 0:2].values
outs = datat.iloc[:, 2:4].values
for i in range(20):
net = nn.NeuralNetwork()
#Inicializamoos los valores solo al inicio
net.neuRandom(2, 2, 2)
#Añadimos la red al arreglo
nets.append(net)
#evaluamos cada red por los 4 vectores de entrada
print("Working...")
for i in range(len(ins)):
vector = ins[i]
mseMax, mseMin, mseProm, nCol = [], [], [], []
cont = 0
print(f"--------------------{i}-------------------------")
for net in nets:
cont += 1
nCol.append(nets.index(net) + 1)
errorA, MSE = 1, []
#rondas, por defecto son 100, a menos que el usuari mande un valor
for j in range(cEpochMax):
net.evaluar(vector)
gradient(net, vector)
weightUpdate(net, vector)
#Calculamos el MSE actual
ultimasN = net.layers[len(net.layers) - 1].neurons
error = (np.square(outs[i] -
[ultimasN[0][2], ultimasN[1][2]])).mean()
#Vemos si el error ha aumentado, detener el proceso
if error > errorA:
#print(f"El error empezó a aumentar. Se detiene el proceso.\nLa época: {j+1} no se guardará")
break
#Si los errores actual con el pasado es igual:
if (error == errorA):
#Si llego al limite especificado, termine
if (roundSuccesful == roundWithoutDecrement):
#print("Llegó al limite de rondas sin incrementos establecidos")
break
#si no, continue, buen joven
else:
roundSuccesful += 1
else:
if ((errorA - error) <= epsilon): break
#Significa que el error es menor, así que pierde la racha de errores iguales
roundSuccesful = 0
#Actualizamos el errors anterior con el actual
errorA = error
#Añadimos el error al arreglo de MSE
MSE.append(errorA)
#Imprimimos el MSE se especifico como requerimieto
print(
tabulate([[j, error]],
headers=['ÉPOCA', 'MSE'],
tablefmt='fancy_grid',
showindex="never",
colalign=("center", )), "\n")
#Con np calculamos el max, min y promedio de un solo
mseMax.append(np.amax(MSE))
mseMin.append(np.amin(MSE))
mseProm.append(np.mean(MSE))
#guardamos los resultados de la red
save(
net, 2, 'BackPropagation_Results/JSON/results_net_' +
str(nets.index(net) + 1) + '.json')
#Se imprime en consola
print(
tabulate(
[[cont, np.amax(MSE),
np.amin(MSE),
np.mean(MSE)]],
headers=['Net', 'MSE_MAX', 'MSE_MIN', 'MSE_PROM'],
tablefmt='fancy_grid',
showindex="never",
colalign=("center", )), "\n")
#Formateamos
data = {
'NET': nCol,
'MSE_MIN': mseMin,
'MSE_MAX': mseMax,
'MSE_PROM': mseProm
}
archivo = pd.DataFrame(
data, columns=['NET', 'MSE_MIN', 'MSE_MAX', 'MSE_PROM'])
#Se imprime en consola
print(
tabulate(archivo,
headers=['NET', 'MSE_MAX', 'MSE_MIN', 'MSE_PROM'],
tablefmt='fancy_grid',
showindex="always",
colalign=("center", )))
#Guardamos
archivo.to_csv('BackPropagation_Results/CSV/inputs_net_' +
str(vector[0]) + str(vector[1]) + '.csv',
index=False)
saveGraphic(mseMax, mseProm, mseMin, vector)
print("Los resultados se guardaron en 'BackPropagation_Results/'")
def neuralArchitecture(dataN, dataV, cNeuronH, cInH, cNeuronO):
roundWithoutDecrement, epsilon = 3, 0.5
net = nn.NeuralNetwork()
#(cantidad de neuronas, cantidad de entradas)
net.AddHiddenLayer(cNeuronH, cInH)
#(cantidad de neuronas)
net.AddOutLayer(cNeuronO)
#print(dataN)
for i in range(len(dataN)):
vector = data[i]
outs = dataV[i]
mseMax, mseMin, mseProm, nCol = [], [], [], []
cont = 0
cont += 1
nCol.append(cNeuronH)
errorA, MSE = 1, []
for j in range(50):
net.evaluar(vector)
net = gp.gradient(net, vector)
net = gp.weightUpdate(net, vector)
#Calculamos el MSE actual
ultimasN = net.layers[len(net.layers) - 1].neurons
error = (np.square(outs[i] -
[ultimasN[0][2], ultimasN[1][2]])).mean()
#Vemos si el error ha aumentado, detener el proceso
if error > errorA:
#print(f"El error empezó a aumentar. Se detiene el proceso.\nLa época: {j+1} no se guardará")
break
#Si los errores actual con el pasado es igual:
if (error == errorA):
#Si llego al limite especificado, termine
if (roundSuccesful == roundWithoutDecrement):
#print("Llegó al limite de rondas sin incrementos establecidos")
break
#si no, continue, buen joven
else:
roundSuccesful += 1
else:
if ((errorA - error) <= epsilon): break
#Significa que el error es menor, así que pierde la racha de errores iguales
roundSuccesful = 0
#Actualizamos el errors anterior con el actual
errorA = error
#Añadimos el error al arreglo de MSE
MSE.append(errorA)
#Imprimimos el MSE se especifico como requerimieto
print(
tabulate([[j, error]],
headers=['ÉPOCA', 'MSE'],
tablefmt='fancy_grid',
showindex="never",
colalign=("center", )), "\n")
#Con np calculamos el max, min y promedio de un solo
mseMax.append(np.amax(MSE))
mseMin.append(np.amin(MSE))
mseProm.append(np.mean(MSE))
#guardamos los resultados de la red
save(net, 2,
'Clasicacion_Result/JSON/results_net_' + str(cNeuronH) + '.json')
#Se imprime en consola
print(
tabulate(
[[cont, np.amax(MSE),
np.amin(MSE), np.mean(MSE)]],
headers=['Net', 'MSE_MAX', 'MSE_MIN', 'MSE_PROM'],
tablefmt='fancy_grid',
showindex="never",
colalign=("center", )), "\n")
inputs = np.array([[0, 1, 1, 1, 0, 0, 1, 1],
[0, 1, 1, 1, 0, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 0, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 1, 1, 0],
[0, 1, 1, 1, 0, 1, 0, 1],
[0, 0, 0, 0, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 0, 0, 0, 0, 0],
[1, 0, 1, 1, 0, 1, 0, 0]])'''
outputs_raw = [2, 3, 4, 5, 6, 7]
normalize(outputs_raw, hiddenNUM)
#outputs = [[1], [0], [0], [1], [0], [1], [1], [0], [1], [0]]
NN = NeuralNetwork(np.array(inputs_raw), np.array(outputs_raw))
clock = pygame.time.Clock()
cycles = 0
maxCycles = 1000
n_animations = 5
ex_raw = [8]
normalize(ex_raw, hiddenNUM)
example = np.array([ex_raw])
running = True
while running:
screen.fill((0, 0, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT: