基于CNN实现预测

import tushare as ts
import numpy as np
from tensorflow.keras.models import load_model
import yfinance as yf

# 定义股票代码
stock_code = "159905.SZ"  # 假设是深交所的股票，股票代码需要加上 '.SZ'

# 获取股票数据
stock = yf.Ticker(stock_code)

# 获取最近的股票历史数据（包括开盘价）
stock_data = stock.history(period='1d')

# 提取开盘价
if not stock_data.empty:
    opening_price = stock_data['Open'].iloc[0]
    print(f"{stock_code} 最新交易日的开盘价格为: {opening_price}")
else:
    print(f"未能获取到 {stock_code} 的数据")
if opening_price is not None:
    # 数据归一化，这里的X_min和X_max需要根据实际历史数据确定
    X_min = 0.601
    X_max = 3.237
    new_x = np.array([[opening_price]])
    new_x_normalized = (new_x - X_min) / (X_max - X_min)

    # 加载模型
    trained_model = load_model('cnn_model_with_clip.h5')

    # 将新数据扩大到14个相同值以符合输入要求，并重塑为四维张量
    new_x_sliced = np.tile(new_x_normalized, (14, 1)).reshape(1, 14, 1, 1)

    # 进行预测
    prediction = trained_model.predict(new_x_sliced)
    print(f"对于输入x的开盘价格 {opening_price} 的预测结果为: {prediction[0][0]}")
else:
    print("未能获取有效的开盘价格，无法进行预测。")

将在接下来的时间用此模型 小试牛刀，希望不会亏损太多~

###20240717更新####

• 网络 并不是非常稳定，可以 溜会 再回来获取开盘价

import tushare as ts
import numpy as np
from tensorflow.keras.models import load_model
from pandas_datareader import data as pdr
import yfinance as yf
yf.pdr_override()
# code='510050.ss'
# 股票代码列表
stock_codes = ["159905.SZ", "159910.SZ", "159915.SZ", "159916.SZ", "159920.SZ", "510050.SS", "510300.SS", "510500.SS",
               "510900.SS", "511380.SS", "512000.SS", "512100.SS", "513050.SS", "513890.SS"]
# 初始化空字典来存储开盘价
opening_prices = {}
predictions={}
# 遍历股票代码列表
for code in stock_codes:
    stock = pdr.get_data_yahoo(f"{code}",'2024-07-17','2024-07-18')
    # print("stock['Open']:",stock['Open'][0])
    opening_prices[code] = stock['Open'][0]
# 打印结果
for code, price in opening_prices.items():
    # print(f"Stock Code: {code}, Opening Price: {price}")
# for open in code:
    new_x_normalized=price
    # 加载模型
    trained_model = load_model('cnn_model_with_clip.h5')
    # 将新数据扩大到14个相同值以符合输入要求，并重塑为四维张量
    new_x_sliced = np.tile(new_x_normalized, (14, 1)).reshape(1, 14, 1, 1)
    # 进行预测
    prediction = trained_model.predict(new_x_sliced)
    # print(f"对于输入x的开盘价格  的预测结果为: {prediction[0]}")
    # 使用列表推导式和round函数将预测结果转换为二进制输出
    binary_predictions = [int(p > 0.5) for p in prediction[0]]
    predictions[code] = binary_predictions
    # 打印转换后的二进制预测结果
print(predictions)

###20240722更新###

假设买入时机为E日的最高价，卖出时机为E+1日的最低价,卖出价-买入价>0，则视为可以买入

import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv1D, MaxPooling1D, LSTM, Dense
import matplotlib.pyplot as plt
import numpy as np
from keras.models import Model
from keras.layers import Input, Dense
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
# 加载数据
# data = pd.read_csv('./original_data_path.csv')
data = pd.read_csv('D:/stockData/inputout/latest.csv')

# 查看前几行数据
print(data.head())

