comparison toolboxes/FullBNT-1.0.7/netlab3.3/demopt1.m @ 0:e9a9cd732c1e tip

first hg version after svn

+function demopt1(xinit)
+%DEMOPT1 Demonstrate different optimisers on Rosenbrock's function.
+%
+%	Description
+%	The four general optimisers (quasi-Newton, conjugate gradients,
+%	scaled conjugate gradients, and gradient descent) are applied to the
+%	minimisation of Rosenbrock's well known `banana' function. Each
+%	optimiser is run for at most 100 cycles, and a stopping criterion of
+%	1.0e-4 is used for both position and function value. At the end, the
+%	trajectory of each algorithm is shown on a contour plot of the
+%	function.
+%
+%	DEMOPT1(XINIT) allows the user to specify a row vector with two
+%	columns as the starting point.  The default is the point [-1 1]. Note
+%	that the contour plot has an x range of [-1.5, 1.5] and a y range of
+%	[-0.5, 2.1], so it is best to choose a starting point in the same
+%	region.
+%
+%	See also
+%	CONJGRAD, GRADDESC, QUASINEW, SCG, ROSEN, ROSEGRAD
+%
+
+%	Copyright (c) Ian T Nabney (1996-2001)
+
+% Initialise start point for search
+if nargin < 1 | size(xinit) ~= [1 2]
+  xinit = [-1 1];	% Traditional start point
+end
+
+% Find out if flops is available (i.e. pre-version 6 Matlab)
+v = version;
+if (str2num(strtok(v, '.')) >= 6)
+    flops_works = logical(0);
+else
+    flops_works = logical(1);
+end
+
+% Set up options
+options = foptions;	% Standard options
+options(1) = -1; 	% Turn off printing completely
+options(3) = 1e-8; 	% Tolerance in value of function
+options(14) = 100;  	% Max. 100 iterations of algorithm
+
+clc
+disp('This demonstration compares the performance of four generic')
+disp('optimisation routines when finding the minimum of Rosenbrock''s')
+disp('function y = 100*(x2-x1^2)^2 + (1-x1)^2.')
+disp(' ')
+disp('The global minimum of this function is at [1 1].')
+disp(['Each algorithm starts at the point [' num2str(xinit(1))...
+	' ' num2str(xinit(2)) '].'])
+disp(' ')
+disp('Press any key to continue.')
+pause 
+
+% Generate a contour plot of the function
+a = -1.5:.02:1.5;
+b = -0.5:.02:2.1;
+[A, B] = meshgrid(a, b);
+Z = rosen([A(:), B(:)]);
+Z = reshape(Z, length(b), length(a));
+l = -1:6;
+v = 2.^l;
+fh1 = figure;
+contour(a, b, Z, v)
+title('Contour plot of Rosenbrock''s function')
+hold on
+
+clc
+disp('We now use quasi-Newton, conjugate gradient, scaled conjugate')
+disp('gradient, and gradient descent with line search algorithms')
+disp('to find a local minimum of this function.  Each algorithm is stopped')
+disp('when 100 cycles have elapsed, or if the change in function value')
+disp('is less than 1.0e-8 or the change in the input vector is less than')
+disp('1.0e-4 in magnitude.')
+disp(' ')
+disp('Press any key to continue.')
+pause
+
+clc
+x = xinit;
+flops(0)
+[x, options, errlog, pointlog] = quasinew('rosen', x, options, 'rosegrad');
+fprintf(1, 'For quasi-Newton method:\n')
+fprintf(1, 'Final point is (%f, %f), value is %f\n', x(1), x(2), options(8))
+fprintf(1, 'Number of function evaluations is %d\n', options(10))
+fprintf(1, 'Number of gradient evaluations is %d\n', options(11))
+if flops_works
+    opt_flops = flops;
+    fprintf(1, 'Number of floating point operations is %d\n', opt_flops)
+end
+fprintf(1, 'Number of cycles is %d\n', size(pointlog, 1) - 1);
+disp(' ')
+
+x = xinit;
+flops(0)
+[x, options, errlog2, pointlog2] = conjgrad('rosen', x, options, 'rosegrad');
+fprintf(1, 'For conjugate gradient method:\n')
+fprintf(1, 'Final point is (%f, %f), value is %f\n', x(1), x(2), options(8))
+fprintf(1, 'Number of function evaluations is %d\n', options(10))
+fprintf(1, 'Number of gradient evaluations is %d\n', options(11))
+if flops_works
+    opt_flops = flops;
+    fprintf(1, 'Number of floating point operations is %d\n', ...
+	opt_flops)
+end
+fprintf(1, 'Number of cycles is %d\n', size(pointlog2, 1) - 1);
+disp(' ')
+
+x = xinit;
+flops(0)
+[x, options, errlog3, pointlog3] = scg('rosen', x, options, 'rosegrad');
+fprintf(1, 'For scaled conjugate gradient method:\n')
+fprintf(1, 'Final point is (%f, %f), value is %f\n', x(1), x(2), options(8))
+fprintf(1, 'Number of function evaluations is %d\n', options(10))
+fprintf(1, 'Number of gradient evaluations is %d\n', options(11))
+if flops_works
+    opt_flops = flops;
+    fprintf(1, 'Number of floating point operations is %d\n', opt_flops)
+end
+fprintf(1, 'Number of cycles is %d\n', size(pointlog3, 1) - 1);
+disp(' ')
+
+x = xinit;
+options(7) = 1; % Line minimisation used
+flops(0)
+[x, options, errlog4, pointlog4] = graddesc('rosen', x, options, 'rosegrad');
+fprintf(1, 'For gradient descent method:\n')
+fprintf(1, 'Final point is (%f, %f), value is %f\n', x(1), x(2), options(8))
+fprintf(1, 'Number of function evaluations is %d\n', options(10))
+fprintf(1, 'Number of gradient evaluations is %d\n', options(11))
+if flops_works
+    opt_flops = flops;
+    fprintf(1, 'Number of floating point operations is %d\n', opt_flops)
+end
+fprintf(1, 'Number of cycles is %d\n', size(pointlog4, 1) - 1);
+disp(' ')
+disp('Note that gradient descent does not reach a local minimum in')
+disp('100 cycles.')
+disp(' ')
+disp('On this problem, where the function is cheap to evaluate, the')
+disp('computational effort is dominated by the algorithm overhead.')
+disp('However on more complex optimisation problems (such as those')
+disp('involving neural networks), computational effort is dominated by')
+disp('the number of function and gradient evaluations.  Counting these,')
+disp('we can rank the algorithms: quasi-Newton (the best), conjugate')
+disp('gradient, scaled conjugate gradient, gradient descent (the worst)')
+disp(' ')
+disp('Press any key to continue.')
+pause
+clc
+disp('We now plot the trajectory of search points for each algorithm')
+disp('superimposed on the contour plot.')
+disp(' ')
+disp('Press any key to continue.')
+pause
+plot(pointlog4(:,1), pointlog4(:,2), 'bd', 'MarkerSize', 6)
+plot(pointlog3(:,1), pointlog3(:,2), 'mx', 'MarkerSize', 6, 'LineWidth', 2)
+plot(pointlog(:,1), pointlog(:,2), 'k.', 'MarkerSize', 18)
+plot(pointlog2(:,1), pointlog2(:,2), 'g+', 'MarkerSize', 6, 'LineWidth', 2)
+lh = legend(  'Gradient Descent', 'Scaled Conjugate Gradients', ...
+  'Quasi Newton', 'Conjugate Gradients');
+
+hold off
+
+clc
+disp('Press any key to end.')
+pause
+close(fh1);
+clear all;