Introdução
Elon Musk se tornou uma sensação na internet nos últimos anos, com suas visões sobre o futuro, sua personalidade divertida e paixão por tecnologia. Agora todo mundo o conhece, Tanto como aquele tipo de carro elétrico ou como aquele cara que constrói lança-chamas. Ele é mais ativo em seu Twitter, onde você compartilha tudo, Até memes!
Ele inspira muitos jovens na indústria de TI, e eu queria fazer um pequeno projeto divertido, onde você criaria uma IA que geraria texto com base em suas postagens anteriores no Twitter. Eu queria resumir o estilo dela e ver que tipo de resultados estranhos ela obteria.
Preparação
Os dados que estou usando foram retirados diretamente do twitter de Elon Musk, tanto de suas postagens quanto de suas respostas. Você pode baixar o conjunto de dados neste Ligação.
Importando as bibliotecas:
importar tensorflow Como tf
a partir de tensorflow.keras.preprocessing.sequence importar pad_sequences
a partir de tensorflow.keras.layers importar Embedding, LSTM, Denso
a partir de tensorflow.keras.preprocessing.text importar Tokenizer
a partir de tensorflow.keras.models importar Sequencial
a partir de tensorflow.keras.optimizers importar Adão
importar entorpecido Como por exemplo
importar pandas Como pd
importar ré
Agora vou criar a função que irá remover todos os links, as hashtags, os rótulos e todas as coisas que irão confundir o modelo para que fiquemos com um texto limpo.
#importar os dados
data_path ="C:/Usuários / Dejan / Downloads / elonmusk.csv"
data = pd.read_csv(data_path)
#Função para limpar o texto
def clean_text(texto):
'' 'Fazer o texto em minúsculas, remova o texto entre colchetes,remover links,remover pontuação
e remova palavras que contenham números. '' '
text = text.lower()
#text = text.replace('%','')
text = re.sub('[.*?]', '', texto)
text = re.sub('https?://S +|www.S + ', '', texto)
text = re.sub('<.*?>+', '', texto)
#text = re.sub('[%s]' % re.escape(string.punctuation), '', texto)
text = re.sub('n', '', texto)
text = re.sub('w * dw *', '', texto)
text = " ".Junte(filtro(lambda x:x[0]!="@", text.split()))
Retorna texto
#Aplique a função
dados['texto'] = dados['texto'].Aplique(lambda x: clean_text(x))
dados = dados['texto']
Vamos definir um tokenizer e aplicá-lo ao texto. É assim que mapeamos todas as palavras em suas representações numéricas. Fazemos isso porque as redes neurais não aceitam strings. Se você é novo nisso, há uma ótima série no Youtube de Lawrence Moroney, que eu sugiro que você verifique abaixo:
tokenizer = Tokenizer() tokenizer.fit_on_texts(dados) total_words = len(tokenizer.word_index) + 1 imprimir(total_words) #5952input_sequences = [] para linha no dados: token_list = tokenizer.texts_to_sequences([linha])[0] para eu no faixa(1, len(token_list)): n_gram_sequence = token_list[:i +1] input_sequences.append(n_gram_sequence)
Agora teremos que definir max_length (todos os dados devem ser preenchidos com um comprimento fixo, como com convoluções), e também precisamos converter input_sequences em numpy array.
max_sequence_length = max([len(x) para x no input_sequences])
input_sequences = np.array(pad_sequences(input_sequences, maxlen = max_sequence_length, preenchimento = 'pré'))
Vamos criar sequências de dados, onde usaremos todos os elementos, exceto o último como nosso X, e o último elemento como o y, de nossos dados. O que mais, nosso e é uma representação única de total_words, que às vezes pode ser uma grande quantidade de dados (se total_words for 5952, isso significa que cada um e tem a forma (5952,))
# criar preditores e rótulo
xs, labels = input_sequences[:,:-1],input_sequences[:,-1]
ys = tf.keras.utils.to_categorical(rótulos, num_classes = total_words)
Modelo
Abaixo está a configuração do nosso modelo.
modelo = Sequencial() model.add(Embedding(total_words, 80, input_length = max_sequence_length-1)) model.add(LSTM(100, return_sequences = True)) model.add(LSTM(50)) model.add(tf.keras.layers.Dropout(0.1)) model.add(Denso(total_words /20)) model.add(Denso(total_words, ativação = 'softmax')) model.summary()Modelo: "sequential_1" _________________________________________________________________ Camada (modelo) Parâmetros de forma de saída # ========================================================== =============== embedding_1 (Embedding) (Nenhum, 56, 80) 476160 _________________________________________________________________ lstm_2 (LSTM) (Nenhum, 56, 100) 72400 _________________________________________________________________ lstm_3 (LSTM) (Nenhum, 50) 30200 _________________________________________________________________ dropout_1 (Cair fora) (Nenhum, 50) 0 _________________________________________________________________ denso_2 (Denso) (Nenhum, 297) 15147 _________________________________________________________________ denso_3 (Denso) (Nenhum, 5952) 1773696 ========================================================== =============== Params totais: 2,367,603 Parâmetros treináveis: 2,367,603 Params não treináveis: 0
Tentei alguns otimizadores e descobri que Adam funciona melhor para este exemplo. Vamos construir e executar o modelo:
model.compile(perda ="categorical_crossentropy",
otimizador ="Adão",
metrics =['precisão'])
history = model.fit(xs, sim, épocas =200, verbose =1)
#Saída
Época 196/200
1026/1026 [================================] - 12s 12ms / passo - perda: 0.7377 - precisão: 0.8031
Época 197/200
1026/1026 [================================] - 12s 12ms / passo - perda: 0.7363 - precisão: 0.8025
Época 198/200
1026/1026 [================================] - 12s 12ms / passo - perda: 0.7236 - precisão: 0.8073
Época 199/200
1026/1026 [================================] - 19s 18ms / passo - perda: 0.7147 - precisão: 0.8083
Época 200/200
1026/1026 [================================] - 12s 12ms / passo - perda: 0.7177 - precisão: 0.8070
Vamos criar um 'for loop', que irá gerar um novo texto, com base no seed_text e no número de palavras que definiremos. Esta parte do código pode parecer um pouco intimidante, mas depois de ler cada linha cuidadosamente, você verá que já fizemos algo semelhante antes.
para _ no faixa(next_words):
token_list = tokenizer.texts_to_sequences([seed_text])[0]
token_list = pad_sequences([token_list], maxlen = max_sequence_length - 1, preenchimento = 'pré')
predito = np.argmax(model.predict(token_list), eixo =-1)
output_word = ""
para palavra, índice no tokenizer.word_index.items():
E se índice == previsto:
output_word = word
pausa
seed_text + = " " + output_word
Agora é a hora de brincar com nosso modelo. Uau!
seed_text = "O espaço é grande"
next_words = 20
O espaço é uma grande fusão de gatos, muita civilização por spacex está fazendo alguns meses de dragão é intenso enquanto nós
seed_text = "eu penso em flores"
next_words = 30
Eu penso em flores que no futuro são limitadas, já que você poderia usar força bruta com tanques para a órbita da Terra baixa que é provavelmente mais rápida do que a temperatura líquida no ano que podemos ter
seed_text = "eu quero colonizar júpiter"
next_words = 40
Eu quero colonizar Júpiter sendo palavras apenas para zerar o futuro imediato, nem podemos prever com precisão quais problemas encontraremos em um nível de granulação fina de curto prazo com a casa com uma parte humana de nós
Resumo
O espaço é uma ótima combinação de gatos !? Quem saberia! Como você pode ver, os resultados que o modelo dá são bobos e não fazem muito sentido. Tal como acontece com todos os modelos de aprendizagem profunda, há muitas coisas que podem ser modificadas para gerar melhores resultados. Eu deixo para você.
