def transform(self, dataset):
"""
Aplica estandarización sobre **dataset**.
:param dataset: pyspark.rdd.RDD o numpy.ndarray o :class:`.LabeledDataSet`
"""
labels = None # Por si el dataset viene con labels
type_dataset = type(dataset)
if isinstance(dataset, LabeledDataSet):
labels = dataset.labels
dataset = dataset.features
if self.model is not None: # Se debe usar modelo de pyspark
if not isinstance(dataset, pyspark.rdd.RDD):
dataset = sc.parallelize(dataset)
dataset = self.model.transform(dataset)
else:
if type(dataset) is not np.ndarray:
dataset = np.array(dataset)
if self.flag_mean is True:
dataset -= self.mean # Remove mean
if self.flag_std is True:
dataset /= self.std # Scale unit variance
if labels is not None:
if type_dataset is DistributedLabeledDataSet:
dataset = DistributedLabeledDataSet(labels.zip(dataset))
else:
dataset = LocalLabeledDataSet(zip(labels, dataset))
return dataset
def transform(self, dataset):
"""
Aplica estandarización sobre **dataset**.
:param dataset: pyspark.rdd.RDD o numpy.ndarray o :class:`.LabeledDataSet`
"""
labels = None # Por si el dataset viene con labels
type_dataset = type(dataset)
if isinstance(dataset, LabeledDataSet):
labels = dataset.labels
dataset = dataset.features
if self.model is not None: # Se debe usar modelo de pyspark
if not isinstance(dataset, pyspark.rdd.RDD):
dataset = sc.parallelize(dataset)
dataset = self.model.transform(dataset)
else:
if type(dataset) is not np.ndarray:
dataset = np.array(dataset)
if self.flag_mean is True:
dataset -= self.mean # Remove mean
if self.flag_std is True:
dataset /= self.std # Scale unit variance
if labels is not None:
if type_dataset is DistributedLabeledDataSet:
dataset = DistributedLabeledDataSet(labels.zip(dataset))
else:
dataset = LocalLabeledDataSet(zip(labels, dataset))
return dataset
def __init__(self, data=None):
self.with_lp = False # Flag que indica si se almaceno entradas en forma de LabeledPoints
if data is not None:
if not isinstance(data, pyspark.rdd.RDD):
data = sc.parallelize(data)
if type(data.take(2)[0]) is LabeledPoint:
self.with_lp = True
self.data = data
if self.with_lp is False and self.data is not None: # Por ahora que quede etiquetado con LabeledPoints
self._labeled_point()
if self.data is not None:
self.rows = self.data.count()
self.cols = len(self.features.take(1)[0].toArray())
def __init__(self, data=None):
self.with_lp = False # Flag que indica si se almaceno entradas en forma de LabeledPoints
if data is not None:
if not isinstance(data, pyspark.rdd.RDD):
data = sc.parallelize(data)
if type(data.take(2)[0]) is LabeledPoint:
self.with_lp = True
self.data = data
if self.with_lp is False and self.data is not None: # Por ahora que quede etiquetado con LabeledPoints
self._labeled_point()
if self.data is not None:
self.rows = self.data.count()
self.cols = len(self.features.take(1)[0].toArray())
def test_activation(self):
logger.info("Testeando la integración de funciones de activación...")
activation = 'Tanh'
fun = fun_activation[activation]
res = self.matrix_neurons.activation(fun)
fun_d = fun_activation_d[activation]
res_d = self.matrix_neurons.activation(fun_d)
assert np.array_equiv(res.matrix, fun(np.ones(self.matrix_neurons.shape)))
assert np.array_equiv(res_d.matrix, fun_d(np.ones(self.matrix_neurons.shape)))
# Test de softmax como funcion de activacion
N = self.matrix_neurons.rows
shape = (N,)
x = LocalNeurons(sc.parallelize(range(N)), shape) # Aprovecho para testear con RDD
res = x.softmax()
res = map(lambda e: e[0], res.matrix)
exp_x = np.exp(range(N))
y = exp_x / float(sum(exp_x))
assert np.allclose(res, y)
logger.info("OK")
def test_file_distributed():
logger.info("Testeo de manejo de archivos de texto con DistributedLabeledDataSet...")
filename = TEMP_PATH + "spark_data.txt"
if os.path.exists(filename):
shutil.rmtree(filename)
rdd_data = sc.parallelize(zip(range(10), range(10, 20))) # dummy data
rdd_data = rdd_data.map(lambda (l, f): (l, [f]))
distributed_data = DistributedLabeledDataSet(rdd_data)
distributed_data.save_file(filename) # Saving
dataset = DistributedLabeledDataSet()
dataset.load_file(filename, pos_label=0) # Loading
# LabeledPoints to tuple(l,f)
distributed_data._labeled_point()
dataset._labeled_point()
res1 = sorted(distributed_data.collect(unpersist=True), key=lambda (l, f): l)
res2 = sorted(dataset.collect(unpersist=True), key=lambda (l, f): l)
assert res1 == res2
def test_activation(self):
logger.info("Testeando la integración de funciones de activación...")
activation = 'Tanh'
fun = fun_activation[activation]
res = self.matrix_neurons.activation(fun)
fun_d = fun_activation_d[activation]
res_d = self.matrix_neurons.activation(fun_d)
assert np.array_equiv(res.matrix,
fun(np.ones(self.matrix_neurons.shape)))
assert np.array_equiv(res_d.matrix,
fun_d(np.ones(self.matrix_neurons.shape)))
# Test de softmax como funcion de activacion
N = self.matrix_neurons.rows
shape = (N, )
x = LocalNeurons(sc.parallelize(range(N)),
shape) # Aprovecho para testear con RDD
res = x.softmax()
res = map(lambda e: e[0], res.matrix)
exp_x = np.exp(range(N))
y = exp_x / float(sum(exp_x))
assert np.allclose(res, y)
logger.info("OK")
def _train(self, train_bc, mini_batch=50, parallelism=0, measure=None, optimizer_params=None,
reproducible=False, evaluate=True, seeds=None):
"""
Entrenamiento de la red neuronal sobre el conjunto *train_bc*.
:param train_bc: *pyspark.Broadcast*, variable Broadcast de Spark correspondiente al conjunto de entrenamiento.
:param mini_batch: int, cantidad de ejemplos a utilizar durante una época de la optimización.
:param parallelism: int, cantidad de modelos a optimizar concurrentemente.
Si es 0, es determinado por el nivel de paralelismo por defecto en Spark (variable *sc.defaultParallelism*),
Si es -1, se setea como :math:`\\frac{N}{m}` donde *N* es la cantidad
total de ejemplos de entrenamiento y *m* la cantidad de ejemplos para el mini-batch.
:param optimizer_params: :class:`.OptimizerParameters`
:param measure: string, key de alguna medida implementada en alguna de las métricas
diponibles en :mod:`~learninspy.utils.evaluation`.
:param reproducible: bool, si es True se indica que se debe poder reproducir exactamente el ajuste.
:param evaluate: bool, si es True se evalua el modelo sobre el conjunto de entrenamiento.
:return: float, resultado de evaluar el modelo final, o None si *evaluate* es False.
"""
if parallelism == 0:
parallelism = sc.defaultParallelism
elif parallelism == -1:
# Se debe entrenar un modelo por cada batch (aunque se pueden solapar)
total = len(train_bc.value)
parallelism = total / mini_batch
# Funcion para minimizar funcion de costo sobre cada modelo del RDD
minimizer = opt.optimize
# TODO ver si usar sc.accumulator para acumular actualizaciones y despues aplicarlas (paper de mosharaf)
if reproducible is True:
self._set_initial_rndstate() # Seteo estado inicial del RandomState (al generarse la instancia NeuralNetwork)
if seeds is None:
seeds = list(self.params.rng.randint(500, size=parallelism))
# Paralelizo modelo actual en los nodos mediante parallelism (que define el n° de particiones o slices del RDD)
# NOTA: se persiste en memoria serializando ya que se supone que son objetos grandes y no conviene cachearlos
models_rdd = (sc.parallelize(zip([self] * parallelism, seeds), numSlices=parallelism)
.persist(StorageLevel.MEMORY_ONLY_SER) # TODO: si o si este StorageLevel?
)
# Minimizo el costo de las redes en paralelo
# NOTA: persist() es importante porque se traza varias veces el grafo de acciones sobre el RDD results
logger.debug("Training %i models in parallel.", parallelism)
results = (models_rdd.map(lambda (model, seed):
minimizer(model, train_bc.value, optimizer_params, mini_batch, seed))
.persist(StorageLevel.MEMORY_ONLY_SER) # TODO: si o si este StorageLevel?
)
# Junto modelos entrenados en paralelo, en base a un criterio de ponderacion sobre un valor objetivo
logger.debug("Merging models ...")
list_layers = opt.merge_models(results, optimizer_params.merge['criter'], optimizer_params.merge['goal'])
# Copio el resultado de las capas mezcladas en el modelo actual
self.list_layers = copy.copy(list_layers)
# Quito de memoria
logger.debug("Unpersisting replicated models ...")
results.unpersist()
models_rdd.unpersist()
if evaluate is True:
# Evaluo tasa de aciertos de entrenamiento
hits = self.evaluate(train_bc.value, predictions=False, measure=measure)
else:
hits = None
return hits
def _train(self, train_bc, mini_batch=50, parallelism=0, measure=None, optimizer_params=None,
reproducible=False, evaluate=True, seeds=None):
"""
Entrenamiento de la red neuronal sobre el conjunto *train_bc*.
:param train_bc: *pyspark.Broadcast*, variable Broadcast de Spark correspondiente al conjunto de entrenamiento.
:param mini_batch: int, cantidad de ejemplos a utilizar durante una época de la optimización.
:param parallelism: int, cantidad de modelos a optimizar concurrentemente.
Si es 0, es determinado por el nivel de paralelismo por defecto en Spark (variable *sc.defaultParallelism*),
Si es -1, se setea como :math:`\\frac{N}{m}` donde *N* es la cantidad
total de ejemplos de entrenamiento y *m* la cantidad de ejemplos para el mini-batch.
:param optimizer_params: :class:`.OptimizerParameters`
:param measure: string, key de alguna medida implementada en alguna de las métricas
diponibles en :mod:`~learninspy.utils.evaluation`.
:param reproducible: bool, si es True se indica que se debe poder reproducir exactamente el ajuste.
:param evaluate: bool, si es True se evalua el modelo sobre el conjunto de entrenamiento.
:return: float, resultado de evaluar el modelo final, o None si *evaluate* es False.
"""
if parallelism == 0:
parallelism = sc.defaultParallelism
elif parallelism == -1:
# Se debe entrenar un modelo por cada batch (aunque se pueden solapar)
total = len(train_bc.value)
parallelism = total / mini_batch
# Funcion para minimizar funcion de costo sobre cada modelo del RDD
minimizer = opt.optimize
# TODO ver si usar sc.accumulator para acumular actualizaciones y despues aplicarlas (paper de mosharaf)
if reproducible is True:
self._set_initial_rndstate() # Seteo estado inicial del RandomState (al generarse la instancia NeuralNetwork)
if seeds is None:
seeds = list(self.params.rng.randint(500, size=parallelism))
# Paralelizo modelo actual en los nodos mediante parallelism (que define el n° de particiones o slices del RDD)
# NOTA: se persiste en memoria serializando ya que se supone que son objetos grandes y no conviene cachearlos
models_rdd = (sc.parallelize(zip([self] * parallelism, seeds), numSlices=parallelism)
.persist(StorageLevel.MEMORY_ONLY_SER) # TODO: si o si este StorageLevel?
)
# Minimizo el costo de las redes en paralelo
# NOTA: persist() es importante porque se traza varias veces el grafo de acciones sobre el RDD results
logger.debug("Training %i models in parallel.", parallelism)
results = (models_rdd.map(lambda (model, seed):
minimizer(model, train_bc.value, optimizer_params, mini_batch, seed))
.persist(StorageLevel.MEMORY_ONLY_SER) # TODO: si o si este StorageLevel?
)
# Junto modelos entrenados en paralelo, en base a un criterio de ponderacion sobre un valor objetivo
logger.debug("Merging models ...")
list_layers = opt.merge_models(results, optimizer_params.merge['criter'], optimizer_params.merge['goal'])
# Copio el resultado de las capas mezcladas en el modelo actual
self.list_layers = copy.copy(list_layers)
# Quito de memoria
logger.debug("Unpersisting replicated models ...")
results.unpersist()
models_rdd.unpersist()
if evaluate is True:
# Evaluo tasa de aciertos de entrenamiento
hits = self.evaluate(train_bc.value, predictions=False, measure=measure)
else:
hits = None
return hits
