upload model

Data/.~lock.240_simulations_DS.xlsx#

@@ -0,0 +1 @@
+,wan6,precision,27.01.2026 21:00,/home/wan6/snap/onlyoffice-desktopeditors/890/.local/share/onlyoffice;

Dataset.py

@@ -0,0 +1,78 @@
+import numpy as np
+import pandas as pd
+
+np.random.seed(42)
+epsilon = 1e-8
+
+class Dataset:
+    def __init__(self, mat_name='FRP'):
+        filename = './Data/240_simulations_DS.xlsx'
+        self.df = pd.read_excel(filename, sheet_name=mat_name, header=1)
+        # normalize data
+        self.input_columns = [
+            'Gate Location', 
+            'Matrix', 
+            'Fiber Type', 
+            'Fiber wt%(Volume Fractions)', 
+            # 'Fiber-Matrix Combination',
+            'Packing Pressure (MPa)',
+            'Packing Time (s)',
+            'Mold Temperature (°C)',
+            'Injection Speed (cm^3/s)'
+            ]
+        self.output_columns = ['Alpha_angle_deg(ABS)', 'Beta_angle_deg(ABS)', 'Gamma_angle_deg(ABS)']
+
+        self.material_map = {'PA6': 0, 'PP': 1}
+        self.fiber_map = {'CF': 0, 'GF': 1}
+        self.combination_map = {'PA6-CF-10': 0, 'PA6-CF-15': 1, 'PA6-CF-30': 2, 'PA6-CF-40': 3, 
+                           'PA6-GF-15': 4, 'PA6-GF-30': 5, 'PA6-GF-40': 6, 'PA6-GF-50': 7,
+                           'PP-CF-10': 8, 'PP-CF-15': 9, 'PP-CF-30': 10, 'PP-CF-40': 11,
+                           'PP-GF-15': 12, 'PP-GF-30': 13, 'PP-GF-40': 14, 'PP-GF-50': 15}
+        self.df['Matrix'] = self.df['Matrix'].map(self.material_map)
+        self.df['Fiber Type'] = self.df['Fiber Type'].map(self.fiber_map)
+        self.df['Fiber-Matrix Combination'] = self.df['Fiber-Matrix Combination'].map(self.combination_map)
+        self.df['Fiber wt%(Volume Fractions)'] = self.df['Fiber wt%(Volume Fractions)'] / 100.0
+
+        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=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,13 @@
 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_inverse import inverse_design
 
 #######################
 # Page configuration
@@ -277,19 +278,21 @@ if  st.session_state.AM_design_button_clicked == True:
 
     st.dataframe(data1, hide_index=True, width=600)
     
+    best = inverse_design(gate_loc=1, matrix='PP', fiber='GF', fiber_vf=0.1, y_target=np.array([angleA, angleB, angleC]), n_restarts=5, epochs=100, use_lbfgs=True)
+    
     data2 = pd.DataFrame({
-    'Packing pressure (MPa)': [24],
-    'Packing time (s)': [110],
-    'Mold temperature (C)': [29],
-    'Injection speed (cm^3/s)': [69]
+    'Packing pressure (MPa)': best["input"][0],
+    'Packing time (s)': best["input"][1],
+    'Mold temperature (C)': best["input"][2],
+    'Injection speed (cm^3/s)': best["input"][3]
     })
     st.dataframe(data2, hide_index=True, width=600)
  
-    data3 = pd.DataFrame({
-    'Maximum angle A': [1.2],
-    'Maximum angle B': [2.2],
-    'Maximum angle C': [1.0]})
-    st.dataframe(data3, hide_index=True, width=600)
+    # data3 = pd.DataFrame({
+    # 'Maximum angle A': [1.2],
+    # 'Maximum angle B': [2.2],
+    # 'Maximum angle C': [1.0]})
+    # st.dataframe(data3, hide_index=True, width=600)
  
 
 

main_injection.py

