Cleanup and PEP8

app.py

@@ -1,46 +1,33 @@
 import random
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+import numpy
 import tensorflow
 from tensorflow.python.framework.ops import disable_eager_execution
-import pandas as pd
 import math
 
-
+# Becuase important
 disable_eager_execution()
 
-load_data = np.load('data/train_test_split_data.npz')  # Data saved by the VAE
+# Load the training and testing data
+load_data = numpy.load('data/train_test_split_data.npz')  # Data saved by the VAE
 
 # Convert Data to Tuples and Assign to respective variables
 box_matrix_train, box_density_train, additional_pixels_train, box_shape_train = tuple(load_data['box_matrix_train']), tuple(load_data['box_density_train']), tuple(load_data['additional_pixels_train']), tuple(load_data['box_shape_train'])
 box_matrix_test, box_density_test, additional_pixels_test, box_shape_test = tuple(load_data['box_matrix_test']), tuple(load_data['box_density_test']), tuple(load_data['additional_pixels_test']), tuple(load_data['box_shape_test'])
 testX = box_matrix_test  # Shows the relationship to the MNIST Dataset vs the Shape Dataset
-image_size = np.shape(testX)[-1]  # Determines the size of the images
-test_data = np.reshape(testX, (len(testX), image_size, image_size, 1))
+image_size = numpy.shape(testX)[-1]  # Determines the size of the images
+test_data = numpy.reshape(testX, (len(testX), image_size, image_size, 1))
 
 # Creates tuples that contain all of the data generated
-allX = np.append(box_matrix_train,box_matrix_test, axis=0)
-all_box_density = np.append(box_density_train, box_density_test, axis=0)
-all_additional_pixels = np.append(additional_pixels_train, additional_pixels_test,axis=0)
-all_box_shape = np.append(box_shape_train, box_shape_test,axis=0)
-all_data = np.reshape(allX, (len(allX), image_size, image_size, 1))
-
-# train_latent_points = []
-# train_data = np.reshape(box_matrix_train, (len(box_matrix_train), image_size, image_size, 1))
-# for i in range(len(box_shape_train)):
-#     predicted_train = encoder_model_boxes.predict(np.array([train_data[i]]))
-#     train_latent_points.append(predicted_train[0])
-# train_latent_points = np.array(train_latent_points)
-
-shapes = ("basic_box", "diagonal_box_split", "horizontal_vertical_box_split", "back_slash_box", "forward_slash_box",
-          "back_slash_plus_box", "forward_slash_plus_box", "hot_dog_box", "hamburger_box", "x_hamburger_box",
-          "x_hot_dog_box", "x_plus_box")
+allX = numpy.append(box_matrix_train,box_matrix_test, axis=0)
+all_box_density = numpy.append(box_density_train, box_density_test, axis=0)
+all_additional_pixels = numpy.append(additional_pixels_train, additional_pixels_test,axis=0)
+all_box_shape = numpy.append(box_shape_train, box_shape_test,axis=0)
+all_data = numpy.reshape(allX, (len(allX), image_size, image_size, 1))
 
 import math
 
 def basic_box_array(image_size):
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     # Creates the outside edges of the box
     for i in range(image_size):
         for j in range(image_size):
@@ -48,8 +35,9 @@ def basic_box_array(image_size):
                 A[i][j] = 1
     return A
 
+
 def back_slash_array(image_size):
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for i in range(image_size):
         for j in range(image_size):
             if i == j:
@@ -57,7 +45,7 @@ def back_slash_array(image_size):
     return A
 
 def forward_slash_array(image_size):
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for i in range(image_size):
         for j in range(image_size):
             if i == (image_size-1)-j:
@@ -66,7 +54,7 @@ def forward_slash_array(image_size):
 
 def hot_dog_array(image_size):
     # Places pixels down the vertical axis to split the box
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for i in range(image_size):
         for j in range(image_size):
             if j == math.floor((image_size - 1) / 2) or j == math.ceil((image_size - 1) / 2):
@@ -75,7 +63,7 @@ def hot_dog_array(image_size):
 
 def hamburger_array(image_size):
     # Places pixels across the horizontal axis to split the box
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for i in range(image_size):
         for j in range(image_size):
             if i == math.floor((image_size - 1) / 2) or i == math.ceil((image_size - 1) / 2):
@@ -83,7 +71,7 @@ def hamburger_array(image_size):
     return A
 
 def center_array(image_size):
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for i in range(image_size):
         for j in range(image_size):
             if i == math.floor((image_size-1)/2) and j == math.ceil((image_size-1)/2):
@@ -96,6 +84,7 @@ def center_array(image_size):
                 A[i][j] = 1
     return A
 
+
 def update_array(array_original, array_new, image_size):
     A = array_original
     for i in range(image_size):
@@ -104,10 +93,11 @@ def update_array(array_original, array_new, image_size):
                 A[i][j] = 1
     return A
 
+
 def add_pixels(array_original, additional_pixels, image_size):
     # Adds pixels to the thickness of each component of the box
     A = array_original
-    A_updated = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
+    A_updated = numpy.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     for dens in range(additional_pixels):
         for i in range(1, image_size - 1):
             for j in range(1, image_size - 1):
@@ -123,6 +113,7 @@ def basic_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A*density
 
