① python异常样本识别 交叉验证出现错误

penalty = '12' 这个参数不对，只有L1和L2正则，打错了吧

② 使用python+sklearn的决策树方法预测是否有信用风险

import numpy as np11
import pandas as pd11
names=("Balance,Duration,History,Purpose,Credit amount,Savings,Employment,instPercent,sexMarried,Guarantors,Residence ration,Assets,Age,concCredit,Apartment,Credits,Occupation,Dependents,hasPhone,Foreign,lable").split(',')11
data=pd.read_csv("Desktop/sunshengyun/data/german/german.data",sep='\s+',names=names)11
data.head()11

Balance
Duration
History
Purpose
Credit amount
Savings
Employment
instPercent
sexMarried
Guarantors
…
Assets
Age
concCredit
Apartment
Credits
Occupation
Dependents
hasPhone
Foreign
lable

0
A11 6 A34 A43 1169 A65 A75 4 A93 A101 … A121 67 A143 A152 2 A173 1 A192 A201 1

1
A12 48 A32 A43 5951 A61 A73 2 A92 A101 … A121 22 A143 A152 1 A173 1 A191 A201 2

2
A14 12 A34 A46 2096 A61 A74 2 A93 A101 … A121 49 A143 A152 1 A172 2 A191 A201 1

3
A11 42 A32 A42 7882 A61 A74 2 A93 A103 … A122 45 A143 A153 1 A173 2 A191 A201 1

4
A11 24 A33 A40 4870 A61 A73 3 A93 A101 … A124 53 A143 A153 2 A173 2 A191 A201 2

5 rows × 21 columns
data.Balance.unique()11
array([‘A11’, ‘A12’, ‘A14’, ‘A13’], dtype=object)data.count()11
Balance 1000 Duration 1000 History 1000 Purpose 1000 Credit amount 1000 Savings 1000 Employment 1000 instPercent 1000 sexMarried 1000 Guarantors 1000 Residence ration 1000 Assets 1000 Age 1000 concCredit 1000 Apartment 1000 Credits 1000 Occupation 1000 Dependents 1000 hasPhone 1000 Foreign 1000 lable 1000 dtype: int64#部分变量描述性统计分析
data.describe()1212

Duration
Credit amount
instPercent
Residence ration
Age
Credits
Dependents
lable

count
1000.000000 1000.000000 1000.000000 1000.000000 1000.000000 1000.000000 1000.000000 1000.000000

mean
20.903000 3271.258000 2.973000 2.845000 35.546000 1.407000 1.155000 1.300000

std
12.058814 2822.736876 1.118715 1.103718 11.375469 0.577654 0.362086 0.458487

min
4.000000 250.000000 1.000000 1.000000 19.000000 1.000000 1.000000 1.000000

25%
12.000000 1365.500000 2.000000 2.000000 27.000000 1.000000 1.000000 1.000000

50%
18.000000 2319.500000 3.000000 3.000000 33.000000 1.000000 1.000000 1.000000

75%
24.000000 3972.250000 4.000000 4.000000 42.000000 2.000000 1.000000 2.000000

max
72.000000 18424.000000 4.000000 4.000000 75.000000 4.000000 2.000000 2.000000

