Start testing streamlit implementation

Data_Generation/Dataset_Generation_Functions.py

@@ -16,29 +16,10 @@ def make_boxes(image_size, densities):
     """
     :param image_size: [int] - the pixel height and width of the generated arrays
     :param densities: [list] - of the values of each of the active pixels in each shape
-    :param shapes: [list] - of the various shapes desired for the dataset
-    :return: [list[tuple]] - [Array, Density, Thickness, Shape]
+    :return: [list[tuple]] - [Array, Density, Thickness of each strut type]
     """
 
     matrix = []
-    #
-    # for function in shapes:  # Adds different types of shapes
-    #
-    #     # Adds different density values
-    #     for i in range(len(densities)):
-    #         # Loops through the possible thickness values
-    #         for j in range(image_size):  # Adds additional Pixels
-    #             thickness = j
-    #             Array = (function(thickness, densities[i], image_size))
-    #
-    #             # Checks if there are any 0's left in the array to append
-    #             if (np.where((Array == float(0)))[0] > 0).any():
-    #                 the_tuple = (Array, str(function.__name__), densities[i], thickness)
-    #                 matrix.append(the_tuple)
-    #
-    #             # Prevents solids shapes from being appended to the array
-    #             else:
-    #                 break
 
     # Establish the maximum thickness for each type of strut
     max_vert = int(np.ceil(1 / 2 * image_size) - 2)
@@ -56,7 +37,7 @@ def make_boxes(image_size, densities):
             for k in range(0, max_vert):
                 hamburger_box_thickness = k
                 array_2 = hamburger_array(image_size, hamburger_box_thickness) + array_1
-                array_2 =np.array(array_2 > 0, dtype=int)  # Keep all values 0/1
+                array_2 = np.array(array_2 > 0, dtype=int)  # Keep all values 0/1
                 if np.unique([array_2]).all() > 0:
                     break
 
@@ -85,119 +66,8 @@ def make_boxes(image_size, densities):
                                          hot_dog_box_thickness, hamburger_box_thickness)
                             matrix.append(the_tuple)
 
-    # matrix = []
-    # base_shapes = []
-    #
-    #
-    #
-    #
-    #
-    # density_1 = []
-    # for function in shapes:  # Create an array of the base shapes
-    #     thickness = 0
-    #     Array = function(thickness, 1, image_size)
-    #     # density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])  # Array, Shape, Density, Thickness
-    #     # base_shapes.append(density_1_tuple)
-    #
-    #     density_1 = np.append(density_1,(np.array([Array, str(function.__name__), 1, thickness])), axis=1)  # Array, Shape, Density, Thickness
-    #     # Add one to the thickness of the previous array
-    #     # for j in range(image_size):
-    #     while (np.where((Array == float(0)))[0] > 0).any():
-    #         # Checks if there are any 0's left in the array to append
-    #         # if (np.where((Array == float(0)))[0] > 0).any():
-    #             # density_1.append(density_1_tuple, axis=0)
-    #         thickness += 1
-    #         if np.shape(density_1) == (4,):
-    #             Array = add_pixels(density_1[0], 1) # will add 1 pixel to each previous array, rather than adding multiple and having to loop
-    #
-    #         else:
-    #             print(np.shape(density_1))
-    #             print(density_1[-1][0])
-    #             Array = add_pixels(density_1[-1][0], 1)
-    #         # print(np.shape(Array))
-    #         density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])
-    #         # else:  # Prevents solids shapes from being appended to the array
-    #         #     break
-    #         density_1 = np.vstack((density_1, density_1_tuple))
-    #
-    # matrix = []
-    # # print(np.shape(density_1[0]))
-    # # print(density_1[:][0])
-    # for i in range(len(densities)):
-    #     some = np.multiply(density_1[:][0],densities[i]) #,density_1[:1])
-    #     # print(np.shape(some))
-    #     matrix.append(tuple(some))
-    #
-    #
-    #     # # Adds different density values
-    #     # for i in range(len(densities)):
-    #     #     # Loops through the possible thickness values
-    #     #     for j in range(image_size):  # Adds additional Pixels
-    #     #         thickness = j
-    #     #         Array = (function(thickness, densities[i], image_size))
-    #     #
-    #     #         # Checks if there are any 0's left in the array to append
-    #     #         if (np.where((Array == float(0)))[0] > 0).any():
-    #     #             the_tuple = (Array, str(function.__name__), densities[i], thickness)
-    #     #             matrix.append(the_tuple)
-    #     #
-    #     #         # Prevents solids shapes from being appended to the array
-    #     #         else:
-    #     #             break
     return matrix
 
 
 ########################################################################################################################