# 划分输入和输出
X = data[['x']].values
Y = data[['y', 'z', 'o', 'p']].values
# y = data[['y','z', 'o']].values
# 将目标变量转换为分类格式（假设 y, z, o, p 都是二分类问题）
Y_binary = to_categorical(Y)

# 将数据集拆分为训练集和测试集
X_train, X_test, Y_train, Y_test = train_test_split(X, Y_binary, test_size=0.2, random_state=42)

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

X_test_scaled = scaler.transform(X_test)
# X_test_scaled = X_test)
# 构建输入层
# input_layer = Input(shape=(X_train_scaled.shape[1],))
input_layer = Input(shape=(X_train.shape[1],))

# 构建隐藏层
hidden_layer = Dense(64, activation='relu')(input_layer)

# 构建输出层（假设这是一个二分类问题，所以使用 sigmoid 激活函数）
output_layer_y = Dense(2, activation='sigmoid', name='output_y')(hidden_layer)
output_layer_z = Dense(2, activation='sigmoid', name='output_z')(hidden_layer)
output_layer_o = Dense(2, activation='sigmoid', name='output_o')(hidden_layer)
output_layer_p = Dense(2, activation='sigmoid', name='output_p')(hidden_layer)

# 构建模型
model = Model(inputs=input_layer, outputs=[output_layer_y, output_layer_z, output_layer_o, output_layer_p])
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics={'output_y': 'accuracy',
                       'output_z': 'accuracy',
                       'output_o': 'accuracy',
                       'output_p': 'accuracy'})
#
# # 编译模型
# model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(X_train_scaled, [Y_train[:, 0], Y_train[:, 1], Y_train[:, 2], Y_train[:, 3]], epochs=5, batch_size=32, verbose=1)

# 评估模型
scores = model.evaluate(X_test_scaled, [Y_test[:, 0], Y_test[:, 1], Y_test[:, 2], Y_test[:, 3]], verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# 假设我们已经有了训练好的模型，并且已经进行了数据归一化
# 我们需要对新的输入数据进行相同的归一化处理
from pandas_datareader import data as pdr
import yfinance as yf
yf.pdr_override()
# code='510050.ss'
# 股票代码列表
stock_codes = ["159905.SZ", "159910.SZ", "159915.SZ", "159916.SZ", "159920.SZ", "510050.SS", "510300.SS", "510500.SS",
               "510900.SS", "511380.SS", "512000.SS", "512100.SS", "513050.SS", "513890.SS"]
# 初始化空字典来存储开盘价
opening_prices = {}
predictions={}
# 遍历股票代码列表
for code in stock_codes:
    # 创建Ticker对象
    # ticker = yf.Ticker(f"{code}")
    # ticker = yf.Ticker(f"{code}")
    stock = pdr.get_data_yahoo(f"{code}",'2024-07-20','2024-07-23')
    # print("stock['Open']:",stock['Open'][0])
    opening_prices[code] = stock['Open'][0]
# 打印结果
for code, price in opening_prices.items():
    # print(f"Stock Code: {code}, Opening Price: {price}")
# for open in code:

    new_data=price


# 假设 new_data 是我们想要预测的 x 值
# new_data = np.array([2.5])

    # 对新数据进行归一化
    new_data_scaled = scaler.transform(new_data.reshape(-1, 1))

    # 使用模型进行预测
    predictions = model.predict(new_data_scaled)

    # 由于我们有四个输出，我们需要分别处理它们
    predicted_y = np.argmax(predictions[0], axis=-1)  # 假设 'output_y' 是二分类问题
    predicted_z = np.argmax(predictions[1], axis=-1)  # 假设 'output_z' 是二分类问题
    predicted_o = np.argmax(predictions[2], axis=-1)  # 假设 'output_o' 是二分类问题
    predicted_p = np.argmax(predictions[3], axis=-1)  # 假设 'output_p' 是二分类问题

    # 打印预测结果
    print("code:", code,predicted_y,predicted_z,predicted_o,predicted_p)