Ingeniería Mecatrónica

INTRODUCCIÓN ANN 19-11-2020

Lenguajes de Programación
Brian Steven Valencia Ulchur
brianvalencia@unicomfacauca.edu.co

Resumen que brindan valiosas funcionalidades como cálculo cien-

tífico, manejo de ventanas, multiprocesamiento, manejo
Esta práctica consta de realizar la prueba y aprendiza- de puerto serie, funciones de red, etc.[2]
je de los códigos que nos proporcionó el docente a car-
go de la materia, de redes neuronales artificiales con las
cuales es simular posible el comportamiento y función
del cerebro humano, todo esto con el fin de analizar unos
ejercicios con los cuales se pone a prueba una red neuro-
nal artificial.
Figura 1: PYTHON
1 Introducción
Para esta práctica se trabajó con Artificial Neural Net- 1.2 Hardware
work (ANN), en español seria sobre las Redes Neurona-
les Artificiales, estas están inspiradas en las redes neuro- Se ocupa de un computador, ya sea portátil o de mesa,
nales biológicas del cerebro humano. Están constituidas con todos sus implementos.
por elementos que se comportan de forma similar a la
neurona biológica en sus funciones más comunes. Estos
elementos están organizados de una forma parecida a la
que presenta el cerebro humano. Los modelos de ANN
son dirigidos a partir de los datos, es decir, son capa-
ces de encontrar relaciones (patrones) de forma induc-
tiva por medio de los algoritmos de aprendizaje basado
en los datos existentes más que requerir la ayuda de un
modelador para especificar la forma funcional y sus in-
teracciones. Las ANN se basan en la analogía que existe
en el comportamiento y función del cerebro humano, en
particular del sistema nervioso, el cual está compuesto
por redes de neuronas biológicas que poseen bajas capa-
cidades de procesamiento, sin embargo, toda su capaci-
dad cognitiva se sustenta en la conectividad de éstas.[1] Figura 2: COMPUTADOR PORTÁTIL
Todo esto se hace con la función de trabajar unos códi-
gos proporcionados por el docente los cuales se conside-
ran diferentes tipos de neuronas, dos ejercicios se pue-
den trabajar para funciones de vista, hablar, entre otras, 2 Materiales y métodos
y el último ejercicio es para definir un comportamiento
dentro de la función silla de montar para aprender cuan- No se necesitó de muchos implementos para esta prác-
tos elementos pueden estar en esa silla de montar. tica, solo los que se mostrarán a continuación.
LISTA DE MATERIALES
1.1 Software
*COMPUTADOR
Para esta práctica se trabajó con el programa Python el *SOFTWARE
cual puede ser utilizado tanto para scripting como para *INTERNET
programación orientada a objetos, posee tipos dinámi-
cos, tipos primitivos de alto nivel como listas, dicciona- El método para realizar la práctica fue comprobar los
rios y tuplas, y una abundante biblioteca de módulos, códigos para saber si funcionaba correctamente.

1
 Ingeniería Mecatrónica

3 Resultados valores negativos a cero y entre más cercano sea a cero,

éste mejora. *Para el segundo ejercicio se obtuvieron los
Los resultados obtenidos fueron buenos. *Para el pri- siguientes resultados:
mer ejercicio se obtuvieron los siguientes resultados:

Figura 3: RESULTADOS 1
Figura 6: RESULTADOS 2
Aquí se observa una tasa de clasificación, ósea que se
representa como una red neuronal la cual poco a poco va
aprendiendo a clasificar los datos.
En este ejercicio es muy similar al primero solo que
n este se tendrá una función que ira hacia adelante en
cambio la primera iba hacia atrás.

Figura 4: RESULTADOS 1
Figura 7: RESULTADOS 2

Aquí se observa datos que se generan automáticamen-

te y la meta es que la maquina diga que hay 3 conjuntos
de datos.
En la tasa de clasificación se ve que los pesos son es-
cogidos aleatoriamente y entre más cercano este de cero
es mucho más seguro. *Y a continuación mostraré los re-
sultados que me dio en el tercer ejercicio

