国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

<samp id="ukwgo"></samp>

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）

1年前作者：Star_KeyW分類：Toy博客閱讀(25)違法舉報

這篇具有很好參考價值的文章主要介紹了基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

目錄

一、數據集

二、任務目標

三、代碼實現

1、從本地路徑中讀取數據文件

2、數據歸一化

3、創(chuàng)建配置類，將LSTM的各個超參數聲明為變量，便于后續(xù)使用

4、創(chuàng)建時間序列數據

5、劃分數據集

6、將數據轉化為PyTorch張量

7、將數據加載成迭代器

8、定義LSTM網絡

9、創(chuàng)建LSTM實例

10、訓練模型

11、模型驗證

12、繪制圖像

13、完整版

一、數據集

? ? ? ? 自建數據集--【load.xlsx】。包含2列：

date列（時間列，記錄2022年6月2日起始至2023年12月31日為止，日度數據）
price列（價格列，記錄日度數據對應的某品牌衣服的價格，浮點數）

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

二、任務目標

? ? ? ? 實現基于時間序列的單特征價格預測

三、代碼實現

1、從本地路徑中讀取數據文件

read_excel函數讀取Excel文件（read_csv用來讀取csv文件），并設置為DataFrame對象
index_col='date'將'date'列設置為DataFrame的索引
.values屬性獲取price列的值，pandas會將對應數據轉換為NumPy數組

# 字符串前的r表示一個"原始字符串"，raw string
# 文件路徑中包含多個反斜杠。如果我們不使用原始字符串（即不使用r前綴），那么Python會嘗試解析\U、\N等作為轉義序列，這會導致錯誤
data = pd.read_excel(r'E:\load.xlsx', index_col='date')
# print(data)
prices = data['price'].values
# print(prices)

打印data：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

打印prices：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

2、數據歸一化

歸一化：將原始數據的大小轉化為[0,1]之間，采用最大-最小值歸一化
- 數值過大，造成神經網絡計算緩慢
- 在多特征任務中，存在多個特征屬性，但神經網絡會認為數值越小的，影響越小。所以可能關鍵屬性A的值很小，不重要屬性B的值卻很大，造成神經網絡的混淆
scikit-learn的轉換器通常期望輸入是二維的，其中每一行代表一個樣本，每一列代表一個特征
- prices.reshape(-1, 1) 用于確保 prices 是一個二維數組，即使它只有一個特征列
- -1的意思是讓 NumPy 自動計算該軸上的元素數量，以保持原始數據的元素總數不變
- fit方法計算了數據中每個特征的最小值和最大值，這些值將被用于縮放
- transform方法使用這些統(tǒng)計信息來實際縮放數據，將其轉換到 [0, 1] 范圍內

scaler = MinMaxScaler(feature_range=(0, 1))
scaled_prices = scaler.fit_transform(prices.reshape(-1, 1)) # 二維數組
# print(scaled_prices)

打印歸一化后的價格數據：?

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

3、創(chuàng)建配置類，將LSTM的各個超參數聲明為變量，便于后續(xù)使用

timestep：時間步長，滑動窗口大小
feature_size：每個步長對應的特征數量，這里只使用1維，即每天的價格數據
batch_size：批次大小，即一次性送入多少個數據（一時間步長為單位）進行訓練
output_size：單輸出任務，輸出層為1，預測未來1天的價格
hidden_size：隱藏層大小，即神經元個數
num_layers：神經網絡的層數
learning_rate：學習率
epochs：迭代輪數，即總共要讓神經網絡訓練多少輪，全部數據訓練一遍成為一輪
best_loss：記錄損失

class Config():
    timestep = 7  # 時間步長，滑動窗口大小
    feature_size = 1 # 每個步長對應的特征數量，這里只使用1維，每天的價格數據
    batch_size = 1 # 批次大小
    output_size = 1 # 單輸出任務，輸出層為1，預測未來1天的價格
    hidden_size = 128 # 隱藏層大小
    num_layers = 1 # lstm的層數
    learning_rate = 0.0001 # 學習率
    epochs = 500 # 迭代輪數
    model_name = 'lstm' # 模型名
    best_loss = 0  # 記錄損失
config = Config()

4、創(chuàng)建時間序列數據

通過滑動窗口移動獲取數據，時間步內數據作為特征數據，時間步外1個數據作為標簽數據
通過序列的切片實現特征和標簽的劃分
通過np.array將數據轉化為NumPy數組

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

