Comment traiter des données textuelles à l'aide de TF-IDF en Python

Les ordinateurs sont bons avec les nombres, mais pas tant avec les données textuelles. L'une des techniques les plus utilisées pour traiter les données textuelles est TF-IDF. Dans cet article, nous allons apprendre comment cela fonctionne et quelles sont ses fonctionnalités.

De notre intuition, nous pensons que les mots qui apparaissent le plus souvent devraient avoir un poids plus important dans l'analyse des données textuelles, mais ce n'est pas toujours le cas. Les mots tels que «le», «volonté» et «vous» - appelés mots vides - apparaissent le plus dans un corpus de texte, mais sont de très peu d'importance. Au lieu de cela, les mots qui sont rares sont ceux qui aident réellement à distinguer les données et qui ont plus de poids.

Une introduction à TF-IDF

TF-IDF signifie «Term Frequency - Inverse Data Frequency». Tout d'abord, nous allons apprendre ce que ce terme signifie mathématiquement.

Terme Fréquence (tf) : nous donne la fréquence du mot dans chaque document du corpus. C'est le rapport du nombre de fois où le mot apparaît dans un document par rapport au nombre total de mots dans ce document. Il augmente à mesure que le nombre d'occurrences de ce mot dans le document augmente. Chaque document a son propre tf.

Inverse Data Frequency (idf): utilisé pour calculer le poids des mots rares dans tous les documents du corpus. Les mots qui apparaissent rarement dans le corpus ont un score IDF élevé. Il est donné par l'équation ci-dessous.

En combinant ces deux éléments, nous obtenons le score TF-IDF (w) pour un mot dans un document du corpus. C'est le produit de tf et idf:

Prenons un exemple pour mieux comprendre.

Phrase 1: La voiture roule sur la route.

Phrase 2: Le camion roule sur l'autoroute.

Dans cet exemple, chaque phrase est un document distinct.

Nous allons maintenant calculer le TF-IDF pour les deux documents ci-dessus, qui représentent notre corpus.

À partir du tableau ci-dessus, nous pouvons voir que TF-IDF des mots communs était nul, ce qui montre qu'ils ne sont pas significatifs. En revanche, les TF-IDF de «voiture», «camion», «route» et «autoroute» sont non nulles. Ces mots ont plus de signification.

Utilisation de Python pour calculer TF-IDF

Permet maintenant de coder TF-IDF en Python à partir de zéro. Après cela, nous verrons comment nous pouvons utiliser sklearn pour automatiser le processus.

La fonction computeTFcalcule le score TF pour chaque mot du corpus, par document.

La fonction computeIDFcalcule le score IDF de chaque mot du corpus.

La fonction computeTFIDFci-dessous calcule le score TF-IDF pour chaque mot, en multipliant les scores TF et IDF.

La sortie produite par le code ci-dessus pour l'ensemble des documents D1 et D2 est la même que celle que nous avons calculée manuellement ci-dessus dans le tableau.

Vous pouvez vous référer à ce lien pour la mise en œuvre complète.

sklearn

Nous allons maintenant voir comment nous pouvons implémenter cela en utilisant sklearn en Python.

Tout d'abord, nous importerons TfidfVectorizerdepuis sklearn.feature_extraction.text:

Nous allons maintenant initialiser le vectorizer, puis appeler fit et le transformer pour calculer le score TF-IDF pour le texte.

Sous le capot, le sklearn fit_transform exécute les fonctions fit et transformsuivantes. Ceux-ci peuvent être trouvés dans la bibliothèque officielle sklearn sur GitHub.

 def fit(self, X, y=None): """Learn the idf vector (global term weights) Parameters ---------- X : sparse matrix, [n_samples, n_features] a matrix of term/token counts """ if not sp.issparse(X): X = sp.csc_matrix(X) if self.use_idf: n_samples, n_features = X.shape df = _document_frequency(X) # perform idf smoothing if required df += int(self.smooth_idf) n_samples += int(self.smooth_idf) # log+1 instead of log makes sure terms with zero idf don't get # suppressed entirely. idf = np.log(float(n_samples) / df) + 1.0 self._idf_diag = sp.spdiags(idf, diags=0, m=n_features, n=n_features, format="csr") return self def transform(self, X, copy=True): """Transform a count matrix to a tf or tf-idf representation Parameters ---------- X : sparse matrix, [n_samples, n_features] a matrix of term/token counts copy : boolean, default True Whether to copy X and operate on the copy or perform in-place operations. Returns ------- vectors : sparse matrix, [n_samples, n_features] """ if hasattr(X, 'dtype') and np.issubdtype(X.dtype, np.floating): # preserve float family dtype X = sp.csr_matrix(X, copy=copy) else: # convert counts or binary occurrences to floats X = sp.csr_matrix(X, dtype=np.float64, copy=copy) n_samples, n_features = X.shape if self.sublinear_tf: np.log(X.data, X.data) X.data += 1 if self.use_idf: check_is_fitted(self, '_idf_diag', 'idf vector is not fitted') expected_n_features = self._idf_diag.shape[0] if n_features != expected_n_features: raise ValueError("Input has n_features=%d while the model" " has been trained with n_features=%d" % ( n_features, expected_n_features)) # *= doesn't work X = X * self._idf_diag if self.norm: X = normalize(X, norm=self.norm, copy=False) return X

Une chose à noter dans le code ci-dessus est que, au lieu du journal de n_samples, 1 a été ajouté à n_samples pour calculer le score IDF. Cela garantit que les mots avec un score IDF de zéro ne sont pas entièrement supprimés.

La sortie obtenue est sous la forme d'une matrice asymétrique, qui est normalisée pour obtenir le résultat suivant.

Ainsi, nous avons vu comment coder facilement TF-IDF en seulement 4 lignes en utilisant sklearn. Nous comprenons maintenant à quel point TF-IDF est puissant en tant qu'outil pour traiter des données textuelles à partir d'un corpus. Pour en savoir plus sur sklearn TF-IDF, vous pouvez utiliser ce lien.

Bon codage!

Merci d'avoir lu cet article. Assurez-vous de le partager si vous le trouvez utile.

Pour en savoir plus sur la programmation, vous pouvez me suivre, afin d'être averti chaque fois que je crée un nouveau message.

À votre santé!

Also, Let’s get connected on Twitter, Linkedin, Github and Facebook.