Pythonのscikit-learnでグリッドサーチを使ってSVMのパラメータチューニングをしよう

2016-03-09
このエントリーをはてなブックマークに追加

SVMはパラメータが多すぎる。全部試すとか手間が掛かり過ぎる。
そんな悩みを解決したいグリッドサーチの使い方です。

from sklearn.svm import SVC
from sklearn.grid_search import GridSearchCV


def main():
    _s = GridSearchCV(
            SVC(),
            {
                "C": [0.1, 0.5, 1.0, 1.5],
                "kernel": ["rbf", "linear"],
                "gamma": [1, 1e-2, 1e-3, 1e-4],
            }
    )
    _s.fit(
        [
            [1, 0, 0, 0, 0],
            [1, 1, 0, 0, 0],
            [1, 1, 0, 0, 1],
            [0, 1, 1, 1, 1],
            [0, 0, 0, 1, 1],
            [0, 0, 1, 1, 1],
            [0, 0, 1, 1, 1]
        ],
        [1, 1, 1, 0, 0, 0, 0]
    )

    print(_s.best_estimator_)
    print(_s.best_score_)

if __name__ == "__main__":
    main()

上のコードだとCとカーネルとガンマだけを設定してますけど、SVCで指定できるパラメータは全部設定できます。

出力のところは見やすいように成形してます。便利すぎる。。。
全部のパラメータを1回で指定できるわけでもなくて、併用できないものは途中でエラー吐いたりもします。それでも、かなり実施回数は減らせます。

$ python grid.py
SVC(
    C=0.5,
    cache_size=200,
    class_weight=None,
    coef0=0.0,
    degree=3,
    gamma=1,
    kernel='linear',
    max_iter=-1,
    probability=False,
    random_state=None,
    shrinking=True,
    tol=0.001,
    verbose=False
)
1.0

Pythonでscikit-learnを使ってSVMによる分類

2016-02-25
このエントリーをはてなブックマークに追加

SVMなので二値分類です。多値分類でもSVMを使うこともありますが、あれは二値分類の繰り返しなのでやっぱりSVMを使うのであれば二値分類なんだろうなぁと思います。

LinearSVC、線形カーネルのサンプルです。相変わらずこんなに簡単にできるPythonってすごいって感心しちゃう。

from sklearn.svm import LinearSVC


def main():

    _training = [
        [0, 1, 0],
        [0, 0, 0]
    ]
    _estimator = LinearSVC()
    _estimator.fit(_training, [1, 0])

    _prediction = _estimator.predict([0, 1, 1])
    print(_prediction)

if __name__ == "__main__":
    main()
$ python sample.py
[1]

無事、1と分類されました。

scikit-learnでトレーニングデータとテストデータを分割する

2016-02-19
このエントリーをはてなブックマークに追加

機械学習させるときに用意したデータの9割を学習用データに、1割をテストデータに使ったりします。その分割を手軽にしてくれます。scikit-learnを使いたくてPython書いてるようなもんです。

from sklearn.cross_validation import train_test_split
import numpy as np

