Upload 9 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+modified_SNL_18650_LFP_25C_0-100_0.5-3C_b_timeseries.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,188 @@
+
+import pickle
+
+import torch
+import torch.nn as nn
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+
+from torch.utils.data import Dataset, DataLoader
+
+import net_BNN
+import gradio as gr
+from gradio.components import *
+# 使用已训练的模型进行推理
+class SingleDataset(Dataset):
+    def __init__(self, data, attrib_x, attrib_y,  max_len, C_rated, min_val=None, max_val=None,  mode='train'):
+        self.data = data
+        self.cycle_indices = data['Cycle_Index'].unique()
+        self.attrib_x = attrib_x
+        self.attrib_y = attrib_y
+        self.C_rated = C_rated
+        self.mode = mode
+        self.max_len = max_len
+
+        self.data['Current'] /= self.C_rated
+        if mode == 'train':
+            self.min_val = data[attrib_x].values.min(axis=0)
+            self.max_val = data[attrib_x].values.max(axis=0)
+            with open('./para_BNN/min_max_values.pkl', 'wb') as f:
+                pickle.dump((self.min_val, self.max_val), f)
+        else:
+            self.min_val = min_val
+            self.max_val = max_val
+
+
+    def get_min_max_values(self):
+        if self.mode != 'train':
+            return None
+        return self.min_val, self.max_val
+
+
+    def __len__(self):
+        return len(self.cycle_indices)
+
+    def get_data_by_cycle_index(self, cycle_index):
+        # 获取指定 cycle_index 的数据
+        cycle_data = self.data[self.data['Cycle_Index'] == cycle_index].copy()
+
+        # 提取特征和标签
+        features = cycle_data[self.attrib_x].values
+        label = cycle_data[self.attrib_y].values[0]
+
+        # 标准化特征
+        features = (features - self.min_val) / (self.max_val - self.min_val)
+        pad_len = self.max_len - len(features)
+
+        features = torch.tensor(features, dtype=torch.float32).clone().detach()
+        features = torch.cat([features, torch.full((pad_len, features.shape[1]), 0)])
+        label = torch.tensor(label, dtype=torch.float32)
+
+        return features, label
+
+    def __getitem__(self, index):
+        cycle_index = self.cycle_indices[index]
+        cycle_data = self.data[self.data['Cycle_Index'] == cycle_index].copy()
+
+        # cycle_data['Current'] /= self.C_rated
+
+        # 提取特征和标签
+        features = cycle_data[self.attrib_x].values
+        # C_ini = cycle_data[self.attrib_y].values[0]
+        label = cycle_data[self.attrib_y].values[0]
+
+        # # 标准化特征
+        features = (features - self.min_val) / (self.max_val - self.min_val)
+        # label = (label - self.y_mean) / self.y_std
+        # features = (features - self.min_val) / self.max_val
+        pad_len = self.max_len - len(features)
+
+        features = torch.tensor(features, dtype=torch.float32).clone().detach()
+        # 在 features 后面填充固定值
+        features = torch.cat([features, torch.full((pad_len, features.shape[1]), 0)])
+        # 转换为张量
+        # features = torch.tensor(padded_features, dtype=torch.float32)
+        label = torch.tensor(label, dtype=torch.float32)
+        # label = label.view(1,1)
+
+        return features, label
+
+
+def test(model_path, var_path, csv_path, pos):
+
+    attrib_feature = ['Current', 'Voltage', 'Environment_Temperature', 'Cell_Temperature', 'SOC']
+    attrib_label = ['SOH']
+    max_len = 200
+    input_dim = len(attrib_feature)
+    output_dim = 1
+    hidden_dim = 64
+    num_layers = 2
+    num_heads = 4
+    lr = 1e-3
+    max_seq_len = 200
+    batch_size = 1
+    C_rated = 1.1
+
+    model_path = model_path.name
+    var_path = var_path.name
+    csv_path = csv_path.name
+
+    with open(var_path, 'rb') as f:
+        min_val, max_val = pickle.load(f)
+
+
+
+    test_data = pd.read_csv(csv_path)
+    test_data['SOH'] = test_data['cycle capacity'] / test_data['cycle capacity'].values[0]
+    # C_val = val_data[attrib_label].values[0]
+    # scaler_val = train_dataset.scaler
+    dataset = SingleDataset(
+        data=test_data,
+        attrib_x=attrib_feature,
+        attrib_y=attrib_label,
+        max_len=max_len,
+        C_rated=C_rated,
+        min_val=min_val,
+        max_val=max_val,
+        mode='test')
+    features, label = dataset.get_data_by_cycle_index(pos)
+    features = torch.unsqueeze(features, dim=0)
+    # 导入网络结构
+    model = net_BNN.ATBNN_Model(
+        input_dim=input_dim,
+        output_dim=output_dim,
+        hidden_dim=hidden_dim,
+        num_layers=num_layers,
+        num_heads=num_heads,
+        batch_size=batch_size,
+        max_seq_len=max_seq_len)
+
+    # model.load_state_dict(torch.load("./model_B/model_epoch634_Trainloss0.00013560_ValLoss0.00107357.pt"))  #LOSS=0
+    # model.load_state_dict(torch.load("./model_B/model_epoch2168_Trainloss0.00001729_ValLoss0.00107112.pt"))
+    model.load_state_dict(torch.load(model_path,map_location=torch.device("cpu")))
+
+    # model.load_state_dict(torch.load("./model/model_epoch1.pt"))
+    device = torch.device('cpu')
+    # device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+
+    num_sample = 100
+    model.eval()
+    with torch.no_grad():
+        predictions = []
+        # true_labels = []
+        cov = []
+        # upp = []
+        # low = []
+
+            # outputs = model(test_features.to(device))
+
+        # MC sample
+        sample_output = torch.zeros(num_sample, label.shape[0]).to(device)
+        for i in range(num_sample):
+            sample_output[i] = model(features.to(device)).reshape(-1)
+
+        outputs = C_rated * torch.Tensor(sample_output.mean(dim=0).unsqueeze(1)).to(device)
+        covs = C_rated * torch.Tensor(sample_output.std(dim=0).unsqueeze(1)).to(device)
+
+        results = "{:.4f}±{:.4f}".format(outputs.item(), covs.item())
+        # true_labels.append((test_labels).tolist())
+
+        return results
+
+    #
+inputs = [
+    File(label="上传预训练模型"),
+    File(label="上传参数文件"),
+    File(label="上传CSV测试数据"),
+    Number(label="选择循环次数（1~4004）")
+]
+
+outputs = [
+    Textbox(label="最大可用容量估计结果"),
+
+]
+
+gr.Interface(fn=test, inputs=inputs, outputs=outputs, title="ATBNN Model",
+             description="加载预训练模型，加载测试数据并进行预测，得到当前循环的最大可用容量。").launch(share=True)
+

