22 de noviembre de 2012

Controlabilidad y Observabilidad

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 7

Como última entrega de laboratorio seleccioné un problema del libro Sistemas de Control Moderno, y este pide determinar si el sistema tiene controlabilidad y observabilidad, usando las funciones del paquete control en Octave.

El problema es el siguiente:
Un motor de corriente continua tiene un modelo de variables de estado como se muestra a continuación.

$\dot x= \begin{bmatrix}{-3}&&{-2}&&{-0.5}&&{0}&&{0}\\ {2}&&{0}&&{0}&&{0}&&{0}\\ {0}&&{2}&&{0}&&{0}&&{0}\\ {0}&&{0}&&{1}&&{0}&&{0}\\ {0}&&{0}&&{0}&&{2}&&{0}\end{bmatrix}x+ \begin{bmatrix}{1}\\{0}\\{0}\\{0}\\{0}\end{bmatrix}u$

$y=\begin{bmatrix}{0}&&{0}&&{0}&&{0}&&{1.25}\end{bmatrix}x$

Determinar si el sistema es controlable y observable.

Utilizando las funciones ctrb para obtener la matriz de controlabilidad y obsv para obtener la matriz de observabilidad, podremos obtener la determinante de cada una de estas matrices.

Se sabe que cuando la determinante de la matriz de observabilidad da como resultado un valor diferente de cero, el sistema es observable y que cuando la determinante de la matriz de controlabilidad da como resultado un valor diferente de cero, el sistema es controlable.

Por lo tanto cree en octave funciones simples que hacen uso del paquete control para determinar si el sistema dado, en este caso en la forma de espacio de estados, es controlable y observable.

Este script tiene definidas las funciones "controlabilidad" y "observabilidad", y una más que hace la llamada a estas dos anteriores y yo la llamo "verificar".

Este es el código en octave.


Ahora para poder determinar si el sistema es controlable y observable pasamos las matrices del espacio de estados a matrices en octave. Esta las declaramos como se muestra a continuación.


$\begin{bmatrix}{-3}&&{-2}&&{-0.5}&&{0}&&{0}\\ {2}&&{0}&&{0}&&{0}&&{0}\\ {0}&&{2}&&{0}&&{0}&&{0}\\ {0}&&{0}&&{1}&&{0}&&{0}\\ {0}&&{0}&&{0}&&{2}&&{0}\end{bmatrix}$
A = [-3 -2 -0.5 0 0;2 0 0 0 0;0 2 0 0 0;0 0 1 0 0;0 0 0 2 0];

$\begin{bmatrix}{1}\\{0}\\{0}\\{0}\\{0}\end{bmatrix}$
B = [1; 0; 0; 0; 0];

$\begin{bmatrix}{0}&&{0}&&{0}&&{0}&&{1.25}\end{bmatrix}$
C = [0 0 0 0 1.25];

Ahora es así como cargamos el módulo con las funciones de controlabilidad y observabilidad y creamos las matrices así como se mostró anteriormente.

octave:1> source 'contr-obser.m'
octave:2> A = [-3 -2 -0.5 0 0; 2 0 0 0 0; 0 2 0 0 0; 0 0 1 0 0; 0 0 0 2 0];
octave:3> B = [1; 0; 0; 0; 0];
octave:4> C = [0 0 0 0 1.25];
octave:5> verificar(A, B, C)
------------------------
Matriz de controlabilidad
contr =

    1   -3    5   -5    1
    0    2   -6   10  -10
    0    0    4  -12   20
    0    0    0    4  -12
    0    0    0    0    8

Determinante
deter =  256
CONTROLABLE
------------------------
Matriz de observabilidad
obser =

    0.00000    0.00000    0.00000    0.00000    1.25000
    0.00000    0.00000    0.00000    2.50000    0.00000
    0.00000    0.00000    2.50000    0.00000    0.00000
    0.00000    5.00000    0.00000    0.00000    0.00000
   10.00000    0.00000    0.00000    0.00000    0.00000

