概要

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

その対策としてLeetCodeなるサイトで対策を行うようだ。

早い話が本場でも行われているようなコーディングテストに耐えうるようなアルゴリズム力を鍛えるサイト。

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

Leetcode

ゼロから始めるLeetCode 目次

前回
ゼロから始めるLeetCode Day37「105. Construct Binary Tree from Preorder and Inorder Traversal」

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

Twitterやってます。

問題

208. Implement Trie (Prefix Tree)
難易度はMedium。
Top 100 Liked Questionsからの抜粋です。

問題としては、insert関数、search関数、startsWith関数をTrieというクラスにまとめて実装してください、というものです。

なお、それぞれの挙動としては、

Trie trie = new Trie();

trie.insert("apple");
trie.search("apple"); // returns true
trie.search("app"); // returns false
trie.startsWith("app"); // returns true
trie.insert("app");

trie.search("app"); // returns true

このようになります。

解法

基本的に全ての引数を一度for文でチェックし、元々保持しているelementの中に存在しない場合はFalseを返すか、{}を代入するというものです。

class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.element = {}


    def insert(self, word: str) -> None:
        """
        Inserts a word into the trie.
        """
        inserted = self.element
        for tmp in word:
            if tmp not in inserted:
                inserted[tmp] = {}
            inserted = inserted[tmp]
        inserted["-"] = True


    def search(self, word: str) -> bool:
        """
        Returns if the word is in the trie.
        """

        searched = self.element
        for tmp in word:
            if tmp not in searched:
                return False
            searched = searched[tmp]
        return "-" in searched


    def startsWith(self, prefix: str) -> bool:
        """
        Returns if there is any word in the trie that starts with the given prefix.
        """
        started = self.element
        for tmp in prefix:
            if tmp not in started:
                return False
            started = started[tmp]
        return True



# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

# Runtime: 128 ms, faster than 94.63% of Python3 online submissions for Implement Trie (Prefix Tree).
# Memory Usage: 27.3 MB, less than 66.67% of Python3 online submissions for Implement Trie (Prefix Tree).

思ったよりスピードがでて良い感じに実装できました。

なお、discussをみる限り、他にメジャーな解答だったのは、

from collections import defaultdict


class TrieNode(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.nodes = defaultdict(TrieNode)  # Easy to insert new node.
        self.isword = False  # True for the end of the trie.


class Trie(object):
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        """
        Inserts a word into the trie.
        :type word: str
        :rtype: void
        """
        curr = self.root
        for char in word:
            curr = curr.nodes[char]
        curr.isword = True

    def search(self, word):
        """
        Returns if the word is in the trie.
        :type word: str
        :rtype: bool
        """
        curr = self.root
        for char in word:
            if char not in curr.nodes:
                return False
            curr = curr.nodes[char]
        return curr.isword

    def startsWith(self, prefix):
        """
        Returns if there is any word in the trie
        that starts with the given prefix.
        :type prefix: str
        :rtype: bool
        """
        curr = self.root
        for char in prefix:
            if char not in curr.nodes:
                return False
            curr = curr.nodes[char]
        return True
# Runtime: 192 ms, faster than 57.66% of Python3 online submissions for Implement Trie (Prefix Tree).
# Memory Usage: 32.5 MB, less than 7.41% of Python3 online submissions for Implement Trie (Prefix Tree).

こういったものでした。
TrieNodeというクラスを別に作り、defaultdictというものを使っていますね。
ただ、今回に関していえば前者の回答の方が分かりやすく、そして速いと思うのでそちらの方が良いのかなとは思います。

今回はこんな感じです、お疲れ様でした。

結論

replaceメソッドを使うと楽チン。

from datetime import datetime
from dateutil.relativedelta import relativedelta

today = datetime.now().date()
print(today)
# => 2020-05-27

last_month_start = (today - relativedelta(months=1)).replace(day=1)
print(last_month_start)
# => 2020-04-01

last_month_end = today.replace(day=1) - relativedelta(days=1)
print(last_month_end)
# => 2020-04-30

変数名がアレなのは見逃してください。

参考

https://www.lifewithpython.com/2018/06/python-get-first-and-last-day-of-month.html

目的

分析コンペの効率化のための、可視化ツールのいろいろまとめ。

1.相関マップ

pandasデータフレームの各列の相関をヒートマップ表示。
各特徴量の相関、モデルのアンサンブル用の予測結果の相関に使用する。

参考

－

コード

fig ,ax = plt.subplots(1,1,figsize=(12,12))
sns.heatmap(df.corr(), annot=True, fmt='.7f', ax=ax)
df.corr()

2.混同行列(Confusion Matrix)

参考

－

コード

import numpy as np
import pandas as pd
from scipy import signal
from sklearn.metrics import confusion_matrix, f1_score, plot_confusion_matrix

# Thanks to https://www.kaggle.com/marcovasquez/basic-nlp-with-tensorflow-and-wordcloud
def plot_cm(y_true, y_pred, title="", figsize=(14,14):
    y_pred = y_pred.astype(int)
    cm = confusion_matrix(y_true, y_pred, labels=np.unique(y_true))
    cm_sum = np.sum(cm, axis=1, keepdims=True)
    cm_perc = cm / cm_sum.astype(float) * 100
    annot = np.empty_like(cm).astype(str)
    nrows, ncols = cm.shape
    for i in range(nrows):
        for j in range(ncols):
            c = cm[i, j]
            p = cm_perc[i, j]
            if i == j:
                s = cm_sum[i]
                annot[i, j] = '%.1f%%\n%d/%d' % (p, c, s)
            elif c == 0:
                annot[i, j] = ''
            else:
                annot[i, j] = '%.1f%%\n%d' % (p, c)
    cm = pd.DataFrame(cm, index=np.unique(y_true), columns=np.unique(y_true))
    cm.index.name = 'Actual'
    cm.columns.name = 'Predicted'
    fig, ax = plt.subplots(figsize=figsize)
    plt.title(title)
    sns.heatmap(cm, cmap='viridis', annot=annot, fmt='', ax=ax)

目的

分析コンペの効率化のための、可視化ツールのいろいろまとめ。
少しずつ、増やしていく！

1.相関マップ

pandasデータフレームの各列の相関をヒートマップ表示。
各特徴量の相関、モデルのアンサンブル用の予測結果の相関に使用する。

参考

－

コード

fig ,ax = plt.subplots(1,1,figsize=(12,12))
sns.heatmap(df.corr(), annot=True, fmt='.7f', ax=ax)
df.corr()

2.混同行列(Confusion Matrix)

参考

－

コード

import numpy as np
import pandas as pd
from scipy import signal
from sklearn.metrics import confusion_matrix, f1_score, plot_confusion_matrix

# Thanks to https://www.kaggle.com/marcovasquez/basic-nlp-with-tensorflow-and-wordcloud
def plot_cm(y_true, y_pred, title="", figsize=(14,14):
    y_pred = y_pred.astype(int)
    cm = confusion_matrix(y_true, y_pred, labels=np.unique(y_true))
    cm_sum = np.sum(cm, axis=1, keepdims=True)
    cm_perc = cm / cm_sum.astype(float) * 100
    annot = np.empty_like(cm).astype(str)
    nrows, ncols = cm.shape
    for i in range(nrows):
        for j in range(ncols):
            c = cm[i, j]
            p = cm_perc[i, j]
            if i == j:
                s = cm_sum[i]
                annot[i, j] = '%.1f%%\n%d/%d' % (p, c, s)
            elif c == 0:
                annot[i, j] = ''
            else:
                annot[i, j] = '%.1f%%\n%d' % (p, c)
    cm = pd.DataFrame(cm, index=np.unique(y_true), columns=np.unique(y_true))
    cm.index.name = 'Actual'
    cm.columns.name = 'Predicted'
    fig, ax = plt.subplots(figsize=figsize)
    plt.title(title)
    sns.heatmap(cm, cmap='viridis', annot=annot, fmt='', ax=ax)

最近 AtCoder で競プロを始めました
始めたのはいいのですが、パッとは解けないので何度も何度もデバッグ地獄です
そのたびターミナルにテストケースをコピペの嵐...
もうそんなことはやめよう

この記事は
windows10 1909
VSCode 1.45.1
Python 3.8.2
で確認した内容となっています。

1. デバッグには sys.stdin を使おう

まずは標準入力の簡易化です。

「VSCode python 標準入力」などの条件で検索していると、teratail にこんな質問と回答がありました
VS Codeで標準入力を受け取る方法(Windows10・Python)
競プロ界隈では有名なのかわかりませんが、私が探していたのはまさにこれでした。

import io
import sys

_INPUT = """\
2
1 2 3
aaa
"""
sys.stdin = io.StringIO(_INPUT)

print(int(input()))
print(list(map(int, input().split())))
print(list(input()))

# 出力
2
[1, 2, 3]
['a', 'a', 'a']

Python ドキュメントによると sys.stdin は (input() の呼び出しも含む) すべての対話型入力に使われるもので、io.StringIO は、要するにファイルのように文字列を読み書きするクラスのようです。

テンプレート

test_inut.py

import io
import sys

# input here
_INPUT = """\

"""
sys.stdin = io.StringIO(_INPUT)

# your code here

サンプルケースや自分で考えたテストケースとデバッグしたいコードを入れてください。

なにより別ファイル（ input.txt など）に書いておくのと違い、テストケースがパッと見えるのもいいですよね。
これでコピペの嵐に悩まされることはなくなりました

2. online-judge-tools を使ってみよう

サンプルケースの判定を自動化するツールがあります！！それは
online-judge-tools
です。

online-judge-tools はコンテストサイトからサンプルケースをスクレイピングし、判定を自動化してくれるありがたいツールです。

OS には Linux か Mac OS を推奨しますが、 Windows 上でも動作します。

と書かれている通り、私の環境では何の問題もなく動作しています。

使い方

使い方に関しては、GitHub ページの他、
Visual Studio Codeで競プロ環境構築(実践編)
AtCoderで自動サンプルテストケース&手入力値テスト実行 with VS Code
を参考にさせていただきました。

フォルダ構成

AtCoder\
├── .venv\
│
├── .vscode\
│   └── tasks.json
│
├── sctipt\
│   └── cptest.ps1
│
├── src\
│   └── abc000_0.py
│
└── test\
    └── abc000_0\
        ├── sample-1.in
        └── sample-1.out

.venv フォルダは仮想環境を構築した際の名前と読み替えてください。なくても構いません。.vscode フォルダは tasks.json を生成した際自動的に作成されます。script フォルダと src フォルダは絶対必要というわけではありません。test フォルダは cptest.ps1を実行した際に自動的に作成されます。

1. インストール

> pip install online-judge-tools

pip で簡単にインストールできます。

2. ログイン

ユーザー名とパスワードを入力します。

> oj login -u ユーザー名 -p パスワード "https://atcoder.jp/"

ログインできたか確認するには

> oj login --check "https://atcoder.jp/"

[*] You have already signed in.

と返ってくれば OK です。

3. cptest.ps1

コンテストサイトからサンプルケースを取得し、テストするスクリプトです。

以下は参考にさせていただいたスクリプトを.ps1にし、変更を加えたものです。

cptest.ps1

. ".venv/Scripts/Activate.ps1"

$problem_name = $Args[0]
$problem_name_list = ($problem_name -split "_")
$base_url = if ($problem_name_list.Length -eq 2) {
    $problem_name_list[0]
}
else {
    [string]::Join("-", $problem_name_list[0..-2])
}


if (! (Test-Path $test_dir)) {
    oj dl -d test/$problem_name/ https://atcoder.jp/contests/$base_url/tasks/$problem_name
}

oj test -c "python src/$problem_name.py" -d test/$problem_name/

私は AtCoder フォルダ内の仮想環境に online-judge-tools をインストールしたため、1行目で.venv/Scripts/Activate.ps1を読み込み、仮想環境を activate しています。仮想環境でない方は必要ありません。

また、第二回全国統一プログラミング王決定戦予選 A - Sum of Two Integers などのURLは
https://atcoder.jp/contests/nikkei2019-2-qual/tasks/nikkei2019_2_qual_a
$base_urlにハイフン、$problem_nameにアンダーバーが使われているため、_を-に変える処理を追加しています。

4. tasks.json

VSCode のタスクは、様々な作業を自動化する機能で、Ctrl+Shift+Bで実行することができます。
そこで、cptest.ps1を実行できるようにしましょう。

Ctrl+Shift+Pでコマンドパレットを開き、taskと入力すると、多くのコマンドが表示されます。その中から、「タスクの構成」→「テンプレートから tasks.json を生成」→「 Others 」と選んでいくと、tasks.json が生成されます。

tasks.json

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "test_atcorder_sample",
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "type": "shell",
            "command": "${workspaceFolder}/script/cptest.ps1",
            "args": [
                "${fileBasenameNoExtension}"
            ]
        }
    ]
}

