Updated more to v1.0

Author: nfmcclure

01_Introduction/05_Declaring_Operations/05_operations.py

@@ -37,7 +37,7 @@
 #print(sess.run(tf.equal(test_num, 3)))
 def custom_polynomial(x_val):
     # Return 3x^2 - x + 10
-    return(tf.sub(3 * tf.square(x_val), x_val) + 10)
+    return(tf.subtract(3 * tf.square(x_val), x_val) + 10)
 
 print(sess.run(custom_polynomial(11)))
 # What should we get with list comprehension

02_TensorFlow_Way/01_Operations_as_a_Computational_Graph/01_operations_on_a_graph.py

@@ -20,8 +20,8 @@
 for x_val in x_vals:
     print(sess.run(prod, feed_dict={x_data: x_val}))
 
-merged = tf.merge_all_summaries()
+merged = tf.summary.merge_all()
 if not os.path.exists('tensorboard_logs/'):
     os.makedirs('tensorboard_logs/')
 
-my_writer = tf.train.SummaryWriter('tensorboard_logs/', sess.graph)
+my_writer = tf.summary.FileWriter('tensorboard_logs/', sess.graph)

02_TensorFlow_Way/02_Layering_Nested_Operations/02_layering_nested_operations.py

@@ -1,41 +0,0 @@
-# Layering Nested Operations
-import matplotlib.pyplot as plt
-import numpy as np
-import tensorflow as tf
-import os
-from tensorflow.python.framework import ops
-ops.reset_default_graph()
-
-# Create graph
-sess = tf.Session()
-
-# Create tensors
-
-# Create data to feed in
-my_array = np.array([[1., 3., 5., 7., 9.],
-                   [-2., 0., 2., 4., 6.],
-                   [-6., -3., 0., 3., 6.]])
-x_vals = np.array([my_array, my_array + 1])
-x_data = tf.placeholder(tf.float32, shape=(3, 5))
-m1 = tf.constant([[1.],[0.],[-1.],[2.],[4.]])
-m2 = tf.constant([[2.]])
-a1 = tf.constant([[10.]])
-
-# 1st Operation Layer = Multiplication
-prod1 = tf.matmul(x_data, m1)
-
-# 2nd Operation Layer = Multiplication
-prod2 = tf.matmul(prod1, m2)
-
-# 3rd Operation Layer = Addition
-add1 = tf.add(prod2, a1)
-
-for x_val in x_vals:
-    print(sess.run(add1, feed_dict={x_data: x_val}))
-
-merged = tf.merge_all_summaries()
-
-if not os.path.exists('tensorboard_logs/')
-    os.makedirs('tensorboard_logs/')
-
-my_writer = tf.train.SummaryWriter('tensorboard_logs/', sess.graph)

02_TensorFlow_Way/03_Working_with_Multiple_Layers/03_multiple_layers.py

@@ -46,9 +46,9 @@ def custom_layer(input_matrix):
 # After custom operation, size is now 2x2 (squeezed out size 1 dims)
 print(sess.run(custom_layer1, feed_dict={x_data: x_val}))
 
-merged = tf.merge_all_summaries()
+merged = tf.summary.merge_all()
 
 if not os.path.exists('tensorboard_logs/'):
     os.makedirs('tensorboard_logs/')
 
-my_writer = tf.train.SummaryWriter('tensorboard_logs/', sess.graph)
+my_writer = tf.summary.FileWriter('tensorboard_logs/', sess.graph)

02_TensorFlow_Way/04_Implementing_Loss_Functions/04_loss_functions.py

@@ -67,7 +67,7 @@
 # L = -actual * (log(sigmoid(pred))) - (1-actual)(log(1-sigmoid(pred)))
 # or
 # L = max(actual, 0) - actual * pred + log(1 + exp(-abs(actual)))
-xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(x_vals, targets)
+xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_vals, labels=targets)
 xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)
 
 # Weighted (softmax) cross entropy loss
@@ -93,13 +93,13 @@
 # L = -actual * (log(softmax(pred))) - (1-actual)(log(1-softmax(pred)))
 unscaled_logits = tf.constant([[1., -3., 10.]])
 target_dist = tf.constant([[0.1, 0.02, 0.88]])