Determinante
deter =  390.62
OBSERVABLE
------------------------
octave:6>
Podemos ver en las impresiones que el resultado de las determinantes es diferente de cero por lo tanto el motor de corriente continua es controlable y observable.

Referencias:
Sistemas de Control Moderno, 10ma edición, Richard C. Dorf, Robert H. Bishop, PEARSON.

20 de noviembre de 2012

Proyecto de Redes Neuronales

Redes Neuronales Artificiales
Presentación Final: Reporte y Programa

Este es el reporte final para la materia de Redes Neuronales Artificiales, en la cual estuve trabajando en el proyecto de Reconocimiento de Personas Mediante Voz, en conjunto con mis compañeros Cecilia Urbina y Roberto Martínez.

El objetivo del proyecto fue crear un sistema funcional que permita identificar si un usuario es el correcto o no, mediante su voz. Esto dentro de un sistema que muestre una ventana y que de un texto que tendrá que ser leído por la persona que intenta autentificarse, el audio es captado y analizado, y crea una entrada de datos a la red neuronal la cual se encargara de decir en su salida si el usuario fue identificado o no, y mostrar el resultado finalmente mediante una ventana.

Trabajo grupal


En la siguiente captura se muestran los commits realizados en Octubre y Noviembre desde una semana después de haber presentado el examen de medio curso, y con esto podemos crear evidencia del trabajo realizado.



Estuvimos haciendo cambios en el código que ya teníamos hasta la mitad del curso, de ahí en adelante fueron cambios que tuvieron que ver con la separación del código en clases.

Entre las clases que creamos están la de la Neurona y la de la Red, en las cuales se definen la cantidad de neuronas a utilizar y donde se hace el proceso de generación del vector de pesos, así como el aprendizaje de la Neurona.

Entre los cambios que podemos resaltar, y que se puede evidenciar mediante los últimos commits tenemos:
  • Separación del código en clases
  • Análisis con PCA
  • Creación de la clase interfaz
  • Aprendizaje con dos neuronas
  • Generación de un vector de pesos bueno
  • Reconocimiento funcional


Código


El código completo y las partes en las que yo contribuí están en el repositorio, enseguida se encuentra la liga directa.


El siguiente es el código de la clase Neurona, donde estuve haciendo algunas modificaciones para que fuera útil para el programa que inicia el aprendizaje y el programa que verifica los usuarios que necesita recibir la salida generada por la neurona.


Vídeo demostración


El siguiente vídeo muestra el funcionamiento de dos neuronas que separan cuatro clases, con datos generados con una versión más reciente el programa generador de vectores de entrada.


Presentación en equipo


Integrantes del equipo:


19 de noviembre de 2012

Proyecto de Automatización

Automatización y Control de Sistemas Dinámicos
Reporte Final

El reporte, presentación y código del proyecto final se encuentra en el siguiente enlace al blog del compañero Roberto Martínez.


15 de noviembre de 2012

Representación en el Espacio de Estados

Automatización y Control de Sistemas Dinámicos
Laboratorio: Entrada 6

Una representación de espacios de estados es un modelo matemático de un sistema físico descrito mediante un conjunto de entradas, salidas y variables de estado relacionadas por ecuaciones diferenciales de primer orden que se combinan en una ecuación diferencial matricial de primer orden. Para prescindir del número de entradas, salidas y estados, las variables son expresadas como vectores y las ecuaciones algebraicas se escriben en forma matricial. La representación de espacios de estado, también conocida como aproximación en el dominio del tiempo, provee un modo compacto y conveniente de modelar y analizar sistemas con múltiples entradas y salidas. [1]

Por lo tanto resulta conveniente utilizar la representación de espacio de estados cuando se requiere analizar sistemas de control que poseen más de una entrada y/o más de una salida, ya que se reduce la complejidad en las expresiones matemáticas utilizadas.

Para esta entrega seleccioné un problema del Capítulo 11, Análisis de Sistemas de Control en el Espacio de Estados, del libro Ingeniería de Control Moderna.

El problema es el siguiente:
Obtener con Octave una representación mediante la función de transferencia del sistema siguiente.

