<jupyter_start><jupyter_text>SpaCySpaCy est une alternative à NLTK.<jupyter_code>import numpy as np
import pandas as pd
# pour ajouter des barres de progression sur les boucles
from tqdm import tqdm

import string
import matplotlib.pyplot as plt

from sklearn.decomposition import NMF, LatentDirichletAllocation, TruncatedSVD
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.manifold import TSNE

import concurrent.futures
import time
# des représentation graphiques
import pyLDAvis.sklearn

from pylab import bone, pcolor, colorbar, plot, show, rcParams, savefig
import warnings
warnings.filterwarnings('ignore')

%matplotlib inline
import os
#print(os.listdir("../input"))

# Dataviz avec plotly
from plotly import tools
import plotly.plotly as py
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import plotly.graph_objs as go
import plotly.figure_factory as ff

# import liés à spaCy
import spacy
from spacy.lang.en.stop_words import STOP_WORDS
from spacy.lang.en import English
# installation de en_core_web_lg
# English multi-task CNN trained on OntoNotes, with GloVe vectors trained on Common Crawl. 
# Assigns word vectors, context-specific token vectors, POS tags, dependency parse and named entities.
#!python -m spacy download en_core_web_lg
# chargement des données
wines = pd.read_csv('./data/winemag-data_first150k.csv.zip')
wines.head()
wines.shape
# création d'un objet SpaCy
nlp = spacy.load('en_core_web_lg')<jupyter_output><empty_output><jupyter_text>Reconnaissance d'entités nomméesLa reconnaissance d'entités nommées est une tâche d'extraction d'informations dans laquelle des entités nommées dans des phrases non structurées sont localisées et classées dans des catégories prédéfinies telles que les noms de personnes, les organisations, les lieux, les codes médicaux, les expressions de temps, les quantités, les valeurs monétaires, les pourcentages, etc.<jupyter_code>doc = nlp(wines["description"][3])
spacy.displacy.render(doc, style='ent',jupyter=True)
punctuations = string.punctuation
stopwords = list(STOP_WORDS)<jupyter_output><empty_output><jupyter_text>LemmatisationC'est le processus de regroupement des formes infléchies d'un mot afin qu'elles puissent être analysées comme un seul élément. Des mots tels que "run" et "running" sont convertis en "run" pour éviter que des mots ayant des significations similaires dans nos données.<jupyter_code>review = str(" ".join([i.lemma_ for i in doc]))
doc = nlp(review)
spacy.displacy.render(doc, style='ent',jupyter=True)<jupyter_output><empty_output><jupyter_text>Balisage (Parts of Speech tagging)C'est le processus qui consiste à marquer un mot dans un texte (corpus) comme correspondant à une partie particulière du discours, en fonction à la fois de sa définition et de son contexte, c’est-à-dire de sa relation avec les mots adjacents et liés dans une phrase, une phrase. , ou paragraphe. Une forme simplifiée de ceci est couramment enseignée aux enfants d’âge scolaire, dans l’identification des mots en tant que noms, verbes, adjectifs, adverbes, etc.<jupyter_code># POS tagging
for i in nlp(review):
    print(i,"=>",i.pos_)
# Parser for reviews
parser = English()
def spacy_tokenizer(sentence):
    mytokens = parser(sentence)
    mytokens = [ word.lemma_.lower().strip() if word.lemma_ != "-PRON-" else word.lower_ for word in mytokens ]
    mytokens = [ word for word in mytokens if word not in stopwords and word not in punctuations ]
    mytokens = " ".join([i for i in mytokens])
    return mytokens