これで、ファイル名がabc060_b.pyならばCtrl+Shift+Bで

> cptest.ps1 abc060_b

を実行したことになります。

使い方は以上です。このツールはほかにも、提出やストレステストも行えるそうです。サンプルケースのテストを自動化できるだけでもありがたいのにどれだけですか
私はまだまだ使いこなせていないのでこれから頑張ります。

さいごに

本当にデバッグが楽になりました。この記事がほかの競プロ初心者を少しでも助けることができれば幸いです。
みなさま良き競プロライフを

はじめに

自然言語処理の問題集として有名な言語処理100本ノックの2020年版が公開されました。
この記事では、以下の第1章から第10章のうち、第5章: 係り受け解析を解いてみた結果をまとめています。

• 第1章: 準備運動
• 第2章: UNIXコマンド
• 第3章: 正規表現
• 第4章: 形態素解析
• 第5章: 係り受け解析
• 第6章: 機械学習
• 第7章: 単語ベクトル
• 第8章: ニューラルネット
• 第9章: RNN, CNN
• 第10章: 機械翻訳

事前準備

回答にはGoogle Colaboratoryを利用しています。
Google Colaboratoryのセットアップ方法や基本的な使い方は、こちらの記事が詳しいです。
なお、以降の回答の実行結果を含むノートブックはgithubにて公開しています。

第5章: 係り受け解析

夏目漱石の小説『吾輩は猫である』の文章（neko.txt）をCaboChaを使って係り受け解析し，その結果をneko.txt.cabochaというファイルに保存せよ．このファイルを用いて，以下の問に対応するプログラムを実装せよ．

まずは指定のデータをダウンロードします。
Google Colaboratoryのセル上で下記のコマンドを実行すると、カレントディレクトリに対象のファイルがダウンロードされます。

!wget https://nlp100.github.io/data/neko.txt

続いて、CaboChaおよびCaboChaの実行に必要なMeCabとCRF++をインストールします。

# MeCabのインストール
!apt install mecab libmecab-dev mecab-ipadic-utf8

# CRF++のソースファイルのダウンロード・解凍・インストール
FILE_ID = "0B4y35FiV1wh7QVR6VXJ5dWExSTQ"
FILE_NAME = "crfpp.tar.gz"
!wget 'https://docs.google.com/uc?export=download&id=$FILE_ID' -O $FILE_NAME
!tar xvf crfpp.tar.gz
%cd CRF++-0.58
!./configure && make && make install && ldconfig
%cd ..

# CaboChaのソースファイルのダウンロード・解凍・インストール
FILE_ID = "0B4y35FiV1wh7SDd1Q1dUQkZQaUU"
FILE_NAME = "cabocha-0.69.tar.bz2"
!wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=$FILE_ID' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=$FILE_ID" -O $FILE_NAME && rm -rf /tmp/cookies.txt
!tar -xvf cabocha-0.69.tar.bz2
%cd cabocha-0.69
!./configure -with-charset=utf-8 && make && make check && make install && ldconfig
%cd ..

インストールが完了したら、早速係り受け解析を行います。
以下のコマンドを実行することにより、neko.txtを係り受け解析した結果が、neko.txt.cabocbaとして出力されます。

!cabocha -f1 -o neko.txt.cabocha neko.txt

CaboCha (公式)

40. 係り受け解析結果の読み込み（形態素）

形態素を表すクラスMorphを実装せよ．このクラスは表層形（surface），基本形（base），品詞（pos），品詞細分類1（pos1）をメンバ変数に持つこととする．さらに，CaboChaの解析結果（neko.txt.cabocha）を読み込み，各文をMorphオブジェクトのリストとして表現し，3文目の形態素列を表示せよ．

class Morph:
  def __init__(self, morph):
    (surface, attr) = morph.split('\t')
    attr = attr.split(',')
    self.surface = surface
    self.base = attr[6]
    self.pos = attr[0]
    self.pos1 = attr[1]

filename = './neko.txt.cabocha'

# 文単位に分割して読込
with open(filename, mode='r', encoding='utf-8') as f:
  text = f.read().split('EOS\n')

# 指定フォーマットに整形
sentences = []
for sentence in text:
  morphs = []
  for line in sentence.split('\n'):
    if line == '' or line[0] == '*':  # 文末または係り受け関係を表す行 --> スキップ
      continue
    else:  # 形態素を表す行 --> Morphを適用しリストに追加
      morphs.append(Morph(line))
  sentences.append(morphs)

# 確認
for m in sentences[2]:
  print(vars(m))

出力

{'surface': '\u3000', 'base': '\u3000', 'pos': '記号', 'pos1': '空白'}
{'surface': '吾輩', 'base': '吾輩', 'pos': '名詞', 'pos1': '代名詞'}
{'surface': 'は', 'base': 'は', 'pos': '助詞', 'pos1': '係助詞'}
{'surface': '猫', 'base': '猫', 'pos': '名詞', 'pos1': '一般'}
{'surface': 'で', 'base': 'だ', 'pos': '助動詞', 'pos1': '*'}
{'surface': 'ある', 'base': 'ある', 'pos': '助動詞', 'pos1': '*'}
{'surface': '。', 'base': '。', 'pos': '記号', 'pos1': '句点'}