data.Duration.unique()11
array([ 6, 48, 12, 42, 24, 36, 30, 15, 9, 10, 7, 60, 18, 45, 11, 27, 8, 54, 20, 14, 33, 21, 16, 4, 47, 13, 22, 39, 28, 5, 26, 72, 40], dtype=int64)data.History.unique()11
array([‘A34’, ‘A32’, ‘A33’, ‘A30’, ‘A31’], dtype=object)data.groupby('Balance').size().order(ascending=False)11
c:\python27\lib\site-packages\ipykernel\__main__.py:1: FutureWarning: order is deprecated, use sort_values(…) if __name__ == ‘__main__’: Balance A14 394 A11 274 A12 269 A13 63 dtype: int64data.groupby('Purpose').size().order(ascending=False)11
c:\python27\lib\site-packages\ipykernel\__main__.py:1: FutureWarning: order is deprecated, use sort_values(…) if __name__ == ‘__main__’: Purpose A43 280 A40 234 A42 181 A41 103 A49 97 A46 50 A45 22 A44 12 A410 12 A48 9 dtype: int64data.groupby('Apartment').size().order(ascending=False)11
c:\python27\lib\site-packages\ipykernel\__main__.py:1: FutureWarning: order is deprecated, use sort_values(…) if __name__ == ‘__main__’: Apartment A152 713 A151 179 A153 108 dtype: int64import matplotlib.pyplot as plt
%matplotlib inline
data.plot(x='lable', y='Age', kind='scatter',
alpha=0.02, s=50);12341234
![png](output_13_0.png)data.hist('Age', bins=15);11
![png](output_14_0.png)target=data.lable11
features_data=data.drop('lable',axis=1)11
numeric_features = [c for c in features_data if features_data[c].dtype.kind in ('i', 'f')] # 提取数值类型为整数或浮点数的变量11
numeric_features11
[‘Duration’, ‘Credit amount’, ‘instPercent’, ‘Residence ration’, ‘Age’, ‘Credits’, ‘Dependents’]numeric_data = features_data[numeric_features]11
numeric_data.head()11

Duration
Credit amount
instPercent
Residence ration
Age
Credits
Dependents

0
6 1169 4 4 67 2 1

1
48 5951 2 2 22 1 1

2
12 2096 2 3 49 1 2

3
42 7882 2 4 45 1 2

4
24 4870 3 4 53 2 2

categorical_data = features_data.drop(numeric_features, axis=1)11
categorical_data.head()11

Balance
History
Purpose
Savings
Employment
sexMarried
Guarantors
Assets
concCredit
Apartment
Occupation
hasPhone
Foreign

0
A11 A34 A43 A65 A75 A93 A101 A121 A143 A152 A173 A192 A201

1
A12 A32 A43 A61 A73 A92 A101 A121 A143 A152 A173 A191 A201

2
A14 A34 A46 A61 A74 A93 A101 A121 A143 A152 A172 A191 A201

3
A11 A32 A42 A61 A74 A93 A103 A122 A143 A153 A173 A191 A201

4
A11 A33 A40 A61 A73 A93 A101 A124 A143 A153 A173 A191 A201

categorical_data_encoded = categorical_data.apply(lambda x: pd.factorize(x)[0]) # pd.factorize即可将分类变量转换为数值表示
# apply运算将转换函数应用到每一个变量维度
categorical_data_encoded.head(5)123123

Balance
History
Purpose
Savings
Employment
sexMarried
Guarantors
Assets
concCredit
Apartment
Occupation
hasPhone
Foreign

0
0 0 0 0 0 0 0 0 0 0 0 0 0

1
1 1 0 1 1 1 0 0 0 0 0 1 0

2
2 0 1 1 2 0 0 0 0 0 1 1 0

3
0 1 2 1 2 0 1 1 0 1 0 1 0

4
0 2 3 1 1 0 0 2 0 1 0 1 0

features = pd.concat([numeric_data, categorical_data_encoded], axis=1)#进行数据的合并
features.head()
# 此处也可以选用one-hot编码来表示分类变量，相应的程序如下：
# features = pd.get_mmies(features_data)
# features.head()1234512345

Duration
Credit amount
instPercent
Residence ration
Age
Credits
Dependents
Balance
History
Purpose
Savings
Employment
sexMarried
Guarantors
Assets
concCredit
Apartment
Occupation
hasPhone
Foreign

0
6 1169 4 4 67 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0

1
48 5951 2 2 22 1 1 1 1 0 1 1 1 0 0 0 0 0 1 0

2
12 2096 2 3 49 1 2 2 0 1 1 2 0 0 0 0 0 1 1 0

