Ruby – chop/chop!～末尾文字の削除

2020-11-28 / tau / コメントする

chopは文字列の末尾1文字を削除する。

p("abcd".chop)
#"abc"

p("いろはに".chop)
# "いろは"

p("abcd".chop)

#"abc"

p("いろはに".chop)

# "いろは"

末尾に改行文字がある場合は、それらが削除される。ただし"\n\r"の場合だけは"\n"が削除されずに残る。

p("abcd\n".chop)
# "abcd"

p("abcd\r".chop)
# "abcd"

p("abcd\r\n".chop)
# "abcd"

p("abcd\n\r".chop)
# "abcd\n"

p("abcd\n".chop)

# "abcd"

p("abcd\r".chop)

# "abcd"

p("abcd\r\n".chop)

# "abcd"

p("abcd\n\r".chop)

# "abcd\n"

chopは非破壊的であり、元の文字列は変更されない。

s = "abcd"

p(s.chop)
# "abc"

p(s)
# "abcd"

s = "abcd"

p(s.chop)

# "abc"

p(s)

# "abcd"

chop!にすると破壊的メソッドになり、戻り値も変更後の文字列。

s = "abcd"

p(s.chop!)
# "abc"

p(s)
# "abc"

s = "abcd"

p(s.chop!)

# "abc"

p(s)

# "abc"

Ruby – 配列の演算

2020-11-27 / tau / コメントする

概要

Rubyの配列同士の演算はPythonのようにブロードキャストされない。加算／減算はそれぞれ和集合／差集合のように扱われる。

配列同士の加算

`+`～加算は和集合

配列同士を⁺で加算すると双方の和集合となる。

a = [1, 2, 3, 4, 5]
b = [3, 4, 5, 6, 7]

p(a + b)
# [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]

a = [1, 2, 3, 4, 5]

b = [3, 4, 5, 6, 7]

p(a + b)

# [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]

必ずしも重複が削除されるわけではない。

c = [1, 1, 2, 3, 4]
d = [4, 4, 5, 5, 6, 6]

p(c + d)
# [1, 1, 2, 3, 4, 4, 4, 5, 5, 6, 6]

c = [1, 1, 2, 3, 4]

d = [4, 4, 5, 5, 6, 6]

p(c + d)

# [1, 1, 2, 3, 4, 4, 4, 5, 5, 6, 6]

`−`～減算は差集合

減算の場合、元の配列から重なる要素だけが削除される。下の例ではaとbに共通な[3, 4]が削除され、[5, 6]はもともとaに含まれていないので無視される。

p(a - b)
# [1, 2]

1 2	p(a - b) # [1, 2]

積集合の求め方

加算と減算を組み合わせて、2つの配列の席集合に相当する配列が得られる。

p(a - (a - b))
# [3, 4, 5]

1 2	p(a - (a - b)) # [3, 4, 5]

要素の追加

<<演算子は左辺の配列に右辺の要素を追加する。連続して複数の要素も追加可能。push()と同じ動作。

a = [1, 2, 3]
a << 4
p(a)
// [1, 2, 3, 4]

a << 5 << 6
p(a)
// [1, 2, 3, 4, 5, 6]

a = [1, 2, 3]

a << 4

p(a)

// [1, 2, 3, 4]

a << 5 << 6

p(a)

// [1, 2, 3, 4, 5, 6]

Ruby – 配列メソッド

2020-11-27 / tau / コメントする

概要

配列オブジェクトのメソッドのには破壊系と非破壊系があり、注意を要する。

パラメーター系

`size/length`～要素数の取得

sizeメソッド、lengthメソッドとも配列の要素数を返すエイリアス。

a = [1, 2, 3]
puts(a.size)
# 3

puts(a.length)
# 3

a = [1, 2, 3]

puts(a.size)

# 3

puts(a.length)

# 3

`sum`～合計値の取得

sumメソッドは配列要素の合計値を返す。

puts(a.sum)
# 6

1 2	puts(a.sum) # 6

要素抽出系

`first/last`～先頭要素／末尾要素の取得

firstメソッドは配列の先頭の要素、lastメソッドは末尾の要素を返す。

a = [1, 2, 3]
p(a.first)
# 1

p(a.last)
# 3

a = [1, 2, 3]

p(a.first)

# 1

p(a.last)

# 3

sample～ランダムな要素取得

sampleメソッドは配列からランダムに1つ要素を返す。引数を指定すると重複なしでその個数分のサンプル配列を返すが、引数が要素数を超えた場合は全要素がランダムに並べられた配列が返される。

p(a.sample)
# 1

p(a.sample(2))
# [3, 1]

p(a.sample(5))
# [2, 1, 3]

p(a.sample)

# 1

p(a.sample(2))

# [3, 1]

p(a.sample(5))

# [2, 1, 3]

破壊的メソッド

`push/unshift`～要素の追加

pushメソッドは配列の末尾に要素を追加し、unshiftメソッドは配列の先頭に要素を追加する。いずれも元の配列を変更する（要素の追加は<<演算子でもできる）。

a = [1, 2, 3]
a.push(4)
# [1, 2, 3, 4]

p(a)
# [0, 1, 2, 3, 4]

a.unshift(0)
# 4

p(a)
# [0, 1, 2, 3]

a = [1, 2, 3]

a.push(4)

# [1, 2, 3, 4]

p(a)

# [0, 1, 2, 3, 4]

a.unshift(0)

# 4

p(a)

# [0, 1, 2, 3]

`pop/shift`～要素の取出し

popメソッドは配列の末尾から要素を取り出し、shiftメソッドは配列の先頭から要素を取り出す。いずれも元の配列が変更され、取り出された要素が戻り値となる。

p(a.pop)
# 4

p(a)
# [0, 1, 2, 3]

