GISEPROI

Es un mecanismo de resolución de problemas inspirado en la presunta estructura biológica cognitiva del ser humano. En las redes neuronales artificiales, la solución se construye a partir de transformaciones sucesivas de los datos de entrada.

La unidad más simple de transformación se conoce como neurona artificial y su labor es aplicar una función a los datos de entrada. En estas neuronas, usualmente, los datos de entrada se ponderan para que la transformación pueda corresponder (lo más cercano posible) a la salida esperada.

Un ejemplo simplificado: Tomemos una neurona -un poco perezosa, cuya función de transformación es no hacer nada al dato de entrada, es decir, el dato de salida de la neurona es igual al dato de entrada:

f(x)=x 

Y digamos que nuestra neurona debe transformar 5 unidades en 1 unidad:

Figura: Entrada y salida esperada de la neurona

 

Obviamente, solo la función de transformación de nuestra neurona perezosa es insuficiente para cumplir la tarea asignada y requiere “ponderar”, o multiplicar, la variable de entrada por ⅕ para generar el esperado 1. 

Figura: Neurona perezosa con peso para la variable de entrada

 

En el vocabulario de las redes neuronales se conoce como peso (w), al valor por el cual se multiplican las variables de entrada para ponderarlas. 

 

Siguiendo con nuestro ejemplo de neurona perezosa, ahora le ponen la tarea de transformar 5 unidades en 1.247 unidades. Como es tan perezosa, encuentra que ya tiene un peso asignado y simplemente decide “ajustar” ese valor sumándole el 0.247 que le hace falta y así alimentar a su perezosa función de transformación.

Figura: Neurona perezosa con peso y ajuste

 

Ese ajuste se conoce con el anglicismo de bias y es el segundo mecanismo de ajuste de las variables de entrada de las neuronas.

 

Esta conjunto de operaciones de transformación de la neurona se podría expresar como:

y= f(x*w + b)

Siendo:

       x   : Valor de entrada

       w  :  Peso

        b  :  Ajuste (bias)

       f():   Función de transformación

 

Calibración de pesos y bias

Partiendo del último diseño de la neurona perezosa, se asumirá que el valor del peso es desconocido y el ajuste es 0.

Se plantea una optimización simple – digamos que por “fuerza bruta”:

• De manera aleatoria, asignar un valor al peso, para esta explicación se toma:

w=0

• Calcular la salida (pronóstico) de la neurona:

y=x*w+b=5*0+0=0

• Determinar ¿qué tan diferente es el pronóstico (salida de la neurona) a la salida esperada?. Esto se denominará función de pérdida y una técnica utilizada es el error cuadrático.

error=(Ve – Vp)²

Donde:

    Ve: Valor de salida esperado
    Vp: Valor de salida obtenido (pronóstico)

Como ejemplo, consideramos que el error cuadrático es aceptable cuando sea menor a 0.1.

error=(Ve – Vp)2=(1.247-0)²=1.555

Como puede verse el valor asignado al peso no es exitoso pues error > 0.1 .

• Ajustar el peso para disminuir el error (optimizar). Vamos a usar incrementos de 0.1. Así, el nuevo valor del peso sería:

w=0+0.1=0.1

Con este nuevo peso volvemos a generar un pronóstico y calcular el error cuadŕatico:

y=x*w+b=5*0.1+0=0.5

error=(1.247-0.5)²=0.558

El error ha disminuido pero aún es superior al umbral de éxito, así que volvemos a cambiar el peso y repetir el proceso:

w=0.1+0.1=0.2

y=x*w+b=5*0.2+0=1

error=(1.247-1)²=0.061

Para este caso el umbral de éxito se alcanza y “paramos” la acomodación del peso.

1. Por último se coloca un ajuste (bias) que permita cumplir con la transformación deseada.

b= Ve-Vp=1.247 – 1=0.247

Y así, la neurona perezosa estaría configurada (entrenada).

Un mecanismo para visualizar archivos TIF en Cesium consiste en “teselar” la imagen TIF y luego cargar la teselas generadas empleando un Proveedor de imágenes vía URL.

Un procedimiento “básico” para lograr esto es (el código fuente está disponible en https://gitlab.com/paulocoronado/tif-con-cesium/):

1. Ir a la carpeta en donde está desplegado Cesium y crear una carpeta llamada tiles.

2. A partir de la imagen TIF original, crear un teselado TMS (Tile Map Service) usando gdal2tiles 

gdal2tiles.py -p geodetic –zoom=0-11 -d original.tif tiles/

3. En un script crear un objeto para el visor Cesium: 

let viewer = new Cesium.Viewer(‘cesiumContainer’); 

4. Crear un objeto para el proveedor de imágenes:

let tms = new Cesium.UrlTemplateImageryProvider({     
url :’tiles/{z}/{x}/{reverseY}.png’,     
tilingScheme :newCesium.GeographicTilingScheme(),
maximumLevel:11 
}); 

5. Agregar el nuevo proveedor de imágenes a las capas de imágenes del visor: 

let layers = viewer.scene.imageryLayers;
let tif = layers.addImageryProvider(tms); 

Con esto se tendrá un visor cesium mostrando una imagen correspondiente al TIF optimizada para 11 niveles de zoom.  

Lista de Chequeo:

• En AWS IoT Core:
  • Se creó una nuevo dispositivo (thing)
  • Se descargó el certificado y la llave privada.
  • Se creó una política con los permisos suficientes.
  • Se ató la política al certificado.
• En el programa del NodeMCU:
  • Se colocó el certificado y la llave privada en formato hexadecimal (incluyendo la variable que contiene la longitud de cada uno de ellos).
  • Se colocó la cadena del endpoint que representa al servidor MQTT.

Este es un proyecto simple para obtener un sensor de proximidad utilizando la tarjeta microcontroladora NodeMCU ESP8266 y el módulo HC – SR04.

Listado de Componentes

• Tarjetas microcontroladora NodeMCU basada en ESP 8266.
• Módulo HC- SR04 (sensor de ultrasonido).
• 4 cables para conexión.

En este proyecto la placa se conectará al puerto USB del computador por lo cual no se requiere una fuente de poder externa.

Conexiones

Las instrucciones son para la placa Lolin v.3, que tiene un distribución de pines como la que se muestra en la figura (1):

 

Tomado de https://www.teachmemicro.com/nodemcu-pinout/

Las conexiones son:

NodeMCU                       HC – SR04

D0                —————-     Trig

D1                —————-     Echo

VU                —————-     VCC

G                  —————–     GND

 

Cableado del sensor.

Código Fuente

const int triggerPin = 16; //D0
const int echoPin = 5; //D1 long duracion;
float distancia; void setup() {
pinMode(triggerPin, OUTPUT);
pinMode(echoPin, INPUT);
Serial.begin(9600);

}

void loop() {

digitalWrite(triggerPin, LOW);
delayMicroseconds(2); // Iniciar elproceso de envío de ultrasonido
digitalWrite(triggerPin, HIGH);
delayMicroseconds(10);
digitalWrite(triggerPin, LOW); // https://www.arduino.cc/reference/en/language/functions/advanced-io/pulsein/
duracion = pulseIn(echoPin, HIGH); Serial.print(“Duración: “);
Serial.println(duracion); // Calcular la distancia
distancia= duracion*0.034/2; Serial.print(“Distancia: “);
Serial.println(distancia);
delay(500);

}

 

A partir del año 2019 GISEPROI densifica su portafolio de servicios en torno a las siguientes 7 temáticas:

• Seguridad de la Información.
• Arquitectura empresarial.
• Internet de las Cosas.
• Aprendizaje de Máquina.
• Desarrollo de sistemas de información de código abierto.
• Tecnología educativa.
• Realidad Virtual, aumentada y mixta.