@@ -0,0 +1,222 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from Dataset import Dataset
+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': 14,
+                     '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 main():
+    set_seed(42)
+    dataset = Dataset(mat_name='FRP')
+    # Load raw data; normalize using train-only statistics to avoid leakage.
+    inputs = dataset.get_input(normalize=False)
+    outputs = dataset.get_output(normalize=False)
+
+    # Train/val/test split for early stopping and unbiased test.
+    n = len(inputs)
+    perm = np.random.permutation(n)
+    n_train = int(0.8 * n)
+    n_val = int(0.1 * n)
+    idx_train = perm[:n_train]
+    idx_val = perm[n_train:n_train + n_val]
+    idx_test = perm[n_train + n_val:]
+
+    # Fit normalization on train split only.
+    input_mean = inputs[idx_train].mean(axis=0)
+    input_std = inputs[idx_train].std(axis=0) + 1e-8
+    output_mean = outputs[idx_train].mean(axis=0)
+    output_std = outputs[idx_train].std(axis=0) + 1e-8
+
+    inputs_norm = (inputs - input_mean) / input_std
+    outputs_norm = (outputs - output_mean) / output_std
+
+    inputs_train = torch.tensor(inputs_norm[idx_train], dtype=torch.float32).to(DEVICE)
+    outputs_train = torch.tensor(outputs_norm[idx_train], dtype=torch.float32).to(DEVICE)
+
+    inputs_val = torch.tensor(inputs_norm[idx_val], dtype=torch.float32).to(DEVICE)
+    outputs_val = torch.tensor(outputs_norm[idx_val], dtype=torch.float32).to(DEVICE)
+
+    inputs_test = torch.tensor(inputs_norm[idx_test], dtype=torch.float32).to(DEVICE)
+    outputs_test = torch.tensor(outputs_norm[idx_test], dtype=torch.float32).to(DEVICE)
+
+    # Linear regression baseline on normalized data.
+    X_train = np.concatenate([inputs_norm[idx_train], np.ones((len(idx_train), 1), dtype=np.float32)], axis=1)
+    Y_train = outputs_norm[idx_train]
+    coef, _, _, _ = np.linalg.lstsq(X_train, Y_train, rcond=None)
+
+    def linear_predict(x_norm):
+        X = np.concatenate([x_norm, np.ones((len(x_norm), 1), dtype=np.float32)], axis=1)
+        return X @ coef
+
+    val_pred_lr = linear_predict(inputs_norm[idx_val])
+    test_pred_lr = linear_predict(inputs_norm[idx_test])
+    val_mse_lr = np.mean((val_pred_lr - outputs_norm[idx_val]) ** 2)
+    test_mse_lr = np.mean((test_pred_lr - outputs_norm[idx_test]) ** 2)
+    print(f'Linear baseline - Val Loss: {val_mse_lr:.6f}, Test Loss: {test_mse_lr:.6f}')
+    
+    # Smaller model to reduce overfitting on small data.
+    layer_sizes = [inputs.shape[1]] + [32] * 2 + [outputs.shape[1]]
+    dropout_rate = 0.2
+    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=5000, 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=32, shuffle=True)
+
+    # Train the model
+    epochs = 10000
+    best_val = float('inf')
+    best_state = None
+    patience = 800
+    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 % 500 == 0:
+            model.eval()
+            with torch.no_grad():
+                train_pred = model(inputs_train)
+                train_loss = torch.mean(torch.square(train_pred - outputs_train))
+                val_pred = model(inputs_val)
+                val_loss = torch.mean(torch.square(val_pred - outputs_val))
+            print(f'Epoch {epoch}, Train Loss: {train_loss.item():.6f}, Val Loss: {val_loss.item():.6f}')
+
+        # Early stopping on validation loss (checked every epoch).
+        model.eval()
+        with torch.no_grad():
+            val_pred = model(inputs_val)
+            val_loss = torch.mean(torch.square(val_pred - outputs_val))
+        if val_loss.item() < best_val - 1e-5:
+            best_val = val_loss.item()
+            best_state = {k: v.clone() for k, v in model.state_dict().items()}
+            patience_left = patience
+        else:
+            patience_left -= 1
+            if patience_left <= 0:
+                print(f'Early stopping at epoch {epoch}. Best val loss: {best_val:.6f}')
+                break
+
+    if best_state is not None:
+        model.load_state_dict(best_state)
+
+
+    # MC Dropout inference for predictive mean/uncertainty.
+    def mc_dropout_predict(model, x, n_samples=50):
+        model.train()  # keep dropout active
+        preds = []
+        with torch.no_grad():
+            for _ in range(n_samples):
+                preds.append(model(x).unsqueeze(0))
+        preds = torch.cat(preds, dim=0)
+        return preds.mean(dim=0), preds.std(dim=0)
+
+    predictions, pred_std = mc_dropout_predict(model, inputs_test, n_samples=50)
+    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() * output_std + output_mean
+    predictions = predictions.cpu().numpy() * output_std + output_mean
+    pred_std = pred_std.cpu().numpy() * output_std
+    print(f'Predictive STD (A, B, C): {pred_std.mean(axis=0)}')
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(x, outputs_test[:, 0], color='b', linestyle='--', label='True A')
+    plt.plot(x, predictions[:, 0], color='b', linestyle='-', label='Predicted A')
+    plt.plot(x, outputs_test[:, 1], color='r', linestyle='--', label='True B')
+    plt.plot(x, predictions[:, 1], color='r', linestyle='-', label='Predicted B')
+    plt.plot(x, outputs_test[:, 2], color='g', linestyle='--', label='True C')
+    plt.plot(x, predictions[:, 2], color='g', linestyle='-', label='Predicted C')
+    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 (Degrees)')
+    plt.title('Angle Prediction')
+    plt.legend(loc='upper right')
+    plt.savefig('angle_prediction.png')
+
+
+    # MSE
+    mse = np.mean((predictions - outputs_test) ** 2, axis=0)
+    print(f'Mean Squared Error for A: {mse[0]:.6f}, B: {mse[1]:.6f}, C: {mse[2]:.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 A: {r2_scores[0]:.6f}, B: {r2_scores[1]:.6f}, C: {r2_scores[2]:.6f}')
+
+    # Error
+
+    # Save the model
+    model_save_path = './model_checkpoint.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
+
+
+if __name__ == "__main__":
+    main()
+
+    # model = load_model('./model_checkpoint.pth').to(torch.device('cpu'))

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):
+        for layer in self.layers:
+            x = layer(x)
+            # Use the module's train/eval mode to control dropout.
+            if self.training and hasattr(self, 'dropout_layer') and not isinstance(layer, torch.nn.Linear):
+                x = self.dropout_layer(x)
+
+        return x
+    
+    def predict(self, x):
+        self.eval()
+        with torch.no_grad():
+            return self.forward(x)