p(a.shift)
# 0

p(a)
# [1, 2, 3]

p(a.pop)

# 4

p(a)

# [0, 1, 2, 3]

p(a.shift)

# 0

p(a)

# [1, 2, 3]

非破壊的メソッド

`reverse`～要素の順番の反転

reverseメソッドは、元の配列の要素の順番を反転した配列を新たに生成して返す。

a = [1, 2, 3, 4, 5]
p(a.reverse)
# [5, 4, 3, 2, 1]

p(a)
# [1, 2, 3, 4, 5]

a = [1, 2, 3, 4, 5]

p(a.reverse)

# [5, 4, 3, 2, 1]

p(a)

# [1, 2, 3, 4, 5]

`sort`～昇順ソート

sortメソッドは、元の配列を昇順でソートした配列を生成して返す。文字列オブジェクトの場合は辞書順で、大文字→小文字の順。

a = [3, 1, 5, 2, 4]
p(a.sort)
# [1, 2, 3, 4, 5]

p(a)
# [3, 1, 5, 2, 4]

a = [3, 1, 5, 2, 4]

p(a.sort)

# [1, 2, 3, 4, 5]

p(a)

# [3, 1, 5, 2, 4]

`sort.reverse`～降順ソート

sortメソッドとreverseメソッドの組み合わせで、降順にソートされた配列が生成されて返される。

p(a.sort.reverse)
# [5, 4, 3, 2, 1]

p(a)
#[3, 1, 5, 2, 4]

p(a.sort.reverse)

# [5, 4, 3, 2, 1]

p(a)

#[3, 1, 5, 2, 4]

`uniq`～重複要素の削除

uniqは配列中の重複した要素を削除して1つにし、重複のない配列とする。元の配列は変更されず、新たな配列が生成される。

a = [1, 2, 2, 3, 3, 3, 4, 4, 5]
p(a.uniq)
# [1, 2, 3, 4, 5]

p(a)
# [1, 2, 2, 3, 3, 3, 4, 4, 5]

a = [1, 2, 2, 3, 3, 3, 4, 4, 5]

p(a.uniq)

# [1, 2, 3, 4, 5]

p(a)

# [1, 2, 2, 3, 3, 3, 4, 4, 5]

`shuffle`～要素のシャッフル

shuffleメソッドは、元の配列の要素をランダムに並べ替えた配列を生成して返す。

a = [1, 2, 3, 4, 5]
p(a.shuffle)
# [1, 5, 4, 2, 3]

p(a)
# [1, 2, 3, 4, 5]

a = [1, 2, 3, 4, 5]

p(a.shuffle)

# [1, 5, 4, 2, 3]

p(a)

# [1, 2, 3, 4, 5]

文字列化・配列化

`split`～文字列の配列への分解

splitメソッドは、指定した文字列で元の文字列を区切って、それぞれが要素となる配列を生成する。

p("い,ろ,はに,ab,c".split(","))
# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))
# ["a-b", "c", "-d", "e-f"]

p("い,ろ,はに,ab,c".split(","))

# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))

# ["a-b", "c", "-d", "e-f"]

`join`～配列要素の文字列への結合

joinメソッドは、配列の各要素を指定した文字列でつないだ文字列を生成する。

a = ["ABC", "KLM", "XYZ"]
puts(a.join("および"))
# ABCおよびKLMおよびXYZ

a = ["ABC", "KLM", "XYZ"]

puts(a.join("および"))

# ABCおよびKLMおよびXYZ

Ruby – 文字列メソッド

2020-11-26 / tau / コメントする

`length`～文字列の長さ

半角も全角も1文字。

puts("abcdefg".length)
# 7

puts("いろはにほへと".length)
# 7

puts("Rubyルビー".length)
# 7

puts("abcdefg".length)

# 7

puts("いろはにほへと".length)

# 7

puts("Rubyルビー".length)

# 7

結合系

`+`～文字列の連結

+演算子は文字列同士を結合する。半角と全角の連結もok。

puts("ABCD" + "EFG")
# ABCDEFG

puts("いろはに" + "ほへと")
# いろはにほへと

puts("Ruby" + "ルビー")
# Rubyルビー

puts("ABCD" + "EFG")

# ABCDEFG

puts("いろはに" + "ほへと")

# いろはにほへと

puts("Ruby" + "ルビー")

# Rubyルビー

`join`～配列要素の文字列化

配列のメソッドだが、joinメソッドは配列要素を指定した文字列で結合して文字列にする。

a = ["ABC", "KLM", "XYZ"]
puts(a.join("および"))
# ABCおよびKLMおよびXYZ

a = ["ABC", "KLM", "XYZ"]

puts(a.join("および"))

# ABCおよびKLMおよびXYZ

分割系

`split`～文字列の配列への分割

引数で指定した文字列で元の文字列を分解して配列化。

p("い,ろ,はに,ab,c".split(","))
# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))
# ["a-b", "c", "-d", "e-f"]

p("い,ろ,はに,ab,c".split(","))

# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))

# ["a-b", "c", "-d", "e-f"]

2つ目の例から、引数で指定した文字列"--"が見つかるたびに、そこまでの文字列を要素として配列に加えていることがわかる。

削除系

`delete`～特定の文字の削除

引数で指定した文字列を削除。

puts("a,b,c,d".delete(","))
# abcd

puts("The rain in Spain stays mainly in the plain.".delete("ain"))
# The r  Sp stys mly  the pl.

puts("a,b,c,d".delete(","))

# abcd

puts("The rain in Spain stays mainly in the plain.".delete("ain"))

# The r Sp stys mly the pl.

`strip`～前後のスペースの削除

半角スペースを削除。全角スペースは削除されない。

puts(" a b c ".strip)
# a b c