3
42 7882 2 4 45 1 2 0 1 2 1 2 0 1 1 0 1 0 1 0

4
24 4870 3 4 53 2 2 0 2 3 1 1 0 0 2 0 1 0 1 0

X = features.values.astype(np.float32) # 转换数据类型
y = (target.values == 1).astype(np.int32) # 1:good,2:bad1212
from sklearn.cross_validation import train_test_split # sklearn库中train_test_split函数可实现该划分

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=0) # 参数test_size设置训练集占比
1234512345
from sklearn.tree import DecisionTreeClassifier
from sklearn.cross_validation import cross_val_score

clf = DecisionTreeClassifier(max_depth=8) # 参数max_depth设置树最大深度

# 交叉验证，评价分类器性能，此处选择的评分标准是ROC曲线下的AUC值，对应AUC更大的分类器效果更好
scores = cross_val_score(clf, X_train, y_train, cv=3, scoring='roc_auc')
print("ROC AUC Decision Tree: {:.4f} +/-{:.4f}".format(
np.mean(scores), np.std(scores)))123456789123456789
ROC AUC Decision Tree: 0.6866 +/-0.0105

#利用learning curve，以样本数为横坐标，训练和交叉验证集上的评分为纵坐标，对不同深度的决策树进行对比（判断是否存在过拟合或欠拟合）
from sklearn.learning_curve import learning_curve

def plot_learning_curve(estimator, X, y, ylim=(0, 1.1), cv=3,
n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5),
scoring=None):
plt.title("Learning curves for %s" % type(estimator).__name__)
plt.ylim(*ylim); plt.grid()
plt.xlabel("Training examples")
plt.ylabel("Score")
train_sizes, train_scores, validation_scores = learning_curve(
estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes,
scoring=scoring)
train_scores_mean = np.mean(train_scores, axis=1)
validation_scores_mean = np.mean(validation_scores, axis=1)

plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
label="Training score")
plt.plot(train_sizes, validation_scores_mean, 'o-', color="g",
label="Cross-validation score")
plt.legend(loc="best")
print("Best validation score: {:.4f}".format(validation_scores_mean[-1]))2223
clf = DecisionTreeClassifier(max_depth=None)
plot_learning_curve(clf, X_train, y_train, scoring='roc_auc')
# 可以注意到训练数据和交叉验证数据的得分有很大的差距，意味着可能过度拟合训练数据了123123
Best validation score: 0.6310

clf = DecisionTreeClassifier(max_depth=10)
plot_learning_curve(clf, X_train, y_train, scoring='roc_auc')1212
Best validation score: 0.6565

clf = DecisionTreeClassifier(max_depth=8)
plot_learning_curve(clf, X_train, y_train, scoring='roc_auc')1212
Best validation score: 0.6762

clf = DecisionTreeClassifier(max_depth=5)
plot_learning_curve(clf, X_train, y_train, scoring='roc_auc')1212
Best validation score: 0.7219

clf = DecisionTreeClassifier(max_depth=4)
plot_learning_curve(clf, X_train, y_train, scoring='roc_auc')1212
Best validation score: 0.7226

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

通常使用的划分方法是留出法，即随机选择2/3的数据作为训练数据，专剩余1/3的数据作为测属试数据，但要保证训练集和测试集中数据分布大致相同，以二分类问题为例，两个数据集中正例和反例的比例不能相差过大，都以50%为佳。也有其他方法如交叉验证法、自助法等，它们在训练时间、训练效果、内存占有量等方面各有优劣，具体请看周志华的机器学习（西瓜书）第二章。

④ python中sklearn中lasso怎么设置交叉验证

