ML | Generating text using Gated Recurrent Unit Networks

from __ future__ import absolute_import, division,

print_function, unicode_literals

import numpy as np

import tensorflow as tf

from keras.models import Sequential

from keras.layers import Dense, Activation

from keras.layers import LSTM

from keras.optimizers import RMSprop

from keras.callbacks import LambdaCallback

from keras.callbacks import ModelCheckpoint

from keras .callbacks import ReduceLROnPlateau

import random

import sys

# Change workplace to text file location
cd C : UsersDevDesktopKagglePoems

 
# Read a text file into a string

with open ( ’ poems.txt’ , ’r’ ) as file :

text = file . read ()

 
# Text file preview

print (text)

# Storing all unique characters in the text

vocabulary = sorted ( list ( set (text)))

 
# Create dictionaries to map each character to an index

char_to_indices = dict ((c, i) for i, c in enumerate (vocabulary))

indices_to_char = dict ((i, c) for i, c in enumerate (vocabulary))

print (vocabulary)

# Dividing the text into subsequences of max_length
# So that at each step in time the characters are max_length
# submitted to the network

max_length = 100

steps = 5

sentences = []

next_chars = []

for i in range ( 0 , len (text) - max_length, steps):

sentences.append (text [i: i + max_length])

next_chars.append (text [i + max_length])

 
# Hot encoding each character into a boolean vector

 
# Initialize a matrix of booleans with each column representing
# hot coded character representation

X = np.zeros (( len (sentences), max_length, len (vocabulary)), dtype = np. bool )

y = np.zeros (( len (sentences), len (vocabulary)), dtype = np. bool )

 
# Putting the value 1 in the appropriate position for each vector
# end the hot coding process

for i, sentence in enumerate (sentences):

for t, char in enumerate (sentence):

X [i, t, char_to_indices [char]] = 1

y [i, char_to_indices [next_chars [i]]] = 1

# Initializing the LSTM network

model = Sequential ()

 
# Determine the cell type

model.add (GRU ( 128 , input_shape = (max_length, len (vocabulary))))

 
# Define a tightly coupled neural network layer

model.add (Dense ( len (vocabulary)))

 
# Define the activation function for the cell

model.add (Activation ( ’softmax’ ))

 
# Define the optimization function

optimizer = RMSprop (lr = 0.01 )

 
# Setting up the model for training

model. compile (loss = ’categorical_crossentropy’ , optimizer = optimizer)

# Helper function for fetching an index from an array of probabilities

def sample_index (preds, temperature = 1.0 ):

# temperature determines the freedom that a function has when generating text

# Convert a vector of predictions to a NumPy array

preds = np.asarray (preds) .astype ( ’float64’ )

  # Normalizing the predicate array

preds = np.log (preds) / temperature

  exp_preds = np.exp (preds)

preds = exp_preds / np. sum (exp_preds)

# Main sampling step. Creates an array of probabilities meaning

# the probability that each character will be next in

# generated text

probas = np.random.multinomial ( 1 , preds, 1 )

# Returning a character with the maximum likelihood of being the next character

  # in the generated text

return np.argmax (probas)

# Define a helper function to decrease the learning rate every time
# learning plateaus

reduce_alpha = ReduceLROnPlateau (monitor = ’ loss’ , factor = 0.2 ,

patience = 1 , min_lr = 0.001 )

callbacks = [print_callback, checkpoint, reduce_alpha]

# Train the GRU model

model.fit (X, y, batch_size = 128 , epochs = 30 , callbacks = callbacks)

def generate_text (length, diversity ):

# Get a random starting text

start_index = random.randint ( 0 , len (text) - max_length - 1 )

# Generated text definition

  generated = ’ ’

sentence = text [start_index: start_index + max_length]

generated + = sentence

# Generate new text of a given length

for i in range (length) :

  # Initialize the prediction vector

preds = model.predict (x_pred, verbose = 0 ) [ 0 ]

# Get the index of the next most likely index

next_index = sample_index (preds, diversity)

# Get the most likely next character using the rendered mapping

next_char = indices_to_char [next_index]

# Generate new text

code class = "undefined spaces">  x_pred = np.zeros ( ( 1 , max_length, len (vocabulary)))

for t, char in enumerate (sentence):

x_pred [ 0 , t, char_to_indices [char]] = 1.

# Making forecasts

preds = model.predict (x_pred, verbose =

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers

All questions