tqdm.pandas()
wines["processed_description"] = wines["description"].progress_apply(spacy_tokenizer)
wines["processed_description"]<jupyter_output><empty_output><jupyter_text>Qu'est-ce que le  topic-modelling ?Dans l’apprentissage automatique et le traitement du langage naturel, un topic modeling est un type de modèle statistique permettant de découvrir les "sujets" abstraits qui apparaissent dans une collection de documents. La modélisation de sujets est un outil d'exploration de texte fréquemment utilisé pour la découverte de structures sémantiques cachées dans un corps de texte. Intuitivement, étant donné qu’un document porte sur un sujet particulier, on peut s’attendre à ce que des mots particuliers apparaissent plus ou moins fréquemment dans le document: "chien" et "os" apparaissent plus souvent dans les documents relatifs aux chiens, "chat" et "miaou" apparaîtra dans les documents sur les chats, et "le" et "est" apparaîtra également dans les deux. Un document concerne généralement plusieurs sujets dans des proportions différentes; ainsi, dans un document qui parle de 10% de chats et de 90% de chiens, il y aurait probablement environ 9 fois plus de mots de chien que de mots de chat.Les "sujets" produits par les techniques de modélisation de sujets sont des groupes de mots similaires. Un modèle de sujet capture cette intuition dans un cadre mathématique, ce qui permet d'examiner un ensemble de documents et de découvrir, sur la base de la statistique des mots de chaque mot, quels sont les sujets et quel est le solde des sujets de chaque document. Il implique diverses techniques de réduction de dimensionnalité (généralement non linéaire) et d’apprentissage non supervisé, telles que LDA, SVD, autoencodeurs, etc.<jupyter_code># Creating a vectorizer
vectorizer = CountVectorizer(min_df=5, max_df=0.9, stop_words='english', lowercase=True, token_pattern='[a-zA-Z\-][a-zA-Z\-]{2,}')
data_vectorized = vectorizer.fit_transform(wines["processed_description"])
NUM_TOPICS = 10
# Latent Dirichlet Allocation Model
lda = LatentDirichletAllocation(n_components=NUM_TOPICS, max_iter=10, learning_method='online',verbose=True)
data_lda = lda.fit_transform(data_vectorized)
# Non-Negative Matrix Factorization Model
nmf = NMF(n_components=NUM_TOPICS)
data_nmf = nmf.fit_transform(data_vectorized) 
# Latent Semantic Indexing Model using Truncated SVD
lsi = TruncatedSVD(n_components=NUM_TOPICS)
data_lsi = lsi.fit_transform(data_vectorized)
# Functions for printing keywords for each topic
def selected_topics(model, vectorizer, top_n=10):
    for idx, topic in enumerate(model.components_):
        print("Topic %d:" % (idx))
        print([(vectorizer.get_feature_names()[i], topic[i])
                        for i in topic.argsort()[:-top_n - 1:-1]]) 
# Keywords for topics clustered by Latent Dirichlet Allocation
print("LDA Model:")
selected_topics(lda, vectorizer)
# Keywords for topics clustered by Latent Semantic Indexing
print("NMF Model:")
selected_topics(nmf, vectorizer)
# Keywords for topics clustered by Non-Negative Matrix Factorization
print("LSI Model:")
selected_topics(lsi, vectorizer)
# Transforming an individual sentence
text = spacy_tokenizer("Aromas include tropical fruit, broom, brimstone and dried herb. The palate isn't overly expressive, offering unripened apple, citrus and dried sage alongside brisk acidity.")
x = lda.transform(vectorizer.transform([text]))[0]
print(x)<jupyter_output>[0.00500012 0.00500033 0.00500038 0.06546978 0.00500121 0.08337955
 0.19314925 0.00500002 0.45912628 0.17387309]<jupyter_text>Visualisation avec pyLDAvis<jupyter_code>pyLDAvis.enable_notebook()
dash = pyLDAvis.sklearn.prepare(lda, data_vectorized, vectorizer, mds='tsne')
dash<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07646978210223379, 'fraction_numerical': 0.015348773468548719, 'mean_word_length': 6.03082851637765, 'pattern_counts': {'":': 0, '<': 24, '<?xml version=': 0, '>': 25, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '634239', 'license': 'MIT', 'n_tokens_mistral': 2433, 'n_tokens_neox': 2319, 'n_words': 796, 'path': '08_nlp_avec_spacy.ipynb', 'repo_name': 'stat4decision/python-data-lbp-fev20', 'size': '7297'}