1、概述
在实验数据分析中，有些算法需要用现有的数据构建模型，如卷积神经网络（CNN），这类算法称为监督学习（Supervisied Learning）。构建模型需要的数据称为训练数据。
模型构建完后，需要利用数据验证模型的正确性，这部分数据称为测试数据。测试数据不能用于构建模型中，只能用于最后检验模型的准确性。
有时候模型的构建的过程中，也需要检验模型，辅助模型构建。所以会将训练数据分为两个部分，1）训练数据；2）验证数据。
将数据分类就要采用交叉验证的方法，个人写的交叉验证算法不可避免有一定缺陷，考虑使用强大sklearn包可以实现交叉验证算法。
2、python实现
请注意：以下的方法实现根据最新的sklearn版本实现,老版本的函数很多已经过期。
2.1 K次交叉检验（K-Fold Cross Validation）
K次交叉检验的大致思想是将数据大致分为K个子样本，每次取一个样本作为验证数据，取余下的K-1个样本作为训练数据。
from sklearn.model_selection import KFoldimport numpy as np
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([1, 2, 3, 4])
kf = KFold(n_splits=2)for train_index, test_index in kf.split(X):
print("TRAIN:", train_index, "TEST:", test_index)
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]12345678910

2.2 Stratified k-fold
StratifiedKFold()这个函数较常用，比KFold的优势在于将k折数据按照百分比划分数据集，每个类别百分比在训练集和测试集中都是一样，这样能保证不会有某个类别的数据在训练集中而测试集中没有这种情况，同样不会在训练集中没有全在测试集中，这样会导致结果糟糕透顶。
from sklearn.model_selection import StratifiedKFoldimport numpy as np

X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([0, 0, 1, 1])
skf = StratifiedKFold(n_splits=2)for train_index, test_index in skf.split(X, y):
print("TRAIN:", train_index, "TEST:", test_index)
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]12345678910

2.3 train_test_split
随机根据比例分配训练集和测试集。这个函数可以调整随机种子。
import numpy as npfrom sklearn.model_selection import train_test_split
X, y = np.arange(10).reshape((5, 2)), range(5)

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.33, random_state=42)123456

3、总结
sklearn功能非常强大提供的交叉验证函数也非常多，如：
'BaseCrossValidator', 'GridSearchCV', 'TimeSeriesSplit', 'KFold', 'GroupKFold', 'GroupShuffleSplit', 'LeaveOneGroupOut', 'LeaveOneOut', 'LeavePGroupsOut', 'LeavePOut', 'ParameterGrid', 'ParameterSampler', 'PredefinedSplit', 'RandomizedSearchCV', 'ShuffleSplit', 'StratifiedKFold', 'StratifiedShuffleSplit', 'check_cv', 'cross_val_predict', 'cross_val_score', 'fit_grid_point', 'learning_curve', 'permutation_test_score', 'train_test_split', 'validation_curve'

感兴趣的可以查看sklearn源码。

⑤ 什么是留一交叉验证以及如何用python编码实现

简述： coding声明，实际上没有其他对应的效果 python文件的实际编码，决定了你代码中写的中文的所采用的编码（是gbk还是utf-8还是其他） 将utf-8的中文直接输出到gbk的cmd的中，则必然会报错 详解： 之前就写过类似教程了，尤其适合你这样的人...

⑥ 如何用Python在10分钟内建立一个预测模型

预测模型的分解过程
我总是集中于投入有质量的时间在建模的初始阶段，比如，假设生成、头脑风暴、讨论或理解可能的结果范围。所有这些活动都有助于我解决问题，并最终让我设计出更强大的商业解决方案。为什么你要在前面花费这段时间，这有充分的理由：
你有足够的时间投入并且你是无经验的（这是有影响的）
你不带有其它数据观点或想法的偏见（我总是建议，在深入研究数据之前做假设生成）
在后面的阶段，你会急于完成该项目而没有能力投入有质量的时间了。
这个阶段需要投入高质量时间，因此我没有提及时间表，不过我建议你把它作为标准的做法。这有助于你建立建立更好地预测模型，在后面的阶段的只需较少的迭代工作。让我们来看看建立第一个模型的剩余阶段的时间表：
数据描述性分析——50%的时间
数据预处理（缺失值和异常值修复）——40%的时间
数据建模——4%的时间
性能预测——6%的时间
让我们一步一步完成每个过程（每一步投入预测的时间）：
阶段1：描述性分析/数据探索
在我刚开始成为数据科学家的时候，数据探索占据了我大量的时间。不过，随着时间的推移，我已经把大量的数据操作自动化了。由于数据准备占据建立第一个模型工作量的50%，自动化的好处是显而易见的。
这是我们的第一个基准模型，我们去掉任何特征设计。因此，描述分析所需的时间仅限于了解缺失值和直接可见的大的特征。在我的方法体系中，你将需要2分钟来完成这一步（假设，100000个观测数据集）。
我的第一个模型执行的操作：
确定ID，输入特征和目标特征
确定分类和数值特征
识别缺失值所在列
阶段2：数据预处理（缺失值处理）
有许多方法可以解决这个问题。对于我们的第一个模型，我们将专注于智能和快速技术来建立第一个有效模型。
为缺失值创建假标志：有用，有时缺失值本身就携带了大量的信息。
用均值、中位数或其它简单方法填补缺失值：均值和中位数填补都表现良好，大多数人喜欢用均值填补但是在有偏分布的情况下我建议使用中位数。其它智能的方法与均值和中位数填补类似，使用其它相关特征填补或建立模型。比如，在Titanic生存挑战中，你可以使用乘客名字的称呼，比如：“Mr.”, “Miss.”,”Mrs.”,”Master”，来填补年龄的缺失值，这对模型性能有很好的影响。
填补缺失的分类变量：创建一个新的等级来填补分类变量，让所有的缺失值编码为一个单一值比如，“New_Cat”，或者，你可以看看频率组合，使用高频率的分类变量来填补缺失值。
由于数据处理方法如此简单，你可以只需要3到4分钟来处理数据。
阶段3：数据建模
根据不同的业务问题，我推荐使用GBM或RandomForest技术的任意一种。这两个技术可以极其有效地创建基准解决方案。我已经看到数据科学家通常把这两个方法作为他们的第一个模型同时也作为最后一个模型。这最多用去4到5分钟。
阶段4：性能预测
有各种各样的方法可以验证你的模型性能，我建议你将训练数据集划分为训练集和验证集（理想的比例是70：30）并且在70%的训练数据集上建模。现在，使用30%的验证数据集进行交叉验证并使用评价指标进行性能评估。最后需要1到2分钟执行和记录结果。
本文的目的不是赢得比赛，而是建立我们自己的基准。让我们用python代码来执行上面的步骤，建立你的第一个有较高影响的模型。
让我们开始付诸行动
首先我假设你已经做了所有的假设生成并且你擅长使用python的基本数据科学操作。我用一个数据科学挑战的例子来说明。让我们看一下结构：
步骤1：导入所需的库，读取测试和训练数据集。
#导入pandas、numpy包，导入LabelEncoder、random、RandomForestClassifier、GradientBoostingClassifier函数
import pandas as pd
import numpy as np
fromsklearn.preprocessing import LabelEncoder
import random
fromsklearn.ensemble import RandomForestClassifier
from sklearn.ensembleimport GradientBoostingClassifier
#读取训练、测试数据集
train=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Train.csv')
test=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Test.csv')
#创建训练、测试数据集标志
train='Train'
test='Test'
fullData =pd.concat(,axis=0) #联合训练、测试数据集
步骤2：该框架的第二步并不需要用到python，继续下一步。
步骤3：查看数据集的列名或概要
fullData.columns # 显示所有的列名称
fullData.head(10) #显示数据框的前10条记录
fullData.describe() #你可以使用describe()函数查看数值域的概要
步骤4：确定a)ID变量 b)目标变量 c)分类变量 d)数值变量 e)其他变量。
ID_col =
target_col =
cat_cols =
num_cols= list(set(list(fullData.columns))-set(cat_cols)-set(ID_col)-set(target_col)-set(data_col))
other_col= #为训练、测试数据集设置标识符
步骤5：识别缺失值变量并创建标志
fullData.isnull().any()#返回True或False，True意味着有缺失值而False相反
num_cat_cols = num_cols+cat_cols # 组合数值变量和分类变量
#为有缺失值的变量创建一个新的变量
# 对缺失值标志为1，否则为0
for var in num_cat_cols:
if fullData.isnull().any()=True:
fullData=fullData.isnull()*1
步骤6：填补缺失值
#用均值填补数值缺失值
fullData = fullData.fillna(fullData.mean(),inplace=True)
#用-9999填补分类变量缺失值
fullData = fullData.fillna(value = -9999)
步骤7：创建分类变量的标签编码器，将数据集分割成训练和测试集，进一步，将训练数据集分割成训练集和测试集。
#创建分类特征的标签编码器
for var in cat_cols:
number = LabelEncoder()
fullData = number.fit_transform(fullData.astype('str'))
#目标变量也是分类变量，所以也用标签编码器转换
fullData = number.fit_transform(fullData.astype('str'))
train=fullData='Train']
test=fullData='Test']
train = np.random.uniform(0, 1, len(train)) <= .75
Train, Validate = train=True], train=False]
步骤8：将填补和虚假（缺失值标志）变量传递到模型中，我使用随机森林来预测类。
features=list(set(list(fullData.columns))-set(ID_col)-set(target_col)-set(other_col))
x_train = Train.values
y_train = Train.values
x_validate = Validate.values
y_validate = Validate.values
x_test=test.values
random.seed(100)
rf = RandomForestClassifier(n_estimators=1000)
rf.fit(x_train, y_train)
步骤9：检查性能做出预测
status = rf.predict_proba(x_validate)
fpr, tpr, _ = roc_curve(y_validate, status)
roc_auc = auc(fpr, tpr)
print roc_auc
final_status = rf.predict_proba(x_test)
test=final_status
test.to_csv('C:/Users/Analytics Vidhya/Desktop/model_output.csv',columns=)
现在可以提交了！