Figura 5: RESULTADOS 1

Figura 8: RESULTADOS 3
Aquí se clasifica el error y como se observa va desde

2
 Ingeniería Mecatrónica

Figura 9: RESULTADOS 3 Figura 12: RESULTADOS 3

En este código de “regresión” es para definir un com-

portamiento dentro de la función silla de montar. La red
neuronal puede saber cuándo está en esa silla de montar.
Este es un plano de colores de la silla de montar, es
una forma de graficar a color.

Figura 10: RESULTADOS 3

Figura 13: RESULTADOS 3

Se muestra como en 200 interacciones se acerca a cero,
ósea 200 interacciones para mejorar.

Aquí se observa la derivada de la función de regresión,

en su valor máximo.

Figura 11: RESULTADOS 3 3.1 Códigos

Aquí se mira como mejora. Fueron necesarios 3 códigos para la práctica completa.

3
 Ingeniería Mecatrónica

CÓDIGO 1 CÓDIGO 1.1

from __future__ import print_function, division def derivative_b2(T, Y):
from builtins import range return (T - Y).sum(axis=0)
def derivative_b1(T, Y, W2, Z):
return ((T - Y).dot(W2.T) * Z * (1 - Z)).sum(axis=0)
import numpy as np def cost(T, Y):
import matplotlib.pyplot as plt tot = T * np.log(Y)
return tot.sum()
def main():
np.random.seed(1)

# create the data

def forward(X, W1, b1, W2, b2): Nclass = 500
Z = 1 / (1 + np.exp(-X.dot(W1) - b1))
A = Z.dot(W2) + b2 D = 2 # dimensionality of input
expA = np.exp(A) M = 3 # hidden layer size
Y = expA / expA.sum(axis=1, keepdims=True) K = 3 # number of classes
X1 = np.random.randn(Nclass, D) + np.array([0, -2])
return Y, Z X2 = np.random.randn(Nclass, D) + np.array([2, 2])
X3 = np.random.randn(Nclass, D) + np.array([-2, 2])
# determine the classification rate X = np.vstack([X1, X2, X3])
# num correct / num total Y = np.array([0]*Nclass + [1]*Nclass + [2]*Nclass)
def classification_rate(Y, P): N = len(Y)
n_correct = 0
n_total = 0
for i in range(len(Y)): # turn Y into an indicator matrix for training
n_total += 1 T = np.zeros((N, K))
if Y[i] == P[i]: for i in range(N):
n_correct += 1 T[i, Y[i]] = 1

return float(n_correct) / n_total

# let's see what it looks like
plt.scatter(X[:,0], X[:,1], c=Y, s=100, alpha=0.5)
def derivative_w2(Z, T, Y): plt.show()
N, K = T.shape # randomly initialize weights
M = Z.shape[1] # H is (N, M) W1 = np.random.randn(D, M)
# fastest - let's not loop over anything b1 = np.random.randn(M)
ret4 = Z.T.dot(T - Y) W2 = np.random.randn(M, K)
# assert(np.abs(ret1 - ret4).sum() < 0.00001) b2 = np.random.randn(K)
learning_rate = 1e-3
costs = []
return ret4
def derivative_w1(X, Z, T, Y, W2): for epoch in range(1000):
N, D = X.shape output, hidden = forward(X, W1, b1, W2, b2)
M, K = W2.shape if epoch % 100 == 0:
c = cost(T, output)
P = np.argmax(output, axis=1)
Y[n,k])*W2[m,k]*Z[n,m]*(1 - Z[n,m])*X[n,d] r = classification_rate(Y, P)
# fastest print("cost:", c, "classification_rate:", r)
dZ = (T - Y).dot(W2.T) * Z * (1 - Z) costs.append(c)
ret2 = X.T.dot(dZ)
# assert(np.abs(ret1 - ret2).sum() < 0.00001) # this is gradient ASCENT, not DESCENT
return ret2 # be comfortable with both!
# oldW2 = W2.copy()
W2 += learning_rate * derivative_w2(hidden, T, output)
b2 += learning_rate * derivative_b2(T, output)
W1 += learning_rate * derivative_w1(X, hidden, T,
,→ output, W2)
b1 += learning_rate * derivative_b1(T, output, W2,
,→ hidden)