puts("　い　ろ　は　".strip)
# 　い　ろ　は　
# 最後にも全角スペースが残っている

puts(" a b c ".strip)

# a b c

puts("　い　ろ　は　".strip)

# 　い　ろ　は　

# 最後にも全角スペースが残っている

chop/chop!～末尾文字の削除

chop/chop!は末尾文字を削除する。

chomp/chomp!～末尾の改行文字の削除

chomp/chomp!は末尾文字を削除する。

変換系

`upcase/downcase`～大文字化／小文字化

アルファベットの大文字化／小文字化。

puts("Ruby".upcase)
# RUBY

puts("Ruby".downcase)
# ruby

puts("Ruby".upcase)

# RUBY

puts("Ruby".downcase)

# ruby

PCA – LFWデータセット

2020-11-26 / tau / コメントする

概要

Scikit-learnで提供されているLFW peopleデータセットを、主成分分析を使って分析する。

データの読み込みと確認

LFWデータセットは世界の著名人の顔画像を、その名前とそれに対応するクラスデータとともに格納したものである。

書籍”Pythonではじめる機械学習”に沿って、画像サイズを0.7にし、20枚以上の画像がある人物を抽出する。

import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

fig, axes = plt.subplots(2, 5, figsize=(6.4, 2.4),
    subplot_kw={'xticks':(), 'yticks':()})

fig.subplots_adjust(hspace=0.4)

for target, image, axis in zip(ds.target, ds.images, axes.ravel()):
    axis.imshow(image, cmap='gray')
    axis.set_title(ds.target_names[target], fontsize=8)

plt.show()

import matplotlib.pyplot as plt

from sklearn.datasets import fetch_lfw_people

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

fig, axes = plt.subplots(2, 5, figsize=(6.4, 2.4),

subplot_kw={'xticks':(), 'yticks':()})

fig.subplots_adjust(hspace=0.4)

for target, image, axis in zip(ds.target, ds.images, axes.ravel()):

axis.imshow(image, cmap='gray')

axis.set_title(ds.target_names[target], fontsize=8)

plt.show()

画像の人物は書籍と同じだが顔画像は異なっている。書籍執筆後画像データが追加／変更されたものと思われる。

画像の枚数の絞り込み

元のコード

LFW peopleの画像データは、人物によって枚数にばらつきがある（特にGeorge Bushだけ500枚を超えている）。画像データの多寡によるばらつきを抑えるため、書籍では画像の数を50枚までとし、それ以上の画像は切り落としている。

このコードがちょっとわかり難かったので、別にこちらで整理している。

import numpy as np
from sklearn.datasets import fetch_lfw_people

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

print(X_people.shape)
# (2063, 5655)

print(y_people.shape)
# (2063,)

print(X_people)
# [[0.22091503 0.23660131 0.30457515 ... 0.06928104 0.06666667 0.08888888]
#  [0.2627451  0.31764707 0.3477124  ... 0.03398693 0.03267974 0.03660131]
#  [0.07450981 0.05882353 0.05882353 ... 0.08888888 0.08888888 0.10065359]
#  ...
#  [0.13986929 0.0875817  0.10849673 ... 0.05751634 0.02614379 0.02091503]
#  [0.2130719  0.25882354 0.22091503 ... 0.82222223 0.82483655 0.8326797 ]
#  [0.43529412 0.50326794 0.57124186 ... 0.05359477 0.05359477 0.05490196]]

print(y_people)
# [61 25  9 ...  9 37 22]

import numpy as np

from sklearn.datasets import fetch_lfw_people

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

print(X_people.shape)

# (2063, 5655)

print(y_people.shape)

# (2063,)

print(X_people)

# [[0.22091503 0.23660131 0.30457515 ... 0.06928104 0.06666667 0.08888888]

# [0.2627451 0.31764707 0.3477124 ... 0.03398693 0.03267974 0.03660131]

# [0.07450981 0.05882353 0.05882353 ... 0.08888888 0.08888888 0.10065359]

# ...

# [0.13986929 0.0875817 0.10849673 ... 0.05751634 0.02614379 0.02091503]

# [0.2130719 0.25882354 0.22091503 ... 0.82222223 0.82483655 0.8326797 ]

# [0.43529412 0.50326794 0.57124186 ... 0.05359477 0.05359477 0.05490196]]

print(y_people)

# [61 25 9 ... 9 37 22]

k-近傍法との組み合わせによる精度の確認

書籍では、画像を50枚以下に制限したデータについて、k-近傍法(knn)を適用したときのスコア、元データを主成分分析によって変換した場合のknnのスコアを確認している。

その過程をトレースしてみた。

画像データを最近傍データ1つで判定する1-nnの実行結果は、スコアは0.23と低い
元の画像データを100個の主成分で変換したデータに対しては、1-nnのスコアは0.31と若干向上
PCAインスタンス生成時にwhiten=Trueを指定しない場合、PCA変換後もスコアは向上しなかった

主成分の可視化

PCA.fit()を実行すると、PCA.components_に主成分が格納される。components_は2次元配列で、[主成分の数, 元の特徴量数]という形になっている。たとえば今回のデータの場合、主成分の数はn_componentsで指定した100、特徴量の数は画像のピクセル数87×65=5655となり、components_は100×5655の2次元配列になっている。

(1) $\begin{equation*} \tt{components_} = \left[ \begin{array}{ccc} (p_{0, 0} & \cdots & p_{0, 5654} ) \\ & \vdots &\\ (p_{99, 0} & \cdots & p_{99, 5654}) \end{array} \right] = \left[ \begin{array}{c} \boldsymbol{p}_0 \\ \vdots \\ \boldsymbol{p}_{99} \end{array} \right] \end{equation*}$

components_に収められた主成分はそれぞれが画像データと同じサイズの配列なので、これらを画像として表示させてみる。