⑦ 如何用python实现Adaptive Lasso

sklearn.linear_model里有四个跟lasso有关的函数，分别是lasso,lassoCV,lassolars,lassolarsCV,其中lassoCV会根据交叉验证自动对惩罚项参数lambda寻优，lassolarsCV则是版利用了lars算法权求解。

⑧ python svm 怎么训练模型

支持向量机SVM(Support Vector Machine)是有监督的分类预测模型，本篇文章使用机器学习库-learn中的手写数字数据集介绍使用Python对SVM模型进行训练并对手写数字进行识别的过程。

准备工作

手写数字识别的原理是将数字的图片分割为8X8的灰度值矩阵，将这64个灰度值作为每个数字的训练集对模型进行训练。手写数字所对应的真实数字作为分类结果。在机器学习sklearn库中已经包含了不同数字的8X8灰度值矩阵，因此我们首先导入sklearn库自带的datasets数据集。然后是交叉验证库，SVM分类算法库，绘制图表库等。

12345678910#导入自带数据集from sklearn import datasets#导入交叉验证库from sklearn import cross_validation#导入SVM分类算法库from sklearn import svm#导入图表库import matplotlib.pyplot as plt#生成预测结果准确率的混淆矩阵from sklearn import metrics

读取并查看数字矩阵

从sklearn库自带的datasets数据集中读取数字的8X8矩阵信息并赋值给digits。

12#读取自带数据集并赋值给digitsdigits = datasets.load_digits()

查看其中的数字9可以发现，手写的数字9以64个灰度值保存。从下面的8×8矩阵中很难看出这是数字9。

12#查看数据集中数字9的矩阵digits.data[9]

