精华内容
下载资源
问答
  • DBN Python预测交通流

    2017-11-01 10:30:24
    python 实现的基于DBN的交通流预测系统,为方便验证已给出实验,绝对可用
  • python DBN代码

    2016-09-02 17:49:49
    python版的DBN代码
  • DBN RBN tensorflow python3 源码 mnist DBN RBN tensorflow python3 源码 mnist
  • dbn:一个基于rbm-stack的深度置信网络训练工具,python实现。
  • python-dbn绝对能调通

    热门讨论 2016-12-13 15:45:16
    很多网上的DBN都调不通,我这个一定能调通
  • 很多网上的DBN都调不通,我这个一定能调通很多网上的DBN都调不通,
  • 基于python3 tensorflow DBN_and_RNN的实现,包含源码、数据集、解释文档
  • 亲测好用,挺不错的资源,大家快来下载吧!挺有用的!需要的话可以来下载哦!很多网上的DBN都调不通,我这个一定能调通
  • DBN超参数众多,包括隐含层层数、各层节点数、无监督预...之前写过MATLAB版本的DBN超参数优化,今天这个是python/torch版本的DBN超参数优化。具体运行环境python36、torch1.2。 话不多说,直接上结果。数据结构是...

            DBN超参数众多,包括隐含层层数、各层节点数、无监督预训练阶段的训练次数及其学习率、微调阶段的训练次数及其学习率、与Batchsize,如果采用SGD相关优化器,还有动量项这个超参数。总之就是特别多,手动选择的话很难选到最佳超参数组合,为此采用遗传算法对上述超参数进行优化。

            之前写过MATLAB版本的DBN超参数优化,今天这个是python/torch版本的DBN超参数优化。具体运行环境python36、torch1.2。

            话不多说,直接上结果。数据结构是多输入单输出,按照7:3随机划分训练集与测试集。

            1、DBN预测,代码如下

    # -*- coding: utf-8 -*-
    # DBN建模
    import time
    import numpy as np
    import pandas as pd 
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 步骤一(替换sans-serif字体)
    plt.rcParams['axes.unicode_minus'] = False   # 步骤二(解决坐标轴负数的负号显示问题)
    from sklearn.preprocessing import StandardScaler,MinMaxScaler
    from sklearn.model_selection import train_test_split
    from scipy.io import savemat,loadmat
    from sklearn.metrics import r2_score
    import warnings
    warnings.filterwarnings("ignore")
    import torch
    from utils.DBN import DBN
    device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
    seed=0
    if device == 'cuda':
        torch.cuda.manual_seed(seed) # 为当前GPU设置随机种子
        torch.cuda.manual_seed_all(seed)  # if you are using multi-GPU,为所有GPU设置随机种子
    else:
        torch.manual_seed(seed) # 为CPU设置随机种子
    # In[] 加载数据
    data=pd.read_csv('data1.csv',header=None)
    input_data=data.iloc[:,:-1].values
    output_data=data.iloc[:,-1].values.reshape(-1,1)
    # 归一化
    #ss_X = StandardScaler().fit(input_data)
    #ss_y = StandardScaler().fit(output_data)
    ss_X=MinMaxScaler(feature_range=(0,1)).fit(input_data)
    ss_y=MinMaxScaler(feature_range=(0,1)).fit(output_data)
    input_data = ss_X.transform(input_data)
    output_data = ss_y.transform(output_data)
    # 划分样本
    x_train,x_valid, y_train, y_valid = train_test_split(input_data,output_data,test_size=0.3,random_state=0)
    # In[] 模型构建与训练
    start_time=time.time()
    #超参数设置
    input_length = x_train.shape[1]
    output_length = y_train.shape[1]
    # network
    # rbm的学习率和迭代次数,无监督逐层预训练
    learning_rate=0.1
    epoch_pretrain = 10
    # 隐含层
    hidden_units = [20,15]
    # batchsize
    batch_size = 64
    # 微调阶段dbn采用SGD优化器,学习率,迭代次数,动量,激活函数(4选1),损失函数为均方差
    learning_rate_finetune=0.1
    epoch_finetune = 100
    momentum=0.9
    tf='Sigmoid'# Sigmoid ReLU Tanh Softplus
    loss_function = torch.nn.MSELoss(reduction='mean')  # 均方差损失
    optimizer = torch.optim.SGD
    # Build model
    dbn = DBN(hidden_units, input_length, output_length,learning_rate=learning_rate,activate=tf, device=device)
    # 无监督预训练dbn中各rbm
    dbn.pretrain(x_train, epoch=epoch_pretrain, batch_size=batch_size)
    # 有监督微调
    dbn.finetune(x_train, y_train, epoch_finetune, batch_size, loss_function,
                 optimizer(dbn.parameters(), lr=learning_rate_finetune, momentum=momentum),
                 validation=[x_valid,y_valid],shuffle=True,types=1)
    plt.figure()
    plt.plot(dbn.finetune_train_loss,label='train_loss')
    plt.plot(dbn.finetune_valid_loss,label='valid_loss')
    plt.legend()
    plt.title('Loss Curve')
    plt.show()
    # In[] Make prediction and plot
    y_predict = dbn.predict(x_valid, batch_size,types=1)
    y_predict=y_predict.cpu().numpy()
    end_time=time.time()
    print('Time cost: %f s'%(end_time-start_time))
    # 对测试结果进行反归一化
    test_pred = ss_y.inverse_transform(y_predict)
    test_label = ss_y.inverse_transform(y_valid)
    # In[] 
    # 画出测试集的值
    plt.figure()
    plt.plot(test_label,c='r', label='true')
    plt.plot(test_pred,c='b',label='pred')
    plt.legend()
    plt.show()
    # In[]计算各种指标
    # mape
    test_mape=np.mean(np.abs((test_pred-test_label)/test_label))
    # rmse
    test_rmse=np.sqrt(np.mean(np.square(test_pred-test_label)))
    # mae
    test_mae=np.mean(np.abs(test_pred-test_label))
    # R2
    test_r2=r2_score(test_label,test_pred)
    print('测试集的mape:',test_mape,' rmse:',test_rmse,' mae:',test_mae,' R2:',test_r2)
    

    结果如下:

    图 1 DBN损失曲线
    图2 DBN预测结果

            指标如下:

            mape: 0.02131540499483512  

            rmse: 0.06900334093296646  

            mae: 0.04012139316438816  

            R2: 0.9663487401772392

    2、遗传优化DBN超参数

    本文利用GA对DBN的超参数进行寻优,以最小化DBN预测值与实际值的MSE为适应度函数,目的就是通过GA找到一组超参数,用这组超参数训练的DBN,具有最小的网络误差。寻优参数及其范围设置如下:

    lb=[0.01,0.01,0.1,1 ,1,  1,  1,10]
    ub=[0.1,  0.5,  1,21,201,257,4,101]
    #预训练学习率的范围是0.01到0.1
    #微调训练学习率的范围是0.01到0.5
    #动量0.1到1
    #rbm迭代次数是1到20,
    #dbn微调的迭代次数是1到200
    #batchsize是1到256
    #隐含层数量是1到3
    #隐含层节点数是10-100

    操作要点:

    1)前3个超参数是浮点型、后面的都是整型

    2)遗传算法每条DNA的长度是10,就是前7个参数是两个学习率、动量项、两个训练迭代次数、batchsize与层数,因为我们程序设置的最大隐含层是3(ub中是4,是因为random.int这个函数是左闭右开),所以一共10维,即使某DNA中层数是2,也是10维,只不过最后1层为0,例如:

    [0.1,0.5,0.9,10,25,64,1,10,0,0],则代表两个学习率分别为0.1 0.5;动量为0.9; 两个迭代次数分别是10,25,batchsize是64,隐含层层数是1,神经元为[10]

    [0.1,0.5,0.9,10,25,64,2,10,15,0],则代表两个学习率分别为0.1 0.5;动量为0.9; 两个迭代次数分别是10,25,batchsize是64,隐含层层数是2,各层神经元分别为[10,15]

    [0.1,0.5,0.9,10,25,64,5,10,15,20],则代表两个学习率分别为0.1 0.5;动量为0.9; 两个迭代次数分别是10,25,batchsize是64,隐含层层数是3,各层神经元分别为[10,15,30]

    当然哈,ub中这个参数是可调的,随便设都行,只要大于1。

    3)交叉操作的时候,隐含层层数这个参数不交叉,因为两个DNA如果层数不一致,交叉了的话,后面的节点数就不对了。如果要交叉这个参数的话,就把后面各层的节点数一起进行交叉。

    4)变异的时候,隐含层层数发生改变之后,先把该条DNA的各层节点数全部置0 ,然后重新根据层数进行赋值。

    寻优结果适应度曲线如图所示。

    图3 适应度曲线

     对应GA每代优化后的最优超参数组合如下表所示。可见最优DBN的隐含层层数为3层,各层的节点数是92、35、54。

     取最后一代优化得到的最优超参数组合(就是第9行那个)用来训练DBN,得到的结果如下:

    3、结果对比

    展开全文
  • 在这个项目中,我实现了一个深度学习工具箱(DeepNet),其中包括带有Python的RBM,DBN,多模式DBN,其中大多数矩阵运算是通过使用Cudamat加快计算过程在GPU上进行的。 有一些示例说明如何使用此软件包。 该项目对中...
  • 使用DBN识别手写体 传统的多层感知机或者神经网络的一个问题: 反向传播可能总是导致局部最小值。 当误差表面(error surface)包含了多个凹槽,当你做梯度下降时,你找到的并不是最深的凹槽。 下面你将会看到DBN是...

    任何程序错误,以及技术疑问或需要解答的,请扫码添加作者VX:1755337994

    使用DBN识别手写体
    传统的多层感知机或者神经网络的一个问题: 反向传播可能总是导致局部最小值。
    当误差表面(error surface)包含了多个凹槽,当你做梯度下降时,你找到的并不是最深的凹槽。 下面你将会看到DBN是怎么解决这个问题的。

    深度置信网络

    深度置信网络可以通过额外的预训练规程解决局部最小值的问题。 预训练在反向传播之前做完,这样可以使错误率离最优的解不是那么远,也就是我们在最优解的附近。再通过反向传播慢慢地降低错误率。
    深度置信网络主要分成两部分。第一部分是多层玻尔兹曼感知机,用于预训练我们的网络。第二部分是前馈反向传播网络,这可以使RBM堆叠的网络更加精细化。

    1. 加载必要的深度置信网络库

    # urllib is used to download the utils file from deeplearning.net
    import urllib.request
    response = urllib.request.urlopen('http://deeplearning.net/tutorial/code/utils.py')
    content = response.read().decode('utf-8')
    target = open('utils.py', 'w')
    target.write(content)
    target.close()
    # Import the math function for calculations
    import math
    # Tensorflow library. Used to implement machine learning models
    import tensorflow as tf
    # Numpy contains helpful functions for efficient mathematical calculations
    import numpy as np
    # Image library for image manipulation
    from PIL import Image
    # import Image
    # Utils file
    from utils import tile_raster_images
    

    2. 构建RBM层

    RBM的细节参考【https://blog.csdn.net/sinat_28371057/article/details/115795086
    rbm
    为了在Tensorflow中应用DBN, 下面创建一个RBM的类

    class RBM(object):
        def __init__(self, input_size, output_size):
            # Defining the hyperparameters
            self._input_size = input_size  # Size of input
            self._output_size = output_size  # Size of output
            self.epochs = 5  # Amount of training iterations
            self.learning_rate = 1.0  # The step used in gradient descent
            self.batchsize = 100  # The size of how much data will be used for training per sub iteration
    
            # Initializing weights and biases as matrices full of zeroes
            self.w = np.zeros([input_size, output_size], np.float32)  # Creates and initializes the weights with 0
            self.hb = np.zeros([output_size], np.float32)  # Creates and initializes the hidden biases with 0
            self.vb = np.zeros([input_size], np.float32)  # Creates and initializes the visible biases with 0
    
        # Fits the result from the weighted visible layer plus the bias into a sigmoid curve
        def prob_h_given_v(self, visible, w, hb):
            # Sigmoid
            return tf.nn.sigmoid(tf.matmul(visible, w) + hb)
    
        # Fits the result from the weighted hidden layer plus the bias into a sigmoid curve
        def prob_v_given_h(self, hidden, w, vb):
            return tf.nn.sigmoid(tf.matmul(hidden, tf.transpose(w)) + vb)
    
        # Generate the sample probability
        def sample_prob(self, probs):
            return tf.nn.relu(tf.sign(probs - tf.random_uniform(tf.shape(probs))))
    
        # Training method for the model
        def train(self, X):
            # Create the placeholders for our parameters
            _w = tf.placeholder("float", [self._input_size, self._output_size])
            _hb = tf.placeholder("float", [self._output_size])
            _vb = tf.placeholder("float", [self._input_size])
    
            prv_w = np.zeros([self._input_size, self._output_size],
                             np.float32)  # Creates and initializes the weights with 0
            prv_hb = np.zeros([self._output_size], np.float32)  # Creates and initializes the hidden biases with 0
            prv_vb = np.zeros([self._input_size], np.float32)  # Creates and initializes the visible biases with 0
    
            cur_w = np.zeros([self._input_size, self._output_size], np.float32)
            cur_hb = np.zeros([self._output_size], np.float32)
            cur_vb = np.zeros([self._input_size], np.float32)
            v0 = tf.placeholder("float", [None, self._input_size])
    
            # Initialize with sample probabilities
            h0 = self.sample_prob(self.prob_h_given_v(v0, _w, _hb))
            v1 = self.sample_prob(self.prob_v_given_h(h0, _w, _vb))
            h1 = self.prob_h_given_v(v1, _w, _hb)
    
            # Create the Gradients
            positive_grad = tf.matmul(tf.transpose(v0), h0)
            negative_grad = tf.matmul(tf.transpose(v1), h1)
    
            # Update learning rates for the layers
            update_w = _w + self.learning_rate * (positive_grad - negative_grad) / tf.to_float(tf.shape(v0)[0])
            update_vb = _vb + self.learning_rate * tf.reduce_mean(v0 - v1, 0)
            update_hb = _hb + self.learning_rate * tf.reduce_mean(h0 - h1, 0)
    
            # Find the error rate
            err = tf.reduce_mean(tf.square(v0 - v1))
    
            # Training loop
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                # For each epoch
                for epoch in range(self.epochs):
                    # For each step/batch
                    for start, end in zip(range(0, len(X), self.batchsize), range(self.batchsize, len(X), self.batchsize)):
                        batch = X[start:end]
                        # Update the rates
                        cur_w = sess.run(update_w, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        cur_hb = sess.run(update_hb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        cur_vb = sess.run(update_vb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        prv_w = cur_w
                        prv_hb = cur_hb
                        prv_vb = cur_vb
                    error = sess.run(err, feed_dict={v0: X, _w: cur_w, _vb: cur_vb, _hb: cur_hb})
                    print('Epoch: %d' % epoch, 'reconstruction error: %f' % error)
                self.w = prv_w
                self.hb = prv_hb
                self.vb = prv_vb
    
        # Create expected output for our DBN
        def rbm_outpt(self, X):
            input_X = tf.constant(X)
            _w = tf.constant(self.w)
            _hb = tf.constant(self.hb)
            out = tf.nn.sigmoid(tf.matmul(input_X, _w) + _hb)
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                return sess.run(out)
    

    3. 导入MNIST数据

    使用one-hot encoding标注的形式载入MNIST图像数据。

    # Getting the MNIST data provided by Tensorflow
    from tensorflow.examples.tutorials.mnist import input_data
    
    # Loading in the mnist data
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images,\
        mnist.test.labels
    
    
    Extracting MNIST_data/train-images-idx3-ubyte.gz
    Extracting MNIST_data/train-labels-idx1-ubyte.gz
    Extracting MNIST_data/t10k-images-idx3-ubyte.gz
    Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
    

    4. 建立DBN

    RBM_hidden_sizes = [500, 200 , 50 ] #create 4 layers of RBM with size 785-500-200-50
    
    #Since we are training, set input as training data
    inpX = trX
    
    #Create list to hold our RBMs
    rbm_list = []
    
    #Size of inputs is the number of inputs in the training set
    input_size = inpX.shape[1]
    
    #For each RBM we want to generate
    for i, size in enumerate(RBM_hidden_sizes):
        print('RBM: ',i,' ',input_size,'->', size)
        rbm_list.append(RBM(input_size, size))
        input_size = size
    
    Extracting MNIST_data/train-images-idx3-ubyte.gz
    Extracting MNIST_data/train-labels-idx1-ubyte.gz
    Extracting MNIST_data/t10k-images-idx3-ubyte.gz
    Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
    RBM:  0   784 -> 500
    RBM:  1   500 -> 200
    RBM:  2   200 -> 50

    rbm的类创建好了和数据都已经载入,可以创建DBN。 在这个例子中,我们使用了3个RBM,一个的隐藏层单元个数为500, 第二个RBM的隐藏层个数为200,最后一个为50. 我们想要生成训练数据的深层次表示形式。

    5.训练RBM

    我们将使用***rbm.train()***开始预训练步骤, 单独训练堆中的每一个RBM,并将当前RBM的输出作为下一个RBM的输入。

    #For each RBM in our list
    for rbm in rbm_list:
        print('New RBM:')
        #Train a new one
        rbm.train(inpX) 
        #Return the output layer
        inpX = rbm.rbm_outpt(inpX)
    
    New RBM:
    Epoch: 0 reconstruction error: 0.061174
    Epoch: 1 reconstruction error: 0.052962
    Epoch: 2 reconstruction error: 0.049679
    Epoch: 3 reconstruction error: 0.047683
    Epoch: 4 reconstruction error: 0.045691
    New RBM:
    Epoch: 0 reconstruction error: 0.035260
    Epoch: 1 reconstruction error: 0.030811
    Epoch: 2 reconstruction error: 0.028873
    Epoch: 3 reconstruction error: 0.027428
    Epoch: 4 reconstruction error: 0.026980
    New RBM:
    Epoch: 0 reconstruction error: 0.059593
    Epoch: 1 reconstruction error: 0.056837
    Epoch: 2 reconstruction error: 0.055571
    Epoch: 3 reconstruction error: 0.053817
    Epoch: 4 reconstruction error: 0.054142

    现在我们可以将输入数据的学习好的表示转换为有监督的预测,比如一个线性分类器。特别地,我们使用这个浅层神经网络的最后一层的输出对数字分类。

    6. 神经网络

    下面的类使用了上面预训练好的RBMs实现神经网络。

    import numpy as np
    import math
    import tensorflow as tf
    
    
    class NN(object):
    
        def __init__(self, sizes, X, Y):
            # Initialize hyperparameters
            self._sizes = sizes
            self._X = X
            self._Y = Y
            self.w_list = []
            self.b_list = []
            self._learning_rate = 1.0
            self._momentum = 0.0
            self._epoches = 10
            self._batchsize = 100
            input_size = X.shape[1]
    
            # initialization loop
            for size in self._sizes + [Y.shape[1]]:
                # Define upper limit for the uniform distribution range
                max_range = 4 * math.sqrt(6. / (input_size + size))
    
                # Initialize weights through a random uniform distribution
                self.w_list.append(
                    np.random.uniform(-max_range, max_range, [input_size, size]).astype(np.float32))
    
                # Initialize bias as zeroes
                self.b_list.append(np.zeros([size], np.float32))
                input_size = size
    
        # load data from rbm
        def load_from_rbms(self, dbn_sizes, rbm_list):
            # Check if expected sizes are correct
            assert len(dbn_sizes) == len(self._sizes)
    
            for i in range(len(self._sizes)):
                # Check if for each RBN the expected sizes are correct
                assert dbn_sizes[i] == self._sizes[i]
    
            # If everything is correct, bring over the weights and biases
            for i in range(len(self._sizes)):
                self.w_list[i] = rbm_list[i].w
                self.b_list[i] = rbm_list[i].hb
    
        # Training method
        def train(self):
            # Create placeholders for input, weights, biases, output
            _a = [None] * (len(self._sizes) + 2)
            _w = [None] * (len(self._sizes) + 1)
            _b = [None] * (len(self._sizes) + 1)
            _a[0] = tf.placeholder("float", [None, self._X.shape[1]])
            y = tf.placeholder("float", [None, self._Y.shape[1]])
    
            # Define variables and activation functoin
            for i in range(len(self._sizes) + 1):
                _w[i] = tf.Variable(self.w_list[i])
                _b[i] = tf.Variable(self.b_list[i])
            for i in range(1, len(self._sizes) + 2):
                _a[i] = tf.nn.sigmoid(tf.matmul(_a[i - 1], _w[i - 1]) + _b[i - 1])
    
            # Define the cost function
            cost = tf.reduce_mean(tf.square(_a[-1] - y))
    
            # Define the training operation (Momentum Optimizer minimizing the Cost function)
            train_op = tf.train.MomentumOptimizer(
                self._learning_rate, self._momentum).minimize(cost)
    
            # Prediction operation
            predict_op = tf.argmax(_a[-1], 1)
    
            # Training Loop
            with tf.Session() as sess:
                # Initialize Variables
                sess.run(tf.global_variables_initializer())
    
                # For each epoch
                for i in range(self._epoches):
    
                    # For each step
                    for start, end in zip(
                            range(0, len(self._X), self._batchsize), range(self._batchsize, len(self._X), self._batchsize)):
                        # Run the training operation on the input data
                        sess.run(train_op, feed_dict={
                            _a[0]: self._X[start:end], y: self._Y[start:end]})
    
                    for j in range(len(self._sizes) + 1):
                        # Retrieve weights and biases
                        self.w_list[j] = sess.run(_w[j])
                        self.b_list[j] = sess.run(_b[j])
    
                    print("Accuracy rating for epoch " + str(i) + ": " + str(np.mean(np.argmax(self._Y, axis=1) == \
                                                                                     sess.run(predict_op, feed_dict={_a[0]: self._X, y: self._Y}))))
    
    

    7. 运行

    nNet = NN(RBM_hidden_sizes, trX, trY)
    nNet.load_from_rbms(RBM_hidden_sizes,rbm_list)
    nNet.train()
    
    Accuracy rating for epoch 0: 0.46683636363636366
    Accuracy rating for epoch 1: 0.6561272727272728
    Accuracy rating for epoch 2: 0.7678363636363637
    Accuracy rating for epoch 3: 0.8370727272727273
    Accuracy rating for epoch 4: 0.8684181818181819
    Accuracy rating for epoch 5: 0.885
    Accuracy rating for epoch 6: 0.8947636363636363
    Accuracy rating for epoch 7: 0.9024909090909091
    Accuracy rating for epoch 8: 0.9080363636363636
    Accuracy rating for epoch 9: 0.9124181818181818

    完整代码

    pip install  tensorflow==1.13.1

    # Import the math function for calculations
    import math
    # Tensorflow library. Used to implement machine learning models
    import tensorflow as tf
    # Numpy contains helpful functions for efficient mathematical calculations
    import numpy as np
    # Image library for image manipulation
    # import Image
    # Utils file
    # Getting the MNIST data provided by Tensorflow
    from tensorflow.examples.tutorials.mnist import input_data
    
    """ This file contains different utility functions that are not connected
    in anyway to the networks presented in the tutorials, but rather help in
    processing the outputs into a more understandable way.
    
    For example ``tile_raster_images`` helps in generating a easy to grasp
    image from a set of samples or weights.
    """
    
    import numpy
    
    
    def scale_to_unit_interval(ndar, eps=1e-8):
        """ Scales all values in the ndarray ndar to be between 0 and 1 """
        ndar = ndar.copy()
        ndar -= ndar.min()
        ndar *= 1.0 / (ndar.max() + eps)
        return ndar
    
    
    def tile_raster_images(X, img_shape, tile_shape, tile_spacing=(0, 0),
                           scale_rows_to_unit_interval=True,
                           output_pixel_vals=True):
        """
        Transform an array with one flattened image per row, into an array in
        which images are reshaped and layed out like tiles on a floor.
    
        This function is useful for visualizing datasets whose rows are images,
        and also columns of matrices for transforming those rows
        (such as the first layer of a neural net).
    
        :type X: a 2-D ndarray or a tuple of 4 channels, elements of which can
        be 2-D ndarrays or None;
        :param X: a 2-D array in which every row is a flattened image.
    
        :type img_shape: tuple; (height, width)
        :param img_shape: the original shape of each image
    
        :type tile_shape: tuple; (rows, cols)
        :param tile_shape: the number of images to tile (rows, cols)
    
        :param output_pixel_vals: if output should be pixel values (i.e. int8
        values) or floats
    
        :param scale_rows_to_unit_interval: if the values need to be scaled before
        being plotted to [0,1] or not
    
    
        :returns: array suitable for viewing as an image.
        (See:`Image.fromarray`.)
        :rtype: a 2-d array with same dtype as X.
    
        """
    
        assert len(img_shape) == 2
        assert len(tile_shape) == 2
        assert len(tile_spacing) == 2
    
        # The expression below can be re-written in a more C style as
        # follows :
        #
        # out_shape    = [0,0]
        # out_shape[0] = (img_shape[0]+tile_spacing[0])*tile_shape[0] -
        #                tile_spacing[0]
        # out_shape[1] = (img_shape[1]+tile_spacing[1])*tile_shape[1] -
        #                tile_spacing[1]
        out_shape = [
            (ishp + tsp) * tshp - tsp
            for ishp, tshp, tsp in zip(img_shape, tile_shape, tile_spacing)
        ]
    
        if isinstance(X, tuple):
            assert len(X) == 4
            # Create an output numpy ndarray to store the image
            if output_pixel_vals:
                out_array = numpy.zeros((out_shape[0], out_shape[1], 4),
                                        dtype='uint8')
            else:
                out_array = numpy.zeros((out_shape[0], out_shape[1], 4),
                                        dtype=X.dtype)
    
            #colors default to 0, alpha defaults to 1 (opaque)
            if output_pixel_vals:
                channel_defaults = [0, 0, 0, 255]
            else:
                channel_defaults = [0., 0., 0., 1.]
    
            for i in range(4):
                if X[i] is None:
                    # if channel is None, fill it with zeros of the correct
                    # dtype
                    dt = out_array.dtype
                    if output_pixel_vals:
                        dt = 'uint8'
                    out_array[:, :, i] = numpy.zeros(
                        out_shape,
                        dtype=dt
                    ) + channel_defaults[i]
                else:
                    # use a recurrent call to compute the channel and store it
                    # in the output
                    out_array[:, :, i] = tile_raster_images(
                        X[i], img_shape, tile_shape, tile_spacing,
                        scale_rows_to_unit_interval, output_pixel_vals)
            return out_array
    
        else:
            # if we are dealing with only one channel
            H, W = img_shape
            Hs, Ws = tile_spacing
    
            # generate a matrix to store the output
            dt = X.dtype
            if output_pixel_vals:
                dt = 'uint8'
            out_array = numpy.zeros(out_shape, dtype=dt)
    
            for tile_row in range(tile_shape[0]):
                for tile_col in range(tile_shape[1]):
                    if tile_row * tile_shape[1] + tile_col < X.shape[0]:
                        this_x = X[tile_row * tile_shape[1] + tile_col]
                        if scale_rows_to_unit_interval:
                            # if we should scale values to be between 0 and 1
                            # do this by calling the `scale_to_unit_interval`
                            # function
                            this_img = scale_to_unit_interval(
                                this_x.reshape(img_shape))
                        else:
                            this_img = this_x.reshape(img_shape)
                        # add the slice to the corresponding position in the
                        # output array
                        c = 1
                        if output_pixel_vals:
                            c = 255
                        out_array[
                            tile_row * (H + Hs): tile_row * (H + Hs) + H,
                            tile_col * (W + Ws): tile_col * (W + Ws) + W
                        ] = this_img * c
            return out_array
    
    # Class that defines the behavior of the RBM
    class RBM(object):
        def __init__(self, input_size, output_size):
            # Defining the hyperparameters
            self._input_size = input_size  # Size of input
            self._output_size = output_size  # Size of output
            self.epochs = 5  # Amount of training iterations
            self.learning_rate = 1.0  # The step used in gradient descent
            self.batchsize = 100  # The size of how much data will be used for training per sub iteration
    
            # Initializing weights and biases as matrices full of zeroes
            self.w = np.zeros([input_size, output_size], np.float32)  # Creates and initializes the weights with 0
            self.hb = np.zeros([output_size], np.float32)  # Creates and initializes the hidden biases with 0
            self.vb = np.zeros([input_size], np.float32)  # Creates and initializes the visible biases with 0
    
        # Fits the result from the weighted visible layer plus the bias into a sigmoid curve
        def prob_h_given_v(self, visible, w, hb):
            # Sigmoid
            return tf.nn.sigmoid(tf.matmul(visible, w) + hb)
    
        # Fits the result from the weighted hidden layer plus the bias into a sigmoid curve
        def prob_v_given_h(self, hidden, w, vb):
            return tf.nn.sigmoid(tf.matmul(hidden, tf.transpose(w)) + vb)
    
        # Generate the sample probability
        def sample_prob(self, probs):
            return tf.nn.relu(tf.sign(probs - tf.random_uniform(tf.shape(probs))))
    
        # Training method for the model
        def train(self, X):
            # Create the placeholders for our parameters
            _w = tf.placeholder("float", [self._input_size, self._output_size])
            _hb = tf.placeholder("float", [self._output_size])
            _vb = tf.placeholder("float", [self._input_size])
    
            prv_w = np.zeros([self._input_size, self._output_size],
                             np.float32)  # Creates and initializes the weights with 0
            prv_hb = np.zeros([self._output_size], np.float32)  # Creates and initializes the hidden biases with 0
            prv_vb = np.zeros([self._input_size], np.float32)  # Creates and initializes the visible biases with 0
    
            cur_w = np.zeros([self._input_size, self._output_size], np.float32)
            cur_hb = np.zeros([self._output_size], np.float32)
            cur_vb = np.zeros([self._input_size], np.float32)
            v0 = tf.placeholder("float", [None, self._input_size])
    
            # Initialize with sample probabilities
            h0 = self.sample_prob(self.prob_h_given_v(v0, _w, _hb))
            v1 = self.sample_prob(self.prob_v_given_h(h0, _w, _vb))
            h1 = self.prob_h_given_v(v1, _w, _hb)
    
            # Create the Gradients
            positive_grad = tf.matmul(tf.transpose(v0), h0)
            negative_grad = tf.matmul(tf.transpose(v1), h1)
    
            # Update learning rates for the layers
            update_w = _w + self.learning_rate * (positive_grad - negative_grad) / tf.to_float(tf.shape(v0)[0])
            update_vb = _vb + self.learning_rate * tf.reduce_mean(v0 - v1, 0)
            update_hb = _hb + self.learning_rate * tf.reduce_mean(h0 - h1, 0)
    
            # Find the error rate
            err = tf.reduce_mean(tf.square(v0 - v1))
    
            # Training loop
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                # For each epoch
                for epoch in range(self.epochs):
                    # For each step/batch
                    for start, end in zip(range(0, len(X), self.batchsize), range(self.batchsize, len(X), self.batchsize)):
                        batch = X[start:end]
                        # Update the rates
                        cur_w = sess.run(update_w, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        cur_hb = sess.run(update_hb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        cur_vb = sess.run(update_vb, feed_dict={v0: batch, _w: prv_w, _hb: prv_hb, _vb: prv_vb})
                        prv_w = cur_w
                        prv_hb = cur_hb
                        prv_vb = cur_vb
                    error = sess.run(err, feed_dict={v0: X, _w: cur_w, _vb: cur_vb, _hb: cur_hb})
                    print('Epoch: %d' % epoch, 'reconstruction error: %f' % error)
                self.w = prv_w
                self.hb = prv_hb
                self.vb = prv_vb
    
        # Create expected output for our DBN
        def rbm_outpt(self, X):
            input_X = tf.constant(X)
            _w = tf.constant(self.w)
            _hb = tf.constant(self.hb)
            out = tf.nn.sigmoid(tf.matmul(input_X, _w) + _hb)
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                return sess.run(out)
    
    class NN(object):
    
        def __init__(self, sizes, X, Y):
            # Initialize hyperparameters
            self._sizes = sizes
            self._X = X
            self._Y = Y
            self.w_list = []
            self.b_list = []
            self._learning_rate = 1.0
            self._momentum = 0.0
            self._epoches = 10
            self._batchsize = 100
            input_size = X.shape[1]
    
            # initialization loop
            for size in self._sizes + [Y.shape[1]]:
                # Define upper limit for the uniform distribution range
                max_range = 4 * math.sqrt(6. / (input_size + size))
    
                # Initialize weights through a random uniform distribution
                self.w_list.append(
                    np.random.uniform(-max_range, max_range, [input_size, size]).astype(np.float32))
    
                # Initialize bias as zeroes
                self.b_list.append(np.zeros([size], np.float32))
                input_size = size
    
        # load data from rbm
        def load_from_rbms(self, dbn_sizes, rbm_list):
            # Check if expected sizes are correct
            assert len(dbn_sizes) == len(self._sizes)
    
            for i in range(len(self._sizes)):
                # Check if for each RBN the expected sizes are correct
                assert dbn_sizes[i] == self._sizes[i]
    
            # If everything is correct, bring over the weights and biases
            for i in range(len(self._sizes)):
                self.w_list[i] = rbm_list[i].w
                self.b_list[i] = rbm_list[i].hb
    
        # Training method
        def train(self):
            # Create placeholders for input, weights, biases, output
            _a = [None] * (len(self._sizes) + 2)
            _w = [None] * (len(self._sizes) + 1)
            _b = [None] * (len(self._sizes) + 1)
            _a[0] = tf.placeholder("float", [None, self._X.shape[1]])
            y = tf.placeholder("float", [None, self._Y.shape[1]])
    
            # Define variables and activation functoin
            for i in range(len(self._sizes) + 1):
                _w[i] = tf.Variable(self.w_list[i])
                _b[i] = tf.Variable(self.b_list[i])
            for i in range(1, len(self._sizes) + 2):
                _a[i] = tf.nn.sigmoid(tf.matmul(_a[i - 1], _w[i - 1]) + _b[i - 1])
    
            # Define the cost function
            cost = tf.reduce_mean(tf.square(_a[-1] - y))
    
            # Define the training operation (Momentum Optimizer minimizing the Cost function)
            train_op = tf.train.MomentumOptimizer(
                self._learning_rate, self._momentum).minimize(cost)
    
            # Prediction operation
            predict_op = tf.argmax(_a[-1], 1)
    
            # Training Loop
            with tf.Session() as sess:
                # Initialize Variables
                sess.run(tf.global_variables_initializer())
    
                # For each epoch
                for i in range(self._epoches):
    
                    # For each step
                    for start, end in zip(
                            range(0, len(self._X), self._batchsize), range(self._batchsize, len(self._X), self._batchsize)):
                        # Run the training operation on the input data
                        sess.run(train_op, feed_dict={
                            _a[0]: self._X[start:end], y: self._Y[start:end]})
    
                    for j in range(len(self._sizes) + 1):
                        # Retrieve weights and biases
                        self.w_list[j] = sess.run(_w[j])
                        self.b_list[j] = sess.run(_b[j])
    
                    print("Accuracy rating for epoch " + str(i) + ": " + str(np.mean(np.argmax(self._Y, axis=1) == \
                                                                                     sess.run(predict_op, feed_dict={_a[0]: self._X, y: self._Y}))))
    
    
    if __name__ == '__main__':
        # Loading in the mnist data
        mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    
        trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images,\
            mnist.test.labels
    
        RBM_hidden_sizes = [500, 200, 50]  # create 4 layers of RBM with size 785-500-200-50
        # Since we are training, set input as training data
        inpX = trX
        # Create list to hold our RBMs
        rbm_list = []
        # Size of inputs is the number of inputs in the training set
        input_size = inpX.shape[1]
    
        # For each RBM we want to generate
        for i, size in enumerate(RBM_hidden_sizes):
            print('RBM: ', i, ' ', input_size, '->', size)
            rbm_list.append(RBM(input_size, size))
            input_size = size
    
        # For each RBM in our list
        for rbm in rbm_list:
            print('New RBM:')
            # Train a new one
            rbm.train(inpX)
            # Return the output layer
            inpX = rbm.rbm_outpt(inpX)
    
        nNet = NN(RBM_hidden_sizes, trX, trY)
        nNet.load_from_rbms(RBM_hidden_sizes, rbm_list)
        nNet.train()

    任何程序错误,以及技术疑问或需要解答的,请扫码添加作者VX::1755337994

     

     

     

     

    展开全文
  • Tensorflow-DBN

    2019-04-30 15:19:11
    DBN深度信念网络的代码说明,元数据以及测试数据集训练数据集,和Tensorflow环境下的python源代码,以及DBN的书籍资料
  • DBN

    千次阅读 2017-06-20 11:52:21
    而且每一层 RBM 网络只能确保自身层内的 权值对该层特征向量映射达到最优,并不是对整个 DBN 的特征向量映射达到最优,所以反向传播网络还将错误信息自顶向下传播至每一层 RBM,微调整个 DBN 网络.RBM 网络训练模型的...

    深度神经网路已经在语音识别,图像识别等领域取得前所未有的成功。本人在多年之前也曾接触过神经网络。本系列文章主要记录自己对深度神经网络的一些学习心得。




    1.  自联想神经网络与深度网络


          自联想神经网络是很古老的神经网络模型,简单的说,它就是三层BP网络,只不过它的输出等于输入。很多时候我们并不要求输出精确的等于输入,而是允许一定的误差存在。所以,我们说,输出是对输入的一种重构。其网络结构可以很简单的表示如下:

                                                               


              如果我们在上述网络中不使用sigmoid函数,而使用线性函数,这就是PCA模型。中间网络节点个数就是PCA模型中的主分量个数。不用担心学习算法会收敛到局部最优,因为线性BP网络有唯一的极小值。


          在深度学习的术语中,上述结构被称作自编码神经网络。从历史的角度看,自编码神经网络是几十年前的事情,没有什么新奇的地方。

                                                                      


             既然自联想神经网络能够实现对输入数据的重构,如果这个网络结构已经训练好了,那么其中间层,就可以看过是对原始输入数据的某种特征表示。如果我们把它的第三层去掉,这样就是一个两层的网络。如果,我们把这个学习到特征再用同样的方法创建一个自联想的三层BP网络,如上图所示。换言之,第二次创建的三层自联想网络的输入是上一个网络的中间层的输出。用同样的训练算法,对第二个自联想网络进行学习。那么,第二个自联想网络的中间层是对其输入的某种特征表示。如果我们按照这种方法,依次创建很多这样的由自联想网络组成的网络结构,这就是深度神经网络,如下图所示:

                                                   

          注意,上图中组成深度网络的最后一层是级联了一个softmax分类器。


          深度神经网络在每一层是对最原始输入数据在不同概念的粒度表示,也就是不同级别的特征描述。


          这种层叠多个自联想网络的方法,最早被Hinton想到了。


           从上面的描述中,可以看出,深度网络是分层训练的,包括最后一层的分类器也是单独训练的,最后一层分类器可以换成任何一种分类器,例如SVM,HMM等。上面的每一层单独训练使用的都是BP算法。 相信这一思路,Hinton早就实验过了。


    2. DBN神经网络模型

             

            使用BP算法单独训练每一层的时候,我们发现,必须丢掉网络的第三层,才能级联自联想神经网络。然而,有一种更好的神经网络模型,这就是受限玻尔兹曼机。使用层叠波尔兹曼机组成深度神经网络的方法,在深度学习里被称作深度信念网络DBN,这是目前非常流行的方法。下面的术语,将把自联想网络称作自编码网络autoencoder.。通过层叠自编码网络的深度网络在深度学习里另外一个属于叫栈式自编码网络。


            经典的DBN网络结构 是由若干层 RBM 和一层 BP 组成的一种深层神经网络, 结构如下图所示.

                                                                             
                 DBN 在训练模型的过程中主要分为两步:
                 第 1 步:分别单独无监督地训练每一层 RBM 网络,确保特征向量映射到不同特征空间时,都尽可能多地保留特征信息;
                 第 2 步:在 DBN 的最后一层设置 BP 网络,接收 RBM 的输出特征向量作为它的输入特征向量,有监督地训练实体关系分类器.而且每一层 RBM 网络只能确保自身层内的 权值对该层特征向量映射达到最优,并不是对整个 DBN 的特征向量映射达到最优,所以反向传播网络还将错误信息自顶向下传播至每一层 RBM,微调整个 DBN 网络.RBM 网络训练模型的过程可以看作对一个深层 BP 网络权值参数的初始化,使DBN 克服了 BP 网络因随机初始化权值参数而容易陷入局部最优和训练时间长的缺点.


               上述训练模型中第一步在深度学习的术语叫做预训练,第二步叫做微调。最上面有监督学习的那一层,根据具体的应用领域可以换成任何分类器模型,而不必是BP网络。


    3. 深度信念网络的应用  


          由于自编码网络可以对原始数据在不同概念的粒度上进行抽象,深度网络一种自然的应用是对数据进行压缩或者叫降维。

          胡邵华等,他们用一种自编码网络实现了对经典的"瑞士卷"数据的重构:

                                                                    

      

            " 瑞士卷"数据是经典的机器学习中难于分类的数据之一,其隐含的数据内在模式难以在二维数据中描述。然而, 胡邵华等,采用深度信念网络实现了对三维瑞士卷数据的2维表示,其自编码网络节点大小依次为3-100-50-25-10-2. 具体的实现细节请参考文献:胡邵华、宋耀良:基于autoencoder网络的数据降维与重构。


            深度神经网络的另一个常见的应用是特征提取。

            文献:Philippe Hamel and Douglas Eck, LEARNING FEATURES FROM MUSIC AUDIO WITH DEEP BELIEF NETWORKS.

            通过训练一个5层的深度网络提取音乐的特征,用于音乐风格的分类,其分类精度比基于梅尔倒谱系数特征分类的方法提到了14个百分点。

                                                                          

          他们的实现思路非常简单,用上述层叠的多个RBM网络组成深度网络结构来提取音乐的特征。输入的原始数据是经过分帧,加窗之后的信号的频谱。分类器采用的是支持向量机(SVM)。对比的方法则是提取MFCC特征系数,分类器同样采用SVM。更多的细节和实验结果可以参考上面提到的文献。

        

            深度网络是一种良好的机器学习方法,其特征提取功能能够针对不同概念的粒度大小,能够在很多领域得到广泛的应用。通常,DBN主要用于对一维数据的建模比较有效,例如语音。而通过级联多层卷积网络组成深度网络的模型主要用于二维数据,例如图像等。


    本文转自:http://blog.csdn.NET/celerychen2009/article/details/9079715

    展开全文
  • python作者_Python

    2020-11-24 05:01:47
    打算用Python来做一个原型,用于比较和Java实现方案的具体差异,以前也没有Python实战经验,所以摸索过程如下。首先定义协议,假定我们要实现一个群组成员管理的服务添加成员:POST http://server/group-user/users=...

    最近内部需要实现一个新的HTTP REST服务,数据用JSON。打算用Python来做一个原型,用于比较和Java实现方案的具体差异,以前也没有Python实战经验,所以摸索过程如下。

    首先定义协议,假定我们要实现一个群组成员管理的服务

    添加成员:

    POST http://server/group-user/

    users=[1,2,3…]

    删除成员:

    DELETE http://server/group-user/

    users=[1,2,3…]

    获取成员:

    GET http://server/group-user/

    评估了几个python web框架之后,包括django, selector, CherryPy等。

    Django安装和看了一些文档之后觉得它类似ruby on rails, 是一个快速的MVC/ORM的框架,相对于一个轻量级的REST服务来说不太适合。

    selector文档太少,使用也感觉比较繁琐。

    网上相关的讨论也比较少,可能目前REST方式还没大规模应用。正在比较迷茫的时候,看到了web.py的介绍,试用了一下之后,发现是碰到最适合目前需求的,使用也最简单。POST,GET,DELETE,PUT只需要在相应的function实现即可。另外还带了db,form,http等常用的web应用所需的类。

    主要源代码:

    class group_user:

    def __init__(self):

    pass

    def GET(self, gid):

    db = web.database(dbn='mysql', user='user', pw='pass', db='db', host="localhost")

    users = db.query('SELECT * FROM groupuser WHERE groupid=$gid', \

    vars={'gid':gid})

    output = StringIO.StringIO()

    output.write("[")

    count = 0

    for u in users:

    if count > 0:

    output.write(',')

    output.write('["uid":%d,"nickname":%s]' % \

    (u['uid'], json.dumps(u['nick'], True, False))

    count += 1

    output.write("]")

    str = output.getvalue()

    return str

    def POST(self, gid):

    data = web.data()

    result = urlparse.parse_qs(data)

    uid = result['uid'][0]

    add_count = 0

    list = json.loads(result['users'][0])

    for u in list:

    add_count += self.add_user(gid, u[0])

    return add_count

    def DELETE(self, gid):

    data = web.data()

    result = urlparse.parse_qs(data)

    uid = result['uid'][0]

    del_count = 0

    list = json.loads(result['users'][0])

    for u in list:

    uid = u[0]

    self.del_user(uid)

    del_count += 1

    return del_coun

    几点感想:

    原型所需要的功能很精简,开发效率比Java稍快,Java的代码长度可能会是这个1-2倍之间,但是针对这种纯业务逻辑的代码,Python的优势也不是非常明显,一个熟练的Java程序员可以很快完成这个功能。

    性能。测试环境下每秒只能执行40-50次,如果用Java实现的话可以轻松上千次。如果性能问题不能调优,可能Python实现的这个功能也只能用来验证原型,没法用在生产环境。

    数据库连接是每个function内部都执行一次连接,从Java的角度来看比较低效。

    Python 2.6之上自带JSON支持,无须另外寻找JSON库,比较方便。

    Python Web框架通过一个WSGI的规范来定义,类似Java的Servlet的规范。

    Python的代码强制嵌入的方式看起来比Java更优雅,除了class function定义中要带一个self参数比较怪异。

    展开全文
  • 深度信念(置信)网络(DBN),使用python开发环境,代码思路清晰,易调试。有问题可以留言相互交流
  • 深度置信网络DBN

    2018-08-17 21:09:58
    DBN实例,运行与matlab版本有关系,注释详细,建议用2014版
  • Python 中的 GPU 加速深度信念网络 来自: 在机器学习中,深度信念网络 (DBN) 是一种生成图形模型,或者是一种深度神经网络,由多层潜在变量(“隐藏单元”)组成,层之间有连接,但内部的单元之间没有连接。每一...
  • DBN-Library-master.zip

    2021-04-25 18:13:14
    深度置信网络(Deep Belief Network)python代码实现,亲测可用
  • DBN程序剖析

    2019-10-03 17:40:45
    最近学习深度学习,学习时间半月不到,很多程序似懂非懂,用的又是不太明白的python。不过不怕。什么也难不倒无产阶级,自己剖析下,不指望指点别人,只希望高人能指点。 主函数大体可以分为 建立DBN网络,预训练...
  • Tensorflow实现DBN

    千次阅读 热门讨论 2018-03-17 22:00:40
    My Github: ... 用Tensorflow实现的DBN 用于minst数据集分类,运行得到正确率为97.22% QQ群交流:640571839 P.S. 群如果搜索不到,可以先加我QQ:475366898 ...
  • DBN(深度置信网络)解析

    万次阅读 2016-12-14 22:42:01
    1.DBN结构 DBN: 将RBM像砖块一样叠加起来构建的一个网络。 DBN训练方法: 第 1 步:(预训练) 分别单独无监督地训练每一层 RBM 网络,确保特征向量映射到不同特征空间时,都尽可能多地保留特征信息;(H0可以看作...
  • 使用DBN模型进行故障诊断,故障类型为4类,每类训练集为400个,测试20个。
  • %pyspark#查询认证用户import sys#import MySQLdbimport mysql.connectorimport pandas as pdimport datetimeimport timeoptmap = {'dbuser' : 'haoren','dbpass' : 'G4d','dbhost' : '172.12.112.5','dbport...'dbn...
  • python编写数据库的代码很方便,但是如果不想自己写sql语句,其实还有更多的讨巧办法。使用webpy的db库就是不错的一...db = web.database(dbn=’mysql’, db=’blog’, user=’root’, pw=’123456′) 4、增、删、改
  • Python笔记

    2019-10-03 16:33:57
    查看python已安装模块的方法小结 一、命令行下使用pydoc命令 在命令行下运行$ pydoc modules即可查看 二、在python交互解释器中使用help()查看 在交互式解释器中输入>>> help("modules")即可,效果跟在...
  • python基础特性

    2019-04-25 21:12:17
    1.python的特点 与其他机器语言的不同就在于python支持交互式编程,在原生平台可以随时查看结果。与编译型语言不同,python在运行时才将内容解释为机器语言,而C/C++在进行编译后,以后运行时就不需要再进行编译,...
  • Matlab之DBN代码

    2021-04-23 10:42:36
    我晕,做毕设需要用到DBN算法,由于第一次接触无论是原理还是代码都不懂,于是网上找了一些代码折腾了一个月,python和matlab都试过了,不断调整各种参数,训练数据和测试数据也弄的很明显,但就是预测的不准确。...
  • 自己编写的深度信念网络模型程序,可以直接调用。本人用DBN进行了光伏发电预测,效果很好。
  • 深度置信网络DBN的matlab算法实现,可直接运行,程序运行采样的数据库为MNIST手写数字数据库。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,013
精华内容 805
关键字:

dbnpython

python 订阅