def generar_estadisticas(ruta_base = '.'):
valores = ['Lambda','Spread','Upsilon','no_dominadas']
patrones_OK = [r'ejecuciones']
patron_KO = r'ejecuciones\\antiguos'
f_estadisticas = r'\\estadisticas.txt'
lista = explorador(path = ruta_base, niveles = 3)
lista_filtrada = []
for patron in patrones_OK:
parcial = filtro(lista, patron = patron, excluidos = patron_KO)
for sub in parcial:
if not sub in lista_filtrada:
lista_filtrada.append(sub)
#En este punto lista_filtrada contiene la ruta base de cada simulación.
#Es decir, la ruta justo antes de la carpeta con la fecha
for ruta in lista_filtrada:
l_arch = explorador(ruta)
fl_arch = filtro(l_arch, f_estadisticas)
#Ahora tenemos que recorrer todos los fl_arch y sacar las estadísticas
#Todos corresponden al mismo experimento
nombre_sim = ruta[len(ruta) - ruta[::-1].find('\\'):]
st = Estadisticas(nombre_sim)
for v in valores:
st.nuevo_Acumulador(v)
for arch in fl_arch:
#Leemos el archivo de estadísticas
with open(arch) as fin:
lectura = [l.strip() for l in fin]
for v in valores:
st[v](lookup(lectura, v))
st.guardar(ruta, fichero = nombre_sim + '.txt')
def test_num_elementos_cadena_N(self):
self.assertEqual(Estadisticas().calcular("10,7,5,3,1"),
[5, 1, 10, 5.2],
"Numero de elementos Cadena N elementos")
self.assertEqual(Estadisticas().calcular("10,10,10,10,10"),
[5, 10, 10, 10],
"Numero de elementos Cadena N elementos")
self.assertEqual(Estadisticas().calcular("1,1,1,1,1"), [5, 1, 1, 1],
"Numero de elementos Cadena N elementos")
def __init__(self, size, operadores, generacion = 0, stats = None):
self.size = size
self.gen = generacion
if stats is None:
self.stats = Estadisticas('Estadisticas')
else:
self.stats = stats
self.stats.nuevo_Contador('gens') # Generación actual
if not operadores is None:
self.__class__._selector = operadores['selector']
self.__class__._cruzador = operadores['cruzador']
self.__class__._seleccionador = operadores['seleccionador']
def __init__(self, objetivos, dims, lims, restricciones = None,\
frentePareto = None, parametros = None, operadores = None, stats = None, extras = None):
'''Inicializador del problema:
objetivos: iterable de funciones (se supone minimización)
dims: dimensiones del espacio de soluciones
lims: hipercubo con los límites en cada dimensión (iterable de 2-tuples)
restricciones: conjunto de funciones booleanas para comprobar si una
solución es válida. None por defecto.
frentePareto: diccionario con dos claves:
frente: el frente completo, un iterable con las imágenes de las soluciones
extremos: las imágenes extremas, para algunas métricas
parametros: Parametros de todo el proceso
operadores: operadores evolutivos usados en el problema
stats: módulo de estadisticas
'''
self.objetivos = objetivos
#Comprobamos la coherencia de n y lims
if dims != len(lims):
raise ProblemException('n no coincide con la dimensión de lims')
else:
for i in range(dims):
if len(lims[i]) != 2:
raise ProblemException('El elemento ' + str(i) + ' de lims no tiene dos componentes')
elif lims[i][0] >= lims[i][1]:
raise ProblemException('Límites incongruentes lims[{}] = [{}, {}]'.format(i, lims[i][0], lims[i][1]))
self.dims = dims
self.lims = lims
if restricciones == None:
self.restricciones = []
else:
self.restricciones = restricciones
self.evops = operadores
self.parametros = parametros
if stats is None:
self.stats = Estadisticas(self.parametros.get('nom_stats', 'estadisticas'))
else:
self.stats = stats
self.stats.nuevo_Contador('evals') # Número de evaluaciones de los objetivos
self.fp = frentePareto
if extras is None:
self.extras = Params()
else:
self.extras = extras
def post(self):
if (self.request.get('guardar')):
#NDB
porcentaje = BD_PorcentajeSuspensosProfes(parent = ndb.Key("Estadisticas_almacenadas","PorcentajeSuspensosProfe"),id_profe=1,porcentaje=0.5)
porcentaje_key = porcentaje.put()
#porcentaje = BD_PorcentajeSuspensosProfes(parent = ndb.Key("Estadisticas_almacenadas","PorcentajeSuspensosProfe"),1,0.5)
#porcentaje.put()
self.redirect('/configurar_estadisticas')
if (self.request.get('ver_estadisticas')):
ancestor_key = ndb.Key("Estadisticas_almacenadas","PorcentajeSuspensosProfe")
estadisticas_suspensos_profes = BD_PorcentajeSuspensosProfes.estadisticas_guardadas(ancestor_key).fetch(20)
vector_estadisticas=[];
for estadistica in estadisticas_suspensos_profes:
leido =[]
leido.append(estadistica.fecha)
leido.append(estadistica.id_profe)
leido.append(estadistica.porcentaje)
vector_estadisticas.append(leido)
self.response.out.write(vector_estadisticas)
#sprint estadistica.id_profe
#self.redirect('/configurar_estadisticas')
if not(self.request.get('orden')):
plantilla = plantilla_env.get_template('plantilla/index.html')
self.response.out.write(plantilla.render())
else:
string = "Orden no encontrada"
if(self.request.get('orden')) =="obtenerPorcentajeSuspensosProfesores":
string = str(Estadisticas.obtenerPorcentajeSuspensosProfesores("SinFiltros"))
string = string +'<input type="submit" id="guardar" name="guardar" value="Guardar Estadisticas"></input> <input type="submit" name="ver_estadisticas" id="ver_estadisticas" value="Ver Estadisticas anteriores"></input>'
templateVars = {"texto" : string}
plantilla = plantilla_env.get_template('plantilla/index.html')
self.response.out.write(plantilla.render(templateVars))
def test_getRankigClasesPartes(self):
respuesta = Estadisticas.obtenerRankingPartesCurso("Sin filtro")
self.assertTrue(len(respuesta))
def test_dar_estadiciticas_un_string_y_minimo(self):
self.assertEqual(Estadisticas().dar_estadisticas("1")[0], 1,
"Un solo numero")
self.assertEqual(Estadisticas().dar_estadisticas("1")[1], 1, "Minimo")
self.assertEqual(Estadisticas().dar_estadisticas("2")[1], 2, "Minimo")
def test_dar_estadiciticas_un_solo_numero_promedio(self):
self.assertEqual(Estadisticas().dar_estadisticas("4")[3], 4,
"Promedio")
def test_dar_estadiciticas_n_numeros_maximo(self):
self.assertEqual(Estadisticas().dar_estadisticas("3,4,6,9,6")[2], 9,
"Maximo")
self.assertEqual(Estadisticas().dar_estadisticas("7,3,5,2,1,4")[2], 7,
"Maximo")
def test_dar_estadiciticas_un_numero_maximo(self):
self.assertEqual(Estadisticas().dar_estadisticas("1")[2], 1, "Maximo")
self.assertEqual(Estadisticas().dar_estadisticas("2")[2], 2, "Maximo")
def test_cadenadeNElementos(self):
self.assertEqual(Estadisticas.getEstadisticas("3,1,7,5"), (4, 1, 7, 4),
"Cadena de 4 elementos (n)")
class Problem(object):
'''Define un problema en general, las clases que hereden de este tienen que
proveer implementaciones'''
def __init__(self, objetivos, dims, lims, restricciones = None,\
frentePareto = None, parametros = None, operadores = None, stats = None, extras = None):
'''Inicializador del problema:
objetivos: iterable de funciones (se supone minimización)
dims: dimensiones del espacio de soluciones
lims: hipercubo con los límites en cada dimensión (iterable de 2-tuples)
restricciones: conjunto de funciones booleanas para comprobar si una
solución es válida. None por defecto.
frentePareto: diccionario con dos claves:
frente: el frente completo, un iterable con las imágenes de las soluciones
extremos: las imágenes extremas, para algunas métricas
parametros: Parametros de todo el proceso
operadores: operadores evolutivos usados en el problema
stats: módulo de estadisticas
'''
self.objetivos = objetivos
#Comprobamos la coherencia de n y lims
if dims != len(lims):
raise ProblemException('n no coincide con la dimensión de lims')
else:
for i in range(dims):
if len(lims[i]) != 2:
raise ProblemException('El elemento ' + str(i) + ' de lims no tiene dos componentes')
elif lims[i][0] >= lims[i][1]:
raise ProblemException('Límites incongruentes lims[{}] = [{}, {}]'.format(i, lims[i][0], lims[i][1]))
self.dims = dims
self.lims = lims
if restricciones == None:
self.restricciones = []
else:
self.restricciones = restricciones
self.evops = operadores
self.parametros = parametros
if stats is None:
self.stats = Estadisticas(self.parametros.get('nom_stats', 'estadisticas'))
else:
self.stats = stats
self.stats.nuevo_Contador('evals') # Número de evaluaciones de los objetivos
self.fp = frentePareto
if extras is None:
self.extras = Params()
else:
self.extras = extras
def __call__(self, *args):
'''Hacemos que el problema sea una función'''
return self.evaluador(*args)
def evaluador(self, *args):
'''Evalúa todos los bojetivos en un punto'''
self.stats['evals']()
return np.array([o(*args) for o in self.objetivos])
def en_el_dominio(self, x):
'''comprobamos que x está dentro de los límites'''
return np.all(np.logical_and(self.lims[:,0] <= x, x <= self.lims[:,1]))
def violacion_restricciones(self, x):
'''comprobamos el nivel de violación de las restricciones'''
suma = 0
for f in self.restricciones:
if f(x) < 0:
suma += -f(x)
return suma
def dominado(self, x, y):
'''x, y son puntos del espacio de búsqueda.
Devuelve:
1 si x domina a y
0 si x no domina a y ni y a x
-1 si y domina a x
'''
ox = x.evaluado_en(self)
oy = y.evaluado_en(self)
dom1 = ox < oy #Si es todo verdad x domina a y
dom0 = ox == oy
dom_1 = ox > oy #Si es todo verdad y domina a x
if len(ox) == np.sum(dom1) + np.sum(dom0) and np.sum(dom1) > 0:
return 1
elif len(oy) == np.sum(dom_1) + np.sum(dom0) and np.sum(dom_1) > 0:
return -1
else:
return 0
def dominadoC(self, x, y):
'''Dominancia con restricciones
Devuelve:
1 si x es factible e y no
-1 si x no es factible pero y si
dominado(x,y) si x e y son factibles
1 si ambos son infactibles pero la violacion de x es menor que la de y
-1 si ambos son infactibles pero la violacion de y es menor que la de x
0 en caso contrario
'''
vrx = x.violacion_restricciones(self)
vry = y.violacion_restricciones(self)
if vrx == vry == 0:
#x, y factibles
return self.dominado(x,y)
elif vrx == 0:
#x factible, y no factible
return 1
elif vry == 0:
#x no factible, y factible
return -1
else:
if vrx < vry:
return 1
elif vrx == vry:
return 0
else:
return -1
def test_calcular_conUnNumero(self):
self.assertEqual(Estadisticas().calcular("1"),[1],"Un numero")
def test_promedio_conMultiplesNumeros(self):
self.assertEqual(Estadisticas().promedio("1,3,5,7"),[4,'1','7',4],"Multiples numeros")
def test_calcular(self):
self.assertEqual(Estadisticas().calcular(""),[],"Cadena vacia")
def test_promedio_conDosNumeros(self):
self.assertEqual(Estadisticas().promedio("1,3"),[2,'1','3',2],"Dos numeros")
def test_getAsistenciaTotal(self):
respuesta = Estadisticas.obtenerAsistenciaTotalCentro("Sin filtro")
self.assertTrue(len(respuesta))
def test_cadenadeUnElemento(self):
self.assertEqual(Estadisticas.getEstadisticas("1"), (1, 1, 1, 1),
"Cadena un elemento")
def test_estadisticas_it1_unnumero(self):
self.assertEqual(Estadisticas().estadisticas("1"), [1], "Un numero")
def test_dar_estadiciticas_n_numeros_y_minimo(self):
self.assertEqual(Estadisticas().dar_estadisticas("3,5,2,1")[0], 4,
"Cuatro")
self.assertEqual(Estadisticas().dar_estadisticas("3,5,2,1")[1], 1,
"Minimo")
class Poblacion(list):
'''La población será una lista de Puntos que representará a las soluciones
En las poblaciones definimos el cruce y la selección'''
def __init__(self, size, operadores, generacion = 0, stats = None):
self.size = size
self.gen = generacion
if stats is None:
self.stats = Estadisticas('Estadisticas')
else:
self.stats = stats
self.stats.nuevo_Contador('gens') # Generación actual
if not operadores is None:
self.__class__._selector = operadores['selector']
self.__class__._cruzador = operadores['cruzador']
self.__class__._seleccionador = operadores['seleccionador']
def select_with(self, nomCaracteristica, valor):
'''Seleccionamos los puntos con cierta caracteristica'''
resultado = []
for p in self:
if p.__getattribute__(nomCaracteristica) == valor:
resultado.append(p)
return resultado
def selector(self, problema):
'''Seleccionamos para cruce'''
return self.__class__._selector(self, problema)
def cruzador(self, padre, madre, problema):
'''Cruzamos dos puntos'''
return self.__class__._cruzador(padre, madre, problema)
def seleccionador(self, subpoblacion, problema):
'''Seleccionamos de la población y quitamos los que no sirvan'''
return self.__class__._seleccionador(self, subpoblacion, problema)
def union(self, pop):
for p in pop:
self.append(p)
def borrar(self, conjunto):
for p in conjunto:
if p in self:
self.remove(p)
def fast_non_dominated_sort(self, problema):
'''Seguimos el algoritmo descrito en "A fast and elitist multiobjective GA: NSGA-II"'''
#TODO: Este procedimiento se puede mejorar no teniendo que calcular el rango de toda la población
frentes = [[]]
for p in self:
p.Sp, p.np = [], 0
for q in self:
dominio = problema.dominadoC(p, q)
if dominio == 1: # p domina a q
p.Sp.append(q)
elif dominio == -1: # q domina a p
p.np += 1
if p.np == 0:
p.rgo = 1
frentes[0].append(p)
i = 0
while True:
siguienteFrente = []
for p in frentes[i]:
for q in p.Sp:
q.np -= 1
if q.np == 0:
q.rgo = i + 2
siguienteFrente.append(q)
if siguienteFrente == []:
break
frentes.append(siguienteFrente[:])
i += 1
def __contains__(self, item):
for p in self:
if p is item:
return True
return False
def test_dar_estadiciticas_dos_numeros_y_minimo(self):
self.assertEqual(Estadisticas().dar_estadisticas("3,5")[0], 2, "Dos")
self.assertEqual(Estadisticas().dar_estadisticas("3,5")[1], 3,
"Minimo")
def test_estadisticas_it1_dosnumeros(self):
self.assertEqual(Estadisticas().estadisticas("1,2"), [2],
"Dos numeros")
def test_dar_estadiciticas_string_vacio_minimo_maximo(self):
self.assertEqual(Estadisticas().dar_estadisticas("")[0], 0,
"String vacio")
self.assertEqual(Estadisticas().dar_estadisticas("")[1], 0, "Minimo")
self.assertEqual(Estadisticas().dar_estadisticas("")[2], 0, "Maximo")
def test_estadisticas_it1_multiplesnumeros(self):
self.assertEqual(Estadisticas().estadisticas("4,3,2,1"), [4],
"Multiples numeros")
def test_dar_estadiciticas_dos_numeros_maximo(self):
self.assertEqual(Estadisticas().dar_estadisticas("1,5")[2], 5,
"Maximo")
self.assertEqual(Estadisticas().dar_estadisticas("2,6")[2], 6,
"Maximo")
def test_estadisticas_it2_dosnumeros(self):
self.assertEqual(Estadisticas().estadisticas_it2("1,2"), [2, 1],
"iteracion 2: dos numeros")
def test_dar_estadiciticas_string_vacio_promedio(self):
self.assertEqual(Estadisticas().dar_estadisticas("")[3], 0,
"String vacio")
def test_estadisticas_it3_dosnumeros(self):
self.assertEqual(Estadisticas().estadisticas_it3("1,2"), [2, 1, 2],
"iteracion 3: dos numeros")
def test_dar_estadiciticas_dos_numeros_promedio(self):
self.assertEqual(Estadisticas().dar_estadisticas("2,4")[3], 3,
"Promedio")
self.assertEqual(Estadisticas().dar_estadisticas("3,6")[3], 4.5,
"Promedio")
def test_estadisticas_it3_multiplesnumeros(self):
self.assertEqual(Estadisticas().estadisticas_it3("4,3,2,1"), [4, 1, 4],
"iteracion 3: multiples numeros")
def test_getRankingProfeSuspensos(self):
respuesta = Estadisticas.obtenerPorcentajeSuspensosProfesores("Sin filtro")
self.assertTrue(len(respuesta))
def test_estadisticas_it4_cadenavacia(self):
self.assertEqual(Estadisticas().estadisticas_it4(""),
[0, None, None, None], "iteracion 4: cadena vacia")
def test_getRankingClaseNotaMedia(self):
respuesta = Estadisticas.obtenerRankingNotaMediaCurso("Sin Filtro")
self.assertTrue(len(respuesta))
def test_estadisticas_it4_unnumero(self):
self.assertEqual(Estadisticas().estadisticas_it4("1"), [1, 1, 1, 1],
"iteracion 4: un numero")
def test_getRankingProfePartes(self):
respuesta = Estadisticas.obtenerRankingPartesProfe("Sin filtro")
self.assertTrue(len(respuesta))
def test_estadisticas_it1(self):
self.assertEqual(Estadisticas().estadisticas(""), [0], "cadena vacia")
def test_cadenadeDosElementos(self):
self.assertEqual(Estadisticas.getEstadisticas("6,4"), (2, 4, 6, 5),
"Cadena dos elementos")
def test_estadisticas_it4_dosnumeros(self):
self.assertEqual(Estadisticas().estadisticas_it4("1,2"),
[2, 1, 2, 1.5], "iteracion 4: dos numeros")
def test_cadenaVacia(self):
self.assertEqual(Estadisticas.getEstadisticas(""), (0, 0, 0, 0),
"Cadena vacia")
def test_estadisticas_it4_multiplesnumeros(self):
self.assertEqual(Estadisticas().estadisticas_it4("4,3,2,1"),
[4, 1, 4, 2.5], "iteracion 4: multiples numeros")