-# # Testing
-# image_size = 9
-# densities = [1]
-# 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]
-#
-# boxes = make_boxes(image_size, densities, shapes)
-#
-# # print(np.shape(boxes))
-# desired_label = 'basic_box'
-# desired_density = 1
-# desired_thickness = 0
-#
-# box_arrays, box_shape, box_density, box_thickness,  = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3]
-# # print(np.shape(box_arrays))
-# # print(np.shape(box_shape))
-# # print(np.shape(box_density))
-#
-# indices = [i for i in range(len(box_arrays)) if box_shape[i] == desired_label and box_density[i] == desired_density and box_thickness[i] == desired_thickness]
-# plt.imshow(box_arrays[indices[0]])
-# plt.show()
-########################################################################################################################
-# Testing
-image_size = 9
-densities = [1]
-
-boxes = make_boxes(image_size, densities)
-
-desired_density = 1
-# desired_thickness = 0
-
-desired_basic_box_thickness =1
-desired_forward_slash_box_thickness=2
-desired_back_slash_box_thickness=0
-desired_hot_dog_box_thickness=0
-desired_hamburger_box_thickness=0
-
-
-box_arrays, box_density, basic_box_thickness, forward_slash_box_thickness, back_slash_box_thickness,hot_dog_box_thickness, hamburger_box_thickness\
-    = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3], list(zip(*boxes))[4], list(zip(*boxes))[5], list(zip(*boxes))[6]
-# print(np.shape(box_arrays))
-# print(np.shape(box_shape))
-# print(np.shape(box_density))
-
-indices = [i for i in range(len(box_arrays)) if box_density[i] == desired_density
-           and basic_box_thickness[i] == desired_basic_box_thickness
-           and forward_slash_box_thickness[i] == desired_forward_slash_box_thickness
-           and back_slash_box_thickness[i] == desired_back_slash_box_thickness
-           and hot_dog_box_thickness[i] == desired_hot_dog_box_thickness
-           and hamburger_box_thickness[i] == desired_hamburger_box_thickness]
-plt.imshow(box_arrays[indices[0]])
-plt.show()
+

Data_Generation/Shape_Generation_Functions.py

