python交叉驗證

① 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
data.hist('Age', bins=15);11
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代碼的實現。

下面這個是系統自帶的留一交叉驗證最簡單的舉例。