Не удается подогнать ИНС к “простому” набору данных?

Мне действительно трудно смоделировать набор данных, который я получил, проводя эксперименты. Конкретно это временные ряды (онлайн) данных измерений, а целевые параметры – это кинетические параметры, которые я подгонял под каждый дискретный временной интервал (1 час) химической реакции. Я думал, что это будет довольно простая задача моделирования, поскольку публикации на такие темы существуют. Однако речь идет о другой химической реакции. Я делаю что-то не так? Итак, Var1 – это одно измерение. Var2 – это производная измерения Var1 в той же точке времени. Var3 – это другое измерение. А Var4 – производная Var3 в этой же точке времени. В следующем я предоставлю вам мой набор данных и код, который я использовал. Любая помощь будет очень и очень признательна.

Я попробовал различные структуры моделей, и ничто, похоже, не помогает. Вот код, который я использовал для подгонки ANN:

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from matplotlib import pyplot as plt
from copy import deepcopy
from scipy.integrate import odeint

# Установка случайного семени для воспроизводимости
rnd = np.random.RandomState(MAIN.rnd_seed)
torch.manual_seed(MAIN.rnd_seed)

# Загрузка данных и кинетических параметров
data = pd.read_csv("data.csv")

# Стандартизация данных
mean = np.mean(stacked_data, 0, keepdims=True)
stdv = np.std(stacked_data, 0, keepdims=True)

def standardize(data):
    return {k: (x - mean) / stdv for k, x in data.items()}

stan_data = standardize(data)

# Установка индексов для входа (X) и промежуточных (U)
x_index = ['Var1', 'Var2', 'Var3', 'Var4']
u_index = ['Obj1', 'Obj2']

# %% <Определение модели ANN>
class ANN(nn.Module):
    def __init__(self, hyprams):
        super().__init__()
        self.input_size = hyprams['input_size']
        self.hidden_size = hyprams['hidden_size']
        self.output_size = hyprams['output_size']
        self.activation = nn.Tanh()
        sizes = [self.input_size, *self.hidden_size, self.output_size]
        self.linears = nn.ModuleList([nn.Linear(i, j) for i, j in zip(sizes[:-1], sizes[1:])])

    def forward(self, x):
        x = x.float()
        for linear in self.linears[:-1]:
            x = linear(x)
            x = self.activation(x)
        x = self.linears[-1](x)
        return x * 2

    def init_params(self):
        for linear in self.linears:
            torch.nn.init.xavier_normal_(linear.weight.data)
            torch.nn.init.zeros_(linear.bias)

# %% <Определение тренера ANN>
class ANN_trainer:
    def __init__(self, hyprams, x_index, u_index):
        self.dtype = torch.float
        self.hyprams = hyprams
        self.x_index = x_index
        self.u_index = u_index

    def fit(self, data_train, data_valid):
        f = lambda x1: np.row_stack(np.transpose(x1, axes=(2, 0, 1)))
        g = lambda x2: np.row_stack([f(x1) for x1 in x2.values()])
        data_train = torch.from_numpy(g(data_train)).type(self.dtype)
        self.x_train = data_train[:, self.x_index]
        self.y_train = data_train[:, self.u_index]
        data_valid = torch.from_numpy(g(data_valid)).type(self.dtype)
        self.x_valid = data_valid[:, self.x_index]
        self.y_valid = data_valid[:, self.u_index]

        self.hyprams['input_size'] = len(self.x_index)
        self.hyprams['output_size'] = len(self.u_index)

        self.ANN = ANN(self.hyprams)
        self.ANN.init_params()

        self.optimizer = optim.Adam(self.ANN.parameters(), lr=self.hyprams['learning_rate'])
        self.loss_fn = nn.MSELoss()

        self.training_history = np.zeros((self.hyprams['epochs'], 3))
        for epoch in range(self.hyprams['epochs']):
            self.optimizer.zero_grad()
            y_train_pred = self.ANN(self.x_train)
            training_loss = self.loss_fn(self.y_train, y_train_pred)
            training_loss.backward()
            self.optimizer.step()

            y_valid_pred = self.ANN(self.x_valid)
            validation_loss = self.loss_fn(self.y_valid, y_valid_pred)
            self.training_history[epoch, 0] = epoch
            self.training_history[epoch, 1] = training_loss
            self.training_history[epoch, 2] = validation_loss

    def parity_plot(self, y_true, y_pred, title="Диаграмма соответствия", xlabel="Истинные значения", ylabel="Предсказанные значения"):
        plt.figure(figsize=(6, 6))
        plt.scatter(y_true, y_pred, edgecolors=(0, 0, 0))
        plt.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()], 'k--', lw=2)
        plt.xlabel(xlabel)
        plt.ylabel(ylabel)
        plt.title(title)
        plt.grid(True)
        plt.show()

    def fit_aggregate(self, data_trainval):
        self.aggregate_ANN = []
        training_history = []
        for k in data_trainval.keys():
            data_train = {i: x for i, x in data_trainval.items() if i != k}
            data_valid = {k: data_trainval[k]}
            self.fit(data_train, data_valid)
            self.aggregate_ANN.append(deepcopy(self.ANN))
            training_history.append(self.training_history)
        self.training_history = np.mean(training_history, axis=0)

    def predict(self, x):
        y_aggregate = [ANN(x) for ANN in self.aggregate_ANN]
        y_aggregate = torch.dstack(y_aggregate)
        y_mean = torch.mean(y_aggregate, dim=2)
        y_std = torch.std(y_aggregate, dim=2)
        return y_mean, y_std

# %% <Определение гибридной модели>
class HybridModel(ANN_trainer):
    def __init__(self, hyprams, x_index, u_index):
        super().__init__(hyprams, x_index, u_index)

# %% <Обучение и тестирование гибридной модели>
hyprams = {'hidden_size': [6], 'learning_rate': 0.003, 'epochs': 2000}
train_split = MAIN.train_test_split['train']
test_split = MAIN.train_test_split['test']

data_train = {x: stan_data[x] for x in train_split}
data_test = {x: stan_data[x] for x in test_split}

hyb_model = HybridModel(hyprams, x_index, u_index)
hyb_model.fit_aggregate(data_train)

# Диаграмма соответствия
y_mean, y_std = hyb_model.predict(hyb_model.x_valid)
hyb_model.parity_plot(hyb_model.y_valid.detach().numpy(), y_mean.detach().numpy(), title="Итоговая диаграмма соответствия после предсказания")

print("Завершено")

```