plt.plot(costs)
plt.show()
if __name__ == '__main__':
main()

Con este código se quiso buscar que la maquina diga

4
 Ingeniería Mecatrónica

que hay 3 conjuntos de datos. CÓDIGO 3

CÓDIGO 2 from __future__ import print_function, division

from builtins import range
from __future__ import print_function, division
from builtins import range import numpy as np
import matplotlib.pyplot as plt
import numpy as np from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
# generate and plot the data
Nclass = 500 N = 500
X = np.random.random((N, 2))*4 - 2 # in between (-2, +2)
X1 = np.random.randn(Nclass, 2) + np.array([0, -2]) Y = X[:,0]*X[:,1] # makes a saddle shape
X2 = np.random.randn(Nclass, 2) + np.array([2, 2]) # note: in this script "Y" will be the target,
X3 = np.random.randn(Nclass, 2) + np.array([-2, 2]) # "Yhat" will be prediction
X = np.vstack([X1, X2, X3])
fig = plt.figure()
Y = np.array([0]*Nclass + [1]*Nclass + [2]*Nclass) ax = fig.add_subplot(111, projection='3d')
ax.scatter(X[:,0], X[:,1], Y)
# let's see what it looks like plt.show()
plt.scatter(X[:,0], X[:,1], c=Y, s=100, alpha=0.5)
plt.show() # make a neural network and train it
D=2
# randomly initialize weights M = 100 # number of hidden units
D = 2 # dimensionality of input
M = 3 # hidden layer size # layer 1
K = 3 # number of classes W = np.random.randn(D, M) / np.sqrt(D)
W1 = np.random.randn(D, M) b = np.zeros(M)
b1 = np.random.randn(M)
W2 = np.random.randn(M, K) # layer 2
b2 = np.random.randn(K) V = np.random.randn(M) / np.sqrt(M)
c=0
def sigmoid(a):
return 1 / (1 + np.exp(-a)) # how to get the output
# consider the params global
def forward(X, W1, b1, W2, b2): def forward(X):
Z = sigmoid(X.dot(W1) + b1) # sigmoid Z = X.dot(W) + b
# Z = np.tanh(X.dot(W1) + b1) # tanh Z = Z * (Z > 0) # relu
# Z = np.maximum(X.dot(W1) + b1, 0) # relu # Z = np.tanh(Z)
A = Z.dot(W2) + b2
expA = np.exp(A) Yhat = Z.dot(V) + c
Y = expA / expA.sum(axis=1, keepdims=True) return Z, Yhat
return Y
# how to train the params
# determine the classification rate def derivative_V(Z, Y, Yhat):
# num correct / num total return (Y - Yhat).dot(Z)
def classification_rate(Y, P):
n_correct = 0 def derivative_c(Y, Yhat):
n_total = 0 return (Y - Yhat).sum()
for i in range(len(Y)):
n_total += 1 def derivative_W(X, Z, Y, Yhat, V):
if Y[i] == P[i]: # dZ = np.outer(Y - Yhat, V) * (1 - Z * Z) # this is for tanh
,→ activation
n_correct += 1
return float(n_correct) / n_total dZ = np.outer(Y - Yhat, V) * (Z > 0) # relu
return X.T.dot(dZ)
P_Y_given_X = forward(X, W1, b1, W2, b2)
P = np.argmax(P_Y_given_X, axis=1) def derivative_b(Z, Y, Yhat, V):
# dZ = np.outer(Y - Yhat, V) * (1 - Z * Z) # this is for tanh
# verify we chose the correct axis ,→ activation
assert(len(P) == len(Y)) dZ = np.outer(Y - Yhat, V) * (Z > 0) # this is for relu
,→ activation
print("Classification rate for randomly chosen weights:", return dZ.sum(axis=0)
,→ classification_rate(Y, P))
def update(X, Z, Y, Yhat, W, b, V, c, learning_rate=1e-4):
gV = derivative_V(Z, Y, Yhat)
gc = derivative_c(Y, Yhat)
Con este código, al igual que le primer ejercicio, se gW = derivative_W(X, Z, Y, Yhat, V)
quiso buscar que la maquina diga que hay 3 conjuntos gb = derivative_b(Z, Y, Yhat, V)
de datos, pero con una función que irá hacia adelante.

