Neural Compute Stick Movidius

En los últimos años se escuchado el término de “machine learning” y los procesos que han existido para el análisis de los datos normalmente han sido ejecutados a través de la nube, sin embargo el Neural Compute Stick Movidius INTEL viene a ofrecer una alternativa adicional al proceso a través de un procesamiento local.

El Movidius Neural Compute Stick es el primer kit de aprendizaje basado en USB, que permite acelerar el entrenamiento de AI (Inteligencia Artificial), con una capacidad de procesamiento de una red neuronal.

El dispositivo utiliza una VPU (Vision Processing Unit) Myriad 2 personalizada que ofrece una potencia de 100 GFLOPs con un consumo de 1 vatio y 4GB de memoria LPDDR3, sin embargo una de las características que más me llamo la atención es el “multi-stick”, lo que permite utilizar varias unidades del Movidius Neural Compute Stick para que trabajen en forma conjunta (Si se conectaran 4 Movidius, tendríamos 400 GFLOPS de potencia, lo que es increíble para un USB que tiene un precio $79).

Caracteristicas relevantes:

  • Compilar: Movidius convierte automáticamente una red neuronal convolucional (CNN) basada en Caffe y ya entrenada en una red neuronal integrada y optimizada para operar directamente en la VPU Myriad 2 de Movidius.
  • Ajustar: Permite realizar ajustes efectivos para obtener un rendimiento óptimo con datos reales y con un consumo ultra bajo. Los scripts de validación permiten comparar la precisión de los modelos optimizados en el dispositivo con la de los modelos originales.
  • Acelerar: El Movidius Neural Compute es el único capaz de actuar como un acelerador periférico de redes neuronales añadiendo la capacidad de aprendizaje profundo a las actuales plataformas informáticas para mejorar el rendimiento y la eficiencia.

Conceptos relacionados:

  • VPU (Vision Processing Unit): Es un tipo de acelerador diseñado para procesamiento de argumentos gráficos, como redes neuronales profundas, estimación de pose, detección de profundidad 3D, entre otros.
  • CPU Risc (Reduced Instruction Set Computer): No se trata de usar pocas instrucciones, si no de simplificar la carga de datos de memoria sin realizar operaciones sobre ellos.

NOTA: La siguiente imagen es con fines ilustrativos, únicamente para conocer el Neural Compute Stick por dentro, no intente esto en casa!

123 Listo – Instalar Arduino IDE en Linux

Objetivo: Instalar ARDUINO IDE en su computador con Linux (Se ha probado en Ubuntu 16.04)

  1. Diríjase a la página: https://www.arduino.cc
    1. En la pestaña software seleccione Linux. Si no sabe la cantidad de bits de su sistema ejecute el siguiente comando en terminal: uname –i. El segundo número es la cantidad de bits.
    2. Descargue el archivo,
    3. Una vez descargado, descomprima el archivo usando los siguientes comandos en terminal:
      cd $home
      cd Downloads
      tar -xf arduino         #(presione tab para autocompletar)
      cd arduino              #(presione tab para autocompletar)
      ./install.sh
    4. Después de terminada la instalación ejecute el siguiente comando poniendo su nombre de usuario para poder acceder a los puertos usb de la computadora:
      sudo usermod -aG dialout suNombreDeUsuario
    5. Ahora reinice la computadora
      reboot

¡Listo!

Comandos por BLE – (Parte 1 de 2) – El Receptor

Para continuar la exploración de la tecnología BLE que comenzó nuestra compañera Rebeca Rodriguez Tencio acá, les presentamos este primer tutorial de dos relacionados. La idea es poder implementar una forma de enviar comandos a una tarjeta de prototipado via Bluetooth Low Energy (BLE) desde una App de un teléfono Móvil.

En esta primera parte implementaremos un servicio “Comando LED” en un microcontrolador compatible con Arduino 101 llamado TinyTILE (basado en el chip Curie de Intel)

En la segunda parte, implementaremos una App (Android y IOS) usando IONIC 3 que le envía comandos al micro-controlador mediante el sistema BLE del teléfono.

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.

Primero: Programemos el Curie

En resumen:

  1. Necesitaremos un protoboard, un LED, una resistencia de 150 Ohm, un TinyTILE y un cable USB a micro-USB y una PC
  2. El circuito es muy sencillo:


  3. En la PC instalamos los controladores de placa “Arduino/Genuino 101” en el IDE de ARDUINO (V.1.8.2)
    • Menu: Tools >  Board > Board Manager > Search “Curie” > Instalar V 2.0.2 o superior.
  4. Descargamos el programa (sketch) de ejemplo de mi repositorio de Github y lo abrimos con el IDE de ARDUINO.
  5. Instalamos el boceto de ejemplo en la placa
    • Menu: Sketch > Upload
  6. Usamos una app para pruebas BLE denominada “BLE Scanner” para enviar comandos “ON” y “OFF”
  7. Nótese que hemos implementado una función “parpadear” que nos permite ver si el sketch arrancó adecuadamente.

Las siguientes imágenes ilustran el uso de BLE Scanner para enviar los comandos.

Seguidamente mostramos el código original del programa con los comentarios detallados sobre su funcionamiento. Es realmente sencillo; podemos resumirlo en:

  1. Definir un servicio BLE “ServicioBLE_Comando” (línea 5)
  2. Deinir una característica BLE “CaracteristiciaBLE_Comando” de tipo genérica, de lectura y escritura con mensajes de 20 bytes (línea 8)
  3. Darle un nombre al dispositivo “COMANDO LED” e inicializarlo, agregando el servicio y la característica (línea 19)
  4. Publicitamos el servicio (línea 23)
  5. Leemos eventos BLE en la característica (nuevos comandos) que luego son interpretados y ejecutados (líneas 31,33,57,61)
  6. Para esto convertimos el valor recibido a un String (línea 63)

 


