完成神经网络模型预测股价程序，效果不好。程序到此为止了。

Author: zwdnet

Diff for: dl.py

@@ -0,0 +1,123 @@
+# coding:utf-8
+# 神经网络预测股价
+# 没完成
+
+
+import run
+import tools
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+
+
+# 训练神经网络
+def DL(code="sh000300", start="2018-01-01", end="2018-12-31", refresh = False):
+    # 加载数据
+    tools.initOutput()
+    data = tools.loadData(code=code, start=start, end=end, refresh=refresh)
+    # 筛选特征
+    feature_cols = ["open", "close", "high", "low", "volume"]
+    target_cols = ["close"]
+    features_data = data.loc[:, feature_cols]
+    # 特征归一化
+    mm = MinMaxScaler(feature_range=(0, 1))
+    for col in feature_cols:
+        features_data[col] = mm.fit_transform(features_data[col].values.reshape(-1, 1))
+    target_data = data.loc[:, target_cols].values
+    print(features_data.shape)
+    features_data = np.array(features_data)
+    features_data = torch.tensor(features_data)
+    stock_len = len(features_data)
+    tr_val_slip = int(0.8*stock_len)
+    print("数据天数:", stock_len)
+    print("可预测天数:", tr_val_slip)
+    sqe_len = 5
+    x = torch.zeros(stock_len - sqe_len, sqe_len, 5)
+    y = torch.zeros(stock_len - sqe_len, 1)
+    for i in range(0, stock_len - sqe_len - 1):
+        x[i] = features_data[i:i+sqe_len]
+        y[i] = features_data[i+sqe_len, 1]
+        print(x[i])
+    
+    # 形成训练集和验证集
+    train_x = x[0:tr_val_slip]
+    train_y = y[0:tr_val_slip]
+    vaild_x = x[tr_val_slip:]
+    vaild_y = y[tr_val_slip:]
+    print(train_x.shape, train_y.shape, vaild_x.shape, vaild_y.shape)
+    
+    # 形成DataLoader
+    class StockDataset(Dataset):
+        def __init__(self, x, y):
+            self.x = x
+            self.y = y
+            
+        def __len__(self):
+            return len(self.x)
+            
+        def __getitem__(self, index):
+            X = self.x[index]
+            Y = self.y[index]
+            return X, Y
+            
+    batch_size = 2
+    train_set = StockDataset(train_x, train_y)
+    vaild_set = StockDataset(vaild_x, vaild_y)
+    train_loader = DataLoader(train_set, batch_size = batch_size, shuffle = False)
+    vaild_loader = DataLoader(vaild_set, batch_size = batch_size, shuffle = False)
+    
+    #for i in range(5, len(features_data)):
+#        temp = []
+#        for j in range(5):
+#            temp.append(features_data[i][j])
+#        x.append(temp)
+#        y.append(target_data[i])
+#    print(x, len(x), len(y))
+#    train_x = x[:200]
+#    train_y = y[:200]
+#    test_x = x[200:]
+#    test_y = y[200:]
+    # 定义神经网络
+    lr = 0.001
+    epochs = 20
+    class bp_net(nn.Module):
+        def __init__(self, batch_size = batch_size):
+            super(bp_net, self).__init__()
+            self.layer_input = nn.Linear(5, 200)
+            self.layer_hide = nn.Linear(200, 16)
+            self.layer_output = nn.Linear(16, 1)
+            self.batch_size = batch_size
+            
+        def forward(self, x):
+            x = self.layer_input(x)
+            nn.ReLU()
+            x = self.layer_hide(x)
+            nn.ReLU()
+            x = self.layer_output(x)
+            return x
+            
+    net = bp_net(batch_size)
+    criterion = nn.MSELoss()
+    optim = torch.optim.Adam(net.parameters(), lr = lr, weight_decay=0.0)
+    # 训练过程
+    for epoch in range(epochs):
+        train_loss = []
+        for x, y in train_loader:
+            # x = x.view(batch_size, -1)
+            y_pred = net.forward(x)
+            print("测试", y.shape, y_pred.shape)
+            print(y_pred)
+            loss = criterion(y_pred, y)
+            train_loss.append(loss.item())
+            optim.zero_grad()
+            loss.backward()
+            optim.step()
+        mean_train_loss = torch.mean(torch.tensor(train_loss))
+        print("第%d次迭代，平均损失值:%f" % (i, mean_train_loss))
+
+
+if __name__ == "__main__":
+    DL()

