model update

Dataset.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pandas as pd
+
+np.random.seed(42)
+epsilon = 1e-8
+
+class Dataset:
+    def __init__(self, inverse=False):
+        filename = './Data/DataForThermoforming.xlsx'
+        self.df = pd.read_excel(filename, sheet_name='Data')
+        # remove rows by index
+        self.df = self.df.drop([20, 48], axis=0)
+
+        # normalize data
+        if inverse:
+            self.input_columns = ['Ply_Number', 'A1(abs)', 'B1(abs)', 'C1(abs)', 'Stress(Max) MPa']
+            self.output_columns = ['Initial_Temp (degree celsius)', 'Punch_Velocity (mm/s)', 'Cooling_Time (s)']
+        else:
+            self.input_columns = ['Ply_Number', 'Initial_Temp (degree celsius)', 'Punch_Velocity (mm/s)', 'Cooling_Time (s)']
+            self.output_columns = ['A1(abs)', 'B1(abs)', 'C1(abs)', 'Stress(Max) MPa']
+
+        self.input_mean = self.df[self.input_columns].mean().to_numpy(dtype=np.float32)
+        self.input_std = self.df[self.input_columns].std().to_numpy(dtype=np.float32) + epsilon
+        self.output_mean = self.df[self.output_columns].mean().to_numpy(dtype=np.float32)
+        self.output_std = self.df[self.output_columns].std().to_numpy(dtype=np.float32) + epsilon
+
+
+    def get_input(self, normalize=False):
+        data = self.df[self.input_columns].to_numpy(dtype=np.float32)
+        if normalize:
+            data = self.normalize_input(data)
+        return data
+    
+
+    def get_output(self, normalize=False):
+        data = self.df[self.output_columns].to_numpy(dtype=np.float32)
+        if normalize:
+            data = self.normalize_output(data)
+        return data
+
+    def __str__(self):
+        return str(self.df.head())
+    
+    def normalize_input(self, input_data):
+        return (input_data - self.input_mean) / self.input_std
+    
+    def normalize_output(self, output_data):
+        return (output_data - self.output_mean) / self.output_std
+    
+    def denormalize_input(self, normalized_input):
+        return normalized_input * self.input_std + self.input_mean
+    
+    def denormalize_output(self, normalized_output):
+        return normalized_output * self.output_std + self.output_mean
+
+if __name__ == "__main__":
+    dataset = Dataset()
+    
+    # Example usage
+    input_data = dataset.get_input(normalize=True)
+    output_data = dataset.get_output(normalize=True)
+    
+    print("Input shape:", input_data.shape)
+    print("Output shape:", output_data.shape)

app.py

@@ -4,14 +4,13 @@ import gradio as gr
 from model_inverse import inverse_design
 
 
-def run_inverse_design(ply_number, a1, b1, c1, stress, n_restarts, epochs, loss_scale, use_lbfgs):
+def run_inverse_design(ply_number, a1, b1, c1, stress, n_restarts, epochs, use_lbfgs):
     y_target = np.array([a1, b1, c1, stress], dtype=np.float32)
     best = inverse_design(
-        pile_number=int(ply_number),
+        ply_number=int(ply_number),
         y_target=y_target,
         n_restarts=int(n_restarts),
         epochs=int(epochs),
-        loss_scale=float(loss_scale),
         use_lbfgs=bool(use_lbfgs),
     )
     if best["input"] is None or best["output"] is None:
@@ -37,16 +36,17 @@ with gr.Blocks(title="Inverse Design Demo") as demo:
 
     with gr.Row():
         with gr.Column():
-            pile_number = gr.Number(label="Pile number", value=2, precision=0)
+            gr.Markdown("## Target Output")
+            ply_number = gr.Number(label="Ply number", value=2, precision=0)
             a1 = gr.Number(label="A1", value=0.89, precision=4)
             b1 = gr.Number(label="B1", value=0.83, precision=4)
             c1 = gr.Number(label="C1", value=0.12, precision=4)
             stress = gr.Number(label="Stress", value=180.2, precision=4)
         with gr.Column():
+            gr.Markdown("## Optimization Settings")
             n_restarts = gr.Number(label="Restarts", value=5, precision=0)
-            epochs = gr.Number(label="Epochs", value=1000, precision=0)
-            loss_scale = gr.Number(label="Loss scale", value=1.0, precision=3)
-            use_lbfgs = gr.Checkbox(label="Use LBFGS", value=False)
+            epochs = gr.Number(label="Epochs of Optimization", value=100, precision=0)
+            use_lbfgs = gr.Checkbox(label="Use LBFGS", value=True)
 
     run_btn = gr.Button("Run Inverse Design")
 
@@ -56,7 +56,7 @@ with gr.Blocks(title="Inverse Design Demo") as demo:
 
     run_btn.click(
         run_inverse_design,
-        inputs=[pile_number, a1, b1, c1, stress, n_restarts, epochs, loss_scale, use_lbfgs],
+        inputs=[ply_number, a1, b1, c1, stress, n_restarts, epochs, use_lbfgs],
         outputs=[best_input, best_output],
     )
 

model_inverse_ckpt.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1d8a6c28d5674b85ab110058a65eab6bed5cc61c1180b22a4105dac959f0c493
-size 39655
+oid sha256:627d783e02e0538dbcb75eef4a8a19ac27b3eed2f791b38eadb5c5cd31de98e5
+size 39591