Para esta lección necesitamos configurar iPython para encontrar las librerías de PySpark.
Editar en archivo $HOME/.ipython/profile_default/startup/00-pyspark-setup.py
# Configure the necessary Spark environment
import os
os.environ['SPARK_HOME'] = '[path-to-spark-home]/'
# And Python path
import sys
sys.path.insert(0, '[path-to-spark-home]/python')
Descomprimir el archivo data/wiki-100000.zip en el directorio data.
Empezemos por entender un poco de Spark. Spark es una palataforma de computo distribido que permite hacer análsis de datos de una forma ágil, tanto para escribrlo como para ejecutarlo.
El concepto central en Spark es una colección distribuida de objetos llamad RDD (Resilient Distributed Dataset), estos pueden ser creados a partir de archivos o a partir de la transformación de otros RDD.
Nota: Se puede utilizar PySpark desde la línea de comandos utilizando el comando pyspark
El primer paso es inicializar el contexto de Spark (este paso no es necesario si se utiliza la consola de PySpark)
In [1]:
from pyspark import SparkContext
sc = SparkContext("local", "Minhashing", pyFiles=['lsh.py'])
A continuación leemos un archivo que contiene 100 mil entradas de artículos en Wikipedia con su clasificación y mostramos sus primeros 10 renglones.
Nota: Los archivos originales están disponibles en la DBpedia, bajo la licencia Creative Commons Attribution-ShareAlike License
In [2]:
f = sc.textFile("data/wiki-100000.txt")
f.take(10)
Out[2]:
Podemos observar que los renglones continen dos partes: el nombre del artículo y la categoría a la que pertencen. A continuación dividimos cada renglón en sus componentes utilizando operaciones estandar sobre un RDD, en este caso map y filter.
In [3]:
filtered = f.filter(lambda line: not line.startswith('#'))
split = filtered.map(lambda line: line.split(" "))
print split
Este segmento de código nos muestra varias cosas interesantes, la primera es que estamos pasando funciones lambda a los métodos, para que sean aplicadas a cada renglón del RDD.
La segunda es que al aplicar los métodos sobre un RDD obtenemos de nuevo una estructura RDD. En Spark, la mayoría de las funciones sobre un RDD no ejecutan el contenido sino que lo agregan al grafo de ejecución, y solamente cuando se llaman a funciones como take o collect es que se ejectua dicho grafo.
In [4]:
split.take(10)
Out[4]:
A continuación asociaremos a cada artículo las categorías a las que pertence, utilizando la función groupByKey, en este caso se considera el primer elemento de cada renglón como la llave.
In [5]:
articles = split.groupByKey()
articles.take(5)
Out[5]:
El ejemplo anterior nos muestra algunas de las operaciones básicas que se puden realizat con Spark. En la siguiente sección vamos a retomar el ejemplo de Min-hashing y aplicarlo para encontrar artículos similares.
Aplicando el modelo LSH aprendido en la lección anterior, aplicamos la función lsh a cada uno de los conjuntos que definen los temas de cada artículo.
In [6]:
from lsh import LSH, get_conf
conf = get_conf(0.90)
lsh = articles.map(lambda _: (_[0], LSH(conf).lsh(_[1])))
lsh.take(2)
Out[6]:
La clase LSH y el método get_conf están definidos en el archivo lsh.py.
Para probar la aplicación de este método creamos un mapa con las firmas a las firmas asociadas a cada artículo.
In [7]:
def entry(data):
id = data[0]
return [(sig, id) for sig in data[1]]
signatures = lsh.flatMap(lambda _: entry(_)).groupByKey()\
.filter(lambda _: len(_[1]) > 1).cache()
signatures.take(5)
Out[7]:
En este ejemplo es posible observar como artículos que contienen las mismas categorías se agrupan en una sola cubeta. A continuación obtenemos el conjunto de artículos similares a un artículo dado a partir del valor de sus firmas.
In [22]:
db_90 = signatures.collectAsMap()
index = articles.collectAsMap()
def similar(doc, db, conf):
hashes = LSH(conf).lsh(doc)
candidates = set()
for sig in hashes:
candidates.update(set(db[sig]))
for sim in candidates:
print '%s -> %s' % (sim, index[sim])
doc = index['Third_Epistle_of_John']
similar(doc, db_90, conf)
In [23]:
def create_lsh(threshold, dataset):
conf_s = get_conf(threshold)
lsh_s = dataset.map(lambda _: (_[0], LSH(conf_s).lsh(_[1])))
db_s = lsh_s.flatMap(lambda _: entry(_)).groupByKey()\
.filter(lambda _: len(_[1]) > 1).collectAsMap()
return (conf_s, db_s)
In [24]:
doc = index['Third_Epistle_of_John']
conf_s70, db_s70 = create_lsh(0.7, articles)
In [25]:
similar(doc, db_s70, conf_s70)
In [28]:
doc = index['Third_Epistle_of_John']
conf_s40, db_s40 = create_lsh(0.4, articles)
In [32]:
similar(doc, db_s40, conf_s40)
In [30]:
print len(db_90), len(db_s70), len(db_s40)
A continuación comparamos la precisión de el método de LSH con el método directo utilizando similitud de Jaccard.
In [18]:
alt = split.map(lambda _: (_[1], _[0])).groupByKey().collectAsMap()
from lsh import jaccard
def alt_similar(doc, db, threshold):
candidates = set()
for cat in doc:
candidates.update(set(db[cat]))
for sim in candidates:
if jaccard(set(doc), set(index[sim])) > threshold:
print '%s -> %s' % (sim, index[sim])
len(alt)
Out[18]:
In [33]:
doc = index['Third_Epistle_of_John']
alt_similar(doc, alt, 0.9)
In [15]:
doc = index['Third_Epistle_of_John']
alt_similar(doc, alt, 0.7)
In [16]:
doc = index['Third_Epistle_of_John']
alt_similar(doc, alt, 0.4)
Podemos observar en los resultados que el método LSH efectivamente genero falsos positivos que estaban por arriba del umbral de similitud.