Big grind session, still working on implimenting the model correctly

app.py

@@ -3,7 +3,11 @@ import gradio as gr
 from PIL import Image
 from scipy import ndimage
 import matplotlib.pyplot as plt
-from bulk_bulge_generation import definitions
+from bulk_bulge_generation import definitions, smooth
+from transformers import pipeline
+import fastai
+from fastcore.all import *
+from fastai.vision.all import *
 
 def apply_vector_field_transform(image, func, radius, center=(0.5, 0.5), strength=1, edge_smoothness=0.1, center_smoothness=0.20):
     # 0.106 strength = .50
@@ -15,6 +19,15 @@ def apply_vector_field_transform(image, func, radius, center=(0.5, 0.5), strengt
     # Y Needs to be flipped
     center_y = int(center[1] * rows)
     center_x = int(center[0] * cols)
+
+    # Inverts the Y axis (Numpy is 0 index at top of image)
+    center_y = abs(rows - center_y)
+
+    print()
+    print(rows, cols)
+    print("y =", center_y, "/", rows)
+    print("x =", center_x, "/", cols)
+    print()
     
     pixel_radius = int(max_dim * radius)
     
@@ -34,6 +47,11 @@ def apply_vector_field_transform(image, func, radius, center=(0.5, 0.5), strengt
     # Creating a sigmoid function to apply to masks
     def sigmoid(x, center, steepness):
         return 1 / (1 + np.exp(-steepness * (x - center)))
+    
+    print(radius)
+    print(strength)
+    print(edge_smoothness)
+    print(center_smoothness)
 
     # Masking
     edge_mask = np.clip((radius - dist_from_center) / (radius * edge_smoothness), 0, 1)
@@ -77,6 +95,7 @@ def apply_vector_field_transform(image, func, radius, center=(0.5, 0.5), strengt
     
     return transformed_image, (gx, gy)
 
+
 def create_gradient_vector_field(gx, gy, image_shape, step=20, reverse=False):
     """
     Create a gradient vector field visualization with option to reverse direction.
@@ -123,7 +142,22 @@ def create_gradient_vector_field(gx, gy, image_shape, step=20, reverse=False):
     
     return vector_field
 
-def transform_image(image, func_choice, randomization_check, radius, center_x, center_y, strength, edge_smoothness, center_smoothness, reverse_gradient=True, spiral_frequency=1):
+
+#############################
+#    MAIN FUNCTION HERE
+#############################
+
+# pipeline = pipeline(task="image-classification", model="nick-leland/distortionml")
+
+# Version Check 
+print(f"NumPy version: {np.__version__}")
+print(f"PyTorch version: {torch.__version__}")
+print(f"FastAI version: {fastai.__version__}")
+
+learn = load_learner('model.pkl')
+
+
+def transform_image(image, func_choice, randomization_check, radius, center_x, center_y, strength, reverse_gradient=True, spiral_frequency=1):
     I = np.asarray(Image.open(image))    
 
     def pinch(x, y):
@@ -133,22 +167,7 @@ def transform_image(image, func_choice, randomization_check, radius, center_x, c
         return np.arctan2(y, x)
 
     def bulge(x, y):
-        # Where does this make an array???:w
-
-        print(x.shape)
-        print(y.shape)
-        # Mess with this number
-        # num = 10
-
-        # if x < num or y < num:
-        #     # This might not be correct
-        #     return 1
-        # else:
-        #     r = -np.sqrt(x**2 + y**2)
         r = -np.sqrt(x**2 + y**2)
-        print(r.shape)
-        print(type(r))
-        # return -1 / (r + 1)
         return r 
 
     def spiral(x, y, frequency=1):
@@ -156,44 +175,66 @@ def transform_image(image, func_choice, randomization_check, radius, center_x, c
         theta = np.arctan2(y, x)
         return r * np.sin(theta - frequency * r)
 
+    rng = np.random.default_rng()
+    if randomization_check == True:
+        radius, location, strength, edge_smoothness= definitions(rng)
+        center_x = location[0]
+        center_y = location[1]
+            
+    # Temporarily disabling and using these values.
+    # edge_smoothness = 0.25 * strength
+    # center_smoothness = 0.25 * strength
+    edge_smoothness, center_smoothness = smooth(rng, strength)
+
+
     if func_choice == "Pinch":
         func = pinch
     elif func_choice == "Spiral":
         func = shift 
     elif func_choice == "Bulge":
         func = bulge
+        edge_smoothness = 0
+        center_smoothness = 0
+    elif func_choice == "Volcano":
+        func = bulge
     elif func_choice == "Shift Up":
         func = lambda x, y: spiral(x, y, frequency=spiral_frequency)
 
-    if randomization_check == True:
-        rng = np.random.default_rng()
-        radius, location, strength, edge_smoothness= definitions(rng)
-        center_x = location[0]
-        center_y = location[1]
-
 
     transformed, (gx, gy) = apply_vector_field_transform(I, func, radius, (center_x, center_y), strength, edge_smoothness, center_smoothness)
     vector_field = create_gradient_vector_field(gx, gy, I.shape[:2], reverse=reverse_gradient)
 
-    return transformed, vector_field
+    # GRADIO CHANGE HERE
+    # predictions = pipeline(transformed) 
+
+    # Have to convert to image first
+    result = Image.fromarray(transformed)
+
+    result = str(learn.predict(result))
+    print("result")
+    print(result)
+
+    return transformed, vector_field, result
 
 demo = gr.Interface(
     fn=transform_image,
     inputs=[
         gr.Image(type="filepath"),
-        gr.Dropdown(["Pinch", "Spiral", "Shift Up", "Bulge"], value="Bulge", label="Function"), 
+        gr.Dropdown(["Pinch", "Spiral", "Shift Up", "Bulge", "Volcano"], value="Bulge", label="Function"), 
         gr.Checkbox(label="Randomize inputs?"),
         gr.Slider(0, 0.5, value=0.25, label="Radius (as fraction of image size)"),
         gr.Slider(0, 1, value=0.5, label="Center X"),
         gr.Slider(0, 1, value=0.5, label="Center Y"),
         gr.Slider(0, 1, value=0.5, label="Strength"),
-        gr.Slider(0, 1, value=0.5, label="Edge Smoothness"),
-        gr.Slider(0, 0.5, value=0.1, label="Center Smoothness")
+        # gr.Slider(0, 1, value=0.5, label="Edge Smoothness"),
+        # gr.Slider(0, 0.5, value=0.1, label="Center Smoothness")
         # gr.Checkbox(label="Reverse Gradient Direction"),
     ],
     outputs=[
         gr.Image(label="Transformed Image"),
-        gr.Image(label="Gradient Vector Field")
+        gr.Image(label="Gradient Vector Field"),
+        # gr.Image(label="Result", num_top_classes=2)
+        # gr.Textbox(label='Result')
     ],
     title="Image Transformation Demo!",
     description="This is the baseline function that will be used to generate the database for a machine learning model I am working on called 'DistortionMl'! The goal of this model is to detect and then reverse image transformations that can be generated here! You can read more about the project at this repository link : https://github.com/nick-leland/DistortionML. The main function that I was working on is the 'Bulge' function, I can't really guarantee that the others work well (;"

bulk_bulge_generation.py

@@ -7,8 +7,8 @@ from os import path
 def definitions(generator):
 
     # The image bulge should be entirly contained within the image.  For instance, if we have a radius of 0.5 (the max), the image should be force to be at 0.5 (x and y) locations.
-    radius = generator.random() * 0.5
-    # radius = generator.normal(loc=0.5, scale=(0.5/4))
+    # radius = generator.random() * 0.5
+    radius = generator.normal(loc=0.25, scale=(0.5/6))
     # print(f"Radius is {radius}")
     # strengtH = Generator.random()
     strength = generator.normal(loc=1, scale=(1/6))
@@ -42,6 +42,23 @@ def definitions(generator):
     # print(f"({x[0]}, {x[1]})")
     return radius, x, strength, smoothness
 
+def smooth(generator, strength):
+    # edge
+    emaxval, eminval = 0.75, 0.25
+    emean = (emaxval + eminval) / 2
+    estd = (emaxval - eminval) / 6
+
+    # center
+    cmaxval, cminval = 0.5, 0.25
+    cmean = (cmaxval + cminval) / 2
+    cstd = (cmaxval - cminval) / 4
+
+
+    edge = generator.normal(loc=emean, scale=estd)
+    center = generator.normal(loc=cmean, scale=cstd)
+
+    return edge, center
+
 def bulge(x, y):
     return -np.sqrt(x**2 + y**2)
 

requirements.txt

@@ -71,5 +71,5 @@ uvicorn==0.30.1
 uvloop==0.19.0
 watchfiles==0.22.0
 websockets==11.0.3
-transformers
-torch
+torch==2.2.0+cpu
+fastai