訓練演算法

❶ 大二本科生怎樣訓練演算法和代碼能力

大學生的空閑時間是非常多的，但是大學的課程只是能讓你知道皮毛。建議大二的學生可以去專業教授編程的課外班進行系統的學習。或者展開自學，並且在練習的過程中訓練自己的演算法和寫代碼的能力。

• 到底應該學什麼語言？

隨著科技的發展，學習編程IT行業的人越來越多，但是很多人在第一開始就處於迷茫的階段，那就是，我到底應該學習什麼語言？我的答案是，什麼流行學什麼，什麼有發展性賺錢多就學什麼。流行的語言能讓你更順利的找到工作，比如現在流行的就是JAVA語言等。

• 如何寫好代碼？

當然是練習，沒有比練習更能讓你成長的方式了，但是練習過程中也要花費大量時間去審視自己寫好的代碼，並且要動腦子，要思考，如何寫的更精簡，而不是直接用又臭又長的代碼充數；其次是理解，透過對問題與所使用的語言、框架越加理解，越能寫的簡單易懂。

❷ matlab BP神經網路的訓練演算法中訓練函數（traingdm 、trainlm、trainbr）的實現過程及相應的VC源代碼

VC源代碼？你很搞笑嘛。。
給你trainlm的m碼

function [out1,out2] = trainlm(varargin)
%TRAINLM Levenberg-Marquardt backpropagation.
%
% <a href="matlab:doc trainlm">trainlm</a> is a network training function that updates weight and
% bias states according to Levenberg-Marquardt optimization.
%
% <a href="matlab:doc trainlm">trainlm</a> is often the fastest backpropagation algorithm in the toolbox,
% and is highly recommended as a first choice supervised algorithm,
% although it does require more memory than other algorithms.
%
% [NET,TR] = <a href="matlab:doc trainlm">trainlm</a>(NET,X,T) takes a network NET, input data X
% and target data T and returns the network after training it, and a
% a training record TR.
%
% [NET,TR] = <a href="matlab:doc trainlm">trainlm</a>(NET,X,T,Xi,Ai,EW) takes additional optional
% arguments suitable for training dynamic networks and training with
% error weights. Xi and Ai are the initial input and layer delays states
% respectively and EW defines error weights used to indicate
% the relative importance of each target value.
%
% Training occurs according to training parameters, with default values.
% Any or all of these can be overridden with parameter name/value argument
% pairs appended to the input argument list, or by appending a structure
% argument with fields having one or more of these names.
% show 25 Epochs between displays
% showCommandLine 0 generate command line output
% showWindow 1 show training GUI
% epochs 100 Maximum number of epochs to train
% goal 0 Performance goal
% max_fail 5 Maximum validation failures
% min_grad 1e-10 Minimum performance gradient
% mu 0.001 Initial Mu
% mu_dec 0.1 Mu decrease factor
% mu_inc 10 Mu increase factor
% mu_max 1e10 Maximum Mu
% time inf Maximum time to train in seconds
%
% To make this the default training function for a network, and view
% and/or change parameter settings, use these two properties:
%
% net.<a href="matlab:doc nnproperty.net_trainFcn">trainFcn</a> = 'trainlm';
% net.<a href="matlab:doc nnproperty.net_trainParam">trainParam</a>
%
% See also trainscg, feedforwardnet, narxnet.

% Mark Beale, 11-31-97, ODJ 11/20/98
% Updated by Orlando De Jes鷖, Martin Hagan, Dynamic Training 7-20-05
% Copyright 1992-2010 The MathWorks, Inc.
% $Revision: 1.1.6.11.2.2 $ $Date: 2010/07/23 15:40:16 $

%% =======================================================
% BOILERPLATE_START
% This code is the same for all Training Functions.