-softmax_xentropy = tf.nn.softmax_cross_entropy_with_logits(unscaled_logits, target_dist)
+softmax_xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=unscaled_logits, labels=target_dist)
 print(sess.run(softmax_xentropy))
 
 # Sparse entropy loss
 # Use when classes and targets have to be mutually exclusive
 # L = sum( -actual * log(pred) )
 unscaled_logits = tf.constant([[1., -3., 10.]])
 sparse_target_dist = tf.constant([2])
-sparse_xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(unscaled_logits, sparse_target_dist)
+sparse_xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=unscaled_logits, labels=sparse_target_dist)
 print(sess.run(sparse_xentropy))

02_TensorFlow_Way/05_Implementing_Back_Propagation/05_back_propagation.py

@@ -92,7 +92,7 @@
 sess.run(init)
 
 # Add classification loss (cross entropy)
-xentropy = tf.nn.sigmoid_cross_entropy_with_logits(my_output_expanded, y_target_expanded)
+xentropy = tf.nn.sigmoid_cross_entropy_with_logits(logits=my_output_expanded, labels=y_target_expanded)
 
 # Create Optimizer
 my_opt = tf.train.GradientDescentOptimizer(0.05)

02_TensorFlow_Way/07_Combining_Everything_Together/07_combining_everything_together.py

@@ -44,10 +44,10 @@
 # x1 - A*x2 + b
 my_mult = tf.matmul(x2_data, A)
 my_add = tf.add(my_mult, b)
-my_output = tf.sub(x1_data, my_add)
+my_output = tf.subtract(x1_data, my_add)
 
 # Add classification loss (cross entropy)
-xentropy = tf.nn.sigmoid_cross_entropy_with_logits(my_output, y_target)
+xentropy = tf.nn.sigmoid_cross_entropy_with_logits(logits=my_output, labels=y_target)
 
 # Create Optimizer
 my_opt = tf.train.GradientDescentOptimizer(0.05)

02_TensorFlow_Way/08_Evaluating_Models/08_evaluating_models.py

@@ -118,7 +118,7 @@
 my_output = tf.add(x_data, A)
 
 # Add classification loss (cross entropy)
-xentropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(my_output, y_target))
+xentropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=my_output, labels=y_target))
 
 # Create Optimizer
 my_opt = tf.train.GradientDescentOptimizer(0.05)

03_Linear_Regression/05_Implementing_Deming_Regression/05_deming_regression.py

@@ -40,7 +40,7 @@
 model_output = tf.add(tf.matmul(x_data, A), b)
 
 # Declare Demming loss function
-demming_numerator = tf.abs(tf.sub(y_target, tf.add(tf.matmul(x_data, A), b)))
+demming_numerator = tf.abs(tf.subtract(y_target, tf.add(tf.matmul(x_data, A), b)))
 demming_denominator = tf.sqrt(tf.add(tf.square(A),1))
 loss = tf.reduce_mean(tf.truediv(demming_numerator, demming_denominator))
 

03_Linear_Regression/08_Implementing_Logistic_Regression/08_logistic_regression.py

@@ -61,7 +61,7 @@ def normalize_cols(m):
 model_output = tf.add(tf.matmul(x_data, A), b)
 
 # Declare loss function (Cross Entropy loss)
-loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(model_output, y_target))
+loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target))
 
 # Declare optimizer
 my_opt = tf.train.GradientDescentOptimizer(0.01)

04_Support_Vector_Machines/02_Working_with_Linear_SVMs/02_linear_svm.py

@@ -49,7 +49,7 @@
 b = tf.Variable(tf.random_normal(shape=[1,1]))
 
 # Declare model operations
-model_output = tf.sub(tf.matmul(x_data, A), b)
+model_output = tf.subtract(tf.matmul(x_data, A), b)
 
 # Declare vector L2 'norm' function squared
 l2_norm = tf.reduce_sum(tf.square(A))
@@ -59,7 +59,7 @@
 # L2 regularization parameter, alpha
 alpha = tf.constant([0.01])
 # Margin term in loss
-classification_term = tf.reduce_mean(tf.maximum(0., tf.sub(1., tf.multiply(model_output, y_target))))
+classification_term = tf.reduce_mean(tf.maximum(0., tf.subtract(1., tf.multiply(model_output, y_target))))
 # Put terms together
 loss = tf.add(classification_term, tf.multiply(alpha, l2_norm))
 

