Reporte 3

Reporte 3

 Perceptrón que reconoce un "and"

El Perceptrón es un tipo de red neuronal artificial, también puede entenderse como perceptrón la neurona artificial y unidad básica de inferencia en forma de discriminador lineal, que constituye este modelo de red neuronal artificial, esto debido a que el perceptrón puede usarse como neurona dentro de un perceptrón más grande u otro tipo de red neuronal artificial.

Este es un ejemplo de entrenamiento de Perceptron para el caso de NAND, con un umbral, sesgo y tasa de aprendizaje predeterminados.

threshold = 0.5
learning_rate = 0.1
weights = [0, 0, 0]
training_set = [((1, 0, 0), 1), ((1, 0, 1), 1), ((1, 1, 0), 1), ((1, 1, 1), 0)]
 
def sum_function(values):
    return sum(value * weight for value, weight in zip(values, weights))
 
while True:
    print '-' * 60
    error_count = 0
    for input_vector, desired_output in training_set:
        print weights
        result = 1 if sum_function(input_vector) > threshold else 0
        error = desired_output - result
        if error != 0:
            error_count += 1
            for index, value in enumerate(input_vector):
                weights[index] += learning_rate * error * value
    if error_count == 0:
        break

El objetivo de esta practica es modificar  el código  que para el caso de “and”. Modificar los pesos iniciales, la tasa de aprendizaje y el umbral.

A continuación la replica del perceptron con las modificaciones necesarias para el caso AND.

umbral = 0  
tasa = 0.09
pesos = [0, 0, 1]
entrenamientoAND = [((1, 0, 0), 0), ((1, 0, 1), 0), ((1, 1, 0), 0), ((1, 1, 1), 1)]
 
def sum_function(values):
    return sum(value * weight for value, weight in zip(values, pesos))
 
while True:
    print '-' * 60
    error_count = 0
    for input_vector, desired_output in entrenamientoAND:
        print pesos
        result = 1 if sum_function(input_vector) > umbral else 0
        error = desired_output - result
        if error != 0:
            error_count += 1
            for index, value in enumerate(input_vector):
                pesos[index] += tasa * error * value
    if error_count == 0:
        break

Video

Entrega Final

Código

buscar_ajax.php

Aquí se crea una función AJAX, básicamente vamos a utilizar AJAX para llamar a un fichero php y que nos aparezcan los resultados sin recargar la página. 

function AJAX() {
 this.Updater=carregarDados;
 function carregarDados(caminhoRetorno,idResposta,metodo,mensagem) {

 var divLista=document.getElementById(idResposta)
 conteudo.innerHTML= mensagem;

 var xmlhttp = getXmlHttp();


 xmlhttp.open(metodo.toUpperCase(), caminhoRetorno,true);


 xmlhttp.onreadystatechange=function() {

  if (xmlhttp.readyState==4){
 
  
  var texto=xmlhttp.responseText;
 
  
  texto=texto.replace(/\+/g," ");
  texto=unescape(texto);
 
  
 
  var conteudo=document.getElementById(idResposta);
  conteudo.innerHTML=texto;
  }
 }

xmlhttp.send(null);
}
}

function getXmlHttp() {
var xmlhttp;
try{
xmlhttp = new XMLHttpRequest();
}catch(ee){
try{
xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
}catch(e){
try{
xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
}catch(E){
xmlhttp = false;
}
}
}
return xmlhttp;
}

Index.php

Aquí llamamos a la función AJAX lo que hace es emitir resultados, es decir, va a rellenar el mensaje de lo que estamos enviando.

  
 















.

.

.




        -   
              



Iistar_ajax.php



Aquí en listar_ajax se crea la conexión a la base de datos, selecciona la base de
datos,se selecciona todo de la tblcanción donde intExtra1 = 1, es decir

que si el checkbox está marcado lo que hará el ajax es regresar el valor de lo
que obtenemos de la consulta. En este caso es sacar la canción que marcamos
como favorito.