# 創(chuàng)建時間序列數據
X, y = [], []
for i in range(len(scaled_prices) - config.timestep):
    # 從當前索引i開始，取sequence_length個連續(xù)的價格數據點，并將其作為特征添加到列表 X 中。
    X.append(scaled_prices[i: i + config.timestep])
    # 將緊接著這sequence_length個時間點的下一個價格數據點作為目標添加到列表y中。
    y.append(scaled_prices[i + config.timestep])
X = np.array(X)
y = np.array(y)

打印特征數據：?

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

打印標簽數據：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

5、劃分數據集

按照9:1的比例劃分訓練集和測試集
因為時間序列數據具有時序性，用過去時間數據預測新時間數據，要保證時間有序
測試數據為時間序列的末尾數據

# 確定測試集的大小
test_size = int(len(scaled_prices) * 0.1)

# 為了確保訓練集和測試集的劃分不會破壞時間序列的連續(xù)性，我們需要從時間序列的開頭開始劃分訓練集。
X_train = X[:-test_size]
y_train = y[:-test_size]
X_test = X[-test_size:]
y_test = y[-test_size:]

6、將數據轉化為PyTorch張量

PyTorch使用張量作為其基本數據結構，類似于NumPy中的ndarray，但張量可以在GPU上進行加速計算
神經網絡通常需要單精度浮點數進行計算

X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)

打印X_train_tensor：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

打印y_train_tensor：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

7、將數據加載成迭代器

使用TensorDataset從PyTorch的torch.utils.data模塊創(chuàng)建訓練數據集和測試數據集。這些數據集對象可以方便地與PyTorch的數據加載器（如DataLoader）一起使用，以在模型訓練和評估過程中提供批量數據
當你使用DataLoader來加載訓練和測試數據集時，它會自動將數據分批處理成符合LSTM網絡的輸入格式：(batch_size, sequence_length, feature_size)
- 這里的batch_size由config.batch_size指定
- sequence_length是config.timestep
- feature_size在這個例子中是1，因為只有一個特征
shuffle=False：指定是否在每個訓練時開始時隨機打亂數據。因為時間序列數據，要保證數據的有序性

# 形成訓練數據集
train_data = TensorDataset(X_train_tensor, y_train_tensor)
test_data = TensorDataset(X_test_tensor, y_test_tensor)

# 將數據加載成迭代器
train_loader = torch.utils.data.DataLoader(train_data, batch_size=config.batch_size, shuffle=False)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=config.batch_size, shuffle=False)

打印迭代器：

基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）,深度學習,lstm,人工智能,深度學習

8、定義LSTM網絡

（1）配置LSTM網絡的基本超參數[特征大小、隱藏層大小、網絡層數、輸出層大小]

（2）定義網絡最后的全連接層[fc]

（3）定義神經網絡模型的前向傳播過程[forward( )]

? ? ? ? ①獲取輸入數據的批量大小

? ? ? ? ②初始化隱藏層狀態(tài)

? ? ? ? ③LSTM運算

? ? ? ? ④獲取LSTM網絡的最后一個時間步的輸出，LSTM網絡的輸出形狀：(batch_size, ????????????sequence_length, hidden_size)

? ? ? ? ⑤輸出經過全連接層，產生一個值

torch.nn.Module類是所有神經網絡模塊的基類
參數batch_first=True意味著輸入張量的形狀應該是[batch_size, sequence_length, input_size]
在PyTorch中，全連接層被命名為 fc（代表“fully connected”）
- 全連接層通常是通過 nn.Linear 類來實現的
- 在神經網絡的定義中創(chuàng)建一個nn.Linear實例并將其賦值給一個成員變量（如 self.fc）時，實際上是在網絡中嵌入了一個全連接層
- 這個層會在forward方法中被調用，對LSTM的輸出進行線性變換