04_Support_Vector_Machines/03_Reduction_to_Linear_Regression/03_support_vector_regression.py

@@ -53,7 +53,7 @@
 # 1/2 margin width parameter = epsilon
 epsilon = tf.constant([0.5])
 # Margin term in loss
-loss = tf.reduce_mean(tf.maximum(0., tf.sub(tf.abs(tf.sub(model_output, y_target)), epsilon)))
+loss = tf.reduce_mean(tf.maximum(0., tf.subtract(tf.abs(tf.subtract(model_output, y_target)), epsilon)))
 
 # Declare optimizer
 my_opt = tf.train.GradientDescentOptimizer(0.075)

04_Support_Vector_Machines/04_Working_with_Kernels/04_svm_kernels.py

@@ -47,16 +47,16 @@
 gamma = tf.constant(-50.0)
 dist = tf.reduce_sum(tf.square(x_data), 1)
 dist = tf.reshape(dist, [-1,1])
-sq_dists = tf.add(tf.sub(dist, tf.multiply(2., tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist))
-my_kernel = tf.exp(tf.mul(gamma, tf.abs(sq_dists)))
+sq_dists = tf.add(tf.subtract(dist, tf.multiply(2., tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist))
+my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists)))
 
 # Compute SVM Model
 model_output = tf.matmul(b, my_kernel)
 first_term = tf.reduce_sum(b)
 b_vec_cross = tf.matmul(tf.transpose(b), b)
 y_target_cross = tf.matmul(y_target, tf.transpose(y_target))
 second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross)))
-loss = tf.neg(tf.sub(first_term, second_term))
+loss = tf.negative(tf.subtract(first_term, second_term))
 
 # Create Prediction Kernel
 # Linear prediction kernel
@@ -65,7 +65,7 @@
 # Gaussian (RBF) prediction kernel
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1])
 rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid), 1),[-1,1])
-pred_sq_dist = tf.add(tf.sub(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
+pred_sq_dist = tf.add(tf.subtract(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
 pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist)))
 
 prediction_output = tf.matmul(tf.multiply(tf.transpose(y_target),b), pred_kernel)

04_Support_Vector_Machines/05_Implementing_Nonlinear_SVMs/05_nonlinear_svm.py

@@ -49,12 +49,12 @@
 b_vec_cross = tf.matmul(tf.transpose(b), b)
 y_target_cross = tf.matmul(y_target, tf.transpose(y_target))
 second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross)))
-loss = tf.neg(tf.sub(first_term, second_term))
+loss = tf.negative(tf.subtract(first_term, second_term))
 
 # Gaussian (RBF) prediction kernel
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1])
 rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid), 1),[-1,1])
-pred_sq_dist = tf.add(tf.sub(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
+pred_sq_dist = tf.add(tf.subtract(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
 pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist)))
 
 prediction_output = tf.matmul(tf.multiply(tf.transpose(y_target),b), pred_kernel)

04_Support_Vector_Machines/06_Implementing_Multiclass_SVMs/06_multiclass_svm.py

@@ -57,28 +57,28 @@
 gamma = tf.constant(-10.0)
 dist = tf.reduce_sum(tf.square(x_data), 1)
 dist = tf.reshape(dist, [-1,1])
-sq_dists = tf.add(tf.sub(dist, tf.multiply(2., tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist))
+sq_dists = tf.add(tf.subtract(dist, tf.multiply(2., tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist))
 my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists)))
 
 # Declare function to do reshape/batch multiplication
 def reshape_matmul(mat):
     v1 = tf.expand_dims(mat, 1)
     v2 = tf.reshape(v1, [3, batch_size, 1])
-    return(tf.batch_matmul(v2, v1))
+    return(tf.matmul(v2, v1))
 
 # Compute SVM Model
 model_output = tf.matmul(b, my_kernel)
 first_term = tf.reduce_sum(b)
 b_vec_cross = tf.matmul(tf.transpose(b), b)
 y_target_cross = reshape_matmul(y_target)
 
-second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.mul(b_vec_cross, y_target_cross)),[1,2])
-loss = tf.reduce_sum(tf.neg(tf.sub(first_term, second_term)))
+second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross)),[1,2])
+loss = tf.reduce_sum(tf.negative(tf.subtract(first_term, second_term)))
 
 # Gaussian (RBF) prediction kernel
 rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1])
 rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid), 1),[-1,1])
