股票 订阅
股票(stock)是股份公司所有权的一部分,也是发行的所有权凭证,是股份公司为筹集资金而发行给各个股东作为持股凭证并借以取得股息和红利的一种有价证券。每股股票都代表股东对企业拥有一个基本单位的所有权。每家上市公司都会发行股票。同一类别的每一份股票所代表的公司所有权是相等的。每个股东所拥有的公司所有权份额的大小,取决于其持有的股票数量占公司总股本的比重。股票是股份公司资本的构成部分,可以转让、买卖,是资本市场的主要长期信用工具,但不能要求公司返还其出资。 [1] 展开全文
股票(stock)是股份公司所有权的一部分,也是发行的所有权凭证,是股份公司为筹集资金而发行给各个股东作为持股凭证并借以取得股息和红利的一种有价证券。每股股票都代表股东对企业拥有一个基本单位的所有权。每家上市公司都会发行股票。同一类别的每一份股票所代表的公司所有权是相等的。每个股东所拥有的公司所有权份额的大小,取决于其持有的股票数量占公司总股本的比重。股票是股份公司资本的构成部分,可以转让、买卖,是资本市场的主要长期信用工具,但不能要求公司返还其出资。 [1]
信息
归    属
广义票据的一种
外文名
shares; share certificate; stock certificate; equity security;
适用范围
所有人
拼    音
gǔ piào
释    义
一种有价证券
中文名
股票
目    的
募集资金
数据分析师作用
收起全文
精华内容
下载资源
问答
  • 股票

    千次阅读 2019-08-02 15:49:38
    股票 一、股票和上市 上市:即IPO(首次公开募股)。 股票股票是一种所有权凭证,公司发行一亿股,如果你买了一千万股,那么这个公司的十分之一就记在你的名下,即把一些固定资产转换为可以交易的资产在交易...

    一、股票和上市

    上市:即IPO(首次公开募股)。
    股票:股票是一种所有权凭证,公司发行一亿股,如果你买了一千万股,那么这个公司的十分之一就记在你的名下,即把一些固定资产转换为可以交易的资产在交易所进行交易。

    我相信大部分没接触过金融知识的人相信也会知道有股票这样一个东西存在,我们会听到公司上市这样的消息,如最近上市的斗鱼。说道到股票就可以拓展到上市了。我记得我看中国合伙人时,孟晓骏一直希望成东青把公司上市,最后上市成功后得到了美国那边的大公司的注意,那时候他们的公司应该是S股,即在纽约上市的公司。那么股票和上市之间有联系么?

    通俗来说,股票是公司融资的一种手段,什么是融资呢?融资就是需要资金的融入,简而言之就是需要钱进行资金周转,所以上市之后你就可以向所有投资者去筹钱,让他们成为你公司的股东。不上市如果你是股份制公司也不能去交易所进行交易股票。上市也会有一定的要求,你的公司需要近几年都要盈利,切上市之后每年需要盈利一个值,不然也会下市的。

    如今最著名的未上市的股份公司就是华为。为什么华为不上市呢?因为华为不想让其他人来赚自己公司的钱,自己赚钱自己拿,华为的员工是持有有股份的,如果你离职,那这部分股票就会属于替你干活的那个人,华为的资金周转也够,不需要去筹资,有底气不上市。所以并不是上市的公司就一定比不上市的公司强。

    二、股票的特征

    股票最基本的特征就是收益性,买股票的投资者就是想要赚钱,如果你的股票不赚钱的话没人会买的。
    风险性:投资有风险的。可能赚可能亏。
    流动性:可以在交易所进行交易流通。
    永久性:不用还,无期限。
    参与性:投资者可以参与,买卖。

    三、股票的分类

    按股东权益:优先股和普通股
    按是否记载股东姓名:记名股和不记名股
    按有无面额:有面额股和无面额股
    按流通性:流通股和非流通股

    国内上市的中国股票
    A股:正式名称是人民币普通股票。它是由我国境内的股份制公司发行,供境内机构、组织、或个人(不含台、港、澳投资者)以人民币申购和交易的普通股票。
    B股:正式名称是人民币特种股票。它是以人民币标明面值,以外币申购和买卖,在境内证券交易所上市交易的股票。
    国外上市的中国股票
    L股: 即公司注册地在内地,上市地在伦敦的外资股
    H股: 即公司注册地在内地、上市地在香港的外资股
    N股: 即公司注册地在内地,上市地在纽约的外资股
    S股: 即公司注册地在内地,上市地在新加坡的外资股

    原币:你交易时用的币种,可以用人民币或者美元等等。
    本币:交收时的币种,需要把原币乘以汇率全部转换为本币进行交收。

    四、股票的价格和作用

    股票价格:由价值决定,受需求关系的影响。
    股票价格变动的原因
    1.宏观经济,市场运营
    2.公司前景
    3.公司经营状况

    股票作用
    对发行者来说:
    1.筹集资金
    2.分散投资风险
    3.实现创业资本增值
    4.广告宣发
    对投资者来说:
    1.实现资本增值
    2.可以实现控股,购买兼并公司
    3.赚取差价

    五、股票交易流程

    1.开户
    2.委托
    3.成交
    4.过户
    5.资金交收

    六、交易所股票代码

    上交所股票代码编码规则:
    001×××国债现货;
    110×××120×××企业债券;
    129×××100×××可转换债券;
    201×××国债回购;
    310×××国债期货;
    500×××550×××基金;
    600×××A股;
    700×××配股;
    710×××转配股;
    701×××转配股再配股;
    711×××转配股再转配股;
    720×××红利;
    730×××新股申购;
    735×××新基金申购;
    737×××新股配售;
    900×××B股。
    深交所股票代码编码规则:

    第1位 第2位 第3-6位 含义
    0 0 XXXX A股证券
    0 3 XXXX A股A2权证
    0 7 XXXX A股增发
    0 8 XXXX A股A1权证
    0 9 XXXX A股转配
    1 0 XXXX 国债现货
    1 1 XXXX 债券
    1 2 XXXX 可转换债券
    1 3 XXXX 国债回购
    1 7 XXXX 原有投资基金
    1 8 XXXX 证券投资基金
    2 0 XXXX B股证券
    2 7 XXXX B股增发
    2 8 XXXX B股权证
    3 0 XXXX 创业板证券
    3 7 XXXX 创业板增发
    3 8 XXXX 创业板权证
    3 9 XXXX 综合指数/成份指数

    创业板

    创业板的代码是300打头的股票代码

    沪市A股

    沪市A股的代码是以600、601或603打头

    沪市B股

    沪市B股的代码是以900打头

    深市A股

    深市A股的代码是以000打头

    中小板

    中小板的代码是002打头

    深圳B股

    深圳B股的代码是以200打头

    新股申购

    沪市新股申购的代码是以730打头

    深市新股申购的代码与深市股票买卖代码一样

    配股代码

    沪市以700打头,深市以080打头 权证,沪市是580打头 深市是031打头

    席位:当你去交易所交易时,不能直接去和交易所交易,要去找券商租一个交易席位,即一个通道,然后才可以进行交易。
    股东代码:当有很多人向交易所进行交易时,股东代码是识别你身份的一个工具,在深交所和上交所要去交易需要拿身份证去获取一个股东代码。

    展开全文
  • 基于LSTM的股票预测模型_python实现_超详细

    万次阅读 多人点赞 2019-07-05 22:25:13
    近年来,股票预测还处于一个很热门的阶段,因为股票市场的波动十分巨大,随时可能因为一些新的政策或者其他原因,进行大幅度的波动,导致自然人股民很难对股票进行投资盈利。因此本文想利用现有的模型与算法,对股票...

    一、背景

    近年来,股票预测还处于一个很热门的阶段,因为股票市场的波动十分巨大,随时可能因为一些新的政策或者其他原因,进行大幅度的波动,导致自然人股民很难对股票进行投资盈利。因此本文想利用现有的模型与算法,对股票价格进行预测,从而使自然人股民可以自己对股票进行预测。
    理论上,股票价格是可以预测的,但是影响股票价格的因素有很多,而且目前为止,它们对股票的影响还不能清晰定义。这是因为股票预测是高度非线性的,这就要预测模型要能够处理非线性问题,并且,股票具有时间序列的特性,因此适合用循环神经网络,对股票进行预测。
    虽然循环神经网络(RNN),允许信息的持久化,然而,一般的RNN模型对具备长记忆性的时间序列数据刻画能力较弱,在时间序列过长的时候,因为存在梯度消散和梯度爆炸现象RNN训练变得非常困难。Hochreiter 和 Schmidhuber 提出的长短期记忆( Long Short-Term Memory,LSTM)模型在RNN结构的基础上进行了改造,从而解决了RNN模型无法刻画时间序列长记忆性的问题。
    综上所述,深度学习中的LSTM模型能够很好地刻画时间序列的长记忆性。

    二、主要技术介绍

    1、RNN模型

    在传统的RNN(循环神经网络)中,所有的w都是同一个w,经过同一个cell的时候,都会保留输入的记忆,再加上另外一个要预测的输入,所以预测包含了之前所有的记忆加上此次的输入。所有RNN都具有一种重复神经网络模块的链式的形式。在标准的RNN中,这个重复的模块只有一个非常简单的结构,例如一个tanh层。
    当权中大于1时,反向传播误差时,误差将会一直放大,导致梯度爆炸;当权中小于1时,误差将会一直缩小,导致梯度消失,进而导致网络权重更新缓慢,无法体现出RNN的长期记忆的效果,使得RNN太过健忘。RNN模型的结构如图:
    在这里插入图片描述

    2、LSTM模型

    长短期记忆模型(long-short term memory)是一种特殊的RNN模型,是为了解决反向传播过程中存在梯度消失和梯度爆炸现象,通过引入门(gate)机制,解决了RNN模型不具备的长记忆性问题,LSTM模型的结构如图:

    图2
    具体来说,LSTM模型的1个神经元包含了1个细胞状态(cell)和3个门(gate)机制。细胞状态(cell)是LSTM模型的关键所在,类似于存储器,是模型的记忆空间。细胞状态随着时间而变化,记录的信息由门机制决定和更新。门机制是让信息选择式通过的方法,通过sigmoid函数和点乘操作实现。sigmoid取值介于0~1之间,乘即点乘则决定了传送的信息量(每个部分有多少量可以通过),当sigmoid取0时表示舍弃信息,取1时表示完全传输(即完全记住)[2]。
    LSTM 拥有三个门,来保护和控制细胞状态:遗忘门(forget gate)、更新门(update gate)和输出门(output gate)。
    细胞状态类似于传送带。直接在整个链上运行,只有一些少量的线性交互。信息在上面流传保持不变会很容易。
    如图:
    在这里插入图片描述

    3、控制门工作原理

    遗忘门
    在这里插入图片描述
    更新门
    在这里插入图片描述
    在这里插入图片描述

    输出门
    在这里插入图片描述

    四、代码实现

    UI

    demo.py
    import tensorflow as tf
    import numpy as np
    import tkinter as tk
    from tkinter import filedialog
    import time
    import pandas as pd
    
    import stock_predict as pred
    
    
    def creat_windows():
        win = tk.Tk()  # 创建窗口
        sw = win.winfo_screenwidth()
        sh = win.winfo_screenheight()
        ww, wh = 800, 450
        x, y = (sw - ww) / 2, (sh - wh) / 2
        win.geometry("%dx%d+%d+%d" % (ww, wh, x, y - 40))  # 居中放置窗口
    
        win.title('LSTM股票预测')  # 窗口命名
    
        f_open =open('dataset_2.csv')
        canvas = tk.Label(win)
        canvas.pack()
    
        var = tk.StringVar()  # 创建变量文字
        var.set('选择数据集')
        tk.Label(win, textvariable=var, bg='#C1FFC1', font=('宋体', 21), width=20, height=2).pack()
    
        tk.Button(win, text='选择数据集', width=20, height=2, bg='#FF8C00', command=lambda: getdata(var, canvas),
                  font=('圆体', 10)).pack()
    
        canvas = tk.Label(win)
        L1 = tk.Label(win, text="选择你需要的 列(请用空格隔开,从0开始)")
        L1.pack()
        E1 = tk.Entry(win, bd=5)
        E1.pack()
        button1 = tk.Button(win, text="提交", command=lambda: getLable(E1))
        button1.pack()
        canvas.pack()
        win.mainloop()
    
    def getLable(E1):
        string = E1.get()
        print(string)
        gettraindata(string)
    
    def getdata(var, canvas):
        global file_path
        file_path = filedialog.askopenfilename()
        var.set("注,最后一个为label")
        # 读取文件第一行标签
        with open(file_path, 'r', encoding='gb2312') as f:
        # with open(file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()  # 读取所有行
            data2 = lines[0]
        print()
    
        canvas.configure(text=data2)
        canvas.text = data2
    
    def gettraindata(string):
        f_open = open(file_path)
        df = pd.read_csv(f_open)  # 读入股票数据
        list = string.split()
        print(list)
        x = len(list)
        index=[]
        # data = df.iloc[:, [1,2,3]].values  # 取第3-10列 (2:10从2开始到9)
        for i in range(x):
            q = int(list[i])
            index.append(q)
        global data
        data = df.iloc[:, index].values
        print(data)
        main(data)
    
    def main(data):
        pred.LSTMtest(data)
        var.set("预测的结果是:" + answer)
    
    if __name__ == "__main__":
        creat_windows()
    

    stock_predict.py

    import numpy as np
    import matplotlib.pyplot as plt
    import tensorflow as tf
    import pandas as pd
    import math
    
    def LSTMtest(data):
    
        n1 = len(data[0]) - 1 #因为最后一位为label
        n2 = len(data)
        print(n1, n2)
    
        # 设置常量
        input_size = n1  # 输入神经元个数
        rnn_unit = 10    # LSTM单元(一层神经网络)中的中神经元的个数
        lstm_layers = 7  # LSTM单元个数
        output_size = 1  # 输出神经元个数(预测值)
        lr = 0.0006      # 学习率
    
        train_end_index = math.floor(n2*0.9)  # 向下取整
        print('train_end_index', train_end_index)
        # 前90%数据作为训练集,后10%作为测试集
        # 获取训练集
        # time_step 时间步,batch_size 每一批次训练多少个样例
        def get_train_data(batch_size=60, time_step=20, train_begin=0, train_end=train_end_index):
            batch_index = []
            data_train = data[train_begin:train_end]
            normalized_train_data = (data_train - np.mean(data_train, axis=0)) / np.std(data_train, axis=0)  # 标准化
            train_x, train_y = [], []  # 训练集
            for i in range(len(normalized_train_data) - time_step):
                if i % batch_size == 0:
                    # 开始位置
                    batch_index.append(i)
                    # 一次取time_step行数据
                # x存储输入维度(不包括label) :X(最后一个不取)
                # 标准化(归一化)
                x = normalized_train_data[i:i + time_step, :n1]
                # y存储label
                y = normalized_train_data[i:i + time_step, n1, np.newaxis]
                # np.newaxis分别是在行或列上增加维度
                train_x.append(x.tolist())
                train_y.append(y.tolist())
            # 结束位置
            batch_index.append((len(normalized_train_data) - time_step))
            print('batch_index', batch_index)
            # print('train_x', train_x)
            # print('train_y', train_y)
            return batch_index, train_x, train_y
    
        # 获取测试集
        def get_test_data(time_step=20, test_begin=train_end_index+1):
            data_test = data[test_begin:]
            mean = np.mean(data_test, axis=0)
            std = np.std(data_test, axis=0)  # 矩阵标准差
            # 标准化(归一化)
            normalized_test_data = (data_test - np.mean(data_test, axis=0)) / np.std(data_test, axis=0)
            # " // "表示整数除法。有size个sample
            test_size = (len(normalized_test_data) + time_step - 1) // time_step
            print('test_size$$$$$$$$$$$$$$', test_size)
            test_x, test_y = [], []
            for i in range(test_size - 1):
                x = normalized_test_data[i * time_step:(i + 1) * time_step, :n1]
                y = normalized_test_data[i * time_step:(i + 1) * time_step, n1]
                test_x.append(x.tolist())
                test_y.extend(y)
            test_x.append((normalized_test_data[(i + 1) * time_step:, :n1]).tolist())
            test_y.extend((normalized_test_data[(i + 1) * time_step:, n1]).tolist())
            return mean, std, test_x, test_y
    
        # ——————————————————定义神经网络变量——————————————————
        # 输入层、输出层权重、偏置、dropout参数
        # 随机产生 w,b
        weights = {
            'in': tf.Variable(tf.random_normal([input_size, rnn_unit])),
            'out': tf.Variable(tf.random_normal([rnn_unit, 1]))
        }
        biases = {
            'in': tf.Variable(tf.constant(0.1, shape=[rnn_unit, ])),
            'out': tf.Variable(tf.constant(0.1, shape=[1, ]))
        }
        keep_prob = tf.placeholder(tf.float32, name='keep_prob')  # dropout 防止过拟合
    
        # ——————————————————定义神经网络——————————————————
        def lstmCell():
            # basicLstm单元
            # tf.nn.rnn_cell.BasicLSTMCell(self, num_units, forget_bias=1.0,
            # tate_is_tuple=True, activation=None, reuse=None, name=None) 
            # num_units:int类型,LSTM单元(一层神经网络)中的中神经元的个数,和前馈神经网络中隐含层神经元个数意思相同
            # forget_bias:float类型,偏置增加了忘记门。从CudnnLSTM训练的检查点(checkpoin)恢复时,必须手动设置为0.0。
            # state_is_tuple:如果为True,则接受和返回的状态是c_state和m_state的2-tuple;如果为False,则他们沿着列轴连接。后一种即将被弃用。
            # (LSTM会保留两个state,也就是主线的state(c_state),和分线的state(m_state),会包含在元组(tuple)里边
            # state_is_tuple=True就是判定生成的是否为一个元组)
            #   初始化的 c 和 a 都是zero_state 也就是都为list[]的zero,这是参数state_is_tuple的情况下
            #   初始state,全部为0,慢慢的累加记忆
            # activation:内部状态的激活函数。默认为tanh
            # reuse:布尔类型,描述是否在现有范围中重用变量。如果不为True,并且现有范围已经具有给定变量,则会引发错误。
            # name:String类型,层的名称。具有相同名称的层将共享权重,但为了避免错误,在这种情况下需要reuse=True.
            #
    
            basicLstm = tf.nn.rnn_cell.BasicLSTMCell(rnn_unit, forget_bias=1.0, state_is_tuple=True)
            # dropout 未使用
            drop = tf.nn.rnn_cell.DropoutWrapper(basicLstm, output_keep_prob=keep_prob)
            return basicLstm
    
       
    
        def lstm(X):  # 参数:输入网络批次数目
            batch_size = tf.shape(X)[0]
            time_step = tf.shape(X)[1]
            w_in = weights['in']
            b_in = biases['in']
    
            # 忘记门(输入门)
            # 因为要进行矩阵乘法,所以reshape
            # 需要将tensor转成2维进行计算
            input = tf.reshape(X, [-1, input_size])
            input_rnn = tf.matmul(input, w_in) + b_in
            # 将tensor转成3维,计算后的结果作为忘记门的输入
            input_rnn = tf.reshape(input_rnn, [-1, time_step, rnn_unit])
            print('input_rnn', input_rnn)
            # 更新门
            # 构建多层的lstm
            cell = tf.nn.rnn_cell.MultiRNNCell([lstmCell() for i in range(lstm_layers)])
            init_state = cell.zero_state(batch_size, dtype=tf.float32)
    
            # 输出门
            w_out = weights['out']
            b_out = biases['out']
            # output_rnn是最后一层每个step的输出,final_states是每一层的最后那个step的输出
            output_rnn, final_states = tf.nn.dynamic_rnn(cell, input_rnn, initial_state=init_state, dtype=tf.float32)
            output = tf.reshape(output_rnn, [-1, rnn_unit])
            # 输出值,同时作为下一层输入门的输入
            pred = tf.matmul(output, w_out) + b_out
            return pred, final_states
    
        # ————————————————训练模型————————————————————
    
        def train_lstm(batch_size=60, time_step=20, train_begin=0, train_end=train_end_index):
            # 于是就有了tf.placeholder,
            # 我们每次可以将 一个minibatch传入到x = tf.placeholder(tf.float32,[None,32])上,
            # 下一次传入的x都替换掉上一次传入的x,
            # 这样就对于所有传入的minibatch x就只会产生一个op,
            # 不会产生其他多余的op,进而减少了graph的开销。
    
            X = tf.placeholder(tf.float32, shape=[None, time_step, input_size])
            Y = tf.placeholder(tf.float32, shape=[None, time_step, output_size])
            batch_index, train_x, train_y = get_train_data(batch_size, time_step, train_begin, train_end)
            # 用tf.variable_scope来定义重复利用,LSTM会经常用到
            with tf.variable_scope("sec_lstm"):
                pred, state_ = lstm(X) # pred输出值,state_是每一层的最后那个step的输出
            print('pred,state_', pred, state_)
    
            # 损失函数
            # [-1]——列表从后往前数第一列,即pred为预测值,Y为真实值(Label)
            #tf.reduce_mean 函数用于计算张量tensor沿着指定的数轴(tensor的某一维度)上的的平均值
            loss = tf.reduce_mean(tf.square(tf.reshape(pred, [-1]) - tf.reshape(Y, [-1])))
            # 误差loss反向传播——均方误差损失
            # 本质上是带有动量项的RMSprop,它利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率。
            # Adam的优点主要在于经过偏置校正后,每一次迭代学习率都有个确定范围,使得参数比较平稳.
            train_op = tf.train.AdamOptimizer(lr).minimize(loss)
            saver = tf.train.Saver(tf.global_variables(), max_to_keep=15)
    
            with tf.Session() as sess:
                # 初始化
                sess.run(tf.global_variables_initializer())
                theloss = []
                # 迭代次数
                for i in range(200):
                    for step in range(len(batch_index) - 1):
                        # sess.run(b, feed_dict = replace_dict)
                        state_, loss_ = sess.run([train_op, loss],
                                            feed_dict={X: train_x[batch_index[step]:batch_index[step + 1]],
                                                       Y: train_y[batch_index[step]:batch_index[step + 1]],
                                                       keep_prob: 0.5})
                                            #  使用feed_dict完成矩阵乘法 处理多输入
                                            #  feed_dict的作用是给使用placeholder创建出来的tensor赋值
    
    
                                            #  [batch_index[step]: batch_index[step + 1]]这个区间的X与Y
                                            #  keep_prob的意思是:留下的神经元的概率,如果keep_prob为0的话, 就是让所有的神经元都失活。
                    print("Number of iterations:", i, " loss:", loss_)
                    theloss.append(loss_)
                print("model_save: ", saver.save(sess, 'model_save2\\modle.ckpt'))
                print("The train has finished")
            return theloss
    
        theloss = train_lstm()
    
        # ————————————————预测模型————————————————————
        def prediction(time_step=20):
    
            X = tf.placeholder(tf.float32, shape=[None, time_step, input_size])
            mean, std, test_x, test_y = get_test_data(time_step)
            # 用tf.variable_scope来定义重复利用,LSTM会经常用到
            with tf.variable_scope("sec_lstm", reuse=tf.AUTO_REUSE):
                pred, state_ = lstm(X)
            saver = tf.train.Saver(tf.global_variables())
            with tf.Session() as sess:
                # 参数恢复(读取已存在模型)
                module_file = tf.train.latest_checkpoint('model_save2')
                saver.restore(sess, module_file)
                test_predict = []
                for step in range(len(test_x) - 1):
                    predict = sess.run(pred, feed_dict={X: [test_x[step]], keep_prob: 1})
                    predict = predict.reshape((-1))
                    test_predict.extend(predict)  # 把predict的内容添加到列表
    
                # 相对误差=(测量值-计算值)/计算值×100%
                test_y = np.array(test_y) * std[n1] + mean[n1]
                test_predict = np.array(test_predict) * std[n1] + mean[n1]
                acc = np.average(np.abs(test_predict - test_y[:len(test_predict)]) / test_y[:len(test_predict)])
                print("预测的相对误差:", acc)
    
                print(theloss)
                plt.figure()
                plt.plot(list(range(len(theloss))), theloss, color='b', )
                plt.xlabel('times', fontsize=14)
                plt.ylabel('loss valuet', fontsize=14)
                plt.title('loss-----blue', fontsize=10)
                plt.show()
                # 以折线图表示预测结果
                plt.figure()
                plt.plot(list(range(len(test_predict))), test_predict, color='b', )
                plt.plot(list(range(len(test_y))), test_y, color='r')
                plt.xlabel('time value/day', fontsize=14)
                plt.ylabel('close value/point', fontsize=14)
                plt.title('predict-----blue,real-----red', fontsize=10)
                plt.show()
    
    
    
        prediction()
    

    五、案例分析

    1、数据说明
    本实验分析了两种股票种类,为某单支股票(6109个连续时间点)数据data2上证综合指数前复权日线(6230个连续时间点,1991年到2016年)数据作为data2,分别保存在两个文件中,将两个数据集的最后一列设定为label。前90%数据作为训练集,后10%作为测试集。
    Data1:
    在这里插入图片描述
    Data2:
    在这里插入图片描述
    本次实验所采用的为LSTM模型:
    输入神经元个数 input_size = 选取列数
    输出神经元个数 output_size = 1 (预测值个数)
    学习率 lr = 0.0006
    随机初始化初始化网络权重

    2、数据预处理
    零-均值规范化(z-score标准化):
    标准化值,是讲集合中单个数与集合的均值相减的结果除以集合的标准差得到的标准化的结果,该方法类似与正态分布标准化转换,转换函数公式为:
    在这里插入图片描述
    公式中x为需要被标准化的原始值,μ为均值,σ为标准差,σ不等于0。
    Z分数标准化处理后的值代表原始值和集合均值之间的举例,以标准差为单位计算。该值存在正负值,低于均值均为辅助,反之则为证书,其范围为[-∞,+∞],数据均值为0,方差为1。
    3、损失函数
    损失函数(Loss function)是用来估量网络模型的预测值X与真实值Y的不一致程度,它是一个非负实值函数,通常用 L(Y,f(x))来表示。损失函数越小,模型的鲁棒性就越好。损失函数是经验风险函数的核心部分,也是结构风险函数的重要组成部分。
    本实验采取十分常用的均方误差损失
    平方损失也可以理解为是最小二乘法,一般在回归问题中比较常见,最小二乘法的基本原理是:最优拟合直线是使各点到回归直线的距离和最小的直线,即平方和最。同时在实际应用中,均方误差也经常被用为衡量模型的标准:
    在这里插入图片描述

    4、误差标准
    相对偏差是指某一次测量的绝对偏差占平均值的百分比。
    在这里插入图片描述
    5、可视化UI
    在这里插入图片描述
    在这里插入图片描述

    六、参数设置

    1、输入维度及迭代次数
    在这里插入图片描述
    由表一可见,输入维度越多,网络训练效果越好;迭代次数在100次时,网络已经比较稳定。
    2、忘记偏置
    在这里插入图片描述
    由表二可见,在data1(单支股票)forget_bias适当减小,即忘记部分信息,网络训练效果有些许提高,但在data2(大盘)中,网络训练效果却有所下滑。个人认为,可能是因为对于单支股票来说,近2天的数据相关程度比较小,而在大盘中,因为近2天的数据相关程度比较大,毕竟有多方面因素影响股价。
    3、LSTM单元数
    在这里插入图片描述

    由表三可见,两个数据集中,LSTM单元数增加的情况下时,网络训练效果反而下降,可以看出,其实股票行情在7天内的的相关联程度比在14天内的情况高,但是有可能是因为forget_bias过大。因此,在进行一组实验,调整forget_bias值进行比较。
    在这里插入图片描述
    由表四可以看出,在相同LSTM单元数的情况下,forget_bias较小时,预测效果较好,我们可以看出,在LSTM单元数较大的情况下,forget_bias应选取比较小的,以免记忆太多无效信息。
    在这里插入图片描述
    由表五可以看出,在data1和data2两个数据集中,LSTM单元数较小的情况下,forget_bias比较大时,预测效果较好,记忆更多相关信息。因此LSTM单元数较小的情况下,forget_bias应选取比较大的,记忆更多相关信息。

    4、可视化结果
    选取数据集data1,迭代次数为200次

    (1)、忘记偏置=1.0 , LSTM单元数 = 2
    在这里插入图片描述

    (2)、忘记偏置=0.7 , LSTM单元数 = 2(表现最好)
    在这里插入图片描述
    (3)、忘记偏置=1.0 , LSTM单元数 = 7
    在这里插入图片描述
    (4)、忘记偏置=1.0 , LSTM单元数 = 14
    在这里插入图片描述

    (5)、忘记偏置=0.7, LSTM单元数 = 7
    在这里插入图片描述
    (6)、忘记偏置=0.4 , LSTM单元数 = 7
    在这里插入图片描述
    (7)、忘记偏置=0.4 , LSTM单元数 = 14
    在这里插入图片描述

    七、结论

    针对以上实验,可以得知,在LSTM模型下的对股票收盘价预测值较为准确和稳定。对LSTM模型进行参数调整,发现迭代次数在100次后,网络模型趋于稳定,说明其是一个较轻量级的网络;在LSTM单元数较大的情况下,forget_bias应选取比较小的,以免记忆太多无效信息;LSTM单元数较小的情况下,forget_bias应选取比较大的,记忆更多相关信息。当然,这和本身的数据集有关。就股票数据集来说,本实验中表现的最优秀的是,忘记偏置为0.7,LSTM神经单元数取2时,网络预测效果最好,说明,在2天内股票序列是比较有价值的,与最后预测值有一定程度的联系。

    完整程序下载

    注意,代码下载后仍需自行调试~
    积分值为5(如果有变为csdn自行修改)——完整代码其实和上面贴出的差别不大,酌情下载~

    https://download.csdn.net/download/zxm_jimin/12126063

    参考文献
    [1] 陈卫华. 基于深度学习的上证综指波动率预测效果比较研究[D].统计与信息论坛,2018.
    [2] Hochreiter & Schmidhuber. Long short-term memory[ J]. Neural Computation, 1997, 9( 8).

    参考博客
    https://blog.csdn.net/jiaoyangwm/article/details/79725445
    https://blog.csdn.net/mylove0414/article/details/56969181

    感谢各位大佬看到最后~
    本文为原创。转载请注明出处。
    注:原理部分,参考了一些文章,博客,如有侵权请联系,我附上原出处。

    展开全文
  • 1月12日早间,名为“如何看待天才黑客 Flanker 疑因拒绝做黑客攻击业务,被拼多多强行辞退,错失上亿股票?”的话题冲上知乎热搜。 原阿里集团安全研究实验室总监云舒发微博称,某安全团队老大在5年即将到期,可以...

    本文转载自 新智元

    2021年开年持续霸占热榜的互联网某厂又霸榜了。1月12日早间,名为“如何看待天才黑客 Flanker 疑因拒绝做黑客攻击业务,被拼多多强行辞退,错失上亿股票?”的话题冲上知乎热搜。

    原阿里集团安全研究实验室总监云舒发微博称,某安全团队老大在5年即将到期,可以拿取股票时,突然被开除,而被开除的原因是「不愿做黑客攻击」。

    图片

    该话题知乎热搜1229万热度。

    不过,现在已经它已经从热榜消失了。

    Flanker是谁?

    这位在黑客圈里知名的Flanker大有来头,公开信息显示:@Flanker_017英文名为Flanker Edward,顶级黑客,前腾讯·科恩实验室高级研究员, PC Pwn2Own 2016 & Mobile Pwn2Own 2016冠军。

    离职?纠纷?

    至此,围绕互联网某厂的云雾又多了一层。

    Flanker何许人也?

    2015年10月24日,「黑客奥运会」GeekPwn大会在上海举办。

    一个看起来文质彬彬的男孩成功Root 360奇酷手机,要知道,该少年破解的奇酷手机搭载的居然还是360前夜推出的最新版本048系统。

    图片

    然而,这位少年并非一战成名,他在黑客圈儿一直小有名气。

    江湖名号Flanker,知名互联网企业安全总监,世界顶级黑客大赛Pwn2Own Mobile 和 PC 双料冠军,Google Android Security Top Researcher ,BlackHat USA和DEFCON演讲者。

    图片

    「天才」一直是他的标签。

    但Flanker也如平凡少年一样,经历过高考的压力。

    「当时家长觉得学化学肯定有用,学计算机就是玩物丧志。」

    少年时期,他虽参加了一些小型计算机竞赛,但更多的是比拼于化学竞赛,这些奖项成功帮他高考加分考入浙江大学

    那一年,他才15岁。

    图片

    上大学后,Flanker开始参加各种计算机竞赛。先是ACM的国际大学生程序设计竞赛,后来又接触CTF后,就开始打CTF(Capture The Flag,网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式)。

    19岁那一年,在有安全圈奥斯卡之称的Defcon总决赛中,Flanker所在的蓝莲花战队历史性地作为华人世界首次入围DEFCON CTF总决赛的队伍。

    渐渐的,Flanker有了自己的职业方向:安全研究员。

    图片

    后面在机缘巧合下,Flanker进入腾讯安全科恩实验室,虽在一些国际比较前沿的领域取得了非常不错的成果,但后来Flanker还是回到了业务安全领域。

    图片

    正如与他一起打入DEFCON总决赛的队友一样,战队中很多人都成为了各种团队里核心的研究员或技术负责人。

    图片

    Flanker知乎主页

    Flanker加入了某知名美股上市公司担任安全总监,负责公司整体安全。

    那时,他还没满26岁。

    2020年12月22日,Flanker发微博称离职:

    图片

    事情发酵后,知乎上疑似Flanker的前同事也为Flanker打抱不平,更加证实了Flanker被强行开除的原因。

    展开全文
  • 从今天开始正式开启我的博客之旅,博客内容全部是我自己的量化心得,主要还是为自己将来中工作之中遇到...思路:在A股市场之中,在每个月月底的时候,按照市值排名,选择最小市值的10只股票买入,持有到下个月月底...

    从今天开始正式开启我的博客之旅,博客内容全部是我自己的量化心得,主要还是为自己将来中工作之中遇到相似问题,可以方便的找到答案,如果能帮到有相似问题的其他同学,我也很开心,如果帮不到的话,不喜勿喷,如果文章中有什么不对的地方,欢迎批评指正。

     

    建立第一个简单的量化模型——小市值选股票模型。

    思路:在A股市场之中,在每个月月底的时候,按照市值排名,选择最小市值的10只股票买入,持有到下个月月底,每月调仓一次,坚持一年,看收益率能否跑赢同期的创业板指数/中小板指数

     


    具体操作:

    方法1:

    自己下载数据并且进行清洗和计算,建议使用tushare网站——http://tushare.org/,数据质量不错,还免费。

    然后经过清洗和计算之后,得到自己想要的结果,我大概是用了近3天的时间才搞定,主要还是自己以前没学过python,很多函数都是现学现卖,浪费很多时间,之前的博客写过相关的内容,现在来看不值得新手学习,原因有二:

    1:下载太多,数据清洗步骤太多,需要用到pandas 的各种方法,相比较之下都不是很好的方法,毕竟量化交易的核心不在数据清洗,这些都是基本工作,如果有质量很高的数据的话,可以减少很多无用功,所以建立一个好的数据库,可以节省很多时间。

    2:在自己进行这个策略编织的时候,其实90%以上的时间都是用于计算各种数值,或者画图,这里还不包括用来评价策略好坏的夏普比率,要是加上的话,代码更多,真正策略本身的代码其实少得可怜,大多数都是脏活累活的数据清洗和整理,所以决定以后还是用第三方平台效率更高一些,可以更加的专注策略本身。

    方法2:

    使用第三方平台,目前我使用的是聚宽,我对比了一下聚宽、优矿、大宽网(已经倒闭了),都大同小异,选哪个都一样。

     

    顺便说一句,虽然这些平台都大同小异,但是代码可不能简单复制粘贴,因为底层函数库是不一样的,有可能在别的平台根本用不了某个函数,并且简单复制到自己电脑中的python的话百分之百用不了。

    talking is cheap, show me the code

    展示部分源代码

    def find(context):
        # 计算出要买的股票——按照流通市值从小到大排序,并且选出50只,因为有可能有ST/*ST/停牌/涨停的股票,所以先得出股票池
        df=get_fundamentals(query
        (valuation.code,valuation.circulating_market_cap).order_by(valuation.circulating_market_cap)).loc[:49,'code']
        
        # 把股票池转为列表,并且带入过滤函数得到最后的buylist
        buylist=list(df)
        buylist=filter_stock(buylist)[:30]
        
        #得到目前持仓 
        hold=[]
        for i in context.portfolio.positions.keys():
            hold.append(i)
        # 如果目前持有的股票不在buylist中,就都卖出
        sell=[]
        for i in hold:
            if i not in buylist:
                order_target_value(i,0)
        # 如果在buylist中的股票,不在目前的持仓中,就把股票放到to_buy中
        to_buy=[]
        for i in buylist:
            if i not in hold:
                to_buy.append(i)
        # 如果to_buy不是空列表的话,就给每只股票平分可用资金,然后进场
        if len(to_buy)>0:
            cash=context.portfolio.available_cash/len(to_buy)
            for i in to_buy:
                order_value(i,cash)

    代码的思路是,每个月底进行调仓,选出市值最小的股票交易,去掉ST/*ST/停牌/涨停的股票,然后选择最小市值的10只,基准是创业板综指,看看结果吧。

    时间2017.1.1-2018.12.31,这波大盘走势先上后下,形成巨幅震荡行情

    跑输创指,并且整体很悲催

     

    时间2016.1.1-2018.2.28,大盘先下后上,和上次走势正好相反,但是因子的效果不同

    这次跑赢指数,但是惨胜,回撤有点过分了

     

    2014.4.28-2014.12.11,大盘单边上涨行情

    表现非常靓丽。

    结论:

    1.因子本身的确有效,但是很明显单因子是不可能直接使用的。

    2.顺风太浪,逆风就投,牛市来的时候可以搞,熊市很难做到降低风险

    如果自己有策略,但是不会写代码的话,可以给我私信,价钱从几十到几百不等,看策略实现的难易程度而定,我使用的是聚宽平台,代码写好之后,可以在上面上模拟盘和实盘,对应的券商是第一创业证券。

    展开全文
  • 股票数据下载-下载股票历史数据

    千次阅读 2019-12-26 14:29:20
    今天介绍最简单的股票数据下载方法,在线可以批量下载,目前A股、港股、美股所有个股的股票历史数据都能下载到。 还有大包好的A股4000+个股数据文件,包含了A股市场所有个股的股票数据。
  • 【我的开源】股票软件简介+源码(蜗牛股票软件)

    万次阅读 多人点赞 2017-08-11 14:52:45
    蜗牛股票软件是博主在业余时间开发的一款股票软件,运行于Windows环境,目前已经开源到GitHub上,界面使用VC++/MFC开发,IDE选用Visual Studio 2010,后台使用java开发,使用微服务spring boot框架。 目前支持的...
  • stock_code stock code, stock symbol 美股股票代码 file us_stock_code.csv code name 0 A 安捷伦 1 AA ...
  • 股票估价

    2019-02-10 00:48:11
    一、股票及其收益率 股票投资的目的是为了:①获利 ②控股 衡量股票的价值的绝对数:股息,价差、利息 衡量股票的价值的相对数:收益率 股票投资收益可以看成是资本利得收益与股利收益之和,用公式表示即 ...
  • 股票评级

    千次阅读 2019-03-13 23:59:21
    股票评级方法 1、获利能力: 税后盈利率=税后盈利额/股本×100% (指标权数分:40) 2、股价波动性: (指标权数分:20) XHi被评股票第i月份最高价 XLi被评股票第i月份最低价 3、股票市场性 股票交易周转率=...
  • 手把手教你利用 python 爬虫分析基金、股票

    千次阅读 多人点赞 2021-02-16 22:43:28
    手把手教你利用 python 爬虫分析基金、股票 文章目录手把手教你利用 python 爬虫分析基金、股票第一步:基金数据爬取第二步:股票增持计算第三步:好股基金选取 从前大家朋友圈都在晒美食,晒旅游,晒玩乐,现在翻...
  • 股票术语

    千次阅读 2018-10-19 19:10:23
    多头:对股票后市看好,先行买进股票,等股价涨至某个价位,卖出股票赚取差价的人。 空头:是指变为股价已上涨到了最高点,很快便会下跌,或当股票已开始下跌时,变为还会继续下跌,趁高价时卖出的投资者。 利空...
  • 博主路一瓢的博文:Tensorflow实例:利用LSTM预测股票每日最高价(一)Tensorflow实例:利用LSTM预测股票每日最高价(二)在以上两篇博文中,博主介绍了RNN和LSTM,并使用LSTM实现了股票预测的例子,让人受益匪浅。...
  • Python3对股票数据进行分析

    万次阅读 多人点赞 2019-04-19 10:40:17
    5、股票回测 二、股票数据 三、股票数据分析 1、导入股票时间序列数据 2、绘制股票成交量的时间序列图 3、绘制股票收盘价和成交量的时间序列图 3、绘制K线图(蜡烛图) (1)K线图理论 (2)K线图绘制 4、...
  • 股票接口

    千次阅读 2018-04-23 22:09:11
    第一种:php使用数据接口实现实时股票行情数据,含沪深股市、香港股市、美国股市等。 股票行情获取文档可看这里 https://www.nowapi.com/api/finance.stock_realtime 所有支持的股票代码可看这里 ...
  • 股票复权计算

    千次阅读 2019-12-26 10:30:41
    股票复权 股票复权算法
  • 腾讯股票接口: 分时图 http://data.gtimg.cn/flashdata/hushen/minute/sz000001.js?maxage=110&0.28163905744440854 五天分时图 http://data.gtimg.cn/flashdata/hushen/4day/sz/sz000002.js?maxage=43200&...
  • 股票作为长期理财和主要收益来源(股票,房产,长期持有债券)的一种,知道怎么玩儿才能让财富增值。搜寻了很多关于股票的课程,大多数是夸夸其谈,最后找到一个不贩卖套路,只输出干货的有钱君,今年就以理论学习为...
  • 腾讯股票接口: 获取最新行情 http://qt.gtimg.cn/q=sh600000 v_sh600519="1~贵州茅台~600519~1265.70~1274.90~1271.00~24661~11850~12609~1265.69~8~1265.68~18~1265.60~1~1265.50~1~1265.46~3~1265.70~6~1265.85~2...
  • Python-抓取股票信息

    千人学习 2017-08-21 14:53:48
    学习利用抓取股票信息
  • LeetCode股票问题总结java

    万次阅读 2020-07-10 10:29:23
    股票问题总结java 个人博客 https://www.b2bchain.cn/6492.html 309. 最佳买卖股票时机含冷冻期 //给定一个整数数组,其中第 i 个元素代表了第 i 天的股票价格 。 // // 设计一个算法计算出最大利润。在满足...
  • 股票是公司公司公开发行的股份,持有股票意味着你是公司的股东,可以在年底获得公司的分红。假如公司有100股,当年产生利润10块钱,每股收益 = 10/100=0.1。现在银行定期存款利率是0.04左右,1/0.04=25, 本金和收益...
  • 股票进行可视化分析

    千次阅读 多人点赞 2021-01-07 16:07:16
    对一只股票的数据分析前言一、数据爬取二、数据可视化分析1.近三个月的走势2.股票点数的最大值区间3.每日低点分析4.低开高走的时间段总结 前言 本文通过对股票数据的爬取,进而对这只股票进行可视化数据分析,分析的...
  • 爬取股票信息(股票代码+价格)

    千次阅读 2020-01-30 14:54:49
    思路为先从东方财富网获取股票列表,列表包含所有的股票名称和代码。然后再根据股票代码从老虎社区获取到个股的价格信息。 直接上代码: import requests from bs4 import BeautifulSoup import re # 获得HTML...
  • 沪深A总共有3700多只股票,一只只股票去看肯定不现实,这时候就需要一个股票筛选的工具。 最近一直想找一款股票查询的工具,可是世面上有的不是收费的,就是不满足我的需求的。如是闲得蛋疼自己做了一个股票筛选的...
  • 股票数据下载-如何下载股票历史行情数据?只要两步就能下载:1. 填股票代码 2. 收到股票历史数据Excel 股票数据是研究和分析行情的基础,不管是量化分析还是数据对比,股票数据都是最基础的部分。之前各个炒股软件...
  • 股票对于首次接触的人来说可能是很混乱的,不了解股票的内容买卖股票可能自己会造成财产损失,股票短线就要先了解清楚,所以股票股民们要了解股票短线可以多学习一下宽客相对论或者是QR相对论,对以后买股票都是有...
  • 实时获取股票数据 (1)实现步骤 1.通过网络爬虫–>爬取所需要的数据->股票实时价,最高价,最低价等等 2.通过python的->pandas库->进行数据整理清洗 (2)实现前的准备工作 神奇的网址 返回一个股票的数据:...
  • 因此,建议多掌握一些短线股票买入时机以及短线股票一般几天等等炒股技巧,就可以让自己变得更加强大了!建议学习一下超级实用的QMACD知识,提高炒股技巧。 短线股票买入时机 短线股票操作理念是看大做小,看长做短...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,496
精华内容 22,998
关键字:

股票