Limitaciones de la automatizacion industrial

La industria 4.0 (teóricamente tan avanzada) esta estancada en el siglo 19.
Los métodos de programación así como los programas usados en la codificación de PLCs se han estancado en un sistema demasiado básico para la época.
Esto no deberia ser un problema, pero lo cierto es que resulta mucho mas cómodo el uso de programas escritos de alto nivel que los de bajo nivel.
Y a cómodo no me refiero a fácil. Hay una gran diferencia entre hacer un programa en lenguaje de alto nivel y uno de bajo nivel.
El de bajo nivel vas a tener que preocuparte de casi todo. paso a paso, eso significa mucho trabajo repetitivo. Ademas los PLCs funcionan en modo cascada, por lo que aumenta el numero de instrucciones. Y el reaprovechamiento de partes de programa se desprecia.
Básicamente código espagueti.
Si fuera solo eso, aun estaria dentro de lo pasable. Los PIC antiguos, usaban un sistema de movimiento de bytes que se solia ver como:
Main:
        movlw   0x00
        movwf   TRISB
Loop:
        movlw    0x01
        movwf    PORTB
        movlw    0x00
        movwf    PORTB

De esta manera se lograba decir que el puerto B se encontrara apagado y que parpadease un LED con bucle infinito a velocidad de Clock.

Este es un sistema muy básico, que para lenguajes de alto nivel se traduce a casi el mismo numero de lineas. Por ejemplo:
void setup() {
  PORTB = 0x00
}
void loop() {
     PORTB = 0x01;
     PORTB = 0x00;
}

Se obvia el movimiento con la instrucción de un '='

En Los programas de PLC funcionan paso por paso moviendo y guardando, como se hacia antiguamente con los PIC.
Además, los PLCs no son tan seguros a nivel de programación.
Con que empieces a jugar con las teclas muy rápido, puedes llegar a generar un salto de paso en el programa y necesitar un reset.
Así que tampoco es tan robusto electrónicamente, como se da a entender.

Pero parte de todo el problema está en el entorno de desarrollo. Donde un conjunto de instrucciones básicas, puede suponer necesitar una pantalla de cine. La razón es que el entorno de programación se define en conjunto de bloques con un orden en vertical. Y las variables o valores, se colocan en los laterales de cada bloque.

Para los programas condicionales, no es tan desagradable, pero cuando quieres conseguir un resultado transformado en otro valor, se vuelve extremadamente molesto.
La razón es que en un lenguaje de alto nivel, usaríamos:
Word = Str(DInt)

mientras que en Step7 eso es igual a:
mover valor del byte 0 a conjunto de bytes "doble palabra"
(4 bytes) ED0 -> EB1 ... 3
Convertir la variable Dint (4bytes) a Real
+(4 bytes) -> ED4 -> EB4 ... 7
Convertir la variable Real a Word
+ (2 bytes) -> ED8 -> EB8 ... 11
MW10 = Word y desechar los EB8 y EB9
Ocupando 10 bytes en la conversion + 2 bytes de residuo y sin poder volver a reutilizar esas posiciones de memoria.
Por lo visto de memoria va sobrada, pero visualmente estos 5 pasos en el programa se traducen a una pagina DIN-A4 impresa por ambas caras.

El problema de una programación así, no es que sea difícil, es que resulta incomoda y aburrida.
Se pierde mucho tiempo y además es difícil encontrar un posible error sin comprobar físicamente.

Actualmente cualquier pagina web maneja 10 veces mas datos que los manejados en un PLC. En cambio, los programadores de PLCs, desde que empiezan a trabajar suelen estar mejor remunerados.

En mi opinion, es una tecnologia de bajo rango intelectual muy bien remunerada.

Regresión Lineal

Método de mínimos cuadrados:

Épocas |   X   |   Y   |   X * Y  |   X^2  |
1          |  12  | 400 |   4800   |   144 |
2          |  10  | 390 |   3900   |   100 |
3          |  40  |1200|  48000  |  1600 |
4          |  50  |1900|  95000  |  2500 |
5          |  30  | 950 |  28500  |   900 |

Suma:  | 142  |4840|  180200 |  5244 |

La regresión lineal, consiste en generar una recta que determine la predicción de la tabla a nuevos valores.

 y = mx + b

m = la pendiente
b = Termino independiente
x = variable de entrada
y = valor de salida resultante

m= (n*(Exy)-(Ex)(Ey))/(n*(Ex^2)-(Ex)^2)

b= ((Ey)*(Ex^2)-(Ex)*(Exy)) / (n*(Ex^2)-(Ex)^2)

n = numero de épocas

E = Sumatoria

Para calcular la pendiente, una vez obtenido la época de cada resultado y almacenado en la base de datos, se aplica la formula, que despejando las variables se obtiene que:

m = (5*(180200)-(142)*(4840))/(5*(5244)-(142)^2)

m = 35.29062087186262

b = ((4840)*(5244)-(142)*(180200)) / (5*(5244)-(142)^2)

b = -34.25363276089828

y = 35.29062087186262 * x + -34.25363276089828

El resultado de la predicción (y) en una pendiente lineal, dependerá del valor de entrada (x).

Obteniendo el resultado de la pendiente en todo el rango de valores.

