kaggle挑戦したメモ

kaggle挑戦したときに見る自分用のメモです．
ちょっとづつ増やしていく（予定）
間違ってるところがあると思うので指摘してくれると助かります．

#1 データの前処理
したこと
1.とりあえず欠損値を埋める
2.文字を数字に置き換える
3.標準化とか正規化

###1.1 とりあえず欠損値を埋める
意味のある欠損値と意味のない欠損値に分けて，埋め方を変えました．
意味のある欠損値:そのモノの有無，例えば家にプールがついているかどうかなど
意味のない欠損値:データがたまたま抜けているだけなど

意味のある欠損値は欠損値そのものに，0などの値を与える．
意味のない欠損値はその項目の平均値，中央値，最瀕値などのそれっぽいもので補間する．

データフレームdfのx列['sample']に対する例:

```.py
df['sample'].fillna(0, inplace=True)#0に置き換え
df.iloc[:,x].fillna(df.iloc[:,x].mean(),inplace=True)#平均値に置き換え
df.iloc[:,x].fillna(df.iloc[:,x].median(),inplace=True)#中央値に置き換え
df.iloc[:,x].fillna(df.mode().iloc[0,x], inplace=True)#最瀕値に置き換え

df.isnull().sum()[df.isnull().sum() != 0].sort_values(ascending=False)#欠損値の確認

```

###1.2 文字を数字に置き換える
文字のままだとデータが使えないのでダミー変数で置き換える．
この場合ダミー変数で置き換えるということは，ある文字で出来ている列のデータに対して列の全ての要素に対する有無のデータを新しく作るということである．
例:

```
df = pd.DataFrame({'sample':['a','b','c','a']})
dummies = pd.get_dummies(df)
print(df)
print(dummies)
```
結果

```
  sample
0      a
1      b
2      c
3      a

   sample_a  sample_b  sample_c
0         1         0         0
1         0         1         0
2         0         0         1
3         1         0         0
```

###1.3 標準化とか正規化
標準化とか正規化を行うことで各列の重みを平等にします．
例:

```.py
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler

sc = StandardScaler()
data_std = sc.fit_transform(data)#標準化
 
ms = MinMaxScaler()
data_norm = ms.fit_transform(data)#正規化
```

###1.4 その他使ったもの

```.py
df = pd.read_csv('train.csv')                   #csvファイルの取り出し
A = df.['sample']                               #列'sample'の取り出し(DataFrame)
B = df.drop(['sample'], axis=1)                 #列'sample'以外の取り出し(DataFrame)
C = df['sample'].as_matrix()                    #列'sample'の取り出し（narray)
D = df['sample'].values                         #列'sample'の取り出し(narray)
E = pd.concat((A,B)).reset_index(drop=True)     #列のA,Bの合体
del E['sample']                                 #列'sample'の削除
```


#2 機械学習の利用
大きく分けて回帰分析と決定木による分析の2つの手法を用いた

##2.1 回帰分析
使用したもの
1. ロジスティック回帰
2. ラッソ回帰

###2.1.1 ロジスティック回帰
ベルヌーイ分布で作成した尤度関数によって作成されるモデル
以下の様にモデルを呼び出す

```.py
clf = linear_model.LogisticRegression()
```
パラメータにCがあり（他にもある），Cは正則化項の係数の分母である．
正則化:モデルを作る際の誤差を小さくするプロセスに，各説明変数の係数（重みと言う）を足す．これをすることで重みを大きくしすぎないようにし，過学習を防ぐ．正則化係数は重みに対する係数のこと（スカラー）．

###2.1.2 ラッソ回帰
誤差にL1正則化項を加えたものを最小化することで作成されるモデル
重みの一部が0になることから，説明変数を減らすことができる．
以下のようにモデルを呼び出す

```.py
lasso = Lasso()
```
パラメータにはalphaがあり，これは正則化項の係数である．

##2.2 決定木による分析
使用したもの
1. random forest
2. xgboost

###2.2.1 random forest
決定木をたくさん作り，全ての決定木で多数決や平均値をとるモデル
以下の様にモデルを呼び出す．

```.py
rf = RandomForestRegressor()
```
パラメータにはn_estimatorsとmax_depthがあり，n_estimatorsは決定木の本数を決め，max_depthは決定木の深さを決定する．

