[PYTHON] Compétition Kaggle: réel ou pas? PNL avec tweets de catastrophe ~ EDA / prétraitement ~

Aperçu de l'article

Cet article est en deux parties.

・ Partie 1: EDA ・ Prétraitement ← Maintenant ici ・ Partie 2: Vectorisation / Modélisation (LSTM, BERT) (En construction, à venir!)

Étant donné que la deuxième partie utilise les données qui ont été prétraitées dans la première partie, Au bas de l'article, il y a ** du code qui peut exécuter le prétraitement dans un lot *, donc Si vous voulez sauter la première partie, veuillez l'exécuter et passez à la deuxième partie. ( Veuillez vous référer à cet article pour obtenir les données!)

Aperçu de la compétition

Kaggle : Real or Not? NLP with Disaster Tweets Il s'agit d'un concours d'introduction au traitement du langage naturel. La tâche est de classer les tweets en deux catégories: «tweets catastrophe» ou «tweets non catastrophiques».

Récemment, Twitter a été utilisé pour les demandes de sauvetage en cas de catastrophe, et il y a un intérêt croissant pour la surveillance automatique des tweets en cas de catastrophe dans les organisations de secours et les entreprises de télécommunications. Cependant, il est difficile de déterminer mécaniquement si un tweet représente réellement une catastrophe. En effet, par exemple, l'expression «brûler» qui exprime explicitement une catastrophe est parfois utilisée comme une expression métaphorique telle que «le ciel brûle». Dans ce concours, nous utiliserons un ensemble de données de 10 000 tweets pour créer un modèle d'apprentissage automatique qui prédit des «tweets de catastrophe» ou des «tweets de non-catastrophe».

Mains sur!

Utilisez le bloc-notes Jupyter pour poursuivre vos travaux pratiques.

0. Obtention de données

Kaggle : Real or Not? NLP with Disaster Tweets - Data De la page ci-dessus ・ Test.csv ・ Train.csv Téléchargez-en deux. Ensuite, placez ce fichier csv dans la même hiérarchie que le notebook à analyser.

Le contenu de chaque colonne du fichier csv est le suivant.

Les détails spécifiques et les informations sur les valeurs manquantes seront expliqués dans la section suivante. Le concours prédit la colonne cible de test.csv.

1. Chargez la bibliothèque

Prédéfinissez la bibliothèque à utiliser dans cette pratique.

#L'analyse des données
import pandas as pd
import numpy as np

#Visualisation
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

#Traitement du langage naturel
import string #symbole(punctuation)Obtenez une liste de
import re
import contractions #Abréviation du document
from wordcloud import STOPWORDS #Obtenez une liste de mots vides
from collections import defaultdict # n-Utilisé lors de la création d'un gramme

2. Vérifiez le contenu des données

Je souhaite vérifier immédiatement le contenu des données. Tout d'abord, lisez les données sous forme de trame de données. Affichez le nombre de lignes et de colonnes du bloc de données et essayez d'extraire 10 lignes au hasard.

#Lecture des données d'entraînement et des données de test
df_train = pd.read_csv('train.csv', dtype={'id': np.int16, 'target': np.int8})
df_test = pd.read_csv('test.csv', dtype={'id': np.int16})

#Afficher le nombre de lignes et de colonnes de données d'entraînement et de données de test
print('Training Set Shape = {}'.format(df_train.shape))
print('Test Set Shape = {}'.format(df_test.shape))

#Extraire aléatoirement 10 lignes des données d'entraînement
df_train.sample(n=10, random_state=28)

Une partie du résultat de l'exécution

Training Set Shape = (7613, 5)
Test Set Shape = (3263, 4)

Ci-dessous, la suite du résultat de l'exécution (contenu des lignes extraites aléatoirement)

Il peut y avoir une valeur manquante NaN '' dans les colonnes mot-clé '' et `` emplacement ''.

Je voudrais étudier les valeurs manquantes en détail.

