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»
Te puede interesar:Análisis de datos de la API con MongoDB, Seaborn y MatplotlibBusquemos 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.
Te puede interesar:Revisión del curso: Domine la entrevista de PythonEl 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.
Te puede interesar:Resolver problemas de secuencia con LSTM en Keras: Parte 2c++ -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:
Te puede interesar:Algoritmos de búsqueda en Python!./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.