#include <CurieBLE.h>
#define ledPin 13

//Definimos un servicio BLE
BLEService servicioBLE_Comandos("db938b80-f010-44b6-8aa9-1835adf9419a"); // create service

//Definimos una característica que pueda ser leida o escrita desde una central BLE, con capacidad de 20 bytes por mensaje.
BLECharacteristic caracteristicaBLE_Comandos("9906064e-9bbe-4eba-b415-bbd223f7d3d9", BLERead | BLEWrite, 20);

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT); 
  delay(500); //Esperamos un poco de tiempo (500ms) por si se puede habilitar la terminal serial.
  parpadear(5,200);//Señalizamos con el LED que estamos iniciando el sketch
  
  BLE.begin(); //Inicializamos el sistema Bluetooth Low Energy (BLE) del Curie
  parpadear(2 ,100);//Señal de aviso de que la operación anterior fue exitosa
  
  BLE.setLocalName("COMANDO LED"); //Definimos un nombre para publicitar nuestro dispositivo
  BLE.setAdvertisedService(servicioBLE_Comandos);//Definimos el servicio que se va a publicitar
  servicioBLE_Comandos.addCharacteristic(caracteristicaBLE_Comandos); //Agregamos la característica al servicio
  BLE.addService(servicioBLE_Comandos); //Agregamos el servicio al dispositivo  
  BLE.advertise(); // Publicitamos el dispositivo
  parpadear(3 ,100);//Señal de aviso de que la operación anterior fue exitosa

  Serial.println("En este punto el dispositivo queda listo, publicitado y esperando conexiones...");
  parpadear(10,50);//Señal de aviso de que SETUP se concluyó satisfactoriamente
}

void loop() {
  BLE.poll(); // Obtenemos cualquier evento BLE que haya sido enviado al dispositivo

  if (caracteristicaBLE_Comandos.written()) { //Si hay datos, ejecutamos el comando
    leerYEjecutarComado();
  } // ... caso contrario simplemente se termina el flujo de loop()
}

/**
 * Este método lee el comando registrado en la característica BLE y lo ejecuta.
 */
void leerYEjecutarComado(){
    String valorDelComando = obtenerValorDelComando();

    if (valorDelComando.startsWith("ON")) {
      Serial.println("LED on");
      digitalWrite(ledPin, HIGH);
    } else {
      Serial.println("LED off");
      digitalWrite(ledPin, LOW);
    }
}

/**
 * Extraer el valor del comando en formato String
 */
String obtenerValorDelComando(){
    int longitudDelComando = caracteristicaBLE_Comandos.valueLength();
    Serial.print("Longitud: ");
    Serial.println(longitudDelComando);
      
    const byte* val = caracteristicaBLE_Comandos.value();
    
    String strValor = String((const char *)val).substring(0, longitudDelComando);
    Serial.println("|" + strValor + "|");

    return strValor;
}

void parpadear(int times, int milliseconds){
  for(int i=0; i<times; i++){
    digitalWrite(ledPin, HIGH);
    delay(milliseconds);
    digitalWrite(ledPin, LOW);
    delay(milliseconds);
  }
}

 

 

Soporte del Intel Realsense para Ubuntu

http://reconstructme.net/wp-content/uploads/2015/11/r200.jpg

¿Realsense? ¿Que tiene de especial esta cámara?

Pués, la cámara Intel Realsense R200 posee 3 cámaras, las cuales en conjunto con sensores integrados permite generar ambientes en 3 Dimensiones hasta distancias de 5 a 10 metros. 1 cámara brinda imágenes RGB, y las otras 2 brindan imágenes infrarrojas (IR) para reproducir la profundidad. Hace uso de un proyector láser para realizar un escaneo de 3D para percepción de escenas y fotografías mejoradas.

Al permitir hacer escaneo en 3D de habitaciones puede detectar movimientos de manos, cabezas, cuerpos y mucho más.

¡Y algo muy importante! ¡Se puede utilizar con el Intel Joule!https://communities.intel.com/community/image/2729/2.png?a=97855

¿Cómo instalar el soporte para sistemas basados en Linux, como Ubuntu?

 

Primero debemos de asegurarnos que el sistema se encuentra actualizado a la última versión.

sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade

Lo segundo es verificar la versión del Kernel de Linux que estamos utilizando

uname -r

El valor que nos imprime debe ser mayor o igual que 4.4.0-50

Luego debemos de instalar algunas dependencias para Librealsense

sudo apt-get install libusb-1.0-0-dev pkg-config

sudo apt-get install libglfw3-dev

 

Posteriormente ocupamos clonar el siguiente repositorio, se puede descargar por medio de la interfaz web en https://github.com/IntelRealSense/librealsense o con el siguiente comando

git clone https://github.com/IntelRealSense/librealsense

Una vez clonado el repositorio nos dirigimos al directorio y ejecutamos el los siguientes comandos

mkdir build && cd build

cmake ../ -DBUILD_EXAMPLES=true

La bandera “DBUILD_EXAMPLES” es para que se compilen los ejemplos con los que podemos probar el funcionamiento de la cámara. El último comando puede tomar bastante tiempo, una vez finalizado ejecutamos lo siguiente

make && sudo make install

Una vez concluido el paso anterior la biblioteca se encontrará instalada en /usr/local/lib y los encabezados se ubican en /usr/local/include Además como compilamos los ejemplos los vamos a poder encontrar en /usr/local/bin

 

https://www.intel.es/content/dam/www/public/us/en/images/photography-abstract/realsense-static-promo-rwd.png.rendition.intel.web.416.234.png