#Calculez le taux de valeur manquante pour chaque colonne de données d'entraînement et de données de test
print("missing-value ratio of training data(%)")
print(df_train.isnull().sum()/df_train.shape[0]*100)
print("\nmissing-value ratio of test data(%)")
print(df_test.isnull().sum()/df_test.shape[0]*100)

Résultat d'exécution

missing-value ratio of training data(%)
id           0.000000
keyword      0.801261
location    33.272035
text         0.000000
target       0.000000
dtype: float64

missing-value ratio of test data(%)
id           0.000000
keyword      0.796813
location    33.864542
text         0.000000
dtype: float64

On peut voir que les valeurs manquantes sont de 0,8% pour mot-clé '' et de 33 à 34% pour emplacement '' à la fois dans les données d'entraînement et les données de test.

Ensuite, regardons la distribution de `` cible '' dans les données d'entraînement.

#Tracez les éléments cibles et leur nombre
target_vals = df_train.target.value_counts()
sns.barplot(target_vals.index, target_vals)
plt.gca().set_ylabel('samples')

Vous pouvez voir qu'il y a plus de tweets non-catastrophe = 0 '' que de tweets catastrophe = 1 '' dans l'ensemble de données.

Ensuite, je voudrais connaître le nombre d'éléments uniques dans chaque colonne de texte '', mot-clé '' et `` emplacement ''.

#Affiche le nombre d'éléments uniques dans le texte, le mot-clé, l'emplacement
print(f'Number of unique values in text = {df_train["text"].nunique()} (Training) - {df_test["text"].nunique()} (Test)')
print(f'Number of unique values in keyword = {df_train["keyword"].nunique()} (Training) - {df_test["keyword"].nunique()} (Test)')
print(f'Number of unique values in location = {df_train["location"].nunique()} (Training) - {df_test["location"].nunique()} (Test)')

Résultat d'exécution

Number of unique values in text = 7503 (Training) - 3243 (Test)
Number of unique values in keyword = 221 (Training) - 221 (Test)
Number of unique values in location = 3342 (Training) - 1603 (Test)

Vous pouvez voir que texte '' et emplacement '' sont des entrées libres. D'autre part, vous pouvez voir que mot-clé '' extrait automatiquement 221 mots-clés prédéfinis du texte ''.

3. Analyse des données explicatives (EDA)

Je voudrais faire un certain traitement pour comprendre les caractéristiques des données. Tout d'abord, je voudrais appréhender et comparer grossièrement les fonctionnalités du texte ''. Les fonctionnalités sont le nombre de mots '', le nombre de mots uniques '', le nombre de mots d'arrêt '', le nombre d'URL '', le nombre moyen de caractères de mots '', le nombre de caractères '' , Nombre de ponctuation () '', Nombre de balises de hachage '', Nombre de mentions ''. Un point à ajouter, la ponctuation () ici ne signifie pas la ponctuation, mais fait référence aux caractères ASCII autres que les caractères alphanumériques. En gros, ce n'est pas grave si vous avez une image comme le "symbole" défini dans string.punctuation. De plus, ces fonctionnalités sont combinées dans la trame de données en tant que méta-fonctionnalités. De plus, dans les données d'entraînement, tweet catastrophe = 1 '' ⇄ tweet autre que catastrophe = 0 '', données d'entraînement ⇄ données de test Comparez la distribution de 9 fonctionnalités. Étant donné que les tweets liés aux catastrophes, les tweets non liés aux catastrophes, les données d'entraînement et les données de test ont des scores de données différents. Lors de la visualisation de la distribution, l'estimation de la densité du noyau permet d'aligner les échelles et de comparer les distributions de manière intuitive. L'argument par défaut de distplot de la bibliothèque de visualisation seaborn est kde = True, mais cette fois nous décrirons explicitement kde = True.

#Nombre de mots
df_train['word_count'] = df_train['text'].apply(lambda x: len(str(x).split()))
df_test['word_count'] = df_test['text'].apply(lambda x: len(str(x).split()))

#Nombre unique de mots
df_train['unique_word_count'] = df_train['text'].apply(lambda x: len(set(str(x).split())))
df_test['unique_word_count'] = df_test['text'].apply(lambda x: len(set(str(x).split())))

