--- a
+++ b/backwardPropagation.py
@@ -0,0 +1,135 @@
+import pandas
+# from pattern.en import sentiment
+# import HTMLParser
+import re
+import pandas as pd
+import tensorflow as tf
+from collections import Counter
+from nltk.corpus import stopwords
+import string
+from collections import OrderedDict
+from nltk import bigrams
+from nltk.tokenize import word_tokenize
+import matplotlib.pyplot as plt
+import numpy as np
+# import plotly.plotly as py
+
+# import pandas as pd
+# import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import recall_score, precision_score, accuracy_score
+import math
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.metrics import confusion_matrix
+from sklearn.feature_selection import RFE
+from tensorflow.python.framework import ops
+import requests
+from bs4 import BeautifulSoup
+# import numpy as np
+# import matplotlib.pyplot as plt
+# from matplotlib import style
+# style.use("ggplot")
+import os
+
+from tf_utils import load_dataset, convert_to_one_hot,create_placeholders,initialize_parameters,forward_propagation,compute_cost,random_mini_batches
+
+
+def model(X_train, Y_train, X_test, Y_test, learning_rate=0.0001,
+          num_epochs=2000, minibatch_size=32, print_cost=True):
+    ops.reset_default_graph()  # to be able to rerun the model without overwriting tf variables
+    tf.set_random_seed(1)  # to keep consistent results
+    seed = 3  # to keep consistent results
+    (n_x, m) = X_train.shape  # (n_x: input size, m : number of examples in the train set)
+    n_y = Y_train.shape[0]  # n_y : output size
+    costs = []  # To keep track of the cost
+
+    # Create Placeholders of shape (n_x, n_y)
+
+    X, Y = create_placeholders(n_x, n_y)
+
+
+    # Initialize parameters
+
+    parameters = initialize_parameters()
+
+
+    # Forward propagation: Build the forward propagation in the tensorflow graph
+
+    Z3 = forward_propagation(X, parameters)
+
+
+    # Cost function: Add cost function to tensorflow graph
+
+    cost = compute_cost(Z3, Y)
+
+
+    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
+
+    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
+
+
+    # Initialize all the variables
+    init = tf.global_variables_initializer()
+
+    # Start the session to compute the tensorflow graph
+    with tf.Session() as sess:
+
+        # Run the initialization
+        sess.run(init)
+
+        # Do the training loop
+        for epoch in range(num_epochs):
+
+            epoch_cost = 0  # Defines a cost related to an epoch
+            num_minibatches = int(m / minibatch_size)
+            # number of minibatches of size minibatch_size in the train set
+
+            #print("Number of minibatch = " + str(num_minibatches))
+
+            minibatches = random_mini_batches(X_train, Y_train, minibatch_size)
+
+            for minibatch in minibatches:
+                # Select a minibatch
+                (minibatch_X, minibatch_Y) = minibatch
+
+                # IMPORTANT: The line that runs the graph on a minibatch.
+                # Run the session to execute the "optimizer" and the "cost", the feedict should contain a minibatch for (X,Y).
+                ### START CODE HERE ### (1 line)
+                _, minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})
+                #print("MinibatchCOst is " +str(minibatch_cost))
+                ### END CODE HERE ###
+
+                epoch_cost += minibatch_cost / num_minibatches
+
+            # Print the cost every epoch
+            if print_cost == True and epoch % 100 == 0:
+                print("Cost after epoch %i: %f" % (epoch, epoch_cost))
+            if print_cost == True and epoch % 5 == 0:
+                costs.append(epoch_cost)
+
+        # plot the cost
+        plt.plot(np.squeeze(costs))
+        plt.ylabel('cost')
+        plt.xlabel('iterations (per tens)')
+        plt.title("Learning rate =" + str(learning_rate))
+        plt.show()
+
+        # lets save the parameters in a variable
+        parameters = sess.run(parameters)
+        print("Parameters have been trained!")
+
+        # Calculate the correct predictions
+        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))
+
+        # Calculate accuracy on the test set
+        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
+
+        print("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
+        print("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))
+
+        return parameters
+
+