def main():

    _train_x, _train_y, _test_x, _test_y = train_test_split(
        np.array([
            [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [1, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [2, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [3, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [4, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [5, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [6, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [7, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [8, 1, 0, 1, 0, 1, 0, 1, 0, 1],
            [9, 1, 0, 1, 0, 1, 0, 1, 0, 1]
        ]),
        np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1]),
        test_size=0.1
    )
    print(_train_x)

if __name__ == "__main__":
    main()

test_size=0.1、で10%をテスト用データとして分割してくれます。

[[0 1 0 1 0 1 0 1 0 1]
 [8 1 0 1 0 1 0 1 0 1]
 [7 1 0 1 0 1 0 1 0 1]
 [4 1 0 1 0 1 0 1 0 1]
 [2 1 0 1 0 1 0 1 0 1]
 [5 1 0 1 0 1 0 1 0 1]
 [6 1 0 1 0 1 0 1 0 1]
 [1 1 0 1 0 1 0 1 0 1]
 [3 1 0 1 0 1 0 1 0 1]]

これだけでシャッフルして指定した割合で分割してくれるからありがたい。

PythonでWord2Vecを使って類義語抽出

2015-11-12
このエントリーをはてなブックマークに追加

今更のWord2Vec。

分かち書きしたテキストファイルを読み込ませて学習データを作って保存。保存した学習データを読み込んで類義語を出力するところまで。毎回学習してから類義語抽出っていう訳にもいかないから学習データの保存は必要ですよね、っていうサンプル。

Word2Vecはおもしろいし、いろいろ触ってるので今後もブログに書いていこう。このエントリも下書きのまま1年くらい放置されててちゃんとブログ書かねばと反省中。。。

from gensim.models import word2vec

def main():

    data = word2vec.Text8Corpus("/path/to/file")
    model = word2vec.Word2Vec(data, size=250, window=5, min_count=2, workers=4)
    model.save("./teacher.bin")

    model = word2vec.Word2Vec.load("./teacher.bin")
    for _w in model.most_similar(positive=['ジャケット']):
        print(_w)

if __name__ == "__main__":
    main()

Pythonでscikit-learnを使ってランダムフォレストの分類器を書いて、学習結果を保存してみた

2015-10-01
このエントリーをはてなブックマークに追加

分類するだけじゃなくて学習したデータを保存もしています。学習データがあったらデータを読み込んで利用します。

import os

from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib


class RandomForest(object):
    def __init__(self):
        if os.path.exists('./.supervised/data.bin'):
            self._m = joblib.load('./.supervised/data.bin')

        else:
            _training_data = [
                [2, 0, 0, 0],
                [0, 2, 0, 0],
                [0, 0, 2, 0],
                [0, 0, 0, 2],
            ]
            _training_label = [1, 2, 3, 4]

            self._m = RandomForestClassifier()
            self._m.fit(_training_data, _training_label)

            joblib.dump(self._m, './.supervised/data.bin')

    def start(self):
        _test_data = [
            [0, 4, 0, 0],
            [0, 0, 0, 2]
        ]
        _out = self._m.predict(_test_data)

        print(_out)

if __name__ == "__main__":
    _obj = RandomForest()
    _obj.start()

結果出力
[2 4]

Pythonでscikit-learnを使ってNon-negative Matrix Factorization

2015-06-16
このエントリーをはてなブックマークに追加

Non-negative Matrix Factorization(NMFでググるといろいろ出てきます)、非負値行列因子分解です。

集合知プログラミング でも紹介されている特徴を抽出する方法です。推薦エンジンとかにも使われているそうです。

書籍では自前で実装されてますがscikit-learnに同じものがあるので便利に利用させていただきます。

import numpy as np
from sklearn.decomposition import ProjectedGradientNMF


def main():

    X = np.array([
        [1, 0, 0],
        [1, 1, 0],
        [0, 1, 0],
        [0, 1, 0],
        [0, 0, 1],
    ])

    model = ProjectedGradientNMF(init='nndsvdar')
    _res = model.fit_transform(X)
    print(_res)

if __name__ == "__main__":
    main()

実行するとこんな感じで出力されます。

$ python nfm.py
[[ -0.00000000e+00   9.15822497e-01  -0.00000000e+00]
 [  6.85467400e-01   9.15816894e-01  -0.00000000e+00]
 [  6.85636205e-01   2.24117374e-09  -0.00000000e+00]
 [  6.85636205e-01   2.24116561e-09  -0.00000000e+00]
 [ -0.00000000e+00  -0.00000000e+00   9.99944486e-01]]

素晴らしい。

サンプルデータをちゃんと投入すればもうちょっとまともな値がでてきます。パラメータの与え方はちゃんと検証して調整しないとです。

動かした環境はPython3.4で、

$ pip freeze
numpy==1.9.2
scikit-learn==0.16.1
scipy==0.15.1

Python便利。

Pythonでコサイン類似度を使ってテキストの類似度を計算する

2014-11-12
このエントリーをはてなブックマークに追加

テキストの類似度って言っても出現する単語の回数比較でしか無いので文意解釈はしてないです。あくまで「出現した文字の一致度」ですね。

Word2Vecとかを使ってテキストを拡張してあげれば少しは文意を加味した類似度といえるのかもです。

from scipy.spatial.distance import cosine
import unittest


class SentenceSimilarity(object):

    def __init__(self):
        self._A = None
        self._B = None

    @property
    def A(self):
        return self._A

    @property
    def B(self):
        return self._B

    @A.setter
    def A(self, v):
        self._A = [i for i in v.replace(' ', ',').split(',') if len(i) > 0]

    @B.setter
    def B(self, v):
        self._B = [i for i in v.replace(' ', ',').split(',') if len(i) > 0]

    def distance(self):

        if self._A is None or self._B is None:
            return False

        if len(self._A) < 2 or len(self._B) < 2:
            return False

        return self._distance()

    def _distance(self):

        _words = []
        _words.extend(self._A)
        _words.extend(self._B)

        _words = list(set(_words))
        _words.sort()

        _listA = [self._A.count(_w) for _w in _words]
        _listB = [self._B.count(_w) for _w in _words]

        try:
            return 1 - cosine(_listA, _listB)
        except:
            return False


class TestSentenceSimilarity(unittest.TestCase):

    def setUp(self):
        pass

    def test_0(self):

        _sentence = SentenceSimilarity()
        _sentence.A = '今期 業績 予想 未定 期限切れ 肉 問題 販売減'
        _sentence.B = '都市 対抗 野球 西濃運輸 初優勝 佐伯 富士 重工'
        self.assertGreater(_sentence.distance(), 0.0)


    def test_1(self):

        _sentence = SentenceSimilarity()
        _sentence.A = '今期 業績 予想 未定 期限切れ 肉 問題 販売減'

        self.assertEqual(_sentence.distance(), False)

    def test_2(self):

        _sentence = SentenceSimilarity()
        _sentence.A = '今期'
        _sentence.B = '都市'

        self.assertEqual(_sentence.distance(), False)

    def test_3(self):

        _sentence = SentenceSimilarity()
        _sentence.A = '今期,業績,予想,未定'
        _sentence.B = '都市,業績,予想,未定'

        _sentence.B = '業績 対抗 野球 西濃運輸 初優勝'

        self.assertGreater(_sentence.distance(), 0.0)

if __name__ == '__main__':
    unittest.main()

使い方はテストをみていただければご理解いただけるかと。

コサイン類似度の計算なんて

return 1 - cosine(_listA, _listB)

の部分でしかやってなくて、残りは全部下ごしらえです。

_sentence = SentenceSimilarity()
_sentence.A = ‘今期 業績 予想 未定 期限切れ 肉 問題 販売減’
_sentence.B = ‘都市 対抗 野球 西濃運輸 初優勝 佐伯 富士 重工’

インスタンス作って、AとB(命名が安直ですいません)にカンマ切り、もしくはスペース切りの文字列を指定します。なので事前に分かち書きをしておく必要があります。

まあ文章を渡してメソッドの中で分かち書きしてもいいんですけどね。手元にあったのが分かち書き済みだったので今回はそのまま使いました。

_sentence.distance()

で、類似度を求めます。類似度を求める前に_Aと_Bの和集合を作って、和集合の単語リストにある単語が_Aと_Bそれぞれで幾つずつ出現するかを求めます。

上記例だと和集合は[今期,業績,予想,未定,期限切れ,肉,問題,販売減,都市,対抗,野球,西濃運輸,初優勝,佐伯,富士,重工]となり、
_listAは[1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0]
_listBは[0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1]
になるはずです。で、これらをベクトルにしてコサイン類似度を求めます。今は0と1だけですが複数回出現する単語があれば当然2以上の値も出てきます。

コサイン類似度は0から1の値で返ってきて、値が大きければ大きいほど類似しています。上記サンプルだと0が返ってくるはずです。ぜんぜん違う、ってことですね。

アイテムベースのレコメンドに使えると思います。サービスとして提供するレコメンドエンジンであればこんな単純な計算じゃないでしょうね。

Python 3.4.2, scipy 0.14.0 で書きました。

scikit-learnを使ってMovieLensの映画評価データをクラスタリングしてみた

2014-11-07
このエントリーをはてなブックマークに追加

使ったのはMovieLens 100k
「100,000 ratings from 1000 users on 1700 movies.」
だそうです。

from sklearn.cluster import KMeans


def main():

    _items = []
    _f = open('./rating.csv' )
    _lines = _f.readlines()

    for _line in _lines:
        _items.append(_line.split(','))

    _f.close()

    km = KMeans(init='k-means++')
    km.fit(_items)

    print(km.labels_)


if __name__ == '__main__':
    main()

すげえ簡単。。。

CSVは1行が1人分で全部の映画のレーティング情報(0が観てない、評価は1から5)が入っています。1000ユーザーが1700本の映画を評価(未鑑賞含む)してます。

だいたいこんな感じ。

5,3,4,3,3,5,4,1,5,3,2,5,5,5,5,5,3,4,,,,,,,,
4,0,0,0,0,0,0,0,0,2,0,0,4,4,0,0,0,0,,,,,,,,

得られる結果は

[0 1 4 4 3 2 6 3 4 6 3 7 6 2 1 5 1 6 4 7 1 3 3 7,,,,,,,

インデックス2番のユーザーさんと3番のユーザーさんは好きな映画が似る傾向にありそうですね。

Python 3.4.2、scikit-learn 0.15.2 で試しました。

scikit-learnを使ってテキスト文書をクラスタリングしてみた

2014-11-05
このエントリーをはてなブックマークに追加

Clustering text documents using k-means (K平均法を使ってテキスト文書をクラスタリングする)というそのまんまのサンプルがあったので写経して最低限だけ削りだしてみた。

K平均法とかTF-IDFとか潜在意味解析の説明は割愛。

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
from sklearn.decomposition import TruncatedSVD
from sklearn.preprocessing import Normalizer


def main():

    _items = [
        'わたし まけ まし た わ',
        'わたし まけ まし た わ',
        'わたし まけ まし た わ',
        'わたし まけ まし た わ',
        'となり の きゃく は よく かき くう きゃく だ',
        'にわ には にわ なかにわ には にわ にわとり が いる',
        'バカ と テスト と 召喚獣',
        '俺 の 妹 が こんな に 可愛い わけ が ない'
    ]

    vectorizer = TfidfVectorizer(
        use_idf=True
    )
    X = vectorizer.fit_transform(_items)

    lsa = TruncatedSVD(10)
    X = lsa.fit_transform(X)
    X = Normalizer(copy=False).fit_transform(X)

    km = KMeans(
        init='k-means++',
    )
    km.fit(X)

    print(km.labels_)


if __name__ == '__main__':
    main()

テキストは分かち書きされてる状態(空白区切りになってます)でドキュメント単位でリストにいれておく。これを元データとしてTfidfVectorizerに突っ込みます。ここでドキュメントがベクトル化されます。

で、潜在意味解析を通した上でK平均法でクラスタリング。至って単純。
km.labels_を出力すると

[1 1 1 1 0 2 4 3]

こんな感じで出力されるのですが、これは「データセットのインデックス0,1,2,3は1番クラスタ、インデックス4は0番クラスタ、、、」ということです。これを使って元データをグルーピングしておきます。

すっごい簡単。使い方はこれであってる、と思う。たぶん。あ、ドキュメント数は少なくても1,000以上ないときれいにクラスタリングされなそうだし、テキストももっと長くないと納得のいく結果は出力されにくいんじゃないかと。

自分のツイートを使ったり青空文庫を使ったりで気軽に試せそうです。

Python 3.4.2、scikit-learn==0.15.2 で動かしました。

昨日Mahoutの記事書いたばっかりなのにね。

Mahoutをローカルモード(Hadoopを使わない)で使うための設定

2014-11-04
このエントリーをはてなブックマークに追加

0.8あたりからMahoutはHDFSからデータ読み込むのがデフォルトになったのか、ファイルを読み込んでもらおうとしても「HADOOP_HOMEが無いよ!」ってエラー吐いて先に進んでくれません。

Hadoopいれろや、ってことなんですけどたいしてメモリ積んでないVMでHadoopいれると結構ツラいものがあるし、たかだか数百万件のログ読ますのにHadoopいれるのもなぁ、という感じでローカルモードで使う方法調べた時のメモ。使ったのはMahout 0.9です。

/usr/lib/にDLしてきたMahoutを置いて、.bash_profileに

export JAVA_HOME=/usr/lib/jvm/jre-1.7.0
export PATH=$JAVA_HOME/bin:$PATH

export MAHOUT_HOME=/usr/lib/mahout-distribution-0.9
export PATH=$PATH:$MAHOUT_HOME/bin
export MAHOUT_LOCAL=TRUE
export CLASSPATH=:$MAHOUT_HOME/lib/hadoop/hadoop-core-1.2.1.jar:$MAHOUT_HOME/lib:$CLASSPATH

って記述。

細かいことは割愛なんですけど、ポイントは「export MAHOUT_LOCAL=TRUE」の部分で、あとは通常の設定となんも変わらず。

ただ、最近Mahout使うよりPythonで書くほうが多いのであんまりMahout触ってない。