#Nombre de mots vides
df_train['stop_word_count'] = df_train['text'].apply(lambda x: len([w for w in str(x).lower().split() if w in STOPWORDS]))
df_test['stop_word_count'] = df_test['text'].apply(lambda x: len([w for w in str(x).lower().split() if w in STOPWORDS]))

#Nombre d'URL
df_train['url_count'] = df_train['text'].apply(lambda x: len([w for w in str(x).lower().split() if 'http' in w or 'https' in w]))
df_test['url_count'] = df_test['text'].apply(lambda x: len([w for w in str(x).lower().split() if 'http' in w or 'https' in w]))

#Nombre moyen de caractères de mot
df_train['mean_word_length'] = df_train['text'].apply(lambda x: np.mean([len(w) for w in str(x).split()]))
df_test['mean_word_length'] = df_test['text'].apply(lambda x: np.mean([len(w) for w in str(x).split()]))

#nombre de mots
df_train['char_count'] = df_train['text'].apply(lambda x: len(str(x)))
df_test['char_count'] = df_test['text'].apply(lambda x: len(str(x)))

#Nombre de signes de ponctuation
df_train['punctuation_count'] = df_train['text'].apply(lambda x: len([c for c in str(x) if c in string.punctuation]))
df_test['punctuation_count'] = df_test['text'].apply(lambda x: len([c for c in str(x) if c in string.punctuation]))

#Nombre de balises de hachage
df_train['hashtag_count'] = df_train['text'].apply(lambda x: len([c for c in str(x) if c == '#']))
df_test['hashtag_count'] = df_test['text'].apply(lambda x: len([c for c in str(x) if c == '#']))

#Nombre de mentions
df_train['mention_count'] = df_train['text'].apply(lambda x: len([c for c in str(x) if c == '@']))
df_test['mention_count'] = df_test['text'].apply(lambda x: len([c for c in str(x) if c == '@']))

#Tweet catastrophe sur la distribution de 9 fonctionnalités=1 ⇄ Tweets autres que catastrophe=0, données d'entraînement ⇄ Comparer avec les données de test
METAFEATURES = ['word_count', 'unique_word_count', 'stop_word_count', 'url_count', 'mean_word_length',
                'char_count', 'punctuation_count', 'hashtag_count', 'mention_count']
DISASTER_TWEETS = df_train['target'] == 1

fig, axes = plt.subplots(ncols=2, nrows=len(METAFEATURES), figsize=(20, 50), dpi=100)

for i, feature in enumerate(METAFEATURES):
    #Tweet de catastrophe=1 ⇄ Tweets autres que catastrophe=Comparez la distribution de 0(Effectuer une estimation de la densité du noyau)
    sns.distplot(df_train.loc[~DISASTER_TWEETS][feature], label='Not Disaster', ax=axes[i][0], color='green', kde=True)
    sns.distplot(df_train.loc[DISASTER_TWEETS][feature], label='Disaster', ax=axes[i][0], color='red', kde=True)
    
    #Données d'entraînement ⇄ Comparez la distribution des données de test(Effectuer une estimation de la densité du noyau)
    sns.distplot(df_train[feature], label='Training', ax=axes[i][1], kde=True)
    sns.distplot(df_test[feature], label='Test', ax=axes[i][1], kde=True)

    for j in range(2):
        axes[i][j].set_xlabel('')
        axes[i][j].tick_params(axis='x', labelsize=12)
        axes[i][j].tick_params(axis='y', labelsize=12)
        axes[i][j].legend()

    axes[i][0].set_title(f'{feature} Target Distribution in Training Set', fontsize=13)
    axes[i][1].set_title(f'{feature} Training & Test Set Distribution', fontsize=13)

plt.show()