class LSTM(nn.Module):
    # __init__方法用于初始化模型的各種層和參數
    def __init__(self, feature_size, hidden_size, num_layers, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        # 參數batch_first=True意味著輸入張量的形狀應該是[batch_size, sequence_length, input_size]
        self.lstm = nn.LSTM(feature_size, hidden_size, num_layers, batch_first=True)
        # input_size 是全連接層的輸入特征數，output_size 是輸出特征數
        self.fc = nn.Linear(hidden_size, output_size)

    # forward方法定義了輸入數據通過模型各層的前向傳播過程。
    # 模型的forward方法被自動調用，并且X_train_batch作為參數傳遞給這個方法。
    def forward(self, x, hidden=None):
        # 獲取輸入數據x的第一維度的大小，即批量大小（batch size）
        # x的形狀通常是 (batch_size, sequence_length, feature_size)
        batch_size = x.shape[0]

        # 初始化隱藏層狀態(tài)
        # 如果隱藏狀態(tài)hidden沒有被提供（即為 None），則使用全零張量來初始化LSTM的隱藏狀態(tài)h_0和細胞狀態(tài)c_0
        if hidden is None:
            h_0 = x.data.new(self.num_layers, batch_size, self.hidden_size).fill_(0).float()
            c_0 = x.data.new(self.num_layers, batch_size, self.hidden_size).fill_(0).float()
        else:
            h_0, c_0 = hidden

        # LSTM運算
        # 將輸入數據 x 和初始化的隱藏狀態(tài) (h_0, c_0) 傳遞給LSTM層，進行前向計算。
        # LSTM層的輸出包含兩部分：輸出序列l(wèi)stm_output 和 最終的隱藏狀態(tài)
        # LSTM層在其內部單元中使用了sigmoid和tanh激活函數來處理輸入和循環(huán)連接
        # self.lstm(x, (h_0, c_0))時，LSTM層內部的計算已經包括了激活函數的應用
        lstm_output, (h_0, c_0) = self.lstm(x, (h_0, c_0))

        # 取最后一個時間步的輸出
        # lstm_output 的形狀是 (batch_size, sequence_length, hidden_size)
        # :：第一個維度（批量維度）取全部。
        # -1：第二個維度（序列長度維度）取最后一個元素。在 Python 中，-1 索引表示從末尾開始計數的第一個元素。
        # :：第三個維度（隱藏層大小維度）取全部。
        final_output = lstm_output[:, -1, :]

        # 全連接層
        # 回歸任務的目標是預測一個連續(xù)值，而不是進行分類，因此輸出層應該能夠直接產生實數范圍的輸出
        # 在PyTorch中，如果你不指定激活函數，nn.Linear層默認就是線性的，即它不會對其輸出應用任何非線性函數
        output = self.fc(final_output)

        return output

9、創(chuàng)建LSTM實例

（1）通過創(chuàng)建的LSTM類傳入參數

（2）定義損失函數

（3）定義梯度下降優(yōu)化器

model.parameters()是一個包含模型所有可訓練參數的迭代器
Adam是一種自適應學習率的優(yōu)化算法，它結合了Momentum和RMSprop的思想，通常在很多任務上表現良好

# 創(chuàng)建了一個LSTM模型的實例
model = LSTM(config.feature_size, config.hidden_size, config.num_layers, config.output_size)
# 損失函數
loss_function = nn.MSELoss()
# 創(chuàng)建一個Adam優(yōu)化器的實例，用于在訓練過程中更新模型的權重
optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)

10、訓練模型

（1）調用train()方法模型訓練

（2）利用訓練數據集進行模型預測

（3）計算預測值和真實值之間的誤差

（4）利用誤差反向傳播

（5）使用優(yōu)化器更新權重

11、模型驗證

（1）調用eval()方法模型驗證

（2）傳入測試數據集傳入模型，得出測試數據集的預測值

（3）計算預測值和真實值之間的誤差

（4）累加損失

（5）利用 損失累加值和測試集長度 計算平均損失

（6）將 測試集的預測值和真實值 組合成數組

（7）將預測值和真實值 反歸一化，轉化為真實值文章來源地址http://www.zghlxwxcb.cn/news/detail-853831.html

為什么要將模型的輸出或目標變量轉換為原始尺度呢？
（1）解釋性：當模型的輸出被縮放或標準化時，它們可能不再具有直觀的解釋性。
????????例如，如果目標變量是股票價格，并且您使用 MinMaxScaler 將其縮放到 [0, 1] 范圍內，那么模型輸出的數值就不再代表實際的股票價格。
       通過逆變換，您可以將輸出重新映射到其原始尺度，從而更容易地解釋和溝通結果。