たとえばComponent-0は顔と背景のコントラスト、Component-2は顔の左右の明るさの差をコーディングしているように見える、と書籍では解説している。その他にも、Component-5は目の下の出っ張った部分、Component-11は鼻筋のあたりを表現しているかもしれないといった想像はできる。

上の画像は以下のコードで表示させたが、要点は以下の通り。

最低20枚の画像を持つ人物のみ読み込んでいる
画像の最大数を50枚以下に制限している
訓練データとテストデータに分割し、訓練データを主成分分析にかけている
components_プロパティーの主成分配列のうち、15行分を取り出して表示させている
表示にあたって、リニアな5655の要素を画像の形(87, 65)に変形している
components_の形状が、100行×5655の2次元配列であることを確認

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.neighbors import KNeighborsClassifier

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)
image_shape = ds.images[0].shape

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(
    X_people, y_people, stratify=y_people, random_state=0)

pca = PCA(n_components=100, whiten=True, random_state=0).fit(X_train)

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})
fig.subplots_adjust(hspace=0.3)

for i, (component, axis) in enumerate(zip(pca.components_, axes.ravel())):
    axis.imshow(component.reshape(image_shape))

    axis.set_title("Component-{}".format(i), fontsize=8)

plt.show()

print("image shape: {}".format(image_shape))
print("image size : {}".format(image_shape[0] * image_shape[1]))
print("components shape : {}".format(pca.components_.shape))

# image shape: (87, 65)
# image size : 5655
# components shape : (100, 5655)

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

from sklearn.decomposition import PCA

from sklearn.neighbors import KNeighborsClassifier

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

image_shape = ds.images[0].shape

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(

X_people, y_people, stratify=y_people, random_state=0)

pca = PCA(n_components=100, whiten=True, random_state=0).fit(X_train)

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})

fig.subplots_adjust(hspace=0.3)

for i, (component, axis) in enumerate(zip(pca.components_, axes.ravel())):

axis.imshow(component.reshape(image_shape))

axis.set_title("Component-{}".format(i), fontsize=8)

plt.show()

print("image shape: {}".format(image_shape))

print("image size : {}".format(image_shape[0] * image_shape[1]))

print("components shape : {}".format(pca.components_.shape))

# image shape: (87, 65)

# image size : 5655

# components shape : (100, 5655)

次元圧縮された主成分からの復元

概要

主成分の意味の一つとして、元のデータは主成分の線形和で表せるという解釈がある。

(2) $\begin{equation*} \boldsymbol{x} = (x_0, ..., x_n) = a_0 \boldsymbol{p}_0 + a_1 \boldsymbol{p}_1 + a_2 \boldsymbol{p}_2 + \cdots \end{equation*}$

LFWの顔画像データで考えると、components_に収められた主成分の重みによって、元のそれぞれの人物の画像を再現しようとすることになる。

そこで、限られた主成分だけを用いて元の顔画像を再現してみる。

顔画像の選定

まず、特に有名な人物の顔画像をいくつか表示させてみた。選んだ人物は、Arnold Schwarzenegger, Tiger Woods, Vladimir Putinの3人。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)
image_shape = ds.images[0].shape

names = ['Arnold Schwarzenegger', 'Tiger Woods', 'Vladimir Putin']

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})
fig.subplots_adjust(hspace=0.3)

for name, axes_row in zip(names, axes):
    id = np.where(ds.target_names == name)[0][0]
    for image_num, axis in zip(np.where(ds.target == id)[0][:5], axes_row):
        axis.imshow(ds.images[image_num])
        axis.set_title("Image {}".format(image_num), fontsize=8)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

image_shape = ds.images[0].shape

names = ['Arnold Schwarzenegger', 'Tiger Woods', 'Vladimir Putin']

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})

fig.subplots_adjust(hspace=0.3)

for name, axes_row in zip(names, axes):

id = np.where(ds.target_names == name)[0][0]

for image_num, axis in zip(np.where(ds.target == id)[0][:5], axes_row):

axis.imshow(ds.images[image_num])

axis.set_title("Image {}".format(image_num), fontsize=8)

plt.show()

これらの画像から、一旦次元削減して復元する画像を選ぶ。Shwalzzeneggerは正面少し左向きの31番、Tiger Woodsは少し右側から撮った歯を出している683番、Putinは左を向いた顔をほぼ正面から撮った372番を選んだ。

次元削減後の逆変換

そして次元数を変化させながらPCAモデルに全データを学習させ、それらのモデルで3枚の画像を変形し、逆変換する。

10個の主成分では、3人とも似たような顔になっているが、30個になると顔の方向や葉を出しているかどうかといった特徴が表れ始めている。

70個から100個にかけて、ShwaltzeneggerとWoodsはかなり元の顔に近いが、Putinはあまり判然としない。前者2人が「濃い」顔立ちなのに比べると、Putinの顔立ちは平板だということだろうか。

この画像は、以下の手順で作成した。

20枚以上の画像を持つ人物を選び、画像の枚数を50枚以下に制限
3人の顔画像について、次元数を10、30、70、100と変化させて以下を実行
1. 設定された次元数で全データを学習
2. 学習済みモデルで各顔画像を変換（ここで次元が削減される）
3. 設定された次元数で元の顔画像に逆変換

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)
image_shape = ds.images[0].shape

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

images = [31, 683, 372]
n_component_list = [10, 30, 70, 100]

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})
fig.subplots_adjust(hspace=0.3)

for r, image_id in enumerate(images):
    axes[r, 0].imshow(ds.images[image_id])
    axes[r, 0].set_title("original image", fontsize=7)