Vous pouvez voir qu'il n'y a pas de grande différence de distribution entre les tweets catastrophe '' et les tweets autres que catastrophe '', les données d'entraînement et les données de test. Vous pouvez voir que les tweets avec des URL, des hashtags et des mentions sont aussi bons ou meilleurs que les tweets sans eux. Comme il est fort possible que la notation telle que URL, balise de hachage, mention, etc. ne soit pas les informations nécessaires pour juger les tweets et tweets de catastrophe autres que les catastrophes, il peut être préférable de nettoyer avec un prétraitement.

Ensuite, découvrez lequel des mots mots clés '' apparaît le plus souvent dans les tweets de catastrophe et lesquels apparaissent le plus souvent dans les tweets non liés à une catastrophe. Puisque la cible '' des tweets de catastrophe est un entier 1 '' et que les tweets autres que les catastrophes sont des entiers 0 '', Prenez la valeur moyenne de cible '' pour chaque mot de mot-clé '', et si elle est proche de 1, les mots qui ont tendance à apparaître dans les tweets de catastrophe, S'il est proche de 0, vous pouvez voir que c'est un mot qui a tendance à apparaître dans les tweets autres que les catastrophes. Utilisez la méthode groupby '' de pandas pour trouver la valeur moyenne de cible '' pour chaque mot de `` mot-clé '' et ajoutez cette valeur à l'ensemble des données d'entraînement. Après cela, le nombre d'apparitions est tracé dans l'ordre du mot qui apparaît dans le tweet de la catastrophe.

#Trouvez la valeur moyenne de la cible pour chaque mot-clé et ajoutez cette valeur à l'ensemble des données d'entraînement
df_train['target_mean'] = df_train.groupby('keyword')['target'].transform('mean')

fig = plt.figure(figsize=(8, 72), dpi=100)

#Vérifiez la distribution de l'étiquette incluse dans le mot-clé
sns.countplot(y=df_train.sort_values(by='target_mean', ascending=False)['keyword'],
             hue=df_train.sort_values(by='target_mean', ascending=False)['target'])

plt.tick_params(axis='x', labelsize=15)
plt.tick_params(axis='y', labelsize=12)
plt.legend(loc=1)
plt.title('Target Distribution in Keywords')

plt.show()

#Supprimez la colonne de la valeur moyenne de la valeur cible car elle ne sera plus utilisée.
df_train.drop(columns=['target_mean'], inplace=True)

Le résultat de sortie est le suivant. Si vous affichez la distribution d'étiquettes entière de 221 mots dans cet article, elle sera verticalement longue. Les mots qui ont tendance à apparaître dans les tweets de catastrophe et les mots qui ont tendance à apparaître dans les tweets non liés à une catastrophe, Seul le haut de chacun est affiché (en fait, vous pouvez obtenir un diagramme de la distribution verticale des étiquettes).

La nomenclature des conditions spécifiques liées aux catastrophes, telles que les déraillements, les débris et les épaves, a tendance à apparaître dans les tweets de catastrophe. D'un autre côté, réplique (= réplique, après), sacs mortuaires (= sacs mortuaires), ruine (= ruine (nom), ruine (verbe)) sont des mots apparemment liés à une catastrophe, Il a tendance à ne pas apparaître dans les tweets de catastrophe. C'est probablement parce que c'est un mot qui est également utilisé comme expression métaphorique.

Ensuite, vérifiez les mots fréquemment utilisés par n-gramme. Cette fois, unigramme (n = 1), bigramme (n = 2), trigramme (n = 3) mots fréquemment utilisés, tweet de catastrophe = 1 '' ⇄ tweet de non-catastrophe = 0 '', respectivement. confirmer. Tout d'abord, définissez une fonction qui générera une liste de n grammes. Veuillez également consulter l 'article explicatif détaillé de la fonction qui génère la liste des n-grammes.

def generate_ngrams(text, n_gram=1):
    #Tokenize uniquement les mots qui ne figurent pas dans la liste des mots vides
    token = [token for token in text.lower().split(' ') if token != '' if token not in STOPWORDS]
    # n_Création de taples gramme, zip(*)Extrait les éléments avec le même index depuis le début de la liste.
    ngrams = zip(*[token[i:] for i in range(n_gram)])
    return [' '.join(ngram) for ngram in ngrams]