persistent INFO;
if isempty(INFO), INFO = get_info; end
nnassert.minargs(nargin,1);
in1 = varargin{1};
if ischar(in1)
switch (in1)
case 'info'
out1 = INFO;
case 'check_param'
nnassert.minargs(nargin,2);
param = varargin{2};
err = nntest.param(INFO.parameters,param);
if isempty(err)
err = check_param(param);
end
if nargout > 0
out1 = err;
elseif ~isempty(err)
nnerr.throw('Type',err);
end
otherwise,
try
out1 = eval(['INFO.' in1]);
catch me, nnerr.throw(['Unrecognized first argument: ''' in1 ''''])
end
end
return
end
nnassert.minargs(nargin,2);
net = nn.hints(nntype.network('format',in1,'NET'));
oldTrainFcn = net.trainFcn;
oldTrainParam = net.trainParam;
if ~strcmp(net.trainFcn,mfilename)
net.trainFcn = mfilename;
net.trainParam = INFO.defaultParam;
end
[args,param] = nnparam.extract_param(varargin(2:end),net.trainParam);
err = nntest.param(INFO.parameters,param);
if ~isempty(err), nnerr.throw(nnerr.value(err,'NET.trainParam')); end
if INFO.isSupervised && isempty(net.performFcn) % TODO - fill in MSE
nnerr.throw('Training function is supervised but NET.performFcn is undefined.');
end
if INFO.usesGradient && isempty(net.derivFcn) % TODO - fill in
nnerr.throw('Training function uses derivatives but NET.derivFcn is undefined.');
end
if net.hint.zeroDelay, nnerr.throw('NET contains a zero-delay loop.'); end
[X,T,Xi,Ai,EW] = nnmisc.defaults(args,{},{},{},{},{1});
X = nntype.data('format',X,'Inputs X');
T = nntype.data('format',T,'Targets T');
Xi = nntype.data('format',Xi,'Input states Xi');
Ai = nntype.data('format',Ai,'Layer states Ai');
EW = nntype.nndata_pos('format',EW,'Error weights EW');
% Prepare Data
[net,data,tr,~,err] = nntraining.setup(net,mfilename,X,Xi,Ai,T,EW);
if ~isempty(err), nnerr.throw('Args',err), end
% Train
net = struct(net);
fcns = nn.subfcns(net);
[net,tr] = train_network(net,tr,data,fcns,param);
tr = nntraining.tr_clip(tr);
if isfield(tr,'perf')
tr.best_perf = tr.perf(tr.best_epoch+1);
end
if isfield(tr,'vperf')
tr.best_vperf = tr.vperf(tr.best_epoch+1);
end
if isfield(tr,'tperf')
tr.best_tperf = tr.tperf(tr.best_epoch+1);
end
net.trainFcn = oldTrainFcn;
net.trainParam = oldTrainParam;
out1 = network(net);
out2 = tr;
end

% BOILERPLATE_END
%% =======================================================

% TODO - MU => MU_START
% TODO - alternate parameter names (i.e. MU for MU_START)

function info = get_info()
info = nnfcnTraining(mfilename,'Levenberg-Marquardt',7.0,true,true,...
[ ...
nnetParamInfo('showWindow','Show Training Window Feedback','nntype.bool_scalar',true,...
'Display training window ring training.'), ...
nnetParamInfo('showCommandLine','Show Command Line Feedback','nntype.bool_scalar',false,...
'Generate command line output ring training.'), ...
nnetParamInfo('show','Command Line Frequency','nntype.strict_pos_int_inf_scalar',25,...
'Frequency to update command line.'), ...
...
nnetParamInfo('epochs','Maximum Epochs','nntype.pos_int_scalar',1000,...
'Maximum number of training iterations before training is stopped.'), ...
nnetParamInfo('time','Maximum Training Time','nntype.pos_inf_scalar',inf,...
'Maximum time in seconds before training is stopped.'), ...
...
nnetParamInfo('goal','Performance Goal','nntype.pos_scalar',0,...
'Performance goal.'), ...
nnetParamInfo('min_grad','Minimum Gradient','nntype.pos_scalar',1e-5,...
'Minimum performance gradient before training is stopped.'), ...
nnetParamInfo('max_fail','Maximum Validation Checks','nntype.strict_pos_int_scalar',6,...
'Maximum number of validation checks before training is stopped.'), ...
...
nnetParamInfo('mu','Mu','nntype.pos_scalar',0.001,...
'Mu.'), ...
nnetParamInfo('mu_dec','Mu Decrease Ratio','nntype.real_0_to_1',0.1,...
'Ratio to decrease mu.'), ...
nnetParamInfo('mu_inc','Mu Increase Ratio','nntype.over1',10,...
'Ratio to increase mu.'), ...
nnetParamInfo('mu_max','Maximum mu','nntype.strict_pos_scalar',1e10,...
'Maximum mu before training is stopped.'), ...
], ...
[ ...
nntraining.state_info('gradient','Gradient','continuous','log') ...
nntraining.state_info('mu','Mu','continuous','log') ...
nntraining.state_info('val_fail','Validation Checks','discrete','linear') ...
]);
end

function err = check_param(param)
err = '';
end

function [net,tr] = train_network(net,tr,data,fcns,param)

% Checks
if isempty(net.performFcn)
warning('nnet:trainlm:Performance',nnwarning.empty_performfcn_corrected);
net.performFcn = 'mse';
net.performParam = mse('defaultParam');
tr.performFcn = net.performFcn;
tr.performParam = net.performParam;
end
if isempty(strmatch(net.performFcn,{'sse','mse'},'exact'))
warning('nnet:trainlm:Performance',nnwarning.nonjacobian_performfcn_replaced);
net.performFcn = 'mse';
net.performParam = mse('defaultParam');
tr.performFcn = net.performFcn;
tr.performParam = net.performParam;
end

% Initialize
startTime = clock;
original_net = net;
[perf,vperf,tperf,je,jj,gradient] = nntraining.perfs_jejj(net,data,fcns);
[best,val_fail] = nntraining.validation_start(net,perf,vperf);
WB = getwb(net);
lengthWB = length(WB);
ii = sparse(1:lengthWB,1:lengthWB,ones(1,lengthWB));
mu = param.mu;

% Training Record
tr.best_epoch = 0;
tr.goal = param.goal;
tr.states = {'epoch','time','perf','vperf','tperf','mu','gradient','val_fail'};

% Status
status = ...
[ ...
nntraining.status('Epoch','iterations','linear','discrete',0,param.epochs,0), ...
nntraining.status('Time','seconds','linear','discrete',0,param.time,0), ...
nntraining.status('Performance','','log','continuous',perf,param.goal,perf) ...
nntraining.status('Gradient','','log','continuous',gradient,param.min_grad,gradient) ...
nntraining.status('Mu','','log','continuous',mu,param.mu_max,mu) ...
nntraining.status('Validation Checks','','linear','discrete',0,param.max_fail,0) ...
];
nn_train_feedback('start',net,status);

% Train
for epoch = 0:param.epochs

% Stopping Criteria
current_time = etime(clock,startTime);
[userStop,userCancel] = nntraintool('check');
if userStop, tr.stop = 'User stop.'; net = best.net;
elseif userCancel, tr.stop = 'User cancel.'; net = original_net;
elseif (perf <= param.goal), tr.stop = 'Performance goal met.'; net = best.net;
elseif (epoch == param.epochs), tr.stop = 'Maximum epoch reached.'; net = best.net;
elseif (current_time >= param.time), tr.stop = 'Maximum time elapsed.'; net = best.net;
elseif (gradient <= param.min_grad), tr.stop = 'Minimum gradient reached.'; net = best.net;
elseif (mu >= param.mu_max), tr.stop = 'Maximum MU reached.'; net = best.net;
elseif (val_fail >= param.max_fail), tr.stop = 'Validation stop.'; net = best.net;
end

% Feedback
tr = nntraining.tr_update(tr,[epoch current_time perf vperf tperf mu gradient val_fail]);
nn_train_feedback('update',net,status,tr,data, ...
[epoch,current_time,best.perf,gradient,mu,val_fail]);

% Stop
if ~isempty(tr.stop), break, end

% Levenberg Marquardt
while (mu <= param.mu_max)
% CHECK FOR SINGULAR MATRIX
[msgstr,msgid] = lastwarn;
lastwarn('MATLAB:nothing','MATLAB:nothing')
warnstate = warning('off','all');
dWB = -(jj+ii*mu) \ je;
[~,msgid1] = lastwarn;
flag_inv = isequal(msgid1,'MATLAB:nothing');
if flag_inv, lastwarn(msgstr,msgid); end;
warning(warnstate)
WB2 = WB + dWB;
net2 = setwb(net,WB2);
perf2 = nntraining.train_perf(net2,data,fcns);

% TODO - possible speed enhancement
% - retain intermediate variables for Memory Rection = 1

if (perf2 < perf) && flag_inv
WB = WB2; net = net2;
mu = max(mu*param.mu_dec,1e-20);
break
end
mu = mu * param.mu_inc;
end

% Validation
[perf,vperf,tperf,je,jj,gradient] = nntraining.perfs_jejj(net,data,fcns);
[best,tr,val_fail] = nntraining.validation(best,tr,val_fail,net,perf,vperf,epoch);
end
end

❸ knn演算法的訓練數據集需要多大

這個不一定。之所以要分訓練集和測試集是因為怕過度擬合（overfitting），所以需要一個測試集來檢驗確定 你建立的模型並不只是適合於這一組數據。我一般都是70%訓練集30%測試集。當然，得看數據量有多大，以及復雜程度。只要訓練集>=測試集，就不會錯，但好不好得具體分析。如果數據量在1000以下的話，最好是k折交叉驗證（基本上只要不是特別復雜的數據，都推薦k折交叉驗證）。如果要是數據量大於10萬的話，最好考慮80：20甚至90:10。

❹ 有哪些可以訓練演算法設計的網站

如果想要提高演算法，還是要從最基本的練起，codeforces上去找被過次數多的題先做，當感覺編碼很快那些都很輕松，就去在規定時間做模擬比賽，另外，建議提高演算法要按照專題來，去找專題，一般網上都有題號，甚至連難度有的人都標明了，對於各種oj，我要推薦我科的，hust oj，這個可以知道題號，自己掛載相應的題目，進行訓練，你也可以查下相關的專題名稱，搜索一下別人曾掛過的練習，你再做一遍，網上推薦的題目基本上都是有解題報告的，做不出來去看解題報告，hust oj上有些人也將提交的代碼開源了，總之，hust vjudge對於想學習演算法的同學是很不錯的選擇。

❺ 在神經網路演算法當中提到的在線訓練和離線訓練分別是什麼意思

在線訓練的話數據是實時過來的。所採用的演算法必須得考慮這種實時性。而離線的話數據都已得到，即不會隨著時間的變化有新的數據到來

❻ 演算法訓練難學嗎

這個是看你的時候如果你對演算法很有興趣的話，那麼學演算法學起來是非常有趣的一件事，如果你對演算法沒有興趣，那麼學演算法你將會非常的痛苦。當然，如果你的數學基礎還有邏輯思維很好的話，學演算法也是比較簡單的！

❼ Hopfield 神經網路有哪幾種訓練方法

人工神經網路模型主要考慮網路連接的拓撲結構、神經元的特徵、學習規則等。目前，已有近40種神經網路模型，其中有反傳網路、感知器、自組織映射、Hopfield網路、波耳茲曼機、適應諧振理論等。根據連接的拓撲結構，神經網路模型可以分為：

（1）前向網路 網路中各個神經元接受前一級的輸入，並輸出到下一級，網路中沒有反饋，可以用一個有向無環路圖表示。這種網路實現信號從輸入空間到輸出空間的變換，它的信息處理能力來自於簡單非線性函數的多次復合。網路結構簡單，易於實現。反傳網路是一種典型的前向網路。

（2）反饋網路 網路內神經元間有反饋，可以用一個無向的完備圖表示。這種神經網路的信息處理是狀態的變換，可以用動力學系統理論處理。系統的穩定性與聯想記憶功能有密切關系。Hopfield網路、波耳茲曼機均屬於這種類型。

學習是神經網路研究的一個重要內容，它的適應性是通過學習實現的。根據環境的變化，對權值進行調整，改善系統的行為。由Hebb提出的Hebb學習規則為神經網路的學習演算法奠定了基礎。Hebb規則認為學習過程最終發生在神經元之間的突觸部位，突觸的聯系強度隨著突觸前後神經元的活動而變化。在此基礎上，人們提出了各種學習規則和演算法，以適應不同網路模型的需要。有效的學習演算法，使得神經網路能夠通過連接權值的調整，構造客觀世界的內在表示，形成具有特色的信息處理方法，信息存儲和處理體現在網路的連接中。
根據學習環境不同，神經網路的學習方式可分為監督學習和非監督學習。在監督學習中，將訓練樣本的數據加到網路輸入端，同時將相應的期望輸出與網路輸出相比較，得到誤差信號，以此控制權值連接強度的調整，經多次訓練後收斂到一個確定的權值。當樣本情況發生變化時，經學習可以修改權值以適應新的環境。使用監督學習的神經網路模型有反傳網路、感知器等。非監督學習時，事先不給定標准樣本，直接將網路置於環境之中，學習階段與工作階段成為一體。此時，學習規律的變化服從連接權值的演變方程。非監督學習最簡單的例子是Hebb學習規則。競爭學習規則是一個更復雜的非監督學習的例子，它是根據已建立的聚類進行權值調整。自組織映射、適應諧振理論網路等都是與競爭學習有關的典型模型。
研究神經網路的非線性動力學性質，主要採用動力學系統理論、非線性規劃理論和統計理論，來分析神經網路的演化過程和吸引子的性質，探索神經網路的協同行為和集體計算功能，了解神經信息處理機制。為了探討神經網路在整體性和模糊性方面處理信息的可能，混沌理論的概念和方法將會發揮作用。混沌是一個相當難以精確定義的數學概念。一般而言，「混沌」是指由確定性方程描述的動力學系統中表現出的非確定性行為，或稱之為確定的隨機性。「確定性」是因為它由內在的原因而不是外來的雜訊或干擾所產生，而「隨機性」是指其不規則的、不能預測的行為，只可能用統計的方法描述。混沌動力學系統的主要特徵是其狀態對初始條件的靈敏依賴性，混沌反映其內在的隨機性。混沌理論是指描述具有混沌行為的非線性動力學系統的基本理論、概念、方法，它把動力學系統的復雜行為理解為其自身與其在同外界進行物質、能量和信息交換過程中內在的有結構的行為，而不是外來的和偶然的行為，混沌狀態是一種定態。混沌動力學系統的定態包括：靜止、平穩量、周期性、准同期性和混沌解。混沌軌線是整體上穩定與局部不穩定相結合的結果，稱之為奇異吸引子。

❽ 如何利用bing演算法訓練自己的模型

在MNIST調用已經訓練好的模型，測試。
這個測試，假定可能是新加入的測試集，還是按照原來的需求轉換，存放數據到指定的位置。
./build/tools/caffe.bin test -model=examples/mnist/lenet_train_test.prototxt -weights=examples/mnist/lenet_iter_10000.caffemodel -gpu=0
如果沒有GPU則使用
./build/tools/caffe.bin test -model=examples/mnist/lenet_train_test.prototxt -weights=examples/mnist/lenet_iter_10000.caffemodel
從上面的指令，對應上圖。
1、先是test表明是要評價一個已經訓練好的模型。
2、然後指定模型prototxt文件，這是一個文本文件，詳細描述了網路結構和數據集信息。從mnist下面的train_lenet.sh指定的solver對應於examples/mnist/lenet_solver.prototxt，而lenet_solver.prototxt指定的模型為examples/mnist/lenet_train_test.prototxt。
3、然後在指定模型的具體的權重。剛好為examples/mnist/lenet_iter_10000.caffemodel
在cifar10模型下面調用已經訓練好的模型，測試。
同上，是用train_quick.sh訓練的。
./build/tools/caffe.bin test -model=examples/cifar10/cifar10_quick_train_test.prototxt -weights=examples/cifar10/cifar10_quick_iter_5000.caffemodel -gpu=0
1、先是test表明是要評價一個已經訓練好的模型。
2、然後指定模型prototxt文件，這是一個文本文件，詳細描述了網路結構和數據集信息。從cifar下面的train_quick.sh指定的solver對應於開始的examples/mnist/lenet_solver.prototxt和4000次以後snapshot的examples/cifar10/cifar10_quick_solver_lr1.prototxt，而這兩者指定的模型都為cifar10_quick_train_test.prototxt。
3、然後在指定模型的具體的權重。為examples/cifar10/cifar10_quick_iter_5000.caffemodel

❾ 如何訓練深度神經網路

deeplearinig就是神經網路的一類，就是解決的訓練問題的深層神經網路，所以你這問題「深度學習會代替神經網路『就不對，BP么，BP有自己的優勢，也是很成熟的演算法，做手寫識別等等效果已經商用化了，不會被輕易替代。deeplearning遠比BP要復雜，用來解決的問題也不是一個層面，所以也沒有替代的必要。Deeplearning所涉及的問題大多數BP都沒法解決的。

度學習的概念源於人工神經網路的研究。含多隱層的多層感知器就是一種深度學習結構，通過組合低層特徵形成更加抽象的高層表示屬性類別或特徵，以發現數據的分布式特徵表示。深度學習的概念由Hinton等人於2006年提出，基於深信度網(DBN)提出非監督貪心逐層訓練演算法，為解決深層結構相關的優化難題帶來希望，隨後提出多層自動編碼器深層結構。深度學習是機器學習研究中的一個新的領域，其動機在於建立、模擬人腦進行分析學習的神經網路，它模仿人腦的機制來解釋數據，例如圖像，聲音和文本。
系統地論述了神經網路的基本原理、方法、技術和應用，主要內容包括：神經信息處理的基本原理、感知器、反向傳播網路、自組織網路、遞歸網路、徑向基函數網路、核函數方法、神經網路集成、模糊神經網路、概率神經網路、脈沖耦合神經網路、神經場理論、神經元集群以及神經計算機。每章末附有習題，書末附有詳細的參考文獻。神經網路是通過對人腦或生物神經網路的抽象和建模，研究非程序的、適應性的、大腦風格的信息處理的本質和能力。它以腦科學和認知神經科學的研究成果為基礎，拓展智能信息處理的方法，為解決復雜問題和智能控制提供有效的途徑，是智能科學和計算智能的重要部分。

❿ bp神經網路演算法訓練集怎麼來的

你自己取的。。。。