機械学習の前処理でのデータの正規化/標準化

前処理の目的

  • 体重と身長など複数の異なる特徴量を生で扱ってしまうと、出力に対して使いやすい(大まかにFitしやすい)方を優先してしまう問題がある。

内容

  • 問題解決の単純な方法は異なるカテゴリのデータを同じ範囲のデータに変換する。
  • 変換は入力だけでなく、出力も変換する。
  • また、一般的には各特徴量毎に変換する。ただし、画像のように2次元(行/列)ではあるが、意味が全ての次元で等しい場合には、全体で変換することも考えられる。

具体的な変換方法

  • 一般的には正規化と標準化(ZScore化とも言われる)が良く使われる。
  • 正規化は、変換後のデータの最小値, 最大値を0, 1変換する。背景にデータが一様分布に従う場合を想定している。
  • 標準化は、平均0, 標準偏差1に変換する。背景にデータが正規化分布に従うことを想定している。

実践

  • 2次元データ(n_batch, n_feature)のデータであればSklearnのpreprocessingモジュールで簡単に変換できる。
  • 3次元データ、例えば(n_batch, n_object_type, n_object_feature)のような場合にはSklearnが使えない。その場合は下記のような関数を使う。
import sys
import numpy as np
import logging

logger = logging.getLogger(__name__)


class Scaler():
    '''
    Sklearn-API like simple scaler for data preprocessing.
    '''
    def __init__(self, mode):
        if not(mode in ['maxmin', 'standard']):
            logger.error("The mode must be 'maxmin' or 'standard'.")
            sys.exit(1)
        self.mode = mode
        self.maxs = None
        self.mins = None
        self.means = None
        self.stds = None

    def fit(self, data, axis=0):
        '''
        Args:
          data: Ndim numpy array .
          axis: scaling axis, usually batch dimension.
        '''
        if self.mode == 'maxmin':
            self.maxs = data.max(axis=axis)
            self.mins = data.min(axis=axis)
        elif self.mode == 'standard':
            self.means = data.mean(axis=axis)
            self.stds = data.std(axis=axis)
        return

    def transform(self, data):
        if self.mode == 'maxmin':
            d = (data - self.mins)/(self.maxs - self.mins)
        elif self.mode == 'standard':
            d = (data - self.means)/(self.stds)
        return d

    def fit_transform(self, data, axis=0):
        self.fit(data, axis)
        d = self.transform(data)
        return d

    def inverse_transform(self, data):
        if self.mode == 'maxmin':
            d = data*(self.maxs - self.mins) + self.mins
        elif self.mode == 'standard':
            d = (data - self.means)/(self.stds)
            d = data*self.stds + self.means
        return d        

    
if __name__ == '__main__':
    d0 = np.random.randn(100,4,2)

    s = Scaler('maxmin')
    s.fit(d0)
    d1 = s.transform(d0)
    d2 = s.inverse_transform(d1)

    s = Scaler('standard')
    s.fit(d0)
    d1 = s.transform(d0)
    d2 = s.inverse_transform(d1)

ArgparserとConfigparser

Deep Learning関連のプログラムを試していると、やたらと設定パラメタが多い。 これまではargparseを使ってきたけど、コードが煩雑になるのでconfigファイルの扱い方を調べてみた。

argparse

  • まずはargparseの基本的な使い方。
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--hoge', action='store', type=int, default=0)
args = parser.parse_args()

print('hoge:', args.hoge)  # python3 xxx.py --map 2 #=> 'hoge: 2'

ConfigParser

  • 次のようなconfig.iniファイルがあるとする。
  • 基本的にはセクションとパラメタ名を書いていくだけ。
# config.ini
[model] ; Section名
type = MLP
input_size = 81
output_size = 81
hidden_sizes = 64,32

[learning]
data_file = /home/hoge/project/data/xxx.csv
train_ratio = 0.8
n_epoch = 30
lr = 0.0001
  • 使う側の例
import configparser

