【最新28理财源码】【万淘铺源码】【偏移量源码】traintest源码-皮皮网

【最新28理财源码】【万淘铺源码】【偏移量源码】traintest源码

2024-11-24 22:53:10 来源：和平精英雷达透视源码分类：休闲

1.基于 Toad 的评分卡模型全流程详解（含 Python 源码）
2.python测试集的个数多少合适
3.controlnet源码解读
4.Python时序预测系列基于LSTM实现时序数据多输入多输出多步预测（案例+源码）
5.matlab BP神经网络的训练算法中训练函数（traingdm 、trainlm、trainbr）的实现过程及相应的VC源代码

traintest源码

基于 Toad 的评分卡模型全流程详解（含 Python 源码）

欢迎关注@Python与数据挖掘，专注于 Python、数据分析、数据挖掘、最新28理财源码好玩工具！

toad 是一个专为风险评分卡建模而设计的工具包，它功能强大且使用便捷，能简化模型构建过程中的多个步骤，包括数据探索、特征筛选、分箱、WOE变换、建模、模型评估、分数转换等，深受行业用户的喜爱。如果您在使用过程中遇到任何问题，欢迎在文末进行技术交流。

以下是基于 toad 的评分卡模型构建流程详解：

首先，要安装 toad，使用 pip 命令即可完成。

导入库和数据读取：演示数据包含条记录，个特征，其中个为特征变量，一列为主键和一列为标签（Defaulter）。数据中有离散型和连续型变量，且存在一定数量的缺失值。为了模型检验，使用 sklearn 的万淘铺源码 train_test_split 函数将数据划分为训练集和测试集。

数据探索：使用 toad.detect 方法检测数据情况，获取每列特征的统计信息，如缺失值、唯一值、数值变量的平均值、离散型变量的众数等。此外，通过 toad.quality 方法输出每个变量的 iv 值、gini 指数、熵值和唯一值，结果按 iv 值排序。

特征筛选与分箱：使用 toad.selection.select 方法筛选变量，根据缺失值占比、iv 值、相关性进行变量选择。筛选后，从个特征中选出个变量。接着，使用 toad.transform.Combiner 类进行分箱，支持多种分箱方法，如卡方分箱、决策树分箱、等频分箱、等距分箱和最优分箱。根据实际需求调整参数，完成变量分箱。

WOE 转换：在分箱调整完成后，使用 WOE 转换方法。仅转换被分箱的变量，并确保所有变量经过 WOE 转换。偏移量源码

逐步回归特征筛选：使用 toad.selection.stepwise 方法进行特征筛选，调整参数以获得最佳结果。使用 toad.metrics.PSI 函数检验 WOE 转换后的特征稳定性。

建模与评估：首先使用逻辑回归（LR）构建模型，评估模型结果，常用指标包括 KS（Kolmogorov-Smirnov）值、AUC（曲线下面积）和 PSI（预测分箱稳定性指数）。使用 toad.metrics.KS_bucket 函数评估模型预测分箱后的信息，包括分数区间、样本量、坏账率和 KS 值。

评分转换：使用 toad.ScoreCard 函数将逻辑回归模型转换为标准评分卡。调整参数以适应实际需求，包括基准评分、比率、基准奇偶比等。

至此，通过使用 toad，可以快速完成评分卡模型的全流程构建。在实际工作中，根据数据特性和需求调整参数，以满足特定任务需求。本文提供了 toad 的功能介绍和评分卡建模基础流程，实际应用时，只需根据实际情况调整流程和参数即可。

关注@Python与数据挖掘，获取更多优质文章与技术交流。

python测试集的个数多少合适

导读：今天首席CTO笔记来给各位分享关于python测试集的个数多少合适的相关内容，如果能碰巧解决你现在面临的问题，别忘了关注本站，源码笔记本现在开始吧！

划分训练、测试集和数据观察

一般在进行模型的测试时，我们会将数据分为训练集和测试集。在给定的样本空间中，拿出大部分样本作为训练集来训练模型，剩余的小部分样本使用刚建立的模型进行预测。

train_test_split函数利用伪随机数生成器将数据集打乱。默认情况下0.为训练集,0.测试集。

在构建机器学习模型之前，通常最好检查一下数据，看看如果不用机器学习能不能轻松完成任务，或者需要的信息有没有包含在数据中。

