Aclaración grafica de una neurona "Machine Learning"

Descenso gradiente

import numpy as np #libreria de calculo numerico
import scipy as sc #extension de numpy
import matplotlib.pyplot as plt #visualizacion de datos

#funcion anonima de coste para vector de parametros
#func = lambda th: np.sin(1 / 2 * x ** 2 -1 / 4 * y ** 2 + 3) * np.cos(2 * x + 1 - np.e ** y)
#optimizacion de funciones
func = lambda th: np.sin(1 / 2 * th[0] ** 2 -1 / 4 * th[1] ** 2 + 3) * np.cos(2 * th[0] + 1 - np.e ** th[1]) #funcion anonima de coste para vector de parametros

#visualizar el parametro de la funcion: print(func([2,3]))
res = 100 #100 valores de resolucion
#vectores X e Y de -2 a 2 con 100 coordenadas
_X = np.linspace(-2, 2, res)
_Y = np.linspace(-2, 2, res)

_Z = np.zeros((res, res)) #matriz de elementos nulos de tamaño 100x100

for ix, x in enumerate(_X):
for iy, y in enumerate(_X):
_Z[iy, ix] = func([x,y]) #primero columnas, luego filas
plt.contour(_X, _Y, _Z, 100) #crear superficie diferencial desde arriba
plt.colorbar() #regla de profundidad con colores

Theta = np.random.rand(2) * 4 -2 #numero aleatorio de 2 a -2

_T = np.copy(Theta) #copia de Theta

h = 0.01 #incremento de diferenciacion
lr = 0.01 #ratio de aprendizaje

plt.plot(Theta[0], Theta[1], "o", c="white")


grad = np.zeros(2) #vector/array de 2 posiciones con valor '0'

for _ in range (10000): #bucle de intentos
#calcular la derivada parcial en el mapa
for it, th in enumerate(Theta):
_T = np.copy(Theta)
_T[it] = _T[it] + h #incremento añadido
deriv = (func(_T) - func(Theta)) / h #calcula la diferencia de vectores respecto al incremento
grad[it] = deriv #guarda la derivada parcial en un vector
Theta = Theta - lr * grad #aumenta el vector gradiante respecto el ratio de aprendizaje

# mirar numeros del vector en el mapa: print(func(Theta))

#metodo de diferencias minimas
if ( _ % 100 == 0): #cuando el resto de la division de 100 es 0, haz:
plt.plot(Theta[0], Theta[1], "o", c="red") #coloca el punto al azar en el mapa

plt.plot(Theta[0], Theta[1], "o", c="green") #coloca el punto en el mapa
plt.show() #visualizacion de la matriz

Engañar a el algoritmo de reconocimiento de imagen

import tensorflow as tf
import keras
import matplotlib.pyplot as plt
import numpy as np

from keras.applications.inception_v3 import InceptionV3, decode_predictions
from keras import backend as K

iv3 = InceptionV3() #tocho libreria

print(iv3.summary()) #resumen de la topologia inseptionv3

from keras.preprocessing import image

#cargar imagen en array y ajustar al objetivo de tamaño deseado
x = image.img_to_array(image.load_img("./Direccion_de_la_imagen/imagen.jpg", target_size=(299,299)))
print(x,shape)
#reescalar el rango de intensidades de la imagen de 255 a 1 y de 0 a -1
x /= 255 #dividir x por 255 para obtener rango de 0 y 1
x -= 0.5 #restar 0.5 para reducir el rango de 0 a -0,5 y de 1 a 0,5
x *= 2 #multiplicar por 2 para obtener el rango de -1 a 1

x = x.reshape([1,x.shape[0], x.shape[1], x.shape[2]])#añadir nueva dimension
#para visualizar: print(x.shape)

y = iv3.predict(x) #resultado de x

#para saber el tamaño del vector: print(y.shape)
#para saber que imagen predice el modelo: decode_predictions(y)


