print(miDBN)
parametros = {
'tasaAprendizaje': tasaAprenFIT,
'regularizadorL1': regularizadorL1,
'regularizadorL2': regularizadorL2,
'momento': momentoFIT,
'toleranciaError': toleranciaError,
'epocas': epocasFIT
}
miDBN.setParametros(parametros)
costoTRN, costoVAL, costoTST, costoTST_final = 0.0, 0.0, 0.0, 0.0
costoTRN, costoVAL, costoTST, costoTST_final = miDBN.ajuste(
datos=datos,
listaPesos=None,
fnActivacion='sigmoidea',
semillaRandom=None,
tambatch=tambatch)
errorTRN_conjunto.append(costoTRN)
errorVAL_conjunto.append(costoVAL)
errorTST_conjunto.append(costoTST)
errorTST_conjunto_h.append(costoTST_final)
#miDBN.guardarObjeto(nombreArchivo=nombre)
final_todo = T.toc()
print("Tiempo total para entrenamiento: {}".format(
T.transcurrido(inicio_todo, final_todo)))
print("PROMEDIO de ERRORES para los {} conjuntos".format(contador))
def DBN_basica(**kwargs):
# parametros pasados por consola
directorio = kwargs['directorio']
dataset = kwargs['dataset']
capas = kwargs['capas']
epocasTRN = kwargs['epocasTRN']
epocasFIT = kwargs['epocasFIT']
tambatch = kwargs['tambatch']
porcentaje = kwargs['porcentaje']
tasaAprenTRN = kwargs['tasaAprenTRN']
tasaAprenFIT = kwargs['tasaAprenFIT']
pasosGibbs = kwargs['pasosGibbs']
nombre = kwargs['nombre']
pcd = kwargs['pcd']
regularizadorL1 = kwargs['regularizadorL1']
regularizadorL2 = kwargs['regularizadorL2']
momentoTRN = kwargs['momentoTRN']
momentoFIT = kwargs['momentoFIT']
tipo = kwargs['tipo']
toleranciaError = kwargs['toleranciaError']
capas = np.asarray(capas)
tasaAprenTRN = np.asarray([tasaAprenTRN]) if isinstance(
tasaAprenTRN, float) else np.asarray(tasaAprenTRN)
momentoTRN = np.asarray([momentoTRN]) if isinstance(
momentoTRN, float) else np.asarray(momentoTRN)
pasosGibbs = np.asarray([pasosGibbs]) if isinstance(
pasosGibbs, int) else np.asarray(pasosGibbs)
# chequeos
assert dataset.find(
'.npz') != -1, "El conjunto de datos debe ser del tipo '.npz'"
assert len(epocasTRN) >= len(capas) or len(
epocasTRN
) == 1, "Epocas de entrenamiento y cantidad de capas no coinciden (unidad aplica a todas)"
assert len(tasaAprenTRN) >= len(capas) or len(
tasaAprenTRN
) == 1, "Tasa de aprendizaje no coincide con la cantidad de capas (unidad aplica a todas)"
assert len(momentoTRN) >= len(capas) or len(
momentoTRN
) == 1, "Tasa de momento entrenamiento no coincide con la cantidad de capas (unidad aplica a todas)"
assert len(pasosGibbs) >= len(capas) or len(
pasosGibbs
) == 1, "Pasos de Gibbs no coinciden con la cantidad de capas (unidad aplica a todas)"
assert porcentaje <= 1.0
# ajustes
epocasTRN = epocasTRN * len(capas) if len(epocasTRN) == 1 else epocasTRN
tasaAprenTRN = np.resize(
tasaAprenTRN,
(len(capas), )) if len(tasaAprenTRN) == 1 else tasaAprenTRN
momentoTRN = np.resize(
momentoTRN, (len(capas), )) if len(momentoTRN) == 1 else momentoTRN
pasosGibbs = np.resize(
pasosGibbs, (len(capas), )) if len(pasosGibbs) == 1 else pasosGibbs
# configuraciones con respecto a los directorios
directorioActual = os.getcwd() # directorio actual de ejecucion
rutaTest = directorioActual + '/cupydle/test/face/' # sobre el de ejecucion la ruta a los tests
rutaDatos = directorioActual + '/cupydle/data/DB_face/' # donde se almacenan la base de datos
carpetaTest = directorio + '/' # carpeta a crear para los tests
rutaCompleta = rutaTest + carpetaTest
os.makedirs(rutaCompleta) if not os.path.exists(
rutaCompleta) else None # crea la carpeta en tal caso que no exista
###########################################################################
##
## 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'
try:
datos = np.load(rutaDatos + dataset)
except:
try:
rutaTest = directorioActual + '/cupydle/test/mnist/' # sobre el de ejecucion la ruta a los tests
rutaDatos = directorioActual + '/cupydle/data/DB_mnist/' # donde se almacenan la base de datos
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
#validacion = datos['validacion']
#validacion_clases = datos['validacion_clases'] #las clases creo que arrancan bien
#testeo = datos['testeo']
#testeo_clases = datos['testeo_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
###########################################################################
##
## P R E - E N T R E N A M I E N T O R B M s
##
###########################################################################
print(" Clases :",
"[c1 c2 c3 c4 c5 c6]")
print(" :",
"-------------------")
print("Cantidad de clases en el conjunto EntrenamieDBN:",
np.bincount(datosDBN[0][1]))
print("Entrenado la DBN con {} ejemplos".format(len(datosDBN[0][1])))
# se crea el modelo
miDBN = DBN(nombre=nombre, ruta=rutaCompleta)
# se agregan las capas
for idx in range(
len(capas[:-1])
): # es -2 porque no debo tener en cuenta la primera ni la ultima
miDBN.addLayer(n_visible=capas[idx],
n_hidden=capas[idx + 1],
epocas=epocasTRN[idx],
tamMiniBatch=tambatch,
lr_pesos=tasaAprenTRN[idx],
pasosGibbs=pasosGibbs[idx],
w=None,
momento=momentoTRN[idx],
tipo=tipo)
#entrena la red
miDBN.entrenar(
dataTrn=datosDBN[0][0], # imagenes de entrenamiento
dataVal=None, # imagenes de validacion
pcd=pcd,
guardarPesosIniciales=False,
filtros=False)
#miDBN.save(rutaCompleta + "dbnMNIST", compression='zip')
del datosDBN
# FIN DEL ENTRENAMIENTO
###########################################################################
##
## 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 + 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 = datos['entrenamiento']
entrenamiento_clases = datos[
'entrenamiento_clases'] #las clases creo que arrancan bien
validacion = datos['validacion']
validacion_clases = datos[
'validacion_clases'] #las clases creo que arrancan bien
testeo = datos['testeo']
testeo_clases = datos[
'testeo_clases'] #las clases creo que arrancan bien
del datos # libera memoria
entrenamiento = entrenamiento.astype(np.float32)
entrenamiento_clases = entrenamiento_clases.astype(np.int32)
validacion = validacion.astype(np.float32)
validacion_clases = validacion_clases.astype(np.int32)
testeo = testeo.astype(np.float32)
testeo_clases = testeo_clases.astype(np.float32)
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
###########################################################################
##
## A J U S T E F I N O ( M L P )
##
###########################################################################
print(" Clases :",
"[c1 c2 c3 c4 c5 c6]")
print(" :",
"-------------------")
print("Cantidad de clases en el conjunto Entrenamiento:",
np.bincount(datosMLP[0][1]))
print("Cantidad de clases en el conjunto Validacion: \t",
np.bincount(datosMLP[1][1]))
print("Cantidad de clases en el conjunto Test: \t",
np.bincount(datosMLP[2][1]))
#miDBN = DBN.load(filename=rutaCompleta + "dbnMNIST", compression='zip')
print(miDBN)
parametros = {
'tasaAprendizaje': tasaAprenFIT,
'regularizadorL1': regularizadorL1,
'regularizadorL2': regularizadorL2,
'momento': momentoFIT,
'toleranciaError': toleranciaError,
'epocas': epocasFIT
}
miDBN.setParametros(parametros)
costoTRN, costoVAL, costoTST, costoTST_final = miDBN.ajuste(
datos=datosMLP,
listaPesos=None,
fnActivacion="sigmoidea",
semillaRandom=None,
tambatch=tambatch)
del datosMLP
miDBN.guardarObjeto(nombreArchivo=nombre)
# FIN DEL AJUSTE FINO
return costoTRN, costoVAL, costoTST, costoTST_final
print("Tiempo total para pre-entrenamiento DBN-(RBM): {}".format(
T.transcurrido(inicio, final)))
miDBN.save(rutaCompleta + "dbnMNIST", compression='zip')
if seccionDBN:
print("S E C C I O N D B N")
miDBN = DBN.load(filename=rutaCompleta + "dbnMNIST", compression='zip')
print(miDBN)
parametros = {
'tasaAprendizaje': tasaAprenMLP,
'regularizadorL1': 0.00,
'regularizadorL2': 0.0001,
'momento': 0.0,
'activationfuntion': sigmoideaTheano()
}
miDBN.setParametrosAjuste(parametros)
miDBN.setParametrosAjuste({'epocas': epocasMLP})
#miDBN.setParametrosAjuste({'toleranciaError':0.08})
miDBN.ajuste(datos=datos,
listaPesos=None,
fnActivacion=sigmoideaTheano(),
semillaRandom=None)
else:
assert False, "Esto no es un modulo, es un TEST!!!"
class dbn_base_test(object):
def __init__(self, **kwargs):
# re-parseo de los parametros pasados
self.general = kwargs['general']
self.directorio = kwargs['directorio']
self.dataset = kwargs['dataset']
self.nombre = kwargs['nombre']
self.tipo = kwargs['tipo']
self.capas = kwargs['capas']
self.epocasTRN = kwargs['epocasTRN']
self.epocasFIT = kwargs['epocasFIT']
self.tambatch = kwargs['tambatch']
self.tasaAprenTRN = kwargs['tasaAprenTRN']
self.tasaAprenFIT = kwargs['tasaAprenFIT']
self.regularizadorL1 = kwargs['regularizadorL1']
self.regularizadorL2 = kwargs['regularizadorL2']
self.momentoTRN = kwargs['momentoTRN']
self.momentoFIT = kwargs['momentoFIT']
self.pasosGibbs = kwargs['pasosGibbs']
self.porcentaje = kwargs['porcentaje']
self.toleranciaError = kwargs['toleranciaError']
self.pcd = kwargs['pcd']
self.capas = np.asarray(self.capas)
self.tasaAprenTRN = np.asarray([self.tasaAprenTRN]) if isinstance(
self.tasaAprenTRN, float) else np.asarray(self.tasaAprenTRN)
self.momentoTRN = np.asarray([self.momentoTRN]) if isinstance(
self.momentoTRN, float) else np.asarray(self.momentoTRN)
self.pasosGibbs = np.asarray([self.pasosGibbs]) if isinstance(
self.pasosGibbs, int) else np.asarray(self.pasosGibbs)
# chequeos
assert self.dataset.find(
'.npz') != -1, "El conjunto de datos debe ser del tipo '.npz'"
assert len(self.epocasTRN) >= len(self.capas) or len(
self.epocasTRN
) == 1, "Epocas de entrenamiento y cantidad de capas no coinciden (unidad aplica a todas)"
assert len(self.tasaAprenTRN) >= len(self.capas) or len(
self.tasaAprenTRN
) == 1, "Tasa de aprendizaje no coincide con la cantidad de capas (unidad aplica a todas)"
assert len(self.momentoTRN) >= len(self.capas) or len(
self.momentoTRN
) == 1, "Tasa de momento entrenamiento no coincide con la cantidad de capas (unidad aplica a todas)"
assert len(self.pasosGibbs) >= len(self.capas) or len(
self.pasosGibbs
) == 1, "Pasos de Gibbs no coinciden con la cantidad de capas (unidad aplica a todas)"
assert self.porcentaje <= 1.0
# ajustes
self.epocasTRN = self.epocasTRN * len(self.capas) if len(
self.epocasTRN) == 1 else self.epocasTRN
self.tasaAprenTRN = np.resize(
self.tasaAprenTRN, (len(self.capas), )) if len(
self.tasaAprenTRN) == 1 else self.tasaAprenTRN
self.momentoTRN = np.resize(self.momentoTRN, (len(
self.capas), )) if len(self.momentoTRN) == 1 else self.momentoTRN
self.pasosGibbs = np.resize(self.pasosGibbs, (len(
self.capas), )) if len(self.pasosGibbs) == 1 else self.pasosGibbs
# configuraciones con respecto a los directorios
self.directorioActual = os.getcwd() # directorio actual de ejecucion
self.rutaTest = self.directorioActual + '/cupydle/test/' + self.general + '/' # sobre el de ejecucion la ruta a los tests
self.rutaDatos = self.directorioActual + '/cupydle/data/DB_' + self.general + '/' # donde se almacenan la base de datos
self.carpetaTest = self.directorio + '/' # carpeta a crear para los tests
self.rutaCompleta = self.rutaTest + self.carpetaTest
os.makedirs(self.rutaCompleta) if not os.path.exists(
self.rutaCompleta
) else None # crea la carpeta en tal caso que no exista
# se crea el modelo
self.miDBN = DBN(nombre=self.nombre, ruta=self.rutaCompleta)
DBN.DBN_custom = True
# se agregan las capas
for idx in range(
len(self.capas[:-1])
): # es -2 porque no debo tener en cuenta la primera ni la ultima
self.miDBN.addLayer(n_visible=self.capas[idx],
n_hidden=self.capas[idx + 1],
epocas=self.epocasTRN[idx],
tamMiniBatch=self.tambatch,
lr_pesos=self.tasaAprenTRN[idx],
pasosGibbs=self.pasosGibbs[idx],
w=None,
momento=self.momentoTRN[idx],
tipo=self.tipo)
return
def entrenar(self, data):
###########################################################################
##
## P R E - E N T R E N A M I E N T O R B M s
##
###########################################################################
datosDBN = data
cant_clases = len(np.bincount(datosDBN[0][1]))
print(" Clases :",
"".join("{:^6}".format(x) for x in range(0, cant_clases)))
print(" :",
"".join("{:^6}".format("-----") for x in range(0, cant_clases)))
print("Cantidad de clases en el conjunto EntrenamieDBN:",
"".join("{:^6}".format(x) for x in np.bincount(datosDBN[0][1])))
print("Entrenado la DBN con {} ejemplos".format(len(datosDBN[0][1])))
#entrena la red
tiempo_entrenar = self.miDBN.entrenar(
dataTrn=datosDBN[0][0], # imagenes de entrenamiento
dataVal=None, # imagenes de validacion
pcd=self.pcd,
guardarPesosIniciales=False,
filtros=True)
#miDBN.save(rutaCompleta + "dbnMNIST", compression='zip')
del datosDBN
return tiempo_entrenar
def ajustar(self, datos):
###########################################################################
##
## A J U S T E F I N O ( M L P )
##
###########################################################################
datosMLP = datos
cant_clases = len(np.bincount(datosMLP[0][1]))
print(" Clases :",
"".join("{:^6}".format(x) for x in range(0, cant_clases)))
print(" :",
"".join("{:^6}".format("-----") for x in range(0, cant_clases)))
print("Cantidad de clases en el conjunto Entrenamiento:",
"".join("{:^6}".format(x) for x in np.bincount(datosMLP[0][1])))
print("Cantidad de clases en el conjunto Validacion: \t",
"".join("{:^6}".format(x) for x in np.bincount(datosMLP[1][1])))
print("Cantidad de clases en el conjunto Test: \t",
"".join("{:^6}".format(x) for x in np.bincount(datosMLP[2][1])))
#miDBN = DBN.load(filename=rutaCompleta + "dbnMNIST", compression='zip')
print(self.miDBN)
parametros = {
'tasaAprendizaje': self.tasaAprenFIT,
'regularizadorL1': self.regularizadorL1,
'regularizadorL2': self.regularizadorL2,
'momento': self.momentoFIT,
'toleranciaError': self.toleranciaError,
'epocas': self.epocasFIT
}
self.miDBN.setParametros(parametros)
costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar = self.miDBN.ajuste(
datos=datosMLP,
listaPesos=None,
fnActivacion="sigmoidea",
semillaRandom=None,
tambatch=self.tambatch)
del datosMLP
#miDBN.guardarObjeto(nombreArchivo=nombre)
return costoTRN, costoVAL, costoTST, costoTST_final, tiempo_ajustar