for c, n_components in enumerate(n_component_list):
    pca = PCA(n_components=n_components, whiten=True, random_state=0).fit(X_people)
    for r, image_id in enumerate(images):
        image_trans = pca.transform(ds.data[image_id].reshape(1, -1))
        image_inv = pca.inverse_transform(image_trans)
        axes[r, c + 1].imshow(image_inv.reshape(image_shape))
        axes[r, c + 1].set_title("{} components".format(n_components), fontsize=7)

plt.show()

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

image_shape = ds.images[0].shape

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

images = [31, 683, 372]

n_component_list = [10, 30, 70, 100]

fig, axes = plt.subplots(3, 5, subplot_kw={'xticks':(), 'yticks':()})

fig.subplots_adjust(hspace=0.3)

for r, image_id in enumerate(images):

axes[r, 0].imshow(ds.images[image_id])

axes[r, 0].set_title("original image", fontsize=7)

for c, n_components in enumerate(n_component_list):

pca = PCA(n_components=n_components, whiten=True, random_state=0).fit(X_people)

for r, image_id in enumerate(images):

image_trans = pca.transform(ds.data[image_id].reshape(1, -1))

image_inv = pca.inverse_transform(image_trans)

axes[r, c + 1].imshow(image_inv.reshape(image_shape))

axes[r, c + 1].set_title("{} components".format(n_components), fontsize=7)

plt.show()

同一人物の画像

さらに、3人について1人ずつ、3枚の顔画像について同様のことを行った結果が以下の通り。

Shwalzeneggerの後半2枚は向きが逆だが口元などがよく似ていて、目元と口元の特徴が強調されている。1枚目の画像はこの2枚と特徴が違うが、主成分30個あたりではよく似た感じともいえる。

Tiger Woodsも、主成分30個のところで173と683の画像が似ている。だが、535については一貫して他の2つと異なっているように見える。個人の特徴よりも顔の表情に大きく引きずられているようだ。

Putinは60と372の画像が割に似ているが、239の画像はかなり異なり、コントラストが強調されているようだ。60や372では、そもそも顔画像が平板なせいなのか、主成分を増やしても明確な画像が得られていない（他の人物との区別も難しいのではないだろうか）。

第2主成分までによるクラスの分布

第1主成分と第2主成分だけを使って、各クラスの分布をみてみる。62人の人物の各画像データが1つの点に対応している。2つの主成分だけでは人物が明確なクラスターとしては認識し難い（というよりもクラスが多すぎて識別も難しい）。

試しに表示するクラスを5つに限定してみる。やはり2つの主成分では明確なクラスターは確認できない。先ほどの変換・逆変換の結果でも、主成分10個でも個々の顔の識別は困難だったので、2つの主成分では難しいのは自明だが。

以上の可視化のコードは以下の通り。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(
    X_people, y_people, stratify=y_people, random_state=0)

pca = PCA(n_components=3, whiten=True, random_state=0).fit(X_train)

X_trans = pca.transform(X_train)

target_classes = np.unique(y_train)

fig, axis = plt.subplots()

for target_class in target_classes[:5]:
    mask = np.zeros(y_train.shape, dtype=np.bool)
    mask[np.where(y_train == target_class)] = 1
    axis.scatter(X_trans[mask, 0], X_trans[mask, 1])
    axis.set_xlabel("First principal component")
    axis.set_ylabel("Second principal component")

plt.show()

print("components_.shape : {}".format(pca.components_.shape))
print("X_train -> X_trans: {} -> {}".format(X_train.shape, X_trans.shape))
print("y_train.shape     : {}".format(y_train.shape))

# components_.shape : (3, 5655)
# X_train -> X_trans: (1547, 5655) -> (1547, 3)
# y_train.shape     : (1547,)

import numpy as np

import matplotlib.pyplot as plt

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(

X_people, y_people, stratify=y_people, random_state=0)

pca = PCA(n_components=3, whiten=True, random_state=0).fit(X_train)

X_trans = pca.transform(X_train)

target_classes = np.unique(y_train)

fig, axis = plt.subplots()

for target_class in target_classes[:5]:

mask = np.zeros(y_train.shape, dtype=np.bool)

mask[np.where(y_train == target_class)] = 1

axis.scatter(X_trans[mask, 0], X_trans[mask, 1])

axis.set_xlabel("First principal component")

axis.set_ylabel("Second principal component")

plt.show()

print("components_.shape : {}".format(pca.components_.shape))

print("X_train -> X_trans: {} -> {}".format(X_train.shape, X_trans.shape))

print("y_train.shape : {}".format(y_train.shape))

# components_.shape : (3, 5655)

# X_train -> X_trans: (1547, 5655) -> (1547, 3)

# y_train.shape : (1547,)

Ruby – コメント

2020-11-26 / tau / コメントする

1行コメント～`#`

文頭に'#'があると、以降行末までコメントになる。

# 1行コメント
# one line comment

1 2	# 1行コメント # one line comment

複数行コメント～`=begin/=end`

=begin～=endの間の行は埋め込みドキュメントとして実行時には無視される。=beginと=endはそれぞれ行頭になければならない。

=begin
複数行コメント
multi line comments
=end

=begin

複数行コメント

multi line comments

=end

`END`の応用

__END__はコードの終端を示し、それ以降の記述は実行対象にならない。

puts "some executions"

__END__

以降は全てコメント
いくら書いても無視される

puts "some executions"

__END__

以降は全てコメント

いくら書いても無視される

Ruby – コンソール表示

2020-11-26 / tau / コメントする

puts

putsはオブジェクトの内容を表示する。文の実行ごとに改行する。

puts("Ruby")
puts("Diamond")
puts(["one", "two", 3])

# Ruby
# Diamond
# one
# two
# 3

puts("Ruby")

puts("Diamond")

puts(["one", "two", 3])

# Ruby

# Diamond

# one

# two

# 3

print