#____Ataques adversarios________
inp_layer = iv3.layer[0].input
out_layer = iv3.layer[-1].output

target_class = 951 #la clase objetivo es un limón

out_layer[0, target_class] #maximizar la clase de salida

grad = K.gradients(loss, inp_layer)[0]

#valores de entrada para la optimizacion de inclinacion: [entrada de capa, fase de aprendizaje],[inclinacion y valor de error]
optimize_gradient = K.function([inp_layer, K.learning_phase()],[grad, loss])

adv = np.copy(x) #copia de la imagen (variable X)

pert = 0.01 #perturbacion de la imagen

max_pert = x + 0.01 #limite superior
min_pert = x - 0.01 #limite inferior

cost = 0.0

while cost < 0.95:
gr = optimize_gradient([adv, 0]) #guarda el gradiante en gr optimizado
adv += gr #manipular pixeles en la copia original
adv = np.clip(adv, min_pert, max_pert) #limita los valores de las variables int
adv = np.clip(adv, -1, 1) #limita los valores de las variables float

print("coste objetivo(limon): ", cost) #solo con el GPU de tensorflow instalado

hacked = np.copy(adv)

#revertir el valor de adv [/2][+0.5][*255]
adv /= 2
adv += 0.5
adv *= 255

#visualiza la salida con la conversion de float a int
plt.imshow(adv[0].astype(np.uint8))
plt.show()

from PIL import image
im = image.formarray(adv[0].astype(np.uin8)) #convertir matriz integer a imagen
im.save("./Direccion_de_la_imagen/hacked.png") #guardar la nueva imagen

Red neuronal Topology Learning Ratio dynamic TensorFlow

import numpy as np
import scipy as sc
import matplotlib.pyplot as plt

from sklearn.datasets import make_circles

#Crear Dataset

n = 500 #numero de registros en los datos
p = 2 #numero de caracteristicas que tienen los datos

#hacer un circulo con los datos y caracteristicas separado con un factor de 0.5 y 0.05 de ruido
X, Y = make_circles(n_samples = n, factor = 0.5, noise = 0.05)

Y = Y[:, np.newaxis]

#visualizar (X[...])... donde X => es el eje en el plano

#indice '0' en el vector Y visible en azul claro
plt.scatter(X[Y[:, 0]  == 0, 0], X[Y[:, 0] == 0, 1], c="skyblue") #p=1
#indice '1' en el vector Y visible en salmon
plt.scatter(X[Y[:, 0] == 1, 0], X[Y[:, 0] == 1, 1], c="salmon") #p=2
plt.axis("equal")
plt.show()


class neural_layer(): #crear una clase capa neuronal
#inicia un constructor de numero de conexiones, numero de neuronas y funcion de activacion
def __init__(self,n_conn, n_neur, act_f):
self.act_f = act_f #la act_f = al mismo parametro de act_f
self.b = np.random.rand(1, n_neur)*2 -1 #vector aleatorio con numero 0 como valor medio -1 a 1
self.b = np.random.rand(n_conn, n_neur)*2 -1 #matriz con numero de conexiones necesarias al numero de neuronas

#Funciones de activacion
sigm = (lambda x: 1/(1 + np.e**(-x)), #para un parametro de entrada x, sigm vale:
lambda x: x * (1 - x)) #derivada de sigm
_x = np.linspace(-5, 5, 100) #variable que crea 100 valores de forma lineal de entre -5 y 5

relu = lambda x: np.maximum(0,x) #valor maximo entre 0 y X


plt.plot(_x, sigm[0](_x)) #vista de la grafica con [0]= sigmoide con [1]= derivada



def create_nn(topology, act_f):
nn = []
for l, layer in enumerate(topology[:-1]):
nn.append(neural_layer(topology[l], topology[l+1], act_f))
return nn

topology = [p, 4, 8, 1] #numero de neuronas por capa

neural_net = create_nn(topology, sigm)

