rangkaian neural convolutional sebab

Rangkaian neural convolutional kausal ialah rangkaian neural convolutional khas yang direka untuk masalah kausalitas dalam data siri masa. Berbanding dengan rangkaian neural convolutional konvensional, rangkaian neural convolutional kausal mempunyai kelebihan unik dalam mengekalkan hubungan kausal siri masa dan digunakan secara meluas dalam ramalan dan analisis data siri masa.

Idea teras rangkaian neural convolutional kausal adalah untuk memperkenalkan kausalitas dalam operasi konvolusi. Rangkaian saraf konvolusional tradisional secara serentak boleh melihat data sebelum dan selepas titik masa semasa, tetapi dalam ramalan siri masa, ini mungkin membawa kepada masalah kebocoran maklumat. Kerana keputusan ramalan pada titik masa semasa akan dipengaruhi oleh data pada titik masa akan datang. Rangkaian saraf konvolusi penyebab menyelesaikan masalah ini Ia hanya dapat melihat titik masa semasa dan data sebelumnya, tetapi tidak dapat melihat data masa depan, dengan itu memastikan hubungan sebab akibat data siri masa. Oleh itu, rangkaian neural convolutional kausal boleh mengendalikan masalah ramalan dan analisis data siri masa dengan lebih baik.

Terdapat banyak cara untuk melaksanakan rangkaian neural convolutional kausal, salah satu kaedah yang biasa digunakan ialah menggunakan kernel convolutional kausal. Kernel lilitan kausal ialah kernel lilitan khas yang hanya boleh melihat titik masa semasa dan data sebelumnya, tetapi tidak dapat melihat data masa hadapan. Reka bentuk ini memastikan bahawa hasil lilitan tidak akan diganggu oleh data masa hadapan, sekali gus membolehkan kausalitas dalam data siri masa. Rangkaian neural convolutional kausal memanfaatkan sifat ini untuk menangkap perhubungan kausal dengan lebih baik apabila memproses data siri masa. Oleh itu, dengan memperkenalkan kernel lilitan kausal, data siri masa boleh diproses dengan berkesan dan prestasi model boleh dipertingkatkan.

Selain kernel lilitan kausal, terdapat pelaksanaan lain rangkaian neural convolutional kausal, seperti pengenalan pengumpulan kausal dan struktur sisa. Pengumpulan sebab-sebab ialah operasi pengumpulan khas yang mengekalkan hubungan sebab-akibat data siri masa. Dalam pengumpulan sebab, setiap tetingkap pengumpulan hanya mengandungi data pada titik masa semasa dan sebelum, dan tidak termasuk data masa hadapan. Ini secara berkesan mengelakkan kebocoran maklumat dan meningkatkan kestabilan dan keteguhan model.

Beri contoh mudah Mula-mula, anda perlu mengimport perpustakaan dan modul yang diperlukan:

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

Kemudian, baca dan proses data:

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)

Kemudian, bahagikan set data kepada set latihan dan set ujian:

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)]

Seterusnya, tentukan model rangkaian neural konvolusi penyebab:

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

Selepas definisi model selesai, data perlu dipraproses supaya ia boleh dimasukkan ke dalam model. Kami menukar data kepada jenis Tensor PyTorch dan menukarnya kepada tensor 3D, iaitu, dalam bentuk (saiz_kelompok, panjang_jujukan, saiz_input):

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)

Seterusnya, tentukan proses latihan:

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()))

Akhir sekali, gunakan set ujian untuk menguji model Penilaian:

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()

Di atas ialah proses pelaksanaan model rangkaian neural konvolusi penyebab mudah, yang boleh digunakan untuk meramal data siri masa. Perlu diingatkan bahawa dalam aplikasi sebenar, model mungkin perlu diselaraskan dan dioptimumkan mengikut tugas tertentu untuk mencapai prestasi yang lebih baik.

Berbanding dengan rangkaian neural convolutional tradisional, rangkaian neural convolutional kausal mempunyai kelebihan unik apabila memproses data siri masa. Ia boleh mengelakkan masalah kebocoran maklumat dengan berkesan dan memelihara hubungan sebab akibat siri masa dengan lebih baik. Oleh itu, dalam ramalan dan analisis data siri masa, rangkaian neural convolutional kausal telah menunjukkan prestasi yang baik pada beberapa tugas. Contohnya, dalam bidang seperti pengecaman pertuturan, pemprosesan bahasa semula jadi dan ramalan stok, rangkaian saraf konvolusi penyebab telah digunakan secara meluas dan telah mencapai beberapa hasil yang mengagumkan.

Atas ialah kandungan terperinci rangkaian neural convolutional sebab. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!