Ensuite, utilisez la fonction pour calculer l'unigramme (n = 1), le bigramme (n = 2), le trigramme (n = 3) et leur fréquence.

#Unigramme
disaster_unigrams = defaultdict(int)
nondisaster_unigrams = defaultdict(int)

# df_Créez un unigramme de tweets de catastrophe dans le train
for tweet in df_train[DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet):
        disaster_unigrams[word] += 1

# df_Créez un unigramme de tweets non catastrophiques dans le train.
for tweet in df_train[~DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet):
        nondisaster_unigrams[word] += 1

#Trier par fréquence d'occurrence
df_disaster_unigrams = pd.DataFrame(sorted(disaster_unigrams.items(), key=lambda x: x[1])[::-1])
df_nondisaster_unigrams = pd.DataFrame(sorted(nondisaster_unigrams.items(), key=lambda x: x[1])[::-1])

#Biggramme
disaster_bigrams = defaultdict(int)
nondisaster_bigrams = defaultdict(int)

for tweet in df_train[DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet, n_gram=2):
        disaster_bigrams[word] += 1
        
for tweet in df_train[~DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet, n_gram=2):
        nondisaster_bigrams[word] += 1
        
df_disaster_bigrams = pd.DataFrame(sorted(disaster_bigrams.items(), key=lambda x: x[1])[::-1])
df_nondisaster_bigrams = pd.DataFrame(sorted(nondisaster_bigrams.items(), key=lambda x: x[1])[::-1])

#Trigramme
disaster_trigrams = defaultdict(int)
nondisaster_trigrams = defaultdict(int)

for tweet in df_train[DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet, n_gram=3):
        disaster_trigrams[word] += 1
        
for tweet in df_train[~DISASTER_TWEETS]['text']:
    for word in generate_ngrams(tweet, n_gram=3):
        nondisaster_trigrams[word] += 1
        
df_disaster_trigrams = pd.DataFrame(sorted(disaster_trigrams.items(), key=lambda x: x[1])[::-1])
df_nondisaster_trigrams = pd.DataFrame(sorted(nondisaster_trigrams.items(), key=lambda x: x[1])[::-1])

Tout d'abord, examinons les 30 unigrammes les plus fréquents.

N = 30 #Afficher uniquement les 30 meilleurs unigrammes

fig, axes = plt.subplots(ncols=2, figsize=(15, 15), dpi=100)
plt.tight_layout()

sns.barplot(y=df_disaster_unigrams[0].values[:N], x=df_disaster_unigrams[1].values[:N], ax=axes[0], color='red')
sns.barplot(y=df_nondisaster_unigrams[0].values[:N], x=df_nondisaster_unigrams[1].values[:N], ax=axes[1], color='green')

for i in range(2):
    axes[i].spines['right'].set_visible(False)
    axes[i].set_xlabel('')
    axes[i].set_ylabel('')
    axes[i].tick_params(axis='x', labelsize=13)
    axes[i].tick_params(axis='y', labelsize=13)

axes[0].set_title(f'Top {N} most common unigrams in Disaster Tweets', fontsize=15)
axes[1].set_title(f'Top {N} most common unigrams in Non-disaster Tweets', fontsize=15)

plt.show()

Vous pouvez voir que la plupart des unigrammes les plus fréquents sont des symboles, des mots vides qui ne peuvent pas être supprimés et des chiffres, même pour les tweets de catastrophe et les tweets non-catastrophe. Ces unigrammes ne sont pas un critère de `` cible '' et doivent être supprimés avant la modélisation.

Vous pouvez également voir qu'Unigram, qui apparaît fréquemment dans les tweets de catastrophe, fournit des informations spécifiques sur la catastrophe. D'autre part, vous pouvez voir qu'il existe de nombreux verbes dans les unigrammes qui apparaissent fréquemment dans les tweets autres que les catastrophes. C'est probablement parce que dans les tweets non liés à une catastrophe, les utilisateurs ont tendance à tweeter sur eux-mêmes ou quelque chose.

