def test():
assert len(sys.argv) == 2, "cantidad incorrecta de parametros"
parametros = {}
parametros['general'] = ['mnist']
parametros['nombre'] = ['dbn']
parametros['tipo'] = ['binaria']
parametros['capas'] = []
parametros['epocasTRN'] = [[50]]
parametros['epocasFIT'] = [100]
parametros['tambatch'] = [10]
parametros['tasaAprenTRN'] = [0.01]
parametros['tasaAprenFIT'] = [0.1]
parametros['regularizadorL1'] = [0.0]
parametros['regularizadorL2'] = [0.0]
parametros['momentoTRN'] = [0.0]
parametros['momentoFIT'] = [0.0]
parametros['pasosGibbs'] = [5]
parametros['porcentaje'] = [0.8]
parametros['toleranciaError'] = [0.0]
parametros['pcd'] = [True]
parametros['directorio'] = ['dbn_mnist']
parametros['dataset'] = [sys.argv[1]]
parametros['capas'] = [[784, 500, 100, 10]]
Grid = ParameterGrid(parametros)
parametros = Grid[0]
nombreArchivo = 'resultados_dbn_MNIST'
print(
"GUARDANDO LOS RESULTADOS EN EL ARCHIVO {}\n\n".format(nombreArchivo))
##
##
tiempo_entrenar = 0
tiempo_ajustar = 0
tiempo_total = 0
T = temporizador()
inicio = T.tic()
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaDatos = str(directorioActual) + '/cupydle/data/DB_' + str(
parametros['general']) + '/' # donde se almacenan la base de datos
print("****************************************************")
print("PARAMETROS:")
for k in sorted(parametros.keys()):
print(str("{: >20} : {: <20}").format(k, str(parametros[k])))
# creo la dbn
d = dbn_base_test(**parametros)
###########################################################################
## P R E P A R A N D O L O S D A T O S E N T R E N A M I E N T O
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'entrenamiento' y 'entrenamiento_clases'
try:
datos = np.load(rutaDatos + str(sys.argv[1]))
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + str(
sys.argv[1])
entrenamiento = datos['entrenamiento'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(np.int32)
del datos # libera memoria
datosDBN = []
datosDBN.append((entrenamiento, entrenamiento_clases))
del entrenamiento, entrenamiento_clases
## se entrena
tiempo_entrenar = d.entrenar(data=datosDBN)
del datosDBN
###########################################################################
## P R E P A R A N D O L O S D A T O S A J U S T E F I N O
###########################################################################
try:
datos = np.load(rutaDatos + str(sys.argv[1]))
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + str(
sys.argv[1])
entrenamiento = datos['entrenamiento'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(np.int32)
validacion = datos['validacion'].astype(np.float32)
validacion_clases = datos['validacion_clases'].astype(np.int32)
testeo = datos['testeo'].astype(np.float32)
testeo_clases = datos['testeo_clases'].astype(np.int32)
del datos # libera memoria
datosMLP = []
datosMLP.append((entrenamiento, entrenamiento_clases))
datosMLP.append((validacion, validacion_clases))
datosMLP.append((testeo, testeo_clases))
del entrenamiento, entrenamiento_clases, validacion, validacion_clases, testeo, testeo_clases
## se ajustan
costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar = d.ajustar(
datos=datosMLP)
del datosMLP
#
#almaceno los resultados generales
_guardar(nombreArchivo=nombreArchivo,
valor={
'parametros': parametros,
'costoTRN': costoTRN,
'costoVAL': costoVAL,
'costoTST': costoTST,
'costoTST_final': costoTST_final
})
print("\n\n")
final = T.toc()
tiempo_total = T.transcurrido(inicio, final)
print("TIEMPOS [HH:MM:SS.ss]:")
print("-> Entrenamiento: {}".format(T.transcurrido(0, tiempo_entrenar)))
print("-> Ajuste: {}".format(T.transcurrido(0, tiempo_ajustar)))
print("-> Total: {}".format(T.transcurrido(inicio, final)))
return 0
print("Prueba con tecnicas de validacion cruzada...")
print("Numero de particiones: ", folds)
print("Porcentaje entrenamiento/validacion: ", porcentaje)
errorTRN_conjunto = []
errorVAL_conjunto = []
errorTST_conjunto = []
errorTST_conjunto_h = []
###########################################################################
##
## P R E - E N T R E N A M I E N T O R B M s
##
###########################################################################
T = temporizador()
inicio_todo = T.tic()
for train_index, test_index in skf:
contador += 1
print("Particion < " + str(contador) + " >")
datos = []
cantidad = int(len(train_index) * porcentaje)
datosTRN = (videos[train_index[:cantidad]],
clases[train_index[:cantidad]])
datosVAL = (videos[train_index[cantidad:]],
clases[train_index[cantidad:]])
datosTST = (videos[test_index], clases[test_index])
def test():
assert len(sys.argv) == 2, "cantidad incorrecta de parametros"
parametros['dataset'] = [sys.argv[1]]
parametros['capas'] = [[784, 100, 10]]
#parametros['dataset'] = ["mnist_minmax.npz"]
#parametros['capas'] = [[784, 100, 10], [85, 30, 6]]
Grid = ParameterGrid(parametros)
cantidad_combinaciones = len(Grid)
cantidad_a_ejecutar = cantidad_combinaciones // 2
nombreArchivo = 'resultados_dbnMNIST_gridSearch'
print(
"GUARDANDO LOS RESULTADOS EN EL ARCHIVO {} QUE CONTIENE {} ITERACIONES\n\n"
.format(nombreArchivo, cantidad_a_ejecutar))
T = temporizador()
inicio = T.tic()
for x in range(cantidad_a_ejecutar):
T2 = temporizador()
inicio2 = T2.tic()
print("****************************************************")
print("\n\n")
print("Iteracion {} de {}".format(x, cantidad_a_ejecutar))
print("PARAMETROS:")
# modo random la eleccion de los parametros sobre el conjunto posible
indice = np.random.randint(cantidad_combinaciones)
# no tengo implementada el __setitem__ en ParameterGrid
params = Grid[indice]
params['directorio'] = 'dbn_grid_' + str(x)
for k in sorted(params.keys()):
print(str("{: >25} : {: <50}").format(k, str(params[k])))
print("\n\n")
d = dbn_base_test(**params)
##
###########################################################################
##
## P R E P A R A N D O L O S D A T O S E N T R E N A M I E N T O
##
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'videos' y 'clases'
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaDatos = str(directorioActual) + '/cupydle/data/DB_' + str(
parametros['general']
[0]) + '/' # donde se almacenan la base de datos
try:
datos = np.load(rutaDatos + str(sys.argv[1]))
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + str(
sys.argv[1])
entrenamiento = datos['entrenamiento'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(np.int32)
del datos # libera memoria
datosDBN = []
datosDBN.append((entrenamiento, entrenamiento_clases))
del entrenamiento, entrenamiento_clases
##
d.entrenar(data=datosDBN)
del datosDBN
##
###########################################################################
##
## P R E P A R A N D O L O S D A T O S A J U S T E F I N O
##
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'videos' y 'clases'
try:
datos = np.load(rutaDatos + str(sys.argv[1]))
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + str(
sys.argv[1])
entrenamiento = datos['entrenamiento'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(np.int32)
validacion = datos['validacion'].astype(np.float32)
validacion_clases = datos['validacion_clases'].astype(np.int32)
testeo = datos['testeo'].astype(np.float32)
testeo_clases = datos['testeo_clases'].astype(np.int32)
del datos # libera memoria
datosMLP = []
datosMLP.append((entrenamiento, entrenamiento_clases))
datosMLP.append((validacion, validacion_clases))
datosMLP.append((testeo, testeo_clases))
del entrenamiento, entrenamiento_clases, validacion, validacion_clases
del testeo, testeo_clases
##
costoTRN, costoVAL, costoTST, costoTST_final = d.ajustar(
datos=datosMLP)
del datosMLP
#
_guardar(nombreArchivo=nombreArchivo,
valor={
str(x): {
'parametros': params,
'costoTRN': costoTRN,
'costoVAL': costoVAL,
'costoTST': costoTST,
'costoTST_final': costoTST_final
}
})
final2 = T2.toc()
print("\n\nPaso de la grilla terminado, iteracion " + str(x + 1) +
"\n\n")
print("Tiempo: {}".format(T2.transcurrido(inicio2, final2)))
print("****************************************************")
print("\n\n")
final = T.toc()
print("\n\nGRID SEARCH FINALIZADO\n\n")
print("Tiempo total requerido: {}".format(T.transcurrido(inicio, final)))
return 0
def test(archivoResultados, noEntrenar, **parametrosd):
"""
parametros = {}
parametros['general'] = [general]
parametros['nombre'] = ['dbn']
parametros['tipo'] = ['binaria']
parametros['capas'] = []
parametros['epocasTRN'] = [[50]]
parametros['epocasFIT'] = [100]
parametros['tambatch'] = [10]
parametros['tasaAprenTRN'] = [0.01]
parametros['tasaAprenFIT'] = [0.1]
parametros['regularizadorL1'] = [0.0]
parametros['regularizadorL2'] = [0.0]
parametros['momentoTRN'] = [0.0]
parametros['momentoFIT'] = [0.0]
parametros['pasosGibbs'] = [5]
parametros['porcentaje'] = [0.08]
parametros['toleranciaError'] = [0.0]
parametros['pcd'] = [True]
parametros['directorio'] = [directorio]
parametros['dataset'] = [dataset]
parametros['capas'] = capas
"""
parametros = parametrosd
validacionCruzada = False
#parametros['folds'] = parametros['folds'][0] if isinstance(parametros['folds'],list) else parametros['folds']
folds = parametros['folds'][0]
if folds != 1:
validacionCruzada = True
errorTRN_conjunto = []
errorVAL_conjunto = []
errorTST_conjunto = []
errorTST_conjunto_h = []
Grid = ParameterGrid(parametros)
parametros = Grid[0]
print("GUARDANDO LOS RESULTADOS EN EL ARCHIVO {}\n\n".format(
archivoResultados))
##
##
if validacionCruzada:
print("Prueba con tecnicas de validacion cruzada...")
print("Numero de particiones: ", folds)
print("Porcentaje entrenamiento/validacion: ",
parametros['porcentaje'])
tiempo_entrenar = 0
tiempo_ajustar = 0
tiempo_total = 0
T = temporizador()
inicio = T.tic()
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaDatos = str(directorioActual) + '/cupydle/data/DB_' + str(
parametros['general']) + '/' # donde se almacenan la base de datos
carpetaConjunto = parametros['directorio'] + '_k_fold_'
print("****************************************************")
print("PARAMETROS:")
for k in sorted(parametros.keys()):
print(str("{: >20} : {: <20}").format(k, str(parametros[k])))
try:
datos = np.load(rutaDatos + dataset)
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + dataset
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
clases = datos[
'clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos
skf = StratifiedKFold(clases, n_folds=folds)
del clases
else:
# no se puede hacer por stratifiedFold porque no estan balanceadas las clases desde un principio
#por lo que quedan mal cualquier configuracion de fold..
# dividirlas variaas veces de forma random
entrenamiento_clases = datos['entrenamiento_clases'].astype(
np.int32) #las clases creo que arrancan bien
#validacion_clases = datos['validacion_clases'].astype(np.int32)
#testeo_clases = datos['testeo_clases'].astype(np.int32)
del datos
#trn_clases = np.concatenate((entrenamiento_clases, validacion_clases))
#skf = StratifiedKFold(trn_clases, n_folds=folds)
# se hace esto para mantener la compativilidad con KML
skf = StratifiedKFold(entrenamiento_clases, n_folds=folds)
del entrenamiento_clases
#del validacion_clases, testeo_clases
contador = 0
errorTRN_conjunto = []
errorVAL_conjunto = []
errorTST_conjunto = []
errorTST_conjunto_h = []
T = temporizador()
inicio_todo = T.tic()
for train_index, test_index in skf:
contador += 1
print("Particion < " + str(contador) + " >")
# creo la dbn
parametros['directorio'] = carpetaConjunto + str(contador)
d = dbn_base_test(**parametros)
###########################################################################
## P R E P A R A N D O L O S D A T O S E N T R E N A M I E N T O
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'entrenamiento' y 'entrenamiento_clases'
try:
datos = np.load(rutaDatos + dataset)
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + dataset
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos[
'clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos
X_train, y_train = videos[train_index], clases[train_index]
del videos, clases
datosDBN = []
datosDBN.append((X_train, y_train))
del X_train, y_train
else:
entrenamiento = datos['entrenamiento'].astype(np.float32)
validacion = datos['validacion'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(
np.int32)
validacion_clases = datos['validacion_clases'].astype(np.int32)
del datos
trn_val = np.concatenate((entrenamiento, validacion))
trn_val_c = np.concatenate(
(entrenamiento_clases, validacion_clases))
del entrenamiento, entrenamiento_clases, validacion, validacion_clases
# cantidad de elementos que debe tener cada conjunto
cantidad = len(trn_val_c) // folds
while cantidad % parametros['tambatch'] != 0:
cantidad += 1
# indices desde 0 hasta len; # = cantidad, sin repeticion (replace=False)
indices = np.random.choice(a=len(trn_val_c),
size=cantidad,
replace=False)
datosDBN = []
datosDBN.append((trn_val[indices], trn_val_c[indices]))
## se entrena, puede negarse con la variable de entorno "ENTRENAR"
if not noEntrenar:
tiempo_entrenar = d.entrenar(data=datosDBN)
del datosDBN
##
###########################################################################
## P R E P A R A N D O L O S D A T O S A J U S T E F I N O
###########################################################################
try:
datos = np.load(rutaDatos + dataset)
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + dataset
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos[
'clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos # libera memoria
# se debe dividir los subconjuntos para que quepan los minibatch
cantidad = int(len(train_index) * porcentaje)
while cantidad % parametros['tambatch'] != 0:
cantidad += 1
datosMLP = []
datosMLP.append((videos[train_index[:cantidad]],
clases[train_index[:cantidad]]))
datosMLP.append((videos[train_index[cantidad:]],
clases[train_index[cantidad:]]))
datosMLP.append((videos[test_index], clases[test_index]))
del videos, clases
else:
entrenamiento = datos['entrenamiento'].astype(np.float32)
validacion = datos['validacion'].astype(np.float32)
testeo = datos['testeo'].astype(np.float32)
entrenamiento_clases = datos['entrenamiento_clases'].astype(
np.int32)
validacion_clases = datos['validacion_clases'].astype(np.int32)
testeo_clases = datos['testeo_clases'].astype(np.int32)
del datos
trn_val = np.concatenate((entrenamiento, validacion))
trn_val_c = np.concatenate(
(entrenamiento_clases, validacion_clases))
#del entrenamiento, entrenamiento_clases, validacion, validacion_clases
# cantidad de elementos que debe tener cada conjunto
cantidad_conjunto = int(len(trn_val_c)) // folds
while cantidad_conjunto % parametros['tambatch'] != 0:
cantidad_conjunto += 1
# cantidad de cada subconjunto, deben complementarse
cantidad_subconjunto = int(cantidad_conjunto * porcentaje)
while cantidad_subconjunto % parametros['tambatch'] != 0:
cantidad_subconjunto += 1
cantidad_subconjunto_complemento = cantidad_conjunto - cantidad_subconjunto
cantidad_tst = len(testeo_clases) // folds
# indices desde 0 hasta len; # = cantidad, sin repeticion (replace=False)
indices_trn = np.random.choice(a=len(entrenamiento),
size=cantidad_subconjunto,
replace=False)
indices_val = np.random.choice(
a=len(validacion),
size=cantidad_subconjunto_complemento,
replace=False)
indices_tst = np.random.choice(a=len(testeo),
size=cantidad_tst,
replace=False)
datosMLP = []
datosMLP.append((entrenamiento[indices_trn],
entrenamiento_clases[indices_trn]))
datosMLP.append(
(validacion[indices_val], validacion_clases[indices_val]))
datosMLP.append(
(testeo[indices_tst], testeo_clases[indices_tst]))
del entrenamiento, entrenamiento_clases, validacion, validacion_clases, testeo, testeo_clases
## se ajustan
#costoTRN, costoVAL, costoTST, costoTST_final = 0.0,0.0,0.0,0.0
costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar = d.ajustar(
datos=datosMLP)
del datosMLP
errorTRN_conjunto.append(costoTRN)
errorVAL_conjunto.append(costoVAL)
errorTST_conjunto.append(costoTST)
errorTST_conjunto_h.append(costoTST_final)
#almaceno los resultados generales
_guardar(nombreArchivo=archivoResultados,
valor={
'parametros': parametros,
'costoTRN': costoTRN,
'costoVAL': costoVAL,
'costoTST': costoTST,
'costoTST_final': costoTST_final
})
print("\n\n")
final = T.toc()
tiempo_total = T.transcurrido(inicio, final)
print("TIEMPOS [HH:MM:SS.ss]:")
print("-> Entrenamiento: {}".format(
T.transcurrido(0, tiempo_entrenar)))
print("-> Ajuste: {}".format(
T.transcurrido(0, tiempo_ajustar)))
print("-> Total: {}".format(T.transcurrido(inicio,
final)))
####
final_todo = T.toc()
print("===============================================")
print("Tiempo total para entrenamiento: {}".format(
T.transcurrido(inicio_todo, final_todo)))
print("PROMEDIO de ERRORES para los {} conjuntos".format(contador))
print("Error Entrenamiento: {: <8}".format(
np.mean(errorTRN_conjunto) * 100.))
print("Error Validacion: {: <8}".format(
np.mean(errorVAL_conjunto) * 100.))
print("Error Testeo: {: <8}".format(
np.mean(errorTST_conjunto) * 100.))
print("Error Testeo FINAL: {: <8}".format(
np.mean(errorTST_conjunto_h) * 100.))
else:
tiempo_entrenar = 0
tiempo_ajustar = 0
tiempo_total = 0
T = temporizador()
inicio = T.tic()
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaDatos = str(directorioActual) + '/cupydle/data/DB_' + str(
parametros['general']) + '/' # donde se almacenan la base de datos
print("****************************************************")
print("PARAMETROS:")
for k in sorted(parametros.keys()):
print(str("{: >20} : {: <20}").format(k, str(parametros[k])))
# creo la dbn
d = dbn_base_test(**parametros)
###########################################################################
## P R E P A R A N D O L O S D A T O S E N T R E N A M I E N T O
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'entrenamiento' y 'entrenamiento_clases'
try:
datos = np.load(rutaDatos + dataset)
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + dataset
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos[
'clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos # libera memoria
# divido todo el conjunto con 120 ejemplos para el test
# separo con un 86% aprox
X_train, _, y_train, _ = train_test_split(videos,
clases,
test_size=120,
random_state=42)
del videos, clases
datosDBN = []
datosDBN.append((X_train, y_train))
del X_train, y_train
else:
entrenamiento = datos['entrenamiento']
entrenamiento_clases = datos[
'entrenamiento_clases'] #las clases creo que arrancan bien
del datos # libera memoria
entrenamiento = entrenamiento.astype(np.float32)
entrenamiento_clases = entrenamiento_clases.astype(np.int32)
datosDBN = []
datosDBN.append((entrenamiento, entrenamiento_clases))
del entrenamiento, entrenamiento_clases
## se entrena, puede negarse con la variable de entorno "ENTRENAR"
if not noEntrenar:
tiempo_entrenar = d.entrenar(data=datosDBN)
del datosDBN
###########################################################################
## P R E P A R A N D O L O S D A T O S A J U S T E F I N O
###########################################################################
try:
datos = np.load(rutaDatos + dataset)
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + dataset
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos[
'clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos # libera memoria
# divido todo el conjunto con 120 ejemplos para el test
# separo con un 86% aprox
X_train, X_test, y_train, y_test = train_test_split(
videos, clases, test_size=120, random_state=42)
del videos, clases
# me quedaron 600 ejemplos, lo divido de nuevo pero me quedo con 100 ejemplos para validacion
X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(
X_train, y_train, test_size=100, random_state=42)
del X_train, y_train
datosMLP = []
datosMLP.append((X_train_sub, y_train_sub))
datosMLP.append((X_valid, y_valid))
datosMLP.append((X_test, y_test))
del X_train_sub, X_valid, y_train_sub, y_valid, X_test, y_test
else:
entrenamiento = np.asarray(datos['entrenamiento'],
dtype=np.float32)
validacion = np.asarray(datos['validacion'], dtype=np.float32)
testeo = np.asarray(datos['testeo'], dtype=np.float32)
entrenamiento_clases = np.asarray(datos['entrenamiento_clases'],
dtype=np.int32)
validacion_clases = np.asarray(datos['validacion_clases'],
dtype=np.int32)
testeo_clases = np.asarray(datos['testeo_clases'], dtype=np.int32)
del datos
datosMLP = []
datosMLP.append((entrenamiento, entrenamiento_clases))
datosMLP.append((validacion, validacion_clases))
datosMLP.append((testeo, testeo_clases))
del entrenamiento, entrenamiento_clases, validacion, validacion_clases, testeo, testeo_clases
## se ajustan
costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar = d.ajustar(
datos=datosMLP)
del datosMLP
#
#almaceno los resultados generales
_guardar(nombreArchivo=archivoResultados,
valor={
'parametros': parametros,
'costoTRN': costoTRN,
'costoVAL': costoVAL,
'costoTST': costoTST,
'costoTST_final': costoTST_final
})
print("\n\n")
final = T.toc()
tiempo_total = T.transcurrido(inicio, final)
print("TIEMPOS [HH:MM:SS.ss]:")
print("-> Entrenamiento: {}".format(T.transcurrido(
0, tiempo_entrenar)))
print("-> Ajuste: {}".format(T.transcurrido(0,
tiempo_ajustar)))
print("-> Total: {}".format(T.transcurrido(inicio, final)))
return 0
def test(archivoResultados, noEntrenar, **parametrosd):
"""
parametros = {}
parametros['general'] = [general]
parametros['nombre'] = ['dbn']
parametros['tipo'] = ['binaria']
parametros['capas'] = []
parametros['epocasTRN'] = [[50]]
parametros['epocasFIT'] = [100]
parametros['tambatch'] = [10]
parametros['tasaAprenTRN'] = [0.01]
parametros['tasaAprenFIT'] = [0.1]
parametros['regularizadorL1'] = [0.0]
parametros['regularizadorL2'] = [0.0]
parametros['momentoTRN'] = [0.0]
parametros['momentoFIT'] = [0.0]
parametros['pasosGibbs'] = [5]
parametros['porcentaje'] = [0.08]
parametros['toleranciaError'] = [0.0]
parametros['pcd'] = [True]
parametros['directorio'] = [directorio]
parametros['dataset'] = [dataset]
parametros['capas'] = capas
"""
parametros=parametrosd
Grid = ParameterGrid(parametros)
parametros = Grid[0]
print("GUARDANDO LOS RESULTADOS EN EL ARCHIVO {}\n\n".format(archivoResultados))
##
##
tiempo_entrenar = 0; tiempo_ajustar = 0; tiempo_total = 0
T = temporizador() ; inicio = T.tic()
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaDatos = str(directorioActual) + '/cupydle/data/DB_' + str(parametros['general']) +'/' # donde se almacenan la base de datos
print("****************************************************")
print("PARAMETROS:")
for k in sorted(parametros.keys()):
print(str("{: >20} : {: <20}").format(k, str(parametros[k])))
# creo la dbn
d = dbn_base_test(**parametros)
###########################################################################
## P R E P A R A N D O L O S D A T O S E N T R E N A M I E N T O
###########################################################################
# se cargan los datos, debe ser un archivo comprimido, en el cual los
# arreglos estan en dos keys, 'entrenamiento' y 'entrenamiento_clases'
try:
datos = np.load(rutaDatos + parametros['dataset'])
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + parametros['dataset']
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos['clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos # libera memoria
# divido todo el conjunto con 120 ejemplos para el test
# separo con un 86% aprox
X_train, _, y_train, _ = train_test_split(videos, clases, test_size=120, random_state=np.random.randint(2**30))
del videos, clases
datosDBN = []; datosDBN.append((X_train, y_train))
del X_train, y_train
else:
entrenamiento = datos['entrenamiento']
entrenamiento_clases = datos['entrenamiento_clases'] #las clases creo que arrancan bien
del datos # libera memoria
entrenamiento = entrenamiento.astype(np.float32)
entrenamiento_clases = entrenamiento_clases.astype(np.int32)
datosDBN = []; datosDBN.append((entrenamiento, entrenamiento_clases))
del entrenamiento, entrenamiento_clases
## se entrena, puede negarse con la variable de entorno "ENTRENAR"
if not noEntrenar:
tiempo_entrenar = d.entrenar(data=datosDBN)
del datosDBN
###########################################################################
## P R E P A R A N D O L O S D A T O S A J U S T E F I N O
###########################################################################
try:
datos = np.load(rutaDatos + parametros['dataset'])
except:
assert False, "El dataset no existe en la ruta: " + rutaDatos + parametros['dataset']
KML = False
if 'videos' in datos.keys():
KML = True
if KML:
videos = datos['videos']
clases = datos['clases'] - 1 # las clases estan desde 1..6, deben ser desde 0..5
del datos # libera memoria
# divido todo el conjunto con 120 ejemplos para el test
# separo con un 86% aprox
X_train, X_test, y_train, y_test = train_test_split(videos, clases, test_size=120, random_state=np.random.randint(2**30))
del videos, clases
# me quedaron 600 ejemplos, lo divido de nuevo pero me quedo con 100 ejemplos para validacion
X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(X_train, y_train, test_size=100, random_state=np.random.randint(2**30))
del X_train, y_train
datosMLP = []
datosMLP.append((X_train_sub,y_train_sub)); datosMLP.append((X_valid,y_valid)); datosMLP.append((X_test,y_test))
del X_train_sub, X_valid, y_train_sub, y_valid, X_test, y_test
else:
entrenamiento = np.asarray(datos['entrenamiento'], dtype=np.float32)
validacion = np.asarray(datos['validacion'], dtype=np.float32)
testeo = np.asarray(datos['testeo'], dtype=np.float32)
entrenamiento_clases = np.asarray(datos['entrenamiento_clases'], dtype=np.int32)
validacion_clases = np.asarray(datos['validacion_clases'], dtype=np.int32)
testeo_clases = np.asarray(datos['testeo_clases'], dtype=np.int32)
del datos
datosMLP = []
datosMLP.append((entrenamiento,entrenamiento_clases)); datosMLP.append((validacion,validacion_clases))
datosMLP.append((testeo,testeo_clases))
del entrenamiento,entrenamiento_clases,validacion,validacion_clases,testeo,testeo_clases
## se ajustan
costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar = d.ajustar(datos=datosMLP)
del datosMLP
#
#almaceno los resultados generales
_guardar(nombreArchivo=archivoResultados, valor={'parametros':parametros, 'costoTRN':costoTRN, 'costoVAL':costoVAL, 'costoTST':costoTST, 'costoTST_final':costoTST_final })
print("\n\n")
final = T.toc()
tiempo_total = T.transcurrido(inicio, final)
print("TIEMPOS [HH:MM:SS.ss]:")
print("-> Entrenamiento: {}".format(T.transcurrido(0,tiempo_entrenar)))
print("-> Ajuste: {}".format(T.transcurrido(0,tiempo_ajustar)))
print("-> Total: {}".format(T.transcurrido(inicio, final)))
return costoTRN, costoVAL, costoTST, costoTST_final
def ajuste(self,
datos,
listaPesos=None,
fnActivacion='sigmoidea',
tambatch=10,
semillaRandom=None):
"""
construye un perceptron multicapa, y ajusta los pesos por medio de un
entrenamiento supervisado.
"""
bias = None
if listaPesos is None:
print("Cargando los pesos almacenados...") if DBN.DEBUG else None
pesos = self._cargar(clave='pesos')
bias = self._cargar(clave='bias')
if pesos == []:
print("PRECAUCION!!!, esta ajustando la red sin entrenarla!!!"
) if DBN.DEBUG else None
pesos = [None] * self.n_layers
bias = [None] * self.n_layers
else:
pesos = listaPesos
if bias == None:
bias = [None] * self.n_layers
activaciones = []
if fnActivacion is not None:
if isinstance(fnActivacion, list):
assert len(fnActivacion) == len(
pesos), "No son suficientes funciones de activacion"
activaciones = fnActivacion
else:
activaciones = [fnActivacion] * len(pesos)
else:
assert False, "Debe proveer una funcion de activacion"
# se construye un mlp para el ajuste fino de los pesos con entrenamiento supervisado
clasificador = MLP(clasificacion=True,
rng=semillaRandom,
ruta=self.ruta)
## solo cargo las keys del ajuste cargadas en las DBN al MLP buscando coincidencias y filtrando lo que no interesa
tmp = clasificador.parametrosEntrenamiento
clasificador.setParametroEntrenamiento(
{k: self._cargar(clave=k)
for k in tmp})
del tmp
# cargo en el perceptron multicapa los pesos en cada capa
# como el fit es de clasificacion, las primeras n-1 capas son del tipo
# 'logisticas' luego la ultima es un 'softmax'
#assert False, "aca entra para cuando es custom pero no para el caso normal de una sola capa... debe entrar siempre"
cantidadPesos = len(pesos) - 1 if DBN.DBN_custom else len(pesos)
for i in range(0, cantidadPesos):
clasificador.agregarCapa(unidadesEntrada=self.capas[i].n_visible,
unidadesSalida=self.capas[i].n_hidden,
clasificacion=False,
activacion=activaciones[i],
pesos=pesos[i],
biases=bias[i])
if DBN.DBN_custom:
# en este tipo carga la red y entrena con los pesos tal cual fue preentrenada.
print("Ajustando con metodo \'custom\'")
clasificador.agregarCapa(unidadesEntrada=self.capas[-1].n_visible,
unidadesSalida=self.capas[-1].n_hidden,
clasificacion=True,
activacion=activaciones[-1],
pesos=pesos[-1],
biases=bias[-1])
else:
# w = numpy.zeros((self.capas[-1].n_visible, self.capas[-1].n_hidden),dtype=theanoFloat)
clasificador.agregarCapa(unidadesEntrada=self.capas[-1].n_visible,
unidadesSalida=self.capas[-1].n_hidden,
clasificacion=True,
activacion=activaciones[-1],
pesos=None,
biases=None)
T = temporizador()
inicio = T.tic()
costoTRN, costoVAL, costoTST, costoTST_final = 0.0, 0.0, 0.0, 0.0
costoTRN, costoVAL, costoTST, costoTST_final = clasificador.entrenar(
trainSet=datos[0],
validSet=datos[1],
testSet=datos[2],
batch_size=tambatch)
final = T.toc()
print("Tiempo total para el ajuste de DBN: {}".format(
T.transcurrido(inicio, final)))
# se guardan los estadisticos
self._guardar(diccionario={
'costoTRN': costoTRN,
'costoVAL': costoVAL,
'costoTST': costoTST
})
# dibujar estadisticos
clasificador.dibujarEstadisticos(mostrar=False,
guardar=clasificador.ruta +
'estadisticosMLP')
clasificador.score(datos=datos[2],
guardar='Matriz de Confusion',
mostrar=False)
return costoTRN, costoVAL, costoTST, costoTST_final, final - inicio
def entrenar(self,
dataTrn,
dataVal=None,
pcd=True,
guardarPesosIniciales=False,
filtros=True):
"""
:type dataTrn: narray
:param dataTrn: datos de entrenamiento
:type dataVal: narray
:param dataTrn: datos de validacion
:type guardarPesosIniciales: boolean
:param guardarPesosIniciales: si se requiere almacenar los pesos iniciales antes de aplicar la rbm
"""
assert self.n_layers > 0, "No hay nada que computar"
self.x = dataTrn
T = temporizador()
inicio = T.tic()
cantidadCapas = self.n_layers if DBN.DBN_custom else self.n_layers - 1
print("Entrenando con metodo \'custom\'") if DBN.DBN_custom else None
for i in range(cantidadCapas):
# deben diferenciarse si estamos en presencia de la primer capa o de una intermedia
if i == 0:
layer_input = self.x
del dataTrn
else:
layer_input = self._cargar(clave='activacionesOcultas')[
-1] # al entrada es la anterior, la que ya se entreno
# una carpeta para alojar los datos de la capa intermedia
directorioRbm = self.ruta + 'rbm_capa{}/'.format(i + 1)
os.makedirs(
directorioRbm) if not os.path.exists(directorioRbm) else None
# creo la red
if self.capas[i].tipo == "binaria":
capaRBM = BRBM(n_visible=self.capas[i].n_visible,
n_hidden=self.capas[i].n_hidden,
w=self.capas[i].w,
ruta=directorioRbm)
BRBM.DEBUG = DBN.DEBUG
elif self.capas[i].tipo == 'gaussiana':
capaRBM = GRBM(n_visible=self.capas[i].n_visible,
n_hidden=self.capas[i].n_hidden,
w=self.capas[i].w,
ruta=directorioRbm)
GRBM.DEBUG = DBN.DEBUG
else:
raise NotImplementedError('RBM no implementada')
# configuro la capa, la rbm
# si un parametro es None lo paso como una lista vacia...
capaRBM.setParametros({
k: v if v is not None else []
for k, v in self.capas[i].getParametrosEntrenamiento.items()
})
# se entrena capa por capa
print("Entrenando la capa:", i + 1)
self._guardar(diccionario={'pesos_iniciales': capaRBM.getW
}) if guardarPesosIniciales else None
capaRBM.entrenamiento(data=layer_input,
tamMiniBatch=self.capas[i].tamMiniBatch,
pcd=pcd,
gibbsSteps=self.capas[i].pasosGibbs,
filtros=filtros)
# en caso de debug guardo la capa entera
if DBN.DEBUG:
print("Guardando la capa..")
filename = self.name + "_capa" + str(i + 1)
capaRBM.guardarObjeto(nombreArchivo=filename)
# ahora debo tener las entras que son las salidas del modelo anterior (activaciones de las ocultas)
# [probabilidad_H1, muestra_V1, muestra_H1]
if DBN.ACT_OCULTAS:
print(
"Activaciones Ocultas \"Muestreo\"") if DBN.DEBUG else None
[_, _, hiddenAct] = capaRBM.muestra(muestraV=layer_input)
else:
print("Activaciones Ocultas \"Probabilidad\""
) if DBN.DEBUG else None
[hiddenAct, _, _] = capaRBM.muestra(muestraV=layer_input)
# por ahora no lo utilizo
if dataVal is not None:
[_, _, dataVal] = capaRBM.muestra(muestraV=dataVal)
# se guardan las activaciones ocultas para la siguiente iteracion
# de la siguiente capa oculta
print("Guardando las muestras para la siguiente capa.."
) if DBN.DEBUG else None
self._guardar(diccionario={'activacionesOcultas': hiddenAct})
del hiddenAct
# se guardan los pesos para el ajuste fino y los bias
self._guardar(diccionario={'pesos': capaRBM.getW})
self._guardar(diccionario={'bias': capaRBM.getOculto})
del capaRBM
# FIN FOR
final = T.toc()
print("Tiempo total para pre-entrenamiento DBN: {}".format(
T.transcurrido(inicio, final)))
return final - inicio
