和鲸社区数据分析每周挑战【第九十五期：奈飞股价预测分析】

和鲸社区数据分析每周挑战【第九十五期：奈飞股价预测分析】

一、前言

本周的挑战内容为：奈飞股价预测分析

大家可以去我的和鲸鱼主页查看这个项目。

1、背景描述

本数据集收录了Netflix自2002年开始至2022年的股价数据，数据来源为Yahoo Finance。

Netflix(NFLX)是一家在视频流媒体领域非常成功的公司，运营着全球最大的视频流媒体订阅平台之一（目前已经有超过2.3亿的付费会员）。
它的商业模式也比较简单，主要通过向客户收取每月或每年的会员费来获取收入，客户订阅会员后，可以获得Netflix平台上各种类型和各种语言的电视连续剧和电影。
Netflix目前在190多个国家为客户提供视频流媒体服务，客户可以在任何时间、任何地点、任何设备上观看Netflix的内容。

2、数据说明

字段	说明
Date	日期
Open	开盘价，是金融证券在市场上开始交易时的价格。
High	指股票在一个时期内的最高交易价格。
Low	指股票在一个时期内的最低交易价格。
Close	收盘价，一般指股票在正常交易时段的最后交易价格。
Adj Close	已调整收盘价，指修正了一只股票的收盘价，以反映该股票在核算后的价值，使用收盘价作为起点，但它考虑了股息，股票拆分和新股票发行等因素来确定价值。 调整后的收盘价代表了股票价值的更准确反映。
Volume	交易量/成交量，衡量的是股票交易的股数或期货或期权交易的合约数。

3、数据集预览

数据集来源于本次活动提供：

二、数据读取和数据预处理

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime

# 加载数据集
df = pd.read_csv('/content/Netflix Stock Price Data set 2002-2022.csv')

# 将日期列转换为datetime类型
df['Date'] = pd.to_datetime(df['Date'])
df

三、历史股价数据可视化

plt.figure(figsize=(12, 6))
plt.plot(df['Date'], df['Adj Close'])
plt.xlabel('Date')
plt.ylabel('Adjusted Close Price')
plt.title('Netflix Stock Price')
plt.grid(True)
plt.show()

四、利用sklearn中LinearRegression模型进行股价预测分析

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression 

# 创建特征和目标变量
X = df[['Open', 'High', 'Low', 'Volume']]
y = df['Adj Close']

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 使用线性回归模型进行训练和预测
model = LinearRegression()
model.fit(X_train, y_train)
predicted_prices = model.predict(X_test)

# 可视化预测结果
plt.figure(figsize=(12, 6))
plt.plot(df['Date'], df['Adj Close'], label='Actual')
plt.plot(df['Date'].iloc[-len(y_test):], predicted_prices, label='Predicted')
plt.xlabel('Date')
plt.ylabel('Adjusted Close Price')
plt.title('Netflix Stock Price Prediction')
plt.legend()
plt.grid(True)
plt.show()

五、使用Pytorch中LSTM模型进行股价预测分析

1、设置随机种子及检查GPU可用性

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# 设置随机种子
torch.manual_seed(42)

# 检查GPU可用性
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
device

device(type='cuda')

2、数据预处理

# 选择调整后的收盘价作为目标变量
data = df['Adj Close'].values.reshape(-1, 1)

# 归一化数据
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)

# 划分训练集和测试集
train_size = int(len(scaled_data) * 0.8)
train_data = scaled_data[:train_size, :]
test_data = scaled_data[train_size:, :]

# 创建训练集和测试集的特征和目标变量
def create_dataset(data, lookback):
    X, y = [], []
    for i in range(len(data) - lookback):
        X.append(data[i:i+lookback, 0])
        y.append(data[i+lookback, 0])
    return np.array(X), np.array(y)

lookback = 60  # 使用前60个时间步作为输入特征
X_train, y_train = create_dataset(train_data, lookback)
X_test, y_test = create_dataset(test_data, lookback)

# 转换数据为PyTorch张量，并移动到GPU上
X_train = torch.from_numpy(X_train).float().to(device)
y_train = torch.from_numpy(y_train).float().to(device)
X_test = torch.from_numpy(X_test).float().to(device)
y_test = torch.from_numpy(y_test).float().to(device)

3、构建简单LSTM模型

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])
        return out

input_size = 1
hidden_size = 64
output_size = 1

# 初始化模型，并移动到GPU上
model = LSTMModel(input_size, hidden_size, output_size).to(device)
model

LSTMModel(
  (lstm): LSTM(1, 64, batch_first=True)
  (fc): Linear(in_features=64, out_features=1, bias=True)
)

4、定义损失函数和优化器

criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

5、训练模型

num_epochs = 100
batch_size = 32
train_loss_history = []

for epoch in range(num_epochs):
    for i in range(0, len(X_train), batch_size):
        inputs = X_train[i:i+batch_size]
        targets = y_train[i:i+batch_size]

        # 前向传播
        outputs = model(inputs.unsqueeze(2))
        loss = criterion(outputs.squeeze(), targets)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    train_loss_history.append(loss.item())

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

Epoch [1/100], Loss: 0.007953
Epoch [11/100], Loss: 0.000076
Epoch [21/100], Loss: 0.000081
Epoch [31/100], Loss: 0.000081
Epoch [41/100], Loss: 0.000136
Epoch [51/100], Loss: 0.000155
Epoch [61/100], Loss: 0.000073
Epoch [71/100], Loss: 0.000125
Epoch [81/100], Loss: 0.000320
Epoch [91/100], Loss: 0.000099

6、测试模型

model.eval()
with torch.no_grad():
    test_inputs = X_test.unsqueeze(2)
    test_outputs = model(test_inputs)
    test_loss = criterion(test_outputs.squeeze(), y_test)
    predicted_prices = scaler.inverse_transform(test_outputs.cpu().numpy())

print(f'Test Loss: {
      
      test_loss.item():.6f}')

Test Loss: 0.000395

7、可视化训练损失

plt.figure(figsize=(12, 6))
plt.plot(train_loss_history, label='Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss History')
plt.legend()
plt.show()

8、可视化预测结果

plt.figure(figsize=(12, 6))
plt.plot(df['Date'][train_size+lookback:], scaler.inverse_transform(test_data[lookback:]), label='Actual')
plt.plot(df['Date'][train_size+lookback:], predicted_prices, label='Predicted')
plt.xlabel('Date')
plt.ylabel('Stock Price')
plt.title('Netflix Stock Price Prediction')
plt.legend()
plt.show()