min_max_values.pkl

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

model_epoch8876_Trainloss0.00001546_ValLoss0.00022519.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73bd1b279432fb53a459c9f83804b6ff48cd9bcf6524f3a20c86423c58e9b36b
+size 2323516

modified_SNL_18650_LFP_25C_0-100_0.5-3C_b_timeseries.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20533877941565f1d1ab6ffe7aa8cd4e91f5ace283cb0de1a0c9ee6b55002f24
+size 30805653

net_BNN.py

@@ -0,0 +1,276 @@
+import math
+
+import pickle
+
+import torch
+import torch.nn as nn
+from torch.distributions import Normal
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+from sklearn.preprocessing import StandardScaler,MinMaxScaler
+from torch.nn.utils.rnn import pad_sequence
+from torch.utils.data import Dataset, DataLoader
+import torch.nn.functional as F
+
+class CycleDataset(Dataset):
+    def __init__(self, data, attrib_x, attrib_y,  max_len, C_rated, min_val=None, max_val=None,  mode='train'):
+        self.data = data
+        self.cycle_indices = data['Cycle_Index'].unique()
+        self.attrib_x = attrib_x
+        self.attrib_y = attrib_y
+        self.C_rated = C_rated
+        self.mode = mode
+        self.max_len = max_len
+
+        self.data['Current'] /= self.C_rated
+        if mode == 'train':
+            self.min_val = data[attrib_x].values.min(axis=0)
+            self.max_val = data[attrib_x].values.max(axis=0)
+            with open('./para_BNN/min_max_values.pkl', 'wb') as f:
+                pickle.dump((self.min_val, self.max_val), f)
+        else:
+            self.min_val = min_val
+            self.max_val = max_val
+
+
+    def get_min_max_values(self):
+        if self.mode != 'train':
+            return None
+        return self.min_val, self.max_val
+
+
+    def __len__(self):
+        return len(self.cycle_indices)
+
+    def __getitem__(self, index):
+        cycle_index = self.cycle_indices[index]
+        cycle_data = self.data[self.data['Cycle_Index'] == cycle_index].copy()
+
+        # cycle_data['Current'] /= self.C_rated
+
+        # 提取特征和标签
+        features = cycle_data[self.attrib_x].values
+        # C_ini = cycle_data[self.attrib_y].values[0]
+        label = cycle_data[self.attrib_y].values[0]
+
+        # # 标准化特征
+        features = (features - self.min_val) / (self.max_val - self.min_val)
+        # label = (label - self.y_mean) / self.y_std
+        # features = (features - self.min_val) / self.max_val
+        pad_len = self.max_len - len(features)
+
+        features = torch.tensor(features, dtype=torch.float32).clone().detach()
+        # 在 features 后面填充固定值
+        features = torch.cat([features, torch.full((pad_len, features.shape[1]), 0)])
+        # 转换为张量
+        # features = torch.tensor(padded_features, dtype=torch.float32)
+        label = torch.tensor(label, dtype=torch.float32)
+        # label = label.view(1,1)
+
+        return features, label
+
+    #
+    # def pad_collate(self, batch):
+    #     # 填充批次数据，使其长度一致
+    #     features_batch, labels_batch = zip(*batch)
+    #     features_batch = pad_sequence(features_batch, batch_first=True)
+    #     labels_batch = torch.stack(labels_batch)
+    #
+    #     return features_batch, labels_batch
+
+
+
+class Transformer_FeatureExtractor(nn.Module):
+    def __init__(self, input_dim, output_dim, hidden_dim, num_layers, num_heads, batch_size, max_seq_len):
+        super(Transformer_FeatureExtractor, self).__init__()
+
+        self.num_layers = num_layers
+        self.hidden_size = hidden_dim
+        self.batch_size = batch_size
+        self.max_seq_len = max_seq_len
+        # self.cls_token = nn.Parameter(torch.randn(self.batch_size, 1, self.hidden_size))
+        self.embedding = nn.Linear(input_dim, hidden_dim)
+        self.position_encoding = self.create_position_encoding()
+
+        self.transformer_encoder = nn.TransformerEncoder(
+            nn.TransformerEncoderLayer(d_model=hidden_dim, nhead=num_heads,dropout=0),
+            num_layers=num_layers
+        )
+
+    def create_position_encoding(self):
+        position_encoding = torch.zeros(self.max_seq_len, self.hidden_size)
+        position = torch.arange(0, self.max_seq_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, self.hidden_size, 2) * (-math.log(10000.0) / self.hidden_size))
+        position_encoding[:, 0::2] = torch.sin(position * div_term)
+        position_encoding[:, 1::2] = torch.cos(position * div_term)
+        position_encoding = position_encoding.unsqueeze(0)
+        return nn.Parameter(position_encoding, requires_grad=False)
+
+    def forward(self, x):
+        seq_len = x.shape[1]
+        positions = self.position_encoding[:, :seq_len, :]
+        x = self.embedding(x)
+        x = x + positions
+        # x = torch.cat((x, self.cls_token),dim=1)
+        # x = torch.cat((self.cls_token, x),dim=1)
+        x_layer = self.transformer_encoder(x)
+        feature = torch.mean(x_layer, dim=1)
+        return feature
+
+# class BaseVaraitionLayer_(nn.Module):
+#     def __init__(self):
+#         super().__init__()
+#     def kl_div(self, mu_q, sigma_q, mu_p, sigma_p):
+#         '''
+#         Calculates kl divergence between two guassians (Q || P)
+#         :param mu_q: torch.Tensor -> mu parameter of distribution Q
+#         :param sigma_q: torch.Tensor -> sigma parameter of distribution Q
+#         :param mu_p: float -> mu parameter of distribution P
+#         :param sigma_p: float -> sigma parameter of distribution P
+#         :return: torch.Tensor of shape 0
+#         '''
+#         kl = torch.log(sigma_p) - torch.log(sigma_q)
+#         + (sigma_q**2 + (mu_q - mu_p)**2) / (2 * (sigma_p**2)) - 0.5
+#         return kl.sum()
+
+
+class BayesLinear(nn.Module):
+    def __init__(self, input_dim, output_dim, prior_mu, prior_sigma):
+        super(BayesLinear, self).__init__()
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.prior_mu = prior_mu
+        self.prior_sigma = prior_sigma
+
+        self.weight_mu = nn.Parameter(torch.Tensor(output_dim, input_dim))
+        self.weight_rho = nn.Parameter(torch.Tensor(output_dim, input_dim))
+        self.bias_mu = nn.Parameter(torch.Tensor(output_dim))
+        self.bias_rho = nn.Parameter(torch.Tensor(output_dim))
+
+        self.weight = None
+        self.bias = None
+
+        self.prior = Normal(prior_mu, prior_sigma)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.kaiming_uniform_(self.weight_mu, a=math.sqrt(self.input_dim))
+        nn.init.constant_(self.weight_rho, -3.0)
+        nn.init.zeros_(self.bias_mu)
+        nn.init.constant_(self.bias_rho, -3.0)
+
+    def forward(self, input):
+        weight_epsilon = torch.randn_like(self.weight_mu)
+        bias_epsilon = torch.randn_like(self.bias_mu)
+
+        weight_sigma = torch.log1p(torch.exp(self.weight_rho))
+        bias_sigma = torch.log1p(torch.exp(self.bias_rho))
+
+        self.weight = self.weight_mu + weight_sigma * weight_epsilon
+        self.bias = self.bias_mu + bias_sigma * bias_epsilon
+
+        weight_log_prior = self.prior.log_prob(self.weight)
+        bias_log_prior = self.prior.log_prob(self.bias)
+        self.log_prior = torch.sum(weight_log_prior) + torch.sum(bias_log_prior)
+
+        self.weight_post = Normal(self.weight_mu.data, torch.log(1 + torch.exp(self.weight_rho)))
+        self.bias_post = Normal(self.bias_mu.data, torch.log(1 + torch.exp(self.bias_rho)))
+        self.log_post = self.weight_post.log_prob(self.weight).sum() + self.bias_post.log_prob(self.bias).sum()
+
+        # output_mean = torch.matmul(input, weight.t()) + bias
+        # output_var = torch.matmul(input, weight_sigma.t())**2 + bias_sigma**2
+        # output_mean = nn.functional.linear(input, self.weight_mu, self.bias_mu)
+        # output_variance = nn.functional.linear(input ** 2, weight_sigma ** 2, bias_sigma ** 2) + 1e-8
+        # return output_mean, output_var
+        return F.linear(input, self.weight, self.bias)
+
+class BNN_Regression(nn.Module):
+    def __init__(self, input_dim, output_dim, noise_tol):
+        super(BNN_Regression, self).__init__()
+
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        # self.batch_size = batch_size
+        self.noise_tol = noise_tol
+
+        self.relu = nn.ReLU()
+        self.tanh = nn.Tanh()
+        # self.bnn1 = BayesLinear(input_dim=input_dim, output_dim=64, prior_mu=0, prior_sigma=1.)
+        # self.bnn2 = BayesLinear(input_dim=64, output_dim=32, prior_mu=0, prior_sigma=1.)
+        # self.fc = BayesLinear(input_dim=16, output_dim=output_dim,prior_mu=0, prior_sigma=1.)
+        self.bnn = BayesLinear(input_dim=input_dim, output_dim=16, prior_mu=0, prior_sigma=1.)
+
+        self.fc = BayesLinear(input_dim=16, output_dim=output_dim, prior_mu=0, prior_sigma=1.)
+   
+    def forward(self, x):
+        x = self.bnn(x)
+        x = self.relu(x)
+        predictions = self.fc(x)
+        # x = self.bnn1(x)
+        # x = self.relu(x)
+        # x = self.bnn2(x)
+        # x = self.tanh(x)
+        # x = self.bnn3(x)
+        # x = self.relu(x)
+        # predictions = self.fc(x)
+
+        return predictions
+
+
+    def log_prior(self):
+        # calculate the log prior over all the layers
+        # return self.bnn1.log_prior + self.bnn2.log_prior + self.bnn3.log_prior + self.fc.log_prior
+
+        return self.bnn.log_prior + self.fc.log_prior
+
+    def log_post(self):
+        # calculate the log posterior over all the layers
+        # return self.bnn1.log_post + self.bnn2.log_post + self.bnn3.log_post + self.fc.log_post
+
+        return self.bnn.log_post + self.fc.log_post
+
+
+    def sample_elbo(self, input, target, samples, device):
+        # we calculate the negative elbo, which will be our loss function
+        # initialize tensors
+        outputs = torch.zeros(samples, target.shape[0]).to(device)
+        log_priors = torch.zeros(samples)
+        log_posts = torch.zeros(samples)
+        log_likes = torch.zeros(samples)
+        # make predictions and calculate prior, posterior, and likelihood for a given number of samples
+        # 蒙特卡罗近似
+        for i in range(samples):
+            outputs[i] = self(input).reshape(-1)  # make predictions
+            log_priors[i] = self.log_prior()  # get log prior
+            log_posts[i] = self.log_post()  # get log variational posterior
+            log_likes[i] = Normal(outputs[i], self.noise_tol).log_prob(target.reshape(-1)).sum()  # calculate the log likelihood
+        # calculate monte carlo estimate of prior posterior and likelihood
+        log_prior = log_priors.mean()
+        log_post = log_posts.mean()
+        log_like = log_likes.mean()
+        # calculate the negative elbo (which is our loss function)
+        loss = log_post - log_prior - log_like
+        return loss
+
+
+class ATBNN_Model(nn.Module):
+    def __init__(self, input_dim, output_dim, hidden_dim, num_layers, num_heads, batch_size, max_seq_len):
+        super(ATBNN_Model, self).__init__()
+
+        self.feature_extractor = Transformer_FeatureExtractor(input_dim=input_dim,
+                                                              output_dim=hidden_dim,
+                                                              hidden_dim=hidden_dim,
+                                                              num_layers=num_layers,
+                                                              num_heads=num_heads,
+                                                              batch_size=batch_size,
+                                                              max_seq_len=max_seq_len)
+
+        self.bnn_regression = BNN_Regression(input_dim=hidden_dim,
+                                             output_dim=output_dim,
+                                             noise_tol=0.01)
+
+    def forward(self, x):
+        self.features = self.feature_extractor(x)
+        predictions = self.bnn_regression(self.features)
+        return predictions