$\begin{bmatrix}{\dot x_1}\\{\dot x_2}\\{\dot x_3}\end{bmatrix}= \begin{bmatrix}{2}&&{1}&&{0}\\{0}&&{2}&&{0}\\{0}&&{1}&&{3}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{0}&&{1}\\{1}&&{0}\\{0}&&{1}\end{bmatrix} \begin{bmatrix}{u_1}\\{u_2}\end{bmatrix}$

$y=\begin{bmatrix}{1}&&{0}&&{0}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}$

Para empezar hay que saber que es posible representar el modelo de un sistema mediante su función de transferencia o su espacio de estados. Octave provee de funciones en el paquete signal para transformar de una representación a otra, es decir, nuestra función de transferencia la podemos representar en un espacio de estados, y viceversa.

Primero me enfocaré a resolver lo que el problema pide, que es obtener la función de transferencia desde el espacio de estados.

Transformación del espacio de estados a una función de transferencia

Para obtener la función de transferencia desde el espacio de estados, usamos la siguiente orden en octave.
[num, den] = ss2tf(A, B, C, D)

Para el espacio de estados descrito anteriormente en el problema, desde octave escribimos lo siguiente.

octave:1> pkg load signal
octave:2> A = [2 1 0; 0 2 0; 0 1 3]
A =

   2   1   0
   0   2   0
   0   1   3

octave:3> B = [0 1; 1 0; 0 1]
B =

   0   1
   1   0
   0   1

octave:4> C = [1 0 0]
C =

   1   0   0

octave:5> D = [0 0]
D =

   0   0

octave:6> [num, den] = ss2tf(A, B, C, D)
num = 
{
  [1,1] =  1.00000
  [1,2] =  1.00000
}
den = 
{
  [1,1] =

     1.0000  -4.0000   4.0000

  [1,2] =

     1.0000  -2.0000

}
octave:7>

Vemos que octave nos arroja dos arreglos, uno para la variable "num" y otro para la variable "den", cada uno con dos elementos dentro. Esto significa que este espacio de estados contempla dos funciones de transferencia, así que tomamos el primer elemento de "num" con el primero de "den" para formar una función de transferencia, y el segundo elemento de "num" y el segundo elemento de "den" para la segunda función de transferencia.

Entonces nuestro resultado queda como sigue.

$\dfrac {Y(s)}{U_1(s)} = \dfrac {1}{s^2 - 4s + 4}$

$\dfrac {Y(s)}{U_2(s)} = \dfrac {1}{s - 2}$

Ahora veamos el caso contrario.

Formulación en el espacio de estados de sistemas basados en una función de transferencia

Ahora lo que queremos es obtener el espacio de estados, desde una función de transferencia.

Para esto la orden usada en octave es:
[A, B, C, D] = tf2ss(num, den)
Entonces si tenemos la siguiente función de transferencia.

$\dfrac {Y(s)}{U(s)} = \dfrac {10s+10}{s^3 + 6s^2 + 5s + 10}$

En octave escribimos el numerador y el denominador de la siguiente manera, para después mandarlos como parámetros a la orden en octave.

octave:1> pkg load signal
octave:2> num = [0 0 10 10];
octave:3> den = [1 6 5 10];
octave:4> [A, B, C, D] = tf2ss(num, den)
A =

   -0.00000   -0.00000    1.00000
    1.00000   -0.00000    0.50000
    0.00000  -10.00000   -6.00000

B =

   1.00000
   1.00000
   0.00000

C =

   0   0  -1

D = 0
octave:5>

Lo que nos arroja en este caso son matrices, que son las que forman parte del espacio de estados, y las representamos así.

$\begin{bmatrix}{\dot x_1}\\{\dot x_2}\\{\dot x_3}\end{bmatrix}= \begin{bmatrix}{0}&&{0}&&{1}\\{1}&&{0}&&{0.5}\\{0}&&{-10}&&{-6}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{1}\\{1}\\{0}\end{bmatrix}u$

