introduction
Elon Musk est devenu une sensation sur Internet ces dernières années, avec leur vision de l'avenir, sa personnalité amusante et sa passion pour la technologie. Tout le monde le connaît maintenant, Soit comme ce type de voiture électrique, soit comme ce type qui fabrique des lance-flammes. Il est surtout actif sur son Twitter, où tu partages tout, Même les mèmes!
Il inspire de nombreux jeunes dans l'industrie informatique, et je voulais faire un petit projet amusant, où vous créeriez une IA qui générerait du texte basé sur vos précédents messages sur Twitter. Je voulais résumer son style et voir quel genre de résultats étranges elle obtiendrait.
préparation
Les données que j'utilise proviennent directement du twitter d'Elon Musk, à la fois de vos messages et de vos réponses. Vous pouvez télécharger l'ensemble de données dans ce Relier.
Importation des bibliothèques:
importer tensorflow comme tf
de tensorflow.keras.preprocessing.sequence importer pad_sequences
de tensorflow.keras.layers importer Intégration, LSTM, Dense
de tensorflow.keras.preprocessing.text importer Tokenizer
de tensorflow.keras.models importer Séquentiel
de tensorflow.keras.optimizers importer Adam
importer numpy comme par exemple
importer pandas comme pd
importer ré
Maintenant, je vais créer la fonction qui supprimera tous les liens, les hashtags, les étiquettes et toutes les choses qui vont embrouiller le modèle afin que nous nous retrouvions avec du texte propre.
#importer les données
chemin_données="C:/Utilisateurs/Dejan/Téléchargements/elonmusk.csv"
données = pd.read_csv(Chemin de données)
#Fonction pour nettoyer le texte
déf texte_propre(texte):
'''Mettre le texte en minuscule, supprimer le texte entre crochets,supprimer des liens,supprimer la ponctuation
et supprimez les mots contenant des chiffres.'''
texte = texte.inférieur()
#texte = texte.replace('%','')
texte = re.sub('[.*?]', '', texte)
texte = re.sub('https?://S+|www.S+', '', texte)
texte = re.sub('<.*?>+', '', texte)
#texte = re.sub('[%s]' % re.échapper(chaîne.ponctuation), '', texte)
texte = re.sub('m', '', texte)
texte = re.sub('w * dw *', '', texte)
texte = " ".rejoindre(filtre(lambda X:X[0]!="@", text.split()))
revenir texte
#Appliquer la fonction
Les données['texte'] = données['texte'].appliquer(lambda X: texte_propre(X))
données = données['texte']
Définissons un tokenizer et appliquons-le au texte. C'est ainsi que nous mappons tous les mots dans leurs représentations numériques. Nous le faisons parce que les réseaux de neurones ne peuvent pas accepter les chaînes. Si vous êtes nouveau, il y a une super série sur Youtube de Lawrence Moroney, que je vous propose de vérifier ci-dessous:
tokenizer = Tokenizer() tokenizer.fit_on_texts(Les données) total_mots = longueur(tokenizer.word_index) + 1 imprimer(total_mots) #5952input_sequences = [] pour ligne dans Les données: token_list = tokenizer.texts_to_sequences([ligne])[0] pour je dans gamme(1, longueur(token_list)): n_gram_sequence = token_list[:je+1] input_sequences.append(n_gram_sequence)
Maintenant, nous devrons définir max_length (toutes les données doivent être remplies à une longueur fixe, comme pour les circonvolutions), et nous devons également convertir input_sequences en tableau numpy.
max_sequence_length = max([longueur(X) pour X dans input_sequences])
input_sequences = np.array(pad_sequences(input_sequences, maxlen=max_sequence_length, padding='pré'))
Nous allons créer des séquences de données, où nous utiliserons tous les éléments sauf le dernier comme notre X, et le dernier élément comme y, de nos données. En outre, le nôtre et est une représentation unique de total_words, qui peut parfois être une grande quantité de données (si total_words est 5952, cela signifie que chacun et a la forme (5952,))
# créer des prédicteurs et étiqueter
xs, labels = input_sequences[:,:-1],input_sequences[:,-1]
ys = tf.keras.utils.to_categorical(Étiquettes, num_classes=total_mots)
Modèle
Ci-dessous la configuration de notre modèle.
modèle = Séquentiel() model.ajouter(Intégration(total_mots, 80, input_length=max_sequence_length-1)) model.ajouter(LSTM(100, return_sequences=Vrai)) model.ajouter(LSTM(50)) model.ajouter(tf.keras.layers.Dropout(0.1)) model.ajouter(Dense(total_mots/20)) model.ajouter(Dense(total_mots, activation='softmax')) modèle.résumé()Modèle: "séquentiel_1" _________________________________________________________________ Couche (taper) Paramètre de forme de sortie # ================================================== ================ incorporation_1 (Intégration) (Rien, 56, 80) 476160 _________________________________________________________________ lstm_2 (LSTM) (Rien, 56, 100) 72400 _________________________________________________________________ lstm_3 (LSTM) (Rien, 50) 30200 _________________________________________________________________ abandon_1 (Abandonner) (Rien, 50) 0 _________________________________________________________________ dense_2 (Dense) (Rien, 297) 15147 _________________________________________________________________ dense_3 (Dense) (Rien, 5952) 1773696 ================================================== ================ Paramètres totaux: 2,367,603 Paramètres entraînables: 2,367,603 Paramètres non entraînables: 0
J'ai essayé quelques optimiseurs et j'ai trouvé qu'Adam fonctionne mieux pour cet exemple. Construisons et exécutons le modèle:
modèle.compile(perte ="catégorique_crossentropie",
optimiseur="Adam",
métriques=['précision'])
histoire = model.fit(xs, oui, époques=200, verbeux=1)
#Sortir
Époque 196/200
1026/1026 [===============================] - 12s 12ms/pas - perte: 0.7377 - précision: 0.8031
Époque 197/200
1026/1026 [===============================] - 12s 12ms/pas - perte: 0.7363 - précision: 0.8025
Époque 198/200
1026/1026 [===============================] - 12s 12ms/pas - perte: 0.7236 - précision: 0.8073
Époque 199/200
1026/1026 [===============================] - 19s 18ms/pas - perte: 0.7147 - précision: 0.8083
Époque 200/200
1026/1026 [===============================] - 12s 12ms/pas - perte: 0.7177 - précision: 0.8070
Créons une "boucle for", qui va générer un nouveau texte, basé sur seed_text et le nombre de mots que nous allons définir. Cette partie du code peut sembler un peu intimidante, mais une fois que vous avez lu attentivement chaque ligne, vous verrez que nous avons déjà fait quelque chose de similaire avant.
pour _ dans gamme(mots_suivants):
token_list = tokenizer.texts_to_sequences([semence_texte])[0]
token_list = pad_sequences([token_list], maxlen=max_sequence_length - 1, padding='pré')
prédit = np.argmax(model.predict(token_list), axe=-1)
mot_sortie = ""
pour mot, indice dans tokenizer.word_index.items():
si indice == prédit:
output_word = mot
Pause
seed_text += " " + mot_de_sortie
C'est le moment de jouer avec notre modèle. Wow!
semence_texte = "L'espace est grand"
mots_suivants = 20
L'espace est un grand amalgame de chats beaucoup de civilisation par spacex fait quelques mois de dragon est intense comme nous
semence_texte = "je pense aux fleurs"
mots_suivants = 30
Je pense aux fleurs qu'à l'avenir, elles sont limitées car vous pourriez les forcer brutalement avec des pétroliers en orbite terrestre basse qui est probablement plus rapide que la température du liquide dans l'année que nous pouvons avoir
semence_texte = "je veux coloniser Jupiter"
mots_suivants = 40
Je veux coloniser Jupiter, les mots doivent juste être dans l'ordre de zéro avenir immédiat et nous ne pouvons pas nous-mêmes prédire avec précision les problèmes que nous rencontrerons à court terme à un niveau granulaire dans la maison avec une partie humaine de nous
résumé
L'espace est une excellente combinaison de chats !? Qui aurait su! Comme tu peux le voir, les résultats que donne le modèle sont idiots et n'ont pas beaucoup de sens. Comme avec tous les modèles d'apprentissage en profondeur, il y a beaucoup de choses qui pourraient être modifiées pour générer de meilleurs résultats. Je te le laisse.
