update model

Dataset.py

@@ -0,0 +1,175 @@
+import numpy as np
+import pandas as pd
+
+np.random.seed(42)
+epsilon = 1e-8
+
+
+class Dataset:
+    """
+    Base dataset class.
+
+    Subclasses must implement:
+      - _load_dataframe()
+      - _get_columns()
+    """
+
+    def __init__(self, inverse=False):
+        self.inverse = inverse
+        self.df = self._load_dataframe()
+        self.input_columns, self.output_columns = self._get_columns()
+        self._compute_stats()
+
+    def _load_dataframe(self):
+        raise NotImplementedError
+
+    def _get_columns(self):
+        raise NotImplementedError
+
+    def _compute_stats(self):
+        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
+
+
+class DataThermoforming(Dataset):
+    """
+    Dataset for thermoforming process.
+    Materials: "CFPEEK", "CFPA6", or "CFRP" which includes both materials.
+    """
+    def __init__(self, material="CFRP", inverse=False, filename="./Data/DataForThermoforming.xlsx"):
+        self.material = material
+        self.filename = filename
+        self.materials_map = {"CF/PEEK": 0.0, "CF/PA6": 1.0}
+        super().__init__(inverse=inverse)
+
+    def _load_dataframe(self):
+        df = pd.read_excel(self.filename, sheet_name=self.material)
+        df["Materials"] = df["Materials"].map(self.materials_map).astype(np.float32)
+        if self.material == "CFPEEK" or self.material == "CFRP":
+            df = df.drop([7, 78, 101, 129], axis=0)
+        return df
+
+    def _get_columns(self):
+        if self.inverse:
+            input_columns = [
+                "Materials",
+                "Ply_Number",
+                "Fiber_Volume_Fractions",
+                "A1(abs)",
+                "B1(abs)",
+                "C1(abs)",
+                "Stress(Max) MPa",
+            ]
+            output_columns = [
+                "Initial_Temp (degree celsius)",
+                "Punch_Velocity (mm/s)",
+                "Cooling_Time (s)",
+            ]
+        else:
+            input_columns = [
+                "Ply_Number",
+                "Fiber_Volume_Fractions",
+                "Initial_Temp (degree celsius)",
+                "Punch_Velocity (mm/s)",
+                "Cooling_Time (s)",
+            ]
+            output_columns = ["A1(abs)", 
+                              "B1(abs)", 
+                              "C1(abs)", 
+                              "Stress(Max) MPa"]
+        return input_columns, output_columns
+
+
+class DataAdditiveManufacturing(Dataset):
+    def __init__(self, inverse=False, filename="./Data/FDM_192_Simulation_Matrix_Shared.xlsx"):
+        self.filename = filename
+        self.material_base_map = {"HDPE": 0.0, "PP": 1.0}
+        self.fiber_type_map = {"CF": 0.0, "GF": 1.0}
+        self.build_direction_map = {"Vertical": 1.0, "Horizontal": 0.0}
+        super().__init__(inverse=inverse)
+
+    def _load_dataframe(self):
+        df = pd.read_excel(self.filename, sheet_name="Batch_1")
+        df["Material_Base"] = df["Material_Base"].map(self.material_base_map).astype(np.float32)
+        df["Fiber_Type"] = df["Fiber_Type"].map(self.fiber_type_map).astype(np.float32)
+        df["Build_Direction"] = df["Build_Direction"].map(self.build_direction_map).astype(np.float32)
+
+        return df
+
+    def _get_columns(self):
+        if self.inverse:
+            input_columns = [
+                "Phi1_Change",
+                "Phi2_Change",
+                "Phi3_Change",
+                "Phi7_Change",
+                "Phi8_Change",
+                "Phi9_Change",
+                "Global_Max_Stress"
+            ]
+            output_columns = [
+                "Material_Base",
+                "Fiber_Type",
+                "Vol_Fraction",
+                # "Build_Direction",
+                "Extruder_Temp",
+                "Velocity",
+                "Bed_Temp"
+            ]
+        else:
+            input_columns = [
+                "Material_Base",
+                "Fiber_Type",
+                "Vol_Fraction",
+                "Build_Direction",
+                "Extruder_Temp",
+                "Velocity",
+                "Bed_Temp"
+            ]
+            output_columns = [
+                # "Phi1_Change",
+                # "Phi2_Change",
+                # "Phi3_Change",
+                "Phi7_Change",
+                "Phi8_Change",
+                "Phi9_Change",
+                "Global_Max_Stress"
+            ]
+        return input_columns, output_columns
+
+if __name__ == "__main__":
+    dataset = DataAdditiveManufacturing()
+
+    input_data = dataset.get_input(normalize=False)
+    output_data = dataset.get_output(normalize=False)
+    print("Input shape:", input_data.shape)
+    print("Output shape:", output_data.shape)