model_checkpoint.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79577a07df4872d6efa8b5c87ff739110bcdea92e4e1f5fc4e3c61a7c4a9d29a
+size 9153

model_inverse.py

@@ -0,0 +1,171 @@
+import torch
+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('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': 14,
+                     '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)    
+
+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)
+            if train and hasattr(self, 'dropout_layer'):
+                x = self.dropout_layer(x)
+
+        return x
+    
+    def predict(self, x, train=False):
+        self.eval()
+        with torch.no_grad():
+            return self.forward(x, train)
+
+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 load_model(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(gate_loc, matrix, fiber, fiber_vf, y_target, n_restarts=10, epochs=100, use_lbfgs=False, feasibility_samples=0):
+    model = load_model('./model_checkpoint.pth')
+
+    data = Dataset()
+    mat_type = data.material_map.get(matrix, 0.0)
+    fiber_type = data.fiber_map.get(fiber, 0.0)
+    
+    y_target_norm = data.normalize_output(y_target) # (A1, B1, C1, Stress)
+    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], dtype=torch.float32)
+    bounds = torch.tensor([[1., 100.], [1., 10.], [1., 100.], [1., 100.]], dtype=torch.float32)
+    best = {"loss": float('inf'), "input": None, "output": None}
+
+    for restart in range(n_restarts):
+        z = torch.randn(4, 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([gate_loc, mat_type, fiber_type, fiber_vf]), var]).unsqueeze(0)
+                input_norm = (input_raw - input_mean) / input_std
+                output_pred = model(input_norm, train=False)
+                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([gate_loc, mat_type, fiber_type, fiber_vf]), var])
+            input_norm = (input_raw - input_mean) / input_std
+            output_pred = model.predict(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(5324)
+    # train the inverse model over springback data
+    # inverse_model()
+
+    # perform inverse design
+    import time
+    start_time = time.time()
+    best = inverse_design(gate_loc=1, matrix='PA6', fiber='CF', fiber_vf=0.4, y_target=np.array([0.45, 9.03, 1.87]), n_restarts=5, epochs=100, use_lbfgs=True)
+    end_time = time.time()
+    time_elapsed = (end_time - start_time)
+    print(f"Inverse design completed in {time_elapsed:.2f} seconds.")
+    print("Best Input:", best["input"])
+    print("Best Output:", best["output"])
+