（2）性能評估：在評估模型性能時，通常需要使用與原始數據尺度相同的指標。
        例如，如果您要計算均方誤差（MSE）或平均絕對誤差（MAE），則需要在原始尺度上進行這些計算，以便正確評估預測誤差的大小。
（3）可視化：當您想要將模型的預測結果與實際數據一起可視化時，使用原始尺度可以確保圖表和圖形具有正確的軸標簽和比例，從而更容易進行視覺比較。

train()函數是torch.nn.Module類的一個方法
eval()驗證模型性能

# 訓練模型
for epoch in range(config.epochs):
    # train()函數是torch.nn.Module類的一個方法
    model.train()
    train_loss_sum = 0.0
    # 形成進度條
    train_bar = tqdm(train_loader)
    for data in train_bar:
        X_train_batch, y_train_batch = data
        # 這行代碼清除了之前優(yōu)化步驟中累積的所有梯度。由于PyTorch在反向傳播時默認會累積梯度，所以在每個新的優(yōu)化步驟開始之前，需要手動清除它們。
        optimizer.zero_grad()
        # 通過模型進行前向傳播以獲取預測值（y_train_pred）
        y_train_pred = model(X_train_batch)
        # 預測值和真實值（y_train_batch）之間的損失。
        loss = loss_function(y_train_pred, y_train_batch.view(-1))
        # 進行反向傳播。它計算損失相對于模型參數的梯度，這些梯度之后將被用于更新模型的權重。
        loss.backward()
        # 根據之前計算的梯度來更新模型的權重。具體來說，它使用之前定義的Adam優(yōu)化器來調整模型的參數以最小化損失。
        optimizer.step()
        train_bar.desc = "train epoch[{} / {}] loss:{:.3f}".format(epoch + 1, config.epochs, loss)

    # 當你想要使用已經訓練好的模型來預測新的、未見過的數據時，你需要確保模型處于評估模式
    # 在每個epoch結束后，,模型驗證
    # model.eval()會改變模型中特定層的行為，如Dropout和BatchNorm層，使它們在推理時保持固定
    # 在訓練模式中，這些層可能會引入隨機性或根據訓練數據的統(tǒng)計信息進行歸一化；而在評估模式中，它們會保持確定性行為，以確保輸出的一致性
    model.eval()
    test_loss_sum = 0.0
    y_test_preds = [] # 初始化一個空列表來保存所有預測結果
    y_test_true = []  # 初始化一個空列表來保存所有真實值
    test_bar = tqdm(test_loader)
    # 使用了torch.no_grad()上下文管理器來確保在驗證過程中不計算梯度，因為不需要更新模型的權重,從而節(jié)省內存
    with torch.no_grad():
        for data in test_bar:
            X_test_batch, y_test_batch = data
            # 將測試數據X_test傳遞給模型，并接收模型的預測輸出
            # 由于梯度計算被禁用，這個前向傳播過程會更快，并且不會消耗額外的資源來存儲梯度信息。
            y_test_pred = model(X_test_batch) # 獲取當前批次的預測結果
            # 通常用于累積測試損失（test loss）
            test_loss = loss_function(y_test_pred, y_test_batch.view(-1))          
            # test_loss.item()將PyTorch張量（tensor）中的單個值（在這種情況下是一個標量，即損失值）轉換為Python數字（通常是浮點數）
            # 在評估模型性能時，能夠計算整個測試集的平均損失，而不僅僅是單個批次或樣本的損失
            # 通過累積所有批次或樣本的損失，并在最后除以總的批次數或樣本數，你可以得到一個更準確的模型性能估計
            test_loss_sum += test_loss.item()  # 累加損失
            y_test_preds.append(y_test_pred.detach().numpy())  # 將預測結果追加到列表中
            y_test_true.append(y_test_batch.detach().numpy())  # 將真實值追加到列表中
    test_loss_avg = test_loss_sum / len(test_loader)  # 計算平均測試損失
    y_test_preds= np.concatenate(y_test_preds, axis=0)  # 將所有批次的預測結果連接成一個數組
    y_test_true = np.concatenate(y_test_true, axis=0)  # 將所有批次的真實值連接成一個數組

    # 反歸一化預測值和真實值
    # scaler.inverse_transform(...)：使用之前擬合的 MinMaxScaler 將縮放后的預測值轉換回其原始尺度
    # 以便在原始尺度上評估模型性能
    y_test_preds_unnormalized = scaler.inverse_transform(y_test_preds)
    y_test_true_unnormalized = scaler.inverse_transform(y_test_true.reshape(-1, 1))

    if test_loss_avg < config.best_loss:
        config.best_loss = test_loss_avg