+
 def horizontal_vertical_box_split(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Creates the outside edges of the box
     # Place pixels across the horizontal and vertical axes to split the box
@@ -132,6 +123,7 @@ def horizontal_vertical_box_split(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A*density
 
+
 def diagonal_box_split(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Creates the outside edges of the box
 
@@ -144,30 +136,35 @@ def diagonal_box_split(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A*density
 
+
 def back_slash_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, back_slash_array(image_size), image_size)
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def forward_slash_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, forward_slash_array(image_size), image_size)
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def hot_dog_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hot_dog_array(image_size), image_size)
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def hamburger_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hamburger_array(image_size), image_size)
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def x_plus_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hot_dog_array(image_size), image_size)
@@ -177,6 +174,7 @@ def x_plus_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def forward_slash_plus_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hot_dog_array(image_size), image_size)
@@ -186,6 +184,7 @@ def forward_slash_plus_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def back_slash_plus_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hot_dog_array(image_size), image_size)
@@ -195,6 +194,7 @@ def back_slash_plus_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def x_hot_dog_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, hot_dog_array(image_size), image_size)
@@ -204,6 +204,7 @@ def x_hot_dog_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def x_hamburger_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     # A = update_array(A, hot_dog_array(image_size), image_size)
@@ -213,6 +214,7 @@ def x_hamburger_box(additional_pixels, density, image_size):
     A = add_pixels(A, additional_pixels, image_size)
     return A * density
 
+
 def center_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Initializes A matrix with 0 values
     A = update_array(A, center_array(image_size), image_size)
@@ -220,7 +222,6 @@ def center_box(additional_pixels, density, image_size):
     return A * density
 
 
-
 import tensorflow as tf
 sess = tf.compat.v1.Session()
 
@@ -230,9 +231,10 @@ K.set_session(sess)
 # Gradio Interface
 
 import gradio
-import numpy
 
-endpoint_types = shapes
+endpoint_types = ("basic_box", "diagonal_box_split", "horizontal_vertical_box_split", "back_slash_box", "forward_slash_box",
+          "back_slash_plus_box", "forward_slash_plus_box", "hot_dog_box", "hamburger_box", "x_hamburger_box",
+          "x_hot_dog_box", "x_plus_box")
 density_options = ["{:.2f}".format(x) for x in numpy.linspace(0.1, 1, 10)]
 thickness_options = [str(int(x)) for x in numpy.linspace(0, 10, 11)]
 interpolation_options = [str(int(x)) for x in [3, 5, 10, 20]]
@@ -257,8 +259,8 @@ def interpolate(t1, t2, d1, d2, th1, th2, steps):
     number_2 = globals()[t2](int(th2), float(d2), 28)
 
     # resize the array to match the prediction size requirement
-    number_1_expand = np.expand_dims(np.expand_dims(number_1, axis=2), axis=0)
-    number_2_expand = np.expand_dims(np.expand_dims(number_2, axis=2), axis=0)
+    number_1_expand = numpy.expand_dims(numpy.expand_dims(number_1, axis=2), axis=0)
+    number_2_expand = numpy.expand_dims(numpy.expand_dims(number_2, axis=2), axis=0)
 
     # Determine the latent point that will represent our desired number
     latent_point_1 = encoder_model_boxes.predict(number_1_expand)[0]
@@ -268,9 +270,9 @@ def interpolate(t1, t2, d1, d2, th1, th2, steps):
     num_interp = num_internal  # the number of images to be pictured
     latent_matrix = []  # This will contain the latent points of the interpolation
     for column in range(latent_dimensionality):
-        new_column = np.linspace(latent_point_1[column], latent_point_2[column], num_interp)
+        new_column = numpy.linspace(latent_point_1[column], latent_point_2[column], num_interp)
         latent_matrix.append(new_column)
-    latent_matrix = np.array(latent_matrix).T  # Transposes the matrix so that each row can be easily indexed
+    latent_matrix = numpy.array(latent_matrix).T  # Transposes the matrix so that each row can be easily indexed
 
     plot_rows = 2
     plot_columns = num_interp + 2
@@ -278,7 +280,7 @@ def interpolate(t1, t2, d1, d2, th1, th2, steps):
     predicted_interps = [number_1_expand[0, :, :, 0]]
 
     for latent_point in range(2, num_interp + 2):  # cycles the latent points through the decoder model to create images
-        generated_image = decoder_model_boxes.predict(np.array([latent_matrix[latent_point - 2]]))[0]  # generates an interpolated image based on the latent point
+        generated_image = decoder_model_boxes.predict(numpy.array([latent_matrix[latent_point - 2]]))[0]  # generates an interpolated image based on the latent point
         predicted_interps.append(generated_image[:, :, -1])
 
     predicted_interps.append(number_2_expand[0, :, :, 0])
@@ -289,13 +291,10 @@ def interpolate(t1, t2, d1, d2, th1, th2, steps):
 
     return transition_region
 
-def generate_unit_cell(t, d, th):
-    number_1 = globals()[t](int(th), float(d), 28)
 
-    # resize the array to match the prediction size requirement
-    number_1_expand = np.expand_dims(np.expand_dims(number_1, axis=2), axis=0)
+def generate_unit_cell(t, d, th):
+    return globals()[t](int(th), float(d), 28)
 
-    return number_1_expand[0, :, :, 0]
 
 with gradio.Blocks() as demo:
     with gradio.Row():