réseau neuronal convolutif causal

Le réseau neuronal convolutif causal est un réseau neuronal convolutif spécial conçu pour les problèmes de causalité dans les données de séries chronologiques. Par rapport aux réseaux de neurones convolutifs conventionnels, les réseaux de neurones convolutifs causals présentent des avantages uniques en ce qu'ils conservent la relation causale des séries chronologiques et sont largement utilisés dans la prédiction et l'analyse des données de séries chronologiques.

L'idée centrale du réseau neuronal convolutionnel causal est d'introduire la causalité dans l'opération de convolution. Les réseaux neuronaux convolutifs traditionnels peuvent percevoir simultanément les données avant et après le point temporel actuel, mais dans la prévision des séries chronologiques, cela peut entraîner des problèmes de fuite d'informations. Parce que les résultats de la prédiction à l’heure actuelle seront affectés par les données à des instants futurs. Le réseau neuronal convolutif causal résout ce problème. Il ne peut percevoir que le point temporel actuel et les données précédentes, mais ne peut pas percevoir les données futures, garantissant ainsi la relation causale des données de séries chronologiques. Par conséquent, les réseaux de neurones convolutifs causals peuvent mieux gérer les problèmes de prédiction et d’analyse des données de séries chronologiques.

Il existe de nombreuses façons de mettre en œuvre des réseaux de neurones convolutifs causals, l'une des méthodes courantes consiste à utiliser des noyaux de convolution causale. Le noyau de convolution causale est un noyau de convolution spécial qui ne peut percevoir que le point temporel actuel et les données précédentes, mais ne peut pas percevoir les données futures. Cette conception garantit que les résultats de convolution ne seront pas perturbés par les données futures, permettant ainsi la causalité dans les données de séries chronologiques. Les réseaux de neurones convolutifs causals tirent parti de cette propriété pour mieux capturer les relations causales lors du traitement des données de séries chronologiques. Par conséquent, en introduisant des noyaux de convolution causale, les données de séries chronologiques peuvent être traitées efficacement et les performances du modèle peuvent être améliorées.

En plus des noyaux de convolution causale, il existe d'autres implémentations de réseaux neuronaux convolutifs causals, telles que l'introduction de pooling causal et de structures résiduelles. Le pooling causal est une opération de pooling spéciale qui préserve la relation causale des données de séries chronologiques. Dans le pooling causal, chaque fenêtre de pooling contient uniquement les données du moment actuel et avant, et n'inclut pas les données futures. Cela évite efficacement les fuites d’informations et améliore la stabilité et la robustesse du modèle.

Donnez un exemple simple. Tout d'abord, vous devez importer les bibliothèques et modules nécessaires :

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

Ensuite, lire et traiter les données :

data = pd.read_csv('temperature.csv')
scaler = MinMaxScaler(feature_range=(-1, 1))
data['scaled_temperature'] = scaler.fit_transform(data['temperature'].values.reshape(-1, 1))
data.drop(['temperature'], axis=1, inplace=True)

Ensuite, divisez l'ensemble de données en un ensemble d'entraînement et un ensemble de test :

train_size = int(len(data) * 0.8)
test_size = len(data) - train_size
train_data, test_data = data.iloc[0:train_size], data.iloc[train_size:len(data)]

Ensuite, définissez le modèle de réseau neuronal convolutionnel causal :

class CCN(nn.Module):
    def __init__(self, input_size, output_size, num_filters, kernel_size):
        super(CCN, self).__init__()
        self.conv1 = nn.Conv1d(input_size, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv2 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv3 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv4 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv5 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv6 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv7 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv8 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv9 = nn.Conv1d(num_filters, num_filters, kernel_size, padding=kernel_size - 1)
        self.conv10 = nn.Conv1d(num_filters, output_size, kernel_size, padding=kernel_size - 1)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = torch.relu(self.conv4(x))
        x = torch.relu(self.conv5(x))
        x = torch.relu(self.conv6(x))
        x = torch.relu(self.conv7(x))
        x = torch.relu(self.conv8(x))
        x = torch.relu(self.conv9(x))
        x = self.conv10(x)
        return x

Une fois la définition du modèle terminée, les données doivent être prétraitées afin qu'elles puissent être saisies dans le modèle. Nous convertissons les données en type Tensor de PyTorch et les convertissons en tenseur 3D, c'est-à-dire sous la forme de (batch_size, séquence_length, input_size) :

def create_sequences(data, seq_length):
    xs = []
    ys = []
    for i in range(len(data) - seq_length - 1):
        x = data[i:(i + seq_length)]
        y = data[i + seq_length]
        xs.append(x)
        ys.append(y)
    return np.array(xs), np.array(ys)

sequence_length = 10
trainX, trainY = create_sequences(train_data['scaled_temperature'], sequence_length)
testX, testY = create_sequences(test_data['scaled_temperature'], sequence_length)

trainX = torch.from_numpy(trainX).float()
trainY = torch.from_numpy(trainY).float()
testX = torch.from_numpy(testX).float()
testY = torch.from_numpy(testY).float()

trainX = trainX.view(-1, sequence_length, 1)
trainY = trainY.view(-1, 1)
testX = testX.view(-1, sequence_length, 1)
testY = testY.view(-1, 1)

Ensuite, définissons le processus de formation :

num_epochs = 1000
learning_rate = 0.001
num_filters = 64
kernel_size = 2

model = CCN(input_size=1, output_size=1, num_filters=num_filters, kernel_size=kernel_size)
criterion = nn.MSELoss()
optimizer= optim.Adam(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(trainX)
    loss = criterion(outputs, trainY)
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

Enfin, utilisez l'ensemble de test pour tester le modèle Évaluation :

with torch.no_grad():
    test_outputs = model(testX)
    test_loss = criterion(test_outputs, testY)
    print('Test Loss: {:.4f}'.format(test_loss.item()))

    test_outputs = scaler.inverse_transform(test_outputs.numpy())
    testY = scaler.inverse_transform(testY.numpy())

    test_outputs = np.squeeze(test_outputs)
    testY = np.squeeze(testY)

    plt.plot(test_outputs, label='Predicted')
    plt.plot(testY, label='True')
    plt.legend()
    plt.show()

Ce qui précède est le processus de mise en œuvre d'un modèle simple de réseau neuronal convolutif causal, qui peut être utilisé pour prédire les données de séries chronologiques. Il convient de noter que dans les applications réelles, le modèle devra peut-être être ajusté et optimisé en fonction de tâches spécifiques pour obtenir de meilleures performances.

Par rapport aux réseaux de neurones convolutifs traditionnels, les réseaux de neurones convolutifs causals présentent des avantages uniques lors du traitement des données de séries chronologiques. Cela peut efficacement éviter les problèmes de fuite d'informations et mieux préserver la relation causale des séries chronologiques. Par conséquent, dans la prédiction et l’analyse des données de séries chronologiques, les réseaux de neurones convolutifs causals ont montré de bonnes performances sur certaines tâches. Par exemple, dans des domaines tels que la reconnaissance vocale, le traitement du langage naturel et la prédiction des stocks, les réseaux neuronaux convolutifs causals ont été largement utilisés et ont obtenu des résultats impressionnants.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!