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

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

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:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

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:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

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:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

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!

Arduino (IoT): Simple Tutorial Medición de Corriente UNO vs NANO

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Medición de Corriente UNO vs Nano

En un tutorial anterior vimos como medir la corriente de un MCU, en ese caso una Tosduino UNO.  El consumo era de 46.5mA mientras esta activa.  Luego la pusimos a dormir mediante un sketch y el consumo bajó a 33.3mA.

En este caso lo comparamos con el consumo de una Tosduino Nano (equivalente a una Arduino Nano) y el consumo es de 28.1mA y baja a 21.1mA mientras duerme.

Aquí podemos ver las imágenes de la diferencia en consumo entre la UNO utilizada arriba (anteriormente) versus la Nano:

Arduino IoT Consumo Energético Uno vs Nano Santiapps Marcio Valenzuela
Arduino IoT Consumo Energético Uno vs Nano

Ahora veamos al poner la Nano en Sleep Mode:

Arduino IoT Consumo Energético Uno vs Nano Santiapps Marcio Valenzuela
Arduino IoT Consumo Energético Uno vs Nano

 

Arduino (IoT): Simple Tutorial Proyecto Iluminación Nocturna v2

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Proyecto Iluminación Nocturna v2

En un tutorial anterior vimos el proyecto de iluminación nocturna y si medimos su consumo con una Nano, vemos que el consumo es de 28.8mA.  Si un día tiene 24 horas estamos hablando de 28.8mA x 24hrs = 691mAh.  Una paquete de baterías 1.5V en serie tienen una capacidad de alrededor de 2500mAh.  Esto significa que nuestro proyecto podría operar durante 2500/691 = 3.6 días.

Hay mucho que se puede hacer para reducir el consumo energético de la MCU.  Como vimos podíamos reducir su consumo a 21.1mA en Sleep Mode pero aun así estamos hablando de 4.9 días de operación.  Como es posible que los juguetes duren mas?  Bueno, las MCU tienen un consumo energético alto debido a la LED que llevan y le regulador de voltaje.  Remover estos componentes puede mejorar el consumo a unos 12mA, lo cual nos daría 8.7 días.

Lo ideal es hacer un IC especifico a nuestro proyecto, sin embargo a menos que tengamos nuestra propia linea de producción, eso es muy costoso.  Otra opción es remover la MCU por completo, lo cual por suerte, en nuestro proyecto de iluminación nocturna es posible.  El PIR tiene la opción de conectarle un photoresistor que lo activara solo en la noche.  Luego usamos la fuente de poder para alimentar el PIR que produce una señal que en lugar de llevarla a una MCU para procesamiento, la conectamos a un transistor que amplifica la corriente para encender la LED cuando el PIR se dispara.

El proyecto final se mira asi:

Arduino (IoT) Simple Tutorial Iluminación Nocturna sin MCU Santiapps Marcio Valenzuela
Arduino (IoT) Simple Tutorial Iluminación Nocturna sin MCU

Esto reduce el consumo a básicamente los 20mA de la LED, que los consumirá durante 10 segundos cada ciclo de disparo.  Si asumimos unos 10 ciclos por noche, en realidad por día o 24 hrs, hablamos de un consumo de 100 segundos al dia.  Esto es alrededor de 0.03hrs, ósea 20mA x 0.03hrs = 0.55mAh lo cual, para 2500mAh de capacidad equivale a 4,166 días.