print("訓練結束")

12、繪制圖像

# 繪制真實值和預測值的對比圖
# 創(chuàng)建一個新的圖形窗口，并設置其大小為寬10英寸、高5英寸。
plt.figure(figsize=(10, 5))
# 繪制真實值（y_test）的折線圖，并為其添加標簽 "True Values"。
plt.plot(y_test_true_unnormalized, label='True Values')
# 繪制預測值（predicted）的折線圖。這條線被標記為 "Predicted Values"。
plt.plot(y_test_preds_unnormalized, label='Predictions')
plt.title('Comparison of True Values and Predictions')
plt.xlabel('Time Steps')
plt.ylabel('Prices')
plt.legend()
plt.show()

13、完整版

import pandas as pd
import numpy as np
import torch
from sklearn.preprocessing import MinMaxScaler
from torch import nn
from torch.utils.data import TensorDataset
from tqdm import tqdm
import matplotlib.pyplot as plt

class Config():
    timestep = 1  # 時間步長，滑動窗口大小
    feature_size = 1 # 每個步長對應的特征數量，這里只使用1維，每天的價格數據
    batch_size = 1 # 批次大小
    output_size = 1 # 單輸出任務，輸出層為1
    hidden_size = 128 # 隱藏層大小
    num_layers = 1 # bilstm的層數
    learning_rate = 0.0001 # 學習率
    epochs = 500 # 迭代輪數
    model_name = 'lstm' # 模型名
    best_loss = 0  # 記錄損失
config = Config()

qy_data = pd.read_excel(r'C:\Users\Desktop\load.xlsx', index_col='date')
prices = qy_data['price'].values

scaler = MinMaxScaler()
scaled_prices = scaler.fit_transform(prices.reshape(-1, 1))

# 創(chuàng)建時間序列數據
X, y = [], []
for i in range(len(scaled_prices) - config.timestep):
    X.append(scaled_prices[i: i + config.timestep])
    y.append(scaled_prices[i + config.timestep])
X = np.array(X)
y = np.array(y)

# 確定測試集的大小
test_size = int(len(scaled_prices) * 0.1)

# 創(chuàng)建訓練和測試數據
X_train, y_train = [], []
X_test, y_test = [], []

# 構建訓練數據
for i in range(len(scaled_prices) - config.timestep - test_size):
    X_train.append(scaled_prices[i:i + config.timestep])
    y_train.append(scaled_prices[i + config.timestep])

# 構建測試數據（取時間序列末尾的數據）
for i in range(len(scaled_prices) - config.timestep - test_size, len(scaled_prices) - config.timestep):
    X_test.append(scaled_prices[i:i + config.timestep])
    y_test.append(scaled_prices[i + config.timestep])

# 將列表轉換為NumPy數組
X_train = np.array(X_train)
y_train = np.array(y_train)
X_test = np.array(X_test)
y_test = np.array(y_test)

# 將數據轉換為PyTorch張量
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)

# 形成訓練數據集
train_data = TensorDataset(X_train_tensor, y_train_tensor)
test_data = TensorDataset(X_test_tensor, y_test_tensor)

# 將數據加載成迭代器
train_loader = torch.utils.data.DataLoader(train_data, batch_size=config.batch_size, shuffle=False)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=config.batch_size, shuffle=False)

