Recurrent Neural Network (RNN) - Long short-term memory (LSTM)
! wget http: // www.manythings.org / anki / fra - eng.zip
! unzip -q fra-eng.zip -d /content/french-eng
In [1]:
--2020-02-04 06:43:40-- http://www.manythings.org/anki/fra-eng.zip (http://www.manythings.org/anki/fra-eng.zip)
Resolving www.manythings.org (www.manythings.org). 104.24.109.196,
104.24.108.196, 2606:4700:3037::6818:6cc4, ...
Connecting to www.manythings.org (www.manythings.org)|104.24.109.196
|:80. connected.
HTTP request sent, awaiting response... 200 OK Length: 5939832 (5.7M) [application/zip] Saving to: ‘fra-eng.zip’
fra-eng.zip 100%[===================>] 5.66M 7.67MB/s i
n 0.7s
2020-02-04 06:43:41 (7.67 MB/s) - ‘fra-eng.zip’ saved [5939832/593983
2]
error: -fn or any combination of -c, -l, -p, -t, -u and -v options i nvalid
UnZip 6.00 of 20 April 2009, by Debian. Original by Info-ZIP.
Usage: unzip [-Z] [-opts[modifiers]] file[.zip] [list] [-x xlist] [-d exdir]
Default action is to extract files in list, except those in xlist, to exdir;
file[.zip] may be a wildcard. -Z => ZipInfo mode ("unzip -Z" for u sage).
-p extract files to pipe, no messages -l list files (short fo rmat)
-f freshen existing files, create none -t test compressed arch ive data
-u update files, create if necessary -z display archive comm ent only
-v list verbosely/show version info -T timestamp archive to latest
-x exclude files that follow (in xlist) -d extract files into e xdir
modifiers:
-n never overwrite existing files -q quiet mode (-qq => q uieter)
-o overwrite files WITHOUT prompting -a auto-convert any tex t files
-j junk paths (do not make directories) -aa treat ALL files as t ext
-U use escapes for all non-ASCII Unicode -UU ignore any Unicode f ields
-C match filenames case-insensitively -L make (some) names lo wercase
-X restore UID/GID info -V retain VMS version n umbers
-K keep setuid/setgid/tacky permissions -M pipe through "more" pager
-O CHARSET specify a character encoding for DOS, Windows and OS/2 archives
-I CHARSET specify a character encoding for UNIX and other archive
s
See "unzip -hh" or unzip.txt for more help. Examples:
unzip data1 -x joe => extract all files except joe from zipfile d ata1.zip
unzip -p foo | more => send contents of foo.zip via pipe into prog ram more
unzip -fo foo ReadMe => quietly replace existing ReadMe if archive file newer
#importing libraries
from future import print_function
from keras.models import Model
from keras.layers import Input, LSTM, Dense
import numpy as np
In [2]:
Using TensorFlow backend.
The default version of TensorFlow in Colab will soon switch to TensorFlow 2.x.
We recommend you upgrade ( https://www.tensorflow.org/guide/migrate) now or ensure your notebook will continue to use TensorFlow 1.x via the %tensorflow_version 1.x magic: more info ( https://colab.research.google.com/notebooks/tensorflow_version.ipynb).
batch_s = 64 # Batch size for training.
epochs = 100 # Number of epochs to train for.
latent_dimension = 256 # Latent dimensionality of the encoding space.
number_samples = 10000 # Number of samples to train on. # Path to the data txt file on disk.
data_path = '/content/french-eng/fra.txt'
In [0]:
In [0]:
# Vectorize the data. input_texts = [] target_texts = [] input_characters = set() target_characters = set()
with open(data_path, 'r', encoding='utf-8') as f: lines = f.read().split('\n')
for line in lines[: min(number_samples, len(lines) - 1)]: input_text, target_text, _ = line.split('\t')
# We use "tab" as the "start sequence" character
# for the targets, and "\n" as "end sequence" character. target_text = '\t' + target_text + '\n' input_texts.append(input_text) target_texts.append(target_text)
for char in input_text:
if char not in input_characters: input_characters.add(char)
for char in target_text:
if char not in target_characters: target_characters.add(char)
input_characters = sorted(list(input_characters)) target_characters = sorted( list(target_characters)) num_encoder_tokens = len(input_characters) num_decoder_tokens = len(target_characters)
max_encoder_seq_length = max([len(txt) for txt in input_texts]) max_decoder_seq_length = max([len(txt) for txt in target_texts])
print('Number of samples:', len(input_texts)) print( 'Number of unique input tokens:', num_encoder_tokens)
print('Number of unique output tokens:', num_decoder_tokens) print( 'Max sequence length for inputs:', max_encoder_seq_length) print('Max sequence length for outputs:', max_decoder_seq_length)
In [8]:
Number of samples: 10000
Number of unique input tokens: 70 Number of unique output tokens: 93 Max sequence length for inputs: 16 Max sequence length for outputs: 59
input_token_index = dict(
[(char, i) for i, char in enumerate(input_characters)]) target_token_index = dict(
[(char, i) for i, char in enumerate(target_characters)])
In [0]:
encoder_input_data = np.zeros(
(len(input_texts), max_encoder_seq_length, num_encoder_tokens), dtype='float32')
decoder_input_data = np.zeros(
(len(input_texts), max_decoder_seq_length, num_decoder_tokens), dtype='float32')
decoder_target_data = np.zeros(
(len(input_texts), max_decoder_seq_length, num_decoder_tokens), dtype='float32')
In [0]:
In [0]:
for i, (input_text, target_text) in enumerate(zip(input_texts, target_
for t, char in enumerate(input_text): encoder_input_data[i, t, input_token_index[char]] = 1.
encoder_input_data[i, t + 1:, input_token_index[' ']] = 1.
for t, char in enumerate(target_text):
# decoder_target_data is ahead of decoder_input_data by one ti
decoder_input_data[i, t, target_token_index[char]] = 1.
if t > 0:
# decoder_target_data will be ahead by one timestep # and will not include the start character.
decoder_target_data[i, t - 1, target_token_index[char]] = decoder_input_data[i, t + 1:, target_token_index[' ']] = 1. decoder_target_data[i, t:, target_token_index[' ']] = 1.
# Define an input sequence and process it. encoder_inputs = Input(shape=(None, num_encoder_tokens)) encoder = LSTM(latent_dimension, return_state=True)
encoder_outputs, state_h, state_c = encoder(encoder_inputs) # We discard `encoder_outputs` and only keep the states. encoder_states = [state_h, state_c]
In [12]:
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/ backend/tensorflow_backend.py:66: The name tf.get_default_graph is de precated. Please use tf.compat.v1.get_default_graph instead.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/ backend/tensorflow_backend.py:541: The name tf.placeholder is depreca ted. Please use tf.compat.v1.placeholder instead.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/keras/ backend/tensorflow_backend.py:4432: The name tf.random_uniform is dep recated. Please use tf.random.uniform instead.
# Set up the decoder, using `encoder_states` as initial state.
decoder_inputs = Input(shape=(None, num_decoder_tokens)) # We set up our decoder to return full output sequences, # and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inferen decoder_lstm = LSTM(latent_dimension, return_sequences=True, return_st decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
initial_state=encoder_states) decoder_dense = Dense(num_decoder_tokens, activation='softmax') decoder_outputs = decoder_dense(decoder_outputs)
In [0]:
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_dat
model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
In [0]:
# Run training
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics =['accuracy'])
model.fit([encoder_input_data, decoder_input_data], decoder_target_dat batch_size=batch_s,
epochs=epochs, validation_split=0.2)
In [16]:
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tens orflow_core/python/ops/math_grad.py:1424: where (from tensorflow.py thon.ops.array_ops) is deprecated and will be removed in a future v ersion.
Instructions for updating:
Use tf.where in 2.0, which has the same broadcast rule as np.where WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/kera s/backend/tensorflow_backend.py:1033: The name tf.assign_add is dep recated. Please use tf.compat.v1.assign_add instead.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/kera s/backend/tensorflow_backend.py:1020: The name tf.assign is depreca ted. Please use tf.compat.v1.assign instead.
WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/kera s/backend/tensorflow_backend.py:3005: The name tf.Session is deprec ated. Please use tf.compat.v1.Session instead.
Train on 8000 samples, validate on 2000 samples
# Save model
model.save('seq2seq.h5')
In [0]:
# Next: inference mode (sampling). # Here's the drill:
# 1) encode input and retrieve initial decoder state # 2) run one step of decoder with this initial state # and a "start of sequence" token as target.
# Output will be the next target token
# 3) Repeat with the current target token and current states
# Define sampling models
encoder_model = Model(encoder_inputs, encoder_states)
decoder_state_input_h = Input(shape=(latent_dim,)) decoder_state_input_c = Input(shape=(latent_dim,)) decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] decoder_outputs, state_h, state_c = decoder_lstm(
decoder_inputs, initial_state=decoder_states_inputs) decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_outputs) decoder_model = Model(
[decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states)
In [0]:
# Reverse-lookup token index to decode sequences back to # something readable.
reverse_input_char_index = dict(
(i, char) for char, i in input_token_index.items()) reverse_target_char_index = dict(
(i, char) for char, i in target_token_index.items())
In [0]:
In [0]:
def decode_sequence(input_seq):
# Encode the input as state vectors.
states_value = encoder_model.predict(input_seq)
# Generate empty target sequence of length 1.
target_seq = np.zeros((1, 1, num_decoder_tokens))
# Populate the first character of target sequence with the start c
target_seq[0, 0, target_token_index['\t']] = 1.
# Sampling loop for a batch of sequences
# (to simplify, here we assume a batch of size 1).
stop_condition = False decoded_sentence = '' while not stop_condition:
output_tokens, h, c = decoder_model.predict( [target_seq] + states_value)
# Sample a token
sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_char = reverse_target_char_index[sampled_token_index] decoded_sentence += sampled_char
# Exit condition: either hit max length # or find stop character.
if (sampled_char == '\n' or
len(decoded_sentence) > max_decoder_seq_length): stop_condition = True
# Update the target sequence (of length 1). target_seq = np.zeros((1, 1, num_decoder_tokens)) target_seq[ 0, 0, sampled_token_index] = 1.
# Update states
states_value = [h, c]
return decoded_sentence
-
Input sentence: Go. Decoded sentence: Va !
-
Input sentence: Hi. Decoded sentence: Salut !
-
Input sentence: Hi. Decoded sentence: Salut !
-
Input sentence: Run! Decoded sentence: Courez !
-
Input sentence: Run! Decoded sentence: Courez !
for seq_index in range(100):
# Take one sequence (part of the training set) # for trying out decoding.
input_seq = encoder_input_data[seq_index: seq_index + 1] decoded_sentence = decode_sequence(input_seq)
print('-')
print('Input sentence:', input_texts[seq_index]) print( 'Decoded sentence:', decoded_sentence)
In [22]:
In [0]: