精华内容
下载资源
问答
  • python代码(SAE代码
  • matlab聚类的代码零镜头学习的语义自动编码器 Elyor Kodirov,Tao Xiang和Shaogang Gong,聚光灯。 抽象的 现有的零镜头学习(ZSL)模型通常从视觉特征空间到语义嵌入空间(例如,属性空间)学习投影函数。 然而,...
  • DeepLearnToolbox中SAE代码理解

    千次阅读 2016-11-15 08:50:33
    %训练出最终模型sae.ae{i}(更新后的W),输入的ae模型的W是随机初始化的 t = nnff( sae. ae {i} , x, x); %前向传播,算出每层的特征(激活值) x = t. a { 2 } ; %取中间层的特征 %remove bias term x ...

    Dropout是指在模型训练时随机让网络某些隐含层节点的权重不工作,不工作的那些节点可以暂时认为不是网络结构的一部分,但是它的权重得保留下来(只是暂时不更新而已),因为下次样本输入时它可能又得工作了。
    训练神经网络模型时,如果训练样本较少,为了防止模型过拟合,Dropout可以作为一种trikc供选择。Dropout是hintion最近2年提出的,源于其文章Improving neural networks by preventing co-adaptation of feature detectors.中文大意为:通过阻止特征检测器的共同作用来提高神经网络的性能。

    Denoise Autoencoder(简称dAE)是指当采用无监督的方法分层预训练深度网络的权值时,为了学习到较鲁棒的特征,可以在网络的可视层(即数据的输入层)引入随机噪声,这里并不是加入高斯噪声,而是以一定概率使输入层节点的值清为0。这种方法由Bengio在08年提出,见其文章Extracting and composing robust features with denoising autoencoders.使用dAE时,可以用被破坏的输入数据重构出原始的没被破坏的数据,所以它训练出来的特征会更鲁棒。
    Bengio对dAE的直观解释为:1.dAE有点类似人体的感官系统,比如人眼看物体时,如果物体某一小部分被遮住了,人依然能够将其识别出来,2.多模态信息输入人体时(比如声音,图像等),少了其中某些模态的信息有时影响也不大。3.普通的autoencoder的本质是学习一个相等函数,即输入和重构后的输出相等,这种相等函数的表示有个缺点就是当测试样本和训练样本不符合同一分布,即相差较大时,效果不好,明显,dAE在这方面的处理有所进步。
    当在训练深度网络时,且采用了无监督方法预训练权值,通常,Dropout和Denoise Autoencoder在使用时有一个小地方不同:Dropout在分层预训练权值的过程中是不参与的,只是后面的微调部分引入;而Denoise Autoencoder是在每层预训练的过程中作为输入层被引入,在进行微调时不参与。另外,一般的重构误差可以采用均方误差的形式,但是如果输入和输出的向量元素都是位变量,则一般采用交叉熵来表示两者的差异。
    test_example_SAE.m

    function test_example_SAE
    sae = saesetup([327 200 20]);%1*2cell,[327 200 327]和[200 20 200]两个神经网络
        sae.ae{1}.activation_function       = 'sigm';%只改变第一个神经网络的参数
        sae.ae{1}.learningRate              = 1;
        sae.ae{1}.inputZeroMaskedFraction   = 0.5;
        opts.numepochs =   1;
        opts.batchsize = 100;
        [reducedim_x,sae] = saetrain(sae, X, opts);%reducedim_x是降维后的20维的训练样本

    saesetup.m

    function sae = saesetup(size)%[327 200 20]
        for u = 2 : numel(size)%3
            sae.ae{u-1} = nnsetup([size(u-1) size(u) size(u-1)]);%sae.ae{1} = nnsetup([327 200 327]);以此为例注释
                                                                 %sae.ae{2} = nnsetup([200 20 200]);
        end
    end
    

    nnsetup.m

    function nn = nnsetup(architecture)
    %NNSETUP creates a Feedforward Backpropagate Neural Network
    % nn = nnsetup(architecture) returns an neural network structure with n=numel(architecture)
    % layers, architecture being a 1 x n vector of layer sizes e.g. [784 100 10]
    
        nn.size   = architecture;%构建神经网络[327 200 327]
        nn.n      = numel(nn.size);%n=3
    
        nn.activation_function              = 'tanh_opt';   %  Activation functions of hidden layers: 'sigm' (sigmoid) or 'tanh_opt' (optimal tanh).
        nn.learningRate                     = 2;            %  learning rate Note: typically needs to be lower when using 'sigm' activation function and non-normalized inputs.
        nn.momentum                         = 0.5;          %  Momentum
        nn.scaling_learningRate             = 1;            %  学习率的收缩因子;Scaling factor for the learning rate (each epoch)
        nn.weightPenaltyL2                  = 0;            %  W的L2规则项的系数;L2 regularization
        nn.nonSparsityPenalty               = 0;            %  稀疏惩罚项的系数;Non sparsity penalty
        nn.sparsityTarget                   = 0.05;         %  稀疏因数(Sparse AE)Sparsity target
        nn.inputZeroMaskedFraction          = 0;            %  Used for Denoising AutoEncoders
        nn.dropoutFraction                  = 0;            %  Dropout level (http://www.cs.toronto.edu/~hinton/absps/dropout.pdf)
        nn.testing                          = 0;            %  Internal variable. nntest sets this to one.
        nn.output                           = 'sigm';       %  output unit 'sigm' (=logistic), 'softmax' and 'linear'
    
        for i = 2 : nn.n   
            % weights and weight momentum
            nn.W{i - 1} = (rand(nn.size(i), nn.size(i - 1)+1) - 0.5) * 2 * 4 * sqrt(6 / (nn.size(i) + nn.size(i - 1)));
            %W{1}=[200x328],W{2}=[327x201]
            nn.vW{i - 1} = zeros(size(nn.W{i - 1}));
    
            % 平均激活值(Sparse AE);average activations (for use with sparsity)
            nn.p{i}     = zeros(1, nn.size(i)); % p{1}=[],p{2}=[1x200],p{3}=[1x327]
            %对于神经网络[327 200 327],隐藏层节点个数是200和327
        end
    end
    

    saetrain.m

    function [reducedim_x,sae] = saetrain(sae, x, opts)
        reducedim_x = {};  
        for i = 1 : numel(sae.ae);%sae 1*2cell,[327 200 327]和[200 20 200]两个神经网络
            disp(['Training AE ' num2str(i) '/' num2str(numel(sae.ae))]);
            sae.ae{i} = nntrain(sae.ae{i}, x, x, opts);%训练出最终模型sae.ae{i}(更新后的W),输入的ae模型的W是随机初始化的
            t = nnff(sae.ae{i}, x, x);%前向传播,算出每层的特征(激活值)
    
             x = t.a{2};%取中间层的特征
            %remove bias term
             x = x(:,2:end);%中间层的特征去除bias后 是下一个ae的输入x
             reducedim_x = x;
    
        end
    end

    nntrain.m

    function [nn, L]  = nntrain(nn, train_x, train_y, opts, val_x, val_y)
    %NNTRAIN trains a neural net
    % [nn, L] = nntrain(nn, x, y, opts) trains the neural network nn with input x and
    % output y for opts.numepochs epochs, with minibatches of size opts.batchsize.
    %  用输入x和输出y训练一个神经网络,循环opts.numepochs次,每次样本数量为opts.batchsize
    %Returns a neural network nn with updated activations,
    % errors, weights and biases, (nn.a, nn.e, nn.W, nn.b) and L, the sum
    % squared error for each training minibatch.
    %返回更新后的激活值,误差值,权重W,偏置量b和每个batch样本的均方误差
    assert(isfloat(train_x), 'train_x must be a float');
    assert(nargin == 4 || nargin == 6,'number ofinput arguments must be 4 or 6')
    
    loss.train.e               = [];
    loss.train.e_frac          = [];
    loss.val.e                 = [];
    loss.val.e_frac            = [];
    opts.validation = 0;
    if nargin == 6
        opts.validation = 1;
    end
    
    fhandle = [];
    if isfield(opts,'plot') && opts.plot == 1
        fhandle = figure();
    end
    
    m = size(train_x, 1);%414
    train_x_dims  =  size(train_x,2);%327
    train_y_dims  =  size(train_y,2);%327,这里的train_x和train_y都是训练样本X
    
    batchsize = opts.batchsize;%100
    numepochs = opts.numepochs;%1 循环次数
    
    % numbatches = m / batchsize;
    numbatches = ceil(m / batchsize);%5
    
    assert(rem(numbatches, 1) == 0, 'numbatches must be a integer');
    
    L = zeros(numepochs*numbatches,1);%记录每次循环,每个batch样本的均方误差
    n = 1;
    for i = 1 : numepochs
        tic;
            kk = randperm(m);
        for l = 1 : numbatches
    
            batch_x=zeros(batchsize,train_x_dims);%[100x327]初始化为0
            batch_y=zeros(batchsize,train_y_dims);%[100x327]初始化为0
    
            end_indice=min(l*batchsize,m);
            batch_x(1:end_indice-(l-1)*batchsize,1:train_x_dims) = train_x(kk((l - 1) * batchsize + 1 : end_indice), :);
            %最后一个batch样本不足100个!!
    
            %Add noise to input (for use in denoising autoencoder)
            if(nn.inputZeroMaskedFraction ~= 0)
                batch_x = batch_x.*(rand(size(batch_x))>nn.inputZeroMaskedFraction);
                %rand(size(batch_x))产生和batch_x矩阵一样大小的矩阵,元素是随机0~1之间的数字。
                %而rand(size(batch_x))>nn.inputZeroMaskedFraction使随机数字的矩阵大于0.5的为1,小于0.5的为0。
                %batch_x.*(rand(size(batch_x))>nn.inputZeroMaskedFraction)
                %将batch_x与这个只有0和1的矩阵 对应元素相乘,使batch_x很多特征变成0
                %
            end
            %融合特征其实不需要y,y用来给nnff函数算错误率
    
            batch_y(1:end_indice-(l-1)*batchsize,1:train_y_dims) = train_y(kk((l - 1) * batchsize + 1 :end_indice), :);
    
            nn = nnff(nn, batch_x, batch_y);%计算每层的a,即sigm(数据x*W),得到output(前向传播)
            nn = nnbp(nn);%根据output得到所有层dW(W的偏导数),bp算法
            nn = nnapplygrads(nn);%根据dW更新所有层W,批量梯度下降算法法
    
            L(n) = nn.L;
    
            n = n + 1;
        end%一个batch结束,用每个batch都对所有层W更新一次
    
        t = toc;
    
        if opts.validation == 1
            loss = nneval(nn, loss, train_x, train_y, val_x, val_y);
            str_perf = sprintf('; Full-batch train mse = %f, val mse = %f', loss.train.e(end), loss.val.e(end));
        else
            loss = nneval(nn, loss, train_x, train_y);
            str_perf = sprintf('; Full-batch train err = %f', loss.train.e(end));
        end
        if ishandle(fhandle)
            nnupdatefigures(nn, fhandle, loss, opts, i);
        end
    
        disp(['epoch ' num2str(i) '/' num2str(opts.numepochs) '. Took ' num2str(t) ' seconds' '. Mini-batch mean squared error on training set is ' num2str(mean(L((n-numbatches):(n-1)))) str_perf]);
        nn.learningRate = nn.learningRate * nn.scaling_learningRate;%学习率收缩
    end%一次循环结束
    end
    

    nnff.m

    function nn = nnff(nn, x, y)
    %NNFF performs a feedforward pass
    % nn = nnff(nn, x, y) returns an neural network structure with updated
    % layer activations, error and loss (nn.a, nn.e and nn.L)
    %进行前向传播,得到各层激活值,最后一层的误差和均方误差
        n = nn.n;%nn=[327 200 327],n=3
        m = size(x, 1);%m=100
    
        x = [ones(m,1) x];% [x0 x]=[100x328],第一列是偏置量
        nn.a{1} = x;%第一层激活值是输入x
    
        %feedforward pass
        for i = 2 : n-1
            switch nn.activation_function 
                case 'sigm'
                    % Calculate the unit's outputs (including the bias term)
                    nn.a{i} = sigm(nn.a{i - 1} * nn.W{i - 1}');%a{2}  [x0 x] *[W0 =x0W0+Wx=bias+Wx=[100x328]*[328x200] =[100x200]
                                                               %               W]
                case 'tanh_opt'
                    nn.a{i} = tanh_opt(nn.a{i - 1} * nn.W{i - 1}');
            end
    
            %dropout
            if(nn.dropoutFraction > 0)
                if(nn.testing)
                    nn.a{i} = nn.a{i}.*(1 - nn.dropoutFraction);
                else
                    nn.dropOutMask{i} = (rand(size(nn.a{i}))>nn.dropoutFraction);%随机0和1的矩阵
                    nn.a{i} = nn.a{i}.*nn.dropOutMask{i};%将激活值以一定概率清为0(处理同denoise AE)
                end
            end
    
            %calculate running exponential activations for use with sparsity
            if(nn.nonSparsityPenalty>0)
                nn.p{i} = 0.99 * nn.p{i} + 0.01 * mean(nn.a{i}, 1);%p{i}初始化为0
                %mean(nn.a{i}, 1)求a各列的均值,得到[1x200],为平均激活值(参见Sparse AE)
            end
    
            %Add the bias term
            nn.a{i} = [ones(m,1) nn.a{i}];
        end
        switch nn.output %计算输出层的值
            case 'sigm'
                nn.a{n} = sigm(nn.a{n - 1} * nn.W{n - 1}');
            case 'linear'
                nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';
            case 'softmax'
                nn.a{n} = nn.a{n - 1} * nn.W{n - 1}';
                nn.a{n} = exp(bsxfun(@minus, nn.a{n}, max(nn.a{n},[],2)));
                nn.a{n} = bsxfun(@rdivide, nn.a{n}, sum(nn.a{n}, 2)); 
        end
    
        %error and loss
        nn.e = y - nn.a{n};%最后一层的误差
    
        switch nn.output
            case {'sigm', 'linear'}
                nn.L = 1/2 * sum(sum(nn.e .^ 2)) / m; %均方误差
            case 'softmax'
                nn.L = -sum(sum(y .* log(nn.a{n}))) / m;
        end
    end
    

    nnbp.m

    function nn = nnbp(nn)
    %NNBP performs backpropagation
    % nn = nnbp(nn) returns an neural network structure with updated weights 
    
        n = nn.n;
        sparsityError = 0;
        switch nn.output
            case 'sigm'
                d{n} = - nn.e .* (nn.a{n} .* (1 - nn.a{n}));%计算最后一层的残差d{n}(公式见bp算法第二步)
                %nn.e = y - nn.a{n};
                %nn.a{n} = sigm(nn.a{n - 1} * nn.W{n - 1}');
    
            case {'softmax','linear'}
                d{n} = - nn.e;
        end
        for i = (n - 1) : -1 : 2%从倒数第二层往前,计算残差d{i}
            % Derivative of the activation function
            switch nn.activation_function 
                case 'sigm'
                    d_act = nn.a{i} .* (1 - nn.a{i});%sigm函数的导数
                case 'tanh_opt'
                    d_act = 1.7159 * 2/3 * (1 - 1/(1.7159)^2 * nn.a{i}.^2);
            end
    
            if(nn.nonSparsityPenalty>0)
                pi = repmat(nn.p{i}, size(nn.a{i}, 1), 1);%平均激活值
                sparsityError = [zeros(size(nn.a{i},1),1) nn.nonSparsityPenalty * (-nn.sparsityTarget ./ pi + (1 - nn.sparsityTarget) ./ (1 - pi))];
            end
    
            % Backpropagate first derivatives
            if i+1==n % in this case in d{n} there is not the bias term to be removed  求倒数第二层的残差时,使用的最后一层残差d{n}没有偏置量           
                d{i} = (d{i + 1} * nn.W{i} + sparsityError) .* d_act; % 公式见bp算法第三步(Sparse AE)
            else % in this case in d{i} the bias term has to be removed
                d{i} = (d{i + 1}(:,2:end) * nn.W{i} + sparsityError) .* d_act;
            end
    
            if(nn.dropoutFraction>0)
                d{i} = d{i} .* [ones(size(d{i},1),1) nn.dropOutMask{i}];
            end
    
        end%从倒数第二层往前
    
        for i = 1 : (n - 1)%计算W的偏导数dW
            if i+1==n
                nn.dW{i} = (d{i + 1}' * nn.a{i}) / size(d{i + 1}, 1);%除以样本数量
            else
                nn.dW{i} = (d{i + 1}(:,2:end)' * nn.a{i}) / size(d{i + 1}, 1);      
            end
        end
    end
    

    nnapplygrads.m

    function nn = nnapplygrads(nn)
    %NNAPPLYGRADS updates weights and biases with calculated gradients
    % nn = nnapplygrads(nn) returns an neural network structure with updated
    % weights and biases
    
        for i = 1 : (nn.n - 1)
            if(nn.weightPenaltyL2>0)%nn.dW已经除以了样本数量
                dW = nn.dW{i} + nn.weightPenaltyL2 * [zeros(size(nn.W{i},1),1) nn.W{i}(:,2:end)];
            else
                dW = nn.dW{i};
            end
    
            dW = nn.learningRate * dW;%批量梯度下降法中第三步
    
            if(nn.momentum>0)
                nn.vW{i} = nn.momentum*nn.vW{i} + dW;
                dW = nn.vW{i};
            end
    
            nn.W{i} = nn.W{i} - dW;
        end
    end
    

    参考资料:
    1、Deep learning:四十一(Dropout简单理解)
    2、Deep learning:四十二(Denoise Autoencoder简单理解)

    展开全文
  • 基于MATLAB的SAE模块

    2018-07-11 17:13:25
    基于MATLAB的SAE模块基于MATLAB的SAE模块基于MATLAB的SAE模块
  • 主要介绍了简单解决新浪SAE无法上传文件的问题,不知道到底是新浪的BUG还是我个人的问题,分享给大家吧。
  • SAE算法代码

    2019-03-05 21:03:48
    代码包包含零元学习算法SAE代码,亲测可运行,对研究零元学习童鞋们有一定的帮助
  • 学习笔记:SAE TensorFlow代码

    千次阅读 热门讨论 2017-04-16 15:59:44
    栈式自编码: 一.... ...AE的原理是先通过一个encode层对输入进行编码,这个编码就是特征,然后利用encode乘第2层参数(也可以是encode层的参数的转置乘特征并加偏执),重构(解码)输入,然后用重构...SAE是这样的:

    栈式自编码:

    一.基本原理

    AE的原理是先通过一个encode层对输入进行编码,这个编码就是特征,然后利用encode乘第2层参数(也可以是encode层的参数的转置乘特征并加偏执),重构(解码)输入,然后用重构的输入和实际输入的损失训练参数。

    对于我的应用来说,我要做的首先是抽取特征。AE的encode的过程很简单,是这样的:


    SAE是这样的:


     

    训练过程中,两个SAE分别训练,第一个SAE训练完之后,其encode的输出作为第二个SAE的输入,接着训练。训练完后,用第二层的特征,通过softmax分类器(由于分类器 还是得要带标签的数据来训练,所以,实际应用总,提取特征后不一定是拿来分类),将所有特征分为n类,得到n类标签。训练网络图


              step 1



                  step 2



                          step 3    

     按照UFLDL的说明,在各自训练到快要收敛的时候,要对整个网络通过反向传播做微调,但是不能从一开始就整个网络调节。

    两个SAE训练完后,每个encode的输出作为两个隐层的特征,然后重新构建网络,新网络不做训练,只做预测。网络如下:


     


    from __future__ import division, print_function, absolute_import
    
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 下载并导入MNIST数据集
    from tensorflow.examples.tutorials.mnist import input_data
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
    
    # 参数
    learning_rate = 0.01#学习率
    training_epochs = 20#训练的周期
    batch_size = 256#每一批次训练的大小
    display_step = 1
    
    
    # 神经网络的参数
    n_hidden_1 = 256 # 隐层1的神经元个数
    n_hidden_2 = 100 # 隐层2神经元个数
    n_input = 784 # MNIST数据集的输出(img shape: 28*28)
    n_output=10
    
    # tf Graph input (only pictures)
    X = tf.placeholder("float", [None, n_input])
    
    weights = {
        'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
        'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
        'decoder_h1': tf.Variable(tf.random_normal([n_hidden_1, n_input])),
        'decoder_h2': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
        'softmax_w': tf.Variable(tf.random_normal([n_hidden_2, n_output])),
    }
    biases = {
        'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
        'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
        'decoder_b1': tf.Variable(tf.random_normal([n_input])),
        'decoder_b2': tf.Variable(tf.random_normal([n_hidden_1])),
        'softmax_b': tf.Variable(tf.random_normal([n_output])),
    }
    
    
    
    
    #************************* 1st hidden layer **************
    X = tf.placeholder("float", [None, n_input])
    
    h1_out =tf.nn.sigmoid(tf.add(tf.matmul(X, weights['encoder_h1']),
                                       biases['encoder_b1']))
    keep_prob = tf.placeholder("float")
    h1_out_drop = tf.nn.dropout(h1_out,keep_prob)
    
    X_1 = tf.nn.sigmoid(tf.matmul(h1_out_drop,weights['decoder_h1'])+biases['decoder_b1'])
    
    loss1 = tf.reduce_mean(tf.pow(X - X_1, 2))
    train_step_1 = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss1)
    sess=tf.Session()
    sess.run(tf.variables_initializer([weights['encoder_h1'],biases['encoder_b1'],
                                      weights['decoder_h1'],biases['decoder_b1']]))
    # training
    for i in range(training_epochs):
        batch_x,batch_y =  mnist.train.next_batch(batch_size)
        _,c=sess.run([train_step_1,loss1],feed_dict={X:batch_x, keep_prob:1.0})
        if i%5==0:
            print(c)
    
    #h1_out = tf.nn.sigmoid(tf.add(tf.matmul(X, weights['encoder_h1']),
    #                                  biases['encoder_b1']))
    #get result of 1st layer as well as the input of next layer
    
    #************************** 2nd hidden layer *************
        
    h2_x = tf.placeholder("float", shape = [None, n_hidden_1])
    
    h2_out = tf.nn.sigmoid(tf.matmul(h2_x,weights['encoder_h2']) + biases['encoder_b2'])
    
    h2_out_drop = tf.nn.dropout(h2_out,keep_prob)
    
    h2_in_decode = tf.nn.sigmoid(tf.matmul(h2_out_drop, weights['decoder_h2']) +  biases['decoder_b2'])
    
    loss2 = tf.reduce_mean(tf.pow( h2_x- h2_in_decode, 2))
    train_step_2 = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss2)
    
    sess.run(tf.variables_initializer([weights['encoder_h2'],biases['encoder_b2'],
                                       weights['decoder_h2'],biases['decoder_b2']]))
    
    for i in range(training_epochs):
            #batch_x = numpy.reshape(batch_x,[batch_size,sample_length])		
        h1_out=[]
        batch_x,batch_y =  mnist.train.next_batch(batch_size)
        temp=tf.nn.sigmoid(tf.add(tf.matmul(batch_x, weights['encoder_h1']),
                                       biases['encoder_b1']))
        h1_out.extend(sess.run(temp))
        
        _,c=sess.run([train_step_2,loss2],feed_dict={h2_x:h1_out,keep_prob:1.0})
        if i%5==0:
            print(c)
    #h2_out = tf.nn.sigmoid(tf.matmul(h1_out,weights['decoder_h2']) + biases['decoder_b2'])
    #get result of 2nd layer as well as the input of next layer
    
    
    #************************** softmax layer ****************
    y_ = tf.placeholder("float", shape = [None, n_output])
    soft_x = tf.placeholder("float", shape = [None, n_hidden_2])
    
    y_out = tf.nn.softmax(tf.matmul(soft_x, weights['softmax_w']) + biases['softmax_b'])
    
    cross_entropy = -tf.reduce_sum(y_ * tf.log(y_out))
    train_step_soft = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)
    correct_prediction = tf.equal(tf.argmax(y_out, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    sess.run(tf.variables_initializer([weights['softmax_w'],biases['softmax_b']]))
    
    for i in range(training_epochs):
        h2_out=[]
        batch_x,batch_y =  mnist.train.next_batch(batch_size)
        for i in range(batch_size):
            temp=tf.nn.sigmoid(tf.add(tf.matmul(batch_x[i].reshape([1,784]), weights['encoder_h1']),
                                           biases['encoder_b1']))
    
            temp=tf.nn.sigmoid(tf.add(tf.matmul(temp, weights['encoder_h2']),
                                           biases['encoder_b2']))
            h2_out.extend(sess.run(temp))
    
        sess.run(train_step_soft,feed_dict={soft_x:h2_out, y_:batch_y, keep_prob:1.0})
        if i%5 == 0:
            print(sess.run(accuracy, feed_dict={soft_x:h2_out, y_:batch_y, keep_prob:1.0}))
    
    
    
    #fine-tuning
    print ("************************* fine-tuning ***************************")
    h1_out = tf.nn.sigmoid(tf.add(tf.matmul(X_1, weights['encoder_h1']),
                                       biases['encoder_b1']))
    h2_out = tf.nn.sigmoid(tf.matmul(h1_out,weights['encoder_h2']) + biases['encoder_b2'])
            
    h2_out_drop = tf.nn.dropout(h2_out,keep_prob)
    
    y_out = tf.nn.softmax(tf.matmul(h2_out_drop, weights['softmax_w']) + biases['softmax_b'])
    
    cross_entropy = -tf.reduce_sum(y_ * tf.log(y_out))
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)
    correct_prediction = tf.equal(tf.argmax(y_out, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    for i in range(training_epochs):
        batch_x,batch_y = mnist.train.next_batch(batch_size)
        #batch_x = numpy.reshape(batch_x,[batch_size,sample_length])		
        sess.run(train_step,feed_dict={X:batch_x, y_:batch_y, keep_prob:0.5})
        if i%5 == 0:
            print (sess.run(accuracy,feed_dict={X:batch_x, y_:batch_y, keep_prob:0.5}))
    print (sess.run(accuracy,feed_dict={X:batch_x, y_:batch_y, keep_prob:0.5}))
    


    展开全文
  • SAE代码部署问题

    2012-03-05 00:30:00
    如何将代码上传到SAE?...SAE代码部署说明SVN手册 SVN仓库地址:https://svn.sinaapp.com/your_app_name SVN用户名: SAE安全邮箱 SVN密码: SAE安全密码  Windows 示例: 参见:在Windows下使用SVN部署代码 ...

    如何将代码上传到SAE?

        您可以使用SVN将代码上传到SAE。 SAE代码部署说明     SVN手册

        SVN仓库地址:  https://svn.sinaapp.com/your_app_name

        SVN用户名:  SAE安全邮箱

        SVN密码:  SAE安全密码

     Windows 示例:

            参见:  在Windows下使用SVN部署代码

     Linux/Mac 示例:

            参见:  通过SVN部署代码

     

    SVN上线后,还可以使用SDK部署代码吗?

        可以,SDK的使用不受SVN上线的影响,但SAE建议您使用SVN进行代码部署,SVN具有 更好的使用特性,因此当前只提供SVN的下载 链接。

        如果您需要使用SDK的大文件 上传功能,为您提供SDK下载地址:http://sae.sina.com.cn/?m=sdk

     

    代码版本与应用版本有什么区别?

        图例:

    http://www-static.stor.sinaapp.com/attachement/22/23e891a75fe09fdb072be5ff0708550e.png

     

        应用版本号:  1

            C:\User\sina\Documents\sae\myhello\1\*

        代码版本号:4

            Completed     At revision: 4

     

    应用参与者能否使用SVN?    

        可以。应用参与者可以使用SVN进行代码部署。

     

    使用svn方式部署代码有什么限制吗?

        使用svn方式部署代码到SAE有如下限制:

            1. 文件名或目录名不允许含有以下字符:",*,?,<,>,|,另外文件或文件名的开始与结束也不允许有空格。

            2. 上传单个文件大小不超过20M

            3. 单个目录下的文 件个数不能超过2000个

            4. 每个应用代码总大小不超过100M

            5. 单个版本代码总大小不超过50M

            6. appname目录下只允许存在10个以内的版本,并且版本号必须为正整数。(也就是说appname下面只允许出现10个以内的正整数目录名,不允许有非目录的存在)

     

    SVN常见错误说明及解决办法

    错误码错误提示错误原因解决方法
    001The change log need some words(not null)提交时没有添加log message提交时加上log message
    002wrong file name format with white space,",",*,?,",\,<,>,|文件或目录名称 以空格开头或结尾、包含,*?\<>|"修改出错文件名
    003file xxx is not allowed in root directory!working copy的根目录下不允许有文件(只能是版本目录)删除该文件或移动至版本目录下
    004invalid dir name format xxxworking copy的根目录下不允许有非正整数的目录删除该目录或改名
    005directory b/ is not allowed in root directory! Only positive integer dirs are allowed!working copy的根目录下存在不为正整数的目录修改或删除该目录
    006Too many versions!(less than 10 is permited)版本目录数多于10个减少版本目录数目
    007Error: Too many files: xxx (less than 2000 is allowed).目录下的文件个数太多减少xxx目录下的文件数至2000以下
    008dir APPNAME/dir(size:xxxx) is too large less than xxxapp各版本大小相加大于100M或某一个版本目录大侠大于50M删除不必要的代码并重新提交
    009File AAA is too large!(less than 4M)单个文件大小大于超过限制删除该文件并重新提交
    010deploy xx failed部署失败内部原因,请联系saesupport@sina.cn
    N/Asvn: The log message is a pathname (was -F intended?); use '--force-log' to overridelog message 与路径名称相同修改log message或加选项--force-log
    N/ARepository UUID '305b-a4b9-f4be' doesn't match expected UUID '44e2-1b69-bd12'服务器端仓库被删除重建,客户端对原仓库进行操作,报错。重新checkout出一份代码即可

     

    SAE能否提供真实生产环境的仿真包?

         本地环境正在开发测试中,很快就能上线,敬请期待。

     

    SVN是否可以提供大文件上传功能?

        目前SVN暂时无法提供大文件上传功能。您可以使用SDK大文件上传方法,SDK下载地址http://sae.sina.com.cn/?m=sdk

        SAE将提供数据导入服务,届时您可以更方便的进行大文件导入工作。

     

    SVN会导致代码泄露么?

        不会。因为PHP文件被访问就运行了,所以不会显示您的原代码。不过.inc或者.fla文件可能会被下载。所以希望您不要将其放入SVN代码仓库,或者用appconfig对目录进行访问权限设置。

     

    为什么我无法使用svn cp, svn mv等指令?

        由于SVN服务端不能捕获某些svn cp及svn mv命令的更新,所以您使用这两个命令时可能会出现异常,建议您不要使用这两个命令。
        如果您要修改版本号或复制一个新版本,您可以使用svn export命令。用法如下:比如您要将版本1更改为版本2,那么您可以在本地工作拷贝使用svn export 1 2,然后删除1,并将2提交即可。相应的,如果您要复制一个新版本,您也可以使用svn export 1 2,然后将2提交即可。(注意:此处1和2是指的您本地工作拷贝下的版本目录)
     
     
    如何解决 “Server sent unexpected return value (504 ) xxx”错误

        您可以将代码分批提交来解决该问题。

     

    为何我创建的app版本目录下没有config.yaml文件?

        SVN仓库在创建版本时默认不创建config.yaml文件,如果您要使用config.yaml文件(如添加计划任务或rewrite规则),您可以创建一个名为config.yaml的文本文件,按照SAE配置文件规则来进行书写。查看AppConfig文档

     

    如何解决“提交失败,无法连接到服务器”错误

        您可以将代码分批提交来解决该问题。

     

    SDK支持代理连接吗?怎么设置代理?

        支持,SAE SDK支持标准http代理并支持basic auth。在Windows版,菜单->设置->网络;在Linux/Mac版,请指定子命令参数,如,-x127.0.0.1:80 or -x127.0.0.1:80:kobe:1234

     

    SDK提示网络不可用或者部署失败是什么原因?

        首先请确认您的SDK版本 (错误信息提示里有),建议您下载使用最新版本的Windows或者Linux/Mac平台下的SDK,http://sae.sina.com.cn/?m=sdk;其次,您可以运行SDK的诊断功能来确认网络连接情况,Windows版SDK请运行菜单->工具->网络连接诊 断,Linux版SDK请运行php am.php diagnose,如果诊断出问题,请检查自己的网络连接是否正常,是否有防火墙等,是否设置了代理等(SDK支持http代理并支持basic认证)。 如果网络诊断正常而代码部署或者下载出现问题,请您立即与我们联系。

     

    为什么我不能使用SDK部署代码?

        SAE推荐使用SVN部署代码,但SDK仍可使用。

        首先您需要检查上传时需要输入的邮箱账号和密码是否正确,是否按照提示输入了全部信息。如果还不行,请检查您的项目目录结构,无论是Windows版还是 Linux版SDK,您的代码目录都在apps/project_name/version/code/目录下,只有该目录下的代码会被上传。此外,需要 注意,SAE的代码版本号只支持正整数,不支持类似1.1的浮点数版本号。

     

     XCode 配置SAE的SVN代码管理,出现证书错误,应如何处理?

        请使用svn ls等指令在console下将证书保存。

    转载于:https://www.cnblogs.com/lzhitian/archive/2012/03/05/2379825.html

    展开全文
  • 新浪云Git代码仓库地址 https://git.sinacloud.com/demo 来我的GitHub看看吧~ 在本地合适的目录里进入Git Bash命令行 克隆git远程仓库1.$ git clone ...编辑代码并将代码部署到 `o

    新浪云Git代码仓库地址    https://git.sinacloud.com/demo

    来我的GitHub看看吧~


    在本地合适的目录里进入Git Bash命令行

    • 克隆git远程仓库
    • 1.$ git clone https://git.sinacloud.com/demo “demo”应当换成自己的
    • 2.输入安全邮箱和密码
    • 3.$ cd demo
    • 编辑代码并将代码部署到 `origin` 的版本1。
    • 4.$ git add .
    • 5.$ git commit -m '上传的项目注释'
    • 6.$ git push origin 1
    然后就可以在你的后台看到代码啦~

    附:新浪云代码部署手册

    展开全文
  • 之前写过模拟登录新浪微博的帖子,然而我并没有去爬过微博的数据,觉得有点浪费,于是就想写一个代码来发微博。写完之后觉得如果能自动发微博就好了,但是我又不可能24小时开始(晚上12点后还会断网),也没有vps...
  • alexnet代码matlab Sae-Pytorch 原来的 : 语义自动编码器(SAE)的PyTorch实现。 怎么跑 git克隆 下载“ awa_demo_data.mat” python sae.py 在PyTorch中实现SAE 设置CUB,AwA,aP&Y,SUN和ImageNet数据集。 部分...
  • 新浪SAE为广大开发者提供了一个低成本的应用开发环境,不需要太多的费用就可以利用新浪提供的强大的云计算服务器搭建自己的应用 一、安装Subclipse 安装Subclipse的最好方法是使用Eclipse Update Manager。在...
  • c代码-CRC8校验计算, 遵从SAE-J1850规范,多项式为0x11D。
  • sae 初步学习

    2019-09-25 14:47:21
    http://python.sinaapp.com/doc/quickstart.html#hello-world 上传好文件千万不要忘了设置回调页,OAuth2.0 授权设置。   转载于:https://www.cnblogs.com/marvin007/p/3499548.html...
  • 【ThinkPHP】SAE代码横跨性

    千次阅读 2012-05-13 13:24:37
    查看SAE的ThinkPHP完全开发手册,查看其中的代码跨越性建议。  其中有一条是关于数据库的。  大意是:对数据库的配置根据本地的和SAE分别配置。  在 /App/Conf/ 下有两个文件,config_sae.php和config.php。 ...
  • 最近一直在看Deep Learning,各类...只是跟着Andrew Ng的UFLDL tutorial写了些已有框架的代码(这部分的代码见github) 后来发现了一个matlab的Deep Learning的toolbox,发现其代码很简单,感觉比较适合用来学习算...
  • 简单的在新浪SAE应用的php代码,用于移动端简单服务器实用。移动应用开发
  • c代码-CRC8校验计算, 遵从SAE-J1850规范,多项式为0x11D。安全访问!
  • SAE-J1939源码

    2018-03-15 11:07:07
    SAE J1939源代码,包含4个文件:1939.c 1939.h J1939_Config.H readme
  • 基于SAE和Tornado的Python应用示例的CodeShare.tk的源代码: ://codeshare.tk ========= ##功能特性 用户可以匿名自由发布代码并设置管理密码进行修改或删除 ##应用部署 ##步骤1。 在SAE中创建Python应用 ##第...
  • 新浪SAE平台版本的Ueditro文本编辑器,主要根据SAE平台特性更改里面文件储存机制!目录下的code/config.php里可以设置文件接收的路径,另外这个是jquery版本的,需要导入Jquery.js

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,086
精华内容 3,234
关键字:

sae代码