Oi, habrozhiteli! O aprendizado por reforço é a área mais popular e promissora da inteligência artificial. O aprendizado prático de RL em Python ajudará você a dominar não apenas o básico, mas também os algoritmos avançados de aprendizado profundo com reforço. Este livro é destinado a desenvolvedores de MO e entusiastas de aprendizado profundo que estão interessados em inteligência artificial e desejam aprender o método de aprendizado por reforço. Leia este livro e torne-se um especialista em aprendizado reforçado, implementando exemplos práticos no trabalho ou fora dele. O conhecimento de álgebra linear, análise matemática e a linguagem de programação Python ajudará você a entender a lógica da apresentação.
Trecho. Gerando letras usando o LSTM RNN
Agora vamos ver como usar o LSTM para gerar letras de Zayn Malik. O conjunto de dados das letras de músicas de Zane pode ser baixado em
https://github.com/sudharsan13296/Hands-On-Reinforcement-Learning-With-Python/blob/master/07.%20Deep%20Learning%20Fundamentals/data/ZaynLyrics.txt .
O trabalho começa importando as bibliotecas necessárias:
import tensorflow as tf import numpy as np
Em seguida, o arquivo com a letra é lido:
with open("Zayn_Lyrics.txt","r") as f: data=f.read() data=data.replace('\n','') data = data.lower()
Verifique se os dados foram enviados com sucesso:
data[:50] "now i'm on the edge can't find my way it's inside "
Agora todos os caracteres são armazenados na variável all_chars:
all_chars=list(set(data))
O número de caracteres exclusivos é armazenado em unique_chars:
unique_chars = len(all_chars)
E o número total de caracteres é armazenado na variável total_chars:
total_chars =len(data)
Primeiro, atribuímos a cada caractere um índice. char_to_ix conterá o mapeamento do caractere para o índice e ix_to_char conterá o mapeamento do caractere para o índice:
char_to_ix = { ch:i for i,ch in enumerate(all_chars) } ix_to_char = { i:ch for i,ch in enumerate(all_chars) }
Um exemplo:
char_to_ix['e'] 9 ix_to_char[9] e
Em seguida, é definida a função generate_batch, que gera os valores de entrada e de destino. Os valores teóricos são iguais ao deslocamento do valor de entrada vezes i.
Por exemplo, se input = [12,13,24] com um valor de deslocamento de 1, os valores alvo serão [13,24]:
def generate_batch(seq_length,i): inputs = [char_to_ix[ch] for ch in data[i:i+seq_length]] targets = [char_to_ix[ch] for ch in data[i+1:i+seq_length+1]] inputs=np.array(inputs).reshape(seq_length,1) targets=np.array(targets).reshape(seq_length,1) return inputs,targets
Determinaremos a duração da sequência, a velocidade da aprendizagem e o número de nós, que é igual ao número de neurônios:
seq_length = 25 learning_rate = 0.1 num_nodes = 300
Crie o LSTM RNN. O TensorFlow fornece a função BasicLSTMCell () para a construção de células LSTM; você deve especificar o número de unidades na célula LSTM e o tipo de função de ativação usada.
Portanto, criamos a célula LSTM e construímos a rede RNN com essa célula usando a função tf.nn.dynamic_rnn (), que retorna a saída e o valor do estado:
def build_rnn(x): cell= tf.contrib.rnn.BasicLSTMCell(num_units=num_nodes, activation=tf.nn.relu) outputs, states = tf.nn.dynamic_rnn(cell, x, dtype=tf.float32) return outputs,states
Agora crie um substituto para a entrada X e o destino Y:
X=tf.placeholder(tf.float32,[None,1]) Y=tf.placeholder(tf.float32,[None,1])
Converta X e Y em int:
X=tf.cast(X,tf.int32) Y=tf.cast(Y,tf.int32)
Crie também visualizações onehot para X e Y:
X_onehot=tf.one_hot(X,unique_chars) Y_onehot=tf.one_hot(Y,unique_chars)
Obtenha as saídas e estados da RNN chamando a função build_rnn:
outputs,states=build_rnn(X_onehot)
Transponha a saída:
outputs=tf.transpose(outputs,perm=[1,0,2])
Inicializamos os pesos e compensações:
W=tf.Variable(tf.random_normal((num_nodes,unique_chars),stddev=0.001)) B=tf.Variable(tf.zeros((1,unique_chars)))
Calculamos a saída multiplicando a saída pelo peso e adicionando o deslocamento:
Ys=tf.matmul(outputs[0],W)+B
Agora vamos executar a ativação do softmax e obter as probabilidades:
prediction = tf.nn.softmax(Ys)
A perda de cross_entropy será calculada da seguinte maneira:
cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels =Y_onehot,logits=Ys))
Nosso objetivo é minimizar as perdas, para que possamos realizar a propagação de volta para a rede e realizar a descida gradiente:
optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cro ss_entropy)
Em seguida, será definida a previsão da função auxiliar, que fornecerá os índices do próximo símbolo previsto, de acordo com o modelo RNN:
def predict(seed,i): x=np.zeros((1,1)) x[0][0]= seed indices=[] for t in range(i): p=sess.run(prediction,{X:x}) index = np.random.choice(range(unique_chars), p=p.ravel()) x[0][0]=index indices.append(index) return indices
Em seguida, serão definidos o tamanho do pacote batch_size, o número de pacotes e o número de eras, bem como o valor do turno para gerar o pacote:
batch_size=100 total_batch=int(total_chars//batch_size) epochs=1000 shift=0
Por fim, criamos uma sessão TensorFlow e construímos um modelo:
init=tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for epoch in range(epoch): print("Epoch {}:".format(epoch)) if shift + batch_size+1 >= len(data): shift =0
Como você pode ver nos resultados, na era inicial, a saída consiste em caracteres aleatórios, mas conforme você aprende, os resultados melhoram:
Epoch 0: Iteration 0: wsadrpud,kpswkypeqawnlfyweudkgt,khdi nmgof' u vnvlmbis . snsblp,podwjqehb,e;g- 'fyqjsyeg,byjgyotsrdf;;u,ha;ik'sfc;dvtauofd.,q.;npsw'wjy-quw'quspfqw- . . . Epoch 113: Iteration 0: i wanna see you, yes, and she said yes!
Sobre o autor
Sudharsan Ravichandiran é especialista em processamento e análise de dados, um fervoroso fã de inteligência artificial e um blogueiro em vídeo. Ele se formou em ciência da computação pela Universidade de Anne e está envolvido em pesquisas sobre a implementação prática de aprendizado profundo e aprendizado reforçado, incluindo processamento de linguagem natural e visão computacional. Anteriormente trabalhou como web designer e desenvolvedor freelancer, participou da criação de vários sites premiados. Atualmente, ele participa de projetos de código aberto e frequentemente responde a perguntas no
Stack Overflow .
Sobre editores de ciências
Sujit Pal é diretor de pesquisa técnica da Elsevier Labs, a mais recente equipe de desenvolvimento de tecnologia do Reed-Elsevier Group. Ele está envolvido em pesquisas no campo da pesquisa semântica, processamento de linguagem natural, máquina e aprendizado profundo. Na Elsevier, ele trabalhou em vários projetos de iniciativa, incluindo avaliar e melhorar a qualidade da pesquisa, classificação de imagens e identificação duplicada, anotando e desenvolvendo antologias de textos médicos e científicos. Ele escreveu um livro de aprendizado profundo com Antonio Gulli e escreve sobre tecnologia em seu blog
Salmon Run .
Suriyadeepan Ramamoorthy é pesquisador e engenheiro de inteligência artificial do pesquisador e engenheiro de IA em Pondicherry (Índia). O assunto principal de seu trabalho é entender as línguas naturais e formar o raciocínio. Ele escreve extensivamente em um blog de aprendizado profundo. Na SAAMA Technologies, ele usa métodos avançados de aprendizado profundo para analisar textos biomédicos. Sendo um fervoroso defensor do software livre, ele participa ativamente de projetos para seu desenvolvimento na comunidade da FSFTN. Ele também está interessado em redes colaborativas, visualização de dados e programação criativa.
»Mais informações sobre o livro podem ser encontradas no
site do editor»
Conteúdo»
TrechoCupom de 25% de desconto para vendedores ambulantes -
PythonApós o pagamento da versão impressa do livro, um livro eletrônico é enviado por e-mail.