# 定義LSTM網絡
class LSTM(nn.Module):
    # __init__方法用于初始化模型的各種層和參數
    def __init__(self, feature_size, hidden_size, num_layers, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(feature_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    # forward方法定義了輸入數據通過模型各層的前向傳播過程。
    # 模型的forward方法被自動調用，并且X_train_batch作為參數傳遞給這個方法。
    def forward(self, x, hidden=None):
        batch_size = x.shape[0]

        if hidden is None:
            h_0 = x.data.new(self.num_layers, batch_size, self.hidden_size).fill_(0).float()
            c_0 = x.data.new(self.num_layers, batch_size, self.hidden_size).fill_(0).float()
        else:
            h_0, c_0 = hidden

        lstm_output, (h_0, c_0) = self.lstm(x, (h_0, c_0))

        lstm_output = self.dropout(lstm_output)

        final_output = lstm_output[:, -1, :]

        output = self.fc(final_output)

        return output


# 這行代碼創(chuàng)建了一個LSTM模型的實例
model = LSTM(config.feature_size, config.hidden_size, config.num_layers, config.output_size, config.dropout)
loss_function = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)

# 訓練模型
for epoch in range(config.epochs):
    model.train()
    train_loss_sum = 0.0
    # 形成進度條
    train_bar = tqdm(train_loader)
    for data in train_bar:
        X_train_batch, y_train_batch = data
        optimizer.zero_grad()
        y_train_pred = model(X_train_batch)
        loss = loss_function(y_train_pred, y_train_batch.view(-1))
        loss.backward()
        optimizer.step()
        train_bar.desc = "train epoch[{} / {}] loss:{:.3f}".format(epoch + 1, config.epochs, loss)

    model.eval()
    test_loss_sum = 0.0
    y_test_preds = [] # 初始化一個空列表來保存所有預測結果
    y_test_true = []  # 初始化一個空列表來保存所有真實值
    test_bar = tqdm(test_loader)
    with torch.no_grad():
        for data in test_bar:
            X_test_batch, y_test_batch = data
            y_test_pred = model(X_test_batch) # 獲取當前批次的預測結果
            test_loss = loss_function(y_test_pred, y_test_batch.view(-1))
            test_loss_sum += test_loss.item()  # 累加損失
            y_test_preds.append(y_test_pred.detach().numpy())  # 將預測結果追加到列表中
            y_test_true.append(y_test_batch.detach().numpy())  # 將真實值追加到列表中
    test_loss_avg = test_loss_sum / len(test_loader)  # 計算平均測試損失
    y_test_preds= np.concatenate(y_test_preds, axis=0)  # 將所有批次的預測結果連接成一個數組
    y_test_true = np.concatenate(y_test_true, axis=0)  # 將所有批次的真實值連接成一個數組

    # 反歸一化預測值和真實值
    # scaler.inverse_transform(...)：使用之前擬合的 MinMaxScaler 將縮放后的預測值轉換回其原始尺度。
    # 以便在原始尺度上評估模型性能
    y_test_preds_unnormalized = scaler.inverse_transform(y_test_preds)
    y_test_true_unnormalized = scaler.inverse_transform(y_test_true.reshape(-1, 1))
    

    if test_loss_avg < config.best_loss:
        config.best_loss = test_loss_avg
        torch.save(model.state_dict(), config.save_path)
print("訓練結束")

plt.figure(figsize=(10, 5))
plt.plot(y_test_true_unnormalized, label='True Values')
plt.plot(y_test_preds_unnormalized, label='Predictions')
plt.title('Comparison of True Values and Predictions')
plt.xlabel('Time Steps')
plt.ylabel('Prices')
plt.legend()
plt.show()

到了這里，關于基于Python的LSTM網絡實現單特征預測回歸任務（PyTorch版）的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。如若轉載，請注明出處：如若內容造成侵權/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經查實，立即刪除！

分享到：

領支付寶紅包贊助服務器費用

時序預測 | Python實現ARIMA-LSTM差分自回歸移動平均模型結合長短期記憶神經網絡時間序列預測
預測效果基本介紹時序預測 | Python實現ARIMA-LSTM差分自回歸移動平均模型結合長短期記憶神經網絡時間序列預測直接替換數據即可用適合新手小白附贈案例數據可直接運行程序設計完整程序和數據下載方式私信博主回復： Python實現ARIMA-LSTM差分自回歸移動平均模型結合長
2024年02月07日
瀏覽(31)
回歸預測 | MATLAB實現基于QPSO-LSTM、PSO-LSTM、LSTM多輸入單輸出回歸預測
效果一覽基本描述 1.Matlab實現QPSO-LSTM、PSO-LSTM和LSTM神經網絡時間序列預測； 2.輸入數據為多輸入單輸出數據； 3.運行環(huán)境Matlab2020及以上,依次運行Main1LSTMNN、Main2PSOLSTMNN、Main3QPSOLSTMNN、Main4CDM即可，其余為函數文件無需運行,所有程序放在一個文件夾,data為數據集，輸入多個特征
2024年02月09日
瀏覽(29)
Python基于PyTorch實現循環(huán)神經網絡回歸模型(LSTM回歸算法)項目實戰(zhàn)
說明：這是一個機器學習實戰(zhàn)項目（附帶數據+代碼+文檔+視頻講解），如需數據+代碼+文檔+視頻講解可以直接到文章最后獲取。 LSTM網絡是目前更加通用的循環(huán)神經網絡結構，全稱為Long?Short-Term?Memory，翻譯成中文叫作“長‘短記憶’”網絡。讀的時候，“長”后面要稍
2024年02月16日
瀏覽(27)
10.（Python數模）（預測模型二）LSTM回歸網絡（1→1）
長短期記憶網絡 - 通常只稱為“LSTM” - 是一種特殊的RNN，能夠學習長期的規(guī)律。它們是由Hochreiter＆Schmidhuber（1997）首先提出的，并且在后來的工作中被許多人精煉和推廣。他們在各種各樣的問題上應用得非常好，現在被廣泛的使用。有一串時間序列數據[112,118,132,129,121,13
2024年02月09日
瀏覽(20)
回歸預測 | MATLAB實現GA-LSTM遺傳算法優(yōu)化長短期記憶網絡的數據多輸入單輸出回歸預測
效果一覽基本介紹 MATLAB實現GA-LSTM遺傳算法優(yōu)化長短期記憶網絡的數據多輸入單輸出回歸預測 GA-LSTM遺傳算法優(yōu)化長短期記憶網絡回歸預測（Matlab完整程序和數據）輸入6個特征，輸出1個，即多輸入單輸出；運行環(huán)境Matlab2018及以上,運行主程序main即可，其余為函數文件無需運
2023年04月09日
瀏覽(27)
回歸預測 | MATLAB實現POA-CNN-LSTM鵜鶘算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測
預測效果基本介紹 MATLAB實現POA-CNN-LSTM鵜鶘算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測（完整源碼和數據) 1.MATLAB實現POA-CNN-LSTM鵜鶘算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測（完整源碼和數據) 2.輸入多個特征，輸出單個變量，多輸入單輸出回歸預測
2024年02月13日
瀏覽(25)
回歸預測 | MATLAB實現SSA-CNN-LSTM麻雀算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測
預測效果基本介紹 MATLAB實現SSA-CNN-LSTM麻雀算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測，運行環(huán)境Matlab2020b及以上。優(yōu)化正則化率、學習率、隱藏層單元數。 1.Matlab實現SSA-CNN-LSTM麻雀算法優(yōu)化卷積長短期記憶網絡(CNN-LSTM)多輸入單輸出回歸預測 2.輸入多個特征，輸
2024年02月08日
瀏覽(27)
回歸預測 | MATLAB實現WOA-CNN-LSTM鯨魚算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測
預測效果基本介紹回歸預測 | MATLAB實現WOA-CNN-LSTM鯨魚算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測，運行環(huán)境Matlab2020b及以上。優(yōu)化正則化率、學習率、隱藏層單元數。 1.MATLAB實現WOA-CNN-LSTM鯨魚算法優(yōu)化卷積長短期記憶神經網絡多輸入單輸出回歸預測 2.輸入多個特
2024年02月13日
瀏覽(20)
python實現Lasso回歸分析（特征篩選、建模預測）
實現功能： python實現Lasso回歸分析（特征篩選、建模預測）輸入結構化數據，含有特征以及相應的標簽，采用Lasso回歸對特征進行分析篩選，并對數據進行建模預測。實現代碼：實現效果： # 繪制Lambda與回歸系數的關系 ???# 基于最佳的lambda值建模進行特征分析 ???# 基于
2023年04月12日
瀏覽(24)
時序預測 | Matlab實現ARIMA-LSTM差分自回歸移動差分自回歸移動平均模型模型結合長短期記憶神經網絡時間序列預測
預測效果基本介紹時序預測 | Matlab實現ARIMA-LSTM差分自回歸移動差分自回歸移動平均模型模型結合長短期記憶神經網絡時間序列預測程序設計完整程序和數據下載方式私信博主回復： Matlab實現ARIMA-LSTM差分自回歸移動差分自回歸移動平均模型模型結合長短期記憶神經網絡時間
2024年02月07日
瀏覽(28)

<td id="mwu2a"></td><del id="mwu2a"><tfoot id="mwu2a"></tfoot></del>

<dfn id="mwu2a"><dd id="mwu2a"></dd></dfn>