以灰度值的方式输出手写数字9的图像，可以看出个大概轮廓。这就是经过切割并以灰度保存的手写数字9。它所对应的64个灰度值就是模型的训练集，而真实的数字9是目标分类。我们的模型所要做的就是在已知64个灰度值与每个数字对应关系的情况下，通过对模型进行训练来对新的手写数字对应的真实数字进行分类。

1234#绘制图表查看数据集中数字9的图像plt.imshow(digits.images[9], cmap=plt.cm.gray_r, interpolation='nearest')plt.title('digits.target[9]')plt.show()


从混淆矩阵中可以看到，大部分的数字SVM的分类和预测都是正确的，但也有个别的数字分类错误，例如真实的数字2，SVM模型有一次错误的分类为1，还有一次错误分类为7。



⑨ 求教Ubuntu里的python运行sthor和liblinearutil不见的问题

在python中使用liblinear
1.安装
1.从 下载压缩文件，解压
2.进入liblinear主目录，执行make
3.进入./python的文件夹下，拷贝文件夹目录
4.将目录添加至python解释器的path中，export PYTHONPATH=/Users/username/Downloads/liblinear-2.01/python:$PAYTHONPATH
5.进入python， 运行import liblinear，无报错，即完成。
2.使用liblinearutil
liblinearutil模块相比liblinear模块不用考虑ctypes的问题，直接用python数据类型就可以。
from liblinearutil import *1

常用函数
train()：训练线性模型
predict()：对testing数据做预测
svm_read_problem()：读取libsvm格式的数据
load_model()：load模型
save_model()：将模型存储为文件
evaluations()：评价预测结果
model = train(y, x[, 'training_options'])# y是list/tuple类型，长度为l的训练标签向量# x是list/tuple类型的训练实例，list中的每一个元素是list/tuple/dictory类型的feature向量#以下写法的作用是相同的model = train(prob[, 'training_options'])
model = train(prob, param)# examplesy, x = svm_read_problem('../heart_scale')# 读入libsvm格式的数据prob = problem(y, x)# 将y,x写作probparam = parameter('-s 3 -c 5 -q')# 将参数命令写作paramm = train(y, x, '-c 5')
m = train(prob, '-w1 5 -c 5')
m = train(prob, param)# 进行训练CV_ACC = train(y, x, '-v 3')# -v 3 是指进行3-fold的交叉验证# 返回的是交叉验证的准确率best_C, best_rate = train(y, x, '-C -s 0')

p_labs, p_acc, p_vals = predict(y, x, m [,'predicting_options'])# y是testing data的真实标签，用于计算准确率# x是待预测样本# p_labs: 预测出来的标签# p_acc: tuple类型，包括准确率，MSE，Squared correlation coefficient(平方相关系数)# p_vals: list, 直接由模型计算出来的值，没有转化成1，0的值，也可以看做是概率估计值(ACC, MSE, SCC) = evaluations(ty, pv)# ty: list, 真实值# pv: list, 估计值

⑩ 什么是留一交叉验证以及如何用python编码实

留一交叉验证：

就是将样本集中的样本每次抽取一个不同的样本作为测试集，剩余专的样本作为训练集属。需要进行原样本个数次抽取，以进行后续的操作。假设一个.mat文件有310个样本，那么每次抽取一个不同的样本做测试，剩余的299个样本做训练。需要进行310次这样的过程，但是每次选取的做测试的样本是不同的，那么每次训练集的样本也是不同的。由于留一交叉验证的操作的次数十分多，这样选取出来的主成分更具普遍性，可以避免一些不必要的波动，避免一些数据分析时出现有时效果好，有时效果差，这样摇摆不定的情况。因此广受青睐，但是留一交叉验证也有其弊端，样本过多运算时间过长。

下面就来说一下留一交叉验证Python代码的实现。

下面这个是系统自带的留一交叉验证最简单的举例。