$y=\begin{bmatrix}{0}&&{0}&&{-1}\end{bmatrix} \begin{bmatrix}{x_1}\\{x_2}\\{x_3}\end{bmatrix}+ \begin{bmatrix}{0}\end{bmatrix}u$

Cabe mencionar que la representación anterior no es la única, sino que existen muchas representaciones en el espacio de estados posibles, pero octave solo ofrece una de entre todas las opciones posibles.

Fuentes consultadas:
[1] - Espacio de Estados
Página 760, Ingeniería de Control Moderna, 4ta. Edición, Katsuhiko Ogata.

13 de noviembre de 2012

Sistema de Seguridad usando Redes Neuronales

Redes Neuronales
Lectura Científica

Lectura completa por Obaidat en el siguiente enlace:
A Multilayer Neural Network System for Computer Access Security

El uso de redes neuronales es muy amplio en sistemas computacionales, que van desde aplicaciones para clasificar datos, procesamiento de señales, reconocimiento de texto, reconocimiento de voz, encontrar personas o rostros en una imagen o fotografía cancelación de ruido, redes de telecomunicaciones, entre otros.

Uno de los usos actuales de una red neuronal es el reconocimiento de personas como sistema de seguridad en una computadora. Esto se hace con el fin de restringir acceso a personas no autorizadas para usar una computadora. Podemos imaginar el administrador de los servidores de un sistema bancario trabajando desde su computadora en un escritorio del lugar donde trabaja, luego esta persona se va por un café o al baño, y mientras el dejó sola la computadora donde trabajaba, una segunda persona llega y empieza a hacer acciones indebidas en el sistema, evidentemente esto implica un gran problema, ya que seguramente esta segunda persona lo esta haciendo con malos fines. Entonces si la computadora tuviera un sistema que pueda lograr reconocer a una persona mediante como esta escribe en el teclado, el sistema podría bloquear todo acceso a la computadora si encuentra que la persona que actualmente escribe en el teclado no es la que habitualmente hace uso de ella.

http://muyseguridad.net/wp-content/uploads/2010/11/tecleando.jpg

Un sistema como el propuesto es posible tenerlo no solo en una computadora de escritorio o portátil, es también aplicable a dispositivos móviles, con el único inconveniente que para este sistema es necesario una red neuronal que analice datos en tiempo real, y muchos dispositivos móviles seguramente no estén preparados para un análisis complejo de datos en un periodo de tiempo razonable.

¿Cómo se hace esto con una red neuronal?

EL uso que se le da a esta aplicación en una red neuronal es mejor reconocido como reconocimiento de patrones. Los datos que se dan como vectores de entrada a la red neuronal son los intervalos de tiempo entre las pulsaciones que se hacen en el teclado mientras escriben una secuencia conocida de caracteres.

Una red neuronal para la clasificación de patrones debe de tener los siguientes elementos básicos:

  • Un grupo de unidades simples para procesamiento.
  • Un estado de activación inicial por cada unidad.
  • Función de salida para cada unidad.
  • Una regla de propagación.
  • Una regla de activación.
  • Una regla de aprendizaje.
  • Cada elemento esta relacionado con un peso en el vector de pesos.
  • Cada elemento produce una activación y una propagación de error.

Ya sabemos que el vector de entrada a la red neuronal esta dado por el tiempo que la persona se tarda en presionar entre una tecla y otra. Se necesita una red neuronal que tenga varias neuronas en la capa de entrada, en donde cada neurona analizará una unidad de datos del correspondiente vector de entrada.

Una capa oculta no necesariamente con la misma cantidad de neuronas que en la capa de entrada y una capa de salida con una cantidad de neuronas proporcional a la capa oculta anterior.

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=293498

El aprendizaje para este tipo de red neuronal es mediante un cambio en el vector de pesos, como se suele hacer normalmente, y existe una regla de propagación de errores que ayuda a obtener un vector de pesos que dará una salida cercana a lo ideal.