此外，检查数据也是发现异常值和特殊值的好方法。举个例子，可能有些鸢尾花的测量单位是英寸而不是厘米。在现实世界中，经常会遇到不一致的数据和意料之外的测量数据。检查数据的最佳方法之一就是将其可视化。一种可视化方法是绘制散点图（scatterplot）。数据散点图将一个特征作为x轴，另一个特征作为y轴，将每一个数据点绘制为图上的一个点。不幸的是，计算机屏幕只有两个维度，所以我们一次只能绘制两个特征（也可能是3个）。用这种方法难以对多于3个特征的数据集作图。解决这个问题的一种方法是绘制散点图矩阵（pairplot），从而可以两两查看所有的吉工家源码特征。如果特征数不多的话，比如我们这里有4个，这种方法是很合理的。但是你应该记住，散点图矩阵无法同时显示所有特征之间的关系，所以这种可视化方法可能无法展示数据的某些有趣内容。

数据点的颜色与鸢尾花的品种相对应。为了绘制这张图，我们首先将NumPy数组转换成pandasDataFrame。pandas有一个绘制散点图矩阵的函数，叫作scatter_matrix。矩阵的对角线是每个特征的直方图

从图中可以看出，利用花瓣和花萼的测量数据基本可以将三个类别区分开。这说明机器学习模型很可能可以学会区分它们。

参考资料：

Python机器学习基础教程

Pandas官方文档

如何利用python将txt文件划分训练集和测试集

“按照8:2的比例对项目分出训练集和测试集”：从数据源中随机抽取%的数据作为“训练集”，其余的是“测试集”

import?random

with?open("datasource.txt",?'rt')?as?handle:

dataset?=?[map(int,?ln.split())?for?ln?in?handle]

#?乱序

random.shuffle(dataset)

#?[训练集,?测试集]

pos?=?len(dataset)?*.8

parts?=?dataset[:pos],?dataset[pos:]

训练集测试集8比2合适吗

不合适。

数据量较小（1w条以下），一般的划分是，训练集：验证集：测试集=8：1：1（有的地方说是6：2：2），训练集：测试集=2：1至4：1（总之测试集不要超过%）。训练集：训练参数，此处的参数是指普通参数，即在神经网络中能够被梯度下降算法所更新的，如权值。验证集：用于调超参数，监控模型是否发生过拟合，能够被多次使用，进行人工调参。此处的超参数，如神经网络中的网络层数、网络节点数、迭代次数、学习率测试集：评估最终模型泛化能力，被一次使用。

BP神经网络的训练集需要大样本吗？一般样本个数为多少？

BP神经网络样本数有什么影响

学习神经网络这段时间，有一个疑问，BP神经网络中训练的次数指的网络的迭代次数，如果有a个样本,每个样本训练次数n，则网络一共迭代an次，在na情况下，网络在不停的调整权值，减小误差，跟样本数似乎关系不大。而且，a大了的话训练时间必然会变长。

换一种说法，将你的数据集看成一个固定值，那么样本集与测试集也可以按照某种规格确定下来如7：3所以如何看待样本集的多少与训练结果呢？或者说怎么使你的网络更加稳定，更加符合你的所需。

我尝试从之前的一个例子中看下区别

如何用行Java代码实现深度神经网络算法

作者其实是实现了一个BP神经网络，不多说，看最后的例子

一个运用神经网络的例子

最后我们找个简单例子来看看神经网络神奇的效果。为了方便观察数据分布，我们选用一个二维坐标的数据，下面共有4个数据，方块代表数据的类型为1，三角代表数据的类型为0，可以看到属于方块类型的数据有（1，2）和（2，1），属于三角类型的数据有（1，1），（2，2），现在问题是需要在平面上将4个数据分成1和0两类，并以此来预测新的数据的类型。

描述

我们可以运用逻辑回归算法来解决上面的分类问题，但是逻辑回归得到一个线性的直线做为分界线，可以看到上面的红线无论怎么摆放，总是有一个样本被错误地划分到不同类型中，所以对于上面的数据，仅仅一条直线不能很正确地划分他们的分类，如果我们运用神经网络算法，可以得到下图的分类效果，相当于多条直线求并集来划分空间，这样准确性更高。

描述

简单粗暴，用作者的代码运行后训练次。根据训练结果来预测一条新数据的分类（3,1）

预测值（3,1）的结果跟（1,2）（2,1）属于一类属于正方形

这时如果我们去掉2个样本，则样本输入变成如下