app.py

@@ -3,12 +3,14 @@
 import streamlit as st
 import pandas as pd
 import altair as alt
-import plotly.express as px
+# import plotly.express as px
 from PIL import Image # Used to open and handle image files
 import matplotlib
 import matplotlib.pyplot as plt
 import numpy as np
 
+from model_fdm import inverse_design
+
 
 #######################
 # Page configuration
@@ -258,12 +260,17 @@ if st.session_state.AM_input_changed == True:
     st.session_state.AM_input_changed = False
     
 st.button("AM process design", width=400, on_click=AM_design_click)
+
 if  st.session_state.AM_design_button_clicked == True:
     st.write("Process parameters")
     data1 = pd.DataFrame({
     'Matrix material': ['PP'],
     'Fiber material': ['Glass'],
     'Build direction': ['Vertical']})
+    
+    y_target = np.array([angleA, angleB, angleC, max_stress])
+    best = inverse_design(material_base="PP", fiber="GF", fiber_vf=45.0, 
+                        y_target=y_target, n_restarts=20, epochs=100, use_lbfgs=True)
     #st.table(data1)
     # Define styles
     styles = [
@@ -275,9 +282,9 @@ if  st.session_state.AM_design_button_clicked == True:
     st.dataframe(data1, hide_index=True, width=500)
     
     data2 = pd.DataFrame({
-    'Nozzel velocity (cm/s)': [100],
-    'Extruder temperature (C)': [240],
-    'Bed temperature (C)': [110]})
+    'Nozzel velocity (cm/s)': best['input'][0],
+    'Extruder temperature (C)': best['input'][1],
+    'Bed temperature (C)': best['input'][2]})
     st.dataframe(data2, hide_index=True, width=500)
  
 

model.py

@@ -0,0 +1,40 @@
+import torch
+
+
+class NeuralNetwork(torch.nn.Module):
+    def __init__(self, layer_sizes, dropout_rate=0.0, activation=torch.nn.ReLU):
+        super(NeuralNetwork, self).__init__()
+
+        if dropout_rate > 0:
+            self.dropout_layer = torch.nn.Dropout(dropout_rate)
+
+        self.layer_sizes = layer_sizes
+        self.layers = torch.nn.ModuleList()
+        for i in range(len(layer_sizes) - 2):
+            self.layers.append(torch.nn.Linear(layer_sizes[i], layer_sizes[i + 1]))
+            self.layers.append(activation())
+        self.layers.append(torch.nn.Linear(layer_sizes[-2], layer_sizes[-1]))
+
+        # self.sequential = torch.nn.Sequential(*self.layers)
+
+        self.init_weights()
+
+    def init_weights(self):
+        for layer in self.layers:
+            if isinstance(layer, torch.nn.Linear):
+                torch.nn.init.xavier_normal_(layer.weight)
+                layer.bias.data.fill_(0.0)
+
+    def forward(self, x, train=True):
+        for layer in self.layers:
+            x = layer(x)
+            # Apply dropout only after activations, never on the output layer
+            if train and hasattr(self, 'dropout_layer') and not isinstance(layer, torch.nn.Linear):
+                x = self.dropout_layer(x)
+
+        return x
+    
+    def predict(self, x, train=False):
+        self.eval()
+        with torch.no_grad():
+            return self.forward(x, train)

model_fdm.py