###2.2.2 xgboost
random forest に誤差に関する要素を付け加えたもの．
具体的には1回random forestによってモデルを作成し，その誤差をとる．次にその誤差に関するモデルを作成し，その誤差を取る．．．というのを繰り返したものである．
以下のようにしてモデルを呼び出す．

```
mod = xgb.XGBRegressor()
```
パラメータにはlearning_rate,max_depth,subsample,colsample_bytreeがある．learning_rateは学習率,max_depthは木の深さの条件，subsample決定木に用いいるデータの割合，colsample_bytree各ステップごとに用いる説明変数の割合である．

##2.3 その他
使用したもの
1.SVR

###2.3.1 SVR
SVMというものがある．これは，ある説明変数と目的変数に対して高次元空間に写像し，マージン（境界線と最も近いデータの差）が最大になるような超平面（ある空間を2分割できる1つ次元の低い空間）を求める手法である．
SVRはSVMの回帰版のようなもの．
以下のようにしてモデルを呼び出す．

```
svr = svm.SVR()
```
パラメータにはCとepsilonがあり，Cは超平面を作成する際の誤差の許容具合であり，epsilonは高次元に写像する際の複雑さの度合いを示すものである．

#3 各手法をより良くする方法
1.グリッドサーチ

#3.1 グリッドサーチ
モデルのパラメータの最も良い組み合わせを総当りで確認する手法．
以下のように行う

```
model_parameters = {'C':[1,2,3],'B',[1,2,3]
model_gs = GridSearchCV(model, model_parameters,cv=10,scoring='r2',n_jobs=-1)
```
これはmodelというモデルのパラメータC,Bを[1,2,3]と[1,2,3]の合計9の組み合わせを確認した手法である．またパラメータのcvは交差検証の分割数，scoringはモデルの良さを評価する指標（r2の場合は誤差の2乗），n_jobsは並列計算する場合のCPUのコア数（-1で自動調整）である
交差検証:データ数をnとし分割数をkとするとn(k-1)/k 個をトレーニングデータにし，n/k個をテストデータにすると言う動作をK回（全組み合わせ）行う検証のことである

また，グリッドリサーチを2で説明した機械学習に適用した例を以下に記す．

```GridSearch.py
#logistic
logi = linear_model.LogisticRegression()
logi_parameters = {'C':[0.5,1,2], 'tol':[0.05, 0.1, 0.5]}
logi_gs = GridSearchCV(logi, logi_parameters,cv=lcv,scoring='r2',n_jobs=-1)
logi_gs.fit(mix_X,mix_y)
y_pred1 = logi_gs.predict(mix_test)
 
#lasso
lasso = Lasso()
lasso_parameters = {'alpha':[0.1, 0.5, 1]}
lasso_gs = GridSearchCV(lasso, lasso_parameters,cv=lcv,scoring='r2',n_jobs=-1)
lasso_gs.fit(mix_X,mix_y)
y_pred2 = lasso_gs.predict(mix_test)

#random forest
rf = RandomForestRegressor()
rf_parameters= {'n_estimators':[750,1000,1250]}
rf_gs = GridSearchCV(rf, rf_parameters,cv=lcv,scoring='r2',n_jobs=-1)
rf_gs.fit(mix_X,mix_y)
y_pred3 = rf_gs.predict(mix_test)

#xgboost
mod = xgb.XGBRegressor()
xgb_parameters = {'learning_rate':[0.1,0.3,0.5],'max_depth': [2,3,5,10],'subsample': 
                  [0.5,0.8,0.9,1],'colsample_bytree': [0.5,1.0]}
xgb_gs = GridSearchCV(mod, xgb_parameters,cv=lcv,scoring='r2',n_jobs=-1)
xgb_gs.fit(mix_X,mix_y)
y_pred4 = xgb_gs.predict(mix_test)

#svr
svr = svm.SVR()
svr_parameters = {'C':[1e-1, 1e+1, 1e+3], 'epsilon':[0.05, 0.1, 0.3]}
svr_gs = GridSearchCV(svr, svr_parameters,cv=lcv,scoring='r2',n_jobs=-1)
svr_gs.fit(mix_X,mix_y)
y_pred5 = svr_gs.predict(mix_test)
```