Listar_ajax.php

Aquí en listar_ajax básicamente lo que hacemos es crear la conexión a la base de datos, selecciona la base de datos Lo que básicamente hacemos le decimos es selecciónamelo todo de la tblcanción donde intExtra1 = 1, es decir que si el checkbox está marcado lo que hará el ajax es regresar el valor de lo que obtenemos de la consulta. En este caso es sacar la canción que marcamos como favorito.

Video- Reproductor adaptativo

Reporte 4

Smart Python multi-Agent Development Environment(SPADE) es una Plataforma Multiagente y las organizaciones basadas en la tecnología XMPP / Jabber y escrito en el Python lenguaje de programación. Esta tecnología ofrece por sí mismo funciones y prestaciones que facilitan la construcción del MAS, como un canal de comunicación existente, los conceptos de usuarios (agentes) y servidores (plataformas) y un protocolo de comunicaciones extensible basado en XML, como FIPA-ACL . Muchas plataformas de otro agente existen, pero Spade es el primero en basar sus raíces en la tecnología XMPP.

Es una plataforma de sistemas multi-agente desarrollada en 2005 en la Universidad Politécnica de Valencia. La plataforma nació como una prueba de concepto para probar la tecnología de la mensajería instantánea como protocolo de transporte para los agentes inteligentes. Desde ese momento el proyecto ha seguido creciendo y añadiendo nuevas características aprovechando la flexibilidad del protocolo de mensajería instantánea basado en XML y la cantidad de extensiones desarrolladas para el mismo que son aprovechables dentro del marco de los sistemas multi-agente. La plataforma SPADE está basada en un conjunto de estándares, siendo los más destacables FIPA y XMPP/Jabber.

Las principales características de la plataforma SPADE son:

1. Soporte del estándar FIPA mediante el protocolo de mensajería instantánea XMPP (Agentes AMS y DF incluídos)
2. Notificación de presencia entre agentes.
3. Organizaciones Virtuales basadas en el protocolo de multi-conferencia MUC.
4. Comunicación P2P entre agentes.
5. Invocación remota de servicios entre agentes usando el estándar XML-RPC.
6. Procesadores de lenguajes de contenido en SL0 y RDF.
7. Modelo de agente BDI basado en Conocimiento, Deseos e Intenciones.
8. Modelo de comportamientos: Cíclicos, Periódicos, Timeout, una ejecución, máquina de estados finita y basado en eventos.
9. Soporte de comunicación con otras plataformas mediante diversos protocolos de transporte: JADE (vía HTTP o XMPP) y SIMBA.
10. Publicación y subscripción de eventos mediante el estándar PubSub.
11. Interfaz gráfica basada en web.

Interfaz Gráfica

SPADE es una plataforma de agentes interoperable y multiplataforma, dado que el protocolo de comunicación está basado en XML y el lenguaje de implementación es Python. Del mismo modo la interfaz gráfica está basada en HTTP, siendo accesible desde multitud de dispositivos. Las características de la interfaz son las siguientes:

·         La plataforma y los agentes exportan su propia interfaz web.

·         La interfaz es configurable a través de plantillas.

·         Cada agente exporta su identificador como un código QR.

·         Introspector de agente.

·         Visor de mensajes enviados.

·         Búsqueda de agentes y servicios.

JADE (Java Agente de Desarrollo Framework) es un marco de software aplicado plenamente en el lenguaje Java. Simplifica la implementación de sistemas multi-agente a través de un middleware que cumple con las especificaciones FIPA ya través de un conjunto de herramientas gráficas que soportan la depuración y fases de despliegue.

La plataforma de agentes pueden ser distribuidos a través de máquinas (que ni siquiera necesitan compartir el mismo sistema operativo) y la configuración se puede controlar a través de una interfaz gráfica de usuario remoto. La configuración se puede cambiar incluso en tiempo de ejecución moviendo agentes de una máquina a otra, como y cuando sea necesario. JADE está completamente implementada en lenguaje Java y la exigencia mínima del sistema es la versión 1.4 de Java (el entorno de tiempo de ejecución o el JDK). 

