Internet Of Things (IoT): Inteligencia Artificial via Neural Networks Parte 1

Para que se usa?

Para modelar el comportamiento complejo en el pasado y usar el modelo para pronosticar el futuro comportamiento.

Ejemplo: Un cliente con ciertas características (compras mensuales, compras por categoría histórica) cuanto nos comprara en los siguientes meses?

Ejemplo: Una imagen leída por una computadora con ciertas características (lineas horizontales, diagonales, colores, etc) es una persona o un objeto?

Como funciona?

Todo sistema bajo estudio (imagen, comportamiento de compra) tiene una capa de ingreso de información en la izquierda llamados inputs, capas ocultas y una capa final de resultados:

Una neural network o red neural tiene 3 capas:

1. Capa Input (ingreso o variables conocidas)
2. Capa Oculta (interacciones entre variables o factores)
3. Capa Output (resultado final buscado)

Cada variable o factor tiene un peso e interactua para crear un nodo en la capa oculta.  Pueden haber varias capas ocultas pero en nuestro ejemplo sencillo solo hay una capa oculta.

Neural Networks toman en cuenta la interacción entre todos los inputs entre ellos mismos, no solo la interaccion de los inputs sobre el output final.

Veamos un ejemplo sencillo:

Tenemos:

Capa Input:  2 variables, digamos que el cliente ha hecho 2 compras mensuales con valores de 3mil cada una.  Una variable es el numero de compras mensuales y la otra es el valor de cada compra.

Capa Oculta: Cada variable o factor interactua entre si y genera un nodo.  Por ende tenemos 2 nodos; uno con valor 5 y otro con valor 1.  Como se calculan esos nodos?

Cada factor o variable tiene un peso que significa la magnitud con la cual esa variable afecta el proximo resultado.  Esos resultados se conocen como nodos de la capa oculta.  En nuestro ejemplo, el nodo superior de la capa oculta es afectado con pesos de 1 y 1 por el input 2 y 3, respectivamente.  Por otro lado, el nodo inferior de la capa oculta es afectado con pesos de -1 y 1 por el input 2 y 3, respectivamente.  Usamos reglas de vector para multiplicar.sumar y obtener el resultado del nodo superior:

2×1 = 2

3×1 = 3

2+3=5

De igual forma ahora para el nodo inferior:

2x-1 = -2

3×1 = 3

-2+3=1

Finalmente cada nodo de la capa oculta tiene su peso, 2 y -1.  Esto nos genera:

5×2 = 10

1x-1 = -1

10 + -1 = 9

Lo que vamos a hacer ahora es un ejemplo mas complejo pero ayudados por la tecnología.  En python existe la siguiente library (https://www.scipy.org/install.html) que podemos instalar usando:

python -m pip install --upgrade pip

y

pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

Luego creamos un archivo:

sudo nano neural1.py

y agregamos el código para nuestra red neural.  Veamos el ejemplo que es ligeramente mas complejo:

Como pueden ver tenemos 2 variables y 2 capas ocultas:

Los pasos serán:

1. Importar numpy, la library descargada
2. Crear el array de inputs [3,5]
3. Crear el diccionario de arrays de pesos
4. Crear una función de activación llamada relu que toma el input y retorna el valor máximo o 0.
5. Finalmente creamos la función predecir_con_red().  Este paso esta desglosado al final del código.

Codigo

import numpy as np
input_data=np.array([3,5])
weights={'node_0_0': np.array([2,4]),
'node_0_1': np.array([4,-5]),
'node_1_0': np.array([-1,1]),
'node_1_1': np.array([2,2]),
'output': np.array([-3,7])}
def relu(input):
'''Define your relu activation function here'''
# Calculate the value for the output of the relu function: output
output = max(0, input)
# Return the value just calculated
return(output)
def predecir_con_red(input_data):
# Calculate node 0 in the first hidden layer
node_0_0_input = (input_data * weights['node_0_0']).sum()
node_0_0_output = relu(node_0_0_input)
# Calculate node 1 in the first hidden layer
node_0_1_input = (input_data * weights['node_0_1']).sum()
node_0_1_output =relu(node_0_1_input)
# Put node values into array: hidden_0_outputs
hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
# Calculate node 0 in the second hidden layer
node_1_0_input = (hidden_0_outputs * weights['node_1_0']).sum()
node_1_0_output = relu(node_1_0_input)
# Calculate node 1 in the second hidden layer
node_1_1_input = (hidden_0_outputs * weights['node_1_1']).sum()
node_1_1_output = relu(node_1_1_input)
# Put node values into array: hidden_1_outputs
hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
# Calculate model output: model_output
model_output = (hidden_1_outputs * weights['output']).sum()
# Return model_output
return(model_output)
output = predecir_con_red(input_data)
print(output)

• Primero calculamos el nodo 0 de la capa 0, node_0_0_input.
• Segundo aplicamos la relu para obtener node_0_0_output.
• Tercero, repetimos para el segundo nodo, node_0_1_input y node_0_1_output.
• Almacenamos el resultado de ambos nodos en el array hidden_0_outputs.
• Ahora repetimos para los nodos de la siguiente capa oculta, node_1_0_output y node_1_1_output, su relu y almacenamos los resultados de ambos nodos en el array hidden_1_outputs.
• Repetimos para el modelo final y listo.

Nos debería dar los mismos 364!