Autoajuste de Parámetros

Reporte 1

Réplica del programa del Ventilador

Muestra corridas donde se vea el auto-ajuste. Muestra los fragmentos más importantes de código y explícalos.

El programa presenta donde hay ajuste de parámetros. Se trata de un sistema que, dependiendo la temperatura regula la velocidad del ventilador.

A continuación de presentan fragmentos de código:

Se empezó con la librería random, para hacer que saliera una temperatura aleatoria

import random
from time import sleep

Se establece un comando llamado “sleep” para que el programa se “duerma” por unos segundos en este caso 60 segundos.

rand = random.randrange(-10, 45, 2)
        sleep(0.60)

Luego se comparan los datos aleatorios obtenidos, con respecto a los parámetros que se ajustarán, por ejemplo en este fragmento de código se dice que si la temperatura es menor o igual a 15 grados, (tener en cuenta que la temperatura mínima registrada en esa ciudad va desde -10 a 45 grados medidos en escala Celsius), por lo tanto l abanico esta apagado.

if rand <= 15:

#ventilador = 0

print "El ventilador está apagado, la temperatura es de: ", rand ,"°C"

Aquí se presenta la imagen de la ejecución del programa:

Nota 1: Los niveles van de 0 (abanico apagado), 1 (velocidad baja), 2 (velocidad media), 3 (velocidad máxima).

Reporte 2: Redes Complejas

Unidad 2: Algoritmos adaptativos

Reporte 2: Redes Complejas

Con la siguiente red compleja (representada por su matriz de adyacencias):

0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 
1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 
1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 
1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 
0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 

Genera un programa que obtenga la distribución de grado y la densidad de la red. Grafica la distribución de grado (esto puede ser de manera manual). Hint: Utilizar lenguajes script puede facilitar la programación. Extra: agrupa la red.

Distribución de grado:
Primeramente sacaremos el Grado de cada vertice...

linea[l] = f.readlines()[l]
    numeros = [float(x) for x in linea[l].split()]

En esta parte de nuestro programa lo que hace es leer cada numero de fila para a continuación pasar a sumarla con los siguientes comandos:

for i in numeros[1:]:
        total[l] = total[l] + i 

Y de esta forma se saca el grado del vertice y es impreso de la siguiente forma:

print"El Grado del vertice", v[l], "es: %.f"%total[l]

Después de sacar el Grado de cada vértice procedemos a sacar la los conjuntos de vértices que tengas que tengan las mismas cantidades de confecciones

for i in range(1,33):
    for j in range(0,33):
        if total[i] == j:
            dis[j] = dis[j] + 1

Y para finalmente dividirlo entre el total de conexiones y quedaría de la siguiente forma

for i in range(1,33):
    dist[i] = dis[i]/33

for i in range(1,33):
    print "La distribucion de grado de K = ", i,"con %.f"%dis[i], "vertices es: ",dist[i]

A continuación una tabla donde se muestra la distribución de Grado, así como su Gráfica correspondiente

Densidad de la red

Para iniciar a calcular la densidad de la red, primero ahí que definir la formula:

Primero ahí que obtener la "m" que la calculamos con el siguiente código:

for i in total:
    m = m + i

y como ya contamos con "n", solo realizamos la formula y procedemos a imprimir

D =  2(m)/n(n-1)
print "m =",m
print "n =", n
print "D =  2(m)/n(n-1)"
print "La dencidad es:", D

Nota: Si es necesario publicar el código completo, basta con solicitarlo en un comentario

Avance #3 Proyecto Final

Resumen del proyecto

Coloca una breve descripción de tu proyecto (pueden ser un par de líneas). Si realizaste cambios con respecto a la entrega anterior, menciónalos.

El proyecto se sigue trabajando en Python, tal y como se había mencionado en el avance pasado, la librería mas importante en esto es OpenCV, y otras dos que son también de vital importancia son Pygame, para los juegos y Pybrain, esta ultima para darle la parte “adaptativa” al sistema. El cambio que se realizó es que serán dos juegos, uno parecido al de tomar pelotas, para acumular puntos y otro para que un personaje “camine” con nuestra mano.

Otra modificación que cabe destacar es que posiblemente se cambie la Webcam por un sensor Kinect, para un mejor manejo de la interfaz y la codificación.