JADE crea múltiples contenedores para los agentes, cada uno de los cuales puede ejecutarse en uno o en varios sistemas. Un conjunto de contenedores constituye una plataforma.

Cada plataforma debe tener un contenedor principal que tiene dos agentes especiales denominados AMS y DF.

·         El AMS (Agent Management System) controla la plataforma. Es el único que puede crear y destruir a otros agentes, destruir contenedores y parar la plataforma.

·         The DF (Directory Facilitator) proporciona un directorio que anuncia qué agentes hay disponibles en la plataforma.

Extensiones

JADE tiene una extensión denominada WADE (Workflows and Agents Development Environment) que es un sistema de workflow que permite crear procesos mediante un editor gráfico llamado WOLF.

Integrantes:

Martha Lidia Posadas Castillo            1491761

Ana Perla Reyna Martìnez                  1493892

Luis Adriàn Gòmez Elizondo             1484451

 

Reporte 1

                                  
Ventilador adaptativo

  

Introducción

Como actividad fundamental de la unidad 1 hicimos la simulación de un ventilador, el lenguaje que empleamos para codificarlo fue Python.

Desarrollo

En nuestro ventilador se mostrará un fondo de acuerdo a la estación del año que esté en el mes que se seleccionó de manera aleatoria, posteriormente nosotros ingresaremos la temperatura que deseamos que esté en el interior de la habitación, en nuestro programa se genera la temperatura exterior de manera aleatoria, estableciendo nosotros un rango específico dependiendo de el mes que nos encontremos, la temperatura interior que está antes de encender el ventilador, también es generada de manera aleatoria, y si esta es mayor a la deseada, se le resta un numero aleatorio del 1 al 10, y si es menor se le suma del 1 al 5, también realizado de manera aleatoria, cuando nuestro ventilador llegue a la "temperatura deseada" el programa se detiene. 

  

Código 

#! usr/bin/env python

#importamos las librerías a utilizar en el programa
import time
import random
import pygame
from pygame.locals import *
pygame.init()

#Aquí damos un alto y un ancho a la ventana 
ancho=455 
alto=341

#función a utilizar en el programa
def tempintex(tempexterior, temp, tempinterior):
     
   while (temp != tempinterior):
     if(tempinterior < temp):
        suma = random.randint(1, 5)
        tempinterior= tempinterior + suma 
        print "\nTemperatura interior",tempinterior 
        print "Temperatura exterior",tempexterior
     else:
        suma = random.randint(1, 10)
        tempinterior= tempinterior - suma
        print "\nTemperatura interior",tempinterior
        print "Temperatura exterior",tempexterior

    #Convertimos a str las variables para mostrarlas en la interfaz
     temp = str(temp)

     tempinterior = str(tempinterior)
     screen.blit(fuente.render(temp, True, (0, 0, 0)), (422, 253))
     screen.blit(fuente2.render(tempinterior, True, (220, 220, 220)), (227, 77))
     pygame.display.update()

     

     #Actualizamos el fondo dependiendo del mes que obtuvimos del random
     if((mes == 1)or (mes == 2) or (mes == 3) or (mes == 12)):
        screen.blit(i, (0, 0))
 
     elif((mes == 4)or (mes == 5)):
        screen.blit(p, (0, 0))
 
     elif((mes == 6)or (mes == 7) or (mes == 8) or (mes == 9)):
        screen.blit(v, (0, 0))
 
     elif((mes == 10)or (mes == 11)):
        screen.blit(o, (0, 0))
 

     #Volvemos a convertir a enteros las variables
     temp= int(temp)
     tempinterior= int(tempinterior)
     time.sleep(2)
        