paras.py

@@ -0,0 +1,14 @@
+
+
+attrib_feature = ['Current','Voltage','Environment_Temperature','Cell_Temperature','SOC']
+attrib_label = ['SOH']
+max_len = 200
+input_dim = len(attrib_feature)
+output_dim = 1
+hidden_dim = 64
+num_layers = 2
+num_heads = 4
+lr = 1e-3
+max_seq_len = 200
+batch_size = 5
+C_rated = 1.1

test_BNN.py

@@ -0,0 +1,127 @@
+
+import pickle
+
+import torch
+import torch.nn as nn
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+
+from torch.utils.data import Dataset, DataLoader
+
+import net_BNN
+
+# 使用已训练的模型进行推理
+
+def test_plot(dataloader,model,device,criterion):
+    total_loss = 0.0
+    num_samples = 0
+    num_sample = 10
+    model.eval()
+    with torch.no_grad():
+        predictions = []
+        true_labels = []
+        cov = []
+        # upp = []
+        # low = []
+
+        for test_features, test_labels in dataloader:
+            # outputs = model(test_features.to(device))
+
+            # MC sample
+            sample_output = torch.zeros(num_sample, test_labels.shape[0]).to(device)
+            for i in range(num_sample):
+                sample_output[i] = model(test_features.to(device)).reshape(-1)
+
+            outputs = torch.Tensor(sample_output.mean(dim=0).unsqueeze(1)).to(device)
+            covs = torch.Tensor(sample_output.std(dim=0).unsqueeze(1)).to(device)
+
+            loss = criterion(outputs, test_labels.to(device))
+            total_loss += loss.item() * test_features.size(0)
+            num_samples += test_features.size(0)
+
+            predictions.append((outputs).tolist())
+            cov.append(covs.tolist())
+            true_labels.append((test_labels).tolist())
+            # upp.append(np.percentile(sample_output.cpu().detach().numpy() * float(C_test),95).tolist())
+            # low.append(np.percentile(sample_output.cpu().detach().numpy() * float(C_test),5).tolist())
+
+        average_loss = total_loss / num_samples
+        print('Validation Loss: {:.8f}'.format(average_loss))
+    #
+
+    x = range(len(sum(predictions, [])))
+
+    pred_array = np.array(sum(predictions, [])).flatten()
+    var_array = np.array(sum(cov, [])).flatten()
+
+    plt.plot(sum(predictions,[]), label='Predictions')
+
+    plt.plot(sum(true_labels,[]), label='True Labels')
+    # plt.fill_between(x, upp, low, alpha=0.5, label='Confidence Interval')
+    plt.fill_between(x, pred_array + var_array, pred_array - var_array, alpha=0.5, label='Confidence Interval')
+
+    plt.legend()
+    plt.xlabel('Sample Index')
+    plt.ylabel('Cycle Capacity/Ah')
+    plt.show()
+
+#
+base_path = r'E:\member\ShiJH\Battery Datasets\SNL_18650_LFP Datasets\modified_dataset'
+attrib_feature = ['Current','Voltage','Environment_Temperature','Cell_Temperature','SOC']
+attrib_label = ['SOH']
+
+with open('./min_max_values.pkl', 'rb') as f:
+    min_val, max_val = pickle.load(f)
+
+max_len = 200
+input_dim = len(attrib_feature)
+output_dim = 1
+hidden_dim = 64
+num_layers = 2
+num_heads = 4
+lr = 1e-3
+max_seq_len = 200
+batch_size = 5
+C_rated = 1.1
+
+
+
+
+testdata_path = base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-3C_b_timeseries.csv')
+test_data = pd.read_csv(testdata_path)
+test_data['SOH'] = test_data['cycle capacity'] / test_data['cycle capacity'].values[0]
+# C_val = val_data[attrib_label].values[0]
+# scaler_val = train_dataset.scaler
+test_dataset = net_BNN.CycleDataset(
+    data=test_data,
+    attrib_x=attrib_feature,
+    attrib_y=attrib_label,
+    max_len=max_len,
+    C_rated=C_rated,
+    min_val=min_val,
+    max_val=max_val,
+    mode='test')
+test_dataloader = DataLoader(test_dataset, batch_size=batch_size,shuffle=False,drop_last=True)
+# 导入网络结构
+model = net_BNN.ATBNN_Model(
+input_dim = input_dim,
+output_dim = output_dim,
+hidden_dim = hidden_dim,
+num_layers = num_layers,
+num_heads = num_heads,
+batch_size = batch_size,
+max_seq_len= max_seq_len)
+
+# model.load_state_dict(torch.load("./model_B/model_epoch634_Trainloss0.00013560_ValLoss0.00107357.pt"))  #LOSS=0
+# model.load_state_dict(torch.load("./model_B/model_epoch2168_Trainloss0.00001729_ValLoss0.00107112.pt"))
+model.load_state_dict(torch.load("./model_epoch8876_Trainloss0.00001546_ValLoss0.00022519.pt"))
+
+# model.load_state_dict(torch.load("./model/model_epoch1.pt"))
+
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+model.to(device)
+criterion = nn.MSELoss(reduction='mean')
+
+
+test_plot(test_dataloader,model,device,criterion)