printはオブジェクトの内容を表示する。改行はしない。

print("Ruby")
print("Diamond")
print(["one", "two", 3])

# RubyDiamond["one", "two", 3]

print("Ruby")

print("Diamond")

print(["one", "two", 3])

# RubyDiamond["one", "two", 3]

p

pはオブジェクトの形式がわかるように表示する。文の実行ごとに改行する。

p("Ruby")
p('Diamond')
p(["one", "two", 3])

# "Ruby"
# "Diamond"
# ["one", "two", 3]

p("Ruby")

p('Diamond')

p(["one", "two", 3])

# "Ruby"

# "Diamond"

# ["one", "two", 3]

Python – 配列要素の重複数を制限する

2020-11-24 / tau / コメントする

概要

文字で表現するとわかり難いが、要するに次のようなことを想定している。たとえば次のような1次元の配列があるとする。

import numpy as np

np.random.seed(0)
targets = np.random.randint(0, 5, 20)

print(targets)
# [4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4]

print(np.bincount(targets))
# [5 5 2 4 4]

import numpy as np

np.random.seed(0)

targets = np.random.randint(0, 5, 20)

print(targets)

# [4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4]

print(np.bincount(targets))

# [5 5 2 4 4]

この配列には20個の要素があり、0～4の数値がそれぞれ5個、5個、2個、2個、4個、4個、順不同で含まれている。

この配列において、各数値の数を最大でも3個以内となるように切り落としたい、というのが目標。

たとえば、機械学習の教師データの数がターゲットごとにばらついている場合、各ターゲットのデータ数をある程度の数以下に抑えたいときが想定される。

上の例で仮に早く出現した準から3つまでを残して後は捨てるとすれば、以下のような配列になる。

内容：4 0 3 3 3 1 3 2 4 0 0 4 2 1 0 1 1 0 1 4
個数：1 1 1 2 3 1 4 1 2 2 3 3 2 2 4 3 4 5 5 4

なお、単に1つの配列の要素を切り落とすだけでなく、これと対応する配列が別にあって、その要素についても同時に切り落とすことも想定する。これは、機械学習のターゲット配列でデータを制限するのに、これに紐づけられた画像データなどを格納した配列も同時に操作するイメージ。

手順

ターゲットごとのインデックスの取得

targetsの20個のデータのうちid=0について考える。targetsの要素のうち値が0のものは5個あり、それらのインデックスは(1, 9, 10, 14, 17)。同様にid=1についても5個あり、インデックスは(5, 13, 15, 16, 18)。

このようにしてid=0～4についてインデックスを書き出すと以下の通りになる。

0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19

各idに対応する配列はnumpy.where()関数を用いて以下のように得られる。

for id in range(5):
    array = np.where(targets == id)[0]
    print("{}:{}".format(id, array))

# 0:[ 1  9 10 14 17]
# 1:[ 5 13 15 16 18]
# 2:[ 7 12]
# 3:[2 3 4 6]
# 4:[ 0  8 11 19]

for id in range(5):

array = np.where(targets == id)[0]

print("{}:{}".format(id, array))

# 0:[ 1 9 10 14 17]

# 1:[ 5 13 15 16 18]

# 2:[ 7 12]

# 3:[2 3 4 6]

# 4:[ 0 8 11 19]

上の例では、ループのidを0～4と変化させていくのにrange(5)を使っている。ところが一般的には、番号が連続して存在しているとは限らず、またその上限もわからない。

そこで、targetsに出てくる要素を重なりなく、かつ全て使うためにnumpy.unique()関数を使っている。unique()関数は引数の配列の要素の重複を除き、昇順・辞書順に並べてくれる。この引数にtargetsを渡して、要素の重なりを除けば、targets中の要素を重なりなく1つずつ参照できる。

print(np.unique(targets))
# [0 1 2 3 4]

for id in np.unique(targets):
    array = np.where(targets == id)[0]
    print("{}:{}".format(id, array))

# [ 1  9 10 14 17]
# [ 5 13 15 16 18]
# [ 7 12]
# [2 3 4 6]
# [ 0  8 11 19]

print(np.unique(targets))

# [0 1 2 3 4]

for id in np.unique(targets):

array = np.where(targets == id)[0]

print("{}:{}".format(id, array))

# [ 1 9 10 14 17]

# [ 5 13 15 16 18]

# [ 7 12]

# [2 3 4 6]

# [ 0 8 11 19]

取り出す要素の制限

次に、すべてのターゲットのデータ数が3個以下になるようにすることを考える。

これらのデータで各idの個数を3個以下にするのに、出現順位の早いものから3個を選び出すことを考える。

0：1, 9, 10, 14, 17
1：5, 13, 15, 16, 18
2：7, 12
3：2, 3, 4, 6
4：0, 8, 11, 19

各配列の最初の3個を取り出すには、各idに対応する配列の先頭から3個目までをスライスで取り出せばよい。

for id in np.unique(targets):
    array = np.where(targets == id)[0][:3]
    print("{}:{}".format(id, array))

# 0:[ 1  9 10]
# 1:[ 5 13 15]
# 2:[ 7 12]
# 3:[2 3 4]
# 4:[ 0  8 11]

for id in np.unique(targets):

array = np.where(targets == id)[0][:3]

print("{}:{}".format(id, array))

# 0:[ 1 9 10]

# 1:[ 5 13 15]

# 2:[ 7 12]

# 3:[2 3 4]

# 4:[ 0 8 11]

これで値の最大3個までとするのに取り出すべきtargets中のインデックスが得られた。

要素の抽出

targets配列の要素の個数を制限するには、上で絞り込まれたインデックスに対応する要素を残し、それ以外の要素を切り捨てる。そのためには、残すべきインデックス位置の値がTrue、その他のインデックス位置の値がFalseであるbool配列をつくり、これをtargetsの引数とすればよい。