Diff for: lstm.py

@@ -0,0 +1,125 @@
+# coding:utf-8
+# lstm神经网络预测股价
+
+
+import run
+import tools
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+import matplotlib.pyplot as plt
+
+
+# 读取数据
+def readData(code="sh000300", start="2018-01-01", end="2018-12-31", refresh = False):
+    # 加载数据
+    tools.initOutput()
+    data = tools.loadData(code=code, start=start, end=end, refresh=refresh)
+    print(data, type(data))
+    return data
+    
+    
+# 数据归一化
+def data_pre(data):
+    dataset = data.astype("double")
+    max_value = np.max(dataset)
+    min_value = np.min(dataset)
+    scalar = max_value - min_value
+    dataset = list(map(lambda x: x / scalar, dataset))
+    return dataset
+    
+    
+# 创建数据集
+def create_dataset(dataset, look_back = 2):
+    dataX, dataY = [], []
+    for i in range(len(dataset) - look_back):
+        a = dataset[i:i+look_back]
+        dataX.append(a)
+        dataY.append(dataset[i+look_back])
+    return np.array(dataX), np.array(dataY)
+    
+    
+class LSTM(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layer):
+        super(LSTM, self).__init__()
+        self.layer1 = nn.LSTM(input_size, hidden_size, num_layer, bias = True, batch_first = False, dropout = 0.1)
+        self.layer2 = nn.Linear(hidden_size, output_size)
+        
+    def forward(self, x):
+        x, _ = self.layer1(x)
+        s, b1, n = x.size()
+        x = x.view(s*b1, n)
+        x = self.layer2(x)
+        x = x.view(s*b1, -1)
+        return x
+
+
+# lstm预测模型
+@run.change_dir
+def lstm():
+    # 准备数据
+    data = readData()
+    open = data["open"].values
+    open = open[::-1]
+    open = data_pre(open)
+    plt.figure()
+    plt.plot(open)
+    plt.savefig("./output/open.png")
+    index = int(len(open)*0.8)
+    train = open[:index]
+    test = open[index:]
+    # 生成数据集
+    data_X2, data_Y2 = create_dataset(test)
+    data_X1, data_Y1 = create_dataset(train)
+    train_X = data_X1
+    train_Y = data_Y1
+    train_X = train_X.reshape(-1, 1, 2)
+    train_Y = train_Y.reshape(-1, 1, 1)
+    train_x = torch.from_numpy(train_X).float()
+    train_y = torch.from_numpy(train_Y).float()
+    # 模型搭建
+    model = LSTM(2, 4, 2, 2)
+    # 损失函数
+    criterion = nn.MSELoss()
+    # 优化器
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+    # 模型训练
+    epoches = 1500
+    plt.figure()
+    for epoch in range(epoches):
+        # 前向传播
+        out = model.forward(train_x)
+        loss = criterion(out, train_y)
+        # 反向传播
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        if epoch % int(epoches/10) == 0:
+            out1=loss.view(-1).data.numpy()
+            plt.plot(out1,'r')
+            plt.plot(train_x.view(-1).data.numpy(), 'b')
+            print(epoch, loss)
+    plt.savefig("./output/loss.png")
+    plt.close()
+    # 模型测试
+    test_X = data_X2
+    test_Y = data_Y2
+    test_X = test_X.reshape(-1, 1, 2)
+    test_Y = test_Y.reshape(-1, 1, 1)
+    test_x = torch.from_numpy(test_X).float()
+    test_y = torch.from_numpy(test_Y).float()
+    pred_test = model(test_x)
+    pred_test = pred_test.view(-1).data.numpy()
+    plt.figure()
+    plt.plot(pred_test, 'r', label='prediction')
+    plt.plot(test_x.view(-1).data.numpy(), 'b', label='real')
+    plt.legend(loc='best')
+    plt.savefig("./output/predict.png")
+    plt.close()
+
+
+if __name__ == "__main__":
+    lstm()