train_BNN.py

@@ -0,0 +1,246 @@
+
+import random
+
+import torch
+import torch.nn as nn
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+from torch.utils.data import Dataset, DataLoader
+
+import net_BNN
+
+
+def train(n_epochs,dataloader,val_dataloader,model,criterion,optimizer,device):
+
+    num_batches = len(dataloader)
+    num_sample = 10
+
+    model.train() #重要！设置模式
+    for epoch in range(n_epochs):
+        total_loss = 0
+        total_MSEloss = 0
+        for inputs,labels in dataloader:
+            inputs,labels = inputs.to(device),labels.to(device) #GPU
+            optimizer.zero_grad()
+
+            # MC sample
+            # sample_output = torch.zeros(num_sample, labels.shape[0]).to(device)
+            # for i in range(num_sample):
+            #     sample_output[i] = model(inputs).reshape(-1)
+            #
+            # outputs = torch.Tensor(sample_output.mean(dim=0).unsqueeze(1))
+
+            outputs = model(inputs)
+            features = model.features
+            loss = model.bnn_regression.sample_elbo(features, labels, 10, device)
+
+
+            MSEloss = criterion(outputs,labels)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+            total_MSEloss += MSEloss.item()
+
+        train_loss = total_loss / num_batches
+        train_MSEloss = total_MSEloss / num_batches
+
+        val_loss, val_MSEloss = val(val_dataloader,model,criterion,device)
+
+
+        # torch.save(model.state_dict(),".\model.pth")
+        torch.save(model.state_dict(), f"./model_B/model_epoch{epoch + 1 }_Trainloss{train_MSEloss:.8f}_ValLoss{val_MSEloss:.8f}.pt")
+        print('Epoch [{}/{}], Train_Loss: {:.8f}, Val_Loss: {:.8f}'.format(epoch + 1, num_epochs , train_loss,val_loss), end='   ')
+        print('Train_MSE_Loss: {:.8f}, Val_MSE_Loss: {:.8f}'.format(train_MSEloss, val_MSEloss))
+
+
+
+def val(dataloader,model,criterion,device):
+    val_loss = 0
+    num_batches = len(dataloader)
+    val_MSEloss = 0
+    num_sample = 10
+    model.eval() #重要！设置模式
+    with torch.no_grad():
+        for inputs,labels in dataloader:
+            inputs = inputs.to(device)
+            labels = labels.to(device) #GPU
+
+            # # MC sample
+            # sample_output = torch.zeros(num_sample, labels.shape[0]).to(device)
+            # for i in range(num_sample):
+            #     sample_output[i] = model(inputs).reshape(-1)
+            #
+            # outputs = torch.Tensor(sample_output.mean(dim=0).unsqueeze(1))
+            outputs = model(inputs)
+            features = model.features
+            loss = model.bnn_regression.sample_elbo(features, labels, 1, device)
+            # outputs = model(inputs)
+            # features = model.features.to(device)
+            # loss = model.bnn_regression.sample_elbo(features, labels, 1, device)
+            MSEloss = criterion(outputs,labels)
+            val_loss += loss.item()
+            val_MSEloss += MSEloss.item()
+    val_loss = val_loss / num_batches
+    val_MSEloss = val_MSEloss / num_batches
+
+    return val_loss, val_MSEloss
+
+
+def test_plot(dataloader,model,device,criterion):
+    total_loss = 0.0
+    num_samples = 0
+    model.eval()
+    with torch.no_grad():
+        predictions = []
+        true_labels = []
+        var = []
+        for test_features, test_labels in dataloader:
+            outputs, vars  = model(test_features.to(device))
+            loss = criterion(outputs, test_labels.to(device))
+            total_loss += loss.item() * test_features.size(0)
+            num_samples += test_features.size(0)
+
+            predictions.append(outputs.tolist())
+            var.append(vars.tolist())
+            true_labels.append(test_labels.tolist())
+
+        average_loss = total_loss / num_samples
+        print('Validation Loss: {:.8f}'.format(average_loss))
+    #
+    # predictions = [(np.array(x) * y_std + y_mean).tolist() for x in predictions]
+    # true_labels = [(np.array(x) * y_std + y_mean).tolist() for x in true_labels]
+    x = range(len(sum(predictions, [])))
+
+    pred_array = np.array(sum(predictions, [])).flatten()
+    var_array = np.array(sum(var, [])).flatten()
+
+    plt.plot(sum(predictions,[]), label='Predictions')
+
+    plt.plot(sum(true_labels,[]), label='True Labels')
+
+    plt.fill_between(x, pred_array + var_array, pred_array - var_array, alpha=0.5)
+
+    plt.legend()
+    plt.xlabel('Sample Index')
+    plt.ylabel('Cycle Capacity')
+    plt.show()
+
+
+
+def setup_seed(seed):
+   torch.manual_seed(seed)
+   torch.cuda.manual_seed_all(seed)
+   np.random.seed(seed)
+   random.seed(seed)
+   torch.backends.cudnn.deterministic = True
+
+# 设置随机数种子
+setup_seed(20)
+
+base_path = r'E:\member\ShiJH\Battery Datasets\SNL_18650_LFP Datasets\modified_dataset'
+# csv_files_list = [base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-1C_a_timeseries.csv'),
+#                   # base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-1C_b_timeseries.csv'),
+#                   base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-3C_a_timeseries.csv')]
+# train_data = pd.DataFrame()
+# cycle_index = 0
+# index_max = 0
+# for csv_file in csv_files_list:
+#         df = pd.read_csv(csv_file)
+#         C_ini = df['cycle capacity'].values[0]
+#         df['SOH'] = df['cycle capacity'] / C_ini
+#         index_max = df['Cycle_Index'].max()
+#         df['Cycle_Index'] = df['Cycle_Index'] + cycle_index
+#         cycle_index += index_max
+#         train_data = pd.concat([train_data, df], ignore_index=True)
+traindata_path = base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-3C_a_timeseries.csv')
+train_data = pd.read_csv(traindata_path)
+train_data['SOH'] = train_data['cycle capacity'] / train_data['cycle capacity'].values[0]
+
+# attrib_feature = ['Test_Time','Charge_Capacity','Discharge_Capacity','Voltage','Environment_Temperature','Cell_Temperature']
+attrib_feature = ['Current','Voltage','Environment_Temperature','Cell_Temperature','SOC']
+attrib_label = ['SOH']
+max_len = 200  # 初值100
+C_rated = 1.1
+C_train = train_data[attrib_label].values[0]
+train_dataset = net_BNN.CycleDataset(
+    data= train_data,
+    attrib_x=attrib_feature,
+    attrib_y=attrib_label,
+    max_len=max_len,
+    C_rated=C_rated,
+    mode='train')
+min_val, max_val = train_dataset.get_min_max_values()
+
+
+batch_size = 30
+# train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True,
+#                               collate_fn=train_dataset.pad_collate, drop_last=True)
+
+train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, drop_last=True)
+
+valdata_path = base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-3C_b_timeseries.csv')
+val_data = pd.read_csv(valdata_path)
+val_data['SOH'] = val_data['cycle capacity'] / val_data['cycle capacity'].values[0]
+# C_val = val_data[attrib_label].values[0]
+# scaler_val = train_dataset.scaler
+val_dataset = net_BNN.CycleDataset(
+    data=val_data,
+    attrib_x=attrib_feature,
+    attrib_y=attrib_label,
+    max_len=max_len,
+    C_rated=C_rated,
+    min_val=min_val,
+    max_val=max_val,
+    mode='val')
+
+# val_dataloader = DataLoader(tar_dataset, batch_size=batch_size,shuffle=False, collate_fn=tar_dataset.pad_collate,drop_last=True)
+val_dataloader = DataLoader(val_dataset, batch_size=batch_size,shuffle=False,drop_last=True)
+
+
+# testdata_path = base_path + str('\modified_SNL_18650_LFP_25C_0-100_0.5-1C_c_timeseries.csv')
+# test_data = pd.read_csv(testdata_path)
+# C_test = test_data[attrib_label].values[0]
+# test_dataset = net.CycleDataset(test_data, attrib_feature, attrib_label, C_test, max_len, C_rated,
+#                                 min_val=min_val, max_val=max_val, mode='test')
+# # test_dataloader = DataLoader(test_dataset, batch_size=batch_size,shuffle=False, collate_fn=test_dataset.pad_collate,drop_last=True)
+# test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, drop_last=True)
+
+
+# 初始化Transformer模型
+input_dim = len(attrib_feature)
+output_dim = 1
+hidden_dim = 64
+num_layers = 2
+num_heads = 4
+lr = 1e-4
+max_seq_len = 200
+
+
+# ATBNN_model = net.ATBNN_Model(input_dim, output_dim, hidden_dim, num_layers, num_heads, batch_size, max_seq_len)
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
+
+# 导入网络结构
+ATBNN_model = net_BNN.ATBNN_Model(
+input_dim = input_dim,
+output_dim = output_dim,
+hidden_dim = hidden_dim,
+num_layers = num_layers,
+num_heads = num_heads,
+batch_size = batch_size,
+max_seq_len= max_seq_len)
+# ATBNN_model.load_state_dict(torch.load("./model_BNN_new/model_epoch185_Trainloss0.01930173_ValLoss0.01682474.pt"))
+ATBNN_model.to(device)
+
+optimizer = torch.optim.Adam(ATBNN_model.parameters(), lr=lr)
+# optimizer = torch.optim.Adadelta(ATBNN_model.parameters(), lr=1.0, rho=0.9, eps=1e-6, weight_decay=0)
+# optimizer = torch.optim.SGD(ATBNN_model.parameters(),lr=lr)
+# scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer,gamma=0.9)
+criterion = nn.MSELoss(reduction='mean')
+num_epochs = 10000
+
+
+
+ATBNN_model.to(device)
+train(num_epochs, train_dataloader, val_dataloader, ATBNN_model, criterion, optimizer, device)
+# test_plot(test_dataloader, ATBNN_model, device, criterion)