41. 係り受け解析結果の読み込み（文節・係り受け）

40に加えて，文節を表すクラスChunkを実装せよ．このクラスは形態素（Morphオブジェクト）のリスト（morphs），係り先文節インデックス番号（dst），係り元文節インデックス番号のリスト（srcs）をメンバ変数に持つこととする．さらに，入力テキストのCaboChaの解析結果を読み込み，１文をChunkオブジェクトのリストとして表現し，8文目の文節の文字列と係り先を表示せよ．第5章の残りの問題では，ここで作ったプログラムを活用せよ．

文章は文(sentence)オブジェクトのリストで表され、文オブジェクトは文節(chunk)オブジェクトのリストを要素に持ち、文節オブジェクトは形態素(morph)オブジェクトのリストを要素に持つ階層構造を考え、ここでは指定のクラスChunkに加え、Sentenceを実装しています。
なお、Chunkオブジェクトの要素である係り元文節インデックス番号のリスト(srcs)の作成には1文のすべての文節情報を必要とするため、Sentenceオブジェクトの初期化時に作成しています。

class Chunk():
  def __init__(self, morphs, dst):
    self.morphs = morphs
    self.dst = dst
    self.srcs = []


class Sentence():
  def __init__(self, chunks):
    self.chunks = chunks
    for i, chunk in enumerate(self.chunks):
      if chunk.dst != -1:
        self.chunks[chunk.dst].srcs.append(i)

filename = './neko.txt.cabocha'

# 文単位に分割して読込
with open(filename, mode='r', encoding='utf-8') as f:
  text = f.read().split('EOS\n')

# 指定フォーマットに整形
sentences = []
for sentence in text:
  if sentence == '':  # 空の文 --> 以下の処理を省略して空のSentenceオブジェクトをsentencesリストに追加
    sentences.append(Sentence([]))
  else:
    chunks = []
    morphs = []
    dst = None
    for line in sentence.split('\n'):
      if line == '':  # 文末を表す行 --> 文末直前の文節の情報にChunkを適用しchunksリストに追加
        chunks.append(Chunk(morphs, dst))
      elif line[0] == '*':  # 係り受け関係を表す行 --> 直前の文節の情報にChunkを適用しchunksリストに追加 + 直後の文節の係り先を取得
        if len(morphs) > 0:
          chunks.append(Chunk(morphs, dst))
          morphs = []
        dst = int(line.split(' ')[2].rstrip('D'))
      else:  # 形態素を表す行 --> Morphを適用しmorphsリストに追加
        morphs.append(Morph(line))
    sentences.append(Sentence(chunks))  # Sentenceを適用しsentencesリストに追加

# 確認
for chunk in sentences[7].chunks:
  print([morph.surface for morph in chunk.morphs], chunk.dst, chunk.srcs)

出力

['吾輩', 'は'] 5 []
['ここ', 'で'] 2 []
['始め', 'て'] 3 [1]
['人間', 'という'] 4 [2]
['もの', 'を'] 5 [3]
['見', 'た', '。'] -1 [0, 4]

42. 係り元と係り先の文節の表示

係り元の文節と係り先の文節のテキストをタブ区切り形式ですべて抽出せよ．ただし，句読点などの記号は出力しないようにせよ．

以降、特に指示がない限り、41と同様に8文目の文で出力を確認しています。

sentence = sentences[7]
for chunk in sentence.chunks:
  if int(chunk.dst) != -1:
    modifier = ''.join([morph.surface if morph.pos != '記号' else '' for morph in chunk.morphs])
    modifiee = ''.join([morph.surface if morph.pos != '記号' else '' for morph in sentence.chunks[int(chunk.dst)].morphs])
    print(modifier, modifiee, sep='\t')

出力

吾輩は   見た
ここで   始めて
始めて   人間という
人間という ものを
ものを   見た

43. 名詞を含む文節が動詞を含む文節に係るものを抽出

名詞を含む文節が，動詞を含む文節に係るとき，これらをタブ区切り形式で抽出せよ．ただし，句読点などの記号は出力しないようにせよ．

sentence = sentences[7]
for chunk in sentence.chunks:
  if int(chunk.dst) != -1:
    modifier = ''.join([morph.surface if morph.pos != '記号' else '' for morph in chunk.morphs])
    modifier_pos = [morph.pos for morph in chunk.morphs]
    modifiee = ''.join([morph.surface if morph.pos != '記号' else '' for morph in sentence.chunks[int(chunk.dst)].morphs])
    modifiee_pos = [morph.pos for morph in sentence.chunks[int(chunk.dst)].morphs]
    if '名詞' in modifier_pos and '動詞' in modifiee_pos:
      print(modifier, modifiee, sep='\t')

出力

吾輩は   見た
ここで   始めて
ものを   見た

44. 係り受け木の可視化

与えられた文の係り受け木を有向グラフとして可視化せよ．可視化には，係り受け木をDOT言語に変換し，Graphvizを用いるとよい．また，Pythonから有向グラフを直接的に可視化するには，pydotを使うとよい．

係り元と係り先の文節のペアを作成し、pydotのgraph_from_edgesに渡すことで、グラフを作成しています。
なお、表層形そのままでは1文内に同じ文字列の文節が複数回出てきた場合に区別できないため、末尾にIDを付与して表示しています。

# 日本語表示用フォントのインストール
!apt install fonts-ipafont-gothic

import pydot
from IPython.display import Image,display_png
from graphviz import Digraph

sentence = sentences[7]
edges = []
for id, chunk in enumerate(sentence.chunks):
  if int(chunk.dst) != -1:
    modifier = ''.join([morph.surface if morph.pos != '記号' else '' for morph in chunk.morphs] + ['(' + str(id) + ')'])
    modifiee = ''.join([morph.surface if morph.pos != '記号' else '' for morph in sentence.chunks[int(chunk.dst)].morphs] + ['(' + str(chunk.dst) + ')'])
    edges.append([modifier, modifiee])
n = pydot.Node('node')
n.fontname = 'IPAGothic'
g = pydot.graph_from_edges(edges, directed=True)
g.add_node(n)
g.write_png('./ans44.png')
display_png(Image('./ans44.png'))

45. 動詞の格パターンの抽出

今回用いている文章をコーパスと見なし，日本語の述語が取りうる格を調査したい． 動詞を述語，動詞に係っている文節の助詞を格と考え，述語と格をタブ区切り形式で出力せよ． ただし，出力は以下の仕様を満たすようにせよ．

• 動詞を含む文節において，最左の動詞の基本形を述語とする
• 述語に係る助詞を格とする
• 述語に係る助詞（文節）が複数あるときは，すべての助詞をスペース区切りで辞書順に並べる
  

このプログラムの出力をファイルに保存し，以下の事項をUNIXコマンドを用いて確認せよ．

• コーパス中で頻出する述語と格パターンの組み合わせ
• 「する」「見る」「与える」という動詞の格パターン（コーパス中で出現頻度の高い順に並べよ）

with open('./ans45.txt', 'w') as f:
  for sentence in sentences:
    for chunk in sentence.chunks:
      for morph in chunk.morphs:
        if morph.pos == '動詞':  # chunkの左から順番に動詞を探す
          cases = []
          for src in chunk.srcs:  # 見つけた動詞の係り元chunkから助詞を探す
            cases = cases + [morph.surface for morph in sentence.chunks[src].morphs if morph.pos == '助詞']
          if len(cases) > 0:  # 助詞が見つかった場合は辞書順にソートして出力
            cases.sort()  
            line = '{}\t{}'.format(morph.base, ' '.join(cases))
            print(line, file=f)
          break

# 確認
!cat ./ans45.txt | sort | uniq -c | sort -nr | head -n 10

出力

   2414 ある  が
   1395 つく  か が
    676 云う  に
    608 する  が で と
    330 つかむ   を
    319 見る  の
    270 思う  と
    260 云う  と は
    238 かかる   が て
    237 かく  たり を

!cat ./ans45.txt | grep 'する' | sort | uniq -c | sort -nr | head -n 5

出力

   1128 する  が
    729 する  が と
    311 する  が で と
    130 する  と は は は
    126 する  でも に

!cat ./ans45.txt | grep '見る' | sort | uniq -c | sort -nr | head -n 5

出力

    319 見る  の
    113 見る  は を
     50 見る  て て は
     23 見る  から て
     22 見る  から

!cat ./ans45.txt | grep '与える' | sort | uniq -c | sort -nr | head -n 5

出力

      5 与える   ば を
      3 与える   け に を
      2 与える   だけ で に を
      2 与える   て に は を
      1 与える   に に対して のみ は は も

46. 動詞の格フレーム情報の抽出

45のプログラムを改変し，述語と格パターンに続けて項（述語に係っている文節そのもの）をタブ区切り形式で出力せよ．45の仕様に加えて，以下の仕様を満たすようにせよ．

