fixed stupid bug

{

    "python.pythonPath": "/usr/local/opt/python/bin/python3.6",

    "python.linting.pylintEnabled": false,

    "python.linting.pylintEnabled": true,

    "python.linting.flake8Enabled": true,

    "python.linting.enabled": true,

    "python.linting.pylintArgs": [

Reader: inputPath /Users/rudolfchrispens/Documents/GIT/Show-and-tell/caption-lib/lstm/Readers/../Input_Data

Reader: outputPath /Users/rudolfchrispens/Documents/GIT/Show-and-tell/caption-lib/lstm/Readers/../Read_Data

Reader: modelPath /Users/rudolfchrispens/Documents/GIT/Show-and-tell/caption-lib/lstm/Readers/../Trained_Models

class basic_masa_reader:

    def read_input(self, filename: str):

        with tf.gfile.GFile(helper.inputPath + filename, "r") as f:

            if(config.reader.verbose is True):

                print("")

            return f.read().replace("\n", "<eos>").split()

        i = tf.train.range_input_producer(epoch_size, shuffle=False).dequeue()

        x = data[:, i * num_steps:(i + 1) * num_steps]

        x.set_shape([batch_size, num_steps])

        y = data[:, i * num_steps + 1: (i + 1) * num_steps + 1]

        y.set_shape([batch_size, num_steps])

        return x, y

from lstm.configuration import current as config

import lstm.Readers as reader

# yelp reviews

# Learning to generate  Product reviews from attributes

# Graham Neubig Tutorial Sequence tp Sequence Models

class masa_trainer:

    class Input(object):

        def __init__(self, batch_size, num_steps, data):

            self.epoch_size = ((len(data) // batch_size) - 1) // num_steps

            temp_reader = reader.basic_masa_reader()

            self.input_data, self.targets = temp_reader.batch_producer(data, batch_size, num_steps)

            print("x input_data:", self.input_data)

            print("y targets:", self.targets)

    # create the main model

    class Model(object):

        def __init__(self, input, is_training, hidden_size, vocab_size, num_layers,

        def __init__(self, _input, is_training, hidden_size, vocab_size, num_layers,

                    dropout=config.trainer.dropout, init_scale=config.trainer.init_scale):

            self.is_training = is_training

            self.input_obj = input

            self.batch_size = input.batch_size

            self.num_steps = input.num_steps

            self.input_obj = _input

            self.batch_size = _input.batch_size

            self.num_steps = _input.num_steps

            self.hidden_size = hidden_size

            # create the word embeddings

            if is_training and dropout < 1:

                inputs = tf.nn.dropout(inputs, dropout)

            # set up the state storage / extraction

            self.init_state = tf.placeholder(tf.float32, [num_layers, 2, self.batch_size, hidden_size])

            rnn_tuple_state = tuple([tf.contrib.rnn.LSTMStateTuple(state_per_layer_list[idx][0], state_per_layer_list[idx][1])for idx in range(num_layers)])

            # create an LSTM cell to be unrolled

            #print("Hidden size: ", hidden_size)

            cell = tf.contrib.rnn.LSTMCell(hidden_size, forget_bias=config.trainer.forget_bias)

            # add a dropout wrapper if training

            if is_training and dropout < 1:

            if num_layers > 1:

                cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_layers)], state_is_tuple=True)

            #print("input: ", input)

            output, self.state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32, initial_state=rnn_tuple_state)

            # reshape to (batch_size * num_steps, hidden_size)

            if not is_training:

                return

            self.learning_rate = tf.Variable(0.0, trainable=False)

            self.learning_rate = tf.Variable(0.01, trainable=False)

            tvars = tf.trainable_variables()

            grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), 5)

        def assign_lr(self, session, lr_value):

            session.run(self.lr_update, feed_dict={self.new_lr: lr_value})

    def train(self, train_data, vocabulary, num_layers, num_epochs, batch_size,

    def train(self, train_data, vocabulary_size, num_layers, num_epochs, batch_size,

            learning_rate=config.trainer.learning_rate, max_lr_epoch=10, lr_decay=0.93):

        # setup data and models

        training_input = self.Input(batch_size=batch_size, num_steps=config.trainer.num_steps, data=train_data)

        m = self.Model(training_input, is_training=True, hidden_size=config.trainer.hidden_size, vocab_size=vocabulary,

        m = self.Model(training_input, is_training=True, hidden_size=config.trainer.hidden_size, vocab_size=vocabulary_size,

                num_layers=num_layers)

        init_op = tf.global_variables_initializer()

                m.assign_lr(sess, learning_rate * new_lr_decay)

                current_state = np.zeros((num_layers, 2, batch_size, m.hidden_size))

                for step in range(training_input.epoch_size):

                    if step % 50 != 0:

                    if step % 10 != 0:

                        cost, _, current_state = sess.run([m.cost, m.train_op, m.state], feed_dict={m.init_state: current_state})

                    else:

                        cost, _, current_state, acc = sess.run([m.cost, m.train_op, m.state, m.accuracy], feed_dict={m.init_state: current_state})

                        print("Epoch {}, Step {}, cost: {:.3f}, accuracy: {:.3f}".format(epoch, step, cost, acc))

                        print()

                        print("Epoch {}, Step {}, cost: {:.3f}, accuracy: {:.3f}, learningrate: {:.3f}, epoch_stepsize: {:.3f}".format(epoch, step, cost, acc, m.learning_rate.eval(), training_input.epoch_size))

                # save a model checkpoint

                saver.save(sess, reader.helper.modelPath + config.path.model_trained, global_step=epoch)

            # do a final save

    read_test = "/ptb.test"

    # model state saves

    model_folder_path = "/Trained_Models"

    model_trained = "/2/trained_model"

    model_trained = "/3/trained_model"

    # model for validation

    model_for_validation = "/1/trained_model"

    init_scale = 0.05

    forget_bias = 1.0

    hidden_size = 650

    learning_rate = 0.1

    learning_rate = 0.2

"""

    # e.g. reader.input_train = "/train2"

    # e.g. validator.read_test = "/test1234"

    reader.reader_on = True

    reader.reader_on = False

    reader.verbose = False

    validator.validator_on = True

    validator.validator_on = False

    trainer.train_on = False

    trainer.verbose = True

    trainer.num_epochs = 15

    trainer.train_on = True

    trainer.verbose = False

    trainer.num_epochs = 3