精华内容
下载资源
问答
  • 提出在危险模式入侵检测系统中使用利用多层支撑矢量机分类算法对免疫克隆算法对原始数据的行为特征集进行优化获得的最优抗体集合,可以大大缩短危险模式入侵检测系统抗体模式库的训练时间。
  • TF之LSTM:利用多层LSTM算法对MNIST手写数字识别数据集进行多分类 目录 设计思路 实现代码 设计思路 更新…… 实现代码 # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np...

    TF之LSTM:利用多层LSTM算法对MNIST手写数字识别数据集进行多分类

     

     

    目录

    设计思路

    实现代码


     

     

    设计思路

    更新……

     

     

    实现代码

    
    
    
    # -*- coding:utf-8 -*-
    import tensorflow as tf
    import numpy as np
    from tensorflow.contrib import rnn
    from tensorflow.examples.tutorials.mnist import input_data
    
    #根据电脑情况设置 GPU
    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True
    sess = tf.Session(config=config)
    
    # 1、定义数据集
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
    print(mnist.train.images.shape)
    
    
    #2、定义模型超参数
    lr = 1e-3
    # batch_size = 128
    batch_size = tf.placeholder(tf.int32)  #采用占位符的方式,因为在训练和测试的时候要用不同的batch_size。注意类型必须为 tf.int32
    input_size = 28      # 每个时刻的输入特征是28维的,就是每个时刻输入一行,一行有 28 个像素
    timestep_size = 28   # 时序持续长度为28,即每做一次预测,需要先输入28行
    hidden_size = 256    # 每个隐含层的节点数
    layer_num = 2        # LSTM layer 的层数
    class_num = 10       # 最后输出分类类别数量,如果是回归预测的话应该是 1
    
    _X = tf.placeholder(tf.float32, [None, 784])
    y = tf.placeholder(tf.float32, [None, class_num])
    keep_prob = tf.placeholder(tf.float32)
    
    #3、LSTM模型的搭建、训练、测试
    #3.1、LSTM模型的搭建
    X = tf.reshape(_X, [-1, 28, 28])  #RNN 的输入shape = (batch_size, timestep_size, input_size),把784个点的字符信息还原成 28 * 28 的图片
    lstm_cell = rnn.BasicLSTMCell(num_units=hidden_size, forget_bias=1.0, state_is_tuple=True)      #定义一层 LSTM_cell,只需要说明 hidden_size, 它会自动匹配输入的 X 的维度
    lstm_cell = rnn.DropoutWrapper(cell=lstm_cell, input_keep_prob=1.0, output_keep_prob=keep_prob) #添加 dropout layer, 一般只设置 output_keep_prob
    mlstm_cell = rnn.MultiRNNCell([lstm_cell] * layer_num, state_is_tuple=True)  #调用 MultiRNNCell来实现多层 LSTM
    init_state = mlstm_cell.zero_state(batch_size, dtype=tf.float32)             #用全零来初始化state
    
    #3.2、LSTM模型的运行:构建好的网络运行起来
    #T1、调用 dynamic_rnn()法
    # ** 当 time_major==False 时, outputs.shape = [batch_size, timestep_size, hidden_size],所以,可以取 h_state = outputs[:, -1, :] 作为最后输出
    # ** state.shape = [layer_num, 2, batch_size, hidden_size],或者,可以取 h_state = state[-1][1] 作为最后输出,最后输出维度是 [batch_size, hidden_size]
    # outputs, state = tf.nn.dynamic_rnn(mlstm_cell, inputs=X, initial_state=init_state, time_major=False)
    # h_state = outputs[:, -1, :]  # 或者 h_state = state[-1][1]
    
    #T2、自定义LSTM迭代按时间步展开计算:为了更好的理解 LSTM 工作原理把T1的函数自己来实现
    #(1)、可以采用RNNCell的 __call__()函数,来实现LSTM按时间步迭代。
    outputs = list()
    state = init_state
    with tf.variable_scope('RNN'):
        for timestep in range(timestep_size):
            if timestep > 0:
                tf.get_variable_scope().reuse_variables()
            (cell_output, state) = mlstm_cell(X[:, timestep, :], state)   # 这里的state保存了每一层 LSTM 的状态
            outputs.append(cell_output)
    h_state = outputs[-1]
    
    
    #3.3、LSTM模型的训练
    # 定义 softmax 的连接权重矩阵和偏置:上面 LSTM 部分的输出会是一个 [hidden_size] 的tensor,我们要分类的话,还需要接一个 softmax 层
    # out_W = tf.placeholder(tf.float32, [hidden_size, class_num], name='out_Weights')
    # out_bias = tf.placeholder(tf.float32, [class_num], name='out_bias')
    W = tf.Variable(tf.truncated_normal([hidden_size, class_num], stddev=0.1), dtype=tf.float32)
    bias = tf.Variable(tf.constant(0.1,shape=[class_num]), dtype=tf.float32)
    y_pre = tf.nn.softmax(tf.matmul(h_state, W) + bias)
    
    #定义损失和评估函数
    cross_entropy = -tf.reduce_mean(y * tf.log(y_pre))
    train_op = tf.train.AdamOptimizer(lr).minimize(cross_entropy)
    
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(y,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    sess.run(tf.global_variables_initializer())
    for i in range(2000):
        _batch_size = 128
        batch = mnist.train.next_batch(_batch_size)
        if (i+1)%200 == 0:
            train_accuracy = sess.run(accuracy, feed_dict={
                _X:batch[0], y: batch[1], keep_prob: 1.0, batch_size: _batch_size})
            # 已经迭代完成的 epoch 数: mnist.train.epochs_completed
            print("Iter%d, step %d, training accuracy %g" % ( mnist.train.epochs_completed, (i+1), train_accuracy))
        sess.run(train_op, feed_dict={_X: batch[0], y: batch[1], keep_prob: 0.5, batch_size: _batch_size})
    
    # 计算测试数据的准确率
    print("test accuracy %g"% sess.run(accuracy, feed_dict={_X: mnist.test.images, y: mnist.test.labels, 
                                                            keep_prob: 1.0, batch_size:mnist.test.images.shape[0]}))
    
    

     

    参考文章https://www.cnblogs.com/mfryf/p/7903958.html

     

     

     

    展开全文
  • 继上文的集成学习模型之后,本文实践使用的pyspark提供的多层感知机神经网络模型,这是一种比较简单但是却又很重要的神经网络模型。MLP是一种前向结构的人工神经网络,映射一组输入向量到一组输出向量。MLP可以被...

             继上文的集成学习模型之后,本文实践使用的pyspark提供的多层感知机神经网络模型,这是一种比较简单但是却又很重要的神经网络模型。MLP是一种前向结构的人工神经网络,映射一组输入向量到一组输出向量。MLP可以被看做是一个有向图,由多个节点层组成,每一层全连接到下一层。除了输入节点,每个节点都是一个带有非线性激活函数的神经元(或称处理单元)。一种被称为反向传播算法的监督学习方法常被用来训练MLP。MLP是感知器的推广,克服了感知器无法实现对线性不可分数据识别的缺点。多层感知器(Multi-Layer Perceptron,MLP)也叫人工神经网络(Artificial Neural Network,ANN),除了输入输出层,它中间可以有多个隐层。最简单的MLP需要有一层隐层,即输入层、隐层和输出层才能称为一个简单的神经网络。

           一个简单的MLP结果示意图如下所示:
     

           也可以是这样的:

           上面是隐藏层只有一层的MLP神经网络模型,下面是隐藏层为两层的神经网络结果示意图: 

     

          同样,下面贴一下自己学习pyspark以来的记录笔记,具体如下:

        pyspark顾名思义就是由python和spark组合使用的。Spark提供了一个Python_Shell,即pyspark,从而可以以交互的方式使用Python编写Spark程序。有关Spark的基本架构以及pyspark环境配置相关的内容本篇博客就不再多加阐述了,网络上也有很多不错的讲解。

          pyspark里最核心的模块是SparkContext(简称sc),最重要的数据载体是RDD。RDD就像一个NumPy array或者一个Pandas Series,可以视作一个有序的item集合。只不过这些item并不存在driver端的内存里,而是被分割成很多个partitions,每个partition的数据存在集群的executor的内存中。

           接下来回归正题,基于pyspark的MLP分类模型实现如下:

    #!usr/bin/env python
    #encoding:utf-8
    from __future__ import division
     
     
    '''
    __Author__:沂水寒城
    功能: pyspark 机器学习实践之【多层感知器分类器模型】
    '''
     
     
     
    import findspark
    findspark.init()
    import pyspark
    from pyspark import SparkConf
    from pyspark.ml import Pipeline
    from pyspark.context import SparkContext
    from pyspark.sql.session import SparkSession
    from pyspark.ml.classification import DecisionTreeClassifier
    from pyspark.ml.evaluation import MulticlassClassificationEvaluator
    from pyspark.ml.feature import StringIndexer, VectorIndexer,IndexToString
     
     
     
    conf=SparkConf().setAppName('MLDemo')
    sc = SparkContext('local')
    spark = SparkSession(sc)
     
     
    def MLPClassifier(data="mllib/sample_multiclass_classification_data.txt"):
        '''
        多层感知器分类器(MLPC)是基于前馈人工神经网络的分类器。 MLPC由多层节点组成。 每层完全连接到网络中的下一层。 输入层中的节点表示输入数据。 所有其他节点通过输入与节点权重w和偏差b的线性组合将输入映射到输出,并应用激活函数。
        多层感知机分类器
        '''
        #加载LIBSVM格式的数据集
        data = spark.read.format("libsvm").load(data)
        #训练集、测试集划分
        splits = data.randomSplit([0.6, 0.4], 1234)
        train = splits[0]
        test = splits[1]
        #指定神经网络的层
        #输入层4个神经元,隐藏层两层神经元数量分别为:5、4,输出层3个神经元
        layers = [4, 5, 4, 3]
        trainer = MultilayerPerceptronClassifier(maxIter=100, layers=layers, blockSize=128, seed=1234)
        model = trainer.fit(train)
        result = model.transform(test)
        predictionAndLabels = result.select("prediction", "label")
        evaluator = MulticlassClassificationEvaluator(metricName="accuracy")
        print("Test set accuracy = " + str(evaluator.evaluate(predictionAndLabels)))
    
    
     
    if __name__=='__main__':
        MLPClassifier(data="mllib/sample_multiclass_classification_data.txt")

            结果输出如下:
     

          本文MLP神经网络模型输入的是多分类的数据集,可以看到在多分类的情况下MLP达到了90%以上的准确度,整体的性能来说还是很不错的。
     

    展开全文
  • 多层神经网络BP算法 文本垃圾分类

    千次阅读 2017-08-29 13:16:00
    本篇文章主要介绍了如何用多层神经网络BP算法做文本垃圾分类。在多层神经网络BP算法里面,最核心的部分其实就是梯度下降。梯度下降的方法有很多种,这里使用的是感知机(Perceptions);当然还有其它的一些方法,...

    本篇文章主要介绍了如何用多层神经网络BP算法做文本垃圾分类。

    在多层神经网络BP算法里面,最核心的部分其实就是梯度下降。梯度下降的方法有很多种,这里使用的是感知机(Perceptions);当然还有其它的一些方法,例如RBF和Adaline两个梯度下降的方法。

    之后我会写出两个python的脚本,一个是模块脚本,用来被调用的;另外一个是测试脚本,用来训练和测试用的。

    这个部分是nn.py的模块,之后会调用里面的方程。

    
    # -*- coding: utf-8 -*-
    """
    Created on Sat Aug 19 17:14:07 2017
    @author: CHEN Ming
    """
    
    from numpy import tanh,multiply,unique,zeros,sign
    
    def mlp_test(x,W1,W2):
        z = tanh(W1*(x.T))
        y = tanh(W2*z)
        return y,z
    
    
    def errorSample(yd,y):
        err = (yd-y)
        return err
    
    # 梯度下降
    def backprop(W1,W2,err,x,yp,z,eta):
        delta2 = multiply(-err,(1-multiply(yp,yp)))
        delta1 = multiply(  (W2*(delta2.tolist()[0][0])).T,(1-multiply(z,z))   )
        W2 = W2-eta*delta2*(z.T)
        W1 = W1-eta*delta1*x;
        return  W1,W2
    
    
    # 只设置最大循环次数
    def mlp(W1,W2,x,y,eta,maxIter):
        nbIter = 0
        while  nbIter<maxIter:
            nbIter = nbIter+1
            for i in range(0,len(x)):
                ya,za = mlp_test(x[i,:],W1,W2)
                err = errorSample(y[i],ya)
                W1,W2 = backprop(W1,W2,err,x[i,:],ya,za,eta)
                taux = "%.2f%%" % ((i+1)/len(x))
                print('\033[1;35m','第',str(nbIter),'次循环','    完成',taux,'\033[0m!')
            ya,za = mlp_test(x,W1,W2)
        return W1,W2
    
    
    def performance(ypred,y):
        perf=0
        for i in range(len(y)):
            if y[i]==ypred[i]:
                perf=perf + 1/len(y)
            else:
                perf=perf
        return perf
    
    
    # 设置最大循环次数和容错率
    def mlp02(W1,W2,x,y,eta,maxIter,errApp):
        nbIter = 0
        errMAX=1
        error02=0
        while  nbIter<maxIter or  errMAX>errApp:
            nbIter = nbIter+1
            for i in range(0,len(x)):
                ya,za = mlp_test(x[i,:],W1,W2)
                err = errorSample(y[i],ya)
                W1,W2 = backprop(W1,W2,err,x[i,:],ya,za,eta)
                taux = "%.2f%%" % (100*(i+1)/len(x))
                print('\033[1;35m','第',str(nbIter),'次循环','    完成',taux,'\033[0m!')
            ya,za = mlp_test(x,W1,W2)
            error01 = error02
            #error02 = len(sign(ya!=y))/len(y);
            error02 = 1 - performance(sign(ya.tolist()[0]),y)
            errMAX = abs(error02-error01)
        return W1,W2
    
    
    
    
    # 读取词袋和标签数据         
    def readVectors():
        f='C:\\Users\\CHEN Ming\\stage\\prepareData\\vectors.txt'
        fp=open(f);lines=fp.readlines()
        lines_new=[]
        for line in lines:
             lines_new.append(list(  map(int,line.split())  )) 
        return(lines_new)       
    
    def setLabels():
        file_types='C:\\Users\\CHEN Ming\\stage\\prepareData\\types.txt'
        fp=open(file_types,encoding='utf-8')
        lines=fp.readlines()
        types=[]
        for i in range(len(lines)):
            types.append(int(''.join(lines[i])))#int(lines[i])
        return types
    

    现在我给大家介绍第二个脚本t_nn.py

    # -*- coding: utf-8 -*-
    """
    Created on Sat Aug 19 17:14:38 2017
    
    @author: CHEN Ming
    """
    import sys
    sys.path.append('C:\\Users\\CHEN Ming\\stage\\NN\\')
    import nn
    
    
    #加载数据
    from numpy import mat,random,sign,zeros,append
    classLabels=nn.setLabels(); a=mat(classLabels).T; a[a==0]=-1
    classLabels=a.T.tolist()[0]
    dataMatIn=nn.readVectors02()
    #dataMat=mat(dataMatIn)
    dataMat=zeros((len(dataMatIn),len(dataMatIn[0])+1))
    for i in range(len(dataMatIn)):
        dataMat[i,:] = append(dataMatIn[i],1)
    #
    dataMat=mat(dataMat)
    
    
    
    ##training
    J=dataMat.shape[1] -1
    E=dataMat.shape[1]
    S=1
    W1 = random.randn(J,E)
    W2 = random.randn(S,J)
    eta = 0.05
    maxIter = 20
    #train data
    x = dataMat[0:2000,:]
    y = classLabels[0:2000]
    W1,W2 = nn.mlp(W1,W2,x,y,eta,maxIter)
    #test data
    xt = dataMat[2000:2100,:]
    yt = classLabels[2000:2100]
    #
    ypreda,zpreda = nn.mlp_test(x,W1,W2)
    ypred,zpred = nn.mlp_test(xt,W1,W2)
    #
    nn.performance(sign(ypreda.tolist()[0]),y)
    nn.performance(sign(ypred.tolist()[0]),yt)
    #
    print(perf_train)
    print(perf_test)
    
    

    由于神经网络算法的速度很慢,这里我只选择了2000个训练集和100个测试集。
    最终训练和测试的结果如下:

    0.02 
    0.1

    最终训练的错误率未0.02,测试的错误率为0.1。总的来说还是可以的。

    展开全文
  • BPNet算法是一种最有效的多层神经网络学习方法算法实现分类。包括已实现的代码和训练、测试的数据集。
  • nnCostFunction.m function [J grad] = nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X, y, lambda) %NNCOSTFUNCTION Implements the neural network cost...BP算法的流程,结合代码理解!

    nnCostFunction.m

    function [J grad] = nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X, y, lambda)
    %NNCOSTFUNCTION Implements the neural network cost function for a two layer
    %neural network which performs classification
    %   [J grad] = NNCOSTFUNCTON(nn_params, hidden_layer_size, num_labels, ...
    %   X, y, lambda) computes the cost and gradient of the neural network. The
    %   parameters for the neural network are "unrolled" into the vector
    %   nn_params and need to be converted back into the weight matrices. 
    % 
    %   The returned parameter grad should be a "unrolled" vector of the
    %   partial derivatives of the neural network.
    %
    
    % Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices
    % for our 2 layer neural network
    Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), hidden_layer_size, (input_layer_size + 1));
    
    Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end),num_labels, (hidden_layer_size + 1));
    
    % Setup some useful variables
    m = size(X, 1);
             
    % You need to return the following variables correctly 
    J = 0;
    Theta1_grad = zeros(size(Theta1));
    Theta2_grad = zeros(size(Theta2));
    
    %传入的参数y是一个列向量,每个元素就是每个样本对应的数字
    %有两个求和,依然是向量化后进行矩阵运算,最后用两次sum即可
    %在神经网络的CostFunction中要求y和h用0/1矩阵来表示,所以对于每个样本,其结果要从数字改成一个0/1向量
    %最后的J应是一个数
    X=[ones(m,1) X];
    z2=X*Theta1';
    a2=[ones(m,1) sigmoid(z2)];
    z3=a2*Theta2';
    h=sigmoid(z3);%h的元素并非都是0/1而是代表概率的数,不需要把他们改为0/1!!!但是CostFunction公式中的y一定要改成0/1矩阵!!!
    
    %非常骚气的操作,for循环真正作用的地方:
    yk=zeros(m,num_labels);
    for i=1:m
      yk(i,y(i))=1;%得到修改后用于公式中的0/1矩阵
    end;
    J=(1/m)*sum(sum(-1*yk.*log(h)-(1.-yk).*log(1.-h)));
    
    %正则项,注意Theta1和Theta2里的第一列是怎么去除的
    r=(lambda/(2*m))*(sum(sum(Theta1(:,2:end).^2))+sum(sum(Theta2(:,2:end).^2)));
    J=J+r
    
    
    %BackPropagation
    for ex=1:m
      a1=X(ex,:);
      a1=a1';
      z2=Theta1*a1;
      a2=[1;sigmoid(z2)];
      z3=Theta2*a2;
      a3=sigmoid(z3);
      y=yk(ex,:);
      delta3=a3-y';
      delta2=Theta2(:,2:end)'*delta3.*sigmoidGradient(z2);
      Theta1_grad=Theta1_grad+delta2*a1';
      Theta2_grad=Theta2_grad+delta3*a2';
    end;
    
    Theta1_grad=Theta1_grad./m;
    Theta2_grad=Theta2_grad./m;
    %正则化
    Theta1(:,1)=0;
    Theta2(:,1)=0;
    Theta1_grad=Theta1_grad+lambda/m*Theta1;
    Theta2_grad=Theta2_grad+lambda/m*Theta2;
    
    % Unroll gradients
    grad = [Theta1_grad(:) ; Theta2_grad(:)];
    
    
    end

    BP算法的流程,结合代码理解!


    展开全文
  • 1.多层前馈神经网络 ...多层前馈(multilayer feed-forward)神经网络由一个输入层、一个或多个隐藏层和一个输出层组成,后向传播(BP)算法多层前馈神经网络上面进行学习,采用BP算法的(多层)前馈神经网...
  • 多层感知器是一种多层前馈神经网络 ,常用的快速训练算法有共轭梯度法、拟牛顿...过模式分类实验对这两种算法和 BP算法进行比较 ,并由试验数据得出这几种算法的复杂性、可靠 性 ,以及由算法产生的多层感知器的泛化能力。
  • 主要讲Spark ML中关于分类算法的实现。示例的算法Demo包含:LR、DT、RF、GBTs、多层感知器、线性支持向量机、One-vs-Rest分类器以及NB等。 文章目录1. Logistic regression1.1 二分类LR1.2 多分类LR2. 决策树分类器3...
  • 单层感知器只能解决线性可分的分类问题,要增强,唯一的方法就是采用多层网络,在输入输出层之间加上隐含层,构成多层感知器。 多层感知器同单层感知器的四个特点: 除了输入输出层,多层感知器还有一层或者多层隐...
  • 多层数据结构估计所有的web开发者估计都不会陌生,各种软件的分类都是基于多层结构来设计的。下面是一个典型的多层数据结构示意图:相关创建数据语句:CREATE TABLE category(category_id INT AUTO_INCREMENT ...
  • 然后是对各种各样的特征抽取进行研究,包括词项频率-逆文档频率和word2vec,降维方法有主成分分析法和潜在索引分析,最后是对分类算法进行研究,包括朴素贝叶斯的多变量贝努利模型和多项式模型,支持向量机和深度...
  • 其次,通过预处理静态障碍物,实现对障碍物的分类以及分别处理,可大幅降低代价地图更新过程中的计算量,变相地提高代价地图的计算速度;再次,通过等距膨胀法构建完整的多层代价地图;最后,在实验室的自主机器人平台上进行...
  • 机器学习实战-分类算法之决策树和多层神经网络 鉴于目前Python最流行的机器学习库Scikit(http://scikit-learn.org/)集成了很多成型的算法,本博客就使用其中的决策树和神经网络算法对Kdd99数据集进行分类处理,...
  • 实现一个简单的神经网络,做一个简单的二分类算法。感知机(perceptron)是一种二分类的线性分类模型,最最简单的感知机只能做到线性的二分类,当然经过研究现在多层感知机(维基解释)已经可以做到非线性分类了。...
  • 本节主要讲Spark ML中关于分类算法的实现。示例的算法Demo包含:LR、DT、RF、GBTs、多层感知器、线性支持向量机、One-vs-Rest分类器以及NB等。 文章目录1. Logistic regression1.1 二分类LR1.2 多分类LR2. 决策树...
  • 多层数据结构估计所有的web开发者估计都不会陌生,各种软件的分类都是基于多层结构来设计的。下面是一个典型的多层数据结构示意图:相关创建数据语句:CREATETABLEcategory(category_idINTAUTO_INCREMENTPRIMARYKEY,...
  • 简介 多层感知器,是指包含1个或多个隐层的前馈神经网络。 前馈神经网络的特点: 第0层为输入层,最后一层为输出层,中间层为隐层。 整个网络无反馈,信号从输入层向输出...具有解决复杂模式分类的能力,解决简单...
  • 预排序遍历树算法(非递归无限极分类算法)学习笔记 本文是我学习MySQL官方教程Managing Hierarchical Data in MySQL的笔记 多层数据结构估计所有的web开发者估计都不会陌生,各种软件的分类都是基于多层结构来...
  • 第3章 多层前向网络及BP学习算法 3.1多层感知器 3.2 BP学习算法 3.3 径向基网络 3.4 仿真实例 3.1多层感知器 单层感知器只能解决线性可分的分类问题要增强网络的分类能力唯一的方法是采用多层网络即在输入与输出层...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 477
精华内容 190
关键字:

多层分类算法