--- a/tests/test_logistic_regression.py	Mon Sep 04 12:37:45 2017 -0700
+++ b/tests/test_logistic_regression.py	Mon Sep 04 13:20:25 2017 -0700
@@ -59,7 +59,7 @@
         """test gradient descent method"""
 
         # test examples
-        w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
+        w, b, X, Y = (np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]]))
 
         params, grads, costs = logistic_regression.optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)
 
@@ -77,6 +77,14 @@
         self.compare_arrays(w_expected, params['w'])
         self.compare_arrays(dw_expected, grads['dw'])
 
+    def test_predict(self):
+
+        w, b, X, Y = (np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]]))
+
+        predictions = logistic_regression.predict(w, b, X)
+
+        assert predictions[0][0] == 1
+        assert predictions[0][1] == 1
 
 if __name__ == '__main__':
     unittest.main()

--- a/tvii/logistic_regression.py	Mon Sep 04 12:37:45 2017 -0700
+++ b/tvii/logistic_regression.py	Mon Sep 04 13:20:25 2017 -0700
@@ -136,3 +136,79 @@
     grads = {"dw": dw,
              "db": db}
     return params, grads, costs
+
+
+def predict(w, b, X):
+    '''
+    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)
+
+    Arguments:
+    w -- weights, a numpy array of size (num_px * num_px * 3, 1)
+    b -- bias, a scalar
+    X -- data of size (num_px * num_px * 3, number of examples)
+
+    Returns:
+    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X
+    '''
+
+    m = X.shape[1]
+    Y_prediction = np.zeros((1,m))
+    w = w.reshape(X.shape[0], 1)
+
+    # Compute vector "A" predicting the probabilities
+    A = sigmoid(np.dot(w.T, X) + b)
+
+    for i in range(A.shape[1]):
+        # Convert probabilities A[0,i] to actual predictions p[0,i]
+        Y_prediction[0][i] = 0 if A[0][i] <= 0.5 else 1
+
+    assert(Y_prediction.shape == (1, m))
+
+    return Y_prediction
+
+
+def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
+    """
+    Builds the logistic regression model by calling the function you've implemented previously
+
+    Arguments:
+    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
+    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
+    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
+    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
+    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters
+    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()
+    print_cost -- Set to true to print the cost every 100 iterations
+
+    Returns:
+    d -- dictionary containing information about the model.
+    """
+
+    # initialize parameters with zeros
+    raise NotImplementedError('TODO') # -> record TODO items
+    w, b = initialize_with_zeros(X_train.shape[0])
+
+    # Gradient descent
+    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost=print_cost)
+
+    # Retrieve parameters w and b from dictionary "parameters"
+    w = parameters["w"]
+    b = parameters["b"]
+
+    # Predict test/train set examples
+    Y_prediction_test = predict(w, b, X_test)
+    Y_prediction_train = predict(w, b, X_train)
+
+
+    # Print train/test Errors
+    print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
+    print("test accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
+
+    d = {"costs": costs,
+         "Y_prediction_test": Y_prediction_test,
+         "Y_prediction_train" : Y_prediction_train,
+         "w" : w,
+         "b" : b,
+         "learning_rate" : learning_rate,
+         "num_iterations": num_iterations}
+    return d