この配列を例えばmaskという名前とすると、targetsと同じサイズですべての要素がFalseである配列としてmaskを準備し、先ほどの切り落とすべきインデックスの位置のみTrueにするとよい。

以下では、まず全要素がFalseでtargetsと同じサイズのbool配列を準備し、各idに対して3つ目までの要素の位置をTrue(1)としている。

ループの1回目で1、9、10番目がTrueになり、2回目で5、13、15番目がTrueに代わっていき、ループを重ねるごとに、取り出すべき要素の位置がTrueになっていることが確認できる。

なおbool配列の初期化では、Falseが数値の0と等価なため、numpy.zeros()関数を使っている。同じ理由で、numpy.where()でTrueをセットするときに、数値の1をセットしている。

mask = np.zeros(targets.size, dtype=np.bool)
print(mask)

# [False False False False False False False False False False False False
#  False False False False False False False False]

for target in np.unique(targets):
    mask[np.where(targets == target)[0][:3]] = 1
    print(mask)

# [False  True False False False False False False False  True  True False
#  False False False False False False False False]
# [False  True False False False  True False False False  True  True False
#  False  True False  True False False False False]
# [False  True False False False  True False  True False  True  True False
#   True  True False  True False False False False]
# [False  True  True  True  True  True False  True False  True  True False
#   True  True False  True False False False False]
# [ True  True  True  True  True  True False  True  True  True  True  True
#   True  True False  True False False False False]

mask = np.zeros(targets.size, dtype=np.bool)

print(mask)

# [False False False False False False False False False False False False

# False False False False False False False False]

for target in np.unique(targets):

mask[np.where(targets == target)[0][:3]] = 1

print(mask)

# [False True False False False False False False False True True False

# False False False False False False False False]

# [False True False False False True False False False True True False

# False True False True False False False False]

# [False True False False False True False True False True True False

# True True False True False False False False]

# [False True True True True True False True False True True False

# True True False True False False False False]

# [ True True True True True True False True True True True True

# True True False True False False False False]

最後に、このbool配列をtargetsに適用して、取り出すべき要素の配列を得る。

print(targets[mask])
# [4 0 3 3 3 1 2 4 0 0 4 2 1 1]

print(np.bincount(targets[mask]))
# [3 3 2 3 3]

print(targets[mask])

# [4 0 3 3 3 1 2 4 0 0 4 2 1 1]

print(np.bincount(targets[mask]))

# [3 3 2 3 3]

他の配列の同時操作

mask配列は、targetsと同じサイズを持つ次元の配列に繰り返し適用できるので、たとえば機械学習でtargetsの各要素に紐づけられた画像データなどを格納した配列などについても、targetsと整合させながら必要な分だけ切出すことができる。

LFWデータセット – k近傍法（PCA変換付き）

2020-11-23 / tau / コメントする

概要

“Pythonではじめる機械学習”の主成分分析(PCA)のところで、著名人の顔画像データ（LFW peopleデータセット）に対するk-近傍法の精度を確認している。

LFW peopleのデータを、最低20枚以上の画像がある人物で絞り込んで読み込み
各人物の画像を最大でも50枚以内となるよう制限（配列要素数の制限手順についてはこちらを参照）
2063人の人物について、87×65ピクセルを1次元化した5,655個の数値配列を特徴量データ(X_people)、各画像の人物の番号を収めた配列(y_people)をターゲットデータとする
画像データを訓練データとテストデータに分割
このデータセットをそのまま1-nnで予測したスコアは、0.2程度でそれほどよくない
画像データに主成分分析(PCA)を用いて、100個の主成分で変換したデータについても1-nnを適用していて、この場合のスコアは0.31

コード例ではPCAインスタンス生成時の引数としてwhiten=Trueを指定しているが、これを指定しない場合、データ変換後のスコアは0.23でこうじょうしなかった。

なお、スコアが書籍掲載値と異なるが、画像データの内容も書籍と今回実行時で異なっている。

コードと実行結果

import numpy as np
from sklearn.datasets import fetch_lfw_people
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)
for target in np.unique(ds.target):
    mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]
y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(
    X_people, y_people, stratify=y_people, random_state=0)

knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, y_train)
print("Test score (1-nn): {:.2f}".format(knn.score(X_test, y_test)))

pca = PCA(n_components=100, whiten=True, random_state=0).fit(X_train)
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)

knn.fit(X_train_pca, y_train)
print("Test score (1-nn) w/ PCA: {:.2f}".format(knn.score(X_test_pca, y_test)))

print("\nUsed data shape")
print(X_train.shape, X_test.shape)
print(X_train_pca.shape, X_test_pca.shape)
print(y_train.shape, X_test.shape)

# Test score (1-nn): 0.23
# Test score (1-nn) w/ PCA: 0.31
# 
# Used data shape
# (1547, 5655) (516, 5655)
# (1547, 100) (516, 100)
# (1547,) (516, 5655)

import numpy as np

from sklearn.datasets import fetch_lfw_people

from sklearn.model_selection import train_test_split

from sklearn.neighbors import KNeighborsClassifier

from sklearn.decomposition import PCA

ds = fetch_lfw_people(min_faces_per_person=20, resize=0.7)

mask = np.zeros(ds.target.shape, dtype=np.bool)

for target in np.unique(ds.target):

mask[np.where(ds.target == target)[0][:50]] = 1

X_people = ds.data[mask]

y_people = ds.target[mask]

X_people /= 255

X_train, X_test, y_train, y_test = train_test_split(

X_people, y_people, stratify=y_people, random_state=0)

knn = KNeighborsClassifier(n_neighbors=1)

knn.fit(X_train, y_train)

print("Test score (1-nn): {:.2f}".format(knn.score(X_test, y_test)))