if __name__ == "__main__":


    mes = random.randint(1, 12)
    if mes == 1:
        print "Enero"
        temp = input("\nTemperatura deseada del ventilador?: ")        
    elif (mes == 2):
        print "Febrero"
        temp = input("\nTemperatura deseada del ventilador?: ")
  #se repite lo mismo hasta elif( mes == 12):

    screen = pygame.display.set_mode((ancho, alto))
    pygame.display.set_caption("Ventilador Adaptativo")
    p = pygame.image.load("primavera.jpg")
    v = pygame.image.load("verano.jpg")
    o = pygame.image.load("otono.jpg")
    i = pygame.image.load("invierno.jpg")
    fuente = pygame.font.Font(None, 25)
    fuente2= pygame.font.Font(None, 20)
    pygame.display.flip()
    time.sleep(1)
         

    #Solo evaluamos el mes, dependiendo de que mes salga se hará una tarea 

    #específica con un rango de temperaturas en cada uno de ellos
    if mes == 1:
        print "\nInvierno"
        screen.blit(i, (0, 0))        
        pygame.display.update()  
        tempexterior =random.randint(8,20)
        tempinterior =random.randint(4, 24)      
        tempintex(tempexterior, temp, tempinterior) 

    elif mes == 2:
        print "\nInvierno"
        screen.blit(i, (0, 0))
        pygame.display.update()   
        tempexterior =random.randint(10,23) 
        tempinterior =random.randint(6,25)
        tempintex(tempexterior, temp, tempinterior)    

    elif mes == 3:
        print "\nInvierno"
        screen.blit(i, (0, 0))
        pygame.display.update()   
        tempexterior =random.randint(14,27)    
        tempinterior =random.randint(10,31)
        tempintex(tempexterior, temp, tempinterior)

    elif mes == 4:
        print "\nPrimavera"
        screen.blit(p, (0, 0))
        pygame.display.update() 
        tempexterior =random.randint(17,30) 
        tempinterior =random.randint(13,34)
        tempintex(tempexterior, temp, tempinterior)     

    elif mes == 5:
        print "\nPrimavera"
        screen.blit(p, (0, 0))
        pygame.display.update()  
        tempexterior =random.randint(20,32)    
        tempinterior =random.randint(16,36)
        tempintex(tempexterior, temp, tempinterior)

    elif mes == 6:
        print "\nVerano"
        screen.blit(v, (0, 0))
        pygame.display.update()       
        tempexterior =random.randint(22,34)
        tempinterior =random.randint(18,38)
        tempintex(tempexterior, temp, tempinterior)

    elif mes == 7:
        print "\nVerano"
        screen.blit(v, (0, 0))
        pygame.display.update()    
        tempexterior=random.randint(22,34)
        tempinterior =random.randint(18,38)
        tempintex(tempexterior, temp, tempinterior)   

    elif mes == 8:
        print "\nVerano"
        screen.blit(v, (0, 0))
        pygame.display.update()  
        tempexterior =random.randint(22,34) 
        tempinterior =random.randint(18,38) 
        tempintex(tempexterior, temp, tempinterior)   

    elif mes == 9:
        print "\nVerano"
        screen.blit(v, (0, 0))
        pygame.display.update()       
        tempexterior =random.randint(21,31)
        tempinterior =random.randint(18,35)
        tempintex(tempexterior, temp, tempinterior)

    elif mes == 10:
        print "\nOtono"
        screen.blit(o, (0, 0))
        pygame.display.update()       
        tempexterior =random.randint(17,27)
        tempinterior =random.randint(14,24)
        tempintex(tempexterior, temp, tempinterior)
    elif mes == 11:
        print "\nOtono"
        screen.blit(o, (0, 0))
        pygame.display.update()   
        tempexterior =random.randint(13,24) 
        tempinterior =random.randint(9,27) 
        tempintex(tempexterior, temp, tempinterior)

    elif mes == 12:
        print "\nInvierno"
        screen.blit(i, (0, 0))
        pygame.display.update() 
        tempexterior =random.randint(9,21)
        tempinterior =random.randint(5,24) 
        tempintex(tempexterior, temp, tempinterior) 
    

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit()