Regardons également les bigrammes et les trigrammes.

#Biggramme
fig, axes = plt.subplots(ncols=2, figsize=(20, 15), dpi=100)
plt.subplots_adjust(wspace=0.4, hspace=0.6)

sns.barplot(y=df_disaster_bigrams[0].values[:N], x=df_disaster_bigrams[1].values[:N], ax=axes[0], color='red')
sns.barplot(y=df_nondisaster_bigrams[0].values[:N], x=df_nondisaster_bigrams[1].values[:N], ax=axes[1], color='green')

for i in range(2):
    axes[i].spines['right'].set_visible(False)
    axes[i].set_xlabel('')
    axes[i].set_ylabel('')
    axes[i].tick_params(axis='x', labelsize=20)
    axes[i].tick_params(axis='y', labelsize=20)

axes[0].set_title(f'Top {N} most common bigrams in Disaster Tweets', fontsize=20)
axes[1].set_title(f'Top {N} most common bigrams in Non-disaster Tweets', fontsize=20)

plt.show()

#Trigramme
fig, axes = plt.subplots(ncols=2, figsize=(20, 15), dpi=100)
plt.subplots_adjust(wspace=0.7, hspace=0.6)

sns.barplot(y=df_disaster_trigrams[0].values[:N], x=df_disaster_trigrams[1].values[:N], ax=axes[0], color='red')
sns.barplot(y=df_nondisaster_trigrams[0].values[:N], x=df_nondisaster_trigrams[1].values[:N], ax=axes[1], color='green')

for i in range(2):
    axes[i].spines['right'].set_visible(False)
    axes[i].set_xlabel('')
    axes[i].set_ylabel('')
    axes[i].tick_params(axis='x', labelsize=20)
    axes[i].tick_params(axis='y', labelsize=20)

axes[0].set_title(f'Top {N} most common trigrams in Disaster Tweets', fontsize=20)
axes[1].set_title(f'Top {N} most common trigrams in Non-disaster Tweets', fontsize=20)

plt.show()

On peut voir que les tweets de catastrophe contiennent beaucoup de contenu de catastrophe spécifique en commun avec le bigramme et le trigramme. Vous pouvez également voir que les tweets de catastrophe comportent rarement des symboles, des mots vides et des nombres trouvés dans Unigram. D'autre part, pour les tweets autres que les catastrophes, des délimiteurs et des mots vides apparaissent, et de nombreux mots tels que reddit et youtube apparaissent également.

4. Prétraitement des données

L'analyse exploratoire des données a montré que les tweets doivent être dépouillés des informations qui ne sont pas nécessaires pour construire le modèle. Avant de créer le modèle, un prétraitement est effectué sur les données d'entraînement et les données de test.

Tout d'abord, convertissez les mots abrégés tels que «je suis» et «nous» à la forme «je suis» et «nous avons». python fournit un module appelé contractions, avec `` contractions.fix (text) '' Vous pouvez restaurer l'abréviation dans sa forme d'origine.

def fix_contractions(text):
    return contractions.fix(text)

#Exemple de Tweet avant adaptation de fonction
print("tweet before contractions fix : ", df_train.iloc[1055]["text"])

#Appliquer la fonction
df_train['text']=df_train['text'].apply(lambda x : fix_contractions(x))
df_test['text']=df_test['text'].apply(lambda x : fix_contractions(x))

#Exemple de Tweet après application de la fonction
print("tweet after contractions fix : ", df_train.iloc[1055]["text"])

Résultat d'exécution

tweet before contractions fix :  @asymbina @tithenai I'm hampered by only liking cross-body bags. I really like Ella Vickers bags: machine washable. http://t.co/YsFYEahpVg
tweet after contractions fix :  @asymbina @tithenai I am hampered by only liking cross-body bags. I really like Ella Vickers bags: machine washable. http://t.co/YsFYEahpVg

Ensuite, supprimez uniquement l'URL des tweets contenant l'URL à l'aide d'expressions régulières.