• 項は述語に係っている文節の単語列とする（末尾の助詞を取り除く必要はない）
• 述語に係る文節が複数あるときは，助詞と同一の基準・順序でスペース区切りで並べる

with open('./ans46.txt', 'w') as f:
  for sentence in sentences:
    for chunk in sentence.chunks:
      for morph in chunk.morphs:
        if morph.pos == '動詞':  # chunkの左から順番に動詞を探す
          cases = []
          modi_chunks = []
          for src in chunk.srcs:  # 見つけた動詞の係り元chunkから助詞を探す
            case = [morph.surface for morph in sentence.chunks[src].morphs if morph.pos == '助詞']
            if len(case) > 0:  # 助詞を含むchunkの場合は助詞と項を取得
              cases = cases + case
              modi_chunks.append(''.join(morph.surface for morph in sentence.chunks[src].morphs if morph.pos != '記号'))
          if len(cases) > 0:  # 助詞が1つ以上見つかった場合は辞書順にソートし、項と合わせて出力
            cases.sort()  
            line = '{}\t{}\t{}'.format(morph.base, ' '.join(cases), ' '.join(modi_chunks))
            print(line, file=f)
          break

# 確認
!cat ./ans46.txt | head -n 10

出力

生れる   で どこで
つく  か が 生れたか 見当が
泣く  で 所で
する  だけ て は  泣いて いた事だけは
始める   で ここで
見る  は を 吾輩は ものを
聞く  で あとで
捕える   を 我々を
煮る  て 捕えて
食う  て 煮て

47. 機能動詞構文のマイニング

動詞のヲ格にサ変接続名詞が入っている場合のみに着目したい．46のプログラムを以下の仕様を満たすように改変せよ．

• 「サ変接続名詞+を（助詞）」で構成される文節が動詞に係る場合のみを対象とする 述語は「サ変接続名詞+を+動詞の基本形」とし，文節中に複数の動詞があるときは，最左の動詞を用いる
• 述語に係る助詞（文節）が複数あるときは，すべての助詞をスペース区切りで辞書順に並べる
• 述語に係る文節が複数ある場合は，すべての項をスペース区切りで並べる（助詞の並び順と揃えよ）

このプログラムの出力をファイルに保存し，以下の事項をUNIXコマンドを用いて確認せよ．

• コーパス中で頻出する述語（サ変接続名詞+を+動詞）
• コーパス中で頻出する述語と助詞パターン

with open('./ans47.txt', 'w') as f:
  for sentence in sentences:
    for chunk in sentence.chunks:
      for morph in chunk.morphs:
        if morph.pos == '動詞':  # chunkの左から順番に動詞を探す
          for i, src in enumerate(chunk.srcs):  # 見つけた動詞の係り元chunkが「サ変接続名詞+を」で構成されるか確認
            if len(sentence.chunks[src].morphs) == 2 and sentence.chunks[src].morphs[0].pos1 == 'サ変接続' and sentence.chunks[src].morphs[1].surface == 'を':
              predicate = ''.join([sentence.chunks[src].morphs[0].surface, sentence.chunks[src].morphs[1].surface, morph.base])
              cases = []
              modi_chunks = []
              for src_r in chunk.srcs[:i] + chunk.srcs[i + 1:]:  # 残りの係り元chunkから助詞を探す
                case = [morph.surface for morph in sentence.chunks[src_r].morphs if morph.pos == '助詞']
                if len(case) > 0:  # 助詞を含むchunkの場合は助詞と項を取得
                  cases = cases + case
                  modi_chunks.append(''.join(morph.surface for morph in sentence.chunks[src_r].morphs if morph.pos != '記号'))
              if len(cases) > 0:  # 助詞が1つ以上見つかった場合は辞書順にソートし、項と合わせて出力
                cases.sort()  
                line = '{}\t{}\t{}'.format(predicate, ' '.join(cases), ' '.join(modi_chunks))
                print(line, file=f)
              break

# 確認
!cat ./ans47.txt | cut -f 1 | sort | uniq -c | sort -nr | head -n 10

出力

     29 返事をする
     21 挨拶をする
     18 話をする
      9 質問をする
      8 昼寝をする
      8 喧嘩をする
      7 真似をする
      7 問答をやる
      6 相談をする
      5 質問をかける

!cat ./ans47.txt | cut -f 1,2 | sort | uniq -c | sort -nr | head -n 10

出力

      8 返事をする と よ
      8 返事をする て
      6 話をする    か は
      6 話をする    に
      6 挨拶をする で
      5 昼寝をする が
      5 挨拶をする から
      5 挨拶をする か と も
      5 喧嘩をする で
      4 返事をする さ と に は

48. 名詞から根へのパスの抽出

文中のすべての名詞を含む文節に対し，その文節から構文木の根に至るパスを抽出せよ． ただし，構文木上のパスは以下の仕様を満たすものとする．

• 各文節は（表層形の）形態素列で表現する
• パスの開始文節から終了文節に至るまで，各文節の表現を” -> “で連結する

sentence = sentences[7]
for chunk in sentence.chunks:
  if '名詞' in [morph.pos for morph in chunk.morphs]:  # chunkが名詞を含むか確認
    path = [''.join(morph.surface for morph in chunk.morphs if morph.pos != '記号')]
    while chunk.dst != -1:  # 名詞を含むchunkを先頭に、dstを根まで順に辿ってリストに追加
      path.append(''.join(morph.surface for morph in sentence.chunks[chunk.dst].morphs if morph.pos != '記号'))
      chunk = sentence.chunks[chunk.dst]
    print(' -> '.join(path))

出力

吾輩は -> 見た
ここで -> 始めて -> 人間という -> ものを -> 見た
人間という -> ものを -> 見た
ものを -> 見た

49. 名詞間の係り受けパスの抽出

文中のすべての名詞句のペアを結ぶ最短係り受けパスを抽出せよ．ただし，名詞句ペアの文節番号がiとj（i<j）のとき，係り受けパスは以下の仕様を満たすものとする．

• 問題48と同様に，パスは開始文節から終了文節に至るまでの各文節の表現（表層形の形態素列）を” -> “で連結して表現する
• 文節iとjに含まれる名詞句はそれぞれ，XとYに置換する

また，係り受けパスの形状は，以下の2通りが考えられる．

• 文節iから構文木の根に至る経路上に文節jが存在する場合: 文節iから文節jのパスを表示
• 上記以外で，文節iと文節jから構文木の根に至る経路上で共通の文節kで交わる場合: 文節iから文節kに至る直前のパスと文節jから文節kに至る直前までのパス，文節kの内容を” | “で連結して表示

例えば、

• i -> a -> b -> j -> 根 であれば、 i -> a -> b -> j
• i -> a -> k -> 根、j -> b -> k -> 根 であれば、i -> a | j -> b | k

とし、i、jの名詞をそれぞれX、Yに変換して表示すればよいことになります。

from itertools import combinations

sentence = sentences[7]
nouns = []
for i, chunk in enumerate(sentence.chunks):
  if '名詞' in [morph.pos for morph in chunk.morphs]:  # 名詞を含む文節を抽出
    nouns.append(i)
for i, j in combinations(nouns, 2):  # 名詞を含む文節のペアごとにパスを作成
  path_i = []
  path_j = []
  while i != j:  # i, jが同じ文節に到達するまでdstを順に辿る
    if i < j:
      path_i.append(i)
      i = sentence.chunks[i].dst
    else:
      path_j.append(j)
      j = sentence.chunks[j].dst
  if len(path_j) == 0:  # 1つ目のケース
    chunk_X = ''.join([morph.surface if morph.pos != '名詞' else 'X' for morph in sentence.chunks[path_i[0]].morphs])
    chunk_Y = ''.join([morph.surface if morph.pos != '名詞' else 'Y' for morph in sentence.chunks[i].morphs])
    path_XtoY = [chunk_X] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_i[1:]] + [chunk_Y]
    print(' -> '.join(path_XtoY))
  else:  # 2つ目のケース
    chunk_X = ''.join([morph.surface if morph.pos != '名詞' else 'X' for morph in sentence.chunks[path_i[0]].morphs])
    chunk_Y = ''.join([morph.surface if morph.pos != '名詞' else 'Y' for morph in sentence.chunks[path_j[0]].morphs])
    chunk_k = ''.join([morph.surface for morph in sentence.chunks[i].morphs])
    path_X = [chunk_X] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_i[1:]]
    path_Y = [chunk_Y] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_j[1:]]
    print(' | '.join([' -> '.join(path_X), ' -> '.join(path_Y), chunk_k]))

出力

Xは | Yで -> 始めて -> 人間という -> ものを | 見た。
Xは | Yという -> ものを | 見た。
Xは | Yを | 見た。
Xで -> 始めて -> Yという
Xで -> 始めて -> 人間という -> Yを
Xという -> Yを

おわりに

