ceil_modeとは

Pytorchの学習済モデルtorchvision.models.googlenetをKerasに移植してみようと思ったら、気になることが。

MaxPool2dのceil_modeってなんでしょか。

ドキュメントをみると、「Trueの場合、出力シェイプの計算でfloor（切り捨て）ではなくceil（切り上げ）を使う」とある。

torch.nn — PyTorch master documentation

ceil_mode – when True, will use ceil instead of floor to compute the output shape

以下は、torchvision.models.googlenetで最初にでてくるMaxPool2D。

# 入力は (112, 112, 64)
MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)

出力サイズを計算してみると、55.5

output\_shape = \frac{input\_shape + 2 \times padding - kernel\_size}{stride} + 1 \\
= \frac{112 + 2 \times 0 - 3}{2} + 1 = 55.5

torchsummaryで実際の出力サイズを見てみると、(ch=64, 56, 56)なので、確かに小数点以下を切り上げ（ceil）してるっぽい。

MaxPool2d-4           [-1, 64, 56, 56]

PyTorchの結果を確認してみる

kernel=(3,3), stride=(2,2)のMaxPool2dに以下の(10,10)サイズのサンプルデータを突っ込んで結果をみてみる。

サンプルデータ

import torch
import torch.nn as nn

>>> x = torch.arange(1, 101).view(1, 10, 10).float()
>>> x
tensor([[[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.],
         [ 11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.],
         [ 21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.],
         [ 31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.],
         [ 41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  49.,  50.],
         [ 51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.],
         [ 61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.],
         [ 71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.],
         [ 81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,  90.],
         [ 91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99., 100.]]])
>>> x.shape
torch.Size([1, 10, 10])

ceil_mode = False

padding = 1

>>> nn.MaxPool2d((3,3), stride=2, padding=1, ceil_mode=False)(x)               

# 出力サイズ (5, 5)
tensor([[[ 12.,  14.,  16.,  18.,  20.],
         [ 32.,  34.,  36.,  38.,  40.],
         [ 52.,  54.,  56.,  58.,  60.],
         [ 72.,  74.,  76.,  78.,  80.],
         [ 92.,  94.,  96.,  98., 100.]]])

output\_shape = \frac{input\_shape + 2 \times padding - kernel\_size}{stride} + 1 \\
= \frac{10 + 2 \times 1 - 3}{2} + 1 = 5.5

小数点以下を切り捨てて、5.5 → 5

padding = 0

>>> nn.MaxPool2d((3,3), stride=2, padding=0, ceil_mode=False)(x) 

# 出力サイズ (4, 4)
tensor([[[23., 25., 27., 29.],
         [43., 45., 47., 49.],
         [63., 65., 67., 69.],
         [83., 85., 87., 89.]]])

output\_shape = \frac{input\_shape + 2 \times padding - kernel\_size}{stride} + 1 \\
= \frac{10 + 2 \times 0 - 3}{2} + 1 = 4.5

小数点以下を切り捨てて、4.5 → 4

ceil_mode = True

padding = 1

>>> nn.MaxPool2d((3,3), stride=2, padding=1, ceil_mode=True)(x) 

# 出力サイズ (6, 6)
tensor([[[ 12.,  14.,  16.,  18.,  20.,  20.],
         [ 32.,  34.,  36.,  38.,  40.,  40.],
         [ 52.,  54.,  56.,  58.,  60.,  60.],
         [ 72.,  74.,  76.,  78.,  80.,  80.],
         [ 92.,  94.,  96.,  98., 100., 100.],
         [ 92.,  94.,  96.,  98., 100., 100.]]])

output\_shape = \frac{input\_shape + 2 \times padding - kernel\_size}{stride} + 1 \\
= \frac{10 + 2 \times 1 - 3}{2} + 1 = 5.5

小数点以下を切り上げて、5.5 → 6

padding = 0

>>> nn.MaxPool2d((3,3), stride=2, padding=0, ceil_mode=True)(x)  

# 出力サイズ (5, 5)
tensor([[[ 23.,  25.,  27.,  29.,  30.],
         [ 43.,  45.,  47.,  49.,  50.],
         [ 63.,  65.,  67.,  69.,  70.],
         [ 83.,  85.,  87.,  89.,  90.],
         [ 93.,  95.,  97.,  99., 100.]]])

output\_shape = \frac{input\_shape + 2 \times padding - kernel\_size}{stride} + 1 \\
= \frac{10 + 2 \times 0 - 3}{2} + 1 = 4.5

小数点以下を切り上げて、4.5 → 5

ceil_modeのTrue/Falseでの違い

以下の出力サイズはいずれも(5, 5)となるが、違いは何か。
* padding=1, ceil_mode=False
* padding=0, ceil_mode=True

padding=1, ceil_mode=False

MaxPoolingの様子

出力

padding=0, ceil_mode=True

MaxPoolingの様子

パディングなしなので、左上からプーリングを行っている。
出力シェイプが切り上げされることにより、結果右と下のみパディングしたのと同じ結果となっている。

出力

Kerasの結果を確認してみる

kernel=(3,3), stride=(2,2)のMaxPool2dに以下の(10,10)サイズのサンプルデータを突っ込んで結果をみてみる。
KerasのMaxPooling2Dには、ceil_mode的なパラメータはない。

Kerasはいつも出力シェイプの計算結果を小数点以下切り捨てしている模様（Pytorchでいうところのceil_mode=False）。

サンプルデータ

Pytorchのときと同じく、10x10のデータを生成。

from tensorflow.keras.layers import MaxPooling2D
import numpy as np

x = np.arange(1, 101).reshape(1, 10, 10, 1).astype(np.float)

padding=1

Pytorchでの、padding=1, ceil_mode=Falseと同じ出力。

>>> out = MaxPooling2D((3,3), strides=(2,2))(ZeroPadding2D((1,1))(x))
>>> out = tf.transpose(out, perm=[0,3,1,2])
>>> with tf.Session() as sess:  
>>>     out_value = sess.run(out)
>>>     print(out_value)

# 出力サイズ (5, 5)
[[[[ 12.  14.  16.  18.  20.]
   [ 32.  34.  36.  38.  40.]
   [ 52.  54.  56.  58.  60.]
   [ 72.  74.  76.  78.  80.]
   [ 92.  94.  96.  98. 100.]]]]

padding=0

Pytorchでの、padding=0, ceil_mode=Falseと同じ出力。

>>> out = MaxPooling2D((3,3), strides=(2,2))(x)
>>> out = tf.transpose(out, perm=[0,3,1,2])
>>> with tf.Session() as sess:  
>>>     out_value = sess.run(out)
>>>     print(out_value)

# 出力サイズ (4, 4)
[[[[23. 25. 27. 29.]
   [43. 45. 47. 49.]
   [63. 65. 67. 69.]
   [83. 85. 87. 89.]]]]

kerasで、ceil_mode=Trueと同じ出力を出すには？

ZeroPadding2Dは以下の様に設定すると、上下および左右に対しゼロパディングする。

ZeroPadding2D((1,1))(x)

以下のように、上と下、左と右、それぞれパディングの設定を変えることも可能。
（下と右にだけゼロパディングを適用している）

ZeroPadding2D(((0,1), (0,1)))(x)

下と右にだけゼロパディング適用することにより、ceil_mode=Trueと同じ出力を得ることができた。

>>> out = MaxPooling2D((3,3), strides=(2,2))(ZeroPadding2D(((0,1), (0,1)))(x))
>>> out = tf.transpose(out, perm=[0,3,1,2])
>>> with tf.Session() as sess:  
>>>     out_value = sess.run(out)
>>>     print(out_value)

# 出力サイズ (5, 5)
[[[[ 23.  25.  27.  29.  30.]
   [ 43.  45.  47.  49.  50.]
   [ 63.  65.  67.  69.  70.]
   [ 83.  85.  87.  89.  90.]
   [ 93.  95.  97.  99. 100.]]]]

はじめに

atomで開発をしていく中で、途中までのコードを実行したいときありませんか？調べるとAtomをjupyterのように使用できるhydrogenというpackageがあったのでその設定方法を書いていこうと思います。私のような初心者ではエラーがなかなか解消できず、解決できた時は正直泣きました。笑
はじめての投稿かつ独学でやっているもので間違い等あれば指摘していただけると幸いです。

対象とする人

・atomのhydrogenを仮想環境下で設定したい方

