javasigmoid的简单介绍
本篇文章给大家谈谈javasigmoid，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
哪位朋友能介绍一下支持向量机工具libsvm的用法
LIBSVM的简单介绍 2006-09-20 15:59:48
大 中 小
1. LIBSVM 软件包简介
LIBSVM 是台湾大学林智仁(Chih-Jen Lin)博士等开发设计的一个操作简单、易于使用、快速有效的通用SVM 软件包，可以解决分类问题（包括C- SVC、n - SVC ）、回归问题（包括e - SVR、n - SVR ）以及分布估计（one-class-SVM ）等问题，提供了线性、多项式、径向基和S形函数四种常用的核函数供选择，可以有效地解决多类问题、交叉验证选择参数、对不平衡样本加权、多类问题的概率估计等。LIBSVM 是一个开源的软件包，需要者都可以免费的从作者的个人主页
处获得。他不仅提供了LIBSVM的C++语言的算法源代码，还提供了Python、Java、R、MATLAB、Perl、Ruby、LabVIEW以及C#.net 等各种语言的接口，可以方便的在Windows 或UNIX 平台下使用。另外还提供了WINDOWS 平台下的可视化操作工具SVM-toy，并且在进行模型参数选择时可以绘制出交叉验证精度的等高线图。
2. LIBSVM 使用方法简介
LibSVM是以源代码和可执行文件两种方式给出的。如果是Windows系列操作系统，可以直接使用软件包提供的程序，也可以进行修改编译；如果是Unix类系统，必须自己编译。
LIBSVM 在给出源代码的同时还提供了Windows操作系统下的可执行文件，包括：进行支持向量机训练的svmtrain.exe；根据已获得的支持向量机模型对数据集进行预测的svmpredict.exe；以及对训练数据与测试数据进行简单缩放操作的svmscale.exe。它们都可以直接在DOS 环境中使用。如果下载的包中只有C++的源代码，则也可以自己在VC等软件上编译生成可执行文件。
3. LIBSVM 使用的一般步骤是：
1） 按照LIBSVM软件包所要求的格式准备数据集；
2） 对数据进行简单的缩放操作；
3） 考虑选用RBF 核函数；
4） 采用交叉验证选择最佳参数C与g ；
5） 采用最佳参数C与g 对整个训练集进行训练获取支持向量机模型；
6） 利用获取的模型进行测试与预测。
4. LIBSVM使用的数据格式
1）训练数据和检验数据文件格式如下：
label index1:value1 index2:value2 ...
其中label 是训练数据集的目标值，对于分类，它是标识某类的整数(支持多个类)；对于回归，是任意实数。index 是以1开始的整数，可以是不连续的；value为实数，也就是我们常说的自变量。检验数据文件中的label只用于计算准确度或误差，如果它是未知的，只需用一个数填写这一栏，也可以空着不填。
在程序包中，还包括有一个训练数据实例：heart_scale，方便参考数据文件格式以及练习使用软件。可以编写小程序，将自己常用的数据格式转换成这种格式
2）Svmtrain和Svmpredict的用法
LIBSVM软件提供的各种功能都是DOS命令执行方式。我们主要用到两个程序，svmtrain(训练建模)和svmpredict(使用已有的模型进行预测)，下面分别对这两个程序的使用方法、各参数的意义以及设置方法做一个简单介绍：
（1）Svmtrain的用法：
svmtrain [options] training_set_file [model_file]
Options：可用的选项即表示的涵义如下
-s svm类型：SVM设置类型(默认0)
0 -- C-SVC
1 --v-SVC
2 – 一类SVM
3 -- e -SVR
4 -- v-SVR
-t 核函数类型：核函数设置类型(默认2)
0 – 线性：u'v
1 – 多项式：(r*u'v + coef0)^degree
2 – RBF函数：exp(-r|u-v|^2)
3 –sigmoid：tanh(r*u'v + coef0)
-d degree：核函数中的degree设置(默认3)
-g 函数设置(默认1/ k)r(gama)：核函数中的
-r coef0：核函数中的coef0设置(默认0)
-c cost：设置C-SVC， -SVR的参数(默认1)-SVR和
- SVR的参数(默认0.5)-SVC，一类SVM和-n nu：设置
-SVR-p e：设置的值(默认0.1)中损失函数
-m cachesize：设置cache内存大小，以MB为单位(默认40)
-e ：设置允许的终止判据(默认0.001)
-h shrinking：是否使用启发式，0或1(默认1)
-wi C(C-SVC中的C)(默认1)weight：设置第几类的参数C为weight
-v n: n-fold交互检验模式
其中-g选项中的k是指输入数据中的属性数。option -v 随机地将数据剖分为n部分并计算交互检验准确度和均方根误差。以上这些参数设置可以按照SVM的类型和核函数所支持的参数进行任意组合，如果设置的参数在函数或SVM类型中没有也不会产生影响，程序不会接受该参数；如果应有的参数设置不正确，参数将采用默认值。training_set_file是要进行训练的数据集；model_file是训练结束后产生的模型文件，文件中包括支持向量样本数、支持向量样本以及lagrange系数等必须的参数；该参数如果不设置将采用默认的文件名，也可以设置成自己惯用的文件名。
（2）Svmpredict的用法：
svmpredict test_file model_file output_file
model_file 是由svmtrain产生的模型文件；test_file是要进行预测的数据文件；Output_file是svmpredict的输出文件。svm-predict没有其它的选项。
下面是具体的使用例子
svmtrain -s 0 -c 1000 -t 1 -g 1 -r 1 -d 3 data_file
训练一个由多项式核(u'v+1)^3和C=1000组成的分类器。
svmtrain -s 1 -n 0.1 -t 2 -g 0.5 -e 0.00001 data_file =-SVM (在RBF核函数exp(-0.5|u-v|^2)和终止允许限0.00001的条件下，训练一个 0.1)分类器。 svmtrain -s 3 -p 0.1 -t 0 -c 10 data_file =以线性核函数u'v和C=10及损失函数 0.1求解SVM回归。
如何在Python中用LSTM网络进行时间序列预测
时间序列模型
时间序列预测分析就是利用过去一段时间内某事件时间的特征来预测未来一段时间内该事件的特征。这是一类相对比较复杂的预测建模问题，和回归分析模型的预测不同，时间序列模型是依赖于事件发生的先后顺序的，同样大小的值改变顺序后输入模型产生的结果是不同的。
举个栗子：根据过去两年某股票的每天的股价数据推测之后一周的股价变化；根据过去2年某店铺每周想消费人数预测下周来店消费的人数等等
RNN 和 LSTM 模型
时间序列模型最常用最强大的的工具就是递归神经网络（recurrent neural network, RNN）。相比与普通神经网络的各计算结果之间相互独立的特点，RNN的每一次隐含层的计算结果都与当前输入以及上一次的隐含层结果相关。通过这种方法，RNN的计算结果便具备了记忆之前几次结果的特点。
典型的RNN网路结构如下：
右侧为计算时便于理解记忆而产开的结构。简单说，x为输入层，o为输出层，s为隐含层，而t指第几次的计算；V,W,U为权重，其中计算第t次的隐含层状态时为St = f(U*Xt + W*St-1)，实现当前输入结果与之前的计算挂钩的目的。对RNN想要更深入的了解可以戳这里。
RNN的局限：
由于RNN模型如果需要实现长期记忆的话需要将当前的隐含态的计算与前n次的计算挂钩，即St = f(U*Xt + W1*St-1 + W2*St-2 + ... + Wn*St-n)，那样的话计算量会呈指数式增长，导致模型训练的时间大幅增加，因此RNN模型一般直接用来进行长期记忆计算。
LSTM模型
LSTM（Long Short-Term Memory）模型是一种RNN的变型，最早由Juergen Schmidhuber提出的。经典的LSTM模型结构如下：
LSTM的特点就是在RNN结构以外添加了各层的阀门节点。阀门有3类：遗忘阀门（forget gate），输入阀门（input gate）和输出阀门（output gate）。这些阀门可以打开或关闭，用于将判断模型网络的记忆态（之前网络的状态）在该层输出的结果是否达到阈值从而加入到当前该层的计算中。如图中所示，阀门节点利用sigmoid函数将网络的记忆态作为输入计算；如果输出结果达到阈值则将该阀门输出与当前层的的计算结果相乘作为下一层的输入（PS：这里的相乘是在指矩阵中的逐元素相乘）；如果没有达到阈值则将该输出结果遗忘掉。每一层包括阀门节点的权重都会在每一次模型反向传播训练过程中更新。更具体的LSTM的判断计算过程如下图所示：
LSTM模型的记忆功能就是由这些阀门节点实现的。当阀门打开的时候，前面模型的训练结果就会关联到当前的模型计算，而当阀门关闭的时候之前的计算结果就不再影响当前的计算。因此，通过调节阀门的开关我们就可以实现早期序列对最终结果的影响。而当你不不希望之前结果对之后产生影响，比如自然语言处理中的开始分析新段落或新章节，那么把阀门关掉即可。（对LSTM想要更具体的了解可以戳这里）
下图具体演示了阀门是如何工作的：通过阀门控制使序列第1的输入的变量影响到了序列第4,6的的变量计算结果。
黑色实心圆代表对该节点的计算结果输出到下一层或下一次计算；空心圆则表示该节点的计算结果没有输入到网络或者没有从上一次收到信号。
Python中实现LSTM模型搭建
Python中有不少包可以直接调用来构建LSTM模型，比如pybrain, kears, tensorflow, cikit-neuralnetwork等（更多戳这里）。这里我们选用keras。（PS：如果操作系统用的linux或者mac，强推Tensorflow！！！）
因为LSTM神经网络模型的训练可以通过调整很多参数来优化，例如activation函数，LSTM层数，输入输出的变量维度等，调节过程相当复杂。这里只举一个最简单的应用例子来描述LSTM的搭建过程。
应用实例
基于某家店的某顾客的历史消费的时间推测该顾客前下次来店的时间。具体数据如下所示：
消费时间
2015-05-15 14:03:512015-05-15 15:32:462015-06-28 18:00:172015-07-16 21:27:182015-07-16 22:04:512015-09-08 14:59:56..
..
具体操作：
1. 原始数据转化
首先需要将时间点数据进行数值化。将具体时间转化为时间段用于表示该用户相邻两次消费的时间间隔，然后再导入模型进行训练是比较常用的手段。转化后的数据如下：
消费间隔04418054..
..
2.生成模型训练数据集（确定训练集的窗口长度）
这里的窗口指需要几次消费间隔用来预测下一次的消费间隔。这里我们先采用窗口长度为3， 即用t-2, t-1,t次的消费间隔进行模型训练，然后用t+1次间隔对结果进行验证。数据集格式如下：X为训练数据，Y为验证数据。
PS： 这里说确定也不太合适，因为窗口长度需要根据模型验证结果进行调整的。
X1 X2 X3 Y0 44 18 044 18 0 54..
..
注：直接这样预测一般精度会比较差，可以把预测值Y根据数值bin到几类，然后用转换成one-hot标签再来训练会比较好。比如如果把Y按数值范围分到五类（1：0-20，2：20-40，3：40-60，4：60-80，5：80-100）上式可化为：
X1 X2 X3 Y0 44 18 044 18 0 4...
Y转化成one-hot以后则是(关于one-hot编码可以参考这里)
1 0 0 0 00 0 0 0 1...
3. 网络模型结构的确定和调整
这里我们使用python的keras库。（用java的同学可以参考下deeplearning4j这个库）。网络的训练过程设计到许多参数的调整：比如
需要确定LSTM模块的激活函数（activation fucntion）（keras中默认的是tanh）；
确定接收LSTM输出的完全连接人工神经网络（fully-connected artificial neural network）的激活函数（keras中默认为linear）；
确定每一层网络节点的舍弃率（为了防止过度拟合（overfit）），这里我们默认值设定为0.2；
确定误差的计算方式，这里我们使用均方误差（mean squared error）；
确定权重参数的迭代更新方式，这里我们采用RMSprop算法，通常用于RNN网络。
确定模型训练的epoch和batch size（关于模型的这两个参数具体解释戳这里）
一般来说LSTM模块的层数越多（一般不超过3层，再多训练的时候就比较难收敛），对高级别的时间表示的学习能力越强；同时，最后会加一层普通的神经网路层用于输出结果的降维。典型结构如下：
如果需要将多个序列进行同一个模型的训练，可以将序列分别输入到独立的LSTM模块然后输出结果合并后输入到普通层。结构如下：
4. 模型训练和结果预测
将上述数据集按4:1的比例随机拆分为训练集和验证集，这是为了防止过度拟合。训练模型。然后将数据的X列作为参数导入模型便可得到预测值，与实际的Y值相比便可得到该模型的优劣。
实现代码
时间间隔序列格式化成所需的训练集格式
import pandas as pdimport numpy as npdef create_interval_dataset(dataset, look_back):
""" :param dataset: input array of time intervals :param look_back: each training set feature length :return: convert an array of values into a dataset matrix. """
dataX, dataY = [], [] for i in range(len(dataset) - look_back):
dataX.append(dataset[i:i+look_back])
dataY.append(dataset[i+look_back]) return np.asarray(dataX), np.asarray(dataY)
df = pd.read_csv("path-to-your-time-interval-file")
dataset_init = np.asarray(df) # if only 1 columndataX, dataY = create_interval_dataset(dataset, lookback=3) # look back if the training set sequence length
这里的输入数据来源是csv文件，如果输入数据是来自数据库的话可以参考这里
LSTM网络结构搭建
import pandas as pdimport numpy as npimport randomfrom keras.models import Sequential, model_from_jsonfrom keras.layers import Dense, LSTM, Dropoutclass NeuralNetwork():
def __init__(self, **kwargs):
""" :param **kwargs: output_dim=4: output dimension of LSTM layer; activation_lstm='tanh': activation function for LSTM layers; activation_dense='relu': activation function for Dense layer; activation_last='sigmoid': activation function for last layer; drop_out=0.2: fraction of input units to drop; np_epoch=10, the number of epoches to train the model. epoch is one forward pass and one backward pass of all the training examples; batch_size=32: number of samples per gradient update. The higher the batch size, the more memory space you'll need; loss='mean_square_error': loss function; optimizer='rmsprop' """
self.output_dim = kwargs.get('output_dim', 8) self.activation_lstm = kwargs.get('activation_lstm', 'relu') self.activation_dense = kwargs.get('activation_dense', 'relu') self.activation_last = kwargs.get('activation_last', 'softmax') # softmax for multiple output
self.dense_layer = kwargs.get('dense_layer', 2) # at least 2 layers
self.lstm_layer = kwargs.get('lstm_layer', 2) self.drop_out = kwargs.get('drop_out', 0.2) self.nb_epoch = kwargs.get('nb_epoch', 10) self.batch_size = kwargs.get('batch_size', 100) self.loss = kwargs.get('loss', 'categorical_crossentropy') self.optimizer = kwargs.get('optimizer', 'rmsprop') def NN_model(self, trainX, trainY, testX, testY):
""" :param trainX: training data set :param trainY: expect value of training data :param testX: test data set :param testY: epect value of test data :return: model after training """
print "Training model is LSTM network!"
input_dim = trainX[1].shape[1]
output_dim = trainY.shape[1] # one-hot label
# print predefined parameters of current model:
model = Sequential() # applying a LSTM layer with x dim output and y dim input. Use dropout parameter to avoid overfitting
model.add(LSTM(output_dim=self.output_dim,
input_dim=input_dim,
activation=self.activation_lstm,
dropout_U=self.drop_out,
return_sequences=True)) for i in range(self.lstm_layer-2):
model.add(LSTM(output_dim=self.output_dim,
input_dim=self.output_dim,
activation=self.activation_lstm,
dropout_U=self.drop_out,
return_sequences=True)) # argument return_sequences should be false in last lstm layer to avoid input dimension incompatibility with dense layer
model.add(LSTM(output_dim=self.output_dim,
input_dim=self.output_dim,
activation=self.activation_lstm,
dropout_U=self.drop_out)) for i in range(self.dense_layer-1):
model.add(Dense(output_dim=self.output_dim,
activation=self.activation_last))
model.add(Dense(output_dim=output_dim,
input_dim=self.output_dim,
activation=self.activation_last)) # configure the learning process
model.compile(loss=self.loss, optimizer=self.optimizer, metrics=['accuracy']) # train the model with fixed number of epoches
model.fit(x=trainX, y=trainY, nb_epoch=self.nb_epoch, batch_size=self.batch_size, validation_data=(testX, testY)) # store model to json file
model_json = model.to_json() with open(model_path, "w") as json_file:
json_file.write(model_json) # store model weights to hdf5 file
if model_weight_path: if os.path.exists(model_weight_path):
os.remove(model_weight_path)
model.save_weights(model_weight_path) # eg: model_weight.h5
return model
这里写的只涉及LSTM网络的结构搭建，至于如何把数据处理规范化成网络所需的结构以及把模型预测结果与实际值比较统计的可视化，就需要根据实际情况做调整了。
java实现bp算法
package ml;
import java.util.Random;
/**
* BPNN.
*
* @author RenaQiu
*
*/
public class BP {
/**
* input vector.
*/
private final double[] input;
/**
* hidden layer.
*/
private final double[] hidden;
/**
* output layer.
*/
private final double[] output;
/**
* target.
*/
private final double[] target;
/**
* delta vector of the hidden layer .
*/
private final double[] hidDelta;
/**
* output layer of the output layer.
*/
private final double[] optDelta;
/**
* learning rate.
*/
private final double eta;
/**
* momentum.
*/
private final double momentum;
/**
* weight matrix from input layer to hidden layer.
*/
private final double[][] iptHidWeights;
/**
* weight matrix from hidden layer to output layer.
*/
private final double[][] hidOptWeights;
/**
* previous weight update.
*/
private final double[][] iptHidPrevUptWeights;
/**
* previous weight update.
*/
private final double[][] hidOptPrevUptWeights;
public double optErrSum = 0d;
public double hidErrSum = 0d;
private final Random random;
/**
* Constructor.
* p
* strongNote:/strong The capacity of each layer will be the parameter
* plus 1. The additional unit is used for smoothness.
* /p
*
* @param inputSize
* @param hiddenSize
* @param outputSize
* @param eta
* @param momentum
* @param epoch
*/
public BP(int inputSize, int hiddenSize, int outputSize, double eta,
double momentum) {
input = new double[inputSize + 1];
hidden = new double[hiddenSize + 1];
output = new double[outputSize + 1];
target = new double[outputSize + 1];
hidDelta = new double[hiddenSize + 1];
optDelta = new double[outputSize + 1];
iptHidWeights = new double[inputSize + 1][hiddenSize + 1];
hidOptWeights = new double[hiddenSize + 1][outputSize + 1];
random = new Random(19881211);
randomizeWeights(iptHidWeights);
randomizeWeights(hidOptWeights);
iptHidPrevUptWeights = new double[inputSize + 1][hiddenSize + 1];
hidOptPrevUptWeights = new double[hiddenSize + 1][outputSize + 1];
this.eta = eta;
this.momentum = momentum;
}
private void randomizeWeights(double[][] matrix) {
for (int i = 0, len = matrix.length; i != len; i++)
for (int j = 0, len2 = matrix[i].length; j != len2; j++) {
double real = random.nextDouble();
matrix[i][j] = random.nextDouble() 0.5 ? real : -real;
}
}
/**
* Constructor with default eta = 0.25 and momentum = 0.3.
*
* @param inputSize
* @param hiddenSize
* @param outputSize
* @param epoch
*/
public BP(int inputSize, int hiddenSize, int outputSize) {
this(inputSize, hiddenSize, outputSize, 0.25, 0.9);
}
/**
* Entry method. The train data should be a one-dim vector.
*
* @param trainData
* @param target
*/
public void train(double[] trainData, double[] target) {
loadInput(trainData);
loadTarget(target);
forward();
calculateDelta();
adjustWeight();
}
/**
* Test the BPNN.
*
* @param inData
* @return
*/
public double[] test(double[] inData) {
if (inData.length != input.length - 1) {
throw new IllegalArgumentException("Size Do Not Match.");
}
System.arraycopy(inData, 0, input, 1, inData.length);
forward();
return getNetworkOutput();
}
/**
* Return the output layer.
*
* @return
*/
private double[] getNetworkOutput() {
int len = output.length;
double[] temp = new double[len - 1];
for (int i = 1; i != len; i++)
temp[i - 1] = output[i];
return temp;
}
/**
* Load the target data.
*
* @param arg
*/
private void loadTarget(double[] arg) {
if (arg.length != target.length - 1) {
throw new IllegalArgumentException("Size Do Not Match.");
}
System.arraycopy(arg, 0, target, 1, arg.length);
}
/**
* Load the training data.
*
* @param inData
*/
private void loadInput(double[] inData) {
if (inData.length != input.length - 1) {
throw new IllegalArgumentException("Size Do Not Match.");
}
System.arraycopy(inData, 0, input, 1, inData.length);
}
/**
* Forward.
*
* @param layer0
* @param layer1
* @param weight
*/
private void forward(double[] layer0, double[] layer1, double[][] weight) {
// threshold unit.
layer0[0] = 1.0;
for (int j = 1, len = layer1.length; j != len; ++j) {
double sum = 0;
for (int i = 0, len2 = layer0.length; i != len2; ++i)
sum += weight[i][j] * layer0[i];
layer1[j] = sigmoid(sum);
}
}
/**
* Forward.
*/
private void forward() {
forward(input, hidden, iptHidWeights);
forward(hidden, output, hidOptWeights);
}
/**
* Calculate output error.
*/
private void outputErr() {
double errSum = 0;
for (int idx = 1, len = optDelta.length; idx != len; ++idx) {
double o = output[idx];
optDelta[idx] = o * (1d - o) * (target[idx] - o);
errSum += Math.abs(optDelta[idx]);
}
optErrSum = errSum;
}
/**
* Calculate hidden errors.
*/
private void hiddenErr() {
double errSum = 0;
for (int j = 1, len = hidDelta.length; j != len; ++j) {
double o = hidden[j];
double sum = 0;
for (int k = 1, len2 = optDelta.length; k != len2; ++k)
sum += hidOptWeights[j][k] * optDelta[k];
hidDelta[j] = o * (1d - o) * sum;
errSum += Math.abs(hidDelta[j]);
}
hidErrSum = errSum;
}
/**
* Calculate errors of all layers.
*/
private void calculateDelta() {
outputErr();
hiddenErr();
}
/**
* Adjust the weight matrix.
*
* @param delta
* @param layer
* @param weight
* @param prevWeight
*/
private void adjustWeight(double[] delta, double[] layer,
double[][] weight, double[][] prevWeight) {
layer[0] = 1;
for (int i = 1, len = delta.length; i != len; ++i) {
for (int j = 0, len2 = layer.length; j != len2; ++j) {
double newVal = momentum * prevWeight[j][i] + eta * delta[i]
* layer[j];
weight[j][i] += newVal;
prevWeight[j][i] = newVal;
}
}
}
/**
* Adjust all weight matrices.
*/
private void adjustWeight() {
adjustWeight(optDelta, hidden, hidOptWeights, hidOptPrevUptWeights);
adjustWeight(hidDelta, input, iptHidWeights, iptHidPrevUptWeights);
}
/**
* Sigmoid.
*
* @param val
* @return
*/
private double sigmoid(double val) {
return 1d / (1d + Math.exp(-val));
}
}
支持向量机模型的使用？
LIBSVM的简单介绍 2006-09-20 15:59:48
大 中 小
1. LIBSVM 软件包简介
LIBSVM 是台湾大学林智仁(Chih-Jen Lin)博士等开发设计的一个操作简单、易于使用、快速有效的通用SVM 软件包，可以解决分类问题（包括C- SVC、n - SVC ）、回归问题（包括e - SVR、n - SVR ）以及分布估计（one-class-SVM ）等问题，提供了线性、多项式、径向基和S形函数四种常用的核函数供选择，可以有效地解决多类问题、交叉验证选择参数、对不平衡样本加权、多类问题的概率估计等。LIBSVM 是一个开源的软件包，需要者都可以免费的从作者的个人主页
处获得。他不仅提供了LIBSVM的C++语言的算法源代码，还提供了Python、Java、R、MATLAB、Perl、Ruby、LabVIEW以及C#.net 等各种语言的接口，可以方便的在Windows 或UNIX 平台下使用。另外还提供了WINDOWS 平台下的可视化操作工具SVM-toy，并且在进行模型参数选择时可以绘制出交叉验证精度的等高线图。
2. LIBSVM 使用方法简介
LibSVM是以源代码和可执行文件两种方式给出的。如果是Windows系列操作系统，可以直接使用软件包提供的程序，也可以进行修改编译；如果是Unix类系统，必须自己编译。
LIBSVM 在给出源代码的同时还提供了Windows操作系统下的可执行文件，包括：进行支持向量机训练的svmtrain.exe；根据已获得的支持向量机模型对数据集进行预测的svmpredict.exe；以及对训练数据与测试数据进行简单缩放操作的svmscale.exe。它们都可以直接在DOS 环境中使用。如果下载的包中只有C++的源代码，则也可以自己在VC等软件上编译生成可执行文件。
3. LIBSVM 使用的一般步骤是：
1） 按照LIBSVM软件包所要求的格式准备数据集；
2） 对数据进行简单的缩放操作；
3） 考虑选用RBF 核函数；
4） 采用交叉验证选择最佳参数C与g ；
5） 采用最佳参数C与g 对整个训练集进行训练获取支持向量机模型；
6） 利用获取的模型进行测试与预测。
4. LIBSVM使用的数据格式
1）训练数据和检验数据文件格式如下：
label index1:value1 index2:value2 ...
其中label 是训练数据集的目标值，对于分类，它是标识某类的整数(支持多个类)；对于回归，是任意实数。index 是以1开始的整数，可以是不连续的；value为实数，也就是我们常说的自变量。检验数据文件中的label只用于计算准确度或误差，如果它是未知的，只需用一个数填写这一栏，也可以空着不填。
在程序包中，还包括有一个训练数据实例：heart_scale，方便参考数据文件格式以及练习使用软件。可以编写小程序，将自己常用的数据格式转换成这种格式
2）Svmtrain和Svmpredict的用法
LIBSVM软件提供的各种功能都是DOS命令执行方式。我们主要用到两个程序，svmtrain(训练建模)和svmpredict(使用已有的模型进行预测)，下面分别对这两个程序的使用方法、各参数的意义以及设置方法做一个简单介绍：
（1）Svmtrain的用法：
svmtrain [options] training_set_file [model_file]
Options：可用的选项即表示的涵义如下
-s svm类型：SVM设置类型(默认0)
0 -- C-SVC
1 --v-SVC
2 – 一类SVM
3 -- e -SVR
4 -- v-SVR
-t 核函数类型：核函数设置类型(默认2)
0 – 线性：u'v
1 – 多项式：(r*u'v + coef0)^degree
2 – RBF函数：exp(-r|u-v|^2)
3 –sigmoid：tanh(r*u'v + coef0)
-d degree：核函数中的degree设置(默认3)
-g 函数设置(默认1/ k)r(gama)：核函数中的
-r coef0：核函数中的coef0设置(默认0)
-c cost：设置C-SVC， -SVR的参数(默认1)-SVR和
- SVR的参数(默认0.5)-SVC，一类SVM和-n nu：设置
-SVR-p e：设置的值(默认0.1)中损失函数
-m cachesize：设置cache内存大小，以MB为单位(默认40)
-e ：设置允许的终止判据(默认0.001)
-h shrinking：是否使用启发式，0或1(默认1)
-wi C(C-SVC中的C)(默认1)weight：设置第几类的参数C为weight
-v n: n-fold交互检验模式
其中-g选项中的k是指输入数据中的属性数。option -v 随机地将数据剖分为n部分并计算交互检验准确度和均方根误差。以上这些参数设置可以按照SVM的类型和核函数所支持的参数进行任意组合，如果设置的参数在函数或SVM类型中没有也不会产生影响，程序不会接受该参数；如果应有的参数设置不正确，参数将采用默认值。training_set_file是要进行训练的数据集；model_file是训练结束后产生的模型文件，文件中包括支持向量样本数、支持向量样本以及lagrange系数等必须的参数；该参数如果不设置将采用默认的文件名，也可以设置成自己惯用的文件名。
（2）Svmpredict的用法：
svmpredict test_file model_file output_file
model_file 是由svmtrain产生的模型文件；test_file是要进行预测的数据文件；Output_file是svmpredict的输出文件。svm-predict没有其它的选项。
下面是具体的使用例子
svmtrain -s 0 -c 1000 -t 1 -g 1 -r 1 -d 3 data_file
训练一个由多项式核(u'v+1)^3和C=1000组成的分类器。
svmtrain -s 1 -n 0.1 -t 2 -g 0.5 -e 0.00001 data_file =-SVM (在RBF核函数exp(-0.5|u-v|^2)和终止允许限0.00001的条件下，训练一个 0.1)分类器。 svmtrain -s 3 -p 0.1 -t 0 -c 10 data_file =以线性核函数u'v和C=10及损失函数 0.1求解SVM回归。
javasigmoid的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javasigmoid的信息别忘了在本站进行查找喔。
发布于：2022-12-11，除非注明，否则均为原创文章，转载请注明出处。