if __name__ == '__main__':
    config = configparser.ConfigParser()
    config.read('./config.ini')
    # Parameters
    train_ratio = config.getfloat('learning', 'train_ratio')
    lr = config.getfloat('learning', 'lr')
    n_epoch = config.getint('learning', 'n_epoch')
    file_path = config.get('learning', 'data_file')
    
    # Make model and set optimizer
    if config.get('model','type') == 'MLP':
        input_size = config.getint('model', 'input_size')
        output_size = config.getint('model', 'output_size')
        hidden_sizes = list(map(int, config.get('model', 'hidden_sizes').split(',')))
        model = models.MLP(input_size, output_size, hidden_sizes)
...

pythonでのログ(logging)

ロガーは名前で管理される。逆に、同じ名前のロガーは同じものとして扱われる。 それを利用するために、モジュール側ではモジュール名(name)をロガーの名前にしておいて、ユーザ側はモジュールの名前を指定することで当該のロガーを取得して、個別に設定することが可能。 例えば、hoge/foo/bar.pyモジュールの名前はhoge.foo.barになる。

ライブラリ側

  • モジュール(ファイル)の先頭でloggerを生成して、適時出力するだけ。
  • configはトップから渡されることを想定する。
import logging

logger = logging.getLogger(__name__)  # __name__はモジュール名

class Hoge:
    def __init__(self):
        logger.info('A Hoge instance is generated.')

    def foo(self):
        logger.debug('Hoge/foo is called.')

ユーザ側

  • ライブラリ側のloggerのconfigを与える。
  • configにはログのレベル、フォーマット、出力先ファイルなどを設定。デフォルではlogging.WARNINGが設定されている。
  • ロガー毎に指定するなら、package.moduleでモジュール毎にロガーを取得しても良いが、プログラムとして一括で設定する場合には、rootロガーに設定すれば良い。ルートロガーはgetLoger("")で取得可能。
import logging

logging.basicConfig()  # confiを設定
# package/module.pyのロガーをDEBUGで動かす
logging.getLogger('package_name.module_name').setLevel(level=logging.DEBUG)
# 一括して設定したい場合にはrootロガーに設定する。
logging.getLoger("").setLevel(logging.DEBUG)

config

  • formatterのメタ文字は、asctime(ASCII時刻)、filename(ファイル名), funcName(関数名)、module(モジュール名)、message(メッセージ)
# レベル設定
logging.setLevel(logging.DEBUG)
# 出力フォーマット
formatter = logging.Formatter('%(levelname)s:(%(module)s/%(name)s/%(lineno)d:"%(message)s"')
# ファイル名設定
fh = logging.FileHandler('hoge.log')
fh.setFormatter(formatter)
logging.addHandler(fh)
# 標準出力
sh = logging.StreamHandler()
sh.setFormatter(formatter)
logging.addHandler(sh)

Pythonでのインターフェイス(ABCモジュール)

  • pythonインターフェイスのようなことをやりたい場合にはABCモジュールというのが使えるようだ。
  • でも、あんまり使っている印象はなく、raise NotImplementedErrorで簡易的に代用している場合が多いようだ。

ABCモジュールを使わない場合

  • 簡易的にraise NotImplemntedError例外を出す。
  • インスタンスの生成自体はできてしまう。
  • エラーが発生するのはf()の実行時。
class Parent:
    def f(self):
        raise NotImplementedError

class Child(Parent):
    def __init__(self):
        super(Child, self).__init__()
        pass

if __name__ == '__main__':
    c = Child()   # fを実装していなくても生成できる
    c.f()             # これは当然エラー

ABCモジュールを使う場合

  • 使わない場合との違いは、f()を実装しないとインスタンスの生成時点でエラーが発生する。
from abc import ABCMeta, abstractmethod

class Parent(metaclass=ABCMeta):
    @abstractmethod
    def f(self):
        raise NotImplementedError

class Child(Parent):
    def __init__(self):
        super(Child, self).__init__()
        pass

if __name__ == '__main__':
    c = Child()  # エラー発生

pythonのパッケージとimport