・atomでhydrogenを設定する際に以下のようなエラー文が出た方（atomでhydrogenを実行しようとしたきとにでるエラーです）
Traceback (most recent call last): File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.7_3.7.2032.0_x64__qbz5n2kfra8p0\lib\runpy.py", line 193, in _run_module_as_main "main", mod_spec) File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.7_3.7.2032.0_x64__qbz5n2kfra8p0\lib\runpy.py", line 85, in _run_code exec(code, run_globals) File
・・・・・・・中略・・・・・・・・ "C:\Users\username\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.7_qbz5n2kfra8p0\LocalCache\local-packages\Python37\site-packages\jupyter_core\paths.py", line 361, in win32_restrict_file_to_user import win32api ImportError: DLL load failed: �w�肳�ꂽ���W���[����������܂���B


自分が陥ったエラーについて

自分が一通り設定を完了してからatomでhydrogenを実行したときに上記のエラーコードで出できて、ほんとうに苦労しました。
いろいろ試した結果解決策は以下のとおりでした。（詳細は以下の手順⑧からみてください）
・Atom/環境設定/hydrogen/settingsから設定ができる「startup code」「Kernel Gateways」へjupyter Kernel のjsonを張り付ける手順の際に仮想環境のjsonではなくbase環境のjsonを張り付けていたためこのようなエラーがでていたと思われます。（base環境はpython3.7です。）

環境

・Windows10
・Atom 1.48.0
・hydrogen 2.14.3
・仮想環境　conda python3.6.10
※anaconda,atom,hydrogenはインストール済みであることとします。
仮想環境を構築した理由としては、python3.7だとhydrogenが上手く動かない？といった記事がいくつかあったため、python3.6の仮想環境を構築することにしました。（実際にpython3.7での設定は試みていないため真偽は不明）

手順

①仮想環境を構築

・anaconda promptを起動

・以下のコードを実行

Anaconda_prompt

>conda create -n py36_fxpractice python=3.6

※py36_fxpracticeの部分は仮想環境名になる箇所であるため任意の名称で構いません。
※今回はpython3.6の仮想環境を構築したいので仮想環境を構築する際pythonのversionを指定しています。

・実行後いろんな文章が表示された後、以下の文が表示されます。

Proceed ([y]/n)? 

yを入力しEnter

②：構築した環境の確認

以下のコードを実行

Anaconda_prompt

>conda info -e

出力結果

# conda environments:
#
base                  *  C:\Users\UsersName\Anaconda3
py36_fxpractice          C:\Users\UsersName\Anaconda3\envs\py36_fxpractice

※このコードで先ほど作成した仮想環境ができているかの確認および、どこの環境にいるのかの確認をします。
※出力結果からbase環境と先ほど作成したpy36_fxpractice環境があることがわかります。base環境に*印があるため現在はbase環境にいることもわかります。

③：仮想環境への切替え

以下のコードを実行

Anaconda_prompt

>activate py36_fxpractice

実行後

(py36_fxpractice) C:\Users\Kawahara>

※実行後環境が仮想環境に切り替わります。（base）⇒（py36_fxpractice）に替わります。

④：jupyterのインストール

以下のコードを実行

Anaconda_prompt

>conda install jupyter

※仮想環境でjupyterをインストールします。jupyterをインストールする際に、同時に必要なものが④のコード実行後「これも一緒にインストールするよ？」って感じで表示されます。

・実行後いろんな文章が表示された後、以下の文が表示されます。

Proceed ([y]/n)? 

yを入力しEnter

⑤：jupyterのkernelを作成

以下のコードを実行

Anaconda_prompt

ipython kernel install --user --name py36_fxpractice --display-name py36_fxpractice

※$ipython kernel install --user --name=環境名 --display-name=環境名であるため、環境名の箇所は任意のもので構いません。

⑥：jupyter kernelの確認

以下のコードを実行

Anaconda_prompt

jupyter kernelspec list

出力結果

Available kernels:
  py36_fxpractice    C:\Users\UserName\AppData\Roaming\jupyter\kernels\py36_fxpractice
  python3            C:\Users\UserName\AppData\Roaming\jupyter\kernels\python3

※作成した仮想環境のパスのようなものが表示されていれば成功です。

⑦必要なライブラリのインストール

Anaconda_prompt〈例〉

conda install numpy　

conda install 【ライブラリ名】でインストールできます。①④同様にProceed ([y]/n)?と聞かれるのでyを入力しEnterをします。上記は例としてnumpyをインストールしています。

⑧：jupyter notebookの起動

以下のコードを実行

Anaconda_prompt

jupyter notebook　

コード実行後ブラウザでjupyteが起動します。（以下のような画面が表示されます。）

・上記の画像のNewをクリックし⑤で作成したカーネルのdisplay-nameがあるはずなのでそれを選択します。実際にコードを実行してみてjupyterが正常に動くのか確認します。
確認後jupyterおよびanaconda promptを閉じます。(画面右上の×で私は閉じています。)

⑨：jupyter kernelのjsonを取得

再度anaconda promptを開き以下のコードを実行

Anaconda_prompt

　jupyter kernelspec list --json

※コードを実行後にjsonコードが表示されます。jsonとはたくさんの[]で囲まれて中に、パスなどが表示されています。その中に上記の手順で作成した仮想環境名であったり、display名があれば成功っぽいです。

⑩：Atomの設定

anaconda promptよりAtomを開く（以下のコードを実行）
※anaconda promptから開かないとhydrogenが起動しないっぽいです。

Anaconda_prompt

　atom .

Atom起動後、Atom/環境設定/hydrogen/settingsから設定ができる「startup code」「Kernel Gateways」へjupyter Kernel のjsonを張り付ける。

一度atomを終了し再度同じ方法でAtomを開く。
適当なファイルを開いてshift + Enterを押すと画面のようにAtom上でjupyterみたいにコードが実行されるはずです。

参照URL

以下の方のHPを参考にしましたので載せておきます。

Jupyter関連

・ [Qiita] Miniconda・Atom Hydrogenを用いたPython環境構築

仮想環境について

[Qiita] 【初心者向け】Anacondaで仮想環境を作ってみる

path設定

これは記事に書いてはいませんが、上記の手順をしてもダメだった場合、この記事を参考にして仮想環境でPathを通してみてください。
・[Qiita] AtomでHydrogenを動かす手順メモ

概要

海外ではエンジニアの面接においてコーディングテストというものが行われるらしく、多くの場合、特定の関数やクラスをお題に沿って実装するという物がメインである。

どうやら多くのエンジニアはその対策としてLeetCodeなるサイトで対策を行うようだ。

早い話が本場でも行われているようなコーディングテストに耐えうるようなアルゴリズム力を鍛えるサイトであり、海外のテックカンパニーでのキャリアを積みたい方にとっては避けては通れない道である。

と、仰々しく書いてみましたが、私は今のところそういった面接を受ける予定はありません。

ただ、ITエンジニアとして人並みのアルゴリズム力くらいは持っておいた方がいいだろうということで不定期に問題を解いてその時に考えたやり方をメモ的に書いていこうかと思います。

Leetcode

Python3で解いています。

ゼロから始めるLeetCode 目次

前回
ゼロから始めるLeetCode Day71 「1496. Path Crossing」

今はTop 100 Liked QuestionsのMediumを優先的に解いています。
Easyは全て解いたので気になる方は目次の方へどうぞ。

Twitterやってます。

技術ブログ始めました！！
技術はLeetCode、Django、Nuxt、あたりについて書くと思います。こちらの方が更新は早いので、よければブクマよろしくお願いいたします！

問題

1498. Number of Subsequences That Satisfy the Given Sum Condition

難易度はMedium。

問題としては、整数の配列numsと整数targetが与えられます。
numsの最小値と最大値の和が目標値以下になるような、空ではない部分列の数を返します。

答えが大きすぎるかもしれないので、10^9 + 7の剰余演算を返します。

Example 1:

Input: nums = [3,5,6,7], target = 9
Output: 4
Explanation: There are 4 subsequences that satisfy the condition.
[3] -> Min value + max value <= target (3 + 3 <= 9)
[3,5] -> (3 + 5 <= 9)
[3,5,6] -> (3 + 6 <= 9)
[3,6] -> (3 + 6 <= 9)

Example 2:

Input: nums = [3,3,6,8], target = 10
Output: 6
Explanation: There are 6 subsequences that satisfy the condition. (nums can have repeated numbers).
[3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]

Example 3:

Input: nums = [2,3,3,4,6,7], target = 12
Output: 61
Explanation: There are 63 non-empty subsequences, two of them don't satisfy the condition ([6,7], [7]).
Number of valid subsequences (63 - 2 = 61).

Example 4:

Input: nums = [5,2,4,1,7,6,8], target = 16
Output: 127
Explanation: All non-empty subset satisfy the condition (2^7 - 1) = 127

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^6
• 1 <= target <= 10^6

解法

class Solution:
    def numSubseq(self, nums: List[int], target: int) -> int:
        ans,mod = 0,10**9+7
        nums.sort()
        for i,j in enumerate(nums):
            if target < j*2:
                break
            b = bisect.bisect(nums,target-j,lo=i)
            ans += pow(2, b-i-1, mod)
        return ans % mod
# Runtime: 888 ms, faster than 82.84% of Python3 online submissions for Number of Subsequences That Satisfy the Given Sum Condition.
# Memory Usage: 25.2 MB, less than 100.00% of Python3 online submissions for Number of Subsequences That Satisfy the Given Sum Condition.

問題文で指定されている通り、最初にmod(10**9+7)を指定し、for文の中で二分探索をする、という書き方をしました。
bisectの引数は以下の通りです。

bisect(a,b,(lo,hi))

a: リスト
b: 挿入する値
lo: 探索範囲の下限
hi: 探索範囲の上限

なお、この記事を読む方の中にははご存知の方が多いと思いますが、二分探索はソートされていることが前提条件なので、コードの最初の方でリストをソートしてあります。例を見る限りソートされてない場合も多そうだったしね・・・

ちなみに10**9+7、というのは他の競技プログラミングをやる上で（たくさんサイトがあるのでどれか一つに限らず）結構出てきたりします。
それについての分かりやすい解説記事を書いてくださっている方もいるので気になる方は是非そちらもどうぞ。

では今回はここまで。お疲れ様でした。

人工知能を用いて　アナログメーターの読取りを行うのに　教科書の例題にあるMNISTで出来ます。

まずは、カメラと照明を固定して撮影条件が一定となるように設置をします。一定の範囲内で撮影出来る事を保証できると、人工知能による予測精度が向上します。
次に、特定のアナログメーターを　事前に撮影して針の位置の状態をそれぞれ準備します。どの程度のデーターを準備するかは、要求する分解能に従いますが、２０－３０分解能もあれば、十分と思われます。
なぜなら、アナログメーター自体の精度（誤差）は、±2.5%や±1.6%程度あり、つまり、約5%や3%程度の誤差は、アナログメーターを使う時点で、許容されています。
有効桁数３桁、４桁の測定には、アナログメーターは向いていません。

事前のデーターを多く用意するため、撮影条件や照明条件を振って、許容範囲内の状態を可能な限り撮影したり、画像処理でデーターを水増しましょう。

プログラム自体は、MNISTと同等のクラス分類です。データーが十分あれば、トレーニングとテストに分けたり、過剰適合の検証をしたり、パラメーターの調整をしたり、色々できます。

ana00.png

ana01.png

ソースコード
データー準備

import numpy as np
import matplotlib.pyplot as plt
import cv2

i=np.ndarray([32,32,3])
data=np.ndarray([10,32,32,3])
data[:]=0

i=plt.imread("ana00.png")
plt.imshow(i)
plt.show()
i = cv2.resize(i, (32,32))
data[0,:,:,:]=i
plt.imshow(i)
plt.show()

i=plt.imread("ana01.png")
i = cv2.resize(i, (32,32))
data[1,:,:,:]=i

i=plt.imread("ana02.png")
i = cv2.resize(i, (32,32))
data[2,:,:,:]=i

i=plt.imread("ana03.png")
i = cv2.resize(i, (32,32))
data[3,:,:,:]=i

i=plt.imread("ana04.png")
i = cv2.resize(i, (32,32))
data[4,:,:,:]=i

i=plt.imread("ana05.png")
i = cv2.resize(i, (32,32))
data[5,:,:,:]=i

i=plt.imread("ana06.png")
i = cv2.resize(i, (32,32))
data[6,:,:,:]=i

i=plt.imread("ana07.png")
i = cv2.resize(i, (32,32))
data[7,:,:,:]=i

i=plt.imread("ana08.png")
i = cv2.resize(i, (32,32))
data[8,:,:,:]=i

i=plt.imread("ana09.png")
i = cv2.resize(i, (32,32))
data[9,:,:,:]=i

学習と予測
import matplotlib.pyplot as plt
from sklearn import datasets, svm, metrics
from sklearn.model_selection import train_test_split

x = data.reshape((10,-1))
y=np.array([0,1,2,3,4,5,6,7,8,9])

X_train=x
X_test=x
y_train=y
y_test=y

classifier = svm.SVC(gamma=0.001)
classifier.fit(X_train, y_train)
predicted = classifier.predict(X_test)

print("Classification report for classifier %s:\n%s\n"
% (classifier, metrics.classification_report(y_test, predicted)))

人工知能は、画像を見てクラス分類しているだけです。アナログメーターの概念を認識したり針や目盛を理解しているわけではありません。過剰な要求仕様を求めなければ、アナログメーターの読取りは、例題のMNISTで出来ますね。

SPSS Modelerで縦持ちデータを横持ちに変換する再構成ノードをPythonのpandasで書き換えてみます。

１．加工のイメージ

以下のID付POSデータから各顧客毎に①商品カテゴリごとの購入額合計と②商品カテゴリごとの購入割合を集計してみます。

■加工前
誰（CUSTID）がいつ（SDATE）何（PRODUCTID、L_CLASS商品大分類、M_CLASS商品中分類）をいくら（SUBTOTAL）購入したかが記録されたID付POSデータを使います。

■加工後
顧客毎(CUSTID)に商品大分類（L_CLASS）の①商品カテゴリごとの購入額合計と②商品カテゴリごとの購入割合を集計します。

商品大分類にはBAG、COMETICS、SHOESの3つがあり、100001番の顧客はBAGで7243円、COSMETICSで10273円、SHOESで26870円の購入があります。それを金額の割合で計算するとBAG16.3%、COSMETICS23.1%、SHOES60.5%となります。このような集計を行うと顧客の特徴が浮かび上がってきます。

2.Modeler再構成ノードでの設定①商品カテゴリごとの購入額合計

まず、①商品カテゴリごとの購入額合計までを求めてみます。
再構成ノードは、データ型ノード、レコード集計、また置換ノードまでの組合せで通常使われます。
さらに今回は総購入金額まで計算するために、レコード集計とレコード結合ノードも組み合わせます。

まずデータ型ノードで商品大分類（L_CLASS）にどんなカテゴリ値があるかを認識します。データ型ノードで「値の読み込み」を行うと、自動で大分類のすべてのカテゴリが認識されます。

次に再構成ノードで横持ちさせたいフィールドの値を選びます。以下の例では商品大分類（L_CLASS）にはBAG、COMETICS、SHOES、これらを列として展開して値には小計（SUBSTOTAL）をセットしています。

この設定の結果をプレビューすると下のようになります。小計（SUBSTOTAL）が各商品大分類（L_CLASS）の列に振り分けられたことがわかります。

次に「レコード集計」ノードをつかってこのBAG、COMETICS、SHOESの小計値を顧客で1レコードに集計します（レコード度数は不要なのでチェックを外します）。

これで各顧客毎のBAG、COMETICS、SHOESの商品大分類ごとの購入総額が集計されました。100001番の顧客はBAGで7243円、COSMETICSで10273円、SHOESで26870円の購入があることが計算できました。

これでほぼ完成なのですが、いくつかNULLの値があります。これはこの顧客はこの商品大分類での購入が一度もなかったことを意味しています。このままだと計算に使いづらいので、NULLを0に置き換えます。

それを行うのが置換ノードです。
BAG、COMETICS、SHOESの合計値のノードを選択し、ヌル値の場合に0に設定します。

以下のようにヌルが0に変換されました。

次に顧客毎の総購入額を、レコード集計とレコード結合のノードを追加して算出します。

まず、レコード集計ノードで各顧客（CUSTID）の小計（SUBTOTAL）の合計、つまり総購入金額を算出します（やはりレコード度数は不要です）。

100001番の顧客は全部で44,386円の購入しています。

この集計結果と先ほどのBAG、COMETICS、SHOESの合計額の集計をレコード結合ノードで結合します。

そうすると各顧客毎のBAG、COMETICS、SHOESの合計額の集計の後ろに総購入額が結合できました。

最後はフィルターノードで長くなった列名を短くしておきました（この作業は必須ではありません）。

最終的なデータは以下のようになりました。

2.Modeler再構成ノードでの設定②商品カテゴリごとの購入割合

ここからは、再構成ノードとしては少し応用的な使い方ですが、他の顧客と比較しやすい「割合」を計算したいことはよくありますのでご紹介します。

先ほど作ったデータを見てみましょう。

100001番の顧客はBAGは7243円÷44,386円、COSMETICSは10273円÷44,386円、SHOESは26870円÷44,386円の各割り算を行うことで購入額の割合が計算できます。
この計算をフィールド作成ノードで行います。

モードを複数とし、フィールドリストにBAG_SUM、COSMETICS_SUM、SHOES_SUMを選択します。こうするとCLEM式の中で、@FIELDをつかって、BAG_SUM、COSMETICS_SUM、SHOES_SUMの各列を参照できます。
ここでは
@FIELD/ALL_SUM
を指定することで、
BAG_SUM/ALL_SUM、COSMETICS_SUM/ALL_SUM、SHOES_SUM/ALL_SUMの３つの割合が求められます。

これで各顧客毎のBAG、COMETICS、SHOESの商品大分類ごとの購入割合が集計されました。100001番の顧客の購入割合はBAG16.3%、COSMETICS23.1%、SHOES60.5%となります。

3.pandasでの設定①商品カテゴリごとの購入額合計

同じデータ加工をpandasでもやってみます。実は①商品カテゴリごとの購入額合計の算出は、pandasではpivot_tableというメソッド一つで非常に簡単にできます。

pivot_tran_df= df.pivot_table(
    index=['CUSTID'],columns=['L_CLASS'],values=['SUBTOTAL'],
    aggfunc='sum',
    fill_value=0,
    margins=True, margins_name='ALL')

• index=['CUSTID'],columns=['L_CLASS'],values=['SUBTOTAL']でCUSTIDをキーにしてL_CLASSに含まれるBAG、COMETICS、SHOESの商品大分類ごとにSUBTOTALを展開します。ここまでが再構成ノードの設定のイメージです。
• aggfunc='sum'でSUBTOTALの合計値を算出することを示します。ここが集計ノードのイメージです。
• fill_value=0はNULLになった箇所を0埋めすることを示します。ここが置換ノードのイメージです。
• margins=True, margins_name='ALL'は列合計と行合計を追加することを示します。ここが集計ノードとレコード結合ノードの役割を果たしています。

以下のようにCUSTID毎にBAG、COMETICS、SHOESの購入額と総購入金額が計算できています。

• 参考
  • pandas.pivot_table — pandas 1.0.5 documentation https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.pivot_table.html
  • pandasのピボットテーブルでカテゴリ毎の統計量などを算出 | note.nkmk.me https://note.nkmk.me/python-pandas-pivot-table/

列の合計列は必要ですが、行の合計行は今回は不要なので以下で削除します。

pivot_tran_df=pivot_tran_df[:-1]

• 参考
  • python — pandasデータフレームのデータの最後の行を削除する方法 https://www.it-swarm.dev/ja/python/pandas%E3%83%87%E3%83%BC%E3%82%BF%E3%83%95%E3%83%AC%E3%83%BC%E3%83%A0%E3%81%AE%E3%83%87%E3%83%BC%E3%82%BF%E3%81%AE%E6%9C%80%E5%BE%8C%E3%81%AE%E8%A1%8C%E3%82%92%E5%89%8A%E9%99%A4%E3%81%99%E3%82%8B%E6%96%B9%E6%B3%95/1050572731/

pivot_tableをつかうと列が階層構造になりマルチカラムになります。

マルチカラムのままだと結合などがしづらく扱いづらいので、フラットなスネーク形式（アンダースコアで連結）の列名に変換します。Modelerの命名規則に合わせると以下のようになります。

pivot_tran_df.columns = [
    pivot_tran_df.columns.names[1]+"_"+levels[1]+"_"+levels[0] 
    for levels in pivot_tran_df.columns]

ここではさらに正規表現を使って、BAG_SUMのような短い列名に変更しました。

import re
pivot_tran_df=pivot_tran_df.rename(
    columns= lambda str:
    re.sub('L_CLASS_(.+)_SUBTOTAL',r'\1_SUM',str))

3.pandasでの設定②商品カテゴリごとの購入割合

②商品カテゴリごとの購入割合をModelerでは@FIELD/ALL_SUMで計算しました。

pandasではdivメソッドを使います。Modelerの置換ノードのイメージに近くて、すべての列がALL_SUMで除算されて置き換えられます。ALL_SUM自身も割られて1.0になっています。

pivot_tran_ratio_df=pivot_tran_df.div(pivot_tran_df["ALL_SUM"], axis=0)

• 参考
  • pandas.DataFrame.div — pandas 0.24.2 documentation https://pandas.pydata.org/pandas-docs/version/0.24.2/reference/api/pandas.DataFrame.div.html
  • python - データフレームの複数列を一つの列で割る - スタック・オーバーフロー https://ja.stackoverflow.com/questions/52834/%E3%83%87%E3%83%BC%E3%82%BF%E3%83%95%E3%83%AC%E3%83%BC%E3%83%A0%E3%81%AE%E8%A4%87%E6%95%B0%E5%88%97%E3%82%92%E4%B8%80%E3%81%A4%E3%81%AE%E5%88%97%E3%81%A7%E5%89%B2%E3%82%8B

ALL_SUMを削除(drop)し、SUM(合計)ではなくRATIO(割合)なので列名を変更します(rename)。

import re
pivot_tran_ratio_df=pivot_tran_ratio_df\
    .drop(columns=['ALL_SUM'])\
    .rename(columns= lambda str:re.sub('_SUM','_RATIO',str))

最後に①商品カテゴリごとの購入額合計のDataFrameに結合しなおして完成です。

pivot_tran_df=pivot_tran_df.join(pivot_tran_ratio_df)

4. サンプル

サンプルは以下に置きました。

ストリーム
https://github.com/hkwd/200611Modeler2Python/blob/master/Restructure/Restructure.str?raw=true
notebook
https://github.com/hkwd/200611Modeler2Python/blob/master/Restructure/restructure.ipynb
データ
https://raw.githubusercontent.com/hkwd/200611Modeler2Python/master/data/sampletranDEPT4en2019S.csv

■テスト環境
Modeler 18.2.1
Windows 10 64bit
Python 3.6.9
pandas 0.24.1

5. 参考情報

【リレー連載】わたしの推しノード - ID付POSやIoT時系列データから特徴量を生成するスゴ技職人「再構成ノード」 | IBM ソリューション ブログ https://www.ibm.com/blogs/solutions/jp-ja/spssmodeler-push-node-4/

Pythonで実装するアヒル本

アヒル本とは

アヒル本「StanとRでベイズ統計モデリング」、ベイズ界隈では有名な書籍です。

ベイズ推定を実装したい、と思ったときにまず最初に手に取ると良いでしょう。
しかし、ベイズとは何かという点について解説している本ではないため、ベイズの枠組みで事例を積み重ねることで事後分布を更新できるために得られる利点などについて納得ができていない方は、ベイズ自体の基礎的な解説を読んでからチャレンジしたほうが良いと思います。

なぜPythonか

上記本のオフィシャルでは、タイトルどおり実装はRなんですね。
Pythonで実装したい方も多いと思います。
私もその一人でしたので、Python実装をつくりました。

Python実装にあたって

Stanのインターフェイスについては、PyStanでRとほぼ変わらない使いごこちを実現できます。
一方で、データ整形についてはPandasを使うので、Rとはかなり異なるコードとなります。

利用するPythonライブラリ

• Python > 3
• PyStan

など、詳しくは以下をご覧ください。

requirements.txt

https://github.com/MasazI/python-r-stan-bayesian-model-2/blob/master/exec/requirements.txt

コード

すべてのコードはGithubに上がっていますので、実行自体はすぐできるかと思います。
練習問題もすべてPythonで解いてあります。

Github

https://github.com/MasazI/python-r-stan-bayesian-model-2

何かありましたらプルリクエストをいただけるとありがたいです。

はじめに

この記事はPycharmでDjangoを使ってアプリケーションを作成する準備の段階を書いていきます。
あくまで僕の手順なので、他の方の記事も見るとより理解が深まると思います。

新しいPycharmプロジェクトを作成する

1. Pycharmの左上のメニューバーから「ファイル」を選んでクリック。
2. その中の一番上の「新規プロジェクトを作成」をクリック。
3. ロケーションの部分にデフォルトで「untitled」とは言っているのでその部分を削除して、自分の好きなプロジェクト名を入れる。
4. 右下の作成を押すと新規のウィンドウに作成するか、今いるウィンドウで作成するか聞いてくるので、好きな方を選ぶ。 これでプロジェクトの作成は完了です。

仮想環境構築

今回はPipenvを用いて仮想環境の構築を行なっていきます。
Pycharmの左下のあるターミナルを開いてください。

インストールされているかの確認

まずインストールされているか確認します。

pipenv --version

数字が出ればインストールされています。

インストールされていない時

pip install pipenv

このように入力すればインストールができます。

Djangoを追加

pipenv install django

このように入力することで、最新のdjangoをインストールできます。

仮想環境有効化

pipenv　shell

このように入力すると、ターミナルの一番左の部分の「(base)」となっていた部分が、プロジェクト名に変わっていることが確認できます。
ここまでで仮想環境の構築は終了です。

Djangoのプロジェクトとアプリケーションを作成

まずはプロジェクトを作成していきましょう。

①django-admin startproject プロジェクト名 -> プロジェクト名のディレクトリの上に同じ名前のディレクトリができてしまう

②django-admin startproject プロジェクト名 . -> Pycharmのプロジェクトの直下に作成できる

①だとやってみるとわかるのですが、余計なディレクトリができてしまうので、②のように最後に「.」をつけるのがおすすめです。

次にアプリケーションを作成していきます。

python manage.py startapp アプリ名

これでアプリが作成できます。

ついでに

あとで作成することになるので、あらかじめ作成しておくと良いものを書いておきます。

Pycharmプロジェクト
      |
      |___templates
      |
      |___djangoプロジェクトディレクトリ
      |
      |___djangoアプリケーションディレクトリ___
      |                              |___urls.py
      |___manage.py                  
      |                              
      |___その他のファイル類             

urls.pyの作成

アプリの方には「urls.py」がないので、アプリのディレクトリを右クリックして、一番上の「新規」から「urls.py」と入力してファイルを作成しましょう。

templatesの作成

htmlファイルを入れておくtemplatesディレクトリを作成しましょう。
Pycharmプロジェクトのディレクトリを右クリックして「新規ボタン」を押して「templates」ディレクトリを作成しましょう。

Pycharmプロジェクト
      |
      |___templates
      |
      |___djangoプロジェクトディレクトリ
      |
      |___djangoアプリケーションディレクトリ
      |
      |___manage.py
      |
      |___その他のファイル類

順番はバラバラで良いのでこんな感じになっていれば十分です。

最後に

今回はPycharmでのdjangoを使ったアプリケーション作成の準備段階の手順を解説してきました。
参考になれば幸いです。
今後続きの記事を作成していく予定ですのでよければ見ていってください。

はじめに

この記事はPycharmでDjangoを使ってアプリケーションを作成する準備の段階を書いていきます。
あくまで僕の手順なので、他の方の記事も見るとより理解が深まると思います。

新しいPycharmプロジェクトを作成する

1. Pycharmの左上のメニューバーから「ファイル」を選んでクリック。
2. その中の一番上の「新規プロジェクトを作成」をクリック。
3. ロケーションの部分にデフォルトで「untitled」とは言っているのでその部分を削除して、自分の好きなプロジェクト名を入れる。
4. 右下の作成を押すと新規のウィンドウに作成するか、今いるウィンドウで作成するか聞いてくるので、好きな方を選ぶ。 これでプロジェクトの作成は完了です。

仮想環境構築

今回はPipenvを用いて仮想環境の構築を行なっていきます。
Pycharmの左下のあるターミナルを開いてください。

インストールされているかの確認

まずインストールされているか確認します。

pipenv --version

数字が出ればインストールされています。

インストールされていない時

pip install pipenv

このように入力すればインストールができます。

Djangoを追加

pipenv install django

このように入力することで、最新のdjangoをインストールできます。

仮想環境有効化

pipenv　shell

このように入力すると、ターミナルの一番左の部分の「(base)」となっていた部分が、プロジェクト名に変わっていることが確認できます。
ここまでで仮想環境の構築は終了です。

Djangoのプロジェクトとアプリケーションを作成

まずはプロジェクトを作成していきましょう。

①django-admin startproject プロジェクト名 -> プロジェクト名のディレクトリの上に同じ名前のディレクトリができてしまう

②django-admin startproject プロジェクト名 . -> Pycharmのプロジェクトの直下に作成できる

①だとやってみるとわかるのですが、余計なディレクトリができてしまうので、②のように最後に「.」をつけるのがおすすめです。

次にアプリケーションを作成していきます。

python manage.py startapp アプリ名

これでアプリが作成できます。

ついでに

あとで作成することになるので、あらかじめ作成しておくと良いものを書いておきます。

Pycharmプロジェクト
      |
      |___templates
      |
      |___djangoプロジェクトディレクトリ
      |
      |___djangoアプリケーションディレクトリ___
      |                              |___urls.py
      |___manage.py                  
      |                              
      |___その他のファイル類             

urls.pyの作成

アプリの方には「urls.py」がないので、アプリのディレクトリに作成します。

#アプリケーションディレクトリに移動
cd アプリケーションディレクトリ名

#urls.pyファイルを作成
touch urls.py

これで完了です。

templatesの作成

HTMLファイルを入れておくtemplatesディレクトリを作成しましょう。

#Pycharmのプロジェクトに移動
cd Pycharmプロジェクト名

#templatesディレクトリの作成
mkdir templates

これでOKです。

Pycharmプロジェクト
      |
      |___templates
      |
      |___djangoプロジェクトディレクトリ
      |
      |___djangoアプリケーションディレクトリ
      |
      |___manage.py
      |
      |___その他のファイル類

順番はバラバラで良いのでこんな感じになっていれば十分です。

staticディレクトリを作成

CSSファイルやJavaScriptファイル、画像ファイルなどを保存する「static」ディレクトリを作成しましょう。

#アプリケーションディレクトリに移動
cd アプリケーションディレクトリ名

#staticディレクトリを作成
mkdir static

#staticディレクトリに移動
cd static

#cssディレクトリ作成
mkdir css

#javascruptディレクトリ作成
mkdir javascrupt

#画像を入れておくディレクトリ作成
mkdir img

これで「static」ディレクトリの用意は完了です。

実行できるか確認

最後に実行できるか確認しましょう。

#データベース構成のバージョン管理をするための、マイグレーションファイルというものを作成
python manage.py makemigrations 

#データベース構成を変更したり、変更を取り消す
python manage.py migrate

この２つをターミナルに打ち込みましょう。

#実行！！！
python manage.py runserver

これを無事に実行できると

http://127.0.0.1:8000/

と表示されるのでクリックするとブラウザに飛びます。
ブラウザが開いた時にロケットが飛んでいれば無事に実行できています！

終わりに

今回はPycharmでのdjangoを使ったアプリケーション作成の準備段階の手順を解説してきました。
参考になれば幸いです。
今後続きの記事を作成していく予定ですのでよければ見ていってください。
続き
↓
↓
settings.py編

[Python]09章-01 オブジェクトの基礎

今まで、文字列や数値、データ構造の分野ではリストやタプルなどに触れました。データ構造の個所で触れましたが、これらはオブジェクトと言いました。

さて、このオブジェクトとは何でしょう。まずはオブジェクトについて説明して少し掘り下げていきたいと思います。

オブジェクトとは

まずはPython Consoleにて以下のコードを入力して確認してみましょう。

>>> S = 'hello'
>>> type(S)
<class 'str'>

Sという変数に'hello'という文字列を代入しています。さて、次にtype()関数により、<class 'str'>が出力されています。
これは、S変数がが現在str型のオブジェクトであることを意味しています。

では、strオブジェクトの詳細を見てみましょう。以下のURLから閲覧できます。
https://docs.python.org/ja/3/library/stdtypes.html#text-sequence-type-str

マニュアルを見てみると、str型はテキストシーケンス型と書かれています。要するに文字列型のオブジェクトということです。

さて、マニュアルを少し下に送ると、「文字列メソッド」というものが出てきます。
例えば、一番最初にあるstr.capitalize()メソッドを実行してみましょう。
なお、このマニュアルにある、strはstr型のオブジェクトを表すので、今回実際に入力するときにはSという変数名となります。

>>> S
'hello'
>>> S.capitalize()
'Hello'

先頭のみ、大文字になったことが確認できたと思います。詳細はstr.capitalize()メソッドマニュアルを見てください。

また、ほかのメソッドも見てみましょう。str.capitalize()メソッドを実行してみましょう。指定方法はマニュアルを参照してください。

>>> S.replace('l', 'L')
'heLLo'

replaceメソッドにより、文字列中の文字を変更ができます。詳細はマニュアルを見てみましょう。

他にもいろいろなメソッドをマニュアルを見ながらやってみましょう。今後、マニュアルに書いてある内容は一部を除き、割愛していきたいと思います。

さて、このstr型だけではないですが、オブジェクトの型にはほかにもあります。以下のコマンドでいろいろな方を確認してみましょう。

以下はint型オブジェクトとなります。

>>> num1 = 100
>>> type(num1)
<class 'int'>

以下はfloat型オブジェクトとなります。

>>> num2 = 10.5
>>> type(num2)
<class 'float'>

以下はlist型オブジェクトとなります。

>>> ls = ['Japan', 'America', 'China']
>>> type(ls)
<class 'list'>

以下はtuple（タプル）型オブジェクトとなります。

>>> tp = (10, 20, 30)
>>> type(tp)
<class 'tuple'>

以下はdict（ディクショナリ）型オブジェクトとなります。

>>> dc = {'jp':'Japan','us':'America', 'ch':'Chine'}
>>> type(dc)
<class 'dict'>

これらそれぞれの型のオブジェクトにはメソッドを持ちます。実際に調べてみましょう。ほとんどは以下のURLに記載してあります。
https://docs.python.org/ja/3/library/stdtypes.html

＜重要＞
実は、あるデータとその振る舞い（メソッド）が一塊になっているものを一般にオブジェクトと言います。
基本的にPythonにおける値はオブジェクトと言えます。

また、関数もオブジェクトと言えます。出漁結果はとなります。

def calc_func(x):
    print('関数内で実行します')
    f = (x ** 2) + (3 * x) + 4
    ##計算結果fを返す
    return f

print(type(calc_func))

オリジナルのオブジェクト

先ほどはint型やstr型、そしてlist型などのオブジェクトがありましたが、実はオブジェクトは自分で作成することができます。
これについては次回触れていきたいと思います。

最後に

このオブジェクトの概念は非常に取り扱いの難しいものなので、最初は壁を感じるかと思います。ポイントは先ほどのURLにもあった、いろいろなマニュアルを読んでみることです。
最初は意味が分からなくても、読んでいくことで意味が分かってくるようになりますので、ポイントはマニュアルを見ながら実際に実行してみることです。

【目次リンク】へ戻る

とある数学（というか数字）嫌いマンの伝説

• 数IIIと数Cをなんとなくのコレクション精神で履修してみるも、何もかも意味がわからない
• 原因をたどったらそもそも数Iあたりから既によくわかっていなかった
• 飲み会に行くと割り勘の計算ができない
• むしろ1000円上乗せぐらいならあげるからよしなにやっといてという気持ち
• なぜかプログラムは一般人レベルぐらいには書ける

で、なんで今更？

• なんか分析とかやってみたいの！かっこよさそうじゃん？
• 最終的には未来を予測してこの世界の神になるんじゃ！

というわけで神を目指す数学嫌いマンは着々と数学の復習をしていったわけですが....。
数学記号あるじゃないですか。なんすか、あれ。知らんし。

そこで思いついたのです。
数学記号がよくわからないならプログラムで実装してみたら良いのでは、と。

Σを実装してみる

とりあえず手始めにΣの意味を忘れてしまったので、自分で実装してみることにしました。
※本記事はわからない人がわからないなりに理解しようとした内容のため、用語等が正確でない場合があります

そもそもΣの目的とは

目的が不明確だと勉強しても全くしっくり来ませんね。
Σの意味は総和、つま数の一覧（配列）を作成して合計値を求めることです。

たとえば[1,2,3,4,5,6,7,8,9,10]の合計値は55ですが、この合計値を一文字で書き表すために使う記号ということになるでしょう。いや、わかりますよ。でもそれなら1～10までの合計って書けばいいじゃん。

では仮に数の一覧が[2,4,6,8,10]だったら。「1～10の中の偶数値のみの合計」となるでしょうけれど、長い。条件が複雑化すればするほど読みにくくなるらしいです。個人的には文章化してくれたほうが読みやすいんですけどね。

ともかくここでΣが登場します。

Σは繰り返し処理である

たとえば、[1,2,3,4,5,6,7,8,9,10]の合計値はこのように表すことができます。

つまり、1から10まで繰り返しながら、繰り返し毎に1から10までの値をそのまま配列に追加して行き、最後に配列内の全要素の合計を求めるという意味になります。
私の場合は合計をいきなり求めようとするとアレルギー反応を起こしますので、まずは落ち着いて先に数列を作ります。というわけで1~10までの配列（リスト）をpythonで実装してみます。

array = []
for i in range(1, 11):
  array.append(i)

うん、全然問題ないですね。
あとは合計値を求めるのであれば、

sum(array)
 # => 55

と書けば合計値が求まるはずです。

コードに落とすと余裕なのにΣだと一瞬意味不明に見える。
これは数学記号が格好つけて可読性の低い記号や文字を使っているからです。
本当は多分由来とかあるんだと思います....。
ではこの一般的なpythonコードとΣ記号の差を埋めていきましょう。

同じ役割を持つ変数や値を色分けしてみました。
これで多少はわかりやすくなります。「どこまで繰り返すか」はrange()関数の仕様上11になりますが仕方ないです。

この場合だと、kとiは同じ役割を担っていますね。
どうせなら変数名は統一しましょう。

array = []
for k in range(1, 11):
  array.append(k)

これで少しわかりやすくなりました。

こころのこえ

kとかnとかaとか使わずに"start_from"とか"end"とか"element"とかわかりやすい変数名にしてくれたらいいのにな。そもそもΣ自体、英語で総和を表す"Summation"のSをギリシャ文字のΣにしたものらしいですよ。じゃあSummationでいいじゃん。なんで略すのよ。そもそもsummationの語源ってラテン語だからね？なんでギリシャ文字にするのよ。かっこいいけどさ！

処理部分のカスタマイズ

さて話を戻します。
Σの右側が先程は"k"と書いてありましたが、このようにまた別の式が入ってくることもあります。

これは、コードにすれば非常にシンプルです。
最終的にリストに含めたい値がどのように加工されるのかを示していると考えると良いでしょう。

array = []
for k in range(1, 11):
  array.append(k) #ここのkの部分に当たる

ですので、今回の例であれば

array = []
for k in range(1, 11):
  array.append(2 * k) 

このように書けるわけです。

非常にシンプルな式しか扱っていませんが、あとはこれの応用でいけるのではないでしょうか。

ちょっと遊んでみる（おまけ）

さて、基礎はわかったのでプログラム的な視点で調整してみようと思います。
まず、毎回書くのは面倒なので関数化してみます。

安直な関数化

安直に関数化するとこうなりますね。戻り値はちゃんと総和を返すようにしています。

def sigma():
  array = []
  for k in range(1, 11):
    array.append(2 * k)

  return sum(array)

値を外から受け取る

このままだと柔軟性に欠けるので、値はちゃんと外から受け取るようにしましょう。

def sigma(k, n):
  array = []
  for k in range(k, (n + 1)):
    array.append(2 * k)

  return sum(array)

#関数の呼び出し例
print(sigma(1, 10))
 # => 1から10それぞれに2を掛けたものの総和なので110

式も外から受け取る

式も外から受け取れるようにしましょう。ここはラムダ式を使ってみます。

def sigma(k, n, func):
  array = []
  for k in range(k, (n + 1)):
    array.append(func(k, n))

  return sum(array)

#関数の呼び出し例
print(sigma(1, 10, lambda k, n : 2 * k))
 # => 1から10それぞれに2を掛けたものの総和なので110

ここで察しました。
あれ、リスト内包表記ってもしかして....

リスト内包表記の場合

array = [2 * k for k in range(1, 11)]
print(sum(array))

なるほど.....。

print(sum([2 * k for k in range(1, 11)]))

なんと1行にまで縮まりました。
実行速度が早いとかは知ってましたが、リスト内包表記ってこういう意味でも楽なんですね。
なんならこのあと条件分岐とかも挟めますし！

結論

プログラムが書けるけど数学ができない人はプログラムを書いてみるのも手かもしれません！
Σが便利だとは思いませんでしたが、少なくとも理解はできましたしリスト内包表記が素晴らしいことはわかりました（笑）。

はじめに

　Raspberry Piをセンサーモジュールに接続して、検知情報を自分のLINEに通知する人感センサーを作ってみました。

経緯

　社内の試作アプリ作成の一環として、人感センサーの構築を担当することになりました。
　ラズパイってなあに？Pythonって聞いたことあるけど何ができるの？状態からスタートして、センサーが反応したらLINEにお知らせしてくれるものを作ってみました。
　自社への作業報告を兼ねて記事を投稿してますが、ラズパイを使って電子工作をしてみたい！という方の参考になれば幸いです。

作るにあたり必要なもの

　・RaspBerry Pi Zero　
　・Ren He HC-SR501人体赤外線感応モジュール
　　　( URL:https://www.amazon.co.jp/gp/product/B07DCKZS5S )
　・SDカード
　・ブレッドボード・ジャンパーワイヤー（メス-メス）
　　　( URL:https://www.amazon.co.jp/gp/product/B01A4DDUTA )
　・USBハブ
　・モニター
　・USBキーボード
　・プラスチックハンマー
　・GPIOハンマーヘッダー
　　　( https://www.amazon.co.jp/gp/product/B0711MPHVF/ )

OSのインストール

ラズパイの公式サイトからOSをダウンロードします。
今回はNOOBS Liteを利用しました。
ダウンロードしたOSのZipファイルを解凍して、SDカードに書き込みます。

ラズパイとセンサーモジュールの接続

GPIO Hammer Header使ってGPIOピンをラズパイにプラスチックハンマーでトントンしたら、センサーモジュールと同じ役割のGPIOピンにジャンパーワイヤーで接続します。
今回使用したRaspBerry Pie Zeroではこんな感じで接続します。

センサーモジュールの検知時間と検知範囲はこのぐらいに設定しました。

初期設定

ラズパイにSDカードを挿入します。
モニター、USBキーボード、マウス、電源を接続してラズパイを起動します
こちらの記事を参考に、初期設定を行います

センサーモジュール動作確認

PythonでラズパイのGPIOの制御設定を行い、センサーモジュールの動作確認をします。
以下のプログラムを実行します

sensor_test.py

import RPi.GPIO as GPIO
GPIO_PIN = 12

GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIO_PIN,GPIO.IN)

while True:
    if(GPIO.input(GPIO_PIN) == GPIO.HIGH):
        print("1")
        break
GPIO.cleanup()

プログラム実行後、センサーモジュールに手をかざしてみて、以下の結果になれば動作確認完了です

pi@raspberrypi:~ $ python /home/pi/work/sensor_test.py
1

LINE Notifyでアクセストークンの発行

1. LINE Notifyにアクセスして、通知を送りたいLINEのアカウントでログインしマイページを開きます

2.「トークンを発行する」をクリックします

3.トークン名を任意のトークン名に設定し、「1:1でLINE Notify 通知を受け取る」を選択する

4.発行されたトークンをメモします

人感センサーの検知情報をLINEへ通知

いよいよプログラム実装します！
センサーモジュールからの感知情報をラズパイでうけとり、LINE Notifyに向かってAPIをたたきます。

detection_LINE.py

import requests
import RPi.GPIO as GPIO
import time

SLEEPTIME = 30

GPIO_PIN = 12
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIO_PIN,GPIO.IN)

def main():
    url = "https://notify-api.line.me/api/notify"
    token = "先ほどメモしたアクセストークン"
    headers = {"Authorization" : "Bearer "+ token}

    message =  'IN USE!!!!!'
    payload = {"message" :  message}
    requests.post(url ,headers = headers ,params=payload)


try:
    while True:
        if(GPIO.input(GPIO_PIN) == GPIO.HIGH):
                  main()
          time.sleep(SLEEPTIME)

finally:
    GPIO.cleanup

ラズパイ起動時に自動で実行されるようにCronの設定をします。

crontab -e 

cronの設定ファイルが開いたら、最終行に以下を追加します。

@reboot python /home/pi/work/detection_LINE.py

ラズパイ再起動

ラズパイを再起動して、センサーモジュールに手をかざしたら通知が来ました！

つくってみての感想

ちんぷんかんぷんな状態からスタートしましたが、GPIO取り付けるのに意外に力使ったり、センサーモジュールの検知範囲マックスにした状態＋スリープタイム挟まずにスクリプト実行して爆竹のごとくLINE通知鳴りやまなかったりと、初心者ならではの周り道もたくさんしましたが、夏休みの自由研究感覚で楽しめました！

次はAWSのLambdaあたりを使って何か作れたらなあ～と思います。

本投稿の背景

Oracle Cloud にも NoSQL(Oracle NoSQL Database Cloud) があるのですが、
NoSQLの場合、Pythonで DDLや DMLはどうやって実行するのか？を調査したいと思ったのがきっかけです。

Oracle NoSQL Database Cloudシミュレータというのがあり、
ローカルPCで試すことができますので、Oracle NoSQL Database Cloudシミュレータを使用する手順とPythonでDDLやDMLをどうやって実行するのかをまとめました。

本投稿では
Windows10環境で Pythonから Oracle NoSQL Database Cloud シミュレータを触ってみる内容となります。

前提はWindows10環境にAnaconda-Python 3.7 versionがインストールしている状態からの手順です。

Oracle NoSQL Database Cloudシミュレータとは

https://docs.cloud.oracle.com/ja-jp/iaas/nosql-database/doc/developing-oracle-nosql-database-cloud-simulator.html

Oracle NoSQL Database Cloudシミュレータでは、クラウド・サービスをシミュレートし、
Oracle NoSQL Database Cloud Serviceにアクセスせずにローカルでアプリケーションを記述およびテストできます。
Oracle NoSQL Database Java SDKには、開発者が使用するサンプルがいくつか含まれています。

Oracle NoSQL Database Cloud Serviceを使用して開始する前に、
Oracle NoSQL Database Cloud Simulatorでアプリケーションを開発し、基本的な例を理解できます。

⇒Oracle NoSQL Database Cloudシミュレータは、Oracle Cloud に接続せずに、ローカル環境(ノートPC)で、アプリ(Python、Java、Node.js、Go)を試せる環境が準備できます。

環境準備

環境準備は以下２つを準備します
1.Oracle NoSQL Database Cloudシミュレータのダウンロード
2.Oracle NoSQL Database Python SDK のインストール

前提はWindows10環境にAnaconda-Python 3.7 versionがインストールしている状態からの手順です。Anacondaのインストールは こちら から

1.Oracle NoSQL Database Cloudシミュレータのダウンロード

https://docs.cloud.oracle.com/ja-jp/iaas/nosql-database/doc/downloading-oracle-nosql-cloud-simulator.html#GUID-3E11C056-B144-4EEA-8224-37F4C3CB83F6 にアクセス

　
　
　

oracle-nosql-cloud-simulator-1.2.0.zip　を任意のフォルダにダウンロードして解凍します。

Oracle NoSQL Database Cloudシミュレータを動かすための要件

・使用しているマシンにJava JDKバージョン10以上がインストールされていること。
・Oracle NoSQL Database Cloud Simulatorをインストールする5 GB以上の使用可能なディスク領域。

Java JDKバージョン10以上インストールされていない場合

※私の環境ではJava JDKが未インストールでしたので、新規インストール手順となります。例は新規インストールとなります。

https://www.oracle.com/java/technologies/javase-downloads.html
こちらの[ JDK Download ]をクリックして、Windows x64 Installer をダウンロード。

1.ダウンロードした jdk-14.0.1_windows-x64_bin.exe をダブルクリック。
2.以下手順でJava SDKをインストール
　
　
　

2.Oracle NoSQL Database Python SDK のインストール

Anaconda プロンプトを起動

Anaconda プロンプトで

pip install borneo

と入力して [Enter]

※Successfully installed borneo-5.2.0 が出ればOK

Oracle NoSQL Database Cloudシミュレータの起動

1.コマンドプロンプトを起動

コマンドプロンプトを起動される

2.環境変数(PATH)に Java JDK のパスをいれる
今回インストールしたJava JDKのパスは、C:\Program Files\Java\jdk-14.0.1\bin
set PATH=C:\Program Files\Java\jdk-14.0.1\bin;%PATH%　で環境変数PATHにJava JDKのパスを設定

Java -version と入力して、Java JDKのバージョンを確認
⇒今回インストールした Java JDK 14になっていることを確認

コマンドプロンプトで
oracle-nosql-cloud-simulator-1.2.0を解凍したディレクトリに移動

cdコマンドで、oracle-nosql-cloud-simulator-1.2.0を解凍したディレクトリに移動

コマンドプロンプトで以下のコマンドを入力
※マニュアルでは Linux のコマンドしかない。実行ファイル「runCloudSim」 をメモ帳で開き中に書いてあるコマンドを確認。 必須パラメータ -root は 現在のディレクトリとするため . としています。

java -Djava.util.logging.config.file=logging.properties -jar cloudsim/lib/cloudsim.jar -root . 

「Oracle NoSQL Cloud Simulator is ready」で　起動されている状態になります

Oracle NoSQL Database Cloudシミュレータの停止方法

[Ctrl]+C で停止になります。

サンプルスクリプトを実行してみる

GitHubから pythonのサンプルスクリプト(nosql-python-sdk-5.2.0.zip)をダウンロードします。
　https://github.com/oracle/nosql-python-sdk/releases

nosql-python-sdk-5.2.0.zipを任意のフォルダに解凍します。
サンプルスクリプトは [examples]フォルダに格納されています。

Anaconda プロンプトを起動

サンプルスクリプトを実行(試しにsingle_data_ops.pyを実行)
サンプルスクリプトをドラッグして[Enter]キーを押下します。
※Oracle NoSQL Database Cloudシミュレータは起動しておく必要があります

single_data_ops.py の 実行結果
　※single_data_ops.py の中で、各処理実行後、結果を表示しています。

single_data_ops.pyの中に
テーブル作成、データ登録、データ抽出、データ削除、テーブルDropの処理が記載されておりましたので、single_data_ops.pyを参考にして頂ければと思います。

また詳細は、Oracle NoSQL Database Python SDK(日本語) 、SQL Reference for Oracle NoSQL Database(SELECT Expression)　も参考になりました。

multi_data_ops.py、table_ops.py　もサンプルスクリプトとして実行することができます。

参考

・Oracle NoSQL Database Python SDK
　　https://docs.oracle.com/cd/E83857_01/paas/nosql-cloud/sdk/index.html

・SQL Reference for Oracle NoSQL Database(SELECT Expression)
https://docs.oracle.com/en/database/other-databases/nosql-database/19.5/sqlreferencefornosql/select-expression.html

・NoSQLデータベース マニュアル
　　https://docs.cloud.oracle.com/ja-jp/iaas/nosql-database/index.html

・NoSQLデータベース マニュアル (Oracle NoSQL Database Cloudシミュレータでの開発)
　　https://docs.cloud.oracle.com/ja-jp/iaas/nosql-database/doc/developing-oracle-nosql-database-cloud-simulator.html

6.文字列操作

シングルクォート、ダブルクォート

文字列にシングルクォートを含む場合、文字列をダブルクォートで囲むことでエラーを回避できる。

spam = "That is Alice's cat"

エスケープ文字

しかし、シングルクォートとダブルクォートの両方を使いたいときはエスケープ文字を用いることで回避できる。

エスケープ文字	意味
\'	シングルクォート
\"	ダブルクォート
\t	タブ
\n	改行
\\	バックスラッシュ

print("Hello there!\nHow are you?\nI\'m doing fine\t."
Hello there!
How are you?
I'm doing fine  .

windowsでは、 \ は ¥ になる。

raw文字列

クォート文字の前 r に付けると文字列のエスケープ文字を無視する。

print(r'That is Carol\'s cat.')
That is Carol\'s cat.

三連クォート

三連クォートを用いればエスケープ文字を使う必要がなくなる。
Pythonの字下げルールも適用されない。

print('''Dear Alice,

Eve's cat has been arrested for catnapping, cat burglary, and extortion.

Sincerely,
Bob''')

Dear Alice,

Eve's cat has been arrested for catnapping, cat burglary, and extortion.

Sincerely,
Bob

複数行コメント

#記号はつけた場所から文末までコメントを挟み込むことができる。
複数行にわたってコメントを入れたいとき以下のようには"""で囲む。

def spam():
    """これはspam()関数の動きを説明するための、
    複数行コメントです。"""
    print('Hell!')　　

文字列のインデックスとスライス

文字列もリストと同様にインデックスとスライスを適用することができる。

便利な文字列メソッド

• upper()

文字列の全てを大文字にして返す。

spam = 'Hello world'
sapam = spam.upper()
spam
'HELLO WORLD'

• lower()

文字列の全てを小文字にして返す。

spam = 'Hello world'
sapam = spam.lower()
spam
'hello world'

• isupper()

1文字以上の全ての英字が大文字ならTrueを返す。

HELLO.isupper()
True

• islower()

1文字以上の全ての英字が小文字ならTrueを返す。

hello.islower()
True

isXという文字列メソッド

• isalpha()

一文字以上の英字のみで構成されているときTrueを返す。

'hello'.isalpha()
True

• isalnum

一文字以上の英字、数字のみのときTrueを返す。

'hello123'.isalnum()
True

• isdecimal

一文字以上の数字のみで構成されているときTrueを返す。

'123'.isdecimal()
True

• isspace

スペースかタブか改行だけで構成されているときTrueを返す。

' '.isspace()
True

• istitle

大文字から始まり残り全ての英字が小文字で構成されているときTrueを返す。

Apple.istitle()
True

startswith()メソッド、endswith()メソッド

対称の文字列がメソッドに渡された文字列から始まるか、終わる場合にTrueを返す。

'Hello world!'.startswith('Hello')
True
'Hello world!'.endswith('World!')
True

join()メソッド、split()メソッド

• join()メソッド

文字列のリストを一つの文字列に連結する。

','.join(['cats','rats','bats'])
'cats,rats,bats'
'ABC'.join(['cats','rats','bats'])
'catsABCratsABCbats'

• split()メソッド

文字列を指定した文字で区切り、リストにする。

'My name is Simon'.split()
['My','name','is','Simon']
'MyABCnameABCisABCSimon'.split(ABC)
['My','name','is','Simon']

テキストをそろえる

• rjust()メソッド
• ljust()メソッド

文字列が指定した数値より大きいとき、その分だけ指定した文字を右、もしくは左に加える。

'Hello'.rjust(10, '*')
'*****Hello'
'Hello'.ljust(10, '*')
'Hello*****'

• center()メソッド

文字列が指定した数値より大きいとき、その分だけ指定した文字を左右に加える。

'Hello'.center(10, '*')
'**Hello***'
'Hello'.center(10)
'  Hello   '

strip()メソッド、rstrip()メソッド、lstrip()メソッド

文字列の左端、右端、両端から指定した文字を消すときに用いる。

spam = '     Hello world  '
spam.strip()
'Hello world'
spam.lstrip()
'Hello world  '
spam.rstrip()
'     Hello world'

また、引数を渡すことで以下のように文字を消すこともできる。
引数のアルファベットの順番は任意になるので以下のようになる。

spam = 'SpamSpamBaconSpamEggsSpamSpam'
spam.strip(ampS)
BaconSpamEggs

pyperclipモジュール

pyperclipモジュールにはcopy()、paste()関数がある。
コンピュータのクリップボードにコピーしたり、ペーストすることができる。

import pyperclip
pyperclip.copy('Hello world!')
pyperclip.paste()
'Hello world!'

続き

Pythonの基礎復習はこれだけ~4~

初めから
Pythonの基礎復習はこれだけ~1~

↓PythonをSegmentation Faultで落とすのが最近流行っているようなので。
pythonを三行でセグフォらせる
pythonを2行でセグフォらせる
pythonを1行でセグフォらせる
Pythonを33文字でセグフォらせる
Pythonをctypesを使わずに1行でセグフォらせる
Rustを5行でセグフォらせる
主語(Python)をC言語に変えるだけで途端につまらなくなりますが、やってることは同じです。

コード

gcc 10.1.0で動作確認(警告は出ます)

*a;main(){*a=0;}

> gcc segf.c
segf.c:3:4: 警告: データ定義が型または記憶域クラスを持っていません
    3 |    *a;main(){*a=0;}
      |    ^
segf.c:3:5: 警告: 型がデフォルトの ‘int’ に ‘a’ の宣言内でなります [-Wimplicit-int]
    3 |    *a;main(){*a=0;}
      |     ^
segf.c:3:7: 警告: 戻り値の型をデフォルトの ‘int’ にします [-Wimplicit-int]
    3 |    *a;main(){*a=0;}
      |       ^~~~
> ./a.out
zsh: segmentation fault (core dumped)  ./a.out

簡単な解説

これだけだとQiitaの記事要件を満たさないため、簡単に解説します。
まず最初に観るコードは↓です。

int main(void) {
    int *a = 0;
    *a = 0;  // ←ここで落ちる
    return 0;
}

C言語にはポインタという概念があり、これを用いるとメモリの好きな番地にアクセスすることができます。
int *a = 0のところでaという名前のポインタを宣言し、メモリ番地0を代入します。2行目で*aに値を代入すると、実際には存在しないアドレス¹ にアクセスすることになり、CPU例外が発生します。

ショートコーディング

それでは、上のコードを短くしていきましょう。まず、C言語の規約上return 0は省略できます。²また、返り値の型intも互換性の観点から省略できます。(省略すると暗黙的にintになります。)さらに、引数のvoidも書かなくても動きます。
これらを踏まえると以下のようになります。

 main() {
    int *a = 0;
    *a = 0;  // ←ここで落ちる
}

ここで、ローカル変数aはグローバル変数として定義してもよいです。さらに、グローバル変数として定義すると、(よほど特殊な環境でない限り)0で初期化してくれるため初期化のための代入が不要です³。

int *a;
main() {
    *a = 0;  // ←ここで落ちる
}

さらに、グローバル変数の型指定子intも省略できます。これで冒頭のコードになりました。

おまけ。番地*(0p00000000)は本当に存在しないか?

古典的なコンピュータにおいて、メモリはたくさんの情報を保管しておくことができる装置です。しかしながら、たくさんの情報をメモリに送ったり、メモリから受け取るためには、直感的には送受信したい情報の個数分だけ電線が必要になります。しかしながら、CPUの動作速度に耐えられるような細い電線をたくさん用意するのはコスト面で不可能なので、メモリアドレスという概念を導入します。これにより、一度に読み書きできる情報の個数(1Byteという)⁴は少ないながら、メモリアドレスを変更することによってたくさんの情報をメモリに保管することができます。

このように、メモリ大容量時代に欠かすことのできないメモリアドレスという概念ですが、これは0から始まる正の整数で表されるため、実際には0番地というアドレスは存在するのです。では、なぜセグメンテーションフォルトが起きたか、というと、OSが利用しているページングというCPUの機能が原因です。

コンピュータにおいてメモリアドレスはユニークです。よって、特に工夫しない場合、マルチタスキングOSにおいて複数のプロセスが同じメモリアドレス空間を所有することになります。この場合、メモリにアクセスする場合は、他のプロセスが利用しているメモリに間違ってアクセスしないように気をつけなければなりません。このような不便を解消するのがページングで、ページングを用いると各プロセスがそれぞれ別個の仮想アドレス空間を所有できます。このとき、仮想アドレス空間⁵と物理(メモリ)アドレス空間の間を変換する表をOSが管理しています。

よって、本来プロセスは存在するすべてのアドレスにアクセスできるはずです。しかしながら、実際はそうはいかず、仮想アドレス空間においてもOSが幅を利かしています。プログラムから利用できるメモリの範囲を制限しているのです。このような仮想アドレス空間の区画分けをメモリマップといいます。この記事にあるように、0番地の周辺は使用しないこととなっており(対応する物理メモリアドレスが割り当てられていない)、そのためセグメンテーションフォルトが発生します。⁶

おわりに

さらっと書くつもりが20分くらい掛かった。書かなきゃよかった。

---

1. 後述。 ↩

2. return 0;を省略するのは間違い、と勘違いしている人が大勢います。 ↩

3. セグフォを起こすだけなので、初期化しなくても大丈夫だろうけど。 ↩

4. 実際にはメモリモジュール一本あたり64bitが同時に書き込めます。他にもDMA等の技術により、高速にメモリにアクセスできます。 ↩

5. とリニアアドレス空間 ↩

6. OSの実装方法によります。また、OSによっては別のCPU例外が発生します。 ↩

はじめに

KerasのF.Cholletの本を読むと、Concatenate Layerの説明がされている部分がある。下記の絵で表現されているが、この中でどんな演算が行われているかさっぱりしたまなであった。

ところで、U-NET, ResnetなどにConcatenate Layerが重要な役割をしていることから、これ以上にConcatenate Layerを理解せず放置することは良くない判断で、簡単なテンソルを利用し、Concatenate Layerの挙動を確認することにした。

図　U-Net アーキテクチャー

図　ResNetブロック

理解

Excelで、文字列結合の時に、Concatenate関数を使ったことがあったので、何となく複数の配列を何の演算もせず、くっつけるイメージは持っていたが、Teratailにわかりやすい図があったので、ここで紹介する。

ここで、青と緑二つの行列がある。
これらの行列は2次元（2D)テンソルで、これらの行列のShapeは（3,3)である。
axisとは、テンソルの次元（Dimension)を言う。[テンソル(Tensor)の理解(2) : Shape]

axisは、テンソルの次元の軸も指す。（物理でのモーメントを表記するときのベクトルを考えるといいかもしれない。）

2次元テンソルの場合、axis = 0が垂直方向、　axis = 1が水平方向を意味する。

ただし、axis = -1とした場合は、一番最後の軸を意味する。Pythonのリストのスライスを考えるといい。

そして、Concatenate　Layerの時、結合方向を指定することが可能である。

(1) axis = 0の場合、垂直方向に結合する。

(2) axis = 1の場合、水平方向に結合する。（ただし、2次元の場合、axis = -1も同じ意味）

プログラムコード

import tensorflow as tf
import numpy as np

#2D Tensorの準備
x1 = np.array([[1,3,3],
               [5,2,1],
               [0,9,5]])

x2 = np.array([[3,2,3],
               [8,7,4],
               [0,1,1]])

print('x1=',x1)
print('x2=',x2)

Concatenate Layer　

垂直結合

#Concantenate Layer
# axis = 0, 垂直方向結合
y1 = tf.keras.layers.Concatenate(axis=0)([x1,x2])
print('y1=',y1)

垂直結合結果

y1= tf.Tensor(
[[1 3 3]
 [5 2 1]
 [0 9 5]
 [3 2 3]
 [8 7 4]
 [0 1 1]], shape=(6, 3), dtype=int32)

水平結合

# axis = 1 (or axis = -1)  水平方向結合
y2 = tf.keras.layers.Concatenate(axis=-1)([x1,x2])
print('y2=',y2)

水平結合結果

y2= tf.Tensor(
[[1 3 3 3 2 3]
 [5 2 1 8 7 4]
 [0 9 5 0 1 1]], shape=(3, 6), dtype=int32)

まとめ

やっとConcatenate　Layerの動作を理解した。（気がする。）
ただし、Concatenateのスペリングがなかなか頭に入らない。（涙）

参考資料

1. axis=-1の意味がわかりません(Python・Keras)
2. tf.keras.layers.Concatenate
3. kerasで頭に描いたネットワーク構造を実現するためのTips ~ Lambda 編 ~

なろう小説APIを読んでいたら面白いコマンドを見つけたので紹介と分析をしてみる

会話率

パラメータ	値	説明
kaiwaritu	int string	抽出する小説の会話率を%単位で指定できます。範囲指定する場合は、最低数と最大数をハイフン(-)記号で区切ってください。

なるほど。会話率……
会話ばっかりとか地の分とかそういうのかな

ではでは早速

ロードの準備とライブラリの読み込みをし

before_load.py

import pandas as pd
import requests
import numpy as np
import seaborn as sns
from scipy import stats
import matplotlib.pyplot as plt
%matplotlib inline

url = "http://api.syosetu.com/novelapi/api/"

narou_load.py

st = 1
lim = 500

data = []
while st < 2000:
    payload = {'of': 't-gp-gf-n-ka', 'order': 'hyoka',
          'out':'json','lim':lim,'st':st}
    r = requests.get(url,params=payload)
    x = r.json()
    data.extend(x[1:])
    st = st + lim
df = pd.DataFrame(data)

df.head()

payload = {'of': 't-gp-gf-n
この部分にkaという部分を追加すればロードができる。(上では追加済み)
そして出てくるデータが

title	kaiwaritu(%)
転生したらスライムだった件	14
ありふれた職業で世界最強	40
とんでもスキルで異世界放浪メシ	36
無職転生　- 異世界行ったら本気だす -	22
デスマーチからはじまる異世界狂想曲（ web版 ）	38

なるほど。ありふれ結構高いな（ファン）
ただ、そもそもこれがどれくらい高いのか分からないのでdescribe()してみる

	kaiwaritu
count	2000.00000
mean	38.00800
std	10.66831
min	0.00000
25%	31.00000
50%	38.00000
75%	45.00000
max	96.00000

なるほど。平均が38％となると平均くらいなのか。
というか、ありふれくらい文字数が多くてこの割合って結構多いのか？

文字数を少し絞ってみようか。

読了時間

あえて文字数を指定せずに読了時間というものを使ってみる
といっても読了時間とは

パラメータ	値	説明
time	int string	抽出する小説の読了時間を指定できます。読了時間は小説文字数÷500を切り上げした数字です。範囲指定する場合は、最小文字数と最大文字数をハイフン(-)記号で区切ってください。

と、ある通り文字数に比例した数字なので数字が小さくなる以外はそこまで問題はないはず。

payload のof にtiを追加して早速ロード

せっかくなのでtimeをdescribe()してみて

	time
count	2000.000000
mean	1395.985500
std	1823.680635
min	11.000000
25%	434.750000
50%	889.500000
75%	1608.250000
max	26130.000000

一応最低でも5001文字以上はあるようだ。
(...というかmaxってサモナーさんじゃないだろうな)
df[['title','time']].sort_values('time').tail()

title	time
マギクラフト・マイスター	14868
境界迷宮と異界の魔術師	16410
異世界料理道	17653
サモナーさんが行く	25536
レジェンド	26130

違いました

読了時間(文字数)と会話率の関連性

doku_kai.py

#時間で四分位する
df['part']=pd.qcut(df.time,4,labels=['D','C','B','A'])
#パート毎に平均する
df.groupby('part').agg({'kaiwaritu':['mean']})

※文字数はD<C<B<A

part	kaiwaritu(平均:％)
D	36.990
C	38.180
B	38.322
A	38.540

これは驚いた。特に長編だろうが短編だろうが会話率は変わらないようだ。

文体

悔しかったので、もう一つ文体という機能を使ってみた
これはまだ試作段階のようで、はっきりとデータが出ない場合がある(そもそもあいまい)のと、ofに設定ができないのでデータフレーム読み込みを2種類作ることにする

パラメータ	値	説明
buntai	int string	文体を指定できます。ハイフン(-)記号で区切ればOR検索できます。 1：字下げされておらず、連続改行が多い作品 2：字下げされていないが、改行数は平均な作品 4：字下げが適切だが、連続改行が多い作品 6：字下げが適切でかつ改行数も平均な作品

まず、それぞれdf1、df2、df4、df6にわける

• df1

失格紋の最強賢者　～世界最強の賢者が更に強くなるために転生しました～
公爵令嬢の嗜み
転生賢者の異世界ライフ　～第二の職業を得て、世界最強になりました～
乙女ゲームの破滅フラグしかない悪役令嬢に転生してしまった…
ライブダンジョン！

• df2

異世界食堂
誰かこの状況を説明してください
針子の乙女
私はおとなしく消え去ることにします
中堅(中年)サラリーマンのまったり異世界産業革命

• df4

ありふれた職業で世界最強
無職転生　- 異世界行ったら本気だす -
デスマーチからはじまる異世界狂想曲（ web版 ）
Ｒｅ：ゼロから始める異世界生活
陰の実力者になりたくて！【web版】

• df6

転生したらスライムだった件
とんでもスキルで異世界放浪メシ
私、能力は平均値でって言ったよね！
蜘蛛ですが、なにか？
聖女の魔力は万能です

一部納得いかない分類もあるが、ここは我慢する

	df1	df2	df4	df6
count	500.000000	500.000000	500.00000	500.000000
mean	36.506000	35.246000	38.74200	37.668000
std	11.489211	14.927396	9.70091	13.106691
min	1.000000	0.000000	6.00000	0.000000
25%	28.000000	25.000000	32.75000	30.000000
50%	36.000000	35.000000	39.00000	38.000000
75%	44.000000	44.250000	45.00000	46.000000
max	70.000000	98.000000	71.00000	96.000000

この結果を見ると、大きな差は無いもののdf2が全体的に少なく、逆にdf6が多い結果になった。
尚、母数を500ずつにしているのは最初の母数が2000だったからであって、2000ずつ表示にしたときdf2はさらに下がり34％であった。

こうみると会話率は文体にもかかわってないようだ。やっぱりジャンルなのかな

感想

あまり上手くいかない分析結果になってしまったが、今後仕事としてやっていくときの練習にはなったのかなとは思った。
また面白いデータ分析を思いついたらやってみたいと思う。
読み返してみたら転スラの会話率の低さに驚いた。心の中の会話が多いからか？

Python アプリから Oracle データベースに繋ぐ必要があり Python クライアントを入れる Dockerfile を書いたのだが、やたら苦労したので備忘録として書いておく。

Dockerfile

FROM python:3.7

RUN pip install cx_Oracle

# Install Oracle Client
ENV ORACLE_HOME=/opt/oracle
ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib
RUN apt-get update && apt-get install -y libaio1 && rm -rf /var/lib/apt/lists/* \
 && wget -q https://download.oracle.com/otn_software/linux/instantclient/19600/instantclient-basic-linux.x64-19.6.0.0.0dbru.zip \
 && unzip instantclient-*.zip \
 && mkdir -p $ORACLE_HOME \
 && mv instantclient_19_6 $ORACLE_HOME/lib \
 && rm -f instantclient-*.zip

cx_Oracle 8 Initialization — cx_Oracle 8.0.0 documentation

公式ドキュメントによると、cx_Oracle を利用するためには Oracle Client ライブラリがインストールされている必要があり、cx_Oracle は次の順序でライブラリの読み込みを試行する。

1. cx_Oracle.init_oracle_client(lib_dir="...") で指定したパス
2. OS のライブラリパス ($LD_LIBRARY_PATH)
3. $ORACLE_HOME/lib

このうち 1. と 3. の方法で試したときに、他のライブラリは読み込めるのに libnnz19.so だけ「そんなファイルは無い」などとエラーが出て大変困った。
原因はいまだにわからない。

2. の方法を試したところ問題なく読み込まれた。

概要

スライドパズル・15パズルの解法を試してみたいと思っています。
使用言語はpython です。
ここで遊べます（リンクあり）。

空いているマスに、数字マスを移動させる事で1,2,3,・・・と順に並べることを目的とします。

完全ランダム

20回移動して、一致していなかったらさらに移動を繰り返します。
100セットごとに現状をprintします。

座標系

クラスの関数

slide.move(direction)

操作マスをdirectionの方向に動かす
0:上
1:右
2:下
3:左

slide.shuffle(num)

num回、ランダムで移動する

結果

10分ほど回しましたが一致する事はありませんでした。

10105300times
[2, 7, 4, 1]
[3, 10, 8, 12]
[6, 5, 14, 15]
[0, 11, 9, 13]
10105400times
[0, 9, 2, 3]
[14, 1, 8, 7]
[13, 15, 11, 12]
[5, 10, 6, 4]
10105500times
[9, 10, 5, 6]
[15, 2, 13, 8]
[12, 7, 0, 1]
[4, 3, 11, 14]

実行プログラムは次のようになります。

import random
import numpy as np      #   Numpyライブラリ

class Slide():
    """
    0　が　操作マス
    左上を原点とする
    横に　ｘ
    縦に　ｙ  
    トスル

    """

    def __init__(self):
        self.puzzle = [[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12],
                  [13,14,15,0]]
        self.x = 3
        self.y = 3

    def shuffle(self,num):
        for i in range(num):
            j=0
            while True:
                j = random.randint(0,3)
                break
            self.move(j)

    def move(self,direction):
        """
           0
        3     1
           2
        """
        if direction == 0:
            if self.y != 0:
                if self.fixed[self.y-1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y-1][self.x]
                    self.y = self.y - 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 1:
            if self.x != 3:
                if self.fixed[self.y][self.x+1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x+1]
                    self.x = self.x + 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 2:
            if self.y != 3:
                if self.fixed[self.y+1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y+1][self.x]
                    self.y = self.y + 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 3:
            if self.x != 0:
                if self.fixed[self.y][self.x-1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x-1]
                    self.x = self.x - 1
                    self.puzzle[self.y][self.x] = 0

    def check(self):
        for i in range(4):
            for j in range(4):
                if self.puzzle[i][j] != j+1+i*4:
                    return -1

        return 0


if __name__ == '__main__' :
    hoge = Slide()
    hoge.shuffle(500)
    print(hoge.puzzle)

    n=0
    while True:
        hoge.shuffle(20)
        flag = hoge.check()
        if flag == 0:
            break
        n=n+1

        if n%100 == 0:
            print(str(n)+"times")
            print(hoge.puzzle[0])
            print(hoge.puzzle[1])
            print(hoge.puzzle[2])
            print(hoge.puzzle[3])

    print("find")
    print(str(n) + "times")
    print(hoge.puzzle)

一致している部分を固定しながら・ランダム

正しい位置に移動できたマスから固定する方法を使います。
ただし、

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

で、1,2,3を固定すると、4を正しい位置に移動させることができなります。

そこで、
1. 3隅(右下隅は空なので)
2. 3隅の間2マス（同時出ないとアウト）：上辺、左辺
3. 2行
4. 2列

の順に完成させます。（ランダムで回し、成立したら固定し、次に行く）
この段階で、左下4マスのみなので、6通り（確定しているかも）でここはランダムでも解けます。

結果としては、かなり良くなります。

shuffled puzzle
[11, 5, 2, 7]
[1, 6, 12, 14]
[0, 13, 9, 3]
[8, 15, 4, 10]
start analyze
3652times
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]
[13, 14, 15, 0]

3652セット（3652*20回移動）で完成できました。完全ランダムだと、10105500セットを超えても完成しないので、かなりいいと思います。
何回かやりましたが、1秒もかかりませんが、セット数はまばらです。

import random
import numpy as np      #   Numpyライブラリ

class Slide():
    """
    0　が　操作マス
    左上を原点とする
    横に　ｘ
    縦に　ｙ  
    トスル

    """

    def __init__(self):
        self.puzzle = [[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12],
                  [13,14,15,0]]
        self.x = 3
        self.y = 3

        self.fixed = np.zeros((4,4))


    def shuffle(self,num):
        for i in range(num):
            j=0
            while True:
                j = random.randint(0,3)
                break
            self.move(j)

    def move(self,direction):
        """
           0
        3     1
           2
        """
        if direction == 0:
            if self.y != 0:
                if self.fixed[self.y-1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y-1][self.x]
                    self.y = self.y - 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 1:
            if self.x != 3:
                if self.fixed[self.y][self.x+1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x+1]
                    self.x = self.x + 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 2:
            if self.y != 3:
                if self.fixed[self.y+1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y+1][self.x]
                    self.y = self.y + 1
                    self.puzzle[self.y][self.x] = 0
        if direction == 3:
            if self.x != 0:
                if self.fixed[self.y][self.x-1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x-1]
                    self.x = self.x - 1
                    self.puzzle[self.y][self.x] = 0

    def check_corner(self):
        if self.puzzle[0][0] == 1:
            if self.puzzle[0][3] == 4:
                if self.puzzle[3][0] == 13:
                    return 1
        return 0

    def check_upperside(self):
        if self.puzzle[0][1] == 2:
            if self.puzzle[0][2] == 3:
                return 1
        return 0
    def check_lowerside(self):
        if self.puzzle[1][0] == 5:
            if self.puzzle[2][0] == 9:
                return 1
        return 0
    def check_line2(self):
        if self.puzzle[1][1] == 6:
            if self.puzzle[1][2] == 7:
                if self.puzzle[1][3] == 8:
                    return 1
        return 0

    def check_row2(self):
        if self.puzzle[1][1] == 6:
            if self.puzzle[2][1] == 10:
                if self.puzzle[3][1] == 14:
                    return 1
        return 0

    def check_else(self):
        if self.puzzle[2][2] == 11:
            if self.puzzle[2][3] == 12:
                if self.puzzle[3][2] == 15:
                    return 1
        return 0




if __name__ == '__main__' :
    hoge = Slide()
    hoge.shuffle(500)
    print("shuffled puzzle")
    print(hoge.puzzle[0])
    print(hoge.puzzle[1])
    print(hoge.puzzle[2])
    print(hoge.puzzle[3])


    print("start analyze")
    n=0

    #隅
    flag = 0
    while True:
        hoge.shuffle(20)
        n=n+1
        flag = hoge.check_corner()
        if flag == 1:
            break
    hoge.fixed[0][0] = 1
    hoge.fixed[0][3] = 1
    hoge.fixed[3][0] = 1


    #上辺・左辺
    flag1 = 0
    flag2 = 0
    while True:
        hoge.shuffle(20)
        n=n+1
        if flag1 == 0:
            flag1 = hoge.check_upperside()
            if flag1 == 1:
                hoge.fixed[0][1] = 1
                hoge.fixed[0][2] = 1

        if flag2 == 0:
            flag2 = hoge.check_lowerside()
            if flag2 == 1:
                hoge.fixed[1][0] = 1
                hoge.fixed[2][0] = 1
        else:
            if flag1 == 1:
                break

    #２行・２列
    flag1 = 0
    flag2 = 0
    while True:
        hoge.shuffle(20)
        n=n+1
        if flag1 == 0:
            flag1 = hoge.check_line2()
            if flag1 == 1:
                hoge.fixed[1][1] = 1
                hoge.fixed[1][2] = 1
                hoge.fixed[1][3] = 1
        if flag2 == 0:
            flag2 = hoge.check_row2()
            if flag2 == 1:
                hoge.fixed[1][1] = 1
                hoge.fixed[2][1] = 1
                hoge.fixed[3][1] = 1
        else:
            if flag1 == 1:
                break


    #左下4マス
    flag = 0
    while True:
        hoge.shuffle(20)
        n=n+1
        flag = hoge.check_else()
        if flag == 1:
            break   



    print(str(n)+"times")
    print(hoge.puzzle[0])
    print(hoge.puzzle[1])
    print(hoge.puzzle[2])
    print(hoge.puzzle[3])

ランダムでなく、計算により目標位置に移動させる

任意の場所Aにある"数字"を任意の場所Bに移動させる手順の作成法を考えます。
Aを左に移動させるには、操作マス（0マス）をAの左に移動させ、操作マスを右に移動させればよいです。

Aや固定しているマスを動かさないように、操作マスを移動させるルートはA*アルゴリズムによって解きます。
最後に、作成したA*アルゴリズムを貼っておきます。

Astar(goal_x,goal_y,start_x,start_y,obstacle)

を与えると、最短ルートを返します。
このルートに基づき、操作マスを動かしたいマスのとなりに付け、上下左右へ動かします。
この関数によって、Aを任意の場所に動かす事ができるようになりました。

次に、どのマスから確定させていくか決めます。

1. 1
2. 2
3. 4と3 　:3を固定すると4が入らなくなるため
4. 5
5. 9と13
6. 6　　　（ここから先は、ゲーム木探索で解ける、後で実装したい）
7. 7と8
8. 10と14
9. 11と12と15 : ここは0を右下隅に移動させた場合、次の3通りしか有りません。

よって、各パターンで場合分けしてやれば完成します。

二カ所同時に埋める必要がある場所（3,4など）のアルゴリズムを示します。

例外として、4を2のとなりに置いた時点で3が右上隅に移動していた場合

入れ替え手順を考えると、次のようになります。

3を遠くに移動させてから、4-3の縦の列を作るという手順です。

以上で完全に解けるようになりました。手数としては200~50ぐらいです。固定しながらのランダムで8万ぐらい使っていたので、かなりの進歩だと思います。

以上をプログラムにすると

# -*- coding: utf-8 -*-
"""
Created on Mon Jun 29 13:35:47 2020

@author: kisim
"""

"""
スライドパズルの解法を探す

最終的には、パズドラに応用したい。そして10combo を目指す
"""
"""
Astar アルゴリズムにより、fixed をよけながら移動する
場合分けはエラーの原因で面倒のため


"""
import random
import numpy as np      #   Numpyライブラリ
import copy

import Astar as As

class Slide():
    """
    0　が　操作マス
    左上を原点とする
    横に　ｘ
    縦に　ｙ  
    トスル

    """

    def __init__(self):
        self.puzzle = [[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12],
                  [13,14,15,0]]
        self.x = 3   #操作マス　0 の場所
        self.y = 3

        self.fixed = np.zeros((4,4))
        self.route = [[self.x,self.y]]

    def route_clear(self):
        self.route = [[self.x,self.y]]

    def shuffle(self,num):
        for i in range(num):
            j=0
            while True:
                j = random.randint(0,3)
                break
            self.move(j)

    def move(self,direction):
        """
           0
        3     1
           2

        動くのに失敗したら　-1
        動いたら　　　　　　　0
        """
        if direction == 0:
            if self.y != 0:
                if self.fixed[self.y-1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y-1][self.x]
                    self.y = self.y - 1
                    self.puzzle[self.y][self.x] = 0
                    self.route.append([self.x,self.y])
                    return 0
                else:
                    return -1
        if direction == 1:
            if self.x != 3:
                if self.fixed[self.y][self.x+1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x+1]
                    self.x = self.x + 1
                    self.puzzle[self.y][self.x] = 0
                    self.route.append([self.x,self.y])
                    return 0
                else:
                    return -1
        if direction == 2:
            if self.y != 3:
                if self.fixed[self.y+1][self.x] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y+1][self.x]
                    self.y = self.y + 1
                    self.puzzle[self.y][self.x] = 0
                    self.route.append([self.x,self.y])
                    return 0
                else:
                    return -1
        if direction == 3:
            if self.x != 0:
                if self.fixed[self.y][self.x-1] == 0:
                    self.puzzle[self.y][self.x] = self.puzzle[self.y][self.x-1]
                    self.x = self.x - 1
                    self.puzzle[self.y][self.x] = 0
                    self.route.append([self.x,self.y])
                    return 0
                else:
                    return -1
        return -1


    def move_0(self,x,y):
        """
       操作マス("0"マス) を　x,y に動かす       

       先にルートを考え、fixに引っかからないとわかってから、移動を行います。
       これはある種の迷路です。
       別の関数で　迷路を解くための　A*　アルゴリズムを実装し、それを利用して解きましょう

        """

        hoge = As.Astar(x,y,self.x,self.y,self.fixed)
        result = hoge.explore()
        route = []
        if result == 0:
           route = hoge.route
        else:
            return -1


        for i in range(len(route)-1):
            if route[i][0] <  route[i+1][0]:
                self.move(1)
            elif route[i+1][0] <  route[i][0]:
                self.move(3)
            elif route[i+1][1] <  route[i][1]:
                self.move(0)
            elif route[i+1][1] >  route[i][1]:
                self.move(2)

        if self.x !=x or self.y != y:
            return -1
        else:
            return 0

    def move_any(self,position,direction):
        x=position[0]
        y=position[1]
        """
        任意の　"数"(x,y) を　direction の方向に動かす   
           0
        3     1
           2

        動くのに失敗したら　-1
        動いたら　　　　　　　0
        """
        if direction == 0:    #上に移動させる  操作マスを上に付ける
            self.fixed[y][x] = 1
            hoge = self.move_0(x,y-1)
            self.fixed[y][x] = 0
            if hoge == -1:
                return -1
            else:
                self.move_0(x,y)           
                return 0

        elif direction == 2:  # 下に移動させる
            self.fixed[y][x] = 1
            hoge = self.move_0(x,y+1)
            self.fixed[y][x] = 0
            if hoge == -1:
                return -1
            else:
                self.move_0(x,y)           
                return 0

        elif direction == 1:  # 右に移動させる
            self.fixed[y][x] = 1
            hoge = self.move_0(x+1,y)
            self.fixed[y][x] = 0
            if hoge == -1:
                return -1
            else:
                self.move_0(x,y)           
                return 0

        elif direction == 3:  # 左に移動させる
            self.fixed[y][x] = 1
            hoge = self.move_0(x-1,y)
            self.fixed[y][x] = 0
            if hoge == -1:
                return -1
            else:
                self.move_0(x,y)           
                return 0    

    def find_position(self,num):
        for i in range(4):
            for j in range(4):
                if self.puzzle[i][j] == num:
                    return (j,i)

    def move_x(self,number,position):
        target_x = position[0]
        target_y = position[1]
        """
        def move_any(self,position,direction):
        任意の　"数"(x,y) を　direction の方向に動かす   
           0
        3     1
           2

        動くのに失敗したら　-1
        動いたら　　　　　　　0
        """
        position2 = self.find_position(number)
        now_x = position2[0]
        now_y = position2[1]
        """
        Astar アルゴリズムで　number　の　ルート　見つけ
        ルートに従い、move_anyで動かし
        但し、道幅が広くないと成立しないので、move_anyが失敗する可能性がある
        －＞Astar , fixする順序で対処
        """        
        hoge = As.Astar(target_x,target_y,now_x,now_y,self.fixed)
        result = hoge.explore()
        route = []
        if result == 0:
           route = hoge.route
        else:
            return -1

        for i in range(len(route)-1):
            position2 = self.find_position(number)
            now_x = position2[0]
            now_y = position2[1]
            if route[i][0] <  route[i+1][0]:
                result = self.move_any((now_x,now_y),1)
                if result == -1:
                    return -1

            elif route[i+1][0] <  route[i][0]:
                result = self.move_any((now_x,now_y),3)
                if result == -1:
                    return -1

            elif route[i+1][1] <  route[i][1]:
                result = self.move_any((now_x,now_y),0)
                if result == -1:
                    return -1

            elif route[i+1][1] >  route[i][1]:
                result = self.move_any((now_x,now_y),2)
                if result == -1:
                    return -1

        position2 = self.find_position(number)
        now_x = position2[0]
        now_y = position2[1]
        if target_x != now_x or target_y != now_y:
            return -1
        else:
            return 0
    def exchange_row(self):
        """
        4 3
        x 0
        y z
        で入れ替える
        """
        self.move(0)
        self.move(3)
        """
        0 4
        x 3
        y z       
        """
        self.move(2)
        self.move(2)
        self.move(1)
        """
        x 4
        y 3
        z 0        
        """
        self.move(0)
        """
        x 4
        y 0
        z 3       
        """
        self.move(3)
        self.move(0)
        self.move(1)
        """
        4 0
        x y
        z 3       
        """

    def exchange_line(self):
        """
        13 0 y
        9  x z
        """
        self.move(3)
        self.move(2)
        """
        9 13 y
        0  x z
        """
        self.move(1)
        self.move(1)
        self.move(0)
        """
        9 13 0
        x y z
        """
        self.move(3)
        """
        9 0 13
        x y z
        """
        self.move(2)
        self.move(3)
        self.move(0)
        """
        0 y 13
        9 x z
        """

def route_test(slide,route):
    if route == []:
        return -1
    else:
        for i in range(len(route)-1):
            if route[i][0] <  route[i+1][0]:
                slide.move(1)
            elif route[i+1][0] <  route[i][0]:
                slide.move(3)
            elif route[i+1][1] <  route[i][1]:
                slide.move(0)
            elif route[i+1][1] >  route[i][1]:
                slide.move(2)

    return slide




if __name__ == '__main__' :
    hoge = Slide()
    hoge.shuffle(600)
    hoge.route_clear()
    print(hoge.puzzle[0])
    print(hoge.puzzle[1])
    print(hoge.puzzle[2])
    print(hoge.puzzle[3])

    #test用
    hoge2 = Slide()
    hoge2.puzzle = copy.deepcopy(hoge.puzzle)
    hoge2.x = hoge.x
    hoge2.y = hoge.y


    #1
    hoge.move_x(1,(0,0))
    hoge.fixed[0][0] =1
    #2
    hoge.move_x(2,(1,0))
    hoge.fixed[0][1] =1
    #3,4
    hoge.move_x(4,(2,0))
    hoge.fixed[0][2] =1

    if hoge.x == 3 and hoge.y == 0 and hoge.puzzle[1][3] == 3:
        hoge.move(2)
    if hoge.puzzle[0][3] == 3:
        hoge.fixed[0][2] = 0
        hoge.move_0(3,1)
        hoge.exchange_row()
        print("errored 3-4")

    hoge.move_x(3,(2,1))
    hoge.fixed[1][2] = 1
    hoge.move_0(3,0)
    hoge.fixed[1][2] = 0
    hoge.fixed[0][2] = 0
    hoge.move(3)
    hoge.move(2)

    hoge.fixed[0][2] = 1
    hoge.fixed[0][3] = 1


    #5
    hoge.move_x(5,(0,1))
    hoge.fixed[1][0] =1
    #9,13
    hoge.move_x(9,(0,3))
    hoge.fixed[3][0] =1

    if hoge.x == 0 and hoge.y == 2 and hoge.puzzle[2][1] == 13:
        hoge.move(1)
    if hoge.puzzle[2][0] == 13:
        hoge.fixed[3][0] = 0
        hoge.move_0(1,2)
        hoge.exchange_line()
        print("error 9-13")
        hoge.fixed[3][0] = 1

    hoge.move_x(13,(1,3))
    hoge.fixed[3][1] = 1
    hoge.move_0(0,2)
    hoge.fixed[3][1] = 0
    hoge.fixed[3][0] = 0
    hoge.move(2)
    hoge.move(1)

    hoge.fixed[2][0] = 1
    hoge.fixed[3][0] = 1

    #6
    hoge.move_x(6,(1,1))
    hoge.fixed[1][1] =1

    #7,8
    hoge.move_x(8,(2,1))
    hoge.fixed[1][2] =1
    if hoge.x == 3 and hoge.y == 1 and hoge.puzzle[2][3] == 7:
        hoge.move(2)
    if hoge.puzzle[1][3] == 7:
        hoge.fixed[1][2] = 0
        hoge.move_0(3,2)
        hoge.exchange_row()
        print("error 7-8")

    hoge.move_x(7,(2,2))
    hoge.fixed[2][2] = 1
    hoge.move_0(3,1)
    hoge.fixed[2][2] = 0
    hoge.fixed[1][2] = 0
    hoge.move(3)
    hoge.move(2)

    hoge.fixed[1][3] = 1
    hoge.fixed[1][2] = 1

    #6マスなので　もう　ゲーム木探索でも解けるのでは？
    #10,14
    result = hoge.move_x(10,(1,3))
    print(str(result)+"result")

    hoge.fixed[3][1] =1
    if hoge.x == 1 and hoge.y == 2 and hoge.puzzle[2][2] == 14:
        hoge.move(1)
    if hoge.puzzle[2][1] == 14:
        hoge.fixed[3][1] = 0
        hoge.move_0(2,2)
        hoge.exchange_line()
        print("error10-14")
        hoge.fixed[3][1] = 1


    hoge.move_x(14,(2,3))
    hoge.fixed[3][2] = 1
    hoge.move_0(1,2)
    hoge.fixed[3][2] = 0
    hoge.fixed[3][1] = 0
    hoge.move(2)
    hoge.move(1)

    hoge.fixed[2][1] = 1
    hoge.fixed[3][1] = 1


    # これで行けるかと思ったが　、ちょっと違った
    hoge.move_0(3,3)

    print("a")
    print(hoge.puzzle[0])
    print(hoge.puzzle[1])
    print(hoge.puzzle[2])
    print(hoge.puzzle[3])
    print(hoge.fixed[0])
    print(hoge.fixed[1])
    print(hoge.fixed[2])
    print(hoge.fixed[3])

    if hoge.puzzle[3][2] == 11:
        #反時計回り一周
        hoge.move(0)
        hoge.move(3)
        hoge.move(2)
        hoge.move(1)
    elif hoge.puzzle[3][2] == 12:
        #時計回り一周
        hoge.move(3)
        hoge.move(0)
        hoge.move(1)
        hoge.move(2)

    print(hoge.puzzle[0])
    print(hoge.puzzle[1])
    print(hoge.puzzle[2])
    print(hoge.puzzle[3])


    print(len(hoge.route))

    hoge2 = route_test(hoge2,hoge.route)
    if hoge2 == -1:
        print("error")
    else:
        print(hoge2.puzzle[0])
        print(hoge2.puzzle[1])
        print(hoge2.puzzle[2])
        print(hoge2.puzzle[3])

A*アルゴリズム

Aster.py

import numpy as np      #   Numpyライブラリ
import random
import copy

class Node():
    def __init__(self,x,y,cost,parent,num):
        self.x = x
        self.y = y
        self.state = 1   # 0:none 1:open 2:closed
        self.score = 0
        self.cost = cost
        self.parent = parent
        self.expect_cost =  0
        self.num = num
        self.calculated = 0


    def close(self):
        self.state = 2




class Astar():
    def __init__(self,g_x,g_y,s_x,s_y,obstacle):
        self.width = obstacle.shape[1]
        self.height = obstacle.shape[0]
        self.g_x = g_x
        self.g_y = g_y
        self.s_x = s_x
        self.s_y = s_y
        self.x = s_x
        self.y = s_y
        self.obstacle_list = copy.deepcopy(obstacle)
        self.maked_list = []
        self.num = 0

        start = Node(s_x,s_y,0,-1,self.num)
        self.Node_list = [start]
        self.num = self.num + 1
        self.now = start           #現在のノード
        self.route = []
        self.goal = -1            #gaal の　ノード
        self.finished = 0         #goal したかどうか

        if g_x == s_x and g_y == s_y:
            self.finished == 1
            self.goal = start
            self.route = [[s_x,s_y]]


    def open(self):
        self.now.close()
        #周りをopen
        """
        壁・障害　が有るときはopen できない　－＞obstacle_list
        既に作っていないか？－＞maked_list 
        """
        cost = self.now.cost
        parent = self.now.num
        if self.x!=0:
            if self.maked_list.count([self.x-1,self.y]) == 0 and  self.obstacle_list[self.y][self.x-1] == 0 :
                 self.Node_list.append(Node(self.x-1,self.y,cost+1,parent,self.num))
                 self.num = self.num + 1
                 self.maked_list.append([self.x-1,self.y])
        if self.x!=self.width-1:
            if self.maked_list.count([self.x+1,self.y]) == 0 and  self.obstacle_list[self.y][self.x+1] == 0 :
                 self.Node_list.append(Node(self.x+1,self.y,cost+1,parent,self.num))
                 self.num = self.num + 1
                 self.maked_list.append([self.x+1,self.y])
        if self.y!=0:
            if self.maked_list.count([self.x,self.y-1]) == 0 and  self.obstacle_list[self.y-1][self.x] == 0 :
                 self.Node_list.append(Node(self.x,self.y-1,cost+1,parent,self.num))
                 self.num = self.num + 1
                 self.maked_list.append([self.x,self.y-1])
        if self.y!=self.height-1:
            if self.maked_list.count([self.x,self.y+1]) == 0 and  self.obstacle_list[self.y+1][self.x] == 0 :
                 self.Node_list.append(Node(self.x,self.y+1,cost+1,parent,self.num))
                 self.num = self.num + 1
                 self.maked_list.append([self.x,self.y+1])

        """
        #デバッグ
        print("test")
        for i in self.Node_list:
            print(i.state)
        """ 

        #open しているものを計算
        for i in self.Node_list:
            if i.state == 1 and i.calculated == 0:
                i.calculated = 1
                i.expect_cost = abs(i.x - self.g_x)+abs(i.y-self.g_y)
                i.score = i.cost + i.expect_cost

        #open しているもののうち、スコアの小さいものをリストにまとめる
        min_cost  = 100
        min_cost_list = []
        for i in self.Node_list:
            if i.state == 1:
                if i.cost < min_cost:
                    min_cost = i.cost
                    min_cost_list = [i]
                elif i.cost == min_cost:
                    min_cost_list.append(i)

        if min_cost_list != []:
            self.now = min_cost_list[random.randint(0,len(min_cost_list)-1)]
            self.x = self.now.x
            self.y = self.now.y
        else:
            print("none min")
            return -1

        if self.now.x == self.g_x and self.now.y == self.g_y:
            return 1
        else:
            return 0



    def explore(self):
        """
        0 :goal
        -1:goal できない
        """
        if self.finished == 1:
            return 0
        else:
            while True:
                hoge = self.open()
                if hoge == 1:
                    #print("goal!")
                    self.goal = self.now
                    self.finished = 1
                    self.Route()
                    return 0
                elif hoge == -1:
                    return -1


    def Route(self):
        if self.finished == 1:
            while True:
                self.route.append((self.now.x,self.now.y))
                if self.now.parent == -1:
                    break
                else:
                    self.now = self.Node_list[self.now.parent]

            self.route.reverse()
            #print(self.route)

    def Express(self):
        if self.finished == 1:
            if self.route ==[]:
                print("not goaled")
            else:
                graph    =  self.obstacle_list
                for i in self.route:
                    graph[i[1]][i[0]] = 2

                print(graph)




if __name__ == '__main__' :
    width = 5
    height = 5
    obstacle    =np.zeros((height,width))
    """
    obstacle[2][1] = 1
    obstacle[2][2] = 1
    obstacle[1][2] = 1
    obstacle[3][2] = 1
    """
    obstacle[1][0] = 1
    print(obstacle)
    g_x = 0
    g_y = 2
    s_x = 0
    s_y = 0

    hoge = Astar(g_x,g_y,s_x,s_y,obstacle)  
    result = hoge.explore()
    if result == 0:
        hoge.Express()