l2_cost = lambda Yp, Yr: (np.mean(Yp - Yr)**2), #error cuadratico medio de Yp = valor predicho e Yr = valor real
lambda Yp, Yr: (Yp - Yr)) #derivada del ECM

def train(neural_net, X, Y, l2_cost, lr=0.5, train=True): #funcion de entrenamiento / lr= ratio de aprendizaje
out =[(None, X)] # vectores de suma ponderada y valor de activacion

#Forward pass
for l, layer in enumerate (neural_net):
Z = out[-1][1] @ neural_net[1].W + neural_net[1].b #suma ponderada
a = neural_net[1].act_f[0](z) #activacion de la salida de la capa X
out.append((z,a))
print(l2cost[0](out[-1][1], Y)) #imprime el error

if train: #Si la variable Train es False nunca se ejecuta

#Backward pass (propagacion de error al inicio)
deltas = []
for l in reversed(range(0, len(neural_net)): #añades vectores del final hacia el principio
z = out[l+1][0]
a = out[l+1][1]

if l = len(neural_net) - 1:
#calcular delta ultima capa.
deltas.insert(0,l2_cost[1](a, Y) * neural_net[l].act_f[1](a))

else:
#calcular delta respecto a capa previa.
deltas.insert(0, deltas[0] @ _W.Transpose * neural_net[1].act_f[1](a))
_W = neural_net[l].W #guardado temporal

#Gradient descent
neural_net[l].b = neural_net[l].b - np.mean(deltas[0], axis=0, keepdims=True) * lr #algoritmo de bayas
neural_net[l].W = neural_net[l].W - output[1][1].Transpose @ deltas[0] * lr

return out[-1][1]


train(neural_net, X, Y, l2_cost, 0.5)




NN_exe.py

import time
from IPython.display import clear_output
neural_n = create_nn(topology, sigm)

loss = []
for l in range(2500):
#Entrenamiento de la red neuronal:
pY = train(neural_n, X, Y, l2_cost, lr=0.05)

if i % 25 == 0;
loss.append(l2_cost[0](pY, Y))
res = 50 #resolucion de la pantalla
_x0 = np.linspace(-1.5, 1.5, res)
_x1 = np.linspace(-1.5, 1.5, res)
_Y = np.zeros((res, res))
for l0, x0 in enumerate(_x0):
for l1, x1 in enumerate(_x1):
_Y[l0, l1] = train(neural_n, np.array([[x0, x1]]), Y, l2_cost, train = False)[0][0]
plt.pcolormesh(_x0, _x1, _Y, cmap= "coolware")
plt.axis("equal")
plt.scatter[X[Y[:,0] == 0, 0], X[Y[:,0] == 0, 1], c="skyblue")
plt.scatter[X[Y[:,0] == 1, 0], X[Y[:,0] == 1, 1], c="salmon")

clear_output(wait=True)
plt.show()
plt.plot(range(len(loss)), loss)
plt.show()
time.sleep(0.5)

Ejercicio de regresion lineal

import numpy as np
import scipy as sc
import matplotlib.pyplot as pit
from sklearn.datasets import load_boston

#cargar la libreria
boston = load_boston()
print(boston.DESCR)

X = np.array(boston.data[:,5]) # coger todas las filas de la columna 5
Y = np.array(boston.target)
#np.array convierte datos en matriz

plt.scatter(X,Y, alpha=0.3) #cargar grafica "alpha = transparencia"


#Formula de Minimos Cuadrados Ordinarios
#W=((X^{t}X)^-1)X^{t}Y

X = np.array([np.ones(506),X]).T #colocamos una columna de 1

# formula minimos cuadrados
#inversa de (X transpuesta Multiplicada por X)* Transpuesta de X * Y
W = np.linalg.inv(X.Transpose @ X) @ X.Transpose @ Y

plt.plot([4,9],[W[0]+W[1]*4,W[0]+W[1]*9],c="red") #linea de regresion lineal
plt.show() #visualizar grafica en eje de coordenadas

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