import math

import numpy as np

import h5py

import matplotlib.pyplot as plt

import tensorflow as tf

import scipy

from PIL import Image

from scipy import ndimage

from tensorflow.python.framework import ops

from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict

get_ipython().magic('matplotlib inline')

np.random.seed(1)

# **Exercise**: Compute $WX + b$ where $W, X$, and $b$ are drawn from a random normal distribution. W is of shape (4, 3), X is (3,1) and b is (4,1). As an example, here is how you would define a constant X that has shape (3,1):

# ```python

# X = tf.constant(np.random.randn(3,1), name = "X")

#

# You might find the following functions helpful:

# - tf.matmul(..., ...) to do a matrix multiplication

# - tf.add(..., ...) to do an addition

# - np.random.randn(...) to initialize randomly

# ### 1.2 - Computing the sigmoid

# - `tf.placeholder(tf.float32, name = "...")`

# - `tf.sigmoid(...)`

# - `sess.run(..., feed_dict = {x: z})`

#

def sigmoid(z):

return result

# ### 1.3 - Computing the Cost

#

# You can also use a built-in function to compute the cost of your neural network. So instead of needing to write code to compute this as a function of $a^{[2](i)}$ and $y^{(i)}$ for i=1...m:

# $$ J = - \frac{1}{m} \sum_{i = 1}^m \large ( \small y^{(i)} \log a^{ [2] (i)} + (1-y^{(i)})\log (1-a^{ [2] (i)} )\large )\small\tag{2}$$

#

# you can do it in one line of code in tensorflow!

#

# **Exercise**: Implement the cross entropy loss. The function you will use is:

#

#

# - `tf.nn.sigmoid_cross_entropy_with_logits(logits = ..., labels = ...)`

#

#

# $$- \frac{1}{m} \sum_{i = 1}^m \large ( \small y^{(i)} \log \sigma(z^{[2](i)}) + (1-y^{(i)})\log (1-\sigma(z^{[2](i)})\large )\small\tag{2}$$

#

#

def cost(logits, labels):

return cost

# ### 1.4 - Using One Hot encodings

#

# - tf.one_hot(labels, depth, axis)

#

# **Exercise:** Implement the function below to take one vector of labels and the total number of classes $C$, and return the one hot encoding. Use `tf.one_hot()` to do this.

def one_hot_matrix(labels, C):

return one_hot

# - tf.ones(shape)

def ones(shape):

return ones

# # 2 - Building your first neural network in tensorflow

# Loading the dataset

X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

def create_placeholders(n_x, n_y):

return X, Y

# **Exercise:** Implement the function below to initialize the parameters in tensorflow. You are going use Xavier Initialization for weights and Zero Initialization for biases. The shapes are given below. As an example, to help you, for W1 and b1 you could use:

# W1 = tf.get_variable("W1", [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1))

# b1 = tf.get_variable("b1", [25,1], initializer = tf.zeros_initializer())

# ```

def initialize_parameters():

return parameters

# You will now implement the forward propagation module in tensorflow. The function will take in a dictionary of parameters and it will complete the forward pass. The functions you will be using are:

#

# - `tf.add(...,...)` to do an addition

# - `tf.matmul(...,...)` to do a matrix multiplication

# - `tf.nn.relu(...)` to apply the ReLU activation

#

def forward_propagation(X, parameters):

return Z3

# ### 2.4 Compute cost

#

# As seen before, it is very easy to compute the cost using:

# ```python

# tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = ..., labels = ...))

# ```

# **Question**: Implement the cost function below.

# - It is important to know that the "`logits`" and "`labels`" inputs of `tf.nn.softmax_cross_entropy_with_logits` are expected to be of shape (number of examples, num_classes). We have thus transposed Z3 and Y for you.

# - Besides, `tf.reduce_mean` basically does the summation over the examples.

def compute_cost(Z3, Y):

return cost

#

# For instance, for gradient descent the optimizer would be:

# ```python

# optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)

# ```

#

# To make the optimization you would do:

# ```python

# _ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})

# ```

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,

return parameters

parameters = model(X_train, Y_train, X_test, Y_test)

my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T

my_image_prediction = predict(my_image, parameters)