인과 컨벌루션 신경망

인과 컨벌루션 신경망은 시계열 데이터의 인과성 문제를 위해 설계된 특수 컨벌루션 신경망입니다. 기존 합성곱 신경망과 비교하여 인과 합성곱 신경망은 시계열의 인과 관계를 유지하는 데 고유한 장점이 있으며 시계열 데이터의 예측 및 분석에 널리 사용됩니다.

인과 컨볼루션 신경망의 핵심 아이디어는 컨볼루션 연산에 인과성을 도입하는 것입니다. 기존 컨벌루션 신경망은 현재 시점 이전과 이후의 데이터를 동시에 인식할 수 있지만, 시계열 예측에서는 이로 인해 정보 유출 문제가 발생할 수 있습니다. 왜냐하면 현재 시점의 예측 결과는 미래 시점의 데이터에 의해 영향을 받기 때문입니다. 인과 컨벌루션 신경망은 이 문제를 해결합니다. 현재 시점과 이전 데이터만 인식할 수 있고 미래 데이터는 인식할 수 없으므로 시계열 데이터의 인과 관계를 보장합니다. 따라서 인과 컨벌루션 신경망은 시계열 데이터의 예측 및 분석 문제를 더 잘 처리할 수 있습니다.

인과 컨벌루션 신경망을 구현하는 방법에는 여러 가지가 있으며, 일반적인 방법 중 하나는 인과 컨벌루션 커널을 사용하는 것입니다. 인과 컨볼루션 커널은 현재 시점과 이전 데이터만 인식할 수 있고 미래 데이터는 인식할 수 없는 특수 컨볼루션 커널입니다. 이 설계는 컨볼루션 결과가 미래 데이터에 의해 방해받지 않도록 보장하여 시계열 데이터의 인과성을 가능하게 합니다. 인과 컨벌루션 신경망은 이 속성을 활용하여 시계열 데이터를 처리할 때 인과 관계를 더 잘 포착합니다. 따라서 인과 컨벌루션 커널을 도입함으로써 시계열 데이터를 효과적으로 처리하고 모델의 성능을 향상시킬 수 있다.

인과 컨벌루션 커널 외에도 인과 풀링 및 잔차 구조 도입과 같은 인과 컨벌루션 신경망의 다른 구현이 있습니다. 인과풀링은 시계열 데이터의 인과관계를 보존하는 특수한 풀링 작업입니다. 인과 풀링에서 각 풀링 창에는 현재 시점과 이전의 데이터만 포함되며 미래 데이터는 포함되지 않습니다. 이는 정보 유출을 효과적으로 방지하고 모델의 안정성과 견고성을 향상시킵니다.

먼저 필요한 라이브러리와 모듈을 가져와야 합니다.

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

그런 다음 데이터를 읽고 처리합니다.

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)

그런 다음 데이터 세트를 훈련 세트와 테스트 세트로 나눕니다.

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

다음으로 인과 컨벌루션 신경망 모델을 정의합니다.

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

모델 정의가 완료되면 데이터를 모델에 입력할 수 있도록 전처리해야 합니다. 데이터를 PyTorch의 Tensor 유형으로 변환하고 이를 3D 텐서, 즉 ​​(batch_size, 시퀀스_길이, 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)

다음으로 학습 프로세스를 정의합니다.

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

마지막으로 테스트 세트를 사용합니다. 모델 테스트하기 평가:

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

위는 시계열 데이터를 예측하는 데 사용할 수 있는 간단한 인과 컨벌루션 신경망 모델의 구현 과정입니다. 실제 애플리케이션에서는 더 나은 성능을 달성하기 위해 특정 작업에 따라 모델을 조정하고 최적화해야 할 수도 있습니다.

기존의 컨벌루션 신경망과 비교하여 인과 컨볼루션 신경망은 시계열 데이터를 처리할 때 고유한 이점을 갖습니다. 정보 유출 문제를 효과적으로 방지하고 시계열의 인과 관계를 더 잘 보존할 수 있습니다. 따라서 시계열 데이터의 예측 및 분석에서 인과 컨벌루션 신경망은 일부 작업에서 좋은 성능을 보였습니다. 예를 들어, 음성 인식, 자연어 처리, 주식 예측과 같은 분야에서는 인과 컨벌루션 신경망이 널리 사용되어 몇 가지 인상적인 결과를 얻었습니다.

위 내용은 인과 컨벌루션 신경망의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!