Python R2


Traducción de la documentación de cocos2d

Posted in Python por Arturo Elias Antón en 30 octubre 2008
Tags: ,

La verdad que después de ver la presentación en Santa Fe de cocos2d de Lucio Torres, me quede impresionado. Y hoy me decidí a empezar a traducir la documentación del proyecto  cocos2d.

Bueno el link es http://code.google.com/p/los-cocos/w/list

Como siempre espero que les guste y gracias a Lucio por dejarme participar activamente del proyecto. 🙂

Anuncios

Un tipico ejemplo de Logica Borrosa o Disfusa en Python

¿Que es la logica borrosa o difusa?

La lógica borrosa o difusa se basa en lo relativo de lo observado asì. Este tipo de lógica toma dos valores aleatorios, pero contextualizados y referidos entre sí. Así, por ejemplo, una persona que mida 2 metros es claramente una persona alta, si previamente se ha tomado el valor de persona baja y se ha establecido en 1 metro. Ambos valores están contextualizados a personas y referidos a una medida métrica lineal.[http://es.wikipedia.org/wiki/Lógica_difusa]

Las lógicas difusas tratan de crear aproximaciones matemáticas en la resolución de ciertos tipos de problemas. Pretenden producir resultados exactos a partir de datos imprecisos, por lo cual son particularmente útiles en aplicaciones electrónicas o computacionales.

un buen link de logica difusa es: http://delta.cs.cinvestav.mx/~gmorales/ldifl/ldifl.html

Un ejemplo tipico en python

En esta oportunita quería mostrar una implementación simple de lógica difusa. Para eso acudí al típico ejemplo del ventilador y la pelota.

El script principal es

#!/usr/bin/env python
#Archivo: ventiladorBorroso.py

import logicaBorrosa
import random

def borroso(objY,posY):
	distancia = objY-posY

	centrado	=logicaBorrosa.fxTriangulo   (distancia,-10.0,0.0,10.0)
	cercaA		=logicaBorrosa.fxTrapezoide  (distancia,10.0,80.0,120.0,180.0)
	normalA     =logicaBorrosa.fxTrapezoide  (distancia,120.0,160.0,240.0,280.0)
	lejosA		=logicaBorrosa.fxGrado	     (distancia,240.0,300.0)
	cercaB		=logicaBorrosa.fxTrapezoide  (distancia,-180.0,-120.0,-80.0,-10.0)
	normalB		=logicaBorrosa.fxTrapezoide  (distancia,-280.0,-240.0,-160.0,-120.0)
	lejosB		=logicaBorrosa.fxGradoInversa(distancia,-300,-240)

	tmp =(centrado*9.8+cercaA*4.0+normalA*2.0+lejosA*1.0+cercaB*14.0+normalB*15.5+lejosB*18.0)
	div = (centrado+cercaA+normalA+lejosA+cercaB+normalB+lejosB)
	try:
		tmp /= div
	except:
		pass

	return tmp

gravedad = 9.81

velY = 0.0
posY= random.randrange(150.0,450.0)
ventilador = random.randrange(1.0,120.0)/10.0
objY=300

while True:
	caos = 0.0
	ventilador = borroso(objY,posY) # Llevamos a cabo el calculo borroso
	caos = (random.randrange(-50,50))/10.0
	velY = ((gravedad-ventilador+caos)*0.01)
	posY +=velY
	print posY

el modulo que contiene a todas las funciones de membresia es

#Archivo: logicaBorrosa.py
#
#Funciones de Membresia
#
def fxBool(x,y):
	"""
		Funcion de membresia boleana.
		Solo retorna dos valores 1,0
	"""
	if x<=y:
		return 0
	else:
		return 1

def fxBoolInversa(x,y):
	"""
		Funcion inverda de la funcion de membresia boleana.
		Solo retorna dos valores 1,0
	"""
	return 1-fxBool(x,y)

def fxGrado(x,y,z):
	"""
		Funcion de membresia de grado.
	"""
	if x<=y:
		return 0.0
	elif x>y and x<z:
		return (x/(z-y))-(y/(z-y))
	else:
		return 1.0

def fxGradoInversa(x,y,z):
	"""
		Funcion de membresia de grado.
	"""
	if x<=y:
		return 1.0
	elif x>y and x<z:
		return -(x/(z-y))+(z/(z-y))
	else:
		return 0.0

def fxTriangulo(x,x0,x1,x2):
	"""
		funcion de membresia Triangulo
	"""
	if x<=x0:
		return 0.0
	elif x>x0 and x<=x1:
		return (x/(x1-x0))-(x0/(x1-x0))
	elif x>x1 and x<=x2:
		return -(x/(x2-x1))+(x2/(x2-x1))
	else:
		return 0.0

def fxTrapezoide(x,x0,x1,x2,x3):
	"""
		funcion de membresia Trapezoide
	"""
	if x<=x0:
		return 0.0
	elif x>x0 and x<=x1:
		return (x/(x1-x0))-(x0/(x1-x0))
	elif x>x1 and x<=x2:
		return 1.0
	elif x>x2 and x<=x3:
		return -(x/(x3-x2))+(x3/(x3-x2))
	else:
		return 0.0

#
# Operadores Borroso
#
def OperadorAnd(x,y):
	return min(x,y)
def OperadorOR(x,y):
	return max(x,y)
def OperadorNOT(x):
	return 1-x

Saludos y espero que les guste y les sirva 🙂

Un script python de esteganografía

Posted in Python por Arturo Elias Antón en 28 octubre 2008
Tags: , , ,

Con este simple script fue con el que oculte la imagen en la entrada anterior. (simplemente le cambio la paridad al ultimo parametro del color RGB.) Este script es solo para tener una idea de lo que es la esteganografía y para mostrar una simple implementacion. Espero que les guste.

#!/usr/bin/env python
# Archivo: fusion.py
import Image
import sys

def fusionar(arch1,arch2):
	try:
		imagen =Image.open(arch1)
		msg    =Image.open(arch2)
		xsize,ysize = imagen.size
		xsizeMsg,ysizeMsg = msg.size

		if (xsizeMsg,ysizeMsg) != (xsize,ysize):
			return -1 # imagenes de distinta dimencion

		for y in range(ysize):
			for x in range(xsize):
				pixelImg = imagen.getpixel((x,y))
				pixelMsg = msg.getpixel((x,y))
				promRGB = (pixelMsg[0]+pixelMsg[0]+pixelMsg[0])/3
				if promRGB > 125 :
					if pixelImg[2]%2!=0:
					   pixelSet = (pixelImg[0],pixelImg[1],pixelImg[2]+1)
					   if (pixelImg[2] == 255) :
					       pixelSet = (pixelImg[0],pixelImg[1],pixelImg[2]-1)
	 				   imagen.putpixel((x,y),pixelSet)
				else:
					if pixelImg[2]%2==0:
					   pixelSet = (pixelImg[0],pixelImg[1],pixelImg[2]+1)
					   imagen.putpixel((x,y),pixelSet)
		imagen.save("fus.bmp")

		return 0
	except:
		return -1

def desFusionar(arch1):
	try:
		imagen =Image.open(arch1)
		xsize,ysize = imagen.size
		for x in range(xsize):
			for y in range(ysize):
				pixelImg = imagen.getpixel((x,y))
				if pixelImg[2] % 2 ==0:
					imagen.putpixel((x,y),(255,255,255))
				else:
					imagen.putpixel((x,y),(0,0,0))
		imagen.save("des.bmp")
		return 0
	except:
		return -1

def imprimirModoDeEjecucion():
	print "BinSD v1.0"
	print "Mode de ejecucion:"
	print "	fusion.py -D arch1"
	print "	fusion.py -C arch1 arch2"

if len(sys.argv) == 3 and sys.argv[1]== "-D":
	print "Procesando...",
	if desFusionar(sys.argv[2])==0:
		print "ok"
	else:
		print "err"
elif len(sys.argv) == 4 and sys.argv[1]== "-C":
	print "Procesando...",
	if fusionar(sys.argv[2],sys.argv[3]) == 0:
		print "ok"
	else:
		print "err"
else:
	imprimirModoDeEjecucion()

En esta entrada quiero felicitar a Arnau y a Alejandro J. Cura. que lograron sacar el desafio.

el script con el que logro sacar el codigo Arnau es …

import PIL.Image
img = PIL.Image.open(”fus.bmp”)
img.point([0]*256+[0]*256+[( (x&1) << 8 ) for x in range(256)]).show()

el script con el que lo saco Alejandro es …

from itertools import izip, chain, repeat
from PIL import Image

def grouper(n, iterable, padvalue=None):
    return izip(*[chain(iterable, repeat(padvalue, n-1))]*n)

i=Image.open("fus.bmp")
r,g,b=i.split()
i=b
s=i.tostring()

d = ["%d"%(ord(c)&amp;1) for c in s]

o = []
for g in grouper(8, d):
    b = "".join(g)
    o.append(chr(int(b,2)))

b="".join(o)
d=Image.fromstring("1",(800,480),b)
d.show()

😉

Un pequeño desafio.

Posted in Python por Arturo Elias Antón en 27 octubre 2008
Tags: , , , , , , ,

Hola este desafío es muy simple.
Mediante un script muy simple que escribí en Python de esteganografía, oculté una imagen con un código numérico en la siguiente imagen.

Link: http://www.binsd.com.ar/fusion/fus.bmp

¿Quien lo podrá descifrar?

El que lo logre sacar simplemente poste el código que visualiza en la imagen  en los comentarios de esta entrada.

Publicare el script cuando alguien saque el código!!!!!! 😉

Como siempre saludos y espero que les guste.

Buscando caminos con python

Uno de los problemas que me enfrente hoy era aun pequeño mapa donde yo tenía que pasarle la ciudad origen y destino  y mi py tenia que contestar con el camino mas corto posible. buscando en google encontre este link:
http://www.cruzrojaguayas.org/inteligencia/B%FAsqueda%20respaldados%20con%20informaci%F3n.htm

y basándome en el ejemplo de Algoritmo A* hice esto.

Mapa

Mapa

Acá un mapa con las ciudades. (Perdón por mi ignorancia geográfica) 🙂

Y acá el script.

#!/usr/bin/env python
#Archivo: buscadorDecaminos.py
from mapa import Puntos, Mapa

mapa    = Mapa()
mapa.add(Puntos("Capital Federal"))
mapa.add(Puntos("Santa Fe"))
mapa.add(Puntos("Rosario"))
mapa.add(Puntos("Parana"))
mapa.add(Puntos("San Luis"))
mapa.add(Puntos("Cordoba"))
mapa.add(Puntos("Mendoza"))
mapa.add(Puntos("Tucuman"))

mapa.puntos["Capital Federal"].add(mapa.puntos["Rosario"],320)
mapa.puntos["Capital Federal"].add(mapa.puntos["Cordoba"],716)
mapa.puntos["Rosario"].add(mapa.puntos["Parana"],175)
mapa.puntos["Rosario"].add(mapa.puntos["Santa Fe"],150)
mapa.puntos["Rosario"].add(mapa.puntos["Cordoba"],398)
mapa.puntos["Santa Fe"].add(mapa.puntos["Parana"],29)
mapa.puntos["Cordoba"].add(mapa.puntos["Tucuman"],534)
mapa.puntos["Cordoba"].add(mapa.puntos["Mendoza"],617)
mapa.puntos["Cordoba"].add(mapa.puntos["San Luis"],413)

print "Capital Federal -> Parana:",mapa.camino("Capital Federal","Parana")
print "Capital Federal -> San Luis:",mapa.camino("Capital Federal","San Luis")
print "Tucuman         -> Capital Federal:",mapa.camino("Tucuman","Capital Federal")
print "Tucuman         -> Mar del plata  :",mapa.camino("Tucuman","MDQ")

y aca el modulo mapa

#!/usr/bin/env python
#Archivo: mapa.py
class Puntos:
    def __init__(self,nombre):
        self.relaciones = {}
        self.nombre = nombre
        self.max = 0

    def add(self,p,d,b = True):
        self.relaciones[p.nombre] = [p,d]
        if b: p.add(self,d,False)

    def caminoA(self,hasta,recorrido=0,recorridas=[],camino=[]):

        minimo = None;

        if hasta == self.nombre:
            return  [recorrido,[self.nombre]] # estoy en la ciudad wiiiiiii

        recorridas.append(self.nombre)      # pase por aca
        nodosHijos = filter(lambda x:not x in recorridas, self.relaciones) #mis hijos por los cuales no pase son
        if nodosHijos == []: return ["Fallo","Fallo"] # 😦 no llegue a ningun lado

        for p in nodosHijos:
            datos = self.relaciones[p][0].caminoA(hasta,self.relaciones[p][1],recorridas)
            if (datos[0] != "Fallo") and  (datos[0] < minimo or minimo == None):
                minimo = datos[0]
                nodoElegido = datos[1]

        try: # si no existe nodoElegido
            nodoElegido.insert(0, self.nombre)
        except: # Fallo
            return ["Fallo","Fallo"]

        return [recorrido + minimo,nodoElegido]

class Mapa:
    def __init__(self):
        self.puntos = {}

    def add(self,p):
        self.puntos[p.nombre]=p

    def camino(self,desde,hasta):
        return self.puntos[desde].caminoA(hasta,0,[],[])

La salida es:

>>>
Capital Federal -> Parana: [495, ['Capital Federal', 'Rosario', 'Parana']]
Capital Federal -> San Luis: [1129, ['Capital Federal', 'Cordoba', 'San Luis']]
Tucuman         -> Capital Federal: [1250, ['Tucuman', 'Cordoba', 'Capital Federal']]
Tucuman         -> Mar del plata  : ['Fallo', 'Fallo']
>>>

Como siempre espero que les guste y les sirva

Redes Neuronales en Python RNA

Posted in Python por Arturo Elias Antón en 16 octubre 2008
Tags: , , , , , , , ,

En un momento verdaderamente de ocio e improductividad de mi vida traduje una RNA que estaba implementada por Jeff Heaton en java a JavaSrcipt para un curso que dictaba en la consultora Everis de dicho lenguaje. La verdad me tenían medio cansado, con la pregunta ¿que se puede hacer en JS?. 😉

Hoy hablando con un amigo dije por que no hacerlo en python y mejor aun con un ejemplo mínimo y que no sea el maldito XOR para ver como se usa la RNA.

Bueno vasta de historia. Haremos un OCR que detecte números dibujados con el Mouse en una imagen jpg.

Entrenaremos la RNA con las siguientes 5 imágenes de 50×50 pixeles por número (http://picasaweb.google.com/arturoeanton/Pyrna). Y pediremos que nos entregue su representación en binario para facilitar la codificación de la salida.

#!/usr/bin/env python
#Archivo: pyOcr.py
import Image
import pyrna

def procImgRGB(arch):
    im=Image.open(arch)
    procesado=[]
    xsize,ysize=im.size

    matrixImg = map(lambda a:map(lambda a:[],range(50)),range(50))

    a = ""
    for x in range(0,xsize):
        for y in range(0,ysize):
            matrixImg[x][y]= im.getpixel((x,y))

    resp=[]
    for rangoX in [(0,10),(10,20),(20,30),(30,40),(40,50)]:
        for rangoY in [(0,10),(10,20),(20,30),(30,40),(40,50)]:
            manchado = 0
            for x in range(rangoX[0],rangoX[1]):
                for y in range(rangoY[0],rangoY[1]):
                    r,g,b=matrixImg[x][y]
                    if ((r+g+b)/3) < 50:
                        manchado += 1

            if manchado > 0:
                resp.append(1)
            else:
                resp.append(0)

    return resp

respuestas =[
    [0.00,0.00,0.00,0.00],#0
    [0.00,0.00,0.00,1.00],#1
    [0.00,0.00,1.00,0.00],#2
    [0.00,0.00,1.00,1.00],#3
    [0.00,1.00,0.00,0.00],#4
    [0.00,1.00,0.00,1.00],#5
    [0.00,1.00,1.00,0.00],#6
    [0.00,1.00,1.00,1.00],#7
    [1.00,0.00,0.00,0.00],#8
    [1.00,0.00,0.00,1.00] #9
    ]

print "Procesando ..."
entrada =[]
salidaIdeal = []
for i in range(10):
    for img in range(1,6):
        print "Procesando ./"+str(i)+"/"+str(img)+".jpg ...",
        entrada.append(procImgRGB("./"+str(i)+"/"+str(img)+".jpg"))
        salidaIdeal.append(respuestas[i])
        print "ok Respuesta esparada :",respuestas[i]

network = pyrna.classNetwork(25, 5 ,4,0.01,0.9)

print "Entrenando ..."
error = 10
i =0
while error > 0.25:
    for j in range(len(entrada)):
        network.computeOutputs(entrada[j])
        network.calcError(salidaIdeal[j])
        network.learn()
    error = network.getError(len(entrada))
    i +=1
    if i % 1000 == 0:
        print "Error: ",error,"%"
        i=0
print "Error: ",error,"%"
print "recalulo Img..."
for i in range(10):
    for img in range(1,6):
        a = "./"+str(i)+"/"+str(img)+".jpg"
        print a,"  ->",
        respDada = []
        for r in network.computeOutputs(procImgRGB(a)):
            respDada.append(round(r))
            print round(r),
        print (respDada == respuestas[i])

print "Que aprendiste?"
img = 7
for i in range(10):
    a = "./"+str(i)+"/"+str(img)+".jpg"
    print a,"  ->",
    respDada = []
    for r in network.computeOutputs(procImgRGB(a)):
        respDada.append(round(r))
        print round(r),
    print (respDada == respuestas[i])
  • Definimos la función procImgRGB que es una función recibe el nombre de una imagen y la separa en 25 cuadrados y nos dice que cuadrado esta manchado o no.
  • Definimos el vector respuestas con las respuestas esperadas. y armamos los pares (entrada – respuesta) en los vectores entrada y salidaIdeal.
  • Instanciamos una red con las 25 entradas posibles y 5 neuronas ocultas y 4 de salida. También le definimos el rate y el momentum.
  • La entrenamos hasta que el error global de la RNA sea 0.25
  • Imprimimos el resultado con las entradas propuestas.
  • Y por ultimo vemos que aprendió mediante la imagen 7.jpg de cada numero.

Para ver la salida de este script aca esta el link http://www.binsd.com.ar/pyrna/salida.txt

Links:

Como siempre espero que les guste 😉

JSON

Posted in Python por Arturo Elias Antón en 14 octubre 2008
Tags: , , , ,

Para empezara a ver JSON veremos lo que nos dice la wikipedia:

JSON, acrónimo de “JavaScript Object Notation”, es un formato ligero para el intercambio de datos. JSON es un subconjunto de la notación literal de objetos de JavaScript que no requiere el uso de XML.
La simplicidad de JSON ha dado lugar a la generalización de su uso, especialmente como alternativa a XML en AJAX. Una de las supuestas ventajas de JSON sobre XML como formato de intercambio de datos en este contexto es que es mucho más sencillo escribir un analizador semántico de JSON. En JavaScript, JSON puede ser analizado trivialmente usando el procedimiento eval(), lo cual ha sido fundamental para la aceptación de JSON por parte de la comunidad de desarrolladores Ajax, debido a la ubicuidad de JavaScript en casi cualquier navegador web.
[“http://es.wikipedia.org/wiki/JSON”]

Si bien JSON tiene origen en JavaScript, el sitio oficial de JSON www.json.org, nos ofrece librerías que no permiten trasformar los objetos JSON en objetos nativos de cada lenguaje o viceversa

Un objeto JSON está encerrado entre llaves “{}” y contiene propiedades separadas por coma, cada propiedad tiene un valor separado por dos punto “:” y cada valor puede ser:

  • String
  • Numero
  • Array
  • Función
  • Otro Objeto JSON

Un ejemplo de un JSON simple seria:

{
	“Nombre”:”Pedro”,
	“Apellido”: “Canoero”,
	“Edad”: 16,
	“Padres”: [“Maria”,”Juan”]
}

Las ventajas de JSON son muchas, es simple y rápido de escribir, su lectura es comprensible. JSON como todo objeto JavaScript se puede recorrer con un “for in” para saber todas las propiedades que posee.
JSON es indicado para el transporte de objetos entre un programa cliente y uno servidor en reemplazo de XML. Yo utilizo JSON en PyWars para el intercambio de datos entre el servidor de PyWars escrito en python y los clientes escritos en distintos lenguajes.

Un ejemplo en python seria.

#!/usr/bin/python
import json

dato="""
        {
            "Nombre":"Pedro",
            "Apellido": "Canoero",
            "Edad": 16,
            "Padres": ["Maria","Juan"]
     }
     """

obj=json.read(dato)

print obj["Nombre"]
print obj["Apellido"]
print obj["Edad"]
print obj["Padres"]

El efecto inverso

#!/usr/bin/python
import json
obj =  {
            "Nombre":"Pedro",
            "Apellido": "Canoero",
            "Edad": 16,
            "Padres": ["Maria","Juan"]
     }

print json.write(obj)

Observemos que parecido es escribir un JSON a un diccionario python 😉

3ra jornada de python de Santa Fe

Posted in Python por Arturo Elias Antón en 8 octubre 2008
Tags: , , , ,

Hoy después de desarrollar la segunda versión de PyWars para presentar al final del torneo que se llevara a acabo el día 18,  me decidí a volver a retomar la escritura.

Lo primero que quería contarles es que estuve en la 3ra jornada de python de Santa Fe. Y estuvo muy bueno. Sobre todo la charla de cocos2d de Lucio Torres la verdad me dejo impresionado.  Otra cosa que me gusto mucho fue la intro de python de Facundo Batista y la BeautifulSoup. Sinceramente para mi no tubo desperdicio encima me encontré y conocí mucha gente que solo la conocía por la lista de pyar o por gtalk.
También quería agradecer por los 5 minutos de fama en las Lighting Talks que me dieron para presentar pyWars. Desde ya muchas gracias!!!!!!.

Saludos y ya estoy preparando una entrada para el blog  de cómo usar JSON en python.