def __funcion_analizar():
g.errores_lexicos.clear()
g.errores_sintacticos.clear()
principal.consola = ""
principal.listaSemanticos.clear()
entrada = my_editor.text.get('1.0', END)
arbol = g.parse(entrada)
if len(g.errores_lexicos) == 0:
if len(g.errores_sintacticos) == 0:
imprimir_consola("")
data = principal.interpretar_sentencias(arbol, tablaSimbolos)
#tablaSimbolos.mostrar()
imprimir_consola(data)
#append_consola(tablaSimbolos.mostrar_tabla())
raiz = graficando.analizador(entrada)
graficando.GraficarAST(raiz)
graficando.ReporteGramatical()
else:
imprimir_consola('Se detectaron algunos errores sintácticos')
append_consola('')
append_consola(
'No. \t Lexema \t Tipo \t\t Fila \t Columna \t Descripción '
)
i = 0
while i < len(g.errores_sintacticos):
append_consola(
str(i) + ' \t ' +
str(g.errores_sintacticos[i].lexema) + ' \t ' +
str(g.errores_sintacticos[i].tipo) + ' \t ' +
str(g.errores_sintacticos[i].fila) + ' \t ' +
str(g.errores_sintacticos[i].columna) + ' \t ' +
str(g.errores_sintacticos[i].descripcion) + ' ')
i += 1
else:
imprimir_consola('Se detectaron algunos errores léxicos')
append_consola('')
append_consola(
'No. \t Lexema \t Tipo \t\t Fila \t Columna \t Descripción ')
i = 0
while i < len(g.errores_lexicos):
append_consola(
str(i) + ' \t ' + str(g.errores_lexicos[i].lexema) +
' \t ' + str(g.errores_lexicos[i].tipo) + ' \t ' +
str(g.errores_lexicos[i].fila) + ' \t ' +
str(g.errores_lexicos[i].columna) + ' \t ' +
str(g.errores_lexicos[i].descripcion) + ' ')
i += 1
def expectation_maximization(data, cant_clusters, iteraciones):
puntos = abrir_archivo_array(data)
"""
Inicializacion
1. eleccion aleatoria de los puntos iniciales
"""
inicial = random.sample(puntos, cant_clusters)
#cant_clusters iniciales, generacion de kpi y demas
clusters = [Cluster([p], len(inicial)) for p in inicial]
#Crear una lista para guardar los puntos que vayan actualizando (inicial lista vacia)
puntos_actualizados = [[] for i in range(cant_clusters)]
converge = False
limite_iteraciones = 0
#While (los gaussianos se mueven o cambian de forma, o se alcanza el limite de iteraciones):
while (not converge) and (limite_iteraciones <= iteraciones):
for p in puntos:
#paso e
i_cluster = cluster_prob_mayor(clusters, p) #mayor probabilidad
puntos_actualizados[i_cluster].append(p)
# paso m
for i, c in enumerate(clusters):
c.actualizar(puntos_actualizados[i], len(puntos))
#ver por probabilidad si converge
converge = [c.converge for c in clusters].count(False) == 0
#guardar puntos en clusters
limite_iteraciones += 1
puntos_actualizados = [[] for i in range(cant_clusters)]
print '\nIteracion %d' % limite_iteraciones
for i, c in enumerate(clusters):
#print 'Cluster %d: \n \tProbabilidad = %s; \n \tMedia = %s; \n \tDesv. Estandar = %s; \n \tTotal Puntos Actuales = %s' % (
#i + 1, str(c.pi), str(c.mean), str(c.desv_estandar), str(len(c.puntos)))
x1, y1 = gr.generateGrid(10, -10, 10, -10, 0.025)
gr.drawContour(
x1,
y1, [c.mean[0], c.mean[1]],
[[c.desv_estandar[0], 0.2], [0.2, c.desv_estandar[1]]],
10,
color=lista_contour[i])
gr.pintar_puntos(clusters, cant_clusters)
print "+----------------------------------------------------+"
print " Punto perteneciente a un cluster"
print "+----------------------------------------------------+ \n"
x = float(input(" -> Coordenada x del punto: "))
y = float(input(" -> Coordenada y del punto: "))
distanciasrutas.append(particula.distanciaruta)
# Anadimos la particula al enjambre
enjambre.append(particula)
# Sacamos el indice del enjambre correspondiente a la particula
# con menor distancia de ruta del enjambre inicial
indicemejorparticula_ini = numpy.argmin(distanciasrutas)
logbook.write("Mejor distancia inicial: " +
str(enjambre[indicemejorparticula_ini].distanciaruta))
logbook.write("\n")
logbook.write("\n")
logbook.write("\n")
p1 = enjambre[indicemejorparticula_ini]
figura = Graficar.crear_figura()
segmentos = Graficar.crear_lista_segmentos(
enjambre[indicemejorparticula_ini].ruta)
grafo_0 = Graficar.crear_grafo(Citys["Lat"], Citys["Long"])
# Anadimos la ruta
segmentos = Graficar.crear_lista_segmentos(
enjambre[indicemejorparticula_ini].ruta)
grafo = Graficar.anadir_ruta(grafo_0, segmentos)
Graficar.dibujar(figura, grafo)
for i in range(len(p1.ruta)):
print(str(i) + Citys["Nombres"][p1.ruta[i]])
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def ZERG(figura, archivodatos, tamano, itermax, numvecinos, operador_cross,
operador_mut):
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# DATOS INICIALES
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Variables vacias iniciales
enjambre = [] # Lista de todas las particulas
distanciasrutas = [] # Lista de las distancias para cada particula
indices = list(range(tamano)) # Indices del 0 al tamano del enjambre
# Logfile para la ejecucion
nombrelogfile = os.path.splitext(archivodatos)[0] + datetime.datetime.now(
).strftime('_%H_%M_%S_%d_%m_%Y.log')
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# DATOS DEL PROBLEMA
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if operador_cross == 1:
if operador_mut == 0:
configuracion = "/Config1/"
elif operador_mut == 1:
configuracion = "/Config2/"
elif operador_mut == 2:
configuracion = "/Config3/"
elif operador_cross == 2:
if operador_mut == 0:
configuracion = "/Config4/"
elif operador_mut == 1:
configuracion = "/Config5/"
elif operador_mut == 2:
configuracion = "/Config6/"
elif operador_cross == 3:
if operador_mut == 0:
configuracion = "/Config7/"
elif operador_mut == 1:
configuracion = "/Config8/"
elif operador_mut == 2:
configuracion = "/Config9/"
else:
if operador_mut == 0:
configuracion = "/Config1/"
elif operador_mut == 1:
configuracion = "/Config2/"
elif operador_mut == 2:
configuracion = "/Config3/"
#Lectura de datos
# Citys
# "Lat" - Latitud de cada ciudad
# "Long" - Longitud de cada ciudad
# "Nombres" - Nombres de cada punto. Pueden ser nombres propios o numeros simplemente
Citys = FuncionesInicializar.leer_datos(archivodatos)
#Calculo de distancias
Distancias = FuncionesInicializar.calcular_distancias(
Citys["Lat"], Citys["Long"])
with open(
"./logs/" + os.path.splitext(archivodatos)[0] + configuracion +
nombrelogfile, "a") as logbook:
funcionesLog.iniciar(logbook, operador_cross, operador_mut, tamano,
itermax, len(Citys["Lat"]))
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# CREACION DEL ENJAMBRE
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Vamos a generar todas las particulas iniciales
for i in range(tamano):
# Vecinos para cada particula con los que realizará crossovers
indicesvecinos = random.sample(indices, numvecinos)
# Generamos particulas iniciales
particula = GenParticula.crear_particula(indicesvecinos,
Distancias)
# Guardamos la distancia de la ruta de cada particula
distanciasrutas.append(particula.distanciaruta)
# Anadimos la particula al enjambre
enjambre.append(particula)
# Sacamos el indice del enjambre correspondiente a la particula
# con menor distancia de ruta del enjambre inicial
indicemejorparticula_ini = numpy.argmin(distanciasrutas)
logbook.write("Mejor distancia inicial: " +
str(enjambre[indicemejorparticula_ini].distanciaruta))
logbook.write("\n")
logbook.write("\n")
logbook.write("\n")
# Graficamos la ruta inicial
# etiquetas = Graficar.crear_etiquetas(Citys["Nombres"])
#figura = Graficar.crear_figura()
#figura.clear()
grafo_0 = Graficar.crear_grafo(Citys["Lat"], Citys["Long"])
# Anadimos la ruta
segmentos = Graficar.crear_lista_segmentos(
enjambre[indicemejorparticula_ini].ruta)
grafo = Graficar.anadir_ruta(grafo_0, segmentos)
Graficar.dibujar(figura, grafo_0)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# EVOLUCION DEL ENJAMBRE
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
contadorestancamiento = 0
idxbestold = -1
tiempoini = time.time()
# Empezamos el bucle de evolucion que nos dara la solucion al finalizar
for i in range(itermax):
print("Iteracion " + str(i))
# Iteramos a lo largo del enjambre
for j in range(len(indices)):
# print(j)
# Sacamos la particula
particulaoriginal = enjambre[j]
# Caculamos la nueva ruta resultado de curzar y mutar
nuevaruta = Evolucion.gen_nueva_ruta(enjambre,
particulaoriginal,
operador_cross,
operador_mut)
# Si la nueva particula es mejor que la original, la reemplazará
# En caso contrario la particula original se mantendrá
nuevaparticula = GenParticula.GenParticula(
nuevaruta, Distancias, particulaoriginal.vecinos)
if nuevaparticula.distanciaruta < particulaoriginal.distanciaruta:
enjambre[j] = nuevaparticula
distanciasrutas[j] = nuevaparticula.distanciaruta
# Sacamos la mejor distancia de la iteracion
idxbest = numpy.argmin(distanciasrutas)
logbook.write(str(i) + "--" + str(enjambre[idxbest].distanciaruta))
logbook.write("\n")
# Si recibimos misma ruta optima durante más de el 15% de iteraciones - BREAK
if idxbest == idxbestold:
contadorestancamiento += 1
if contadorestancamiento >= round((0.15 * itermax)):
print("Busqueda estancada.")
logbook.write("FINAL DE BUSQUEDA POR ESTANCAMIENTO")
logbook.write("\n")
break
else:
segmentos = Graficar.crear_lista_segmentos(
enjambre[idxbest].ruta)
grafo = Graficar.anadir_ruta(grafo_0, segmentos)
Graficar.dibujar(figura, grafo)
contadorestancamiento = 0
idxbestold = idxbest
tiempofin = time.time()
# Calculamos el tiempo de ejecucion redondeando a milisegundos
tiempocalculo = round(tiempofin - tiempoini, 3)
logbook.write("\n")
logbook.write("El tiempo de búsuqeda ha sido de " +
str(tiempocalculo) + " segundos.")
logbook.write("\n")
logbook.write("\n")
resultado = enjambre[idxbest]
# Resultado final
logbook.write("\n")
logbook.write("El mejor resultado final es:")
logbook.write("\n")
logbook.write("\n")
logbook.write("Distancia: " + str(resultado.distanciaruta))
logbook.write("\n")
logbook.write("\n")
logbook.write("NumVecinos: " + str(numvecinos))
logbook.write("\n")
logbook.write("\n")
logbook.write("Indices de ruta: " + str(resultado.ruta))
logbook.write("\n")
logbook.write("\n")
logbook.write("La ruta a seguir es:")
logbook.write("\n")
contadorbreakline = 0
for i in range(len(resultado.ruta) - 1):
logbook.write(Citys["Nombres"][resultado.ruta[i]] + "==>")
contadorbreakline += 1
# Cada 8 ciudades apuntadas, pasamos a nueva linea
if contadorbreakline == 8:
logbook.write("\n")
contadorbreakline = 0
logbook.write(Citys["Nombres"][resultado.ruta[-1]] + "==>" +
Citys["Nombres"][resultado.ruta[0]])
logbook.write("\n")
logbook.write("\n")
logbook.write("------FINAL DEL EXPERIMENTO------")
logbook.close()
Graficar.guardar_figura(figura, configuracion,
os.path.splitext(archivodatos)[0],
os.path.splitext(nombrelogfile)[0])
return
def __funcion_AST():
entrada = my_editor.text.get('1.0', END)
raiz = graficando.analizador(entrada)
graficando.GraficarAST(raiz)
graficando.ReporteGramatical()
os.startfile('arbol.jpg')
print(string_evol_vict_formateado)
string_evol_vict_formateado += "\n"
evolucion_victorias_formateado.append(string_evol_vict_formateado)
# Imprimr los resultados de la evolución de victorias de la AI
print("Evolución de empates")
for i in range(len(evolucion_empates)):
string_evol_emp_formateado = "AI: {empatadas} / 10 => {porcentaje}%".format(
empatadas=evolucion_empates[i],
porcentaje=evolucion_empates[i] / 10 * 100)
print(string_evol_emp_formateado)
string_evol_emp_formateado += "\n"
evolucion_empates_formateado.append(string_evol_emp_formateado)
string_evol_vict_formateado = "La AI ganó el {porcentaje}% de las veces".format(
porcentaje=victorias / num_partidas * 100)
string_evol_emp_formateado = "La AI empató el {porcentaje}% de las veces".format(
porcentaje=empates / num_partidas * 100)
print(string_evol_vict_formateado)
print(string_evol_emp_formateado)
string_evol_vict_formateado += "\n"
string_evol_emp_formateado += "\n"
evolucion_victorias_formateado.append(string_evol_vict_formateado)
evolucion_empates_formateado.append(string_evol_emp_formateado)
jugador1.grabar_datos_en_disco(evolucion_victorias_formateado,
directorio + "/" + "resumen_winrate.txt")
jugador1.grabar_datos_en_disco(evolucion_empates_formateado,
directorio + "/" + "resumen_tierate.txt")
# Realizar las gráficas del winrate
Graficar.graficar_winrate(directorio, evolucion_victorias)
################################ Solve #####################################
ampl.solve()
############################# Variables ############################
produccion = ampl.getVariable('P').getValues().toPandas()
produccion_df = Generar_Dataframe.Anexo_tiempo(produccion['P.val'],
simulacion, produccion_df)
Generar_Dataframe.Indexar(produccion_df, 'produccion')
inventario = ampl.getVariable('W').getValues().toPandas()
inventario_df = Generar_Dataframe.Anexo_tiempo_tiempo(
inventario['W.val'], simulacion, inventario_df)
Generar_Dataframe.Indexar(inventario_df, 'inventario')
############################ Funcion Objetivo #######################
fo = ampl.getObjective('FO').value()
funcion_objetivo.append((fo, simulacion + 1))
#print(funcion_objetivo)
#print(hold_df)
#print(produccion_df,inventario_df)
Prod_Cuarto, Prod_Entero, Prod_Medio, Prod_Octavo, Prod_Cuarto_t, Prod_Entero_t, Prod_Medio_t, Prod_Octavo_t = Variables.prod(
produccion_df)
#Graficar.funcion_objetivo(funcion_objetivo,rango)
#Graficar.funcion_objetivo_hold(funcion_objetivo,hold_df,rango)
#print(Prod_Cuarto)
Graficar.produccion(Prod_Cuarto, Prod_Entero, Prod_Medio, Prod_Octavo,
Prod_Cuarto_t, Prod_Entero_t, Prod_Medio_t, Prod_Octavo_t,
rango)
# -*- coding: utf-8 -*- """ Created on Mon Dec 3 19:52:43 2018 @author: igarc """ import main import Graficar # Input de datos #archivos = ["autonomicas", "mundiales","berlin52.txt","ch130.txt","ch150.txt","PoblacionesSpa.txt"] archivos = ["ch150.txt"] archivodatos = archivos[0] figura = Graficar.crear_figura() # Tamnos de enjambres tamanos = [40, 100, 250, 500] #tamano = 200 # Numero maximo de iteraciones iteraciones = [100, 200, 500, 1000] #itermax = 1000 # Numero de vecinos entre particulas numerodevecinos = [3, 5, 10] # Numero de vecinos para cada particula #numvecinos = 3 # Operadores de crossover # 1=Order1 // 2=Cycle // 3=PMX