全球领先的IT技术网站 |首页 |Tags |网站地图

您现在正在浏览:首页 » 开发频道 » 其他 » Deeplearning学习之路_第一章(Sparse Autoencoder)

RSS订阅

Deeplearning学习之路_第一章(Sparse Autoencoder)

暂无Tags标签
摘要:Deeplearning学习小结。

一些笔记:

前馈神经网络(feedforward network):

1.一个网络通常又若干层构成,每一层网络都有若干个神经元,在参数初始化之前,每一层的各个节点彼此无法区分,不知道以后“承担”怎样的任务;

2.参数随机初始化是使得对称失效,使得各个节点互相可以“区分”;

3.每个神经元接受到实数z作为输入,输出f(z),f是激活函数;

4.激活函数通常选择sigmoid或者tanh;

5.sigmoid函数的值域为(0,1),tanh的值域为(-1,1);

6.sigmoid函数的导数满足df=(1-f)*f,而tanh满足df=1-f^2;

7.神经网络中的参数较多,通常小样本的情况下容易出现过拟合(over fitting)的现象;

8.神经网络模型的损失函数是在每个样本上定义的损失的平均,通常会加上一些权重衰减项(原因?);

9.通常采用反向传播算法(backpropagation)求损失函数对每一个参数的偏导数;

10;计算偏导数的关键一步是求得2,3...,l层的delta值,由后向前,先求delta_l,再递推向前,反向传播因此得名;

11.含有参数的层数为1,2,...,l-1,公式为w_s=delta_(s+1)*Transpose(act_value_s), b_s=delta_(s+1);

 

梯度检验:

1.在算法实现的过程中,可能会由于疏忽引入缺位错误等细小的错误不容易被发觉;

2.利用df(x)~(f(x+eps)-f(x-eps))/(2*eps)的性质估计f在x附近的导数的的值与求出的精确值比较,在eps很小,通常10^-4方左右的时候,精确值和估计值之间的差值一般也有10^-4左右的精度;

 

稀疏自编码神经网络(Sparse AutoEncoder):

1.稀疏自编码神经网络,迫使一个含有一层隐单元层的神经网络去学习输入x的表达,输入单元与输出单元神经元个数相等,通常隐单元数目较少,这就意味着这个神经网络要在较少的隐单元中学习数据之间的压缩表示,并在输出层重构出自身的特征。

2.如果隐层的神经元数目比输入或输出层更多或者相当的时候,也可以给隐单元的添加一个稀疏性限制;

3.此时的稀疏性指的是,大多数的神经元在很多的时候都是被抑制的,用激活值表示神经元的活跃层度的话,激活值越低就代表神经元被抑制的比较多;

4.通过对普通前馈神经网络的损失函数中添加一个稀疏性惩罚项就可以得到自编码神经网络的损失函数;

5.惩罚项是惩罚系数与KL(p||p_hat)的乘积,p是期望的神经元的对于所有样本的平均的活跃程度,p_hat是实际的平均活跃程度,两者均为向量,维度为隐单元个数;

6.自编码神经网络学习结果类似于CPA;(记得在哪看到过在某种条件下,二者等价?)

 

稀疏自编码神经网络编程练习题:

matlab经验总结:

任何时候,尽量避免显示的循环,尽量利用matlab的强大的库函数提供的各式各样的矩阵的运算避免循环的产生,这将使得代码的效率得到大大的提升。

函数类:

1.randi([min,max],m,n) 在参数区间中均匀抽取一个m*n的向量

   randi(max) 默认[0,max]中抽一个

2.repmat(A,m,n) 理解为以A为元素构造m*n的矩阵,实际大小m_A*n_A*m*n

3.fprintf 格式化输出

4.disp 标准输出

5.A(:) 将矩阵A按列拼接化为列向量

6.符号函数 sign(x)

7.以某个多元函数和该函数某个变量为参数的函数,在调用时需要申明使用的变量,例如