言語処理100本ノックは自然言語処理そのものだけでなく、基本的なデータ処理や汎用的な機械学習についてもしっかり学ぶことができるように作られています。
オンラインコースなどで機械学習を勉強中の方も、とても良いアウトプットの練習になると思いますので、ぜひ挑戦してみてください。

備忘録かつ添削をお願いしたく。

パッケージ化しないアプリでも、アップデートする仕組みを入れておかないと、修正する度にそれぞれのマシンでコピーする作業が起こってしまう事に気が付きました。
http経由でダウンロードする事も、zipファイルを展開することも簡単にできてしまうのだから、それを組み合わせてアプリケーションディレクトリのの .py ファイルを更新してやればよいのでは？ということで、当該の部分はこのようになりました。

    def updateDownloadQuit(self):
        url ="http://〜〜"
        title = './update.zip'
        urllib.request.urlretrieve(url,"{0}".format(title))

        QMessageBox.information(None, "Info",  "アプリケーションを更新して、終了します")
        with zipfile.ZipFile('update.zip') as existing_zip:
            existing_zip.extractall('.')

        MainWindow.close()

Qtでなくても、ちょっとしたスクリプト群の配布に使えると思います。

多分、ゴミ投稿… 逐次、更新。

覚書

商と余り

• Pythonのdivmodで割り算の商と余りを同時に取得 | note.nkmk.me

q = 10 // 3    # 商
mod = 10 % 3   # 余り
q, mod = divmod(10, 3)    # 商と余りを同時に

swap

• Pythonで変数やリストの値を入れ替え（交換・並べ替え） | note.nkmk.me

a, b = b, a

もう tmp 要らない…。

ユークリッドの互除法 Python 版

• 拡張ユークリッドの互除法 〜 一次不定方程式 ax + by = c の解き方 〜 - Qiita

def gcd(a, n):
    if n == 0:
        return  a
    else:
        return gcd(n, a % n)

つか、標準ライブラリ等がありますね。

• math.gcd(a, b) — math --- 数学関数 — Python 3.8.3 ドキュメント ※バージョン 3.5 で追加
• numpy.gcd — NumPy v1.18 Manual
• numpy.lcm — NumPy v1.18 Manual
• Pythonで最大公約数と最小公倍数を算出・取得 | note.nkmk.me
• NumPyで最大公約数・最小公倍数を算出・取得 | note.nkmk.me

Windows でのトラブル

• Windows での Python の使用についてよく寄せられる質問 | Microsoft Docs

Python をインストールせずにショートカットを無効にするには、[スタート] から Manage app execution aliases を開き、"App Installer" (アプリ インストーラー) Python エントリを見つけて "オフ" に切り替えます。

Python 公式等

• Welcome to Python.org
• PyPI · The Python Package Index

Anaconda 関連

• Anaconda | The World's Most Popular Data Science Platform
• conda-forgeからのPythonパッケージインストール - われがわログ
• AnacondaによるPython 3.6環境構築と環境管理 | 東京大学 佐々木淳 研究室 沿岸環境学 海岸工学 環境水工学 水環境学

Python 仮想環境

• venv --- 仮想環境の作成 — Python 3.8.3 ドキュメント
• Virtualenv
  • Virtualenv — virtualenv 20.0.21 documentation
• virtualenv cloning script.
• Pipenv: Python Development Workflow for Humans

科学技術計算・統計

公式

• NumPy
• pandas - Python Data Analysis Library
• Matplotlib: Python plotting — Matplotlib 3.2.1 documentation
• SymPy
• SciPy.org — SciPy.org

日本語での解説

• Scipy Lecture Notes — Scipy lecture notes
• Python 数値計算入門
• Python でデータサイエンス

GIS

• ArcGIS API for Python | ArcGIS for Developers
• GIS奮闘記
  • 【Pythonで分析】ArcpyとPandasを使用して将来推計人口を視覚化する - GIS奮闘記
• Python 経度・緯度で与えられた２点間距離計算 - Qiita
• Folium: Python で地図可視化 - Tak's Notebook

機械学習

• TensorFlow
• Keras: the Python deep learning API
• scikit-learn: machine learning in Python — scikit-learn 0.23.1 documentation
• PyTorch

形態素解析

• MeCab: Yet Another Part-of-Speech and Morphological Analyzer
  • スクリプト言語のバインディング
• MeCab（形態素解析）をPythonから２分で使えるようにする方法

Web フレームワーク

• The Web framework for perfectionists with deadlines | Django
• Home - Django REST framework
• Flask | The Pallets Projects

番外編

• Graphing Pretty Charts With Python Flask and Chartjs - Ruan Bekker's Blog

画像処理

• Python Pillow
• scikit-image: Image processing in Python — scikit-image

OCR

• Python と Tesseract OCR を使って文字認識をしてみよう！ - GIS奮闘記
• PythonでOCRを実行する方法 | ガンマソフト株式会社

Excel 操作

• openpyxl - A Python library to read/write Excel 2010 xlsx/xlsm files — openpyxl 3.0.3 documentation

Game

• 【Pygame入門】ゲームプログラミング【Python】 | 西住工房

その他

• Dive Into Python 3 日本語版
• 1時間で覚える?Python： イントロスペクション(オブジェクトへの質問・調査の機能)

・ツールチップでデータの中身を確認することが可能

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

from bokeh.io import output_notebook, show
from bokeh.plotting import figure,show
output_notebook()

x = np.linspace(1, 10, 10)
y = [random.randint(0, 10) for i in range(10)]

TOOLTIPS = [
    ("index", "$index"),
    ("(x,y)", "($x, $y)"),
]

#グラフ設定
p = figure(tooltips=TOOLTIPS, title="グラフタイトル", x_axis_label="x軸", y_axis_label="y軸")
# 散布図
p.circle(x = x,y = y)
#show(p)

# 折れ線グラフ
#p.line(x = x,y = y)
#show(p)

# 棒グラフ
#p.vbar(x = x,top = y,width=0.5)
show(p)

はじめに

前回に引き続き、PyTorch 公式チュートリアル の第5弾です。
今回は Learning PyTorch with Examples を進めます。

Learning PyTorch with Examples

このチュートリアルでは、サンプルコードを通じてPyTorchの2つの主な機能を紹介します。

• Tensor
• 自動微分とニューラルネットワーク

サンプルコードで扱うネットワーク（モデル）は3層（入力層、隠れ層 × 1、出力層）です。
活性化関数は ReLU を使用します。

1. Tensor

1.1. Warm-up: numpy

PyTorch の前に、まずは numpy を使用してネットワークを実装します。
Numpy には、ディープラーニング、勾配についての機能はありませんが、
手動で実装することで、簡単なニューラルネットワークを構築できます。

import numpy as np

# N     ： バッチサイズ 
# D_in  ： 入力次元数
# H     ： 隠れ層の次元数
# D_out ： 出力次元数
N, D_in, H, D_out = 64, 1000, 100, 10

# ランダムな入力データと教師データを作成します
x = np.random.randn(N, D_in)
y = np.random.randn(N, D_out)

# ランダムな値で重みを初期化します
w1 = np.random.randn(D_in, H)
w2 = np.random.randn(H, D_out)

learning_rate = 1e-6
for t in range(500):
    # 順伝播: 現在の重みの値で、予測値 y を計算します
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)
    y_pred = h_relu.dot(w2)

    # ロス（損失）を計算し出力します
    loss = np.square(y_pred - y).sum()
    print(t, loss)

    # ロス値を参考に、逆伝播で 重み w1、w2 の勾配を計算します。
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.T.dot(grad_y_pred)
    grad_h_relu = grad_y_pred.dot(w2.T)
    grad_h = grad_h_relu.copy()
    grad_h[h < 0] = 0
    grad_w1 = x.T.dot(grad_h)

    # 重みを更新します。
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

このコードを実行すると、ロス値が減少し、学習が進んでいることが確認できます。

1.2. PyTorch: Tensors

Numpy はGPUを利用して計算することができませんが、PyTorch の Tensor は GPU を利用して数値計算を高速化できます。
Tensor は勾配も計算できますが、ここでは、上記の numpy の例のように、手動で実装してみます。

import torch


dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0") # GPU で実行するにはここのコメントを解除します。

# N     ： バッチサイズ 
# D_in  ： 入力次元数
# H     ： 隠れ層の次元数
# D_out ： 出力次元数
N, D_in, H, D_out = 64, 1000, 100, 10

# ランダムな入力データと教師データを作成します
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# ランダムな値で重みを初期化します
w1 = torch.randn(D_in, H, device=device, dtype=dtype)
w2 = torch.randn(H, D_out, device=device, dtype=dtype)

learning_rate = 1e-6
for t in range(500):
    # 順伝播: 現在の重みの値で、予測値 y を計算します
    h = x.mm(w1)
    h_relu = h.clamp(min=0)
    y_pred = h_relu.mm(w2)

    # ロス（損失）を計算し出力します
    loss = (y_pred - y).pow(2).sum().item()
    if t % 100 == 99:
        print(t, loss)

    # ロス値を参考に、逆伝播で 重み w1、w2 の勾配を計算します。
    grad_y_pred = 2.0 * (y_pred - y)
    grad_w2 = h_relu.t().mm(grad_y_pred)
    grad_h_relu = grad_y_pred.mm(w2.t())
    grad_h = grad_h_relu.clone()
    grad_h[h < 0] = 0
    grad_w1 = x.t().mm(grad_h)

    # 勾配降下法を使用して重みを更新します
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