パッケージの構成

  • リポジトリ名とパッケージ名は同じになる(ことが多い)。パッケージは小文字で、アンダースコアも(なるべく)使わず。モジュールは小文字でスネーク。(クラスはキャメルケース)
  • 基本的にはtestはpackageの各ディレクトリ、ファイルと対応する。よって、1モジュールに1テストファイル。
 package(repo)
    - README.md
    - LICENSE
    - setup.py
    - docs
    - examples
    - test
    - package
        - __init__.py
        - subpakcage
            - __init__.py
            - hoge.py
            - foo.py
        - hoge.py
        - foo.py

importの書き方

  • 相対importは基本的に使わずに絶対importを使い、トップパッケージから書く。
  • 例えば、pakcage/subpackage/init.pyの書き方は下記。
from pakcage.subpackage.hoge import xxx # xxxはimport対象
from package.subpackage.foo import yyy
  • package/hoge.pyは例えば下記。
from pakcage.foo import xxx
from package.subpackage.foo yyy

注意事項

  • この絶対importの書き方だと各モジュールを開発している時にそのモジュールのディレクトリで実行しても実行はできない。

画像から塗り絵問題の生成(線画抽出)

塗り絵生成

  • 先日のお絵かきロジック生成の時にPILの使い方を覚えた。
  • その中で、画像処理って使うのも単純で、アルゴリズムも単純なものが多いなぁ、という感想をもった。
  • 例えば、2値化して、エッジ強調すれば塗り絵になるなぁ、すぐ出来そうだなぁ、みたいな。ということで調べたらすぐ出来た。画像処理は見た目がすぐわかるから面白いなぁ。
  • PILの中に、Filter.Find_Edgeというフィルタがあって、それでも一発で生成されるみたいだけど、膨張させて作るほうが綺麗な感じはある。
  • 特定の絵を与えて、膨張(dilation)の大きさを変えて塗り絵画像を生成できる。
  • 処理は敢えて各ステップをそのまま書いているのでわかると思うけれど、
    1. 画像をグレースケール化(convert('L'))
    2. その画像を膨張(MaxFilter)
    3. 膨張したものとグレースケール化したものの差分を取る(difference)。これでエッジ化される
    4. 白黒反転してるので反転(invert)
  • 膨張という処理だけでも結構面白そうで、よりアニメちっくな線画抽出だとこんな綺麗な例があるみたい。
import os
import argparse
from PIL import Image
from PIL import ImageOps
from PIL import ImageFilter
from PIL import ImageChops

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--img', action='store', type=str)
    parser.add_argument('--dilation', action='store', type=int, default=5)
    args = parser.parse_args()

    dir, fname = os.path.split(args.img)
    img_name, ext = os.path.splitext(fname)
    img_out_name = img_name + '_nurie' + ext

    print('File:{} is converted to {}'.format(fname, img_out_name))

    img_org = Image.open(args.img)
    img_gray = img_org.convert('L')  # Gray scale image
    img_gray_dilation = img_gray.filter(ImageFilter.MaxFilter(args.dilation))  # dilation
    img_diff = ImageChops.difference(img_gray, img_gray_dilation)  # diff(Edge image)
    img_diff_invert = ImageOps.invert(img_diff)

    img_diff_invert.show()
    img_diff_invert.save(img_out_name)

    # Memo: Below command generate similar image
    # ImageOps.invert(img_gray.filter(ImageFilter.FIND_EDGES))

サンプル

f:id:nobUnaga:20180329095748p:plain
元画像

f:id:nobUnaga:20180329095737p:plain
生成した塗り絵問題
f:id:nobUnaga:20180329095758p:plain
Filter.Find_Edgeでの生成

ヒートマップ

配列内のデータをRGBのヒートマップに変換したいことは良くあるのでメモ。 下の関数は配列内のデータの最大値(max_val), 最小値(min_val)とヒートマップ化したい値vを渡すと、そのvのRGBを返す。

def calc_heatmap_rgb(min_val, max_val, v, str_out=True):
    mi, ma = float(min_val), float(max_val)
    ration = 2 *(v-mi) / (ma - mi)
    b = int(max(0, 255*(1 - ratio)))
    r = int(max(0, 255*(ratio -1)))
    g = 255 - b - r
    if str_out:
        return '{:0>2X}{:0>2X}{:0>2X}'.format(r, g, b)
    else:
        return r, g, b