[opttheta, cost] = minFunc( @(p) sparseAutoencoderCost(p, ...
                                   visibleSize, hiddenSize, ...
                                   lambda, sparsityParam, ...
                                   beta, patches), ...
                              theta, options);

8.C=[A B]或者[A,B] 矩阵合并

 

犯过的错:

1.matlab中自然对数为log而不是ln,其他log2和log10分别是以2为底和以10为底

2.求矩阵A中含有某一元素a的个数的语句sum(size(find(A==a)))-1,而不是sum((find(A==a))-1;(应该还有更简单的语句吧?)

 

实验代码(matlab):

train,m

  1. %% CS294A/CS294W Programming Assignment Starter Code  
  2.   
  3. %  Instructions  
  4. %  ------------  
  5. %   
  6. %  This file contains code that helps you get started on the  
  7. %  programming assignment. You will need to complete the code in sampleIMAGES.m,  
  8. %  sparseAutoencoderCost.m and computeNumericalGradient.m.   
  9. %  For the purpose of completing the assignment, you do not need to  
  10. %  change the code in this file.   
  11. %  
  12. %%======================================================================  
  13. %% STEP 0: Here we provide the relevant parameters values that will  
  14. %  allow your sparse autoencoder to get good filters; you do not need to   
  15. %  change the parameters below.  
  16.   
  17. visibleSize = 8*8;   % number of input units   
  18. hiddenSize = 25;     % number of hidden units   
  19. sparsityParam = 0.01;   % desired average activation of the hidden units.  
  20.                      % (This was denoted by the Greek alphabet rho, which looks like a lower-case "p",  
  21.              %  in the lecture notes).   
  22. lambda = 0.0001;     % weight decay parameter         
  23. beta = 3;            % weight of sparsity penalty term         
  24.   
  25. %%======================================================================  
  26. %% STEP 1: Implement sampleIMAGES  
  27. %  
  28. %  After implementing sampleIMAGES, the display_network command should  
  29. %  display a random sample of 200 patches from the dataset  
  30.   
  31. patches = sampleIMAGES;  
  32. display_network(patches(:,randi(size(patches,2),200,1)),8);  
  33.   
  34.   
  35. %  Obtain random parameters theta  
  36. theta = initializeParameters(hiddenSize, visibleSize);  
  37.   
  38. %%======================================================================  
  39. %% STEP 2: Implement sparseAutoencoderCost  
  40. %  
  41. %  You can implement all of the components (squared error cost, weight decay term,  
  42. %  sparsity penalty) in the cost function at once, but it may be easier to do   
  43. %  it step-by-step and run gradient checking (see STEP 3) after each step.  We   
  44. %  suggest implementing the sparseAutoencoderCost function using the following steps:  
  45. %  
  46. %  (a) Implement forward propagation in your neural network, and implement the   
  47. %      squared error term of the cost function.  Implement backpropagation to   
  48. %      compute the derivatives.   Then (using lambda=beta=0), run Gradient Checking   
  49. %      to verify that the calculations corresponding to the squared error cost   
  50. %      term are correct.  
  51. %  
  52. %  (b) Add in the weight decay term (in both the cost function and the derivative  
  53. %      calculations), then re-run Gradient Checking to verify correctness.   
  54. %  
  55. %  (c) Add in the sparsity penalty term, then re-run Gradient Checking to   
  56. %      verify correctness.  
  57. %  
  58. %  Feel free to change the training settings when debugging your  
  59. %  code.  (For example, reducing the training set size or   
  60. %  number of hidden units may make your code run faster; and setting beta   
  61. %  and/or lambda to zero may be helpful for debugging.)  However, in your   
  62. %  final submission of the visualized weights, please use parameters we   
  63. %  gave in Step 0 above.  
  64.   
  65. [cost, grad] = sparseAutoencoderCost(theta, visibleSize, hiddenSize, lambda, ...  
  66.                                      sparsityParam, beta, patches);  
  67.   
  68. %%======================================================================  
  69. % %% STEP 3: Gradient Checking  
  70. % %  
  71. % % Hint: If you are debugging your code, performing gradient checking on smaller models   
  72. % % and smaller training sets (e.g., using only 10 training examples and 1-2 hidden   
  73. % % units) may speed things up.  
  74. %   
  75. % % First, lets make sure your numerical gradient computation is correct for a  
  76. % % simple function.  After you have implemented computeNumericalGradient.m,  
  77. % % run the following:   
  78. % checkNumericalGradient();  
  79. %   
  80. % % Now we can use it to check your cost function and derivative calculations  
  81. % % for the sparse autoencoder.    
  82. % numgrad = computeNumericalGradient( @(x) sparseAutoencoderCost(x, visibleSize, ...  
  83. %                                                   hiddenSize, lambda, ...  
  84. %                                                   sparsityParam, beta, ...  
  85. %                                                   patches), theta);  
  86. %   
  87. % % Use this to visually compare the gradients side by side  
  88. % disp([numgrad grad]);   
  89. %   
  90. % % Compare numerically computed gradients with the ones obtained from backpropagation  
  91. % diff = norm(numgrad-grad)/norm(numgrad+grad);  
  92. % disp(diff); % Should be small. In our implementation, these values are  
  93. %             % usually less than 1e-9.  
  94. %   
  95. %             % When you got this working, Congratulations!!!   
  96.   
  97. %%======================================================================  
  98. %% STEP 4: After verifying that your implementation of  
  99. %  sparseAutoencoderCost is correct, You can start training your sparse  
  100. %  autoencoder with minFunc (L-BFGS).  
  101.   
  102. %  Randomly initialize the parameters  
  103. theta = initializeParameters(hiddenSize, visibleSize);  
  104.   
  105. %  Use minFunc to minimize the function  
  106. addpath minFunc/  
  107. options.Method = 'lbfgs'; % Here, we use L-BFGS to optimize our cost  
  108.                           % function. Generally, for minFunc to work, you  
  109.                           % need a function pointer with two outputs: the  
  110.                           % function value and the gradient. In our problem,  
  111.                           % sparseAutoencoderCost.m satisfies this.  
  112. options.maxIter = 400;    % Maximum number of iterations of L-BFGS to run   
  113. options.display = 'on';  
  114.   
  115.   
  116. [opttheta, cost] = minFunc( @(p) sparseAutoencoderCost(p, ...  
  117.                                    visibleSize, hiddenSize, ...  
  118.                                    lambda, sparsityParam, ...  
  119.                                    beta, patches), ...  
  120.                               theta, options);  
  121.   
  122. %%======================================================================  
  123. %% STEP 5: Visualization   
  124.   
  125. W1 = reshape(opttheta(1:hiddenSize*visibleSize), hiddenSize, visibleSize);  
  126. display_network(W1', 12);   
  127.   
  128. print -djpeg weights.jpg   % save the visualization to a file   

step.3在最后运行时注释掉了,因为之前检验过梯度计算,并没有问题了。在Ng的教程中提示到,在做梯度检验的时候,可以修改隐单元为1~2个,用10个样本做就可以了。

第一次检验的时候用全部的样本检验花了5400多秒的时间,后来优化了代码,将前向传播和后向传播的循环全部换成了矩阵的运算,并按照提示修改了参数和样本个数,

Elapsed time is 0.566967 seconds.完成了检验。

最后注释掉step.3后,代码的全部运行时间为Elapsed time is 64.899354 seconds.得到的结果如下:

sampleIMAGES.m

  1. function patches = sampleIMAGES()  
  2. % sampleIMAGES  
  3. % Returns 10000 patches for training  
  4.   
  5. load IMAGES;    % load images from disk   
  6. patchsize = 8;  % we'll use 8x8 patches   
  7. numpatches = 10000;  
  8.   
  9. % Initialize patches with zeros.  Your code will fill in this matrix--one  
  10. % column per patch, 10000 columns.   
  11. patches = zeros(patchsize*patchsize, numpatches);  
  12.   
  13. %% ---------- YOUR CODE HERE --------------------------------------  
  14. %  Instructions: Fill in the variable called "patches" using data   
  15. %  from IMAGES.    
  16. %    
  17. %  IMAGES is a 3D array containing 10 images  
  18. %  For instance, IMAGES(:,:,6) is a 512x512 array containing the 6th image,  
  19. %  and you can type "imagesc(IMAGES(:,:,6)), colormap gray;" to visualize  
  20. %  it. (The contrast on these images look a bit off because they have  
  21. %  been preprocessed using using "whitening."  See the lecture notes for  
  22. %  more details.) As a second example, IMAGES(21:30,21:30,1) is an image  
  23. %  patch corresponding to the pixels in the block (21,21) to (30,30) of  
  24. %  Image 1  
  25.   
  26. %used as a column pointer to fill in patches matrix  
  27. column = 0;  
  28.   
  29. %in order to speed up the code , an effective way is to decrease the times   
  30. %copying big image matrix. So I decide to ensure how many patches to get from   
  31. %each image before copying them.  
  32.   
  33. Random_select = randi([1,10],1,10000);  
  34. Times = zeros(1,10);  
  35.   
  36. %counts how many patchs to get from each image  
  37. for i=1:10  
  38.     Times(i) = sum(size(find(Random_select == i)))-1;  
  39. end  
  40.   
  41. for i=1:10  
  42.     Image=IMAGES(:,:,i);  
  43.     patch = R_Selectpatch(Image, patchsize, patchsize,Times(i));  
  44.     vector = patch2vec(patch);  
  45.     patches(:,column+1:column+Times(i)) = vector;  
  46.     column = column + Times(i);  
  47. end  
  48.       
  49. %% ---------------------------------------------------------------  
  50. % For the autoencoder to work well we need to normalize the data  
  51. % Specifically, since the output of the network is bounded between [0,1]  
  52. % (due to the sigmoid activation function), we have to make sure   
  53. % the range of pixel values is also bounded between [0,1]  
  54. patches = normalizeData(patches);  
  55.   
  56. end  
  57.   
  58.   
  59. %% ---------------------------------------------------------------  
  60. function patches = normalizeData(patches)  
  61.   
  62. % Squash data to [0.1, 0.9] since we use sigmoid as the activation  
  63. % function in the output layer  
  64.   
  65. % Remove DC (mean of images).   
  66. patches = bsxfun(@minus, patches, mean(patches));  
  67.   
  68. % Truncate to +/-3 standard deviations and scale to -1 to 1  
  69. pstd = 3 * std(patches(:));  
  70. patches = max(min(patches, pstd), -pstd) / pstd;  
  71.   
  72. % Rescale from [-1,1] to [0.1,0.9]  
  73. patches = (patches + 1) * 0.4 + 0.1;  
  74.   
  75. end  
  76. %% ---------------------------------------------------------------  
  77. function patch = R_Selectpatch(A, width, height,times)  
  78.   
  79. %for a big matrix A,this function randomly choice a number of times height*width patch which is a small matrix from A  
  80.   
  81. %a appropriate start point which lay on the upper left corner of the patch decides where to select a patch  
  82. %both posx and posy are 1*times vector,posx stand for x-coordinate and posy stand for y-coordinate  
  83. posx = randi([1,505],1,times);  
  84. posy = randi([1,505],1,times);  
  85.   
  86. %initialize for patch  
  87. patch = zeros(height, width, times);  
  88.   
  89. %'cut' times patch from A;  
  90. for i=1:times  
  91. patch(:,:,i) = A(posx(i):posx(i)+width-1,posy(i):posy(i)+height-1);  
  92. end  
  93. end  
  94. %% ---------------------------------------------------------------  
  95. function vector = patch2vec(patch)  
  96.   
  97. %convert an m*n matrix to a mn*1 matrix which is a column vector  
  98.   
  99. %get the size of the matrix  
  100. psize=size(patch);  
  101.   
  102. %fill in the zero vector with each column of patch  
  103. vector = zeros(psize(1)*psize(2),psize(3));  
  104.   
  105. for j=1:psize(3)  
  106. %     for i = 1:psize(2)  
  107. %         a=(i-1)*psize(1)+1;  
  108. %         b=i*psize(1);  
  109. %         vector(a:b,j) = patch(:,i,j);  
  110. %     end  
  111.     t = patch (:,:,j);  
  112.     vector(:,j) = t (:);  
  113. end  
  114. end  

以上代码完成的事情是从10张512*512的图片中随机抽取8*8的像素块共计10000个,作为训练样本;

 

sparseAutoencoderCost.m

  1. function [cost,grad] = sparseAutoencoderCost(theta, visibleSize, hiddenSize, ...  
  2.                                              lambda, sparsityParam, beta, data)  
  3.   
  4. % visibleSize: the number of input units (probably 64)   
  5. % hiddenSize: the number of hidden units (probably 25)   
  6. % lambda: weight decay parameter  
  7. % sparsityParam: The desired average activation for the hidden units (denoted in the lecture  
  8. %                           notes by the greek alphabet rho, which looks like a lower-case "p").  
  9. % beta: weight of sparsity penalty term  
  10. % data: Our 64x10000 matrix containing the training data.  So, data(:,i) is the i-th training example.   
  11.     
  12. % The input theta is a vector (because minFunc expects the parameters to be a vector).   
  13. % We first convert theta to the (W1, W2, b1, b2) matrix/vector format, so that this   
  14. % follows the notation convention of the lecture notes.   
  15.   
  16. W1 = reshape(theta(1:hiddenSize*visibleSize), hiddenSize, visibleSize);  
  17. W2 = reshape(theta(hiddenSize*visibleSize+1:2*hiddenSize*visibleSize), visibleSize, hiddenSize);  
  18. b1 = theta(2*hiddenSize*visibleSize+1:2*hiddenSize*visibleSize+hiddenSize);  
  19. b2 = theta(2*hiddenSize*visibleSize+hiddenSize+1:end);  
  20.   
  21. % Cost and gradient variables (your code needs to compute these values).   
  22. % Here, we initialize them to zeros.   
  23. cost = 0;  
  24. W1grad = zeros(size(W1));   
  25. W2grad = zeros(size(W2));  
  26. b1grad = zeros(size(b1));   
  27. b2grad = zeros(size(b2));  
  28.   
  29. %% ---------- YOUR CODE HERE --------------------------------------  
  30. %  Instructions: Compute the cost/optimization objective J_sparse(W,b) for the Sparse Autoencoder,  
  31. %                and the corresponding gradients W1grad, W2grad, b1grad, b2grad.  
  32. %  
  33. % W1grad, W2grad, b1grad and b2grad should be computed using backpropagation.  
  34. % Note that W1grad has the same dimensions as W1, b1grad has the same dimensions  
  35. % as b1, etc.  Your code should set W1grad to be the partial derivative of J_sparse(W,b) with  
  36. % respect to W1.  I.e., W1grad(i,j) should be the partial derivative of J_sparse(W,b)   
  37. % with respect to the input parameter W1(i,j).  Thus, W1grad should be equal to the term   
  38. % [(1/m) \Delta W^{(1)} + \lambda W^{(1)}] in the last block of pseudo-code in Section 2.2   
  39. % of the lecture notes (and similarly for W2grad, b1grad, b2grad).  
  40. %   
  41. % Stated differently, if we were using batch gradient descent to optimize the parameters,  
  42. % the gradient descent update to W1 would be W1 := W1 - alpha * W1grad, and similarly for W2, b1, b2.   
  43. %   
  44.   
  45. [~,m] = size(data);  
  46.   
  47.   
  48. %initialize active value act and defference value delta to zero  
  49. act = zeros(hiddenSize+visibleSize,m);  
  50. delta = zeros(hiddenSize+visibleSize,m);  
  51.   
  52.   
  53. % for i=1:m %use forward propagation to get act value  
  54. %     act(1:hiddenSize,i) = sigmoid(W1*data(:,i)+b1);  
  55. %     act(hiddenSize+1:hiddenSize+visibleSize,i) = sigmoid(W2*act(1:hiddenSize,i)+b2);  
  56. % end  
  57.   
  58.   
  59. %use forward propagation to get act value  
  60. act(1:hiddenSize,:) = sigmoid(W1*data+repmat(b1,1,m));  
  61. act(hiddenSize+1:hiddenSize+visibleSize,:) = sigmoid(W2*act(1:hiddenSize,:)+repmat(b2,1,m));  
  62.   
  63. %p_hat  
  64. p_hat = 1/m*sum(act(1:hiddenSize,:)')';  
  65. p = sparsityParam*ones(hiddenSize,1);  
  66.   
  67. %backpropagation  
  68. % for i=1:m  
  69. %     delta(hiddenSize+1:hiddenSize+visibleSize,1) = -(data(:,i)-...  
  70. %         act(hiddenSize+1:hiddenSize+visibleSize,i)).*d_sigmoid(W2*act(1:hiddenSize,i)+b2);  
  71. %     delta(1:hiddenSize,1) = ...  
  72. %          (W2'*delta(hiddenSize+1:hiddenSize+visibleSize,1)...  
  73. %          + beta*D_KL_div(p,p_hat))...  
  74. %          .*d_sigmoid(W1*data(:,i)+b1);  
  75. %     W1grad = W1grad + delta(1:hiddenSize,1)*data(:,i)';  
  76. %     W2grad = W2grad + delta(hiddenSize+1:hiddenSize+visibleSize,1)*act(1:hiddenSize,i)';  
  77. %     b1grad = b1grad + delta(1:hiddenSize,1);  
  78. %     b2grad = b2grad + delta(hiddenSize+1:hiddenSize+visibleSize,1);  
  79. % end  
  80.   
  81. %backpropagation  
  82. delta(hiddenSize+1:hiddenSize+visibleSize,:) = -(data-...  
  83. act(hiddenSize+1:hiddenSize+visibleSize,:)).*d_sigmoid(W2*act(1:hiddenSize,:)+repmat(b2,1,m));  
  84. delta(1:hiddenSize,:) = ...  
  85.          (W2'*delta(hiddenSize+1:hiddenSize+visibleSize,:)...  
  86.          + repmat(beta*D_KL_div(p,p_hat),1,m))...  
  87.          .*d_sigmoid(W1*data+repmat(b1,1,m));  
  88. W1grad = 1/m*(delta(1:hiddenSize,:)*data')+lambda*W1;  
  89. W2grad = 1/m*(delta(hiddenSize+1:hiddenSize+visibleSize,:)*act(1:hiddenSize,:)')+lambda*W2;  
  90. b1grad = 1/m*(sum(delta(1:hiddenSize,:)')');  
  91. b2grad = 1/m*(sum(delta(hiddenSize+1:hiddenSize+visibleSize,:)')');  
  92.   
  93.   
  94. cost = 1/m*0.5*norm(act(hiddenSize+1:hiddenSize+visibleSize,:) - data,'fro')^2+...  
  95.     0.5*lambda*(norm(W1,'fro')^2+norm(W2,'fro')^2) + beta*sum(KL_div(p,p_hat));  
  96.           
  97. %-------------------------------------------------------------------  
  98. % After computing the cost and gradient, we will convert the gradients back  
  99. % to a vector format (suitable for minFunc).  Specifically, we will unroll  
  100. % your gradient matrices into a vector.  
  101.   
  102. grad = [W1grad(:) ; W2grad(:) ; b1grad(:) ; b2grad(:)];  
  103.   
  104. end  
  105.   
  106. %-------------------------------------------------------------------  
  107. % Here's an implementation of the sigmoid function, which you may find useful  
  108. % in your computation of the costs and the gradients.  This inputs a (row or  
  109. % column) vector (say (z1, z2, z3)) and returns (f(z1), f(z2), f(z3)).   
  110.   
  111. function sigm = sigmoid(x)  
  112.     
  113.     sigm = 1 ./ (1 + exp(-x));  
  114. end  
  115.   
  116. %-------------------------------------------------------------------  
  117. %Here's an implementation of the derivative of the sigmoid function  
  118.   
  119. function d_sigm = d_sigmoid(x)  
  120.   
  121.     d_sigm = sigmoid(x).*(1-sigmoid(x));  
  122.       
  123. end  
  124.   
  125. %-------------------------------------------------------------------  
  126. %Here's an implementation of the derivative of the KL divergence function  
  127.   
  128. function KL = KL_div(x,y)  
  129.     KL = x.*log(x./y)+(1-x).*log((1-x)./(1-y));  
  130. end  
  131.   
  132. %-------------------------------------------------------------------  
  133. %Here's an implementation of the derivative of the partial derivative of   
  134. %KL divergence function respect to y  
  135.   
  136. function D_KL = D_KL_div(x,y)  
  137.     D_KL = -x./y+(1-x)./(1-y);  
  138. end  
  139.       

计算给定参数点和样本下,损失函数的值以及关于参数的梯度;

 

computeNumericalGrad.m

  1. function numgrad = computeNumericalGradient(J, theta)  
  2. % numgrad = computeNumericalGradient(J, theta)  
  3. % theta: a vector of parameters  
  4. % J: a function that outputs a real-number. Calling y = J(theta) will return the  
  5. % function value at theta.   
  6.     
  7. % Initialize numgrad with zeros  
  8. numgrad = zeros(size(theta));  
  9.   
  10. %% ---------- YOUR CODE HERE --------------------------------------  
  11. % Instructions:   
  12. % Implement numerical gradient checking, and return the result in numgrad.    
  13. % (See Section 2.3 of the lecture notes.)  
  14. % You should write code so that numgrad(i) is (the numerical approximation to) the   
  15. % partial derivative of J with respect to the i-th input argument, evaluated at theta.    
  16. % I.e., numgrad(i) should be the (approximately) the partial derivative of J with   
  17. % respect to theta(i).  
  18. %                  
  19. % Hint: You will probably want to compute the elements of numgrad one at a time.   
  20.   
  21. %EPSILON = 10^-4  
  22. eps = 10^-4;  
  23.   
  24. [m,~] = size(theta);  
  25.   
  26. %use 1/(2*eps)*(J(theta_1,...theta_i+eps,...theta_m)-J(theta_1,...theta_i-eps,...theta_m)) to estimate dJ/dtheta_i   
  27. for i=1:m  
  28.     theta_p = theta;  
  29.     theta_p(i,:) = theta_p(i,:) + eps;  
  30.     theta_m = theta;  
  31.     theta_m(i,:) = theta_m(i,:) - eps;  
  32.     numgrad(i,:) = 1/(2*eps)*(J(theta_p) - J(theta_m));  
  33. end  
  34.   
  35.   
  36.   
  37.   
  38. %% ---------------------------------------------------------------  
  39. end  

计算梯度的估计值.

0 »

开发专题

JavaScript成为网络霸主的“绯闻”
JavaScript成为网络霸主的“绯闻”

JavaScript正凭借新型工具与功能提升以极度夸张的速度吞噬整个世界。我们是否应该接受这一无法逆转的趋势? 还记得那些旧日往事吗?很多用户因为担心安全问题而在浏览器中禁用JavaScript。如...

C++是垃圾语言?!
C++是垃圾语言?!

Linux之父对C++进行了炮轰,说它是糟糕程序员的垃圾语言,可谓是一石激起千层浪,引起众多程序员朋友的关注和讨论。本专题给出正反方的讨论观点,供大家评说!另外,给出了编程语言的发展状况...

MySQL数据库入门与精通
MySQL数据库入门与精通

MySQL是一个跨平台的开源关系型数据库管理系统,目前MySQL被广泛地应用在Internet上的中小型网站中。由于其体积小、速度快、总体拥有成本低,尤其是开放源码这一特点,许多中小型网站为了降低...

最新资讯

相关热门文章

  • 本文暂无Tags标签