-pred_sq_dist = tf.add(tf.sub(rA, tf.mul(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
+pred_sq_dist = tf.add(tf.subtract(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB))
 pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist)))
 
 prediction_output = tf.matmul(tf.multiply(y_target,b), pred_kernel)

05_Nearest_Neighbor_Methods/02_Working_with_Nearest_Neighbors/02_nearest_neighbor.py

@@ -70,24 +70,24 @@
 
 # Declare distance metric
 # L1
-distance = tf.reduce_sum(tf.abs(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=2)
+distance = tf.reduce_sum(tf.abs(tf.subtract(x_data_train, tf.expand_dims(x_data_test,1))), axis=2)
 
 # L2
 #distance = tf.sqrt(tf.reduce_sum(tf.square(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=1))
 
 # Predict: Get min distance index (Nearest neighbor)
 #prediction = tf.arg_min(distance, 0)
-top_k_xvals, top_k_indices = tf.nn.top_k(tf.neg(distance), k=k)
+top_k_xvals, top_k_indices = tf.nn.top_k(tf.negative(distance), k=k)
 x_sums = tf.expand_dims(tf.reduce_sum(top_k_xvals, 1),1)
 x_sums_repeated = tf.matmul(x_sums,tf.ones([1, k], tf.float32))
 x_val_weights = tf.expand_dims(tf.div(top_k_xvals,x_sums_repeated), 1)
 
 top_k_yvals = tf.gather(y_target_train, top_k_indices)
-prediction = tf.squeeze(tf.batch_matmul(x_val_weights,top_k_yvals), squeeze_dims=[1])
+prediction = tf.squeeze(tf.matmul(x_val_weights,top_k_yvals), axis=[1])
 #prediction = tf.reduce_mean(top_k_yvals, 1)
 
 # Calculate MSE
-mse = tf.div(tf.reduce_sum(tf.square(tf.sub(prediction, y_target_test))), batch_size)
+mse = tf.div(tf.reduce_sum(tf.square(tf.subtract(prediction, y_target_test))), batch_size)
 
 # Calculate how many loops over training data
 num_loops = int(np.ceil(len(x_vals_test)/batch_size))

05_Nearest_Neighbor_Methods/04_Computing_with_Mixed_Distance_Functions/04_mixed_distance_functions_knn.py

@@ -71,22 +71,22 @@
 
 # Declare weighted distance metric
 # Weighted - L2 = sqrt((x-y)^T * A * (x-y))
-subtraction_term =  tf.sub(x_data_train, tf.expand_dims(x_data_test,1))
-first_product = tf.batch_matmul(subtraction_term, tf.tile(tf.expand_dims(weight_matrix,0), [batch_size,1,1]))
-second_product = tf.batch_matmul(first_product, tf.transpose(subtraction_term, perm=[0,2,1]))
+subtraction_term =  tf.subtract(x_data_train, tf.expand_dims(x_data_test,1))
+first_product = tf.matmul(subtraction_term, tf.tile(tf.expand_dims(weight_matrix,0), [batch_size,1,1]))
+second_product = tf.matmul(first_product, tf.transpose(subtraction_term, perm=[0,2,1]))
 distance = tf.sqrt(tf.batch_matrix_diag_part(second_product))
 
 # Predict: Get min distance index (Nearest neighbor)
-top_k_xvals, top_k_indices = tf.nn.top_k(tf.neg(distance), k=k)
+top_k_xvals, top_k_indices = tf.nn.top_k(tf.negative(distance), k=k)
 x_sums = tf.expand_dims(tf.reduce_sum(top_k_xvals, 1),1)
 x_sums_repeated = tf.matmul(x_sums,tf.ones([1, k], tf.float32))
 x_val_weights = tf.expand_dims(tf.div(top_k_xvals,x_sums_repeated), 1)
 
 top_k_yvals = tf.gather(y_target_train, top_k_indices)
-prediction = tf.squeeze(tf.batch_matmul(x_val_weights,top_k_yvals), squeeze_dims=[1])
+prediction = tf.squeeze(tf.matmul(x_val_weights,top_k_yvals), axis=[1])
 
 # Calculate MSE
-mse = tf.div(tf.reduce_sum(tf.square(tf.sub(prediction, y_target_test))), batch_size)
+mse = tf.div(tf.reduce_sum(tf.square(tf.subtract(prediction, y_target_test))), batch_size)
 
 # Calculate how many loops over training data
 num_loops = int(np.ceil(len(x_vals_test)/batch_size))

05_Nearest_Neighbor_Methods/05_An_Address_Matching_Example/05_address_matching.py

@@ -58,16 +58,16 @@ def create_typo(s, prob=0.75):
 ref_zip = tf.placeholder(shape=[None, n], dtype=tf.float32)
 
 # Declare Zip code distance for a test zip and reference set
-zip_dist = tf.square(tf.sub(ref_zip, test_zip))
+zip_dist = tf.square(tf.subtract(ref_zip, test_zip))
 
 # Declare Edit distance for address
 address_dist = tf.edit_distance(test_address, ref_address, normalize=True)
 
 # Create similarity scores
 zip_max = tf.gather(tf.squeeze(zip_dist), tf.argmax(zip_dist, 1))
 zip_min = tf.gather(tf.squeeze(zip_dist), tf.argmin(zip_dist, 1))
-zip_sim = tf.div(tf.sub(zip_max, zip_dist), tf.sub(zip_max, zip_min))
-address_sim = tf.sub(1., address_dist)
+zip_sim = tf.div(tf.subtract(zip_max, zip_dist), tf.subtract(zip_max, zip_min))
+address_sim = tf.subtract(1., address_dist)
 
 # Combine distance functions
 address_weight = 0.5

05_Nearest_Neighbor_Methods/06_Nearest_Neighbors_for_Image_Recognition/06_image_recognition.py

@@ -48,17 +48,17 @@
 
 # Declare distance metric
 # L1
-distance = tf.reduce_sum(tf.abs(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=2)
+distance = tf.reduce_sum(tf.abs(tf.subtract(x_data_train, tf.expand_dims(x_data_test,1))), axis=2)
 
 # L2
 #distance = tf.sqrt(tf.reduce_sum(tf.square(tf.sub(x_data_train, tf.expand_dims(x_data_test,1))), reduction_indices=1))
 
 # Predict: Get min distance index (Nearest neighbor)
-top_k_xvals, top_k_indices = tf.nn.top_k(tf.neg(distance), k=k)
+top_k_xvals, top_k_indices = tf.nn.top_k(tf.negative(distance), k=k)
 prediction_indices = tf.gather(y_target_train, top_k_indices)
 # Predict the mode category
-count_of_predictions = tf.reduce_sum(prediction_indices, reduction_indices=1)
-prediction = tf.argmax(count_of_predictions, dimension=1)
+count_of_predictions = tf.reduce_sum(prediction_indices, axis=1)
+prediction = tf.argmax(count_of_predictions, axis=1)
 
 # Calculate how many loops over training data
 num_loops = int(np.ceil(len(x_vals_test)/batch_size))

06_Neural_Networks/02_Implementing_an_Operational_Gate/02_gates.py

@@ -34,7 +34,7 @@
 
 # Declare the loss function as the difference between
 # the output and a target value, 50.
-loss = tf.square(tf.sub(multiplication, 50.))
+loss = tf.square(tf.subtract(multiplication, 50.))
 
 # Initialize variables
 init = tf.global_variables_initializer()
@@ -78,7 +78,7 @@
 
 # Declare the loss function as the difference between
 # the output and a target value, 50.
-loss = tf.square(tf.sub(two_gate, 50.))
+loss = tf.square(tf.subtract(two_gate, 50.))
 
 # Initialize variables
 init = tf.global_variables_initializer()

06_Neural_Networks/03_Working_with_Activation_Functions/03_activation_functions.py

@@ -35,8 +35,8 @@
 
 # Declare the loss function as the difference between
 # the output and a target value, 0.75.
-loss1 = tf.reduce_mean(tf.square(tf.sub(sigmoid_activation, 0.75)))
-loss2 = tf.reduce_mean(tf.square(tf.sub(relu_activation, 0.75)))
+loss1 = tf.reduce_mean(tf.square(tf.subtract(sigmoid_activation, 0.75)))
+loss2 = tf.reduce_mean(tf.square(tf.subtract(relu_activation, 0.75)))
 
 # Initialize variables
 init = tf.global_variables_initializer()