@@ -0,0 +1,338 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from Dataset import DataAdditiveManufacturing, DataThermoforming
+from model import NeuralNetwork
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Set global plotting parameters
+plt.rcParams.update({'font.size': 14,
+                     'figure.figsize': (10, 8),
+                     'lines.linewidth':  2,
+                     'lines.markersize': 6,
+                     'axes.grid': True,
+                     'axes.labelsize': 16,
+                     'legend.fontsize': 10,
+                     'xtick.labelsize': 14,
+                     'ytick.labelsize': 14,
+                     'figure.autolayout': True
+                     })
+
+def set_seed(seed=42):
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)    
+
+def train_neural_network(model, inputs, outputs, optimizer, epochs=1000, lr_scheduler=None):
+    model.train()
+    for epoch in range(epochs):
+        optimizer.zero_grad()
+        predictions = model(inputs)
+        loss = torch.mean(torch.square(predictions - outputs))
+        loss.backward()
+        optimizer.step()
+
+        if lr_scheduler:
+            lr_scheduler.step()
+
+        if epoch % 100 == 0:
+            print(f'Epoch {epoch}, Loss: {loss.item()}, Learning Rate: {optimizer.param_groups[0]["lr"]}')
+
+def kfold_indices(n_samples, k=5, seed=42, shuffle=True):
+    rng = np.random.default_rng(seed)
+    indices = np.arange(n_samples)
+    if shuffle:
+        rng.shuffle(indices)
+    fold_sizes = np.full(k, n_samples // k, dtype=int)
+    fold_sizes[: n_samples % k] += 1
+    current = 0
+    folds = []
+    for fold_size in fold_sizes:
+        start, stop = current, current + fold_size
+        folds.append(indices[start:stop])
+        current = stop
+    return folds
+
+def ridge_fit_predict(x_train, y_train, x_test, alpha=1.0):
+    # Closed-form ridge regression: W = (X^T X + alpha I)^-1 X^T Y
+    x_aug = np.concatenate([x_train, np.ones((x_train.shape[0], 1))], axis=1)
+    xtx = x_aug.T @ x_aug
+    reg = alpha * np.eye(xtx.shape[0], dtype=x_train.dtype)
+    reg[-1, -1] = 0.0  # don't regularize bias
+    w = np.linalg.solve(xtx + reg, x_aug.T @ y_train)
+    x_test_aug = np.concatenate([x_test, np.ones((x_test.shape[0], 1))], axis=1)
+    return x_test_aug @ w
+
+def kfold_ridge_baseline(inputs, outputs, k=5, alpha=1.0, seed=42):
+    folds = kfold_indices(len(inputs), k=k, seed=seed, shuffle=True)
+    mse_folds = []
+    r2_folds = []
+    for i in range(k):
+        test_idx = folds[i]
+        train_idx = np.concatenate([f for j, f in enumerate(folds) if j != i])
+
+        x_train = inputs[train_idx]
+        y_train = outputs[train_idx]
+        x_test = inputs[test_idx]
+        y_test = outputs[test_idx]
+
+        # Train-only normalization
+        x_mean = x_train.mean(axis=0)
+        x_std = x_train.std(axis=0) + 1e-8
+        y_mean = y_train.mean(axis=0)
+        y_std = y_train.std(axis=0) + 1e-8
+
+        x_train_n = (x_train - x_mean) / x_std
+        x_test_n = (x_test - x_mean) / x_std
+        y_train_n = (y_train - y_mean) / y_std
+
+        y_pred_n = ridge_fit_predict(x_train_n, y_train_n, x_test_n, alpha=alpha)
+        y_pred = y_pred_n * y_std + y_mean
+
+        mse = np.mean((y_pred - y_test) ** 2, axis=0)
+        ss_res = np.sum((y_test - y_pred) ** 2, axis=0)
+        ss_tot = np.sum((y_test - np.mean(y_test, axis=0)) ** 2, axis=0)
+        r2 = 1 - ss_res / ss_tot
+        mse_folds.append(mse)
+        r2_folds.append(r2)
+
+    mse_folds = np.stack(mse_folds, axis=0)
+    r2_folds = np.stack(r2_folds, axis=0)
+    print("Ridge k-fold CV (alpha=%.3g, k=%d)" % (alpha, k))
+    print("MSE mean:", np.mean(mse_folds, axis=0))
+    print("MSE std:", np.std(mse_folds, axis=0))
+    print("R2 mean:", np.mean(r2_folds, axis=0))
+    print("R2 std:", np.std(r2_folds, axis=0))
+
+def main():
+    dataset = DataAdditiveManufacturing()
+    inputs = dataset.get_input(normalize=False)
+    outputs = dataset.get_output(normalize=False)
+
+    idx_train = np.random.choice(len(inputs), size=int(0.95 * len(inputs)), replace=False)
+    idx_test = np.setdiff1d(np.arange(len(inputs)), idx_train)
+
+    # Normalize using train-only statistics to avoid test leakage
+    x_train = inputs[idx_train]
+    y_train = outputs[idx_train]
+    x_test = inputs[idx_test]
+    y_test = outputs[idx_test]
+
+    x_mean = x_train.mean(axis=0)
+    x_std = x_train.std(axis=0) + 1e-8
+    y_mean = y_train.mean(axis=0)
+    y_std = y_train.std(axis=0) + 1e-8
+
+    x_train_n = (x_train - x_mean) / x_std
+    x_test_n = (x_test - x_mean) / x_std
+    y_train_n = (y_train - y_mean) / y_std
+    y_test_n = (y_test - y_mean) / y_std
+
+    inputs_train = torch.tensor(x_train_n, dtype=torch.float32).to(DEVICE)
+    outputs_train = torch.tensor(y_train_n, dtype=torch.float32).to(DEVICE)
+
+    inputs_test = torch.tensor(x_test_n, dtype=torch.float32).to(DEVICE)
+    outputs_test = torch.tensor(y_test_n, dtype=torch.float32).to(DEVICE)
+    
+    layer_sizes = [inputs.shape[1], 64, 32, outputs.shape[1]]
+    dropout_rate = 0.1
+    model = NeuralNetwork(layer_sizes, dropout_rate=dropout_rate, activation=torch.nn.ReLU).to(DEVICE)
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=2000, gamma=0.9)
+
+    # Create a proper dataset that keeps input-output pairs together
+    train_dataset = torch.utils.data.TensorDataset(inputs_train, outputs_train)
+    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)
+
+    # Train the model
+    epochs = 5000
+    best_test_loss = float("inf")
+    patience = 400
+    patience_left = patience
+    for epoch in range(epochs):
+        model.train()
+        for inputs_batch, outputs_batch in train_loader:
+            inputs_batch = inputs_batch.to(DEVICE)
+            outputs_batch = outputs_batch.to(DEVICE)
+            optimizer.zero_grad()
+            predictions = model(inputs_batch)
+            loss = torch.mean(torch.square(predictions - outputs_batch))
+            loss.backward()
+            optimizer.step()
+
+        if lr_scheduler:
+            lr_scheduler.step()
+
+        if epoch % 200 == 0:
+            model.eval()
+            with torch.no_grad():
+                train_pred = model(inputs_train, train=False)
+                train_loss = torch.mean(torch.square(train_pred - outputs_train))
+                test_pred = model(inputs_test, train=False)
+                test_loss = torch.mean(torch.square(test_pred - outputs_test))
+            print(f'Epoch {epoch}, Train Loss: {train_loss.item():.6f}, Test Loss: {test_loss.item():.6f}')
+            if test_loss.item() < best_test_loss - 1e-6:
+                best_test_loss = test_loss.item()
+                patience_left = patience
+            else:
+                patience_left -= 1
+                if patience_left <= 0:
+                    print(f"Early stopping at epoch {epoch}")
+                    break
+
+
+    predictions = model.predict(inputs_test)
+    test_loss = torch.mean(torch.square(predictions - outputs_test))
+    print(f'Test Loss: {test_loss.item()}. Samples: {idx_test}')
+
+    x = np.arange(0, len(idx_test))
+
+    outputs_test = outputs_test.cpu().numpy() * y_std + y_mean
+    predictions = predictions.cpu().numpy() * y_std + y_mean
+    # for sample in outputs_test:
+    #     print(f'Test samples: {sample}')
+    plt.figure(figsize=(10, 6))
+    plt.plot(x, outputs_test[:, 0], color='b', linestyle='--', label='True Phi7_Change')
+    plt.plot(x, predictions[:, 0], color='b', linestyle='-', label='Predicted Phi7_Change')
+    plt.plot(x, outputs_test[:, 1], color='r', linestyle='--', label='True Phi8_Change')
+    plt.plot(x, predictions[:, 1], color='r', linestyle='-', label='Predicted Phi8_Change')
+    plt.plot(x, outputs_test[:, 2], color='g', linestyle='--', label='True Phi9_Change')
+    plt.plot(x, predictions[:, 2], color='g', linestyle='-', label='Predicted Phi9_Change')
+    
+    plt.gca().xaxis.set_major_locator(plt.MaxNLocator(integer=True))    
+    plt.xlabel('Sample Index')
+    plt.xticks(ticks=range(len(idx_test)),labels=idx_test + 1)
+    plt.ylabel('Angle Change (Degrees)')
+    plt.title('Angle Change Prediction')
+    plt.legend(loc='lower left')
+    plt.savefig('fdm_simulation.png')
+
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(x, outputs_test[:, -1], color='m', linestyle='--', label='True Global_Max_Stress')
+    plt.plot(x, predictions[:, -1], color='m', linestyle='-', label='Predicted Global_Max_Stress')
+    plt.xlabel('Sample Index')
+    plt.xticks(ticks=range(len(idx_test)),labels=idx_test + 1)
+    plt.ylabel('Stress (MPa)')
+    plt.title('Global Max Stress Prediction')
+    plt.legend(loc='lower left')
+    plt.savefig('fdm_stress_prediction.png')
+
+
+
+    # MSE
+    mse = np.mean((predictions - outputs_test) ** 2, axis=0)
+    # print(f'Mean Squared Error for Phi1_Change: {mse[0]:.6f}, Phi2_Change: {mse[1]:.6f}, Phi3_Change: {mse[2]:.6f}, Phi7_Change: {mse[3]:.6f}, Phi8_Change: {mse[4]:.6f}, Phi9_Change: {mse[5]:.6f}, Global_Max_Stress: {mse[6]:.6f}')
+    print(f'Mean Squared Error for Phi7_Change: {mse[0]:.6f}, Phi8_Change: {mse[1]:.6f}, Phi9_Change: {mse[2]:.6f}, Global_Max_Stress: {mse[3]:.6f}')
+
+
+    # R 2 score
+    ss_ress = np.sum((outputs_test - predictions) ** 2, axis=0)
+    ss_tots = np.sum((outputs_test - np.mean(outputs_test, axis=0)) ** 2, axis=0)
+    r2_scores = 1 - ss_ress / ss_tots
+    # print(f'R² Score for Phi1_Change: {r2_scores[0]:.6f}, Phi2_Change: {r2_scores[1]:.6f}, Phi3_Change: {r2_scores[2]:.6f}, Phi7_Change: {r2_scores[3]:.6f}, Phi8_Change: {r2_scores[4]:.6f}, Phi9_Change: {r2_scores[5]:.6f}, Global_Max_Stress: {r2_scores[6]:.6f}')
+    print(f'R² Score for Phi7_Change: {r2_scores[0]:.6f}, Phi8_Change: {r2_scores[1]:.6f}, Phi9_Change: {r2_scores[2]:.6f}, Global_Max_Stress: {r2_scores[3]:.6f}')
+  
+    # Error
+
+    # Save the model
+    model_save_path = './model_fdm_ckpt.pth'
+    model_config = {'layer_sizes': layer_sizes,
+                    'dropout_rate': dropout_rate
+                    }
+    checkpoint = {
+        'model_state_dict': model.state_dict(),
+        'model_config': model_config
+    }
+    torch.save(checkpoint, model_save_path)
+
+def load_model(model_path):
+    checkpoint = torch.load(model_path)
+    model_config = checkpoint['model_config']
+    model = NeuralNetwork(model_config['layer_sizes'], dropout_rate=model_config['dropout_rate'], activation=torch.nn.ReLU).to(DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    print(f"Model loaded from {model_path}")
+    return model
+
+
+def inverse_design(material_base, fiber, fiber_vf, y_target, n_restarts=5, epochs=100, use_lbfgs=True, model=None, data=None):
+    if model is None:
+        model = load_model('./model_fdm_ckpt.pth').to(torch.device('cpu'))
+
+    if data is None:
+        data = DataAdditiveManufacturing()
+    mat_type = data.material_base_map.get(material_base, 0.0)
+    fiber_type = data.fiber_type_map.get(fiber, 0.0)
+    build_direction = data.build_direction_map.get("Vertical", 0.0)
+    y_target_norm = torch.tensor(data.normalize_output(y_target), dtype=torch.float32)
+    y_target_tensor = torch.tensor(y_target, dtype=torch.float32)
+    input_mean = torch.tensor(data.input_mean)
+    input_std = torch.tensor(data.input_std)
+    output_mean = torch.tensor(data.output_mean)
+    output_std = torch.tensor(data.output_std)
+    
+    weights = torch.tensor([1.0, 1.0, 1.0, 0.001], dtype=torch.float32)
+    bounds = torch.tensor([[100., 300.], [50., 300.], [10., 200.]], dtype=torch.float32) # Extruder_Temp, Velocity, Bed_Temp
+    best = {"loss": float('inf'), "input": None, "output": None}
+
+    for restart in range(n_restarts):
+        z = torch.randn(3, requires_grad=True)
+
+        if use_lbfgs:
+            optimizer = torch.optim.LBFGS([z], lr=0.1, max_iter=epochs, line_search_fn="strong_wolfe")
+            steps = 1
+        else:
+            optimizer = torch.optim.Adam([z], lr=0.001)
+            steps = epochs
+        
+        for step in range(steps):
+            def closure():
+                var =  bounds[:, 0] + (bounds[:, 1] - bounds[:, 0]) * torch.sigmoid(z)
+                optimizer.zero_grad()
+                input_raw = torch.cat([torch.tensor([mat_type, fiber_type, fiber_vf, build_direction]), var]).unsqueeze(0)
+                input_norm = (input_raw - input_mean) / input_std
+                output_pred = model(input_norm)
+                output_pred = (output_pred * output_std) + output_mean
+                loss = torch.sum(weights * (output_pred - y_target_tensor) ** 2)
+                loss.backward()
+                return loss
+
+            if use_lbfgs:
+                loss = optimizer.step(closure)
+            else:
+                loss = closure()
+                optimizer.step()
+
+            if (step + 1) % 200 == 0:
+                print(f'Restart {restart + 1}, Step {step + 1}, Loss: {loss.item():.6f}, grad: {z.grad.norm().item():.6f}')
+            
+        with torch.no_grad():
+            var =  bounds[:, 0] + (bounds[:, 1] - bounds[:, 0]) * torch.sigmoid(z)
+            input_raw = torch.cat([torch.tensor([mat_type, fiber_type, fiber_vf, build_direction]), var])
+            input_norm = (input_raw - input_mean) / input_std
+            output_pred = model(input_norm)
+            output_pred = data.denormalize_output(output_pred.numpy())
+            final_loss = np.sum(weights.numpy() * (output_pred - y_target) ** 2).item()
+            if final_loss < best["loss"]:
+                best["loss"] = final_loss
+                best["input"] = var.detach().cpu().numpy()
+                best["output"] = output_pred
+
+    return best
+
+
+if __name__ == "__main__":
+    set_seed(51)
+    # dataset = DataAdditiveManufacturing()
+    # inputs = dataset.get_input(normalize=False)
+    # outputs = dataset.get_output(normalize=False)
+    # kfold_ridge_baseline(inputs, outputs, k=5, alpha=1.0, seed=51)
+    # main()
+    
+    
+    best = inverse_design(material_base="HDPE", fiber="CF", fiber_vf=45.0,
+                          y_target=np.array([-0.22, 0.11, -0.004, 185.2]), n_restarts=20, epochs=100, use_lbfgs=True)
+    print("Best design found:")
+    print(f"Extruder_Temp: {best['input'][0]:.2f}, Velocity: {best['input'][1]:.2f}, Bed_Temp: {best['input'][2]:.2f}")
+    print(f"Predicted Outputs: Phi7_Change: {best['output'][0]:.4f}, Phi8_Change: {best['output'][1]:.4f}, Phi9_Change: {best['output'][2]:.4f}")

model_fdm_ckpt.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c3e255f49c77c11925a373a288f10a023fcbfeb7835c6653933d815f8bb88c4
+size 14249