def _init_autoencoders(self): """ Inicialización de los parámetros de cada autoencoder que conforman esta red. :return: """ for l in xrange(self.num_layers - 1): # Genero nueva estructura de parametros acorde al Autoencoder a crear params = NetworkParameters( self.params.units_layers[l:l + 2], activation=self.params.activation[l], layer_distributed=self.params.layer_distributed, dropout_ratios=None, classification=False, strength_l1=self.params.strength_l1, strength_l2=self.params.strength_l2) self.list_layers[l] = AutoEncoder(params=params, dropout_in=self.dropout[l]) # Configuro y creo la capa de salida (clasificación o regresión) params = NetworkParameters( self.params.units_layers[-2:], activation=self.params.activation, layer_distributed=self.params.layer_distributed, dropout_ratios=[0.0], # en salida no debe haber DropOut classification=self.params.classification, strength_l1=self.params.strength_l1, strength_l2=self.params.strength_l2) self.list_layers[-1] = NeuralNetwork(params=params)
def test_mix_models(): # Dado que esta funcion se llama en una transformación de RDD, no es rastreada por Python # por lo que es mejor hacerle unittest de forma que sea trazada en el coverage code. # Configuracion de modelo net_params = NetworkParameters(units_layers=[4, 10, 3], activation='ReLU', strength_l1=1e-5, strength_l2=3e-4, dropout_ratios=[0.2, 0.0], classification=True) model = NeuralNetwork(net_params) mixed_layers = mix_models(model.list_layers, model.list_layers) for l in xrange(len(mixed_layers)): assert mixed_layers[l] == model.list_layers[l] * 2 # A + A = 2A
def finetune(self, train, valid, mini_batch=50, parallelism=0, valid_iters=10, measure=None, stops=None, optimizer_params=None, reproducible=False, keep_best=False): """ Ajuste fino con aprendizaje supervisado de la red neuronal, cuyos parámetros fueron inicializados mediante el pre-entrenamiento de los autoencoders. .. note:: Dado que esta función es una sobrecarga del método original :func:`~learninspy.core.model.NeuralNetwork.fit`, se puede remitir a la documentación de esta última para conocer el significado de los parámetros. """ list_layers = copy.deepcopy(self.list_layers) list_layers[:-1] = map( lambda ae: ae.encoder_layer(), list_layers[:-1]) # Tomo solo la capa de encoder de cada ae list_layers[-1] = list_layers[-1].list_layers[ 0] # Agarro la primer capa de la red que se genero para la salida nn = NeuralNetwork(self.params, list_layers=list_layers) hits_valid = nn.fit(train, valid, mini_batch=mini_batch, parallelism=parallelism, valid_iters=valid_iters, measure=measure, stops=stops, keep_best=keep_best, optimizer_params=optimizer_params, reproducible=reproducible) for l in xrange(len(self.list_layers) - 1): # Copio capa con ajuste fino al autoencoder self.list_layers[l].list_layers[0] = nn.list_layers[ l] # TODO mejorar esto, para que sea mas legible self.list_layers[-1].list_layers[0] = nn.list_layers[-1] # Copio los resultados de evaluación también (sobrescribir en lugar de guardar dos listas más) self.hits_train = nn.hits_train self.hits_valid = nn.hits_valid self.epochs = nn.epochs return hits_valid
def __init__(self, network_params=None): logger.info( "Testeo de NeuralNetwork con datos de Combined Cycle Power Plant") # Datos logger.info("Cargando datos...") data = load_ccpp() dataset = LocalLabeledDataSet(data) self.train, self.valid, self.test = dataset.split_data([.5, .3, .2]) self.valid = self.valid.collect() # Modelo if network_params is None: network_params = NetworkParameters(units_layers=[4, 30, 1], activation='ReLU', classification=False, seed=123) self.model = NeuralNetwork(network_params) # Seteo a mano self.model.set_l1(5e-7) self.model.set_l2(3e-4) self.model.set_dropout_ratios([0.0, 0.0])
def __init__(self, opt_params=None): logger.info("Testeo de Optimizer con datos de Iris") # Datos logger.info("Cargando datos...") data = load_iris() dataset = LocalLabeledDataSet(data) self.train, self.valid, self.test = dataset.split_data([.5, .3, .2]) self.train = self.train.collect() self.valid = self.valid.collect() self.test = self.test.collect() # Configuracion de optimizacion if opt_params is None: # Por defecto, se utiliza Adadelta stops = [criterion['MaxIterations'](10), criterion['AchieveTolerance'](0.95, key='hits')] options = {'step-rate': 1.0, 'decay': 0.99, 'momentum': 0.3, 'offset': 1e-8} opt_params = OptimizerParameters(algorithm='Adadelta', stops=stops, options=options, merge_criter='w_avg') self.opt_params = opt_params # Configuracion de modelo net_params = NetworkParameters(units_layers=[4, 10, 3], activation='ReLU', strength_l1=1e-5, strength_l2=3e-4, dropout_ratios=[0.2, 0.0], classification=True) self.model = NeuralNetwork(net_params)
] options = {'step-rate': 1.0, 'decay': 0.995, 'momentum': 0.7, 'offset': 1e-8} optimizer_params = OptimizerParameters(algorithm='Adadelta', stops=local_stops, options=options, merge_criter='w_avg', merge_goal='cost') logger.info("Optimizacion utilizada: %s", os.linesep + str(optimizer_params)) logger.info("Configuracion usada: %s", os.linesep + str(net_params)) # -- 3) Construcción y ajuste de red neuronal neural_net = NeuralNetwork(net_params) logger.info("Entrenando red neuronal ...") hits_valid = neural_net.fit(train, valid, valid_iters=1, mini_batch=20, parallelism=0, stops=global_stops, optimizer_params=optimizer_params, measure='R2', keep_best=True, reproducible=False) hits_test, predict = neural_net.evaluate(test, predictions=True) logger.info("Hits en test: %12.11f", hits_test)