La salida de cada neurona de la capa de salida, nos deberá proporcionar un vector de salida diferente para cada persona, y comparado con un vector anteriormente obtenido con la persona que usualmente hace uso de cierta computadora, es posible determinar si es la misma o es una persona diferente, y así determinar si es necesario bloquear el uso de la computadora o no.

Referencia
A Multilayer Neural Network System for Computer Access Security

7 de noviembre de 2012

Reporte Grupal

Automatización y Control de Sistemas Dinámicos
Reporte Grupal

EL reporte grupal se encuentra en el blog de Roberto Martínez:
Reporte Grupal

6 de noviembre de 2012

Diseño de Control en Computadoras Personales

Automatización y Control de Sistemas Dinámicos
Lectura Científica

Documento original escrito por Thomas Knapp.

Es evidente que las computadoras personales han sido utilizadas por mucho tiempo para el análisis de sistemas de control y sistemas de control moderno, pero debido a la forma en que la mayoría de los programas para estos fines se han desarrollado, hacen que estos programas computacionales que analizan el estado del sistema, suelen no ser de tiempo real, o solo llegan a ser un aproximado a lo que pensamos es un análisis de tiempo real.

Naturalmente los que ya hemos trabajado con sistemas de control, sabemos que es posible trabajar desde nuestra computadora y ejecutar pruebas que creen entradas aleatorias de datos y ver como se comporta la salida en un sistema, pero cuando hablamos de una cantidad inmensa de información a analizar en su salida, se requiere de hardware que este creado para estos fine, es decir, hardware que sea capaz de guardar y procesar gran cantidad de información.

Y no solo se necesita grandes computadoras con hardware sofisticado, también es encesario hacer el uso de sistemas operativos en tiempo real. En nuestra travesía como estudiantes de ingeniería, ya hemos tenido que lidiar con sistemas operativos de este tipo, usados en sistemas embebidos con nuestros microcontroladores.

Ya que esta publicación no se trata de copiar información, les puedo comentar que se tienen rangos de velocidad en procesamiento de una computadora los cuales dicen si una computadora es apta o no para análisis de sistemas de control. Y desde mi punto de vista, el documento puede que este un poco obsoleto, por que fácilmente podría asegurar que cualquier computadora de nueva generación lograría soportar un análisis "bueno" de un sistema de control en tiempo real.

Actualmente la mayoría de los métodos de procesamiento que se tienen están creados en tiempos discretos, ya que resulta más adecuado para trabajar en computación digital. Algo que también hemos visto en clases de control, son los tipos de controladores, como el conocido PID e incluyen uno llamado estado de controlador, que según estudios resulta tener mejor respuesta en tiempo real.

A lo que nos lleva este documento es a la creación de un paquete que sirve para analizar sistemas de control pero tomando en cuenta los siguientes puntos:
  • Adquisición de datos en tiempo real
  • Verificación de proceso y método de control de diseño
  • Simulación de un circuito cerrado
  • Control en el proceso

El nombre del paquete que ellos crearon es CADREG-PC, es compatible con computadoras basadas en procesadores de IBM, y lo que nos ofrece en pocas palabras es crear un algoritmo para un sistema de control que puede ser fácilmente diseñado y probado sin ningún ningún retraso en cuanto a tiempo.

Enlace al documento:
Process Identification, Controller Design and Digital Control with a Personal Computer

5 de noviembre de 2012

Lógica Temporal

Verificación y Validación de Software
Entrada 11

Para esta semana seleccionamos un ejercicio del PDF mencionado al final de esta publicación, referente a lógica lineal temporal (LTL, por sus siglas en inglés).

El ejercicio seleccionado fue el 14.1.6 y la traducción literal del enunciado es el siguiente.

Si un estudiante olvida una moneda en la ranura de monedas, otro estudiante usará esta moneda para obtener una bebida antes de que cualquier profesor pueda hacerlo.

Entonces usando los operadores temporales tenemos:

$\square (eom \Rightarrow \circ(¬pum \ R \ eum))$

Donde:
eom = Estudiante Olvida Moneda
pum = Profesor Usa Moneda
eum = Estudiante Usa Moneda

Recursos consultados:
Linear Temporal Logic