このコードでも、ロス値が減少し、学習が進んでいることが確認できます。

2. Autograd

2.1. PyTorch: Tensors and autograd

上記の例では、順伝播と逆伝播を手動で実装しましたが、PyTorch の autograd パッケージを利用すると、逆伝播の計算を自動化できます。

・勾配を計算したい変数(Tensor)の requires_grad = True にする
・backward() を実行する
この2つで逆伝播の計算を自動化できます。

import torch

dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0") # GPU で実行するにはここのコメントを解除します。

# N     ： バッチサイズ 
# D_in  ： 入力次元数
# H     ： 隠れ層の次元数
# D_out ： 出力次元数
N, D_in, H, D_out = 64, 1000, 100, 10

# 入力データと教師データを保持するランダムな Tensor を作成します。
# require_grad = False を設定すると、勾配を計算する必要がないことを示します。
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 重みを保持するランダムな Tensor を作成します。
# requires_grad = True を設定すると、勾配を計算することを示します。
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

learning_rate = 1e-6
for t in range(500):
    # 順伝播: Tensor の演算を利用して 予測値 y を計算します
    # 逆伝播を手動で計算しないため、中間値 h_relu は保持する必要はありません
    y_pred = x.mm(w1).clamp(min=0).mm(w2)

    # Tensorの演算を使用して損失を計算、表示します
    # 損失は形状（1,）のTensorです
    # loss.item() は損失に保持されているスカラー値を取得します
    loss = (y_pred - y).pow(2).sum()
    if t % 100 == 99:
        print(t, loss.item())

    # autogradを使用して、逆伝播を計算します
    # backward() は、requires_grad = True のすべての Tensor に関する loss の勾配を計算します
    # この呼び出しの後、w1.grad および w2.grad は、それぞれ w1 , w2 の勾配を保持する Tensor になります
    loss.backward()

    # 最急降下法を使用して重みを手動で更新します
    # 重みには require_grad = True があるため、torch.no_grad() で計算グラフが更新されないようにします
    # torch.optim.SGD を使用してこの処理と同じことができます
    with torch.no_grad():
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad

        # 重みを更新した後、手動で勾配をゼロにします
        w1.grad.zero_()
        w2.grad.zero_()

チュートリアルにはありませんが、逆伝播の計算グラフを図示してみます。
torchviz を利用することで計算グラフを図示できます。
colaboratory を使用している場合、インストールが必要です。

!pip install torchviz

PyTorch: Tensors のサンプルコードに少し手を加えます。
ループをやめ、勾配が一度だけ計算されるようにします。

# ランダムな入力データと教師データを作成します
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# ランダムな値で重みを初期化します
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

# 順伝播: 現在の重みの値で、予測値 y を計算します
h = x.mm(w1)
h_relu = h.clamp(min=0)
y_pred = h_relu.mm(w2)

# ロス（損失）を計算し出力します
loss = (y_pred - y).pow(2).sum().item()

# ロス値を参考に、逆伝播で 重み w1、w2 の勾配を計算します。
grad_y_pred = 2.0 * (y_pred - y)
grad_w2 = h_relu.t().mm(grad_y_pred)
grad_h_relu = grad_y_pred.mm(w2.t())
grad_h = grad_h_relu.clone()
grad_h[h < 0] = 0
grad_w1 = x.t().mm(grad_h)

torchviz の make_dot で計算グラフを図にします。
順伝播と勾配を図示します。
param_dict は必須ではありませんが、指定すると図に変数名を記述できます。

# 順伝播の計算グラフを図示します。
from torchviz import make_dot
param_dict = {'w1': w1, 'w2': w2}
make_dot(loss, param_dict)

# w1の勾配の計算グラフを図示します。
make_dot(grad_w1, param_dict)

# w2の勾配の計算グラフを図示します。
make_dot(grad_w2, param_dict)

計算グラフは以下です。

同じように、PyTorch: Tensors and autograd のサンプルコードに手を加え、勾配を一度だけ計算されるようにします。
backward() 実行時に create_graph=True を指定することで導関数のグラフが保持されます。

import torch

# 入力データと教師データを保持するランダムな Tensor を作成します。
# require_grad = False を設定すると、勾配を計算する必要がないことを示します。
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 重みを保持するランダムな Tensor を作成します。
# requires_grad = True を設定すると、勾配を計算することを示します。
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

# 順伝播: Tensor の演算を利用して 予測値 y を計算します
# 逆伝播を手動で計算しないため、中間値 h_relu は保持する必要はありません
y_pred = x.mm(w1).clamp(min=0).mm(w2)

# Tensorの演算を使用して損失を計算、表示します
# 損失は形状（1,）のTensorです
# loss.item() は損失に保持されているスカラー値を取得します
loss = (y_pred - y).pow(2).sum()

# autogradを使用して、逆伝播を計算します
# backward() は、requires_grad = True のすべての Tensor に関する loss の勾配を計算します
# この呼び出しの後、w1.grad および w2.grad は、それぞれ w1 , w2 の勾配を保持する Tensor になります
loss_backward = loss.backward(create_graph=True)

同じように順伝播と autograd で計算された勾配を図示します。

# 順伝播の計算グラフを図示します。
param_dict = {'w1': w1, 'w2': w2}
make_dot(loss, param_dict)

# w1の勾配の計算グラフを図示します。
make_dot(w1.grad, param_dict)

# w2の勾配の計算グラフを図示します。
make_dot(w2.grad, param_dict)

順伝播は同じです。逆伝播は少し形が異なりますが、autograd で逆伝播の計算が自動で行われていることが確認できます。

2.2. PyTorch: Defining new autograd functions

PyTorchでは、torch.autograd.Functionのサブクラスを定義することで、独自の関数（演算子）を定義できます。
サブクラスには、以下の2つ メソッドを実装します。

• forward メソッド：入力 Tensor から出力 Tensor を計算する
• backward メソッド：出力 Tensor の勾配を受け取り、入力 Tensor の勾配を計算する

この例では、ReLU関数を意味する独自の関数を用いて、2層ネットワークを定義します。

import torch

class MyReLU(torch.autograd.Function):
    """
    torch.autograd.Functionをサブクラス化し、
    Tensorsで動作するフォワードパスとバックワードパスを実装することで、
    独自のカスタム autograd 関数を実装できます。
    """

    @staticmethod
    def forward(ctx, input):
        """
        フォワードパスでは、入力を含むTensorを受け取り、
        出力を含むTensorを返します。 
        ctxは、逆伝播計算のためのオブジェクトです。 
        ctx.save_for_backwardメソッドを使用して、
        オブジェクトをキャッシュできます。
        """
        ctx.save_for_backward(input)
        return input.clamp(min=0)

    @staticmethod
    def backward(ctx, grad_output):
        """
        backward では、出力に関する損失の勾配を含むTensorを受け取り、
        入力に関する損失の勾配を計算する必要があります。
        """
        input, = ctx.saved_tensors
        grad_input = grad_output.clone()
        grad_input[input < 0] = 0
        return grad_input


dtype = torch.float
device = torch.device("cpu")
# device = torch.device("cuda:0") # GPU で実行するにはここのコメントを解除します。

# N     ： バッチサイズ 
# D_in  ： 入力次元数
# H     ： 隠れ層の次元数
# D_out ： 出力次元数
N, D_in, H, D_out = 64, 1000, 100, 10

# 入力データと教師データを保持するランダムな Tensor を作成します。
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 重みを保持するランダムな Tensor を作成します。
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

learning_rate = 1e-6
for t in range(500):
    # 関数を適用するには、Function.applyメソッドを使用します。
    relu = MyReLU.apply

    # 順伝播: カスタム autograd 関数を利用して 予測値 y を計算します
    y_pred = relu(x.mm(w1)).mm(w2)

    # 損失を計算、表示します
    loss = (y_pred - y).pow(2).sum()
    if t % 100 == 99:
        print(t, loss.item())

    # autogradを使用して、逆伝播を計算します
    loss.backward()

    # 最急降下法を使用して重みを更新します
    with torch.no_grad():
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad

        # 重みを更新した後、手動で勾配をゼロにします
        w1.grad.zero_()
        w2.grad.zero_()

独自関数も可視化してみます。
先ほどと同様、1回のみ処理されるようにします。

# 入力データと教師データを保持するランダムな Tensor を作成します。
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)

# 重みを保持するランダムな Tensor を作成します。
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)

# 関数を適用するには、Function.applyメソッドを使用します。
relu = MyReLU.apply

# 順伝播: カスタム autograd 関数を利用して 予測値 y を計算します
y_pred = relu(x.mm(w1)).mm(w2)

