def ejecutar(self, ejemplos, atributos, maxDepth = None):
'''
Se ejecuta el algoritmo sobre la lista de datos "ejemplos", considerando los
atributos "atributos".
El algoritmo retorna un arbol de decision, de profundidad maxDepth (si no se
especifica se considera profundidad infinita).
'''
objetivo = self.atributoObjetivo
# Evaluo el caso en que todos los casos de prueba restantes tienen el mismo
# valor en el atributo objetivo
if len(set([e[objetivo] for e in ejemplos])) == 1:
# Retorno una hoja de tipo UNICO con el unico valor posible de G3
return Arbol(ejemplos[0][objetivo], TipoHijo.UNICO)
# Evaluo el caso en que no me quedan atributos por considerar o alcance la
# profundidad maxima estipulada para el arbol de decision
if len(atributos) == 0 or (maxDepth is not None and maxDepth <= 0):
# Retorno una hoja de tipo MAYORIA, cuyo valor es el valor de mayor
# frecuencia entre los ejemplos restantes
return Arbol(self.obtenerValorMasComun(ejemplos), TipoHijo.MAYORIA)
# Obtengo el mejor clasificador local y su ganancia asociada
mejorAtributo, ganancia = self.obtenerMejorClasificador(ejemplos, atributos)
# Remuevo el atributo seleccionado de la lista de atributos a considerar
nuevosAtributos = list(atributos)
nuevosAtributos.remove(mejorAtributo)
# Creo el nodo raiz. Las ganancias almacenadas son para uso estadistico
a = Arbol(mejorAtributo)
a.ganancia = ganancia
sumaGanancias = sum([g[1] for g in self.obtenerGanancias(ejemplos, atributos)])
a.gananciaRelativa = ganancia / sumaGanancias if sumaGanancias != 0 else 0
for v in self.valoresPosibles[mejorAtributo]:
# Para cada valor posible del atributo seleccionado, ejecuto un paso del algoritmo
# y almaceno el arbol resultante en una de las ramas del arbol
ejemplos_aux = [e for e in ejemplos if e[mejorAtributo]==v]
if len(ejemplos_aux) != 0:
rama = self.ejecutar(ejemplos_aux, nuevosAtributos, maxDepth - 1 if maxDepth is not None else None)
a.agregarRama(v, rama)
else:
a.agregarRama(v, Arbol(self.obtenerValorMasComun(ejemplos), TipoHijo.ELSE))
return a
def test_cuando_arbol_no_vacio_es_false(self): arbol = Arbol(2) self.assertFalse(arbol.vacio())
def test_cuando_arbol_vacio_es_true(self): arbol = Arbol() self.assertTrue(arbol.vacio())
def test_dos_arboles_distintos_es_false(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) otro_arbol = Arbol(1, Arbol(8, Arbol(9), Arbol(13)), Arbol(23, Arbol(65), Arbol(337))) self.assertNotEqual(arbol, otro_arbol)
def test_inorder_esperado(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.inorder(), [4, 2, 5, 1, 6, 3, 7])
def test_inorder_de_arbol_vacio_es_vacio(self): arbol = Arbol() self.assertEqual(arbol.inorder(), [])
def test_posorder_esperado(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.posorder(), [7, 6, 3, 5, 4, 2, 1])
else:
for hijo in arbol.hijos:
if arbol.hijos[hijo] is not None:
get_outcome(arbol.hijos[hijo])
def get_entradas(subconjunto, mov_pocmon, fantasmas):
sub_subconjunto = []
for fantasma, mov_fantasma in fantasmas:
for entrada in subconjunto:
if entrada[-1] == mov_pocmon and entrada[fantasma.nombre] == mov_fantasma:
sub_subconjunto.append(entrada)
return sub_subconjunto
for k, v in datos_agrupados.items():
print(k, v)
results = []
fantasma_root = Arbol(0)
crear_arbol(fantasma_root, 4)
fantasma_root.print(0)
get_miedo(fantasma_root)
print(miedo)
r = dict(sorted(miedo.items(), key=operator.itemgetter(1)))
print(r)
get_outcome(fantasma_root)
print(outcomes)
def test_preorder_esperado(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.preorder(), [1, 2, 4, 5, 3, 6, 7])
def p_init(p):
'init : instrucciones'
#p[0] = [p[1]]
p[0] = Arbol(p[1])
def ej_prof():
b1 = Bosque() # el bosque vacío
# _nodo
# b1: --------- --------
# | *---|----->| None |
# --------- --------
assert(len(b1) == 0), "--> Error en __len__ de bosque"
a1 = Arbol(10, b1) # plantar el árbol
print(b1)
# _nodo _valor _primog _sig_herm
# a1: --------- ---------- --------------------------
# | *---|----->| *----|----->| 10 | * | None |
# --------- ---------- -----------|--------------
# |
# v
# _nodo (apuntado por b1)
# --------
# | None |
# --------
assert(a1.raiz() == 10), "--> Error en raíz() de árbol"
assert(len(a1.hijos()) == 0), "--> Error en hijos() de árbol"
assert(a1.num_hijos() == 0), "--> Error en núm_hijos() de árbol"
assert(a1.es_hoja_()), "--> Error en es_hoja_() de árbol"
b1.add_arbol(a1) # añadir el árbol al bosque
# _nodo _valor _primog _sig_herm
# a1: --------- ---------- --------------------------
# | *---|----->| *----|----->| 10 | * | None |
# --------- ---------- -----------|--------------
# ^ |
# | v
# _nodo | _nodo (ya no apuntado por b1)
# b1: --------- ---------- | --------
# | *---|----->| *----|------| | None |
# --------- ---------- --------
assert(len(b1) == 1), "--> Error en __len__ de bosque"
a2 = Arbol(20, b1) # plantar el árbol
# _nodo _valor _primog _sig_herm
# a2: --------- ---------- --------------------------
# | *---|----->| *----|----->| 20 | * | None |
# --------- ---------- -----------|--------------
# |
# v
# _nodo (apuntado por b1)
# --------
# | *---|-----> _valor (10)
# --------
assert(a2.raiz() == 20), "--> Error en raíz() de árbol"
assert(len(a1.hijos()) == 1), "--> Error en hijos() de árbol"
assert(a1.num_hijos() == 1), "--> Error en núm_hijos() de árbol"
assert(not a1.es_hoja_()), "--> Error en es_hoja_() de árbol"
b3 = Bosque() # el bosque vacío
a3 = Arbol(30, b3) # plantar el árbol
b3.add_arbol(a3)
# _nodo _valor _primog _sig_herm
# a3: --------- ---------- --------------------------
# | *---|----->| *----|----->| 30 | * | None |
# --------- ---------- -----------|--------------
# |
# v
# _nodo (apuntado por b3)
# --------
# | None |
# --------
b4 = Bosque() # el bosque vacío
a4 = Arbol(40, b4) # plantar el árbol
b5 = Bosque() # el bosque vacío
b5.add_arbol(a3) # añadir el árbol al bosque
assert(len(b5) == 1), "--> Error en __len__ de bosque"
b5.add_arbol(a4) # añadir el árbol al bosque
assert(len(b5) == 2), "--> Error en __len__ de bosque"
a5 = Arbol(50, b5) # plantar el árbol
assert(a5.raiz() == 50), "--> Error en raíz() de árbol"
assert(len(a5.hijos()) == 2), "--> Error en hijos() de árbol"
assert(a5.num_hijos() == 2), "--> Error en núm_hijos() de árbol"
assert(not a5.es_hoja_()), "--> Error en es_hoja_() de árbol"
# try:
# print(b5[0])
# except AssertionError:
# pass
assert(b5[1].raiz() == 40), "--> Error en añ_árbol() de bosque"
assert(b5[2].raiz() == 30), "--> Error en añ_árbol() de bosque"
print('All tests are ok')
def main():
# Primero se crea el bosque
b_a = Bosque()
# Luego el arbol que contendra al bosque
a_a = Arbol('A', b_a)
b_b = Bosque()
a_b = Arbol('B', b_b)
b_c = Bosque()
a_c = Arbol('C', b_c)
b_d = Bosque()
a_d = Arbol('D', b_d)
b_a.add_arbol(a_b)
b_a.add_arbol(a_c)
b_a.add_arbol(a_d)
assert a_c.es_hoja_(), 'C no es un bosque vacio'
assert len(b_a) == 3, '--> Error al agregar los arboles B,C,D al bosque'
b_e = Bosque()
a_e = Arbol('E', b_e)
b_f = Bosque()
a_f = Arbol('F', b_f)
b_b.add_arbol(a_e)
b_b.add_arbol(a_f)
assert a_e.es_hoja_(), 'E no es un bosque vacio'
assert len(b_b) == 2, '--> Error al agregar los arboles E,F al bosque'
b_j = Bosque()
a_j = Arbol('J', b_j)
b_k = Bosque()
a_k = Arbol('K', b_k)
b_l = Bosque()
a_l = Arbol('L', b_l)
b_f.add_arbol(a_j)
b_f.add_arbol(a_k)
b_f.add_arbol(a_l)
assert len(b_f) == 3, '--> Error al agregar los arboles J,K,L al bosque'
b_g = Bosque()
a_g = Arbol('G', b_g)
b_h = Bosque()
a_h = Arbol('H', b_h)
b_i = Bosque()
a_i = Arbol('I', b_i)
b_d.add_arbol(a_g)
b_d.add_arbol(a_h)
b_d.add_arbol(a_i)
assert a_h.es_hoja_(), 'C no es un bosque vacio'
assert len(b_d) == 3, '--> Error al agregar los arboles J,K,L al bosque'
b_m = Bosque()
a_m = Arbol('M', b_m)
b_g.add_arbol(a_m)
assert len(b_g) == 1, '--> Error al agregar el arbol G al bosque'
b_p = Bosque()
a_p = Arbol('P', b_p)
b_q = Bosque()
a_q = Arbol('Q', b_q)
b_m.add_arbol(a_p)
b_m.add_arbol(a_q)
assert len(b_m) == 2, '--> Error al agregar los arboles P,Q al bosque'
b_n = Bosque()
a_n = Arbol('N', b_n)
b_o = Bosque()
a_o = Arbol('O', b_o)
b_i.add_arbol(a_n)
b_i.add_arbol(a_o)
assert len(b_i) == 2, '--> Error al agregar los arboles N,O al bosque'
print("Numero de nodos: %d" % num_nodos(a_a))
print("Numero de hojas :%d" % num_hojas(a_a))
print("Maximo grado: %d" % grado(a_a))
print("Altura del arbol: %d" % altura(a_a))
print('Recorrido preorden: ', end='')
print(preorden(a_a))
print('Recorrido postorden: ', end='')
print(postorden(a_a))
print('Recorrido niveles: ', end='')
print(niveles(a_a))
print('Recorrido frontera: ', end='')
print(frontera(a_a))
from arbol import Arbol
from ordenar import Ordenar
arbol = Arbol()
criatura = {
'name': 'Ceto',
'derrotado': '-',
'descripcion': '-',
'capturado': 'Trueno'
}
arbol = arbol.insertar_nodo(criatura['name'], criatura)
criatura = {
'name': 'Tifón',
'derrotado': 'Zeus',
'descripcion': '-',
'capturado': 'Sol'
}
arbol = arbol.insertar_nodo(criatura['name'], criatura)
criatura = {
'name': 'Equidna',
'derrotado': 'Argos Panoptes',
'descripcion': '-',
'capturado': 'Mar'
}
arbol = arbol.insertar_nodo(criatura['name'], criatura)
criatura = {'name': 'Enio', 'derrotado': '-'}
arbol = arbol.insertar_nodo(criatura['name'], criatura)
criatura = {
'name': 'Medusa',
'derrotado': 'Perseo',
'descripcion': '-',
else:
for hijo in arbol.hijos:
if arbol.hijos[hijo] is not None:
get_outcome(arbol.hijos[hijo])
def get_entradas(subconjunto, mov_pocmon, fantasmas):
sub_subconjunto = []
for fantasma, mov_fantasma in fantasmas:
for entrada in subconjunto:
if entrada[-1] == mov_pocmon and entrada[
fantasma.nombre] == mov_fantasma:
sub_subconjunto.append(entrada)
return sub_subconjunto
for k, v in datos_agrupados.items():
print(k, v)
results = []
fantasma_root = Arbol(0)
crear_arbol(fantasma_root, 4)
fantasma_root.print(0)
get_miedo(fantasma_root)
print(miedo)
r = dict(sorted(miedo.items(), key=operator.itemgetter(1)))
print(r)
get_outcome(fantasma_root)
print(outcomes)
from arbol import Arbol
tabla = [['Despejado', 0.22], ['Nublado', 0.15], ['Lluvia',0.03], ['Baja', 0.26], ['Alta', 0.14], ['1', 0.05], ['2', 0.01],['3', 0.035], ['5', 0.06],['7', 0.02], ['8',0.025]]
dic = {}
def como_comparo(arbol):
return arbol.frecuencia
bosque = []
for info, frecuencia in tabla:
arbol = Arbol(info, frecuencia)
bosque.append(arbol)
bosque.sort(key=como_comparo)
for arbol in bosque:
print(arbol.info, arbol.frecuencia)
while(len(bosque) > 1):
arbol1 = bosque.pop(0)
arbol2 = bosque.pop(0)
nuevo_arbol = Arbol(frecuencia=arbol1.frecuencia+arbol2.frecuencia)
nuevo_arbol.izq = arbol1
nuevo_arbol.der = arbol2
bosque.append(nuevo_arbol)
bosque.sort(key=como_comparo)
def test_devuelve_la_raiz(self): arbol = Arbol(2) self.assertEqual(arbol.raiz(), 2)
def test_dos_arboles_iguales_es_true(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) otro_arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol, otro_arbol)
from arbol import Arbol
from random import randint
arbol = Arbol()
for i in range(10):
numero = randint(1000, 9999)
arbol.insertar_nodo(numero)
contpares=0
contimpares=0
if (arbol.info%2==0):
contpares+=1
else:
contimpares+=1
print(contpares)
print(contimpares)
