Python para la PNL: trabajar con la biblioteca FastText de Facebook

    Este es el vigésimo artículo de mi serie de artículos sobre Python para PNL. En los últimos artículos, hemos estado explorando técnicas de aprendizaje profundo para realizar una variedad de tareas de Machine Learning, y también debe estar familiarizado con el concepto de incrustaciones de palabras. Las incrustaciones de palabras son una forma de convertir información textual en forma numérica, que a su vez se puede utilizar como entrada para algoritmos estadísticos. En mi artículo sobre incrustaciones de palabras, expliqué cómo podemos crear nuestras propias incrustaciones de palabras y cómo podemos usar incrustaciones de palabras integradas como GloVe .

    En este artículo, vamos a estudiar FastText, que es otro módulo extremadamente útil para la incrustación de palabras y la clasificación de texto. FastText ha sido desarrollado por Facebook y ha mostrado excelentes resultados en muchos problemas de PNL, como la detección de similitudes semánticas y la clasificación de texto.

    En este artículo, exploraremos brevemente la biblioteca FastText. Este artículo se divide en dos secciones. En la primera sección, veremos cómo la biblioteca FastText crea representaciones vectoriales que pueden usarse para encontrar similitudes semánticas entre las palabras. En la segunda sección, veremos la aplicación de la biblioteca FastText para la clasificación de texto.

    FastText para similitud semántica

    FastText admite los modelos Continuous Bag of Words y Skip-Gram . En este artículo, implementaremos el modelo de omisión para aprender la representación vectorial de palabras de los artículos de Wikipedia sobre inteligencia artificial , Machine Learning , aprendizaje profundo y redes neuronales . Dado que estos temas son bastante similares, elegimos estos temas para tener una cantidad sustancial de datos para crear un corpus. Puede agregar más temas de naturaleza similar si lo desea.

    Como primer paso, necesitamos importar las bibliotecas necesarias. Haremos uso de la biblioteca de Wikipedia para Python, que se puede descargar mediante el siguiente comando:

    $ pip install wikipedia
    

    Importación de bibliotecas

    El siguiente script importa las bibliotecas necesarias a nuestra aplicación:

    from keras.preprocessing.text import Tokenizer
    from gensim.models.fasttext import FastText
    import numpy as np
    import matplotlib.pyplot as plt
    import nltk
    from string import punctuation
    from nltk.corpus import stopwords
    from nltk.tokenize import word_tokenize
    from nltk.stem import WordNetLemmatizer
    from nltk.tokenize import sent_tokenize
    from nltk import WordPunctTokenizer
    
    import wikipedia
    import nltk
    nltk.download('punkt')
    nltk.download('wordnet')
    nltk.download('stopwords')
    en_stop = set(nltk.corpus.stopwords.words('english'))
    
    %matplotlib inline
    

    Puede ver que estamos usando el FastTextmódulo de la gensim.models.fasttextbiblioteca. Para la representación de palabras y la similitud semántica, podemos usar el modelo Gensim para FastText. Este modelo se puede ejecutar en Windows, sin embargo, para la clasificación de texto, tendremos que usar la plataforma Linux. Lo veremos en la siguiente sección.

    Raspado de artículos de Wikipedia

    En este paso, eliminaremos los artículos de Wikipedia necesarios. Mira el guión a continuación:

    artificial_intelligence = wikipedia.page("Artificial Intelligence").content
    machine_learning = wikipedia.page("Machine Learning").content
    deep_learning = wikipedia.page("Deep Learning").content
    neural_network = wikipedia.page("Neural Network").content
    
    artificial_intelligence = sent_tokenize(artificial_intelligence)
    machine_learning = sent_tokenize(machine_learning)
    deep_learning = sent_tokenize(deep_learning)
    neural_network = sent_tokenize(neural_network)
    
    artificial_intelligence.extend(machine_learning)
    artificial_intelligence.extend(deep_learning)
    artificial_intelligence.extend(neural_network)
    

    Para raspar una página de Wikipedia, podemos usar el pagemétodo del wikipediamódulo. El nombre de la página que desea eliminar se pasa como parámetro al pagemétodo. El método devuelve un WikipediaPageobjeto, que luego puede usar para recuperar el contenido de la página a través del contentatributo, como se muestra en el script anterior.

    El contenido extraído de las cuatro páginas de Wikipedia se convierte en oraciones mediante el sent_tokenizemétodo. El sent_tokenizemétodo devuelve una lista de oraciones. Las oraciones de las cuatro páginas se tokenizan por separado. Finalmente, las frases de los cuatro artículos se unen mediante el extendmétodo.

    Preprocesamiento de datos

    El siguiente paso es limpiar nuestros datos de texto eliminando las puntuaciones y los números. También convertiremos los datos a minúsculas. Las palabras de nuestros datos se lematizarán a su forma raíz. Además, las palabras vacías y las palabras con una longitud inferior a 4 se eliminarán del corpus.

    La preprocess_textfunción, como se define a continuación, realiza las tareas de preprocesamiento.

    import re
    from nltk.stem import WordNetLemmatizer
    
    stemmer = WordNetLemmatizer()
    
    def preprocess_text(document):
            # Remove all the special characters
            document = re.sub(r'W', ' ', str(document))
    
            # remove all single characters
            document = re.sub(r's+[a-zA-Z]s+', ' ', document)
    
            # Remove single characters from the start
            document = re.sub(r'^[a-zA-Z]s+', ' ', document)
    
            # Substituting multiple spaces with single space
            document = re.sub(r's+', ' ', document, flags=re.I)
    
            # Removing prefixed 'b'
            document = re.sub(r'^bs+', '', document)
    
            # Converting to Lowercase
            document = document.lower()
    
            # Lemmatization
            tokens = document.split()
            tokens = [stemmer.lemmatize(word) for word in tokens]
            tokens = [word for word in tokens if word not in en_stop]
            tokens = [word for word in tokens if len(word) > 3]
    
            preprocessed_text=" ".join(tokens)
    
            return preprocessed_text
    

    Veamos si nuestra función realiza la tarea deseada procesando previamente una oración ficticia:

    
    sent = preprocess_text("Artificial intelligence, is the most advanced technology of the present era")
    print(sent)
    
    
    final_corpus = [preprocess_text(sentence) for sentence in artificial_intelligence if sentence.strip() !='']
    
    word_punctuation_tokenizer = nltk.WordPunctTokenizer()
    word_tokenized_corpus = [word_punctuation_tokenizer.tokenize(sent) for sent in final_corpus]
    
    

    La oración preprocesada se ve así:

    artificial intelligence advanced technology present
    

    Puede ver que las puntuaciones y las palabras vacías se han eliminado y las oraciones se han lematizado. Además, las palabras con una longitud inferior a 4, como «era», también se han eliminado. Estas opciones se eligieron al azar para esta prueba, por lo que puede permitir palabras con menor o mayor longitud en el corpus.

    Crear representación de palabras

    Hemos preprocesado nuestro corpus. Ahora es el momento de crear representaciones de palabras usando FastText. Primero definamos los hiperparámetros para nuestro modelo FastText:

    embedding_size = 60
    window_size = 40
    min_word = 5
    down_sampling = 1e-2
    

    Aquí embedding_sizeestá el tamaño del vector de incrustación. En otras palabras, cada palabra de nuestro corpus se representará como un vector de 60 dimensiones. El window_sizees el tamaño de la cantidad de palabras que aparecen antes y después de la palabra según el cual se aprenderán las representaciones de la palabra para la palabra. Esto puede parecer complicado, sin embargo, en el modelo de omisión de gramática, ingresamos una palabra al algoritmo y la salida son las palabras de contexto. Si el tamaño de la ventana es 40, para cada entrada habrá 80 salidas: 40 palabras que ocurren antes de la palabra de entrada y 40 palabras que ocurren después de la palabra de entrada. Las incrustaciones de palabras para la palabra de entrada se aprenden utilizando estas 80 palabras de salida.

    El siguiente hiperparámetro es el min_word, que especifica la frecuencia mínima de una palabra en el corpus para la que se generarán las representaciones de palabras. Por último, la palabra que aparece con más frecuencia se reducirá mediante un número especificado por el down_samplingatributo.

    Creemos ahora nuestro FastTextmodelo para representaciones de palabras.

    %%time
    ft_model = FastText(word_tokenized_corpus,
                          size=embedding_size,
                          window=window_size,
                          min_count=min_word,
                          sample=down_sampling,
                          sg=1,
                          iter=100)
    

    Todos los parámetros en el script anterior son autoexplicativos, excepto sg. El sgparámetro define el tipo de modelo que queremos crear. Un valor de 1 especifica que queremos crear un modelo de omisión de gramática. Mientras que cero especifica el modelo de bolsa de palabras, que también es el valor predeterminado.

    Ejecute el script anterior. Puede que tarde algún tiempo en ejecutarse. En mi máquina, las estadísticas de tiempo para que se ejecute el código anterior son las siguientes:

    CPU times: user 1min 45s, sys: 434 ms, total: 1min 45s
    Wall time: 57.2 s
    

    Veamos ahora la representación de la palabra «artificial». Para hacerlo, puede utilizar el wvmétodo del FastTextobjeto y pasarle el nombre de la palabra dentro de una lista.

    print(ft_model.wv['artificial'])
    

    Aquí está el resultado:

    [-3.7653010e-02 -4.5558015e-01  3.2035065e-01 -1.5289043e-01
      4.0645871e-02 -1.8946664e-01  7.0426887e-01  2.8806925e-01
     -1.8166199e-01  1.7566417e-01  1.1522485e-01 -3.6525184e-01
     -6.4378887e-01 -1.6650060e-01  7.4625671e-01 -4.8166099e-01
      2.0884991e-01  1.8067230e-01 -6.2647951e-01  2.7614883e-01
     -3.6478557e-02  1.4782918e-02 -3.3124462e-01  1.9372456e-01
      4.3028224e-02 -8.2326338e-02  1.0356739e-01  4.0792203e-01
     -2.0596240e-02 -3.5974573e-02  9.9928051e-02  1.7191900e-01
     -2.1196717e-01  6.4424530e-02 -4.4705093e-02  9.7391091e-02
     -2.8846195e-01  8.8607501e-03  1.6520244e-01 -3.6626378e-01
     -6.2017748e-04 -1.5083785e-01 -1.7499258e-01  7.1994811e-02
     -1.9868813e-01 -3.1733567e-01  1.9832127e-01  1.2799081e-01
     -7.6522082e-01  5.2335665e-02 -4.5766738e-01 -2.7947658e-01
      3.7890410e-03 -3.8761377e-01 -9.3001537e-02 -1.7128626e-01
     -1.2923178e-01  3.9627206e-01 -3.6673656e-01  2.2755004e-01]
    

    En el resultado anterior, puede ver un vector de 60 dimensiones para la palabra «artificial»

    Busquemos ahora las 5 palabras más similares para las palabras ‘artificial’, ‘inteligencia’, ‘máquina’, ‘red’, ‘recurrente’, ‘profundo’. Puede elegir cualquier número de palabras. El siguiente script imprime las palabras especificadas junto con las 5 palabras más similares.

    semantically_similar_words = {words: [item[0] for item in ft_model.wv.most_similar([words], topn=5)]
                      for words in ['artificial', 'intelligence', 'machine', 'network', 'recurrent', 'deep']}
    
    for k,v in semantically_similar_words.items():
        print(k+":"+str(v))
    

    El resultado es el siguiente:

    artificial:['intelligence', 'inspired', 'book', 'academic', 'biological']
    intelligence:['artificial', 'human', 'people', 'intelligent', 'general']
    machine:['ethic', 'learning', 'concerned', 'argument', 'intelligence']
    network:['neural', 'forward', 'deep', 'backpropagation', 'hidden']
    recurrent:['rnns', 'short', 'schmidhuber', 'shown', 'feedforward']
    deep:['convolutional', 'speech', 'network', 'generative', 'neural']
    

    También podemos encontrar la similitud de coseno entre los vectores para dos palabras cualesquiera, como se muestra a continuación:

    print(ft_model.wv.similarity(w1='artificial', w2='intelligence'))
    

    La salida muestra un valor de «0,7481». El valor puede estar entre 0 y 1. Un valor más alto significa una mayor similitud.

    Visualización de similitudes entre palabras

    Aunque cada palabra en nuestro modelo se representa como un vector de 60 dimensiones, podemos usar la técnica de análisis de componentes principales para encontrar dos componentes principales. Los dos componentes principales se pueden utilizar para trazar las palabras en un espacio bidimensional. Sin embargo, primero debemos crear una lista de todas las palabras del semantically_similar_wordsdiccionario. El siguiente script hace eso:

    from sklearn.decomposition import PCA
    
    all_similar_words = sum([[k] + v for k, v in semantically_similar_words.items()], [])
    
    print(all_similar_words)
    print(type(all_similar_words))
    print(len(all_similar_words))
    

    En el script anterior, iteramos a través de todos los pares clave-valor en el semantically_similar_wordsdiccionario. Cada clave del diccionario es una palabra. El valor correspondiente es una lista de todas las palabras semánticamente similares. Dado que encontramos las 5 palabras más similares para una lista de 6 palabras, es decir, «artificial», «inteligencia», «máquina», «red», «recurrente», «profunda», verá que habrá 30 elementos en la all_similar_wordslista.

    Luego, tenemos que encontrar los vectores de palabras para todas estas 30 palabras, y luego usar PCA para reducir las dimensiones de los vectores de palabras de 60 a 2. Luego podemos usar el pltmétodo, que es un alias del matplotlib.pyplotmétodo para trazar las palabras. en un espacio vectorial bidimensional.

    Ejecute el siguiente script para visualizar las palabras:

    word_vectors = ft_model.wv[all_similar_words]
    
    pca = PCA(n_components=2)
    
    p_comps = pca.fit_transform(word_vectors)
    word_names = all_similar_words
    
    plt.figure(figsize=(18, 10))
    plt.scatter(p_comps[:, 0], p_comps[:, 1], c="red")
    
    for word_names, x, y in zip(word_names, p_comps[:, 0], p_comps[:, 1]):
        plt.annotate(word_names, xy=(x+0.06, y+0.03), xytext=(0, 0), textcoords="offset points")
    

    La salida del script anterior se ve así:

    Puede ver que las palabras que aparecen juntas con frecuencia en el texto también están próximas entre sí en el plano bidimensional. Por ejemplo, las palabras «profundo» y «red» casi se superponen. Del mismo modo, las palabras «retroalimentación» y «retropropagación» también son muy parecidas.

    Ahora sabemos cómo crear incrustaciones de palabras usando FastText. En la siguiente sección, veremos cómo se puede utilizar FastText para tareas de clasificación de texto.

    FastText para clasificación de texto

    La clasificación de texto se refiere a clasificar los datos textuales en categorías predefinidas según el contenido del texto. El análisis de opiniones, la detección de spam y la detección de etiquetas son algunos de los ejemplos más comunes de casos de uso para la clasificación de texto.

    El módulo de clasificación de texto FastText solo se puede ejecutar a través de Linux u OSX. Si es un usuario de Windows, puede utilizar Google Colaboratory para ejecutar el módulo de clasificación de texto FastText. Todos los scripts de esta sección se han ejecutado con Google Colaboratory.

    El conjunto de datos

    El conjunto de datos de este artículo se puede descargar desde este enlace de Kaggle . El conjunto de datos contiene varios archivos, pero solo nos interesa el yelp_review.csvarchivo. El archivo contiene más de 5,2 millones de reseñas sobre diferentes negocios, incluidos restaurantes, bares, dentistas, médicos, salones de belleza, etc. Sin embargo, solo utilizaremos los primeros 50.000 registros para entrenar nuestro modelo debido a limitaciones de memoria. Puede probar con más registros si lo desea.

    Importemos las bibliotecas necesarias y carguemos el conjunto de datos:

    import pandas as pd
    import numpy as np
    
    yelp_reviews = pd.read_csv("/content/drive/My Drive/Colab Datasets/yelp_review_short.csv")
    
    bins = [0,2,5]
    review_names = ['negative', 'positive']
    
    yelp_reviews['reviews_score'] = pd.cut(yelp_reviews['stars'], bins, labels=review_names)
    
    yelp_reviews.head()
    

    En el script anterior cargamos el yelp_review_short.csvarchivo que contiene 50.000 reseñas con la pd.read_csvfunción.

    Simplificaremos nuestro problema convirtiendo los valores numéricos de las revisiones en categóricos. Esto se hará agregando una nueva columna reviews_score, a nuestro conjunto de datos. Si la reseña del usuario tiene un valor entre 1 y 2 en la Starscolumna (que califica a la empresa en una escala de 1 a 5), ​​la reviews_scorecolumna tendrá un valor de cadena negative. Si la calificación está entre 3-5 en la Starscolumna, la reviews_scorecolumna contendrá un valor positive. Esto hace que nuestro problema sea un problema de clasificación binaria.

    Finalmente, el encabezado del marco de datos se imprime como se muestra a continuación:

    Instalación de FastText

    El siguiente paso es importar modelos FastText, que se pueden importar usando el wgetcomando del repositorio de GitHub, como se muestra en el siguiente script:

    !wget https://github.com/facebookresearch/fastText/archive/v0.1.0.zip
    

    Nota : Si está ejecutando el comando anterior desde un terminal de Linux, no tiene que prefijar !el comando anterior. En el cuaderno de Google Colaboratory, cualquier comando posterior a !se ejecuta como un comando de shell y no dentro del intérprete de Python. Por lo tanto, todos los comandos que no son de Python tienen el prefijo !.

    Si ejecuta el script anterior y ve los siguientes resultados, eso significa que FastText se ha descargado correctamente:

    --2019-08-16 15:05:05--  https://github.com/facebookresearch/fastText/archive/v0.1.0.zip
    Resolving github.com (github.com)... 140.82.113.4
    Connecting to github.com (github.com)|140.82.113.4|:443... connected.
    HTTP request sent, awaiting response... 302 Found
    Location: https://codeload.github.com/facebookresearch/fastText/zip/v0.1.0 [following]
    --2019-08-16 15:05:05--  https://codeload.github.com/facebookresearch/fastText/zip/v0.1.0
    Resolving codeload.github.com (codeload.github.com)... 192.30.255.121
    Connecting to codeload.github.com (codeload.github.com)|192.30.255.121|:443... connected.
    HTTP request sent, awaiting response... 200 OK
    Length: unspecified [application/zip]
    Saving to: ‘v0.1.0.zip’
    
    v0.1.0.zip              [ <=>                ]  92.06K  --.-KB/s    in 0.03s
    
    2019-08-16 15:05:05 (3.26 MB/s) - ‘v0.1.0.zip’ saved [94267]
    

    El siguiente paso es descomprimir los módulos FastText. Simplemente escriba el siguiente comando:

    !unzip v0.1.0.zip
    

    A continuación, debe navegar al directorio donde descargó FastText y luego ejecutar el !makecomando para ejecutar los binarios de C ++. Ejecute los siguientes pasos:

    cd fastText-0.1.0
    !make
    

    Si ve el siguiente resultado, eso significa que FastText se instaló correctamente en su máquina.

    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/args.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/dictionary.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/productquantizer.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/matrix.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/qmatrix.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/vector.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/model.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/utils.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops -c src/fasttext.cc
    c++ -pthread -std=c++0x -O3 -funroll-loops args.o dictionary.o productquantizer.o matrix.o qmatrix.o vector.o model.o utils.o fasttext.o src/main.cc -o fasttext
    

    Para verificar la instalación, ejecute el siguiente comando:

    !./fasttext
    

    Debería ver que estos comandos son compatibles con FastText:

    usage: fasttext <command> <args>
    
    The commands supported by FastText are:
    
      supervised              train a supervised classifier
      quantize                quantize a model to reduce the memory usage
      test                    evaluate a supervised classifier
      predict                 predict most likely labels
      predict-prob            predict most likely labels with probabilities
      skipgram                train a skipgram model
      cbow                    train a cbow model
      print-word-vectors      print word vectors given a trained model
      print-sentence-vectors  print sentence vectors given a trained model
      nn                      query for nearest neighbors
      analogies               query for analogies
    

    Clasificación de texto

    Antes de entrenar los modelos FastText para realizar la clasificación de texto, es pertinente mencionar que FastText acepta datos en un formato especial, que es el siguiente:

    _label_tag This is sentence 1
    _label_tag2 This is sentence 2.
    

    Si miramos nuestro conjunto de datos, no está en el formato deseado. El texto con sentimiento positivo debería verse así:

    __label__positive burgers are very big portions here.
    

    Del mismo modo, las reseñas negativas deberían verse así:

    __label__negative They do not use organic ingredients, but I thi...
    

    La siguiente secuencia de comandos filtra las columnas reviews_scorey textdel conjunto de datos y luego los antepone a __label__todos los valores de la reviews_scorecolumna. Del mismo modo, ny tse reemplazan por un espacio en la textcolumna. Finalmente, el marco de datos actualizado se escribe en el disco en forma de yelp_reviews_updated.txt.

    import pandas as pd
    from io import StringIO
    import csv
    
    col = ['reviews_score', 'text']
    
    yelp_reviews = yelp_reviews[col]
    yelp_reviews['reviews_score']=['__label__'+ s for s in yelp_reviews['reviews_score']]
    yelp_reviews['text']= yelp_reviews['text'].replace('n',' ', regex=True).replace('t',' ', regex=True)
    yelp_reviews.to_csv(r'/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt', index=False, sep=' ', header=False, quoting=csv.QUOTE_NONE, quotechar="", escapechar=" ")
    

    yelp_reviewsImprimamos ahora el encabezado del marco de datos actualizado .

    yelp_reviews.head()
    

    Debería ver los siguientes resultados:

    reviews_score   text
    0   __label__positive   Super simple place but amazing nonetheless. It...
    1   __label__positive   Small unassuming place that changes their menu...
    2   __label__positive   Lester's is located in a beautiful neighborhoo...
    3   __label__positive   Love coming here. Yes the place always needs t...
    4   __label__positive   Had their chocolate almond croissant and it wa...
    

    Del mismo modo, la cola del marco de datos se ve así:

        reviews_score   text
    49995   __label__positive   This is an awesome consignment store! They hav...
    49996   __label__positive   Awesome laid back atmosphere with made-to-orde...
    49997   __label__positive   Today was my first appointment and I can hones...
    49998   __label__positive   I love this chic salon. They use the best prod...
    49999   __label__positive   This place is delicious. All their meats and s...
    

    Hemos convertido nuestro conjunto de datos en la forma requerida. El siguiente paso es dividir nuestros datos en conjuntos de prueba y de tren. Los datos del 80%, es decir, los primeros 40.000 registros de 50.000 registros se utilizarán para entrenar los datos, mientras que los datos del 20% (los últimos 10.000 registros) se utilizarán para evaluar el rendimiento del algoritmo.

    El siguiente script divide los datos en conjuntos de prueba y entrenamiento:

    !head -n 40000 "/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt"
    !tail -n 10000 "/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt"
    

    Una vez que se ejecuta el script anterior, yelp_reviews_train.txtse generará el archivo, que contiene los datos de entrenamiento. Del mismo modo, el yelp_reviews_test.txtarchivo recién generado contendrá datos de prueba.

    Ahora es el momento de entrenar nuestro algoritmo de clasificación de texto FastText.

    %%time
    !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt" -output model_yelp_reviews
    

    Para entrenar el algoritmo tenemos que usar el supervisedcomando y pasarle el archivo de entrada. El nombre del modelo se especifica después de la -outputpalabra clave. El script anterior dará como resultado un modelo de clasificación de texto entrenado llamado model_yelp_reviews.bin. Aquí está el resultado del script anterior:

    Read 4M words
    Number of words:  177864
    Number of labels: 2
    Progress: 100.0%  words/sec/thread: 2548017  lr: 0.000000  loss: 0.246120  eta: 0h0m
    CPU times: user 212 ms, sys: 48.6 ms, total: 261 ms
    Wall time: 15.6 s
    

    Puede echar un vistazo al modelo a través del !lscomando como se muestra a continuación:

    !ls
    

    Aquí está el resultado:

    args.o             Makefile         quantization-results.sh
    classification-example.sh  matrix.o         README.md
    classification-results.sh  model.o          src
    CONTRIBUTING.md        model_yelp_reviews.bin   tutorials
    dictionary.o           model_yelp_reviews.vec   utils.o
    eval.py            PATENTS          vector.o
    fasttext           pretrained-vectors.md    wikifil.pl
    fasttext.o         productquantizer.o       word-vector-example.sh
    get-wikimedia.sh       qmatrix.o            yelp_reviews_train.txt
    LICENSE            quantization-example.sh
    

    Puede verlo model_yelp_reviews.binen la lista de documentos anterior.

    Finalmente, para probar el modelo puedes usar el testcomando. Debe especificar el nombre del modelo y el archivo de prueba después del testcomando, como se muestra a continuación:

    !./fasttext test model_yelp_reviews.bin "/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt"
    

    La salida del script anterior se ve así:

    N   10000
    [email protected] 0.909
    [email protected] 0.909
    Number of examples: 10000
    

    Aquí se [email protected]refiere a la precisión y se [email protected]refiere al recuerdo. Puede ver que nuestro modelo alcanza una precisión y una recuperación de 0.909, lo cual es bastante bueno.

    Intentemos ahora limpiar nuestro texto de puntuaciones, caracteres especiales y convertirlo a minúsculas para mejorar la uniformidad del texto. El siguiente script limpia el tren:

    !cat "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt" | sed -e "s/([.!?,’/()])/ 1 /g" | tr "[:upper:]" "[:lower:]" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt"
    

    Y el siguiente script limpia el conjunto de prueba:

    "/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt" | sed -e "s/([.!?,’/()])/ 1 /g" | tr "[:upper:]" "[:lower:]" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_test_clean.txt"
    

    Ahora, entrenaremos el modelo en el conjunto de entrenamiento limpio:

    %%time
    !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt" -output model_yelp_reviews
    

    Y finalmente, usaremos el modelo entrenado en el conjunto de entrenamiento limpio para hacer predicciones sobre el conjunto de prueba limpio:

    !./fasttext test model_yelp_reviews.bin "/content/drive/My Drive/Colab Datasets/yelp_reviews_test_clean.txt"
    

    El resultado del script anterior es el siguiente:

    N   10000
    [email protected] 0.915
    [email protected] 0.915
    Number of examples: 10000
    

    Puede ver un ligero aumento tanto en la precisión como en la memoria. Para mejorar aún más el modelo, puede aumentar las épocas y la tasa de aprendizaje del modelo. El siguiente script establece el número de épocas en 30 y la tasa de aprendizaje en 0,5.

    %%time
    !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt" -output model_yelp_reviews -epoch 30 -lr 0.5
    

    Puede probar con diferentes números y ver si puede obtener mejores resultados. ¡No olvides compartir tus resultados en los comentarios!

    Conclusión

    Recientemente, se ha demostrado que el modelo FastText es el estado del arte para incrustaciones de palabras y tareas de clasificación de texto en muchos conjuntos de datos. Es muy fácil de usar y ultrarrápido en comparación con otros modelos de incrustación de palabras.

    En este artículo, exploramos brevemente cómo encontrar similitudes semánticas entre diferentes palabras creando incrustaciones de palabras usando FastText. La segunda parte del artículo explica cómo realizar la clasificación de texto a través de la biblioteca FastText.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *