def __add_product():
while True:
answer = input(
"Indique el tipo de producto que desea agregar (i: ingrediente, t: tamaño): "
)
#Constructing the object
nombre = str(input('Indique el nombre del producto: '))
id = str(input('Indique el codigo del producto: '))
precio = float(input('Indique el precio del producto: '))
if (answer == "I" or answer == "i"):
if (Datos.save_ingredient(Datos.Ingrediente(id, nombre,
precio)) == 1):
print(
"Ya existe un ingrediente con este identificador, por favor intente nuevamente"
)
continue
print()
elif (answer == "T" or answer == "t"):
if (Datos.save_size(Datos.Tamano(id, nombre, precio))):
print(
"Ya existe un tamaño con este identificador, por favor intente nuevamente"
)
continue
print()
else:
print("Seleccione una opción válida")
continue
print("")
input("Producto agregado, presione cualquier tecla para continuar")
break
def __delete_product():
while True:
answer = input(
"Indique el tipo de producto que desea eliminar (i: ingrediente, t: tamaño): "
)
print("")
#Set the function and the list to be shown based on the choice
if (answer == "I" or answer == "i"):
lists = Datos.ingredients_list()
func = Datos.delete_ingredient
print("Mostrando todos los ingredientes: ")
elif (answer == "T" or answer == "t"):
lists = Datos.sizes_list()
func = Datos.delete_size
print("Mostrando todos los tamaños de pizza: ")
else:
print("Seleccione una opción válida")
continue
#Print the list
__print_list(lists)
print("")
#Delete the selected object or ask again if input was wrong
id = input("Indique el Id del producto a eliminar: ")
product = __search_by_id(lists, id)
if (product != None):
func(product)
else:
print("Seleccione una opción válida")
continue
input("Producto eliminado, presione cualquier tecla para continuar: ")
break
def Crear(self, n, m):
q = None
r = None
for i in range(1, n + 1):
for j in range(1, m + 1):
nuevo = Nodo.Nod(dato.Datos("Hola", "15"))
nuevo.siguiente = None
nuevo.abajo = None
if j == 1:
nuevo.anterior = None
if self.inicio == None:
self.inicio = nuevo
q = nuevo
else:
nuevo.anterior = q
q.siguiente = nuevo
q = nuevo
if i == 1:
nuevo.arriba = None
q = nuevo
else:
nuevo.arriba = r
r.abajo = nuevo
r = r.siguiente
r = self.inicio
while r.abajo != None:
r = r.abajo
def discretiza(fileName):
dataset = d.Datos(fileName)
# Para que funcione con scikit hay que discretizar los atributos continuos
# utilizaremos KBinsDiscretizer
matrixAux = []
# iteramos la matriz por columnas excepto la columna de clases
for col, att in zip(dataset.datos.T[:-1], dataset.nominalAtributos[:-1]):
# Si el atributo es discreto no hace falta hacer nada
if att == True:
# matrixAux.append(col.tolist())
matrixAux.append(col)
else:
# hay que discretizar los valores continuos
# asignamos el mismo numero de intervalos que clases distintas
numBins = len(dataset.diccionarios[-1])
enc = KBinsDiscretizer(n_bins=numBins,
encode='ordinal',
strategy='kmeans')
# transformamos en un array de arrays (cada numero dentro de una lista individual)
colReshaped = col.reshape(-1, 1)
colBinned = enc.fit_transform(colReshaped)
# matrixAux.append(colBinned.ravel().tolist())
matrixAux.append(colBinned.ravel())
# ahora la matriz esta traspuesta y debemos devolverla y anadir las clases
matrixAux.append(dataset.datos.T[-1:].ravel())
matrixAux = np.array(matrixAux)
matrixAux = matrixAux.T
return matrixAux
def pruebaGenetica(dicc,
porcentajes,
tamsPob,
gens,
maxReglas,
pElitismo,
pCruce,
repeticiones,
outFile=None):
# if outFile is None:
# f = open('results.txt', "w")
# else: f = open(outFile, "w")
cont = 0
total = len(dicc) * len(porcentajes) * len(tamsPob) * len(gens) * len(
maxReglas) * len(pElitismo) * len(pCruce) * repeticiones
result_matrix = []
for fileName in dicc:
dataset = d.Datos(dicc[fileName])
for prcnt in porcentajes:
for tam in tamsPob:
for epoca in gens:
for reg in maxReglas:
for pe in pElitismo:
for pc in pCruce:
errors = []
mejoresCr = []
numGens = []
avgFitness = []
gen = cl.ClasificadorGenetico(tamPoblacion=tam,
nEpocas=epoca,
pCruce=pc,
pElit=pe,
maxReglas=reg,
usePrior=True)
for i in range(repeticiones):
cont += 1
print("Iteracion ", cont, "/", total)
estrategia = ep.ValidacionSimple(prcnt)
errors.append(
gen.validacion(estrategia, dataset,
gen))
mejoresCr.append([
list(gen.poblacion[-1][0].reglas),
gen.poblacion[-1][1]
])
numGens.append(gen.currentGen)
avgFitness.append(gen.avgFitness)
errorsnp = np.array(errors)
numGensnp = np.array(numGens)
avgFitnessnp = np.array(avgFitness)
mean, std = np.mean(errors), np.std(errors)
fitMean = np.mean(avgFitnessnp)
gensMean = np.mean(numGensnp)
def __view_products():
while True:
answer = input(
"Indique el tipo de producto que desea consultar (i: ingrediente, t: tamaño): "
)
print("")
if (answer == "I" or answer == "i"):
lists = Datos.ingredients_list()
print("Mostrando todos los ingredientes: ")
elif (answer == "T" or answer == "t"):
lists = Datos.sizes_list()
print("Mostrando todos los tamaños de pizza: ")
else:
print("Seleccione una opcion valida")
continue
__print_list(lists)
print("")
input("Presione cualquier tecla para volver")
break
def view_size_pizza():
valid = False
print('Tamaños disponibles:')
listSizePizza = Datos.sizes_list()
__printList(listSizePizza)
while valid == False:
size = input('Seleccione un tamaño: ')
valid = validation(size, listSizePizza)
objectSize = __searchById(listSizePizza, size)
if valid == False:
print('Seleccione un tamaño correcto')
return objectSize
def __pizzaList():
#Pizza 1
pizza1 = Clases.Pizza(1)
pizza1.ingredientes.append(Datos.ingredientsList()[0])
pizza1.ingredientes.append(Datos.ingredientsList()[1])
pizza1.ingredientes.append(Datos.ingredientsList()[2])
pizza1.ingredientes.append(Datos.ingredientsList()[0])
pizza1.tamano = Datos.sizesList()[0]
#Pizza 2
pizza2 = Clases.Pizza(2)
pizza2.ingredientes.append(Datos.ingredientsList()[1])
pizza2.ingredientes.append(Datos.ingredientsList()[2])
pizza2.tamano = Datos.sizesList()[0]
list = []
list.append(pizza1)
list.append(pizza2)
return list
def view_ingredients_pizza():
terminar = False
valid = False
ingredientes = []
print('Ingredientes disponibles:')
listIngredientsPizza = Datos.ingredients_list()
__printList(listIngredientsPizza)
while terminar == False:
ingredient = input('Seleccione un ingrediente (enter para terminar): ')
if ingredient == "":
terminar = True
else:
valid = validation(ingredient, listIngredientsPizza)
objectIngredient = __searchById(listIngredientsPizza, ingredient)
if valid == False:
print('Seleccione un ingrediente correcto')
else:
ingredientes.append(objectIngredient)
return ingredientes
import numpy as np
import random
from plotModel import *
from Datos import *
from sklearn import tree
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.model_selection import StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
import matplotlib
from scipy import stats
try:
dataset = Datos("Datasets/wdbc.data")
X = dataset.getDatos()[:, :-1] # Todos los atributos menos la clase
y = dataset.getDatos()[:, -1] # Todas las clases
k_folds = 10
skf = StratifiedKFold(n_splits=k_folds)
score_tree = []
score_0 = []
score_1 = []
score_both = []
score_random = []
clfTree = tree.DecisionTreeClassifier()
except:
pass
# **** ENVIO DE MENSAJE PARA NOTIFICAR AL ADMINISTRADOR DE UN REINICIO DEL SISTEMA ****
if FLAG_estacion_online == True and config.ADMIN_USER != None:
try:
send_message('Estacion Reiniciada\n' + nombreScriptEjecucion,
ADMIN_USER)
except:
pass
''' Cargar datos desde backup si los hubiese para continuar un experimento en curso '''
try:
#carga de la lista que continene los datos acumuados (grafica completa)
file_datos_experimento = config.ruta_programa + config.RUTA_BACKUP + config.FICHERO_DATOS_EXPERIMENTO
estado_carga, lista_Datos_Experimento_Bio = Datos.cargar_datos_desde_fichero(
file_datos_experimento)
if estado_carga == False:
lista_Datos_Experimento_Bio = []
print("lista_Datos_Experimento_Bio[] no pudo ser restaurada")
print("buscando copia de seguridad...")
longitud_extension = len(file_datos_experimento.split(".")[-1])
nombre_con_ruta_backup = file_datos_experimento[:
-longitud_extension] + "bak"
estado_carga, lista_Datos_Experimento_Bio = Datos.cargar_datos_desde_fichero(
nombre_con_ruta_backup)
if (estado_carga == False):
print(
"ERROR CARGANDO DATOS, se reinicia la toma de datos desde cero"
)
if (estado_carga == True):
import Funciones as fn
import Datos
import visualizaciones_lab2 as vl
data = Datos.read_file("Account_historyAlberto.xlsx")
data = fn.f_columnas_tiempos(data)
data = fn.f_columnas_pips(data)
data = fn.cumulative_capital(data) #creación de columna capital_acm y pips_acm
estadisticas_ba = fn.f_estadisticas_ba(
data) #creación de ranking y estadísticas básicas
profit = fn.f_profit_diario(data) # profit diario
estadisticas_ma = fn.f_estadisticas_mad(
data) #medidas de atribucion al desempeño
sesgo = fn.f_be_de(data) # informacion de disposition effect
sesgo = fn.f_be_de(data)
vl.raking_chart(data) #grafica de ranking
vl.evolution_chart(data) # grafica de evolucion de capital
vl.effect_chart(data) # grafia de disposition effect
indiceAttr = random.randint(0, len(individuo[indiceRegla]) - 1)
indiceBit = random.randint(0,
len(individuo[indiceRegla][indiceAttr]) - 1)
if individuo[indiceRegla][indiceAttr][indiceBit] == 1:
individuo[indiceRegla][indiceAttr][indiceBit] = 0
else:
individuo[indiceRegla][indiceAttr][indiceBit] = 1
return individuo
def mutarPoblacion(self, poblacionCruzada, fitness):
poblacionMutada = []
for i in range(
0,
math.ceil(len(poblacionCruzada) * self.probabilidad_mutacion)):
individuo, indiceIndividuo = self.casinoRoulette007(
fitness, poblacionCruzada, False)
individuoMutado = self.mutarIndividuo(individuo)
poblacionCruzada[indiceIndividuo] = individuoMutado
poblacionMutada = poblacionCruzada
return poblacionMutada
if __name__ == '__main__':
genetico = AlgoritmoGenetico(flagGrafica=True)
dataset = Datos.Datos('titanic.data', esGenetico=True)
validacionCruzada = EstrategiaParticionado.ValidacionSimple(0.6, 1)
particiones = validacionCruzada.creaParticiones(dataset.datos)
mean = genetico.validacion(validacionCruzada, dataset, seed=None)
print("media:", mean)
import Datos as dt
import Modelo as md
URLdatos = 'URL/donde/estan/los/datos'
carpetas = ['carpeta 1', 'carpeta 2', '...', 'carpeta N']
numero_clases = len(carpetas)
optimizador = 'RMSprop'
loss = 'categorical_crossentropy'
metrics = 'accuracy'
epochs = 10
batch_size = 32
URLguardado = 'URL/donde/se/guarda/el/modelo'
datos_entrenamiento, datos_prueba = dt.cargar_datos(URLdatos, carpetas)
target_entrenamiento, target_prueba = dt.generar_target(carpetas)
datos_entrenamiento, target_entrenamiento, datos_prueba, target_prueba = procesar_datos(
datos_entrenamiento, target_entrenamiento, datos_prueba, target_prueba)
modelo = md.iniciar_modelo()
modelo = definir_modelo(modelo)
modelo = definir_modelo(modelo, num_classes)
modelo = compilar_modelo(optimizador, loss, metrics, model)
modelo = fit_model(modelo, datos_entrenamiento, target_entrenamiento, epochs,
batch_size, datos_prueba, target_prueba, URLguardado)
def process():
global dataset
global name_clases
global modelo
parametros = []
contenido = request.form
diccionarioContenido = contenido.copy()
print(diccionarioContenido)
for i in range(len(diccionarioContenido)):
parametros.append(diccionarioContenido[str(i)])
print(parametros)
#parametros=['conv2d,32,same,relu', 'conv2d,32,same,relu', 'maxpooling2d,2,2', 'dropout,0.25', 'conv2d,64,same,relu', 'conv2d,64,same,relu', 'maxpooling2d,2,2', 'dropout,0.25', 'conv2d,64,same,relu', 'conv2d,64,same,relu', 'maxpooling2d,2,2', 'dropout,0.25', 'flatten', 'dropout,0.5', 'rmsprop', 'categorical_crossentropy', 'accuracy','5', '5']
dataset = parametros.pop()
epocs = parametros.pop()
batch_size = parametros.pop()
metrics = parametros.pop()
loss = parametros.pop()
optimizer = parametros.pop()
#dataTraining, dataTrainingLabels=lpi.dataTraining()
#dataTest, dataTestLabels=lpi.dataTest()
#numClases=lpi.numeroClases(dataTrainingLabels)
#train_data, train_data_labels, test_data, test_data_labels, input_shape = lpi.dataReshape(dataTraining, dataTest, dataTrainingLabels , dataTestLabels)
dataTraining, dataTrainingLabels, dataTest, dataTestLabels = lpi.cargarDatos(
dataset)
numClases, name_clases = lpi.numeroClases(dataset)
train_data, train_data_labels, test_data, test_data_labels, input_shape = lpi.procesarDatos(
dataset, dataTraining, dataTrainingLabels, dataTest, dataTestLabels,
numClases)
modelo = pk.iniciarModelo()
modelo = pk.generarModelo(parametros, modelo, numClases, input_shape)
modelo = pk.compilarModelo(optimizer, loss, metrics, modelo)
modelo, history = pk.fitModel(modelo, train_data, train_data_labels, epocs,
batch_size, test_data, test_data_labels)
pk.plotModel(modelo)
loss, metricsD = pk.evaluateModel(modelo, test_data, test_data_labels)
scnn_pred, scnn_predicted = cr.scnn(modelo, test_data)
fpr, tpr, roc_auc = cr.generarDicts(numClases, test_data_labels, scnn_pred)
fprMicro, tprMicro, rocMicro = cr.compuMicro(fpr, tpr, roc_auc,
test_data_labels, scnn_pred)
all_fpr, mean_tpr = cr.generarAllMean(fpr, tpr, numClases)
rocMacro, fprMacro, tprMacro = cr.generarMacro(all_fpr, mean_tpr, fpr, tpr,
roc_auc)
fprMicro, tprMicro, fprMacro, tprMacro = cr.convertirLista(
fprMicro, tprMicro, fprMacro, tprMacro)
met, metri = cr.definirMetrica(metrics)
acc, val_acc, lossD, val_loss = cr.valoresLossMetrics(history, met, metri)
print(acc)
print(val_acc)
print(lossD)
print(val_loss)
if (contenido):
parametros = []
return jsonify({
'loss': loss,
'metric': metricsD,
'fprMicro': fprMicro,
'tprMicro': tprMicro,
'fprMacro': fprMacro,
'tprMacro': tprMacro,
'acc': acc,
'val_acc': val_acc,
'lossD': lossD,
'val_loss': val_loss
})
else:
parametros = []
return jsonify({'error': 'Los términos no arrojaron resultados!'})
def __init__(self, titulo, hoja):
self.ex = Datos.excel(titulo, hoja)
self.actas = []
def f_estadisticas_mad(param_data):
"""
Parameters
----------
param_data
Returns
-------
metrics
"""
profit_data = f_profit_diario(param_data)
rf = .08/300 # converisón de tasa libre de riesgo a términos diarios
rendimiento_log = lambda x : np.log(x/x.shift(1))[1:] # función para obtener rendimientos logarítmicos
rp = rendimiento_log(profit_data["profit_acm_d"]) # cálculo de rendimientos diarios
sigma = np.std(rp) # volatildiad
rp = np.mean(rp) # rendimiento diario promedio
sharpe = (rp - rf) / sigma # cálculo de radio de sharpe
sell = param_data.loc[param_data["type"] == 'sell'] # filtrado por tipo de operación
buy = param_data.loc[param_data["type"] == 'buy']
sell = sell.reset_index(drop=True) # creación de nuevo índice para errores
buy = buy.reset_index(drop=True)
profit_sell = f_profit_diario(sell) # cálculo de profit para operaciones de venta
profit_buy = f_profit_diario(buy) # cálculo de profit para operaciones de compra
MAR = 0.30 / 300 # conversión de tasa MAR a términos diarios
sortino_rate = lambda RP, MAR, TDD: (RP - MAR) / TDD # función para cálculo de sortino rate
rp_buy = rendimiento_log(profit_buy["profit_acm_d"])
rp_sell = rendimiento_log(profit_sell["profit_acm_d"])
TDD_buy = list(i for i in rp_buy if i < MAR) # selección de rendimientos inferiores a la MAR
TDD_buy = np.std(TDD_buy)
rp_buy = np.mean(rp_buy)
sortino_buy = sortino_rate(rp_buy, MAR, TDD_buy)
TDD_sell = list(i for i in rp_sell if i < MAR)
TDD_sell = np.std(TDD_sell)
rp_sell = np.mean(rp_sell)
sortino_sell = sortino_rate(rp_sell, MAR, TDD_sell)
param_data["Máximo profit acumulado movil"] = param_data["capital_acm"].cummax() # maximo capital acumulado en cada momento de tiempo
param_data["drawdown"] = param_data["Máximo profit acumulado movil"] - param_data["capital_acm"]
max_drawdown =param_data["drawdown"].max()
fecha_final = np.argmax(param_data["drawdown"]) # me regresa el índice de la minusvalía máxima
fecha_inicial = param_data["closetime"][:fecha_final]
fecha_final = param_data["closetime"][fecha_final]
#obtención de datos del s&p500
fecha_inicial = pd.to_datetime(profit_data["closetime"].min()).tz_localize('GMT')
fecha_inicial = fecha_inicial + timedelta(days=1) # manipulación de fecha de inicio para obtener datos correctos
fecha_final = pd.to_datetime(profit_data["closetime"].max()).tz_localize('GMT')
fecha_final = fecha_final + timedelta(days=2) # manipulación de fecha de fin para obtener datos correctos
sp500 = Datos.f_precios_masivos(fecha_inicial, fecha_final, 'D', 'SPX500_USD', Datos.token, 4900)
sp500_closes = pd.DataFrame(float(i) for i in sp500["Close"])
profit_data["weekday"]='-'
for i in range(len(profit_data)):
date = profit_data["closetime"][i]
date =pd.to_datetime(date)
profit_data["weekday"][i]=date.weekday() # obtenemos número de día al que corresponde el dia de
# cierre de la operación
profit_data = profit_data.loc[profit_data["weekday"]!=5] # quita rendimientos de los domingos
profit_data = profit_data.reset_index(drop=True)
if len(profit_data)==len(sp500_closes): # validación de mismas dimensiones de los datos
tracking_error = profit_data["profit_acm_d"]-sp500_closes[0]
else :
tracking_error = 0
tracking_error = np.std(tracking_error)
information_ratio =(np.mean(profit_data["profit_acm_d"])-np.mean(sp500_closes))/tracking_error
metrics = {'Sharpe ratio': sharpe,
'Sortino compra': sortino_buy,
'Sortino venta': sortino_sell,
'Information ratio': float(information_ratio),
'Drawdown': [fecha_inicial,fecha_final,max_drawdown]
} # diccionario de salida
return metrics
self.w -= (self.kAprend * (sigma - fila[-1].astype(float)) * current)
def clasifica(self, datostest, atributosDiscretos, diccionario):
probabilidades = np.zeros(len(datostest))
prediccion = np.zeros(len(datostest))
# Para cada registro del dataset de clasificacion
for indice_fila, fila in enumerate(datostest):
probabilidades[indice_fila] = self.sigmoidal(fila[:-1])
prediccion[probabilidades >= 0.5] = 1.0
return prediccion
if __name__ == '__main__':
errores = []
dataset = Datos.Datos('ConjuntosDatosP2/pima-indians-diabetes.data')
clasi = ClasificadorVecinosProximos(K = 11, distancia = "Mahalanobis", normalizado = True)
clasi.entrenamiento(dataset.datos, dataset.nominalAtributos, dataset.diccionario)
pred = clasi.clasifica(dataset.datos, dataset.nominalAtributos, dataset.diccionario)
errores.append(clasi.error(dataset.datos, pred))
print(errores)
#dataset = Datos.Datos('tic-tac-toe.data')
#clasi = ClasificadorRegresionLogistica(0.1, 100, None)
#clasi.entrenamiento(dataset.datos, dataset.nominalAtributos, dataset.diccionario)
#pred = clasi.clasifica(dataset.datos, dataset.nominalAtributos, dataset.diccionario)
#ValidacionSimple = EstrategiaParticionado.ValidacionSimple(0.6, 3)
#particiones = ValidacionSimple.creaParticiones(dataset.datos)
#media_errores, std_errores = clasi.validacion(ValidacionSimple, dataset, clasi, seed=None)
#print(media_errores)
from os import system, name #Nos permitirá limpiar la pantalla en un futuro
from Calculo import * #Importamos nuestra clase Calculo
from Datos import * #Importamos el módulo Datos
#Función para limpiar la pantalla
def limpiar():
"""Limpia la pantalla de la terminal"""
if name == 'nt': #Evalúa si se encuentra en un sistema operativo Windows
_ = system('cls')
else: #Si se encuentra en Mac o Linux
_ = system('clear')
#Declaración de variables
nombre, dui, dui_real, nit, nit_real, salario, tiempo = Datos()
limpiar() #Nos permite limpiar la terminal. Se utiliza para presentar de manera ordenada los datos.
#Instancia de clase Calculo
mi_aguinaldo = Calculo(nombre,str(dui_real(dui)),str(nit_real(nit)),salario, tiempo)
mi_aguinaldo.calcular() #Calcula el aguinaldo
mi_aguinaldo.imprimir() #Imprime los resultados
#Si se abre desde el ejecutable, evita que se cierre sin haber mostrado resultados
input("\n\n\nFIN DE LA EJECUCION -- Presione cualquier tecla para salir")