# 損失を計算、表示します
loss = (y_pred - y).pow(2).sum()

# autogradを使用して、逆伝播を計算します
loss.backward(create_graph=True)

だいたい、似たような計算グラフになっているでしょうか。

続く

長くなりましたので、PyTorch: nn は後編に分けたいと思います。

履歴

2020/05/27 初版公開

はじめに?

ノンコーディングで機械学習モデルが生成可能なツール、サービスをご紹介します。
GUIツールから、pythonライブラリなど、様々な物を探してみました。

そもそもAutoMLって？?

機械学習にはそもそも以下のようプロセスがあります。

1. 課題定義
2. データ収集
3. データ調整
4. 特徴エンジニアリング
5. アルゴリズム選定
6. パラメータ調整
7. 学習
8. 評価
9. 推論

このうち3~9の部分を自動的に行ってくれるのがAutoMLツールとなります。

どんなサービスがあるか

大きく分けて以下のカテゴリがあります。
* クラウドサービス
* オープンソースライブラリ
* フリーソフト

クラウドサービス?

DataRobot

https://www.datarobot.com/

サービス内画面

Dataiku

https://www.dataiku.com/

サービス内画面

H2O DriverlessAI

https://www.h2o.ai/products/h2o-driverless-ai/

サービス内画面

VARISTA

https://www.varista.ai/

サービス内画面

オープンソースライブラリ

PyCaret

https://github.com/pycaret

AutoGluon

https://autogluon.mxnet.io/

フリーソフト

WEKA

https://www.cs.waikato.ac.nz/ml/weka/

おわり?

すてきなAutoMLライフを⭐️

昨日までのはこちら

100日後にエンジニアになるキミ - 66日目 - プログラミング - 自然言語処理について

100日後にエンジニアになるキミ - 63日目 - プログラミング - 確率について1

100日後にエンジニアになるキミ - 59日目 - プログラミング - アルゴリズムについて

100日後にエンジニアになるキミ - 53日目 - Git - Gitについて

100日後にエンジニアになるキミ - 42日目 - クラウド - クラウドサービスについて

100日後にエンジニアになるキミ - 36日目 - データベース - データベースについて

100日後にエンジニアになるキミ - 24日目 - Python - Python言語の基礎1

100日後にエンジニアになるキミ - 18日目 - Javascript - JavaScriptの基礎1

100日後にエンジニアになるキミ - 14日目 - CSS - CSSの基礎1

100日後にエンジニアになるキミ - 6日目 - HTML - HTMLの基礎1

今回はTF-IDFについてです。

TF-IDFとは

TF-IDFは索引語頻度逆文書頻度のことで
TF(Term Frequency)単語の出現頻度と
IDF(Inverse Document Frequency)単語の希少度とを
掛け合わせたものになります。

$$
{TF: 文書における指定単語の出現頻度: \frac{文書内の指定単語の出現回数}{文書内の全単語の出現回数}\
}
$$

$$
{IDF: 逆文書頻度(指定単語の希少度): log\frac{総文書数}{指定単語を含む文書数}}
$$

$$
{TFIDF(索引語頻度逆文書頻度) = TF * IDF}
$$

参考：
https://ja.wikipedia.org/wiki/Tf-idf

ワードカウント

まずは文章の単語数を数えてみましょう。

カウント用の文章を作っておきます。

result_list = []
result_list.append('吾輩 は 猫 で ある')
result_list.append('吾輩 は 猫 で ある')
result_list.append('吾輩 も です')
result_list.append('どうぞ どうぞ 猫 です')

以下のようなコードで単語の出現頻度を数える事ができます。

from sklearn.feature_extraction.text import CountVectorizer
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')

count_vectorizer = CountVectorizer(token_pattern='(?u)\\b\\w+\\b')

count_vectorizer.fit(result_list)
X = count_vectorizer.transform(result_list)

print(len(count_vectorizer.vocabulary_))
print(count_vectorizer.vocabulary_)

pd.DataFrame(X.toarray(), columns=count_vectorizer.get_feature_names())

8
{'吾輩': 6, 'は': 4, '猫': 7, 'で': 1, 'ある': 0, 'も': 5, 'です': 2, 'どうぞ': 3}

	ある	で	です	どうぞ	は	も	吾輩	猫
0	1	1	0	0	1	0	1	1
1	1	1	0	0	1	0	1	1
2	0	0	1	0	0	1	1	0
3	0	0	1	2	0	0	0	1

各文章で単語が何回登場するかを数える事ができます。

次はTF-IDFを求めてみましょう。

以下のようなコードで求める事ができます。

from sklearn.feature_extraction.text import TfidfVectorizer
import warnings
import numpy as np
import pandas as pd
warnings.filterwarnings('ignore')

tfidf_vectorizer = TfidfVectorizer(token_pattern='(?u)\\b\\w+\\b')
tfidf_vectorizer.fit(result_list)

print(len(tfidf_vectorizer.vocabulary_))
print(tfidf_vectorizer.vocabulary_)

X = tfidf_vectorizer.fit_transform(result_list)
pd.DataFrame(X.toarray(), columns=tfidf_vectorizer.get_feature_names())

8
{'吾輩': 6, 'は': 4, '猫': 7, 'で': 1, 'ある': 0, 'も': 5, 'です': 2, 'どうぞ': 3}

	ある	で	です	どうぞ	は	も	吾輩	猫
0	0.481635	0.481635	0	0	0.481635	0	0.389925	0.389925
1	0.481635	0.481635	0	0	0.481635	0	0.389925	0.389925
2	0	0	0.553492	0	0	0.702035	0.4481	0
3	0	0	0.35157	0.891844	0	0	0	0.284626

TF-IDFは0から1の間の数値がでます。
たくさんの文章に出てくるものの値は小さくなります。
1つの文章でたくさん出てくるものは重要なワードだと考えられます。

1に近いほど希少性の高いワードであると考えることもできます。

まとめ

文章をベクトル化する手法と、単語の希少性を算出する手法があります。
文章を数値化する事ができるので、いろいろな計算を行う事ができるようになります。

こう言った手法は機械学習などでは良く用いられるので
名前とかを抑えておきましょう。

君がエンジニアになるまであと32日

作者の情報

乙pyのHP：
http://www.otupy.net/

Youtube：
https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw

Twitter：
https://twitter.com/otupython

線形代数

理系大学で絶対に習う線形代数をわかりやすく、かつ論理的にまとめる。ちなみにそれをPythonで実装。たまに、Juliaで実装するかも。。。
・Pythonで動かして学ぶ！あたらしい数学の教科書 -機械学習・深層学習に必要な基礎知識-
・世界基準MIT教科書 ストラング線形代数イントロダクション
を基に線形代数を理解し、pythonで実装。

環境

・JupyterNotebook
・言語：Python3, Julia1.4.0

固有値と固有ベクトル

固有値と固有ベクトルは人工知能でデータの要約する主成分分析法で用いられる。

固有値、固有ベクトル

正方行列Aを考える。
この行列Aにたいして、

A\vec{x}=λ\vec{x}

を満たすとき、

λを行列Aの固有値\\
\vec{x}を行列Aの固有ベクトル\\

という。

固有方程式

上のような式に対して、ベクトルに影響を及ぼすことのない単位行列Eをかける。

A\vec{x}=λE\vec{x}

右辺を移項して整理する

(A-λE)\vec{x} = \vec{0}

これは要素がすべて0のベクトルを表す。これに対して、逆行列を考えても零
ベクトルである。
この式を固有方程式***という。

固有方程式による固有値、固有ベクトルの求解

(A-λE)\vec{x} = \vec{0}

に沿って、

A=\begin{pmatrix}3 & 1\\2 & 4\end{pmatrix}

として具体例で行う。
そうすると、

det(A-λE)\vec{x} = 0\\
⇔
det(\begin{pmatrix}3 & 1\\2 & 4\end{pmatrix}-λ\begin{pmatrix}1 & 0\\0 & 1\end{pmatrix})\vec{x} = 0\\
⇔
det\begin{pmatrix}3-λ & 1\\2 & 4-λ\end{pmatrix} = 0\\
⇔(λ-2)(λ-5)= 0\\

これによって、固有値は2または5になる。
固有値によって固有ベクトルも変わってくるので。2,5のときそれぞれで考える。

\vec{x} = \begin{pmatrix}p\\q\end{pmatrix}

とおくとき、λ＝2で計算すると、

det(A-λE)\vec{x} = 0\\
\begin{align}
det(A-λE)\vec{x}&=
det(A-2E)\begin{pmatrix}p\\q\end{pmatrix} \\
&=\begin{pmatrix}1 & 1\\2 & 2\end{pmatrix}\begin{pmatrix}p\\q\end{pmatrix}\\
&=\begin{pmatrix}p+q\\2p+2q\end{pmatrix} \\
&= \vec{0} 
\end{align}

これより、p+q = 0であるといえるので、任意の実数tを置いて、xベクトルは

\vec{x}=\begin{pmatrix}t\\-t\end{pmatrix}