@@ -1,143 +0,0 @@
-from Data_Generation.Piecewise_Box_Functions import back_slash_array, basic_box_array, forward_slash_array, \
-    hot_dog_array, hamburger_array, update_array, add_pixels
-
-
-########################################################################################################################
-# Series of Basic Box Shapes
-
-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
-    A = add_pixels(A, additional_pixels)
-    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
-    A = update_array(A, hot_dog_array(image_size), image_size)
-    A = update_array(A, hamburger_array(image_size), image_size)
-    # Increase the thickness of each part of the box
-    A = add_pixels(A, additional_pixels)
-    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
-
-    # Add pixels along the diagonals of the box
-    A = update_array(A, back_slash_array(image_size), image_size)
-    A = update_array(A, forward_slash_array(image_size), image_size)
-
-    # Adds pixels to the thickness of each component of the box
-    # Increase the thickness of each part of the box
-    A = add_pixels(A, additional_pixels)
-    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)
-    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)
-    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)
-    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)
-    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)
-    A = update_array(A, hamburger_array(image_size), image_size)
-    A = update_array(A, forward_slash_array(image_size), image_size)
-    A = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    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)
-    A = update_array(A, hamburger_array(image_size), image_size)
-    A = update_array(A, forward_slash_array(image_size), image_size)
-    # A = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    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)
-    A = update_array(A, hamburger_array(image_size), image_size)
-    A = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    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)
-    A = update_array(A, forward_slash_array(image_size), image_size)
-    A = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    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, hamburger_array(image_size), image_size)
-    A = update_array(A, forward_slash_array(image_size), image_size)
-    A = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    return A * density
-
-
-# New Unit Cells
-def forward_slash_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 = update_array(A, forward_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    return A * density
-
-
-def forward_slash_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 = update_array(A, forward_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    return A * density
-
-
-def back_slash_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 = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    return A * density
-
-
-def back_slash_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 = update_array(A, back_slash_array(image_size), image_size)
-    A = add_pixels(A, additional_pixels)
-    return A * density

2D_Data_Generator_Model.py → app.py

@@ -5,23 +5,60 @@ import pandas as pd
 from datasets import load_dataset, ClassLabel, Sequence
 import json
 import numpy
-from transformers import AutoImageProcessor
-from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
-from transformers import DefaultDataCollator
-# import evaluate
-import numpy as np
-from transformers import AutoModelForImageClassification, TrainingArguments, Trainer
-from PIL import Image
-from matplotlib import cm
-from Data_Generation.Shape_Generation_Functions import 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
-
 
+# from transformers import AutoImageProcessor
+# from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
+# from transformers import DefaultDataCollator
+# # import evaluate
+# import numpy as np
+# from transformers import AutoModelForImageClassification, TrainingArguments, Trainer
+# from PIL import Image
+# from matplotlib import cm
 
+import streamlit as st
 from Data_Generation.Dataset_Generation_Functions import make_boxes
 
 
+x = st.slider('Select a value')
+st.write(x, 'squared is', x * x)
+
+
+'''
+# Testing
+image_size = 100
+densities = [1]
+
+boxes = make_boxes(image_size, densities)
+
+desired_density = 1
+# desired_thickness = 0
+
+desired_basic_box_thickness = 1
+desired_forward_slash_box_thickness = 2
+desired_back_slash_box_thickness = 0
+desired_hot_dog_box_thickness = 0
+desired_hamburger_box_thickness = 0
+
+
+box_arrays, box_density, basic_box_thickness, forward_slash_box_thickness, back_slash_box_thickness,hot_dog_box_thickness, hamburger_box_thickness\
+    = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3], list(zip(*boxes))[4], list(zip(*boxes))[5], list(zip(*boxes))[6]
+# print(np.shape(box_arrays))
+# print(np.shape(box_shape))
+# print(np.shape(box_density))
+
+indices = [i for i in range(len(box_arrays)) if box_density[i] == desired_density
+           and basic_box_thickness[i] == desired_basic_box_thickness
+           and forward_slash_box_thickness[i] == desired_forward_slash_box_thickness
+           and back_slash_box_thickness[i] == desired_back_slash_box_thickness
+           and hot_dog_box_thickness[i] == desired_hot_dog_box_thickness
+           and hamburger_box_thickness[i] == desired_hamburger_box_thickness]
+plt.imshow(box_arrays[indices[0]], cmap='gray', vmin=0, vmax=1)
+plt.show()
+'''
+
+
+
+'''
 
 # food = load_dataset("cmudrc/2d-lattices", split="train[:15]")  # Loads the training data samples
 food = load_dataset("cmudrc/2d-lattices", split="train+test")  # Loads all of the data, for use after training
@@ -79,6 +116,6 @@ print(indices_1)
 # plt.imshow(box_arrays[indices_1])
 plt.imshow(box_arrays[indices_1[0]])
 plt.show()
-
+'''
 
 '''trainer.push_to_hub()''' # Need to figure out how to push the model to the hub