精华内容
下载资源
问答
  • Java调用weka神经网络算法预测股票,含有代码及数据,代码有详细解释,数据为大量数据。
  • #-*- coding: utf-8 -*- import pandas as pd import os os.environ['TF_CPP_MIN_LOG_LEVEL']='2' inputfile = '../data/sales_data.xls' data = pd.read_excel(inputfile, index_col = u'序号') ...
    python3.5下运行
    #-*- coding: utf-8 -*-
    
    
    import pandas as pd
    import os
    os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    
    
    inputfile = '../data/sales_data.xls'
    data = pd.read_excel(inputfile, index_col = u'序号')
    data[data == u'好'] = 1
    data[data == u'是'] = 1
    data[data == u'高'] = 1
    data[data != 1] = 0
    x = data.iloc[:,:3].as_matrix().astype(int)
    y = data.iloc[:,3].as_matrix().astype(int)
    
    from keras.models import Sequential
    from keras.layers.core import Dense, Activation
    
    model = Sequential()
    #model.add(Dense(input_dim = 3, output_dim = 10))
    model.add(Dense(units=10, input_dim=3))
    model.add(Activation('relu'))
    #model.add(Dense(input_dim = 10, output_dim = 1))
    model.add(Dense(input_dim=10, units=1))
    model.add(Activation('sigmoid'))
    
    model.compile(loss = 'binary_crossentropy', optimizer = 'adam', class_mode = 'binary')
    
    model.fit(x, y, epochs = 1000, batch_size = 10)
    yp = model.predict_classes(x).reshape(len(y))
    from cm_plot import *
    cm_plot(y,yp).show()
    
    

    sales_data.xls

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34




    python3.5下运行

    展开全文
  • 模糊神经网络,结合模糊算法与神经网络算法进行预测,MATLAB哈
  • 分析了BP神经网络的特点,从学习速率的角度讨论了BP算法的...仿真结果表明,改进BP神经网络算法预测的平均误差比常规算法降低了0.445%,并且克服了当接近最优解时易产生波动和振荡现象的问题,训练速度也有所提高.
  • 基于神经网络算法的股价趋势预测方法
  • 神经网络算法

    2014-09-22 16:48:05
    神经网络算法用于解决很多预测问题 神经网络预测准确可靠
  • 数据挖掘-分类与预测-神经网络算法

    千次阅读 2018-08-12 18:57:18
    # 使用神经网络算法预测销量高低 import sys reload(sys) sys.setdefaultencoding('utf-8') #导入sys,重新设置编码格式主要是为了解决执行代码报:UnicodeDecodeError: 'ascii' codec can't decode by...

    代码来源:Python数据分析与挖掘实战

    # -*- coding: utf-8 -*-
    # 使用神经网络算法预测销量高低
    
    import sys
    reload(sys)
    sys.setdefaultencoding('utf-8')    #导入sys,重新设置编码格式主要是为了解决执行代码报:UnicodeDecodeError: 'ascii' codec can't decode byte 0xe6 in position 129: ordinal not in range(128)
    import pandas as pd
    from keras.models import Sequential    #顺序模型
    from keras.layers.core import Dense, Activation
    from cm_plot import *
    
    inputfile = '../data/sales_data.xls'
    data = pd.read_excel(inputfile, index_col=u'序号')
    
    data[data==u'好'] = 1
    data[data==u'是'] = 1
    data[data==u'高'] = 1
    data[data!=1] = 0
    
    x = data.iloc[:,:3].as_matrix().astype(int)
    y = data.iloc[:,3].as_matrix().astype(int)
    
    model = Sequential()    #建立模型后可以使用.add来堆叠模型
    model.add(Dense(input_dim=3, output_dim=10))    #建立的神经网络有3个输入节点、10个隐藏节点,添加输入层(3节点)到隐藏层(10节点)的连接
    model.add(Activation('relu'))    #用relu函数作为激活函数,能够大幅提供准确度
    model.add(Dense(input_dim=10, output_dim=1))    #添加隐藏层(10节点)到输出层(1节点)的连接
    model.add(Activation('sigmoid'))    #由于是0-1输出,用sigmoid函数作为激活函数
    
    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])   #crossentropy: 交叉熵; 使用的优化器是'adam'
    #变异模型。由于我们做的是二元分类,所以我们指定损失函数为binary_crossentropy, 以及模式为binary
    #另外常见的损失函数还有mean_squared_error、categorical_crossentropy等
    #求解方法我们指定用adam,还有sgd,rmsprop等可选
    
    model.fit(x, y, nb_epoch=1000, batch_size=10)    #训练模型,学习一千次
    yp = model.predict_classes(x).reshape(len(y))    #分类预测;predict_classes()只能用于序列模型来预测,不能用于函数式模型
    cm_plot(y, yp).show()    #显示混淆矩阵可视化结果

    cm_plot.py

    #-*- coding: utf-8 -*-
    
    def cm_plot(y, yp):
      from sklearn.metrics import confusion_matrix    #导入混淆矩阵函数
      cm = confusion_matrix(y, yp)    #混淆矩阵
      import matplotlib.pyplot as plt
      plt.matshow(cm, cmap=plt.cm.Greens)     #画混淆矩阵图,配色风格使用cm.Greens
      plt.colorbar()    #颜色标签
      
      for x in range(len(cm)):    #数据标签
        for y in range(len(cm)):
          plt.annotate(cm[x,y], xy=(x, y), horizontalalignment='center', verticalalignment='center')
      
      plt.ylabel('True label')    #坐标轴标签
      plt.xlabel('Predicted label')    #坐标轴标签
      return plt

     输出:

    展开全文
  • 神经网络预测算法

    2015-11-21 20:23:42
    神经网络预测方法的MATLAB仿真实现,可对周期数据进行精准预测
  • 灰色神经网络预测算法—订单需求预测 matlab程序 供大家学习
  • 神经网络算法在交通量预测中的应用,周玮明,,本文针对BP神经网络在进行交通量预测中存在很多不足的方面,利用遗传算法所具有的全局搜索能力,可以同时处理搜索空间中的多个个�
  • matlab神经网络源码集锦-基于灰色神经网络预测算法研究—订单需求预测
  • 本代码主要利用MATLAB工具进行灰色神经网络预测算法的仿真,实现订单需求预测的模拟
  • 基于联想神经网络算法的电力系统负荷预测.pdf
  • 基于改进递推预测误差神经网络算法的RBF神经网络PID控制方法,王银河,吴平景,针对工业控制中系统模型参数通常未知的特点,利用改进递推预测误差算法为基础的神经网络系统参数辨识方法,设计了RBF神经网络PID控
  • 基于模糊逻辑聚类神经网络算法的中长期负荷预测.pdf
  • 基于神经网络和聚类预测算法.ppt
  • 智能预测控制BP神经网络算法
  • 中长期负荷预测的模糊竞争学习聚类神经网络算法.pdf
  • 神经网络算法源程序大全神经网络算法源程序大全神经网络算法源程序大全神经网络算法源程序大全
  • 灰色神经网络预测算法—订单需求预测(matlab实现),包含源代码和测试数据
  • ARIMA算法预测速度较快,平均误差在3%以内,特别适合这种超短期负荷预测,而小波分析+BP神经网络算法是一种适应性比较广的算法,在此次超短期负荷预测中它的平均误差在7%以内,预测时间相对更长。 此程序由华北电力...
  • 一个bp神经网络进行交通预测的Matlab源代码,里面备有较为详细的注释,供给初学者! 不仅有最初的bp模型,还包括优化的算法,总共有多个程序段,大家可以根据自己的数据情况选择适合的神经网络结构!
  • 基于BP神经网络的电力负荷预测中的应用,叙述了神经网络预测方面的应用。
  • 如今,当人们想预测足球比赛的结果时,大多数人只是参考自己的经验... 有三种典型算法-卷积神经网络(ANN),随机森林(RF)和支持向量机(SVM)。 本文将这三种算法都用于预测足球比赛的结果,并比较了它们的准确性。
  • 针对系统误差的不确定性可能会引起滤波精度降低或发散的问题,提出一种新的基于模型预测滤波的前向神经网络算法。首先,采用模型预测滤波估计网络在正向传递过程中的模型误差,并对其进行修正,以弥补模型误差对隐含层...
  • BP神经网络算法例子

    2018-01-24 14:18:34
    BP神经网络算法 实现历史数据的样本训练 并对未来数据做出合理预测的案例
  • 针对传统遗传神经网络算法易出现的早熟收敛及锯齿等现象,提出一种新型算法应用于土壤墒情预测。该算法提出了衡量种群基因多样性的遗传多样性函数的概念,自适应调节交叉和变异策略,在全局范围内寻找最优初始网络...
  • 用遗传算法为 BP 神经网络优化权值,使网络具有快速学习网络权重的能力,并且能够摆脱局部极小点的困扰。遗传算法的全局搜索能力来弥补BP算法全局搜索能力不足,实例证明,这种预测模型比BP网络预测模型具有更高的...
  • 模糊神经网络预测算法-嘉陵江水质评价 matlab程序
  • 神经网络算法,是使用计算机模拟生物神经系统,来模拟人类思维方式的算法。它的基本单位就是人工神经元。通过相互连接形成一张神经网络。 生物神经网络中,每个神经元与其他神经元连接,当它“激活”时,会传递...

    一、单个神经元

    神经网络算法,是使用计算机模拟生物神经系统,来模拟人类思维方式的算法。它的基本单位就是人工神经元。通过相互连接形成一张神经网络。

    生物神经网络中,每个神经元与其他神经元连接,当它“激活”时,会传递化学物质到相连的神经元,改变其他神经元的电位,当电位达到一定“阈值”,那么这个神经元也会被激活。

    单个人工神经元的计算公式:

    其中:

     为输入参数向量,表示其他神经元输入的信号。

     为每个输入参数的权重值,表示对应神经元信号的权重。

    θ为阈值或者偏差值,是指该激活神经元的难易程度。

    y为神经元的输出值,表示该神经元是否被激活。

    Act()为激活函数,理想的激活函数是下图(a)中的跃阶函数,“1”为神经元兴奋,“0”为神经元抑制,但由于跃阶函数具有不是连续可导等不好的性质,因此一般采用下图(b)的Sigmoid函数作为激活函数。

     

    二、全连接神经网络结构

    我们来定义一个全连接神经网络:

    全连接神经网络,就是指每一层的每个神经元都和下一层的每个神经元相连接。

    Layer:0为输入层,

    Layer:L为输出层

    其他L-1个Layer为隐层

    输入x

     

    我们称一个输入值x为一个样本

    输出 y

    变量的上标(0)(L),表示该变量处于神经网络的哪一层。

    表示第L层编号为i的神经元。 表示第L层的神经元数量。

    更好的理解神经网络,可观看此视频:https://www.bilibili.com/video/av15532370

     

    三、反向传播算法(BP算法)

    下面来说明如何调整一个神经网络的参数,也就是误差反向传播算法(BP算法)。以得到一个能够根据输入,预测正确输出的模型。

    1、首先我们要了解优化的目标

    根据人工神经元的定义,有以下三个公式:

    其中,Act()是激活函数,之前已经说过。

    根据公式(2)和公式(3),可以得出各个神经元之间的通用计算公式,如下所示:

    公式(4)是人工神经网络正向传播的核心公式。

     

    那么,我们根据什么来调整神经网络的参数,以得到一个能够正确预测结果的模型呢?请看下面的公式:

    公式(5)用来计算我们期望的输出和实际输出的“差别”,其中cost()叫做损失函数。我们的期望是损失值达到最小。

    但是,只根据一次输出的损失值,对参数进行调整,无法使模型适应所有输入样本。我们需要的是,调整参数,使得所有输入样本,得到输出的总损失值最小,而不是只让其中一个样本的损失值最小,导致其他样本损失值增大。因此有如下公式:

    公式(6)表示一个batch的所有样本输出的总损失值的平均值。其中,bn表示一个batch中样本的数量。

    为什么不用所有的样本计算损失值,而将所有样本分成一个个的batch呢?因为所有的训练样本数量太大了,可能有数以百万计,将所有的样本损失值都一起进行运算,计算量过于庞大,大大降低了模型计算的速度。

    公式(6)中计算总的损失值C,其实是一个以所有的连接权值ω和所有的阈值θ未为变量的多元函数。我们想要的模型就是求得C最小时,所有ω和θ的值。直接计算显然是不可能的,因为对于一个大的深度神经网络,所有的参数变量,可能数以万计。

    在这里我们使用梯度下降算法来逐步逼近C的最小值,也就是先随机得到一组参数变量的值,然后计算参数变量当前的梯度,向梯度的反方向,也就是C变小最快的方向,逐步调整参数值,最终得到C的最小值,或者近似最小值。

    而将所有样本,随机分成一个个固定长度的batch,以得到近似的梯度方向,叫做随机梯度下降算法

    更好理解梯度下降算法,逐步求得最优的参数值,可观看此视频:https://www.bilibili.com/video/av16144388

     

    2、开始求梯度

    那么,根据梯度的定义,接下来的任务,就是求取各个参数变量相对于C的偏导数。我们将使用误差反向传播算法来求取各个参数变量的偏导数。

    这里先剧透一下,求取参数偏导数的方法,和神经网络正向传播(根据样本计算输出值)的方式类似,也是逐层求解,只是方向正好相反,从最后一层开始,逐层向前。

    更好的理解误差反向传播算法,可观看此视频:https://www.bilibili.com/video/av16577449

    首先,我们先求神经网络最后一层,也就是输出层的相关参数的偏导数。为了降低推导的复杂性,我们只计算相对于一个样本的损失值函数Cbi的偏导数,因为相对于总损失值函数C的偏导数值,也不过是把某个参数的所有相对于Cbi偏导数值加起来而已。

    根据公式(2)、公式(3)、公式(5),以及“复合函数求导法则”,可以得到输出层(L层)某个神经元的权值参数ω的偏导数,计算公式如下:

    根据公式(5)可以得到:

    根据公式(2)可以得到:

    根据公式(3)可以得到:

    将公式(8)(9)(10),带入公式(7),可以得到:

     

    我们令:

    根据公式(8)(9)则有:

    将公式(13),带入公式(11),可以得到:

    这样我们就得到了输出层L相关的权值参数ω的偏导数计算公式!

    接下来,同理可得输出层L相关的阈值θ的偏导数计算公式为:

    而根据公式(3)可以得到:

    将公式(16)带入公式(15)可以得到:

    这就是输出层L相关的阈值θ的偏导数计算公式!

     

    3、根据L层,求前一层参数的偏导函数

    由公式(3)可知,一个权值参数ω只影响一个L-1层的神经元,因此有:

    根据公式(3)可以得到:

    将公式(19)带入公式(18)可以得到:

    根据公式(12)可以得到:

    将公式(21)带入公式(20)可以得到:

    同理,我们可以得到:

    根据公式(3)可以得到:

    将公式(24)带入公式(23)可以得到:

    这样我们就得到了L-1层神经元相关参数的计算公式!

     

    下面,我们还需要推导一下 之间的关系,根据公式(2)可以得到:

    同样根据公式(2)可以得到:

    将公式(27)带入公式(26)可以得到:

    由公式(3)可知,一个权值参数ω只影响一个L-1层的神经元,但这个L-1层神经元影响了所有L层的神经元。因此,根据“多元复合函数求导法则”有:

    根据公式(12)可以得到:

    将公式(27)带入公式(26)可以得到:

    根据公式(3)可以得到:

    将公式(32)带入到公式(31)可以得到:

    将公式(33)带入公式(28)可以得到:

    这样我们就得到了反向传播,逐层推导的通用公式:

    在这里,ω和z都是正向传播过程中,已经算好的常数,而  可以从L层开始逐层向前推导,直到第1层,第0层是输入层,不需要调整参数。而第L层的   可参考公式(13)。

     

    下面是全连接神经网络的python实现代码:

    #coding=utf-8
    import numpy as np
    import matplotlib.pylab as plt
    import random
    
    class NeuralNetwork(object):
        def __init__(self, sizes, act, act_derivative, cost_derivative):
            #sizes表示神经网络各层的神经元个数,第一层为输入层,最后一层为输出层
            #act为神经元的激活函数
            #act_derivative为激活函数的导数
            #cost_derivative为损失函数的导数
            self.num_layers = len(sizes)
            self.sizes = sizes
            self.biases = [np.random.randn(nueron_num, 1) for nueron_num in sizes[1:]]
            self.weights = [np.random.randn(next_layer_nueron_num, nueron_num)
                for nueron_num, next_layer_nueron_num in zip(sizes[:-1], sizes[1:])]
            self.act=act
            self.act_derivative=act_derivative
            self.cost_derivative=cost_derivative
    
        #前向反馈(正向传播)
        def feedforward(self, a):
            #逐层计算神经元的激活值,公式(4)
            for b, w in zip(self.biases, self.weights):
                a = self.act(np.dot(w, a)+b)
            return a
    
        #随机梯度下降算法
        def SGD(self, training_data, epochs, batch_size, learning_rate):
            #将训练样本training_data随机分为若干个长度为batch_size的batch
            #使用各个batch的数据不断调整参数,学习率为learning_rate
            #迭代epochs次
            n = len(training_data)
            for j in range(epochs):
                random.shuffle(training_data)
                batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
                for batch in batches:
                    self.update_batch(batch, learning_rate)
                print("Epoch {0} complete".format(j))
    
        def update_batch(self, batch, learning_rate):
            #根据一个batch中的训练样本,调整各个参数值
            nabla_b = [np.zeros(b.shape) for b in self.biases]
            nabla_w = [np.zeros(w.shape) for w in self.weights]
            for x, y in batch:
                delta_nabla_b, delta_nabla_w = self.backprop(x, y)
                nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
                nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
            #计算梯度,并调整各个参数值
            self.weights = [w-(learning_rate/len(batch))*nw for w, nw in zip(self.weights, nabla_w)]
            self.biases = [b-(learning_rate/len(batch))*nb for b, nb in zip(self.biases, nabla_b)]
    
        #反向传播
        def backprop(self, x, y):
            #保存b和w的偏导数值
            nabla_b = [np.zeros(b.shape) for b in self.biases]
            nabla_w = [np.zeros(w.shape) for w in self.weights]
            #正向传播
            activation = x
            #保存每一层神经元的激活值
            activations = [x]
            #保存每一层神经元的z值
            zs = []
            for b, w in zip(self.biases, self.weights):
                z = np.dot(w, activation)+b
                zs.append(z)
                activation = self.act(z)
                activations.append(activation)
            #反向传播得到各个参数的偏导数值
            #公式(13)
            d = self.cost_derivative(activations[-1], y) * self.act_derivative(zs[-1])
            #公式(17)
            nabla_b[-1] = d
            #公式(14)
            nabla_w[-1] = np.dot(d, activations[-2].transpose())
            #反向逐层计算
            for l in range(2, self.num_layers):
                z = zs[-l]
                sp = self.act_derivative(z)
                #公式(36),反向逐层求参数偏导
                d = np.dot(self.weights[-l+1].transpose(), d) * sp
                #公式(38)
                nabla_b[-l] = d
                #公式(37)
                nabla_w[-l] = np.dot(d, activations[-l-1].transpose())
            return (nabla_b, nabla_w)
    
    #距离函数的偏导数
    def distance_derivative(output_activations, y):
        #损失函数的偏导数
        return 2*(output_activations-y)
    
    # sigmoid函数
    def sigmoid(z):
        return 1.0/(1.0+np.exp(-z))
    
    # sigmoid函数的导数
    def sigmoid_derivative(z):
        return sigmoid(z)*(1-sigmoid(z))
    
    if __name__ == "__main__":
        #创建一个5层的全连接神经网络,每层的神经元个数为1,8,5,3,1
        #其中第一层为输入层,最后一层为输出层
        network=NeuralNetwork([1,8,5,3,1],sigmoid,sigmoid_derivative,distance_derivative)
    
        #训练集样本
        x = np.array([np.linspace(-7, 7, 200)]).T
        #训练集结果,由于使用了sigmoid作为激活函数,需保证其结果落在(0,1)区间内
        y = (np.cos(x)+1)/2
    
        #使用随机梯度下降算法(SGD)对模型进行训练
        #迭代5000次;每次随机抽取40个样本作为一个batch;学习率设为0.1
        training_data=[(np.array([x_value]),np.array([y_value])) for x_value,y_value in zip(x,y)]
        network.SGD(training_data,5000,40,0.1)
    
        #测试集样本
        x_test = np.array([np.linspace(-9, 9, 120)])
        #测试集结果
        y_predict = network.feedforward(x_test)
    
        #图示对比训练集和测试集数据
        plt.plot(x,y,'r',x_test.T,y_predict.T,'*')
        plt.show()

     

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,115
精华内容 45,246
关键字:

神经网络算法预测