と固有ベクトルを求められる。

λ=5のときは、

\vec{x}=\begin{pmatrix}t\\2t\end{pmatrix}

となる。

プログラム

固有値、固有ベクトルを求めるプログラム

python

7pythoneigenvaluevector

import numpy as np

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

ev = np.linalg.eig(A)
print(ev[0])
print(ev[1])

[2. 5.]
[[-0.70710678 -0.4472136 ]
 [ 0.70710678 -0.89442719]]

ここでlinag.eig関数を使っている。固有値が英語で、eigenvalueというからだ。

原理的なプログラムを組もう。今回は固有値までを求める。

python(原理的)

7pythoneigenvaluevector2

import numpy as np
import sympy

#A = [[a, b],
#     [c, d]]
a = int(input())
b = int(input())
c = int(input())
d = int(input())
#=>3
#=>1
#=>2
#=>4

x = sympy.Symbol('x')
eigenequa = x**2 - (a + d)*x + (a * d) - (b * c)```
print(eigenequa)
# factorization = sympy.factor(eigenequa)
# print(factorization)
solve = sympy.solve(eigenequa)
print(solve)
#=>x**2 - 7*x + 10
#=>[2, 5]

juliaはものすごい簡単なので、載せときます。

julia

7juliaigenvaluevector

using LinearAlgebra
F = eigen([3 1; 2 4;])

#=>Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}
#=>values:
#=>2-element Array{Float64,1}:
#=> 2.0
#=> 5.0
#=>vectors:
#=>2×2 Array{Float64,2}:
#=> -0.707107  -0.447214
#=>  0.707107  -0.894427

たった2行だけ！すごい...

今日はここまで

経緯

PyTorchのDCGANチュートリアルで巨大なデータセット（1GB・22万枚画像くらい）が必要
↓
ローカルのJupyter Labで動かしてみたら学習遅い＆メモリ不足
↓
GPUも使えるGoogle Colaboratory（以下Colab）上で学習させてみよう
↓
手を動かしていくうちに問題発生

データセットをColabにどうやってコピーしよう？

問題

• ColabってGoogle Driveのファイル参照できるの？
• Colab上でZIPって解凍できるの？

ColabってGoogle Driveのファイル参照できるの？

Google Driveをマウントすることで参照することができます。
ノートブックを新規作成し次のコードを実行する。

from google.colab import drive
drive.mount('/content/drive')

認証コードを生成するリンクが貼られるのでアクセスする。
アカウント選択でColabを利用しているアカウントを選択する。
Google Drive File Streamがアクセスを求めてくるので許可する。
認証コードが発行されるのでコピーして、貼り付けてエンター。

Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=xxx
Enter your authorization code:

Colab上でZIPって解凍できるの？

Colab上でunzipコマンドが使えます。
まずはGoogle DriveにデータセットのZIPファイルをアップロードし、Colab上にコピーします。

cp "./drive/My Drive/Colab Notebooks/data/celeba/img_align_celeba.zip" "."

後はunzipコマンドを使いColab上で解凍します。

!unzip "img_align_celeba.zip"

解凍した画像を表示してみる

from PIL import Image
Image.open('img_align_celeba/000001.jpg')

無事表示することができました。

まとめ

1. データセットをGoogle DriveにZIPでアップロードする
2. Colab上でGoogle Driveをマウントする
3. Colab上にZIPファイルをコピーする
4. Colab上でZIPファイルを解凍する

追記

Colabにファイルをアップロードするだけなら次のコードでローカルファイルを選択できます。
ただし、容量が大きなファイルをアップロードしようとするとかなり時間がかかっているように感じます。
本稿のGoogle Drive経由の方が早くアップロードできる気がします。

from google.colab import files
files.upload()

化合物の類似性を語るにあたって、有名な指標に「タニモト係数」があります。ところが、「タニモト係数」とだけしか言わない人がけっこういて、「それだけでは説明不十分ですよね？」って悶々とする機会がけっこうあるわけです。

たとえば次の化合物セットを使いましょう

化合物数は１０個です。

smiles = [
    'C1=CC=C2C3CC(CNC3)CN2C1=O',
    'CN1c2c(C(N(C)C1=O)=O)[nH0](CC(CO)O)c[nH0]2',
    'CN1C2CC(CC1C1C2O1)OC(C(c1ccccc1)CO)=O',
    'CN1C2CC(CC1C1C2O1)OC(C(c1cccnc1)CO)=O', # 一つ上の化合物と類似
    'CN(C=1C(=O)N(c2ccccc2)N(C1C)C)C',
    'CN(C=1C(=O)N(C2CCCCC2)N(C1C)C)C', # 一つ上の化合物と類似
    'OCC1C(C(C(C(OCC2C(C(C(C(OC(c3ccccc3)C#N)O2)O)O)O)O1)O)O)O',
    'OCc1ccccc1OC1C(C(C(C(CO)O1)O)O)O',
    'OCc1cc(N)ccc1OC1C(C(C(C(CO)O1)O)O)O', # 一つ上の化合物と類似
    '[nH0]1c(OC)c2c([nH0]cc[nH0]2)[nH0]c1',
]

SMILES表記からRDKitで化合物を生成

from rdkit import Chem

mols = [Chem.MolFromSmiles(smile) for smile in smiles]

Morgan fingerprint (の一種)を生成

from rdkit.Chem import AllChem

fps = [AllChem.GetMorganFingerprint(mol, 3, useFeatures=True) for mol in mols]

タニモト係数を計算

from rdkit import DataStructs

sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]

タニモト係数の分布

このようにすれば、タニモト係数の分布が見られます。タニモト係数 = 1 のものは同一分子だと思われますが、それ以外でタニモト係数が高めの分子対がありますね。それが何なのか、調べてみてください（あるいは想像してみてください）

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

で、Morgan fingerprint にも色々ありまして

Morgan fingerprintもパラメータがいろいろあって、それを変えるとタニモト係数の数値も変わるわけです。

fps = [AllChem.GetMorganFingerprint(mol, 2, useFeatures=True) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

fps = [AllChem.GetMorganFingerprint(mol, 1, useFeatures=True) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

fps = [AllChem.GetMorganFingerprintAsBitVect(mol, 3, 1024) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

fps = [AllChem.GetMorganFingerprintAsBitVect(mol, 3, 2048) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

で、フィンガープリントは他にもありまして

全部計算するのメンドくさいので２つだけ。重要なことの一つとして、下記の計算結果ではタニモト係数が1.0のものが１０件以上出てきます。つまり、同一分子でなくてもタニモト係数が1.0になる場合があることは知っておきましょう。

fps = [AllChem.GetMACCSKeysFingerprint(mol) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

fps = [Chem.RDKFingerprint(mol) for mol in mols]
sim_matrix = [DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps]
plt.hist(np.array(sim_matrix).flatten(), bins=20)
plt.grid()
plt.show()

MCSを用いたタニモト係数も定義できるわけでして

from rdkit.Chem import rdFMCS

matrix = []
for mol1 in mols:
    for mol2 in mols:
        mcs = rdFMCS.FindMCS([mol1, mol2])
        a1 = len(mol1.GetAtoms())
        a2 = len(mol2.GetAtoms())
        matrix.append(mcs.numAtoms / (a1 + a2 - mcs.numAtoms) )

plt.hist(np.array(matrix).flatten(), bins=20)
plt.grid()
plt.show()

MCSにもいろんなオプションがあるわけでして

from rdkit.Chem import rdFMCS

matrix = []
for mol1 in mols:
    for mol2 in mols:
        mcs = rdFMCS.FindMCS([mol1, mol2], atomCompare=rdFMCS.AtomCompare.CompareAny)
        a1 = len(mol1.GetAtoms())
        a2 = len(mol2.GetAtoms())
        matrix.append(mcs.numAtoms / (a1 + a2 - mcs.numAtoms) )

plt.hist(np.array(matrix).flatten(), bins=20)
plt.grid()
plt.show()

from rdkit.Chem import rdFMCS

matrix = []
for mol1 in mols:
    for mol2 in mols:
        mcs = rdFMCS.FindMCS([mol1, mol2])
        a1 = len(mol1.GetBonds())
        a2 = len(mol2.GetBonds())
        matrix.append(mcs.numBonds / (a1 + a2 - mcs.numBonds) )

plt.hist(np.array(matrix).flatten(), bins=20)
plt.grid()
plt.show()

from rdkit.Chem import rdFMCS

matrix = []
for mol1 in mols:
    for mol2 in mols:
        mcs = rdFMCS.FindMCS([mol1, mol2], bondCompare=rdFMCS.BondCompare.CompareOrderExact)
        a1 = len(mol1.GetBonds())
        a2 = len(mol2.GetBonds())
        matrix.append(mcs.numBonds / (a1 + a2 - mcs.numBonds) )

plt.hist(np.array(matrix).flatten(), bins=20)
plt.grid()
plt.show()

で、あなたのおっしゃる「タニモト係数」って、どれのことかしら？