//设置样本数据，对应上面的4个二维坐标数据

double[][]data=newdouble[][]{ { 1,2},{ 2,2}};

//设置目标数据，对应4个坐标数据的分类

double[][]target=newdouble[][]{ { 1,0},{ 0,1}};

则（3,1）结果变成了三角形，

如果你选前两个点你会发现直接一条中间线就可以区分这时候的你的结果跟之前4个点时有区别so你得增加样本直到这些样本按照你所想要的方式分类，所以样本的多少重要性体现在，样本得能反映所有的特征值（也就是输入值），样本多少或者特征（本例子指点的位置特征）决定的你的网络的训练结果，！！！这是我们反推出来的结果。这里距离深度学习好像近了一步。

另外，这个行代码的神经网络没有保存你训练的网络，所以你每次运行都是重新训练的网络。其实，在你训练过后权值已经确定了下来，我们确定网络也就是根据权值，so只要把训练后的权值保存下来，将需要分类的数据按照这种权值带入网络，即可得到输出值，也就是一旦网络确定，权值也就确定，一个输入对应一个固定的输出，不会再次改变！个人见解。

最后附上作者的源码，作者的文章见开头链接

下面的实现程序BpDeep.java可以直接拿去使用，

importjava.util.Random;

publicclassBpDeep{

publicdouble[][]layer;//神经网络各层节点

publicdouble[][]layerErr;//神经网络各节点误差

publicdouble[][][]layer_weight;//各层节点权重

publicdouble[][][]layer_weight_delta;//各层节点权重动量

publicdoublemobp;//动量系数

publicdoublerate;//学习系数

publicBpDeep(int[]layernum,doublerate,doublemobp){

this.mobp=mobp;

this.rate=rate;

layer=newdouble[layernum.length][];

layerErr=newdouble[layernum.length][];

layer_weight=newdouble[layernum.length][][];

layer_weight_delta=newdouble[layernum.length][][];

Randomrandom=newRandom();

for(intl=0;llayernum.length;l++){

layer[l]=newdouble[layernum[l]];

layerErr[l]=newdouble[layernum[l]];

if(l+1layernum.length){

layer_weight[l]=newdouble[layernum[l]+1][layernum[l+1]];

layer_weight_delta[l]=newdouble[layernum[l]+1][layernum[l+1]];

for(intj=0;jlayernum[l]+1;j++)

for(inti=0;ilayernum[l+1];i++)

layer_weight[l][j][i]=random.nextDouble();//随机初始化权重

}

//逐层向前计算输出

publicdouble[]computeOut(double[]in){

for(intl=1;llayer.length;l++){

for(intj=0;jlayer[l].length;j++){

doublez=layer_weight[l-1][layer[l-1].length][j];

for(inti=0;ilayer[l-1].length;i++){

layer[l-1][i]=l==1?in[i]:layer[l-1][i];

z+=layer_weight[l-1][i][j]*layer[l-1][i];

}

layer[l][j]=1/(1+Math.exp(-z));

}

returnlayer[layer.length-1];

}

//逐层反向计算误差并修改权重

publicvoidupdateWeight(double[]tar){

intl=layer.length-1;

for(intj=0;jlayerErr[l].length;j++)

layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);

while(l--0){

for(intj=0;jlayerErr[l].length;j++){

doublez=0.0;

for(inti=0;ilayerErr[l+1].length;i++){

z=z+l0?layerErr[l+1][i]*layer_weight[l][j][i]:0;

layer_weight_delta[l][j][i]=mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整

layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整

if(j==layerErr[l].length-1){

layer_weight_delta[l][j+1][i]=mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整

layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整

}

layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差

}

publicvoidtrain(double[]in,double[]tar){

double[]out=computeOut(in);

updateWeight(tar);

}

下面是这个测试程序BpDeepTest.java的源码：

importjava.util.Arrays;

publicclassBpDeepTest{

publicstaticvoidmain(String[]args){

//初始化神经网络的基本配置

//第一个参数是一个整型数组，表示神经网络的层数和每层节点数，比如{ 3,,,,,2}表示输入层是3个节点，输出层是2个节点，中间有4层隐含层，每层个节点

//第二个参数是学习步长，第三个参数是动量系数

BpDeepbp=newBpDeep(newint[]{ 2,,2},0.,0.8);

//设置样本数据，对应上面的4个二维坐标数据

double[][]data=newdouble[][]{ { 1,2},{ 2,2},{ 1,1},{ 2,1}};

//设置目标数据，对应4个坐标数据的分类

double[][]target=newdouble[][]{ { 1,0},{ 0,1},{ 0,1},{ 1,0}};

//迭代训练次

for(intn=0;n;n++)

for(inti=0;idata.length;i++)

bp.train(data[i],target[i]);

//根据训练结果来检验样本数据

for(intj=0;jdata.length;j++){

double[]result=bp.computeOut(data[j]);

System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));

}

//根据训练结果来预测一条新数据的分类

double[]x=newdouble[]{ 3,1};

double[]result=bp.computeOut(x);

System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));

}

python随机森林分类模型，测试集和训练集的样本数没有准确按照%和%分配？

进行比例划分的时候从int型转化为了float型，float型总是会有微小的误差的，这个不是大问题。

比如你输入1-0.9，可能返回0.1，也可能返回0.或者0.,这是计算机存储机制导致的。

结语：以上就是首席CTO笔记为大家整理的关于python测试集的个数多少合适的全部内容了，感谢您花时间阅读本站内容，希望对您有所帮助，更多关于python测试集的个数多少合适的相关内容别忘了在本站进行查找喔。

controlnet源码解读

ControlNet是一种用于控制生成的网络结构，其源码主要包含以下几个部分：1.模型定义：通过继承自torch.nn.Module的ControlNet类来实现模型的定义。2.数据加载：ControlNet的数据加载在data.py文件中。3.训练过程：ControlNet的训练过程在train.py文件中。4.测试过程：ControlNet的测试过程在test.py文件中。

Python时序预测系列基于LSTM实现时序数据多输入多输出多步预测（案例+源码）

本文详细介绍了如何使用Python中的LSTM技术处理时序数据的多输入、多输出和多步预测问题。

首先，多输入指的是输入数据包含多个特征变量，多输出则表示同时预测多个目标变量，而多步预测则指通过分析过去的N天数据，预测未来的M天。例如，给定天的历史观测数据，目标是预测接下来3天的5个变量值。

在实现过程中，作者首先加载并划分数据集，共条数据被分为8:2的训练集（条）和测试集（条）。数据经过归一化处理后，构建LSTM数据集，通过逐步提取数据片段作为输入X_train和输出y_train，构建了（，，5）和（，3，5）的三维数组，分别代表输入序列和输出序列。

模型构建上，采用的是多输入多输出的seq2seq模型，包括编码器和解码器。进行模型训练后，用于预测的testX是一个（，，5）的数组，输出prediction_test则是一个（，3，5）的三维数组，展示了每个样本未来3天5个变量的预测结果和真实值对比。

作者拥有丰富的科研背景，已发表多篇SCI论文，目前致力于分享Python、数据科学、机器学习等领域的知识，通过实战案例和源码帮助读者理解和学习。如需了解更多内容或获取数据源码，可以直接联系作者。

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 Epochs between displays

% showCommandLine 0 generate command line output

% showWindow 1 show training GUI

% epochs Maximum number of epochs to train

% goal 0 Performance goal

% max_fail 5 Maximum validation failures

% min_grad 1e- Minimum performance gradient

% mu 0. Initial Mu

% mu_dec 0.1 Mu decrease factor

% mu_inc Mu increase factor

% mu_max 1e 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, --, ODJ //

% Updated by Orlando De Jes鷖, Martin Hagan, Dynamic Training 7--

% Copyright - The MathWorks, Inc.

% $Revision: 1.1.6..2.2 $ $Date: // :: $

%% =======================================================

% 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

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 during training.'), ...

nnetParamInfo('showCommandLine','Show Command Line Feedback','nntype.bool_scalar',false,...

'Generate command line output during training.'), ...

nnetParamInfo('show','Command Line Frequency','nntype.strict_pos_int_inf_scalar',,...

'Frequency to update command line.'), ...

...

nnetParamInfo('epochs','Maximum Epochs','nntype.pos_int_scalar',,...

'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.,...

'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',,...

'Ratio to increase mu.'), ...

nnetParamInfo('mu_max','Maximum mu','nntype.strict_pos_scalar',1e,...

'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 Reduction = 1

if (perf2 < perf) && flag_inv

WB = WB2; net = net2;

mu = max(mu*param.mu_dec,1e-);

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

【最新28理财源码】【万淘铺源码】【偏移量源码】traintest源码

热门资讯

推荐资讯