Avance con respecto a la planeación. Comenta, con una extensión de entre media y una cuartilla, cómo haz avanzado en tu proyecto. Puedes incluir el Gantt actualizado. En tus comentarios, contesta las siguientes preguntas:

¿Qué se ha hecho? Se ha programado ya el primer avance, lo principal del sistema, así como una investigación de lo que e necesitará para poder realizar lo juegos en este lenguaje. También se investigó la interfaz gráfica, como los menús, las imágenes del fondo en ellos y las imágenes para los botones, pero aún falta plasmar esto en el programa, en este avance no se ve tanto de interfaz, se observa más la codificación referente a lo que viene siendo un sistema adaptativo, según los temas vistos en clase.

¿Qué falta? Falta hacer los juegos que llevara nuestro programa, llevando con esto la forma de como se van a conectar éstos con la mano que detectará nuestra red neuronal, además a pesar de que ya se investigó como se puede dar una interfaz al sistema, falta plasmarlo y ver si funciona lo que se ha investigado.

¿Qué problemas se han presentado y cómo los has resuelto / piensas resolverlos? Uno de los principales problemas fue empezar a codificar ya que la relación que teníamos con el lenguaje era mínima, dado que en cursos anteriores se había estado trabajando con C++, sin embargo esto se revolvió investigando por parte de los miembros del equipo, por separado y juntos. Algún problema que también se ha presentado pero no de tanta relevancia fue que, como no teníamos un gran conocimiento del lenguaje, no sabíamos exactamente que lirerías utilizar, eso lo resolvimos investigado, y viendo tutoriales en internet.

Diagrama de Grantt [ver]

Lista actualizada de recursos y herramientas. Expande la lista que tienes con información que te haya sido útil. Si has investigado técnicas inteligentes (ej. redes neuronales, agentes, métodos para NLP, etc.), describe esto concisamente.

Herramientas:

ü  Python 2.7. Usando el lenguaje Python: Es un Lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis muy limpia y que favorezca un código legible.

ü  Librerías como :

o   OpenCV: Biblioteca libre de visión artificial. Es multiplataforma, existiendo versiones para GNU/Linux, Mac OS X y Windows. Contiene más de 500 funciones que abarcan una gran gama de áreas en el proceso de visión, como reconocimiento de objetos (reconocimiento facial), calibración de cámaras, visión estereo y visión robótica.

o   Pygame: es un conjunto de módulos del lenguaje Python que permiten la creación de videojuegos en dos dimensiones de una manera sencilla

o   Pybrain: biblioteca libre y modular del aprendizaje de máquina.

Recursos:

Inteligencia Artificial, más concreto, Redes Neuronales Artificiales.

Redes neuronales artificiales: son un paradigma de aprendizaje y procesamiento automático inspirado en la forma en que funciona el sistema nervioso de los animales. Se trata de un sistema de interconexión de neuronas en una red que colabora para producir un estímulo de salida. En inteligencia artificial es frecuente referirse a ellas como redes de neuronas o redes neuronales.

Primera versión del sistema. 

Coloca fragmentos de código correspondientes a los módulos más importantes de tu proyecto.

Lo primero que se hizo en el código, para lo adaptativo fue capturar desde la cámara

cv2.VideoCapture(1)

A continuación se procedió a cambiar los colores, a  colores “binarios” es decir blanco y negro por medio del comando:

cv.Threshold(imagen, imagen, umbral, color, cv.CV_THRESH_BINARY)

Como en nuestro proyecto, lo más importante es encontrar la mano, ya que ésa es la que guía al juego, se creo un umbral. Éste funciona de la siguiente manera: Primero, se llama encender la cámara con el código visto anteriormente, luego se abre la cámara, y al momento en que se presiona la tecla ESC e guarda la última imagen que vio. De esta manera el programa cambia lo que sea negro a 0 y lo que esté con blanco a 1, con este método podemos distinguir una mano humana.

Nuestro código quedó así:

gray = cv2.cvtColor(f,cv2.COLOR_BGR2GRAY)
    ret,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
    gray = cv2.Threshold(image,image, threshold,colour,cv.CV_THRESH_BINARY)