Python IA, librerias: Tensorflow, Keras y Sklearn

from matlotlib import animation
from IPython.core.display import display, HTML

import tensorflow as tf

#Puntos de entrada de grafos
iX = tf.placeholder('float', shape=[None, X.shape[1]])
iY = tf.placeholder('float', shape=[None])

nn = [2, 16, 8, 1] #Numero de neuronas por capa
lr = 0.01 #Ratio de aprendizaje del optimizador.

#Capa1
W1 = tf.Variable(tf.random_normal([nn[0], nn[1]]), name = 'Weights_1')
b1 = tf.Variable(tf.random_normal([nn[1]]), name='bias_1')

l1 = tf.nn.relu(tf.add(tf.matmul(iX, W1), b1))

#Capa2
W2 = tf.Variable(tf.random_normal([nn[1], nn[2]]), name = 'Weights_2')
b2 = tf.Variable(tf.random_normal([nn[2]]), name='bias_2')

l2 = tf.nn.relu(tf.add(tf.matmul(l1, W2), b2))

#Capa3
W3 = tf.Variable(tf.random_normal([nn[2], nn[3]]), name = 'Weights_3')
b3 = tf.Variable(tf.random_normal([nn[3]]), name='bias_3')


#Vector de prediccion Y
pY = tf.nn.sigmoid(tf.add(tf.matmul(l2, W3), b3))[:,0]

#Evaluacion de las predicciones
loss = tf.losses.mean_squared_error(pY, iY)

#Creamos el optimizador que entrenará la red neuronal
optimizer = tf.train.GradientDescentOptimizer(learning_rate=lr).minimize(loss)

n_steps = 1000 #Numero de pasos para entrenar la red neuronal

with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for step in range(n_steps):
#variables optimizer, loss y pY nuevamente cargadas con:
#la matriz de entrada y el vector de salida
_, _loss, _pY = sess.run([optimizer, loss, pY], feed_dict={iX:X,iY:Y})
ifstep % 25 == 0:
#Calculo de precision entre el vector real y las predicciones
acc = np.mean(np.round(_pY) == Y)
print('Paso', step, ' /', n_steps, 'error del Vector cuadratico medio: ', loss, 'precision: ', acc)



# input X INPUT X
# Matmul XW1
# Suma XW1 + b1 CAPA DENSA (X)
# RELU f(XW1 + b1)
# Matmul L1W1 CAPA DENSA (C1)
# SUMA L1W2 + B2
# RELU f(L1W2 + B2) CAPA DENSA (C2)
# MATMUL L2W3
# SUMA L2W3 +B3 CAPA DENSA (C3)
# ...

#========================================================

# ___TensorFlow con keras___ nivel avanzado (Arquitectura Deeplearning)

import tensorflow.keras as kr

lr = 0,01 #ratio de aprendizaje
nn = [2, 16, 8, 1] #Neuronas por capa

#Estructura del modelo
model = kr.Sequential()

#Capa 1
model.add(kr.layer.Dense(nn[1], activacion='relu')) #agregar capa con funcion de activacion relu

#Capa 2
model.add(kr.layer.Dense(nn[2], activacion='relu')) #agregar capa con funcion de activacion relu

#Capa 3
model.add(kr.layer.Dense(nn[3], activacion='sigmoid')) #agregar capa con funcion de activacion sigmoide

#Compilar el modelo
model.compile(loss='mse', optimizer = kr.optimizers.SGD(lr=lr), metrics['acc']) #compilar el model con el vector de optimizacion deseado y la visualizacion de precision

#entrenar modelo
model.fit(X, Y, epochs=250) #Datos de entrada X y datos de salida Y numero max de epocas 250


#==========================================================

# ___sklearn___  Redes neuronales de capa a modelo

import sklearn as sk
import sklearn.neural_network

lr = 0.01 #ration de aprendizaje
nn = [2, 16, 8, 1] #numero de neuronas por capa

#Objeto del modelo
model = sk.neural_network.MLPRegressor(...) #se crea el objeto del modelo

#Entrenamiento al modelo
model.fit(X,Y) #se crea el modelo de entrenamiento

#Se hacen predicciones
model.predict(Xp) #se realizan predicciones

___________________________________________________________

# ___sklearn___  Redes neuronales de capa a modelo

import sklearn as sk
import sklearn.neural_network

lr = 0.01 #ration de aprendizaje
nn = [2, 16, 8, 1] #numero de neuronas por capa

#Objeto del modelo

#tipo de optimizador, ratio inicial de aprendizaje, numero de neuronas para cada capa oculta, detallado, numero de iteracciones a entrenar
model = sk.neural_network.MLPRegressor(solver='sgd',
learning_rate_init=lr,
hidden_layer_sizes=nn[1:],
verbose =True,
n_iter_no_change = 1000)

#Entrenamiento al modelo
model.fit(X,Y) #se crea el modelo de entrenamiento