4 de noviembre de 2012

Autómata Büchi No-Determinista

Verificación y Validación de Software
Entrada 10

Para esta semana se nos pidió hacer lo siguiente:
  • Inventar una expresión ω-regular con por lo menos dos símbolos y por lo menos dos operadores.
  • Dibujar el NBA que le corresponde.

Abecedario

$\sum {\left\{A, B, C\right\}}$

Expresión ω-regular

$(A^*B)(AC+C)^w$

Autómata Büchi No-Determinista

La siguiente imagen es un paso intermedio antes de llegar al autómata completo, aquí solo están las transiciones entre tres estados, donde tales transiciones son la separación por el AND de la expresión.


Y el autómata completo es el siguiente.


Entonces tenemos $L = \{Q, \sum, \delta, I, F\}$

Donde:
$Q = \{q0, q1, q2, q3\}$
$\sum = {\left\{A, B, C\right\}}$
$\delta$ son las transiciones mostradas en la imagen
$I = \{q0\}$
$F = \{q3\}$

Referencias:
Course On Principles Of Model Checking
Automata On Infinite Words

1 de noviembre de 2012

Steganography

Seguridad de la Información y Criptografía
Homework 8 - Program 4

The hidden code in the images of the last publication was in the images 1, 2 and 5

The homework was create a program to hide a text in an image file or an audio file, it is called Steganography.

Steganography is the art and science of writing hidden messages in such a way that no one, apart from the sender and intended recipient, suspects the existence of the message, a form of security through obscurity. [1]

I create two python programs, one for hide the text (in this case my own code), and other for get again the hidden text.

First of all, I read the PDF that is at the end of this publication, where they explain why is common to hide text in bitmap images, and a introduction to how to change data of the image.

A little introduction about the bitmap images, is how the bytes are arranged, the next is what information is stored in the first bytes of the file.

Header of the file:
Bytes - Description
0-1 Bitmap identifier (BM)
2-5 Bitmap file size
6-9 Reserved
10-13 Bitmap data offset

Information about the file:
Bytes - Description
14-17 Bitmap header size
18-21 Bitmap image width
22-25 Bitmap image height
28:29 Bitmap color depth
26-27 Number of color planes
28:29 Bitmap color depth
30-33 Bitmap compression method
34-37 Bitmap data size
38-41 Bitmap image horizontal rule
42-45 Bitmap image vertical resolution
46-49 Number of colors used
50-53 Number of important colors used

*Information extracted from the PDF in the references.

The rest of the bytes are the image information. In my case I used images with a extension of color of 32 bits per pixel, so are 4 bytes in each pixel, we know that colors are composed by three elemental color, and a fourth in this case that is the "transparent color", (red, green, blue, alpha).

I only made changes in the byte of color red. Per byte we have 8 bits, and I only used the last bit to hide one bit of the complete hidden code.

Example:
If the letter "i" in binary is 01101001, in the first 8 bytes where the color red is stored, I change something like that.

Original - Changed
01010011 - 01010010
01010000 - 01010001
01001101 - 01001101
01001110 - 01001110
01001011 - 01001011
01001001 - 01001000
01001010 - 01001010
01001001 - 01001001

Code



The first parameter in the program is the original bitmap file, then a file with the code and the name of the new image.

~$ python stegano.py "images/rmn-01.bmp" "code_file" "rmn-01.bmp"
Identifier  BM
File size 810054
Reserved 0
Data offset 54
Width  450
Height  450
Text file size 2315
~$

The file with the code look like this.


Then the program to find the code in the image.


In this case the program only needs the bitmap file with the hidden code, and a file name to save the text.

~$ python decode.py "rmn-01.bmp" "decoded"
Image size 810054
~$

If we open the file created, we can see the code in it. After the end of the code we have waste information, because we don't know how many bytes had the original code_file. If we don't want to have waste information at the end, we can include in an specific array of bytes in the beginning, the length of the hidden text.


Image without the hidden text


Image with the hidden text


References:
[1] - Steganography - Definition
Introduction to Bitmap Steganography