Updating to get the model imports to work

app.py

@@ -1,18 +1,17 @@
 import numpy as np
 from scipy import signal
 import math
-# import huggingface_hub  # for loading model
+import matplotlib.pyplot as plt
 from huggingface_hub import from_pretrained_keras
 import streamlit as st
-# from transformers import AutoModel
-# from transformers import TFAutoModel
-# Needed for importing torch to use in the transformers model
-# import torch
+# Needed in requirements.txt for importing to use in the transformers model
 import tensorflow
-import matplotlib.pyplot as plt
-# HELLO HUGGING FACE
 
 
+# HELLO HUGGING FACE
+
+########################################################################################################################
+# Define the piecewise functions to create each of the possible shapes
 def basic_box_array(image_size):
     A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
     # Creates the outside edges of the box
@@ -98,6 +97,8 @@ def add_pixels(array_original, additional_pixels, image_size):
     return A
 
 
+########################################################################################################################
+# Create the desired shape using the density and thickness
 def basic_box(additional_pixels, density, image_size):
     A = basic_box_array(image_size)  # Creates the outside edges of the box
     # Increase the thickness of each part of the box
@@ -269,23 +270,75 @@ thickness_2 = st.selectbox("Thickness 2", thickness_options)
 interp_length = st.selectbox("Interpolation Length", interpolation_options)
 
 
+# Define the function to generate unit cells based on user inputs
 def generate_unit_cell(shape, density, thickness):
     return globals()[shape](int(thickness), float(density), 28)
 
+
+# Generate the endpoints
+number_1 = generate_unit_cell(shape_1, density_1, thickness_1)
+number_2 = generate_unit_cell(shape_2, density_2, thickness_2)
+
+# Display the endpoints to the user
 if st.button("Generate Endpoint Images"):
     plt.figure(1)
     st.header("Endpoints to be generated:")
-    plt.subplot(1, 2, 1), plt.imshow(generate_unit_cell(shape_1, density_1, thickness_1), cmap='gray', vmin=0, vmax=1)
-    plt.subplot(1, 2, 2), plt.imshow(generate_unit_cell(shape_2, density_2, thickness_2), cmap='gray', vmin=0, vmax=1)
+    plt.subplot(1, 2, 1), plt.imshow(number_1, cmap='gray', vmin=0, vmax=1)
+    plt.subplot(1, 2, 2), plt.imshow(number_2, cmap='gray', vmin=0, vmax=1)
     plt.figure(1)
     st.pyplot(plt.figure(1))
-
+########################################################################################################################
 # Load the models from existing huggingface model
 # Load the encoder model
 encoder_model_boxes = from_pretrained_keras("cmudrc/2d-lattice-encoder")
-# encoder_model = TFAutoModel.from_pretrained("cmudrc/2d-lattice-encoder")
+
 # Load the decoder model
 decoder_model_boxes = from_pretrained_keras("cmudrc/2d-lattice-decoder")
-# decoder_model = TFAutoModel.from_pretrained("cmudrc/2d-lattice-decoder")
 
 
+########################################################################################################################
+# Encode the Desired Endpoints
+# 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)
+
+# Determine the latent point that will represent our desired number
+latent_point_1 = encoder_model_boxes.predict(number_1_expand)[0]
+latent_point_2 = encoder_model_boxes.predict(number_2_expand)[0]
+
+latent_dimensionality = len(latent_point_1)  # define the dimensionality of the latent space
+########################################################################################################################
+# Establish the Framework for a LINEAR Interpolation
+number_internal = 8  # the number of interpolations that the model will find between two points
+num_interp = number_internal + 2  # 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)
+    latent_matrix.append(new_column)
+latent_matrix = np.array(latent_matrix).T  # Transposes the matrix so that each row can be easily indexed
+########################################################################################################################
+# Plotting the Interpolation in 2D Using Chosen Points
+if st.button("Generate Interpolation:"):
+    plt.figure(2)
+    plot_rows = 2
+    plot_columns = num_interp + 2
+
+    # Plot the First Interpolation Point
+    plt.subplot(plot_rows, plot_columns, 1), plt.imshow(number_1, cmap='gray', vmin=0, vmax=1)
+    # plt.title("First Interpolation Point:\n" + str(box_shape_test[number_1]) + "\nPixel Density: " + str(
+    #             box_density_test[number_1]) + "\nAdditional Pixels: " + str(additional_pixels_test[number_1]))
+
+    predicted_interps = []  # Used to store the predicted interpolations
+    # Interpolate the Images and Print out to User
+    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
+        predicted_interps.append(generated_image[:, :, -1])
+        plt.subplot(plot_rows, plot_columns, latent_point), plt.imshow(generated_image[:, :, -1], cmap='gray', vmin=0, vmax=1)
+        # plt.axis('off')
+
+    # Plot the Second Interpolation Point
+    plt.subplot(plot_rows, plot_columns, num_interp + 2), plt.imshow(number_2, cmap='gray', vmin=0, vmax=1)
+    # plt.title("Second Interpolation Point:\n" + str(box_shape_test[number_2]) + "\nPixel Density: " + str(
+    #             box_density_test[number_2]) + "\nAdditional Pixels: " + str(additional_pixels_test[number_2]))  # + "\nPredicted Latent Point 2: " + str(latent_point_2)
+    plt.figure(2)
+    st.pyplot(plt.figure(2))