Dimensionalidad, Clasificador, Tensorflow, Matriz de confusión

Dimensionalidad

Imaginando el radio de una circunferencia en 2D. 

El vector de 1, 1, equivale al radio 1 de la circunferencia.

Dejando un circulo de A = pi*r². Con el incrento de dimensiones, el valor resultante de las esquinas tiende a 0.
Observese la tabla de dimensiones.

Tensorflow

En una red neuronal los datos se ordenan de izquierda a derecha creando una red de pruebas.

Las Entradas: se definen como el numero de dimensiones. X

Los Pesos: son las conexiones entre los nodos. W

Las salidas: Vectores resultantes Y

Los objetivos: Vectores objetivos en el aprendizaje supervisado

Función de activación: Activa la operación en función de la entrada

Error: Calcula la precision de la salida Y respecto a los objetivos T.

En el aprendizaje computacional es necesario clasificar los datos según sus valores.

En un array de datos, implementa un algoritmo secuencial de aprendizaje.
Los arrays estan compuestos por entrada de datos y objetivos.

Los valores de entrada son los valores reales y los de salida, pretenden ser los objetivos.

El Clasificador se compone de 3 grupos:

Entrenamiento o Capacitación: reajusta los parámetros en el aprendizaje

Pruebas: Verifica los resultados en un aprendizaje supervisado

Validación: Detecta el error de dimensionalidad según el vector y el numero de dimensiones.

El sistema evalúa el array de datos con valores objetivo y comprueba el resultado.
El resultado de la Validación es guardado y se procede a evaluar nuevamente los datos.
Comprueba y compara el resultado con la anterior validación y guarda el mejor resultado como valido.

Estos tres grupos separan el array de datos y lo evalúan con condicionales simplificados.

El conjunto de datos se analiza en 3 bloques:

La maldición de la dimensionalidad

A medida que aumentan las dimensiones, los algoritmos requieren de mayor rango de procesamiento.

Eso dificulta el aprendizaje. Para solucionarlo, es necesario optimizarlo evitando la sobre saturación de datos.

Tanto para pocas o muchas dimensiones, el conjunto de datos tienen un porcentaje de influencia según el numero de dimensiones.

A consecuencia, se obtiene mayor precision.

Para pocas dimensiones: 50% entrenamiento 25% Pruebas y 25% Validación.

Para mayor rango de dimensiones: 60% 20% 20%.

Estos porcentajes son aproximados y variaran según la complejidad de la red neuronal.

De este modo, se minimiza el proceso de entrenamiento y maximiza el rendimiento libre de ruido excesivo.

En un aprendizaje automático, se hace una simulación en los datos obtenidos.

El algoritmo selecciona según el porcentaje dado en los bloques Entrenamiento (E) Prueba (P) y Validación (V) los diferentes datos obtenidos en la salida y los compara con los datos objetivo.

En un Array de datos, los valores se almacenan en el conjunto porcentual.

En una distribución 50,25,25 tendríamos:

    E,E,P,P,V,E,E,E, V  = ejemplo1

                E,E,P,V,E,E,E, P,V = ejemplo2

                V,E,E,P,V,E,E,P,P   = ejemplo3

    …                          = ejemplo n

Puede ser aleatorio no repetitivo u ordenado según si es un problema de regression o de clasificación.

                E,E,E,E,E,P,P,V,V = ejemplo1

                V,E,E,E,E,E,P,P,V= ejemplo2

                V,V,E,E,E,E,P,P,P = ejemplo3

     …                       = ejemplo n

Estos 3 grupos se ordenan al azar y se busca por aprendizaje supervisado el conjunto de menor error. Guardando el mas favorable en validación y desechando el conjunto no favorable u obteniendo un 0 en el ejemplo “n” de validación..

Estos array de datos quedarían en binario y sumados según su numero de aciertos o (V) validación

Cada ejemplo es enumerado y distribuido en una matriz de Clases.

La Matriz de Confusion

Es una matriz cuadrada que engloban todas las validaciones de ejemplos y permite visualizar el rendimiento del algoritmo para problemas de clasificación. No sirve para problemas de regression porque los resultados son continuos.

Esta matiz se compone de una clasificación de validación respecto a los objetivos.

Y la diagonal de arriba (VP) a abajo (VN) determina los valores correctos del algoritmo.

Obteniendo un resultado porcentual de la exactitud o precision, tasa de error y sensibilidad.

Matriz(i,j) C1          C2           C3 

  C1           5             1             0                                           

  C2           1             4             1                            

  C3           2             0             4                           

                          1             0            Algoritmo       

           1             VP          FP

           0             FN          VN

Validacion          

VP = Verdadero Positivo             (La entrada y Algoritmo COINCIDEN como Correcto)

FP = Falso Positivo                          (El Algoritmo NO coincide con la entrada)

FN = Falso Negativo                       (La entrada NO coincide con el Algoritmo)

VN = Verdadero Negativo          (La entrada y el Algoritmo COINCIDEN como Falso)

Dependiendo de los valores de cada cuadrante de la matriz(I,j) obtendra un porcentaje de aprendizaje y deteccion de errores.

Exactitud = (VP + FP)/total
Sensibilidad = VP / (VP + FN)
Especifico = VN / (VN + FP)
Precisión = VP / (VP + FP)