device update

app.py

@@ -22,10 +22,10 @@ def run_inverse_design(ply_number, a1, b1, c1, stress, n_restarts, epochs, use_l
         "Cooling Time": float(best["input"][2]),
     }
     output_vals = {
-        "A1": float(best["output"][0][0]),
-        "B1": float(best["output"][0][1]),
-        "C1": float(best["output"][0][2]),
-        "Stress": float(best["output"][0][3]),
+        "A1": float(best["output"][0]),
+        "B1": float(best["output"][1]),
+        "C1": float(best["output"][2]),
+        "Stress": float(best["output"][3]),
     }
     return input_vals, output_vals
 

model_inverse.py

@@ -3,7 +3,9 @@ import numpy as np
 import matplotlib.pyplot as plt
 from Dataset import Dataset
 
-DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+DEVICE = torch.device('cpu')
+
 # Set global plotting parameters
 plt.rcParams.update({'font.size': 14,
                      'figure.figsize': (10, 8),
@@ -77,11 +79,14 @@ def train_neural_network(model, inputs, outputs, optimizer, epochs=1000, lr_sche
 
 
 def load_model(model_path):
-    checkpoint = torch.load(model_path)
+    checkpoint = torch.load(model_path, map_location=DEVICE)
     model_config = checkpoint['model_config']
     model = NeuralNetwork(model_config['layer_sizes'], dropout_rate=model_config['dropout_rate'])
     model.load_state_dict(checkpoint['model_state_dict'])
     print(f"Model loaded from {model_path}")
+
+    model.to(DEVICE)
+    model.eval()
     return model
 
 def inverse_design(ply_number, y_target, n_restarts=20, epochs=1000, use_lbfgs=False):
@@ -95,8 +100,6 @@ def inverse_design(ply_number, y_target, n_restarts=20, epochs=1000, use_lbfgs=F
     output_mean = torch.tensor(data.output_mean)
     output_std = torch.tensor(data.output_std)
     
-
-    model.eval()
     weights = torch.tensor([1.0, 1.0, 1.0, 0.0], dtype=torch.float32)
     bounds = torch.tensor([[350., 450.], [100., 500.], [450., 550.]], dtype=torch.float32) # Initial_Temp, Punch_Velocity, Cooling_Time
     best = {"loss": float('inf'), "input": None, "output": None}
@@ -132,7 +135,7 @@ def inverse_design(ply_number, y_target, n_restarts=20, epochs=1000, use_lbfgs=F
             
         with torch.no_grad():
             var =  bounds[:, 0] + (bounds[:, 1] - bounds[:, 0]) * torch.sigmoid(z)
-            input_raw = torch.cat([torch.tensor([ply_number]), var]).unsqueeze(0)
+            input_raw = torch.cat([torch.tensor([ply_number]), var])
             input_norm = (input_raw - input_mean) / input_std
             output_pred = model(input_norm)
             output_pred = data.denormalize_output(output_pred.numpy())
@@ -232,18 +235,15 @@ def inverse_model():
     # Error
 
     # Save the model
-    model_save_path = './model_inverse_ckpt.pth'
-    model_config = {'layer_sizes': layer_sizes,
-                    'dropout_rate': 0.05
-                    }
-    checkpoint = {
-        'model_state_dict': model.state_dict(),
-        'model_config': model_config
-    }
-    torch.save(checkpoint, model_save_path)
-    # Load the model
-    # model = NeuralNetwork(layer_sizes)
-    # model.load_state_dict(torch.load(model_save_path))
+    # model_save_path = './model_inverse_ckpt.pth'
+    # model_config = {'layer_sizes': layer_sizes,
+    #                 'dropout_rate': 0.05
+    #                 }
+    # checkpoint = {
+    #     'model_state_dict': model.state_dict(),
+    #     'model_config': model_config
+    # }
+    # torch.save(checkpoint, model_save_path)
 
 
 if __name__ == "__main__":