Video

Integrantes:
Martha Lidia Posadas Castillo          1491761
Ana Perla Reyna Martínez               1493892
Luis Adrián Gómez Elizondo            1484451

Reporte 2

         

                                        Reporte 2    
          
                   Análisis de una red compleja 


Introducción: 

En este reporte realizamos  el análisis de una red compleja, se nos proporcionó una red compleja representada en una matriz de  adyacencias (la matriz de adyacencia es una matriz cuadrada que se utiliza como una forma de representar relaciones binarias, donde por cada 1 que haya en la matriz , existe una arista que une a dos nodos),  a partir de ella generamos un programa que obtiene la densidad de la red con la formula -> D= 2m / n(n-1), donde:
                                     m= numero de aristas                      n= numero de vertices
también genera la distribución de grado, la cual es probabilidad Pr(k) de que un vértice escogido aleatoriamente tenga grado k y agregamos la gráfica de la distribución de grado de nuestra red compleja.


Código:

import collections 
red = [
[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]
] #Listas en una lista
aristas=0 #Arista corresponde a una relacion entre dos vertices de un grafo.
vertices=0 #Un vertice o nodo es la unidad fundamental de la que estan formados los grafos. 
sb=0
b=0
sumasdebebes=[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]


for bebe in red: #Contador de vertices y aristas
 vertices=vertices+1
 for elemento in red[b]:
  if elemento == 1:
   aristas = aristas+1
  sumasdebebes[sb]=sumasdebebes[sb] + elemento
 sb+=1
 b+=1 
aristas=aristas/2


#Contador de repeticiones
cont_de_rep = collections.Counter(sumasdebebes) #Nos dice con que frecuancia aparecen los elementos en una lista 
rep_ord = sorted(cont_de_rep) #Ordena el indice de grados

res_conteo = [] #Lista vacia
for n in cont_de_rep: #Por cada grado en el diccionario
    res_conteo.append(cont_de_rep[n])  #Hace indice de repeticiones

##############Revisar Listas
#print rep_ord
#print cont_de_rep
#print res_conteo

###############Resultados
print "\n \t                ~~~~~~~~~~~~~~~~~ Distribucion de grado ~~~~~~~~~~~~~~~~~"
print "\n\t       Probabilidad Pr(k) de que un vertice escogido aleatoriamente tenga grado k"
i = 0
print "\n\t\t                 ||Grado !           Pr(k)           ||"
for elemento in res_conteo:     

    prk = float(elemento)/float(vertices)

    if rep_ord[i] < 10:

        print "\t\t                 || ",rep_ord[i],"  !  ",elemento,"/",vertices, "=", prk,"||"
    else:
        print "\t\t                 || ",rep_ord[i]," !  ",elemento,"/",vertices, "=", prk,"||"
    i+=1


print "__________________________________________________________________________________"



print "\n \t                     ~~~~~~~~~~~~~~~~ Densidad de red~~~~~~~~~~~~~~~~ \n\n\t\t\t            D= 2(aristas)/ vertices(vertices-1)  \n"
print "\n\t\t\t              Numero de vertices =", vertices, "\n\t\t\t              Numero de aristas  =", aristas
M1=2*aristas
M2=vertices*(vertices-1)
densidad = float(M1)/float(M2)
print "\t\t\t              Densidad de la red =", densidad, "\n"

 
Resultados:

                      Distribución de grado y densidad de la red

                                          Gráfica de la distribución de grado 

Probabilidad Pr(k) de que un vértice escogido aleatoriamente tenga grado k.

Video:


Integrantes: Martha Lidia Posadas Castillo          1491761  Ana Perla Reyna Martínez              1493892   Luis Adrián Gómez Elizondo           1484451