def remove_URL(text):
    url = re.compile(r'https?://\S+|www\.\S+')
    return url.sub(r'',text)

#Exemple de Tweet avant adaptation de fonction
print("tweet before URL removal : ", df_train.iloc[1055]["text"])

#Appliquer la fonction
df_train['text']=df_train['text'].apply(lambda x : remove_URL(x))
df_test['text']=df_test['text'].apply(lambda x : remove_URL(x))

#Exemple de Tweet après application de la fonction
print("tweet after URL removal : ", df_train.iloc[1055]["text"])

Résultat d'exécution

tweet before URL removal :  @asymbina @tithenai I am hampered by only liking cross-body bags. I really like Ella Vickers bags: machine washable. http://t.co/YsFYEahpVg
tweet after URL removal :  @asymbina @tithenai I am hampered by only liking cross-body bags. I really like Ella Vickers bags: machine washable. 

Ensuite, je voudrais supprimer le symbole. Cela inclura # @! "$% & \ '() * +, -. /:; <=>? [\\] ^ _` {|} ~` `y compris les balises de hachage et les symboles de mention. Le symbole est supprimé. Une liste de symboles à supprimer peut être obtenue avec string.punctuation ''.

def remove_punct(text):
    table=str.maketrans('','',string.punctuation)
    return text.translate(table)

#Exemple de Tweet avant adaptation de fonction
print("tweet before punctuation removal : ", df_train.iloc[1055]["text"])

#Appliquer la fonction
df_train['text']=df_train['text'].apply(lambda x : remove_punct(x))
df_test['text']=df_test['text'].apply(lambda x : remove_punct(x))

#Exemple de Tweet après application de la fonction
print("tweet after punctuation removal : ", df_train.iloc[1055]["text"])

Résultat d'exécution

tweet before punctuation removal :  @asymbina @tithenai I am hampered by only liking cross-body bags. I really like Ella Vickers bags: machine washable. 
tweet after punctuation removal :  asymbina tithenai I am hampered by only liking crossbody bags I really like Ella Vickers bags machine washable 

Le corps du tweet a été nettoyé par les trois processus ci-dessus. À l'avenir, j'aimerais vectoriser et modéliser en utilisant le texte nettoyé!

Un article sur la vectorisation et la modélisation est en cours de rédaction! S'il vous plaît, attendez!

Cahier référencé

Cahier de concours mentionné (ou utilisé) dans cet article

・ Https://www.kaggle.com/gunesevitan/nlp-with-disaster-tweets-eda-cleaning-and-bert (EDA, prétraitement des données, vectorisation, BERT)

・ Https://www.kaggle.com/shahules/basic-eda-cleaning-and-glove (EDA, prétraitement des données, GloVe)

Pré-traitement à effectuer avant de passer au chapitre suivant

Veuillez passer au chapitre suivant avec le code suivant exécuté

#L'analyse des données
import pandas as pd
import numpy as np

#Visualisation
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

#Traitement du langage naturel
import string #symbole(punctuation)Obtenez une liste de
import re
import contractions #Abréviation du document
from wordcloud import STOPWORDS #Obtenez une liste de mots vides
from collections import defaultdict # n-Utilisé lors de la création d'un gramme

#Restauration abrégée
def fix_contractions(text):
    return contractions.fix(text)

#Supprimer l'URL
def remove_URL(text):
    url = re.compile(r'https?://\S+|www\.\S+')
    return url.sub(r'',text)

#Supprimer le symbole
def remove_punct(text):
    table=str.maketrans('','',string.punctuation)
    return text.translate(table)

#Appliquer la fonction
df_train['text']=df_train['text'].apply(lambda x : fix_contractions(x))
df_test['text']=df_test['text'].apply(lambda x : fix_contractions(x))

df_train['text']=df_train['text'].apply(lambda x : remove_URL(x))
df_test['text']=df_test['text'].apply(lambda x : remove_URL(x))

df_train['text']=df_train['text'].apply(lambda x : remove_punct(x))
df_test['text']=df_test['text'].apply(lambda x : remove_punct(x))