Diff for: output/loss.png

@@ -7,52 +7,72 @@
 
 
 # 上传代码至服务器并运行
-def run(gpus, server):
+def run(gpus, user, server):
     # 上传本目录所有文件再执行指定文件
     if gpus == "all":
         # 清除服务器代码目录里所有源文件以及输出目录中的文件
-        s = "ssh ubuntu@" + server + " \"sudo rm -rf ~/code/*.py\""
+        s = "ssh " + user + "@" + server + " \"sudo rm -rf ~/code/*.py\""
+        # print("测试1", s)
         os.system(s)
-        s = "ssh ubuntu@" + server + " \"sudo rm -rf ~/code/output/*\""
+        s = "ssh " + user + "@" + server + " \"sudo rm -rf ~/code/output/*\""
+        # print("测试2", s)
         os.system(s)
         # 将本地目录所有文件上传至容器
-        s = "scp -r ./*.py ubuntu@" + server + ":~/code"
+        s = "scp -r ./*.py " + user + "@" + server + ":~/code"
+        # print("测试3", s)
         os.system(s)
         # 运行指定代码
         s = "ssh root@" + server +  " -p 2222 \"python /home/code/" + sys.argv[2] + "\""
+        # print("测试4", s)
         print("正在运行代码……\n")
         os.system(s)
         # 将代码目录里所有输出文件传回
-        s = "scp -r ubuntu@" + server + ":~/code/output/* ./output/"
+        s = "scp -r " + user +"@" + server + ":~/code/output/* ./output/"
+        # print("测试5", s)
         os.system(s)
     # 将所有结果文件传回
     elif gpus == "copy":
-        s = "scp -r ubuntu@" + server + ":~/code/output/* ./output/"
+        s = "scp -r " + user + "@" + server + ":~/code/output/* ./output/"
         os.system(s)
     # 上传指定文件并执行
     else:
         ## 清除服务器代码目录里所有源文件以及输出目录中的文件
-        s = "ssh ubuntu@" + server + " \"sudo rm -rf ~/code/*.py\""
+        s = "ssh " + user + "@" + server + " \"sudo rm -rf ~/code/*.py\""
         os.system(s)
-        s = "ssh ubuntu@" + server + " \"sudo rm -rf ~/code/output/*\""
+        s = "ssh " + user + "@" + server + " \"sudo rm -rf ~/code/output/*\""
         os.system(s)
         # 将本地目录指定文件上传至容器
-        s = "scp " + sys.argv[1] + " ubuntu@" + server + ":~/code"
+        s = "scp " + sys.argv[1] + " " + user + "@" + server + ":~/code"
         os.system(s)
         # 运行指定代码
         s = "ssh root@" + server +  " -p 2222 \"python /home/code/" + sys.argv[1] + "\""
         os.system(s)
         # 将代码目录里所有文件传回
-        s = "scp -r ubuntu@" + server + ":~/code/output/* ./output/"
+        s = "scp -r " + user +"@" + server + ":~/code/output/* ./output/"
         os.system(s)
-
-
-if __name__ == "__main__":
+        
+        
+# 主函数
+def main():
     gpus = sys.argv[1]
     # 读取服务器IP地址，自己编辑serverIP.txt去
     with open("serverIP.txt", "rt") as f:
-        server = f.read()
-    run(gpus, server)
+        server_list = f.readlines()
+    for s in server_list:
+        s = s.replace('\n', '').replace('\r', '')
+        # print(s)
+        if s[0] != "#":
+            res = s.split("@")
+            username = res[0]
+            server = res[1]
+            # print("测试", username, server)
+            # input("按任意键继续")
+            run(gpus, username, server)
+            return    
+
+
+if __name__ == "__main__":
+    main()
 
 
 # 工具函数，在上传到服务器上运行时改变当前目录

Diff for: output/open.png

@@ -0,0 +1,19 @@
+# coding:utf-8
+# 测试pypy
+
+
+import run
+
+
+@run.timethis
+def testPypy():
+    number = 0
+    for i in range(100000000):
+        number += i
+        
+    print("完成")
+    
+    
+if __name__ == "__main__":
+    testPypy()
+