pca = PCA(n_components=100, whiten=True, random_state=0).fit(X_train)

X_train_pca = pca.transform(X_train)

X_test_pca = pca.transform(X_test)

knn.fit(X_train_pca, y_train)

print("Test score (1-nn) w/ PCA: {:.2f}".format(knn.score(X_test_pca, y_test)))

print("\nUsed data shape")

print(X_train.shape, X_test.shape)

print(X_train_pca.shape, X_test_pca.shape)

print(y_train.shape, X_test.shape)

# Test score (1-nn): 0.23

# Test score (1-nn) w/ PCA: 0.31

# Used data shape

# (1547, 5655) (516, 5655)

# (1547, 100) (516, 100)

# (1547,) (516, 5655)

numpy – bincount

2020-11-21 / tau / コメントする

概要

numpy.bincount()関数の仕様

整数型の配列を引数にとる
配列中、同じ値の要素の個数をカウントする
0～要素の最大値を要素とし、各要素番号に対応する値の個数を要素とする配列を返す
元のデータの要素ごとの重みを指定することができる

使い方

基本形

引数で与えた整数型配列中の同じ値をカウントして、各値ごとの個数を要素とする配列を返す。

import numpy as np

a = np.array([0, 1, 1, 2, 2, 2, 3, 3])
print(np.bincount(a))

# [1 2 3 2]

import numpy as np

a = np.array([0, 1, 1, 2, 2, 2, 3, 3])

print(np.bincount(a))

# [1 2 3 2]

上の結果の意味は、0が1個、1が2個、2が3個、3が2個。

値が飛んでいる場合

引数の配列中、0～最大値までの整数値に対する数をカウントする。値が存在しない場合の個数は0。

b = np.array([1, 3, 3, 5, 5, 5])
print(np.bincount(b))

# [0 1 0 2 0 3]

b = np.array([1, 3, 3, 5, 5, 5])

print(np.bincount(b))

# [0 1 0 2 0 3]

上の例では、0～5までの個数がカウントされ、0, 2, 4は配列中に存在しないので0となっている。

順不同

引数の配列中の要素は昇順である必要はない。

c = np.array([2, 2, 3, 3, 3, 1])
print(np.bincount(c))

# [0 1 2 3]

c = np.array([2, 2, 3, 3, 3, 1])

print(np.bincount(c))

# [0 1 2 3]

`weights`の意味

引数にweightsを指定する場合。

データの配列と同じ要素数のweightsの配列を与える。
要素をカウントの場合に1ずつ足すのではなく、各要素の位置に対応した重みが加算されていく

w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])
d = np.array([1, 2, 4, 2, 4, 4])
print(np.bincount(d, weights=w))

# [0.  0.1 0.6 0.  1.4]

w = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])

d = np.array([1, 2, 4, 2, 4, 4])

print(np.bincount(d, weights=w))

# [0. 0.1 0.6 0. 1.4]

上の例では以下のように動作している。

0は存在しないので0
1は0番目に1つだけ存在し、その位置のweightsの値は0.1
2は1番目と3番目に存在するので、weightsの第1要素0.2と第3要素0.4を加えて0.6
3は存在しないので0
4は2番目、4番目、5番目にあるので、weightsの第2要素0.3、第4要素0.5、第5要素0.6を加えて1.4

概要

配列同士の加算

+～加算は和集合

−～減算は差集合

積集合の求め方

要素の追加

概要

パラメーター系

size/length～要素数の取得

sum～合計値の取得

要素抽出系

first/last～先頭要素／末尾要素の取得

sample～ランダムな要素取得

破壊的メソッド

push/unshift～要素の追加

pop/shift～要素の取出し

非破壊的メソッド

reverse～要素の順番の反転

sort～昇順ソート

sort.reverse～降順ソート

uniq～重複要素の削除

shuffle～要素のシャッフル

文字列化・配列化

split～文字列の配列への分解

join～配列要素の文字列への結合

length～文字列の長さ

結合系

+～文字列の連結

join～配列要素の文字列化

分割系

split～文字列の配列への分割

削除系

delete～特定の文字の削除

strip～前後のスペースの削除

chop/chop!～末尾文字の削除

chomp/chomp!～末尾の改行文字の削除

変換系

upcase/downcase～大文字化／小文字化

概要

データの読み込みと確認

画像の枚数の絞り込み

元のコード

k-近傍法との組み合わせによる精度の確認

主成分の可視化

次元圧縮された主成分からの復元

概要

顔画像の選定

次元削減後の逆変換

同一人物の画像

第2主成分までによるクラスの分布

1行コメント～#

複数行コメント～=begin/=end

__END__の応用

puts

print

p

概要

手順

ターゲットごとのインデックスの取得

取り出す要素の制限

要素の抽出

他の配列の同時操作

概要

コードと実行結果

概要

使い方

基本形

値が飛んでいる場合

順不同

weightsの意味

`+`～加算は和集合

`−`～減算は差集合

`size/length`～要素数の取得

`sum`～合計値の取得

`first/last`～先頭要素／末尾要素の取得

`push/unshift`～要素の追加

`pop/shift`～要素の取出し

`reverse`～要素の順番の反転

`sort`～昇順ソート

`sort.reverse`～降順ソート

`uniq`～重複要素の削除

`shuffle`～要素のシャッフル

`split`～文字列の配列への分解

`join`～配列要素の文字列への結合

`length`～文字列の長さ

`+`～文字列の連結

`join`～配列要素の文字列化

`split`～文字列の配列への分割

`delete`～特定の文字の削除

`strip`～前後のスペースの削除

`upcase/downcase`～大文字化／小文字化

1行コメント～`#`

複数行コメント～`=begin/=end`

`END`の応用

`weights`の意味