5
 Ingeniería Mecatrónica

CÓDIGO 3.1
V += learning_rate*gV
c += learning_rate*gc
W += learning_rate*gW
b += learning_rate*gb

return W, b, V, c

# so we can plot the costs later

def get_cost(Y, Yhat):
return ((Y - Yhat)**2).mean() Figura 14: MONTAJE

# run a training loop No es necesario instalar alguna librería y nada en es-

# plot the costs pecífico para la práctica.
# and plot the final result
costs = []
for i in range(200):
Z, Yhat = forward(X)
4 Análisis de Resultados
W, b, V, c = update(X, Z, Y, Yhat, W, b, V, c)
cost = get_cost(Y, Yhat) Al mirar los resultados obtenidos, se puede observar
costs.append(cost) que los resultados son buenos, primero se debe revisar y
if i % 25 == 0:
print(cost)
entender el funcionamiento de los códigos para ver los
resultados se pueden generar y al ya generar estos resul-
# plot the costs tados, se observa como la red neuronal aprende rápida-
plt.plot(costs) mente y clasifica sus errores e intenta mejorar.
plt.show()

# plot the prediction with the data

fig = plt.figure() 5 Conclusiones
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X[:,0], X[:,1], Y) El desempeño de esta práctica fue bueno ya que se ob-
tuvo los resultados esperados, las conclusiones que se
# surface plot
line = np.linspace(-2, 2, 20) pueden sacar son: 1) Es posible decir que fue increíble
xx, yy = np.meshgrid(line, line) como la red neuronal artificial aprende rápidamente pa-
Xgrid = np.vstack((xx.flatten(), yy.flatten())).T ra generar datos con una tasa mínima de error. 2) Se pue-
_, Yhat = forward(Xgrid)
ax.plot_trisurf(Xgrid[:,0], Xgrid[:,1], Yhat, linewidth=0.2,
de implementar esta idea para realizar un proyecto en el
,→ antialiased=True) que con ayuda de la red neuronal se busque mejorar y
plt.show() tener las mínimas fallas en el proceso de este. 3) Las re-
des neuronales artificiales tienen un amplio campo de
# plot magnitude of residuals
Ygrid = Xgrid[:,0]*Xgrid[:,1]
aplicaciones donde se requiera la solución a problemas,
R = np.abs(Ygrid - Yhat) desde actividades de investigación hasta aplicaciones co-
merciales e industriales.
plt.scatter(Xgrid[:,0], Xgrid[:,1], c=R)
plt.show()

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_trisurf(Xgrid[:,0], Xgrid[:,1], R, linewidth=0.2,
,→ antialiased=True)
plt.show()
Con este código se quiso ver el comportamiento de la
red neuronal dentro la función silla de montar.
3.2 Montajes y funcionamiento
Referencias
[1] Rodrigo Salas. Redes neuronales artificiales. Univer-
sidad de Valparaıso. Departamento de Computación, 1,
2004.
[2] Graciela De Luca, Martín Cortina, Nicanor Casas, Es-
teban Andrés Carnuccio, Sebastián Barillaro, Daniel
Giulianelli, and Sergio Martín. Desarrollo de un pro-
totipo para un visualizador de estructuras de un sis-
tema operativo en ejecución a través de la comunica-
ción serial. 2019.

Para el funcionamiento de esta práctica, solo fue nece-

sario, descargar una carpeta con los códigos.