はじめに

私は、 首都圏の理系大学に通う大学4年生です。
ありがたいことに早いうちに機械学習系のエンジニア職の内定をいただけました。
大学の研究室では、プログラミング言語のPythonを軸に機械学習を勉強しています。
でも、covitショックで大学の研究室にはいけなくなり、独自に勉強せねばならぬ...!
しかも、自分の実力が会社に入ってから通用するのか？勉強しなきゃ...!!!
となった僕が、今まで独学で勉強してきた物を紹介&リストアップ

Step1 : Pythonを理解しようぜ

機械学習やAIを勉強していくに当たって、Pythonの基本的な文法がわからんぞってなると行き詰まってしまいました。
そのため、僕が使ったPythonの勉強サイトは、こいつらです。Python以外の言語を勉強するのにも使える！

EntryNo.1 : Progate

言わずと知れた、プログラミング学習サイト。
スライドと環境構築不要のエディター付きの学習サイトになっている。
解説がスライドなので、音楽を聴きながら勉強することができるのが個人的なGoodポイント。
とくにGoodなのは、後述するPaizaラーニングにもあるが、環境構築不要のエディターがあることが、初心者に優しい。
こいつだけで、結構な基礎を勉強することができる。
実際に他の言語とかも勉強することもできるし、まじで便利。

おすすめ度:★★★☆☆
URL : https://prog-8.com/

EntryNo.2 : Paizaラーニング

Paizaラーニングは、動画と環境構築不要のエディター付きの学習サイト。
前述のProgateと違うのが、スライドではなく動画であること。
しっかりと動画で、動いているところが見れるからしっかりと自分で手を動かしながらコードを構築することができるのがGood。

また、Paizaの運営会社「paiza株式会社」は、HR（人材系）の事業をやっていることから、自分が勉強したプログラミング知識で就職活動をすることができるのがとてもよかった。
(自分もここで就職を決めることができた。)

動画で基礎を勉強することができ、職にまでつなげることができるところがとてもよかった。
学習教材の内容も独自の内容なので、飽きずにやることができる。
progate同様こいつだけで、結構な基礎を勉強することができる。
実際に他の言語とかも勉強することもできるし、まじで便利。

おすすめ度：★★★★☆
URL : https://paiza.jp/works

EntryNo.3 : ドットインストール

ドットインストールは、動画のみの学習サイト。
前述した二つのサイトに比べ、環境構築が必要な点がネックになっているからあまり使わなかった。

ただ、強みとして前述した二つのサイトに比べて、カバーしている領域の広さがとても広い。
マイナーながら統計学をやっていれば一度は目にする「R」の講座があったり、「VBA」や「GAS」、「Docker」などの知ってたら地味に便利になる物の学習ができたり、最近では前述した二つにも増えてきたが、「AWS」の講座があったりとほんとに幅が広い。

おすすめ度：★★☆☆☆
URL : https://dotinstall.com/

Step1まとめ

ここまで紹介してきたサイトのPythonの基礎を勉強することができれば、この後に記載する学習サイトでも特に苦労せずに以降できると思います。
全部やらずとも、一つだけ自分に合うと思うサイトを使えばいいと思います。
何をやれば良いかわからない人は、個人的にPaizaを使えば良いのではないかなと思っています。
就職にも繋がるって良くない？笑

Step 2 機械学習・AIってなんだ？

Pythonの基礎がわかったところで、ここから機械学習について勉強をしました。
ここら辺から、僕はサイト以外にも本などを使って勉強をし始めました。

EntryNo.1 : キカガク

キャッチコピーが

最先端を、最短距離で身につける。初学者から始められる学習サイト

基礎的なところから、しっかり勉強することができるサイト。
機械学習初心者から、中級者に上がるまでをサポートしてくれるようなサイト。

大きく分けて、「自然言語」「画像処理」「ディープラーニング」 などの基礎的なところを無料で勉強することができるサイト。

tensorflowやpytorchのどちらかで勉強するコースが整っているが、基本的に自分の環境が整っている人向けという印象。
ただ、環境構築についてもチュートリアルで説明があるので、敷居は低め！
Google ColaboratoryというGoogle様が提供しているとても素晴らしいエディターでも一応勉強することはできる。

おすすめ度：★★★★☆
URL : https://www.kikagaku.ai/

EntryNo.2 : AI academy

ゴール別にカリキュラムを設定してくれるので、便利。
「AWS」「GCP」や「R」などの機械学習を扱う上で便利なその他ツールの解説などがドキュメント形式である便利なサイト。
Pythonの基本的な文法から立ち戻って勉強することができるが、基礎を勉強するならStep1のサイトの方がわかりやすかったなとか思ったり。
「画像認識」「動画認識」などの分野を勉強することができ、学べる幅が広い。ただ、深いところまで勉強するには、課金しなければいけないのだが、月額1000円ほどで勉強ができるので結構良いのではとか思って私は課金してます。

環境構築についてもこのサイトにチュートリアルがあるので、しっかり自分のPCに環境を作ることもできる！

おすすめ度：★★★★☆
URL : https://aiacademy.jp/

EntryNo.3 : aidemy

僕はまだあまり使いこなしていないが、AI・機械学習を勉強することができるサイト。
コース別に技能を習得することができるみたい。
あまり使ってないので、コメントは程々にしておきます。

おすすめ度 : 未知数
URL : https://aidemy.net/

書籍編

書籍で購入したいという方もたくさんいると思います。
僕が購入している書物をいくつか紹介します。

• Python実践データ分析100本ノック
  結構しっかりと勉強することができる。
  データの配布もあり、分析をJupyterで行うことができるのがポイント高め。

• 前処理大全
  どちらかというとStep3であると便利な本。
  辞書的な運用がメインになるけど、あると便利。

• Kaggleで勝つデータ分析の技術
  Step3で紹介しているKaggleで使えるスキルについて書いてある本。
  この本が出版されたときにKaggle上で日本のKagglerのスコアが異常に伸び、日本のKagglerが不正を疑われたとか噂がある本。
  機械学習を志すなら、持っておいて損ないと思う一冊。

• AI白書
  いるかいらないかでいうと微妙だけど、AI市場の動向はわかる。

• 高校数学でわかるディープラーニングのしくみ

• 深層学習教科書 ディープラーニング G検定（ジェネラリスト） 公式テキスト

• 統計学が最強の学問である　数学編

番外編

中学数学からはじめるAI(人工知能)のための数学入門

Youtuberの予備校のノリで学ぶ「大学の数学・物理」（通称：ヨビノリ）が、Aidemyとコラボした動画。
AIや機械学習のうらで動いている数学を解説してくれている動画になっており、しばらく数学とはご無沙汰だなと感じているそこのあなた！是非見てみると良いですよ！

ヨビノリさんのYouTubeチャンネルはこちら

他の動画でも数学などを取り扱っているので、是非見てみてください。

言語処理100本ノック

言語処理にフォーカスをした物
東北大学の乾・岡崎研究室（当時）（現在は乾・鈴木研究室）の新人研修の一つであるプログラミング基礎勉強会で使われてきた物。

Qiita上に答えのようなものが、いくつかあるので自分で勉強していくこともできると思います。

URL : https://nlp100.github.io/ja/

importについて詳しく知りたい...

まにゃpy@Python解説の猫さんのツイートのなかにあった良く分かるimportの話。
今まで、呪文のように唱えていたimportやfrom 〇〇 import ××についてシックリくる形で解説されています。

Pythonのパッケージやモジュールをimportする方法は

import モジュール名
from パッケージ名 import モジュール名
import パッケージ名.モジュール名
from モジュール名 imoport 関数名
import モジュール名 as 〇〇

などがあります。これらの違いを詳しく解説しました。https://t.co/qgqaKs27t9

— まにゃpy@Python解説の猫 (@uuyr112) May 18, 2020

URL : https://twitter.com/uuyr112/status/1262259224903421952?s=20

Step3 : 実際に分析してみよう！

ここまできたあなたは、きっと自分が成し遂げたいことを実現する能力を身につけていると思います。
ここから先の分析の勉強をするにあたって、方法としては大きく分けて、２つあると思います。

1. コンペに参加する。
2. 自分でデータを集める。 ## コンペへの参加 敷居が低いものとしては、コンペに参加することをあげることができます。 コンペとして有名なのは、
3. Kaggle
4. Quevico AI Competitions
5. Signate

などがあると思います。

Kaggle

世界中のデータサイエンティストがしのぎを削るコンペ
最先端のアルゴリズムなどを使っている人もいるため、Kernelというコードを読んでいるだけでもとてもとても勉強になる。
ただ、データサイエンスの領域になると文化的側面やコンペ対象に深い知識がないと難しい。
そういった面で、外国発のコンペということもあって、難しいように感じる。

Step2までとは違って、ほんとに難しい。
これをやるといきなり100点を目指さずに、不完全でも良いからアウトプットをしていくことの大切さを知る。
Kaggleチュートリアルは、いろんな方が出しているので、それをやっていくことで力を伸ばせるのでは？と思っています。

みなさんお馴染みのメルカリについてのコンペもあり、ここから僕は入りました。
メルカリチュートリアル

他に有名ところだとタイタニック号などもありますので、様々なチュートリアルを経てコンペにチャレンジしてみると良いかもしれないです。

Quevico AI Competitions

最近できたコンペ。
Instagramの広告で出てきた。

コンペ数が少ないが、しっかりとstep2で勉強したことが生かせそうなコンペになってる。
言語が日本語なのも、嬉しいポイント

Signate

日本発のデータサイエンスコンペ。
言語が日本語で、コビットチャレンジなどもあって、日本のデータサイエンスの中心地になればなと思っている。
人のkarnelが見れないのが少し残念

自分でデータを集める。

自分でデータを集めるとなったら、やれることは無限大です。
ただ、追加で取得しなければいけない技術として、スクレイピングの技術が必要になります。

スクレイピングは、様々なサイトで勉強できますが、AI academyである程度勉強できるので、一度こちらで勉強してみるのも良いかもしれないです。

個人的に使っているデータ収集の方法

Twitter developer

Twitter APIを取得することができる開発者アカウントの申請をすることができる。
意外とできることが多くて、可能性がすごく大きい。

オープンソースのデータセットが手に入るサイト

自分でいつか使おうと思ってストックしているサイトです。

FineReportさんが公開しているデータ分析に必要なオープンデータ20選から抜粋したものです。

• 日本本統計局
• YouTubeデータセット
• Google Trend Search

番外編

市場調査系レポート

変数選択などのアイディアを得ることができそうなレポートを提供してくれるサイト。
自分でいつか使おうと思ってストックです。

博報堂生活総合研究所

博報堂が、収集したデータがレポート形式で、アップロードされているサイト。

マクロミル

市場調査事例や分析事例がレポート形式でみることができるサイト

DODA

就職状況のレポートをみることができる。

最後に

今まで勉強したサイトなどをリスト化しました。
これで、慌てて記憶の底からなんだったけなーと思わなくてすみそうです。笑
COVITショックがあり、GWあたりから無料で学べるツールサイトが多くなってきて、とても勉強のやりがいがある一方で、自分が目指している業界の競争率が高くなりそうで、焦っています。

今後は動画解析などの技術を身につけて、TikTokの分析とかしてみたいなと思っています。
TikTokのAPIがあるみたいなので、チャレンジしたいと思っています。

最後にここまで長い間読んでくださった方ありがとうございます。

参考文献

紹介サイトまとめ

• Progate様
• Paizaラーニング様
• ドットインストール様
• キカガク様
• AI academy様
• aidemy様
• Youtuberの予備校のノリで学ぶ「大学の数学・物理」様
• 乾・鈴木研究室様
• Kaggle様
• Quevico AI Competitions様
• Signate様
• まにゃpy@Python解説の猫様
• FineReport様
• Twitter developer様
• 日本本統計局様
• YouTubeデータセット様
• Google Trend Search様
• 博報堂生活総合研究所様
• マクロミル様
• DODA様

良質なコンテンツの提供ありがとうございます。
掲載してはいけない内容などありましたら、削除します。

単語の類似性を知る

発話テキストの形態素解析

Python: 日本語テキスト:形態素解析では
「分析対象データの読み込み」と「自然言語処理の前処理の基本」を学びました。
この投稿ではでは、これまでに学んだ内容を活かして、分析対象である「発話データセットの加工の手法」を学びます。
特に、単語の類似性に着目した前処理の実装を行います。

今回のデータセットのフラグには
O破綻ではない発話
T破綻とは言い切れないが違和感のある発話
X明らかにおかしいと感じる発話、の3種類があります。

ここでは、O破綻ではない発話 のフラグを元に処理していきます。

例題で出現する変数について

破綻ではない発話のみを抽出した変数df_label_text_Oの内容（49行目）
index と column が含まれるNumPy配列のndarrayです。

 0                                1
1     O                  すみません、あなたは誰ですか？
24    O           そうなんですか。高校野球がお好きなんですか？
48    O                          甲子園でしょ？
...  ..                              ...
2376  O                           そうですか。

破綻ではない発話データセットを処理する際に用いる変数rowの内容（62行目）
rowは、tolist()を用いて
NumPy配列ndarrayのdf_label_text_OをPythonのリスト型に変換した値です。

[['O', 'すみません、あなたは誰ですか？'], ['O', 'そうなんですか。高校野球がお好きなんですか？'], ['O', '甲子園でしょ？'], ... ['O', 'そうですか。']]

例題はこちら

import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を格納する空のリストを作成
label_text = []

# JSONファイルを1ファイルずつ10ファイル分処理
for file in file_dir[:10]:
    # 読み込み専用モードで読み込み
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)

    # 発話データ配列`turns`から発話内容とフラグを抽出
    for turn in json_data['turns']:
        turn_index = turn['turn-index'] # 発話ターンNo
        speaker = turn['speaker'] # 話者ID
        utterance = turn['utterance'] # 発話内容
        # 先頭行はシステムの発話なので除外
        if turn_index != 0:
            # 人の発話内容を抽出
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    # 破綻かどうかのフラグを抽出
                    a = annotate['breakdown']
                    # フラグと人の発話内容をリストに格納
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# リスト`label_text`をDataFrameに変換
df_label_text = pd.DataFrame(label_text)

# 重複する行を削除
df_label_text = df_label_text.drop_duplicates()

# 破綻ではない発話のみを抽出
df_label_text_O = df_label_text[df_label_text[0] == 'O']

t = Tokenizer()

# 空の破綻ではない発話データセットを作成
morpO = []  # 分かち書きした単語を格納
tmp1 = []
tmp2 = ''

# 1行ずつ読み込み
# .values:indexやcolumnを除いて読み込み
# .tolist:NumPy配列ndarrayをPythonのリスト型に変換
for row in df_label_text_O.values.tolist():
    # 正規表現で数字とアルファベットの大文字・小文字を除去してください
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')

    # Janomeで形態素解析を行います
    for token in t.tokenize(reg_row):
        # 単語の表層系を`morpO`に追加してください
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# 形態素解析した単語を出力
pd.DataFrame(morpO)

単語文書行列とは

自然言語データを解析するには、単語データ（文章データ）を数値データへ変換すればよいと説明しました。
その変換の方法の一つに

単語文書行列（term-document matrix）と呼ばれるものがあります。

単語文書行列とは、文書に出現する単語の頻度 を表形式で表したものです。

各文書に含まれる単語データは形態素解析によって得ることができ
そこから各単語の出現数をカウントして数値データに変換しています。

単語文書行列は、行方向に単語／列方向に文書、もしくはその逆の行方向に文書／列方向に
単語を並べた行列形式で表現されます。

全N種類の単語と全M個の文書があるとき、N行×M列の単語文書行列と呼びます。

図の単語文書行列は、文書1には単語1が2回、単語2が1回、単語3が3回、・・・、単語Nが0回
出現することを表しています。

単語の出現回数をカウントするには

Python標準ライブラリのcollections.Counter()を用いるなど方法はいくつかありますが
ここではscikit-learn（サイキット・ラーン）のCountVectorizer()を用いて
単語文書行列を作成する一例を示します。
CountVectorizer()はテキストを単語に分割し、単語の出現回数を数えます。

from sklearn.feature_extraction.text import CountVectorizer

# `CountVectorizer()`を用いた変換器を生成します
CV = CountVectorizer()
corpus = ['This is a pen.',
          'That is a bot.',]

# `fit_transform()`で`corpus`の学習と、単語の出現回数を配列に変換します
X = CV.fit_transform(corpus)
print(X)

>>> 出力結果
  (0, 2)    1
  (0, 1)    1
  (0, 4)    1
  (1, 0)    1
  (1, 3)    1
  (1, 1)    1

# `get_feature_names()`で学習した単語が入っているリストを確認します
print(CV.get_feature_names())

>>> 出力結果
['bot', 'is', 'pen', 'that', 'this']

# カウントした出現回数を`toarray()`でベクトルに変換して表示します
print(X.toarray())

>>> 出力結果
# 行：`corpus`で与えた文章の順
# 列：`get_feature_names()`で確認した単語の順
[[0 1 1 0 1]
 [1 1 0 1 0]]

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import CountVectorizer


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を格納する空のリストを作成
label_text = []

# JSONファイルを1ファイルずつ10ファイル分処理
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)

    # 発話データ配列`turns`から発話内容とフラグを抽出
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# リスト`label_text`をDataFrameに変換し、重複を削除
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
# 破綻ではない発話のみを抽出
df_label_text_O = df_label_text[df_label_text[0] == 'O']

t = Tokenizer()

# 空の破綻ではない発話データセットを作成
morpO = []
tmp1 = []
tmp2 = ''

# 数字とアルファベットの大文字・小文字を除去
for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    # Janomeで形態素解析
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# リスト形式からNumPy配列へ変換（arrayのほうが計算速度が速いため）
morpO_array = np.array(morpO)

# 単語の出現回数をカウントしてください
cntvecO = CountVectorizer()

# 学習を行い、単語の出現回数を配列に変換してください
morpO_cntvecs = cntvecO.fit_transform(morpO_array)

# ndarray配列に変換
morpO_cntarray = morpO_cntvecs.toarray()

# DataFrame形式で単語の出現回数を表示
# columns（列）：分割した単語
# index（行）：元の発話データ
pd.DataFrame(morpO_cntarray, columns=cntvecO.get_feature_names(),
             index=morpO).head(20)

1文字単語の注意

デフォルトでは1文字の単語はカウントされません。
日本語には1文字でも意味を持つ単語があるので、日本語を扱う場合には注意が必要です。
1文字の単語もカウントするにはCountVectorizer()にtoken_pattern='(?u)\b\w+\b'を指定します。

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

重みあり単語文書行列とは

単語の出現回数（頻度）を値として持つ単語文書行列では
どの文書においても普遍的に出現する単語（例えば「私」「です」など）の出現頻度が高くなる傾向があります。

一方、特定の文書にのみ出現する単語の出現頻度が低くなり
単語から各文書を特徴付けることが難しくなります。
そのため、単語文書行列では

単語の出現頻度 TF（Term Frequency）に
逆文書頻度 IDF（Inverse Document Frequency）を掛けた
TF-IDF 値が多く利用されます。

ある単語のIDF値は、log（総文書数／ある単語が出現する文書数）＋ 1 で計算できます。
例えば、ある単語が全4文書中3文書に含まれていれば
IDF値は log(4／3)＋1≒1.1 となり
特定の文書にのみ出現する単語ほどIDF値が大きくなります。

IDF値が大きいということは、その単語の重要度が高く、その文書の特徴であると言えます。

TFからIDFを計算し、TFとIDFを掛けたTF-IDF値を算出することができます。

以下にTfidfVectorizer()を用いた

TF-IDF値による重みあり単語文書行列を作成する一例を示します。

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer

# 小数点以下を有効数字２桁で表示する
np.set_printoptions(precision=2)
docs = np.array([
    "白　黒　赤", "白　白　黒", "赤　黒"
])

# `TfidfVectorizer()`を用いた変換器を生成します
vectorizer = TfidfVectorizer(use_idf=True, token_pattern="(?u)\\b\\w+\\b")

# `fit_transform()`で`docs`の学習と、重み付けされた単語の出現回数を配列に変換します
vecs = vectorizer.fit_transform(docs)
print(vecs.toarray())
# >> 出力結果
[[ 0.62  0.62  0.48]
[ 0.93  0.    0.36]
[ 0.    0.79  0.61]]

①vectorizer = TfidfVectorizer()で
ベクトル表現化（単語を数値化すること）を行う変換器を生成します。

②use_idf=Falseにすると、tfのみの重み付けになります。

③vectorizer.fit_transform()で、文書をベクトルに変換します。
引数には、空白文字によって分割された（分かち書きされた）配列を与えます。

④toarray()によって出力をNumPyのndarray配列に変換します。

np.set_printoptions()は、NumPy配列の表示のフォーマットを定める関数です。
print()で値を表示する際にのみ有効な設定で元の値は変わりません。

引数precision=には小数点以下の表示桁数を指定します。

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を格納する空のリストを作成
label_text = []

# JSONファイルを1ファイルずつ10ファイル分処理
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)

    # 発話データ配列`turns`から発話内容とフラグを抽出
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# リスト`label_text`をDataFrameに変換し、重複を削除
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
# 破綻ではない発話のみを抽出
df_label_text_O = df_label_text[df_label_text[0] == 'O']

t = Tokenizer()

# 空の破綻ではない発話データセットを作成
morpO = []
tmp1 = []
tmp2 = ''

# 数字とアルファベットの大文字・小文字を除去
for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    # Janomeで形態素解析
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# リスト形式からNumPy配列へ変換（arrayのほうが計算速度が速いため）
morpO_array = np.array(morpO)

# ①ベクトル表現化を行う変換器を生成
tfidf_vecO = TfidfVectorizer(use_idf=True)

# ②単語をベクトル表現に変換
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)

# ③ndarray配列に変換
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# DataFrame形式で単語（ベクトル表現）を表示してください
pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(), 
             index=morpO).head(20)

単語の類似度(相関)を計算

特徴量 とは、そのデータが持つ他のデータとは異なる特徴です。

CountVectorizer()で作成した単語文書行列では単語の出現回数を
TfidfVectorizer()で作成した単語文書行列では単語のTF-IDF値を単語の特徴量としています。

例えば、画像に写っている物体が犬か猫かを見分ける時
まず無意識に耳の形に目がいくのではないでしょうか。

この場合、耳（を含む領域）が特徴量と言えます。
文書分類の問題では、各単語を特徴量として使用し、教師あり学習モデルを作成します。

ここでは上記とは異なる、2つの単語の出現の仕方がどの程度似ているか

つまり類似度を特徴量とした、教師なし学習モデル を作成します。

類似度を測る方法として身近なものは相関係数ですが

その他にベクトル同士の類似度を測る コサイン類似度や
集合同士の類似度を測る Jaccard係数 が有名です。

ここでは、類似度を求めるのにpandas.DataFrameのcorr()メソッドを用い
各列間の相関係数を算出します。

corr()メソッドはデータ型が数値型・ブール型の列が計算対象となり
文字列や欠損値NaNは除外されます。

corr = DataFrame.corr()

corr()の引数には相関係数の算出方法を以下より指定します。

'pearson'：ピアソンの積率相関係数（デフォルト）
'kendall'：ケンドールの順位相関係数
'spearman'：スピアマンの順位相関係数

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を格納する空のリストを作成
label_text = []

# JSONファイルを1ファイルずつ10ファイル分処理
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)

    # 発話データ配列`turns`から発話内容とフラグを抽出
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# リスト`label_text`をDataFrameに変換し、重複を削除
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
# 破綻ではない発話のみを抽出
df_label_text_O = df_label_text[df_label_text[0] == 'O']

t = Tokenizer()

# 空の破綻ではない発話データセットを作成
morpO = []
tmp1 = []
tmp2 = ''

# 数字とアルファベットの大文字・小文字を除去
for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    # Janomeで形態素解析
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# TF-IDF値による重みありの単語文書行列を作成
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# 単語の出現回数をDataFrame形式に変換
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(), 
             index=morpO).head(20)

# 相関行列を作成
corr_matrixO = dtmO.corr().abs()
# `.abs()` は絶対値を求めるメソッドです
# 相関行列の表示
corr_matrixO

単語の類似性から発話の特徴を知る

類似度リストの作成

ここからは、前節で作成した2つの単語の相関係数を特徴量としたネットワーク分析によって
定量的な分析を行っていきます。

ネットワーク分析を行うために、相関係数を行列形式からリスト形式へ変換します。

行列形式をリスト形式に変換するには
pandas.DataFrameのstack()メソッドを用います。

from pandas import DataFrame

# DataFrameを用意
df=DataFrame([[0.1,0.2,0.3],[0.4,'NaN',0.5]],
             columns=['test1','test2','test3'],
             index=['AA','BB'])
print(df)

# >>> 出力結果
      test1      test2      test3
AA       0.1       0.2       0.3
BB       0.4       NaN       0.5
# stack : 列から行への変換
print(df.stack())

# >>> 出力結果
AA   test1    0.1
     test2    0.2
     test3    0.3
BB   test1    0.4
     test2    NaN
     test3    0.5
# unstack ： 行から列への変換
print(df.unstack())

# >>> 出力結果
test1  AA    0.1
       BB    0.4
test2  AA    0.2
       BB    NaN
test3  AA    0.3
       BB    0.5

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を抽出したリストを作成
label_text = []
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# 重複を削除し、破綻ではない発話のみを抽出
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']

# Janomeによる形態素解析
t = Tokenizer()

morpO = []
tmp1 = []
tmp2 = ''

for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# TF-IDF値による重みありの単語文書行列を作成
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# DataFrame形式に変換し、相関行列を作成
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(), 
             index=morpO)
corr_matrixO = dtmO.corr().abs()

# 相関行列`corr_matrixO`を列方向から行方向へ変換してください
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)

# 相関係数が0.5以上1.0未満のものを抽出
tmp3 = [] # 相関係数が0.5以上1.0未満の値を持つindex値のリスト
tmp4 = [] # 相関係数が0.5以上1.0未満のvalue値のリスト

for i in range(0, len(index)):
    if value[i] >= 0.5 and value[i] < 1.0:
        tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
        tmp2 = [s for s in tmp1.split()]
        tmp3.append(tmp2)
        tmp4 = np.append(tmp4, value[i])

tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})

# DataFrame`tmp3`と`tmp4`を横方向に連結してください
df_corlistO = pd.concat([tmp3, tmp4], axis=1)

# 作成したDataFrameを表示
df_corlistO.head(20)

類似度ネットワークの作成

ネットワークは対象と対象の 関係を表現する方法の一つです。
有名な例として、SNSにおける友だち関係のネットワークがあります。

ネットワーク構造では
対象はノードで
関係はエッジで表現されます。

エッジは重みを持ち、友だち関係のネットワークにおいては親密度にあたります。
親密であればあるほど重みの値は大きくなります。

他にも、路線図や航空網、単語の共起・類似関係もネットワークで表現できます。

前節で作成した類似度リストのように、エッジに方向の概念がなく関係性のない言語群を可視化するには

無向グラフ（または 無向ネットワーク）を利用します。

なお、重み付きのグラフをネットワークとも呼びます。

無向グラフとは、ネットワークを構成するエッジが方向性を持たないものです。
それとは逆に、エッジが方向性を持つものを

有向グラフ（または有向ネットワーク）と呼びます。

無向グラフ（無向ネットワーク）の作成

Pythonには NetworkX と呼ばれるライブラリがあります。
本セクションではこのライブラリを用いて、前節で作成した類似度リストの可視化を行います。

# ライブラリ`NetworkX`をimport
import networkx as nx

# 無向グラフの作成
network = nx.from_pandas_edgelist(df, source='source', target='target', edge_attr=None, create_using=None)

①df：グラフの元となるPandasのDataFrame名

②source：ソースノードの列名
str（文字列型）またはint（整数型）で指定する

③target：対象ノードの列名
strまたはintで指定する

④edge_attr：それぞれのデータのエッジ（重み）
strまたはint、iterable、Trueで指定する

⑤create_using：グラフのタイプ（オプション）

無向グラフ：nx.Graph（デフォルト）
有向グラフ：nx.DiGraph

グラフ（ネットワーク）の可視化

# ライブラリ`Matplotlib`から`pyplot`をimport
from matplotlib import pyplot

# 各ノードの最適な表示位置を計算
pos = nx.spring_layout(graph)

# グラフを描画
nx.draw_networkx(graph, pos)

# Matplolibを用いてグラフを表示
plt.show()

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を抽出したリストを作成
label_text = []
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# 重複を削除し、破綻ではない発話のみを抽出
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']

# Janomeによる形態素解析
t = Tokenizer()

morpO = []
tmp1 = []
tmp2 = ''

for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# TF-IDF値による重みありの単語文書行列を作成
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# DataFrame形式に変換し、相関行列を作成
dtmO = pd.DataFrame(morpO_tfidf_array)

corr_matrixO = dtmO.corr().abs()

# 破綻ではない発話データセットの作成
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)

tmp3 = []
tmp4 = []
for i in range(0, len(index)):
    if value[i] >= 0.5 and value[i] < 1.0:
        tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
        tmp2 = [int(s) for s in tmp1.split()]
        tmp3.append(tmp2)
        tmp4 = np.append(tmp4, value[i])

tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)

# ①無向グラフを作成
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])

# ②作成したグラフを可視化
# レイアウトの設定
pos = nx.spring_layout(G_corlistO)
nx.draw_networkx(G_corlistO, pos)
plt.show()

類似度ネットワークの特徴

前節で可視化したグラフのように、実際のネットワークは複雑な構造が多いため
一見して特徴を把握することは困難です。

このような場合には、何らかの指標をもって定量的に特徴を把握します。
その指標には、ネットワーク全体を把握するためのもの（大域的）もあれば
あるノードに着目して把握するもの（局所的）もあります。

一般的に使用されている指標の例をいくつか挙げます。

次数：ノードが持つエッジの本数を表します。
次数分布：ある次数を持つノード数のヒストグラムを表します。
クラスタ係数：ノード間がどの程度密に繋がっているかを表します。
経路長：あるノードから他のノードへ至るまでの距離です。
中心性：あるノードがネットワークにおいて中心的な役割を果たす度合いを表します。

それでは、前節で作成したネットワークについて、クラスタ係数と媒介中心性を計算し
特徴を見ていきます。

このネットワークでは
クラスタ係数は単語間のつながり密度を
媒介中心性はネットワークにおける単語のハブ度合いを表します。

破綻ではない発話と破綻である発話、それぞれのネットワークにおいて平均クラスタ係数を比較すると
破綻である発話の単語のほうが密につながっていることが分かります。

また、媒介中心性の高い上位5単語を比較してみると
破綻ではない発話にはお盆休みに関する単語が
破綻である発話には早朝の野球に関する単語が中心的な役割を果たしていると推測できます。

①破綻ではない発話
<平均クラスタ係数>　0.051924357
<媒介中心性の高い上位5単語>
　休み、お盆、ここ、少ない、明け

②破綻である発話
<平均クラスタ係数>　0.069563257
<媒介中心性の高い上位5単語>
　今度、ましょ、野球、早朝、かれ

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を抽出したリストを作成
label_text = []
for file in file_dir[:10]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# 重複を削除し、破綻ではない発話のみを抽出
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']

# Janomeによる形態素解析
t = Tokenizer()

morpO = []
tmp1 = []
tmp2 = ''

for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# TF-IDF値による重みありの単語文書行列を作成
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# DataFrame形式に変換し、相関行列を作成
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(), 
             index=morpO)
corr_matrixO = dtmO.corr().abs()

# 破綻ではない発話データセットの作成
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)

tmp3 = []
tmp4 = []
for i in range(0, len(index)):
    if value[i] >= 0.5 and value[i] < 1.0:
        tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
        tmp2 = [s for s in tmp1.split()]
        tmp3.append(tmp2)
        tmp4 = np.append(tmp4, value[i])

tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)

# 無向グラフを作成
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])

# 破綻ではない発話データセットに対して
# ①平均クラスタ係数の計算
print('平均クラスタ係数')
print(nx.average_clustering(G_corlistO, weight='weight'))
print()

# ②媒介中心性の計算
bc = nx.betweenness_centrality(G_corlistO, weight='weight')
print('媒介中心性')
for k, v in sorted(bc.items(), key=lambda x: -x[1]):
    print(str(k) + ': ' + str(v))

平均クラスタ係数の計算

すべてのノードのクラスタ係数の平均が高いほど、そのネットワークは密であると言えます。
クラスタ係数の平均はnx.average_clustering()を用いて算出します。

nx.average_clustering(G, weight=None)

①G
graphを指定します。
（前節で作成した無向グラフG_corlistOのこと）

②weight
重みとして使用する数値を持つエッジを指定します。Noneの場合、各エッジの重みは1になります。

媒介中心性の計算

あるノードがすべてのノード間の最短経路中にいくつ含まれているかによって求められます。
つまり、情報を効率的に伝える際に最も利用されるノードほど媒介性が高く、中心的であると言えます。

nx.betweenness_centrality(G, weight=None)

①G
graphを指定します。
（前節で作成した無向グラフG_corlistOのこと）

②weight
重みとして使用する数値を持つエッジを指定します。Noneの場合、すべてのエッジの重みは等しいとみなされます。

類似度ネットワークのトピック抽出

一つのネットワークは、複数の部分ネットワーク（＝コミュニティ）によって成り立っています。
コミュニティ内の各ノードは、エッジで密につながっていることが特徴です。

一つのネットワークの疎なエッジを取り除くと部分ネットワークに分割できます。
つまり、コミュニティが抽出できる＝類似度の高いネットワークの抽出ができるということです。

ネットワークの分割には

モジュラリティ（Modularity）と呼ばれる指標を用います。

モジュラリティは
「一つのネットワークの総エッジ数に対するコミュニティ内のエッジ数の割合」から
「一つのネットワークのすべてのノードの出次数の合計（ネットワークのエッジ数 × 2 と等しい）に対する
コミュニティ内のノードの出次数の合計の割合」を引いた値で、分割の質を定量化します。

モジュラリティの値が大きいほど、コミュニティ内のノードは密につながっていると言えます。

それでは、モジュラリティを用いてコミュニティを抽出してみます。
破綻ではない発話と破綻である発話、それぞれのネットワークにおいて
所属するノード数が最も多いコミュニティの単語を確認すると以下のような結果を得ました。

①破綻ではない発話
お盆，しまい，ついつい，休み，切れ，困り，少ない，帰省，忘れ，怠け者，明け，続く，連休，集中

②破綻である発話
お願い，くらい，ぐらい，それから，とる，どの，はまっ，もちろん，よい，作業，偏ら，割り勘，危険，待っ，心掛け，時間，栄養，油断，睡眠，食事

破綻ではない発話には、例えば「お盆休みが少なくて帰省に困る」「連休が続くと休み明けに怠ける」などの
トピックがありそうだと推測できます。

破綻である発話には、例えば「食事の栄養が偏らないように心がける」「十分な時間の睡眠をとる」などの
トピックがありそうです。

同様に、他のコミュニティにもどのようなトピックが含まれているか単語から推測できるはずです。

モジュラリティを用いたコミュニティの抽出

greedy_modularity_communities(G, weight=None)

①G
graphを指定します。
（前節で作成した無向グラフG_corlistOのこと）

②weight
重みとして使用する数値を持つエッジを指定します。Noneの場合、すべてのエッジの重みは等しいとみなされます。

使用例はこちら

import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt
from networkx.algorithms.community import greedy_modularity_communities


# init100ディレクトリを指定
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)

# フラグと発話内容を抽出したリストを作成
label_text = []
for file in file_dir[:20]:
    r = open(file_path + file, 'r', encoding='utf-8')
    json_data = json.load(r)
    for turn in json_data['turns']:
        turn_index = turn['turn-index']
        speaker = turn['speaker']
        utterance = turn['utterance']
        if turn_index != 0:
            if speaker == 'U':
                u_text = ''
                u_text = utterance
            else:
                a = ''
                for annotate in turn['annotations']:
                    a = annotate['breakdown']
                    tmp1 = str(a) + '\t' + u_text
                    tmp2 = tmp1.split('\t')
                    label_text.append(tmp2)

# 重複を削除し、破綻ではない発話のみを抽出
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']

# Janomeによる形態素解析
t = Tokenizer()

morpO = []
tmp1 = []
tmp2 = ''

for row in df_label_text_O.values.tolist():
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')
    for token in t.tokenize(reg_row):
        tmp1.append(token.surface)
        tmp2 = ' '.join(tmp1)
    morpO.append(tmp2)
    tmp1 = []

# TF-IDF値による重みありの単語文書行列を作成
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()

# DataFrame形式に変換し、相関行列を作成
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(), 
             index=morpO)
corr_matrixO = dtmO.corr().abs()

# 破綻ではない発話データセットの作成
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)

tmp3 = []
tmp4 = []
for i in range(0, len(index)):
    if value[i] >= 0.5 and value[i] < 1.0:
        tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
        tmp2 = [s for s in tmp1.split()]
        tmp3.append(tmp2)
        tmp4 = np.append(tmp4, value[i])

tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)

# 無向グラフを作成
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])

# 破綻ではない発話データセットに対して
# コミュニティ抽出
cm_corlistO = list(greedy_modularity_communities(G_corlistO, weight='weight'))

# 各コミュニティに属するノードの表示
cm_corlistO

内容

前回入力データの分割方法に改良が必要なのでは？と感じたため、様々な分割方法を試してみる。入力データは前回同様某ラッパーの歌詞を使用。一応検証用として自分が温めていた韻をテーマにしたものも用意している。

分かち書きの場合

import MeCab

mecab = MeCab.Tagger("-Owakati")
mecab_text = mecab.parse(data).split()

歌詞通りの「韻」を抽出できている部分もあるが、「数万円」で踏んでいるところが分かち書きによって「数、万、円」と分割されているため認識できていない。余談だが、kakashiのconv.doに一度に多くのデータは渡せないようだ。text_data = [conv.do(text) for text in mecab_text]とした。ちなみに分かち書き後、母音に変換したwordの長さは最大8文字、平均2.16文字であった。細かく分け過ぎているので、分かち書きでの分割は適していないと言える。
このMeCabを使えるようにするまでに何回も挫けた。色んな記事を見過ぎたのかもしれない。こちらに感謝

N-gramの場合

では、単にN文字ごとに分割していくとどうなるだろう。Nは４から試してみる。

def make_ngram(words, N):
    ngram = []
    for i in range(len(words)-N+1):
        #全角スペースと改行を取り除く
        row = "".join(words[i:i+N]).replace("\u3000","").replace("\n","")
        ngram.append(row)
    return ngram

体感だが、Nは５かそれ以上が良さそうである。（４以下だとスコアの差が付かない）そこそこ歌詞通りに韻を検出できている。試しに検証用データを入れてみると、一見気づかない韻が検出できた。wordが様々な切り取られ方をするのだから、スコアの付け方を変えてみる。

def make_score_ngram(word_a, word_b):
    score = 0
    for i in range(len(word_a)):
        if word_a[-i:] == word_b[-i:]:
            score += i
     return score

母音の一致を語尾から見ることによって、出力が見やすい。Nの値についてはlen(target_word_vo)(韻を探す元の言葉の母音の長さ)が良いだろう。自分がやりたいことが表現できてしまったような気がしている。
折角苦労してMeCabを使用できるようにして、「韻の数値化」も自分なりに考えたので、使いたい。この２つを組み合わせてみる。

target_wordが絞れるのでは？！

「韻の数値化」では母音が合致する部分を探索し、合致している長さlen(word[i:j)をスコアにしていた。このword[i:j]は「eoi」等の形をしており、この出現回数をカウントすれば、入力データ中で一番登場する母音が分かるはずだ。それを含む言葉をtarget_wordに指定すれば、多くのレコメンドが見込めるという考えである。申し訳程度に分かち書きと検証用に用意したテキストを使う。

from pykakasi import kakasi
import re
from collections import defaultdict
import MeCab

with open("./test.txt","r",encoding="utf-8") as f:
    data = f.read()

mecab = MeCab.Tagger("-Owakati")
mecab_text = mecab.parse(data).split()

kakasi = kakasi()

kakasi.setMode('H', 'a')
kakasi.setMode('K', 'a')
kakasi.setMode('J', 'a')

conv = kakasi.getConverter()
text_data = [conv.do(text) for text in mecab_text]
vowel_data = [re.sub(r"[^aeiou]+","",text) for text in text_data]
dic_vo = {k:v for k,v in enumerate(vowel_data)}
#voel_dataのインデックスで母音変換前のdataが分かるように辞書作成。
dic = {k:v for k,v in enumerate(mecab_text)}

#新たなキーを追加する際に初期化を省きたいためdefaultdictを使用{母音:出現回数}
dic_rhyme = defaultdict(int)
for word_a in vowel_data:
    for word_b in vowel_data:
        if len(word_a) > len(word_b):
            word_len = len(word_b)
            for i in range(word_len):
                for j in range(word_len + 1):
                    #カウントするのは２文字以上に限定
                    if word_b[i:j] in word_a and not len(word_b[i:j])<2:
                        dic_rhyme[word_b[i:j]] +=　1
        else:
            word_len = len(word_a)
            for i in range(word_len):
                for j in range(word_len + 1):
                    if word_a[i:j] in word_b and not len(word_a[i:j])<2:
                        dic_rhyme[word_a[i:j]] += 1
#カウントが多かった順にソート
dic_rhyme = sorted(dic_rhyme.items(), key=lambda x:x[1], reverse=True)
print(dic_rhyme)
#dic_rhymeの上位にきたものが含まれているものを探索。ここでは"ai"を使用
bool_index = ["ai" in text for text in vowel_data]

for i in range(len(vowel_data)):
    if bool_index[i]:
        print(dic[i])

登場頻度の高い母音の並びを取得し、どこで使われているか出力できた。しかしながら、分かち書きで細分化された言葉は分かりにくくなっていた。もしかしたら、もう少し長い韻があった可能性もある。

改良点

target_wordを絞るという用途では必要性を感じないが（自分が一番言いたいことを指定したいため）、どの母音の並びが頻出なのかは確認できても良いかもしれない。分かち書きで上手くいかなかったが、MeCabを利用して（何度もいうが、使えるようになるまで四苦八苦した）改良したい。
また、N-gramを採用したことによって「韻の数値化」も簡潔にできたので、もう少し複雑に「韻」を定義し直せないか考える。（現状「っ」など考慮していない）
しかし、回り道をした。「韻の数値化」は韻を漏らさないよう、入力データに対応できるよう、自分なりに考え抜いたつもりのものだ。まさか引数を様々にスライスすることが入力データを様々にスライス（表現が違うかもしれません）で解決できるとは…というかそれに気付かないとは。基本が大事ですね。でもN-gramって意味のない日本語が出来ると感じませんか？ただ、「韻」の部分を強調して発音する等やり方はあるんです。やはり、簡単なデータ使ってとにかくやってみることが大事ってことですわ。

はじめに

自然言語処理の問題集として有名な自然言語処理100本ノックの2020年版が4/6に公開されました。
この記事では、以下の第1章から第10章のうち、第2章: UNIXコマンドを解いてみた結果をまとめています。

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

事前準備

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

第2章: UNIXコマンド

popular-names.txtは，アメリカで生まれた赤ちゃんの「名前」「性別」「人数」「年」をタブ区切り形式で格納したファイルである．以下の処理を行うプログラムを作成し，popular-names.txtを入力ファイルとして実行せよ．さらに，同様の処理をUNIXコマンドでも実行し，プログラムの実行結果を確認せよ．

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

!wget https://nlp100.github.io/data/popular-names.txt

【 wget 】コマンド――URLを指定してファイルをダウンロードする

10. 行数のカウント

行数をカウントせよ．確認にはwcコマンドを用いよ．

早速問題を解いていきます。
今回はpandasのデータフレームとして読み込んでから各問の処理を行っていきます。また、問題文の指示に従い、コマンドでの結果の確認も行っています。

import pandas as pd

df = pd.read_table('./popular-names.txt', header=None, sep='\t', names=['name', 'sex', 'number', 'year'])
print(len(df))

# 確認
!cat ./popular-names.txt | wc -l

pandasでcsv/tsvファイル読み込み
pandasで行数、列数、全要素数（サイズ）を取得
【 cat 】コマンド――設定ファイルの内容を簡単に確認する
【 wc 】コマンド――テキストファイルの文字数や行数を数える

11. タブをスペースに置換

タブ1文字につきスペース1文字に置換せよ．確認にはsedコマンド，trコマンド，もしくはexpandコマンドを用いよ．

本問は、元データの区切り文字であるタブの置換を想定していると思われるため、すでに読み込んでいるデータフレームでは実施せず、コマンドでの確認のみ行っています。

# 確認
!sed -e 's/\t/ /g' ./popular-names.txt

【 sed 】コマンド（基礎編その4）――文字列を置き換える／置換した行を出力する

12. 1列目をcol1.txtに，2列目をcol2.txtに保存

各行の1列目だけを抜き出したものをcol1.txtに，2列目だけを抜き出したものをcol2.txtとしてファイルに保存せよ．確認にはcutコマンドを用いよ．

col1 = df['name'].copy()
col1.to_csv('./col1.txt', index=False)

# 確認
!cut -f 1 ./popular-names.txt > ./col1_chk.txt
!cat ./col1_chk.txt

col2 = df['sex'].copy()
col2.to_csv('./col2.txt', index=False)

# 確認
!cut -f 2 ./popular-names.txt > ./col2_chk.txt
!cat ./col2_chk.txt

pandasのインデックス参照で行・列を選択し取得
pandasでcsvファイルの書き出し
【 cut 】コマンド――行から固定長またはフィールド単位で切り出す
コマンドの実行結果・標準出力をファイルに保存

13. col1.txtとcol2.txtをマージ

12で作ったcol1.txtとcol2.txtを結合し，元のファイルの1列目と2列目をタブ区切りで並べたテキストファイルを作成せよ．確認にはpasteコマンドを用いよ．

col1 = pd.read_table('./col1.txt')
col2 = pd.read_table('./col2.txt')
merged_1_2 = pd.concat([col1, col2], axis=1)
merged_1_2.to_csv('./merged_1_2.txt', sep='\t', index=False)

# 確認
!paste ./col1_chk.txt ./col2_chk.txt

pandas.DataFrame, Seriesを連結する
【 paste 】コマンド――複数のファイルを行単位で連結する

14. 先頭からN行を出力

自然数Nをコマンドライン引数などの手段で受け取り，入力のうち先頭のN行だけを表示せよ．確認にはheadコマンドを用いよ．

def output_head(N):
  print(df.head(N))
output_head(10)

# 確認
!head -n 10 ./popular-names.txt

Pythonで関数を定義・呼び出し
pandas.DataFrame, Seriesの先頭・末尾の行を返す
【 head 】コマンド／【 tail 】コマンド――長いメッセージやテキストファイルの先頭だけ／末尾だけを表示する

15. 末尾のN行を出力

自然数Nをコマンドライン引数などの手段で受け取り，入力のうち末尾のN行だけを表示せよ．確認にはtailコマンドを用いよ．

def output_tail(N):
  print(df.tail(N))
output_tail(10)

# 確認
!tail -n 10 ./popular-names.txt

16. ファイルをN分割する

自然数Nをコマンドライン引数などの手段で受け取り，入力のファイルを行単位でN分割せよ．同様の処理をsplitコマンドで実現せよ．

いろいろなやり方があると思いますが、ここではレコードの通番に対して、対象の数値の大きさで等分するqcutを適用することでファイルをN分割しています。

def split_file(N):
  tmp = df.reset_index(drop=False)
  df_cut = pd.qcut(tmp.index, N, labels=[i for i in range(N)])
  print(df_cut.value_counts())
  df_cut = pd.concat([df, pd.Series(df_cut, name='sp')], axis=1)
  return df_cut
df_cut = split_file(10)
print(df_cut.head())

# 確認
!split -l 200 -d ./popular-names.txt sp

pandas.DataFrame, Seriesのインデックスを振り直す
pandasのcut, qcut関数でビニング処理（ビン分割）
pandasでユニークな要素の個数、頻度（出現回数）をカウント
【 split 】コマンド――ファイルを分割する

17. １列目の文字列の異なり

1列目の文字列の種類（異なる文字列の集合）を求めよ．確認にはcut, sort, uniqコマンドを用いよ．

print(len(df.drop_duplicates(subset='name')))

# 確認
!cut -f 1 ./popular-names.txt | sort | uniq | wc -l

pandas.DataFrame, Seriesの重複した行を抽出・削除
【 sort 】コマンド――テキストファイルを行単位で並べ替える
【 uniq 】コマンド――重複している行を削除する

18. 各行を3コラム目の数値の降順にソート

各行を3コラム目の数値の逆順で整列せよ（注意: 各行の内容は変更せずに並び替えよ）．確認にはsortコマンドを用いよ（この問題はコマンドで実行した時の結果と合わなくてもよい）．

df.sort_values(by='number', ascending=False, inplace=True)
print(df.head())

# 確認
!cat ./popular-names.txt | sort -rnk 3

pandas.DataFrame, Seriesをソートする

19. 各行の1コラム目の文字列の出現頻度を求め，出現頻度の高い順に並べる

各行の1列目の文字列の出現頻度を求め，その高い順に並べて表示せよ．確認にはcut, uniq, sortコマンドを用いよ．

print(df['name'].value_counts().sort_values(ascending=False))

# 確認
!cut -f 1 ./popular-names.txt | sort | uniq -c | sort -rn

おわりに

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

はじめに

自然言語処理の問題集として有名な自然言語処理100本ノックの2020年版が4/6に公開されました。
この記事では、以下の第1章から第10章のうち、第2章: UNIXコマンドを解いてみた結果をまとめています。

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

事前準備

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

第2章: UNIXコマンド

popular-names.txtは，アメリカで生まれた赤ちゃんの「名前」「性別」「人数」「年」をタブ区切り形式で格納したファイルである．以下の処理を行うプログラムを作成し，popular-names.txtを入力ファイルとして実行せよ．さらに，同様の処理をUNIXコマンドでも実行し，プログラムの実行結果を確認せよ．

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

!wget https://nlp100.github.io/data/popular-names.txt

【 wget 】コマンド――URLを指定してファイルをダウンロードする

10. 行数のカウント

行数をカウントせよ．確認にはwcコマンドを用いよ．

早速問題を解いていきます。
今回はpandasのデータフレームとして読み込んでから各問の処理を行っていきます。また、問題文の指示に従い、コマンドでの結果の確認も行っています。

import pandas as pd

df = pd.read_table('./popular-names.txt', header=None, sep='\t', names=['name', 'sex', 'number', 'year'])
print(len(df))

# 確認
!cat ./popular-names.txt | wc -l

pandasでcsv/tsvファイル読み込み
pandasで行数、列数、全要素数（サイズ）を取得
【 cat 】コマンド――設定ファイルの内容を簡単に確認する
【 wc 】コマンド――テキストファイルの文字数や行数を数える

11. タブをスペースに置換

タブ1文字につきスペース1文字に置換せよ．確認にはsedコマンド，trコマンド，もしくはexpandコマンドを用いよ．

本問は、元データの区切り文字であるタブの置換を想定していると思われるため、すでに読み込んでいるデータフレームでは実施せず、コマンドでの確認のみ行っています。

# 確認
!sed -e 's/\t/ /g' ./popular-names.txt

【 sed 】コマンド（基礎編その4）――文字列を置き換える／置換した行を出力する

12. 1列目をcol1.txtに，2列目をcol2.txtに保存

各行の1列目だけを抜き出したものをcol1.txtに，2列目だけを抜き出したものをcol2.txtとしてファイルに保存せよ．確認にはcutコマンドを用いよ．

col1 = df['name'].copy()
col1.to_csv('./col1.txt', index=False)

# 確認
!cut -f 1 ./popular-names.txt > ./col1_chk.txt
!cat ./col1_chk.txt

col2 = df['sex'].copy()
col2.to_csv('./col2.txt', index=False)

# 確認
!cut -f 2 ./popular-names.txt > ./col2_chk.txt
!cat ./col2_chk.txt

pandasのインデックス参照で行・列を選択し取得
pandasでcsvファイルの書き出し
【 cut 】コマンド――行から固定長またはフィールド単位で切り出す
コマンドの実行結果・標準出力をファイルに保存

13. col1.txtとcol2.txtをマージ

12で作ったcol1.txtとcol2.txtを結合し，元のファイルの1列目と2列目をタブ区切りで並べたテキストファイルを作成せよ．確認にはpasteコマンドを用いよ．

col1 = pd.read_table('./col1.txt')
col2 = pd.read_table('./col2.txt')
merged_1_2 = pd.concat([col1, col2], axis=1)
merged_1_2.to_csv('./merged_1_2.txt', sep='\t', index=False)

# 確認
!paste ./col1_chk.txt ./col2_chk.txt

pandas.DataFrame, Seriesを連結する
【 paste 】コマンド――複数のファイルを行単位で連結する

14. 先頭からN行を出力

自然数Nをコマンドライン引数などの手段で受け取り，入力のうち先頭のN行だけを表示せよ．確認にはheadコマンドを用いよ．

def output_head(N):
  print(df.head(N))
output_head(10)

# 確認
!head -n 10 ./popular-names.txt

Pythonで関数を定義・呼び出し
pandas.DataFrame, Seriesの先頭・末尾の行を返す
【 head 】コマンド／【 tail 】コマンド――長いメッセージやテキストファイルの先頭だけ／末尾だけを表示する

15. 末尾のN行を出力

自然数Nをコマンドライン引数などの手段で受け取り，入力のうち末尾のN行だけを表示せよ．確認にはtailコマンドを用いよ．

def output_tail(N):
  print(df.tail(N))
output_tail(10)

# 確認
!tail -n 10 ./popular-names.txt

16. ファイルをN分割する

自然数Nをコマンドライン引数などの手段で受け取り，入力のファイルを行単位でN分割せよ．同様の処理をsplitコマンドで実現せよ．

いろいろなやり方があると思いますが、ここではレコードの通番に対して、対象の数値の大きさで等分するqcutを適用することでファイルをN分割しています。

def split_file(N):
  tmp = df.reset_index(drop=False)
  df_cut = pd.qcut(tmp.index, N, labels=[i for i in range(N)])
  print(df_cut.value_counts())
  df_cut = pd.concat([df, pd.Series(df_cut, name='sp')], axis=1)
  return df_cut
df_cut = split_file(10)
print(df_cut.head())

# 確認
!split -l 200 -d ./popular-names.txt sp

pandas.DataFrame, Seriesのインデックスを振り直す
pandasのcut, qcut関数でビニング処理（ビン分割）
pandasでユニークな要素の個数、頻度（出現回数）をカウント
【 split 】コマンド――ファイルを分割する

17. １列目の文字列の異なり

1列目の文字列の種類（異なる文字列の集合）を求めよ．確認にはcut, sort, uniqコマンドを用いよ．

print(len(df.drop_duplicates(subset='name')))

# 確認
!cut -f 1 ./popular-names.txt | sort | uniq | wc -l

pandas.DataFrame, Seriesの重複した行を抽出・削除
【 sort 】コマンド――テキストファイルを行単位で並べ替える
【 uniq 】コマンド――重複している行を削除する

18. 各行を3コラム目の数値の降順にソート

各行を3コラム目の数値の逆順で整列せよ（注意: 各行の内容は変更せずに並び替えよ）．確認にはsortコマンドを用いよ（この問題はコマンドで実行した時の結果と合わなくてもよい）．

df.sort_values(by='number', ascending=False, inplace=True)
print(df.head())

# 確認
!cat ./popular-names.txt | sort -rnk 3

pandas.DataFrame, Seriesをソートする

19. 各行の1コラム目の文字列の出現頻度を求め，出現頻度の高い順に並べる

各行の1列目の文字列の出現頻度を求め，その高い順に並べて表示せよ．確認にはcut, uniq, sortコマンドを用いよ．

print(df['name'].value_counts().sort_values(ascending=False))

# 確認
!cut -f 1 ./popular-names.txt | sort | uniq -c | sort -rn

おわりに

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

1. はじめに

• インタラクティブなグラフは、数値の挙動を確認する時に何かと便利です。
• また、３Dのグラフを表示した際には、インタラクティブに見る方向を変えられると便利です。
• Jupyter notebookを使っていた頃は、ipywidgetという仕組みを使って、インタラクティブに動くグラフを作れたのですが、現時点ではJupyterLabでは対応していないように思います。
• JupyterLab上でこのような仕組みについて紹介した記事が、私が調べた限りではあまり多くはなかったように思いましたので、投稿してみようと思いました。

2. 概要

• matplotlibのwidgetという仕組みを使うと、GUI backendに依存せずに、Axesに配置するような形でインタラクティブなWidgetを作ることが可能です。

• 以下、widgetのドキュメントからの抜粋です。

Widgets that are designed to work for any of the GUI backends. All of these widgets require you to predefine a matplotlib.axes.Axes instance and pass that as the first arg.

• JupyterLab上で、こんな感じのグラフが簡単に作れます。（このグラフはブラウザのJupyerLab上で動いています。）

3. 具体的なやり方

　ということで、上のようなグラフの作成方法をご説明します。なお、以下をJupyterLab上で作りましたが、先ほどのご説明の通り、matplotlib.widgetはGUI Backendに依存しないということなので、Jupyter notebookはもちろん、LinuxやWindows, MacのGUI上でも同様の結果になるものと思います。（手元では試してませんが）

(1) 必要なライブラリをインポート

まず、必要なライブラリのインポートを行います。また、バックエンドをwidgetに設定する必要があります。

%matplotlib widget
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.widgets import Slider
import numpy as np

(2) サンプルとして表示するデータを作成

ここでは、例として、$z=x^2+2y^2$のグラフを書いてみることにします。

x = y = np.arange(-20, 20, 0.5)
X, Y = np.meshgrid(x, y)
Z = X*X + 2 * Y*Y

(3) Figureを作成

　ご存知の通り、Figureは、matplotlibでグラフを書くキャンパスのようなものです。Figureの上にAxesを載せ、その上にPlotをしていくイメージです。

# Figureの設定
fig = plt.figure(figsize=(5,5))

(4) Axesの作成

次に、Figure上にAxesを作成します。

• 今回は、３Dグラフのプロット用のAxesを１つ、Slider表示用のAxesを２つ作成します。
• どんなやり方でもいいのですが、今回はgridspecを使ってみました、
• 下をコードを実行することで、図のように、Figureを20x20に分割し、1-17行目に３Dグラフ描写用のAxesを、18, 19行目にそれぞれSlider用のAxesを配置できます。

# Figureの中に３Dグラフ、Slider用のAxesを追加
axcolor = 'gold'
gs = fig.add_gridspec(20, 20)
ax1 = fig.add_subplot(gs[:17,:], projection='3d')
ax_slider_z = fig.add_subplot(gs[18,:], facecolor=axcolor)
ax_slider_xy = fig.add_subplot(gs[19,:], facecolor=axcolor)

(5) Sliderの設定

次に、Sliderオブジェクトを作成します。以下のコードでは、

• slider_zとslider_xyというSiderオブジェクトを作成し、それぞれ、上で作成したax_slider_z, ax_slider_xy上に描写
• Sliderの動く範囲は-180〜180
• Sliderの初期値としてz0(=0)を設定
• Sliderの動く幅としてdelta(=10)を設定

を行っています。

# Sliderの設定
z0 = 0
xy0 = 0
delta = 10
slider_z = Slider(ax_slider_z, 'z-axis', -180, 180, valinit=z0, valstep=delta)
slider_xy = Slider(ax_slider_xy, 'xy-axis', -180, 180, valinit=xy0, valstep=delta)

(6) 3Dグラフの見る角度の初期値を設定後、３Dグラフを表示。

次に、３Dグラフの、z軸周り、xy平面周りの見える角度の初期値を設定します。この数値を変化させることで、３Dグラフの見る角度を動かすことができます。

# 3Dグラフの見る方向の初期値を設定
ax1.view_init(elev=z0, azim=xy0)

# 3Dグラフを表示
ax1.plot_surface(X, Y, Z)

(7) Sliderを動かした時に呼ばれるコールバック関数を作成

次に、Sliderを動かした時に呼ばれるコールバック関数を作成します。ここで、３Dグラフを見る角度を指定し、グラフを再描写することで動くグラフを作成することができます。

# Sliderを動かした時に呼ばれるコールバック関数
def view_change(val):

    sz = slider_z.val
    sxy = slider_xy.val
    ax1.view_init(elev=sxy, azim=sz)
    fig.canvas.draw_idle()    

(8) コールバック関数の設定

最後に、Sliderオブジェクトに先ほど作成したコールバック関数を設定します。

slider_z.on_changed(view_change)
slider_xy.on_changed(view_change)
plt.show()

以上で、JupyterLab上で簡単に動くグラフを作成することができます！
こちらにgistも置いておきましたので、よろしければお使いください。（上でご説明したものと同じですが。。。）

対象者

前回の記事の続きです。
本記事では前回の記事のgraph_plot.pyを元に話題をPythonのリストや条件分岐、ループ処理に移していきます。
全部すっ飛ばしても大丈夫な人は不連続な関数を描こうへどうぞ。

目次

• Pythonのリスト
• 条件分岐とループ処理
  • if文
  • for文とwhile文

    • for文
    • while文
• 不連続な関数を描こう
  • めんどくさい？

Pythonのリスト

前回の記事では、Pythonには配列が存在しないと述べました。
その代わり、Pythonにはリスト(List)と呼ばれるデータ構造が標準搭載されています。
今回はそれについて少し触れます。

リストとは

まずリストについて簡単な説明から行います。

list_sample.py

list_sample.py

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)

x.append(10)
print(x)

#print(x + 3)
# TypeErrorが起こる

print(x + [3])
print(x * 3)

x = np.array(x)
print(x)
x = list(x)
print(x)

リストは配列と似た概念で、次のように用いることができます。

list_sample.py

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x)

このx、numpy_calc.pyで定義したxと出力結果が同じになっていることに気づきましたか？
つまり、リストと配列は似たデータ構造であることがわかります。
その最大の違いはデータサイズが可変であることです。

list_sample.py

x.append(10)
print(x)

10が追加されましたね。
このappendメソッドはリスト型のデータ構造が持っている関数¹で、要素を追加するためのものです。
もちろんnumpy配列で同じことをしようとしてもエラーが出るだけです。
numpyでは一度定義した配列のサイズを変更するには(内部処理で)どこかに改めてコピーする必要があります。
その点リストは予め大きめにメモリを確保することで、要素を追加する際にかかるメモリ確保の時間を節約することができます。
要するにそれぞれメリット/デメリットがあるということです。
他にもリストには要素を削除する関数などもあります。
また、リストにはnumpy配列のブロードキャスト機能はありません。

list_sample.py

#print(x + 3)
# TypeErrorが起こる

ただし次のようなことはできます。

list_sample.py

print(x + [3])
print(x * 3)

リスト同士の足し算であれば要素の追加になります。
リストと自然数の掛け算はリストそのものを数値の数だけ繰り返したリストとなります。²
その他の演算はTypeErrorが出てできません
さらに、numpy配列とリストは相互に変換もできます。

list_sample.py

x = np.array(x)
print(x)
x = list(x)
print(x)

以上で本記事で必要なリストの知識の紹介はおしまいです。
要約すると

• リストはデータサイズが可変の配列のようなもの
• numpyとリストは相互に変換できる

だけ知っておけば本記事ではOKです。

条件分岐とループ処理

条件分岐とは「ある条件を満たすなら〇〇、そうでなければ××」という処理のことです。
(この処理は人間の意思決定とも似ているところがありますね)
ループ処理とは「ある条件を満たすまで同じ処理を繰り返す」という処理のことです。
(これは機械っぽい処理ですね)

では具体的にどのようにコードを書くのか、実際にやっていきましょう。

if文

Pythonの条件分岐と言えばif文だけ³です。
C言語などをやったことのある人は「え、switchとかないの?」と思うかもしれませんね。
Pythonではswitch文の類はありません。いちいち書かなければいけません。面倒ですね。
初めての人にとっては覚えることが減ってラッキーかもしれません笑。
とりあえず、この条件分岐を使ってみましょう。

if_sample.py

if_sample.py

x = 5
if x > 0:
    # 条件式x > 0が真ならばここの処理
    print("xは0より大きいです。")
else:
    # 条件式x > 0が偽ならばここの処理
    # つまりx <= 0ならばここの処理です
    if x == 0:
        # 条件式x == 0が真ならばここの処理
        # <note>
        # ==は式の両辺が等しいか、という条件式です
        # 逆に、式の両辺が等しくないか、という演算は!=です
        print("xは0です。")
    else:
        # 条件式x == 0が偽ならばここの処理
        # つまり、x != 0ならばここの処理です
        print("xは0より小さいです。")

if x > 0:
    print("xは0より大きいです。")
elif x == 0:
    print("xは0です。")
else:
    print("xは0より小さいです。")

この二つのif文は全く同じ動作をします。
上の方はif elseのみ、下の方はif elif elseという文法を使って書いています。
見ての通りですが、if文の中にif文を書く(ネストする、といいます)ことができます。
もちろんもっとたくさんネストさせることも可能ですが、読みにくくなってしまうのでできるだけネストは少なめにするよう心がけましょう。
つまり下の方が読みやすいコードということですね。

文法まとめ

if_grammer_summary.py

if (条件式1):
    # (条件式1)が真(True)ならここに記述された処理を実行
#-----ここから-----
elif (条件式2):
    # (条件式1)が偽(False)で(条件式2)が真(True)ならここに記述された処理を実行
elif (条件式3):
...
else:
    # 全ての条件式が偽(False)ならここに記述された処理を実行
#-----ここまで-----
# 全て省略可能です。つまり最初のifだけでもOK。

for文とwhile文

続いてループ処理です。
Pythonのループ処理にはforとwhileの二つがあります。
二つある理由はたまに使い分けたいことがあるからですが、for文をwhile文に、while文をfor文に、等価な処理を行うように変換できますのでお好みで...と言いたいですが、基本的にfor文を使うことを個人的にオススメします。
理由は後ほど...

for文

まずはfor文から。

for_sample.py

for_sample.py

for i in range(10):
    print(i)
print("----------")

for i in range(1, 10):
    print(i, end=" ")
    if i > 5:
        print("\n{} > 5".format(i))
        print("ループを抜けます")
        break
else:
    print("この文は出力されません。")

さて、上の方のfor文は0〜9まで、縦に並べて出力されます。
下の方は6までが横に並べて出力されて、「6 > 5」「ループを抜けます」と出力されて終わるはずです。
(ついでなのでいくつか紹介していない関数などを使っています。気になった方はググってみましょう。)

for文は文法を見た方がわかりやすいですね。

for_grammer_summary.py

for (変数名) in (配列やリストなど):
    (繰り返したい処理をここに書く)
else:
    (ループが正常に終了した場合の処理やループが１度も実行されなかった時に行いたい処理をここに書く)

range関数は指定された数までのリストのようなもの⁴を返します。
break文はループを強制的に抜けるためのものです。
for文では、(配列やリストなど)で指定された数値が順番に(変数名)に代入されて処理が行われます。

for_sample.pyの一つ目のループでは

• 変数iに0が代入される
• print関数によって0が出力される
• 変数iに1が代入される
• print関数によって1が出力される
• ...

のように処理が進みます。

二つ目のループはfor else文の紹介のために書きました。
Pythonでは他の言語には滅多にない、ループ処理にelseを使うことができます。
elseの中には、ループが正常に終了した時に行って欲しい処理を書きます。
つまり、break文でループを強制的に終了した場合はその処理が行われません。
あまり積極的に使うことはありませんが、ネストされたfor文を全て抜けたい時などによりスッキリしたコードを書くことができます。

nested_for.py

nested_for.py

# elseあり
for i in range(10):
    for j in range(10):
        print(i, j)
        if i * j > 10:
            # i = 2, j = 6でここに入ります
            break
    else:
        continue
    break

# elseなし
flag = False
for i in range(10):
    for j in range(10):
        print(i, j)
        if i * j > 10:
            # i = 2, j = 6でここに入ります
            flag = True
            break
    if flag:
        break

continue文は以降の処理をスルーして次のループに移るためのものです。

while文

次はwhile文です。

while_sample.py

while_sample.py

i = 0
while i < 10:
    print(i)
    i += 1
print("----------")

i = 0
while i < 10:
    print(i, end=" ")
    if i > 5:
        print("\n{} > 5".format(i))
        break
    i += 1
else:
    print("この文は出力されません")

このwhile_sample.pyはそれぞれfor_sample.pyと等価なループ処理となっていることが確認できると思います。
while文の文法は次の通りです。

while_grammer_summary.py

while (条件式):
    (繰り返したい処理をここに書く)
else:
    (ループが正常に終了した場合の処理やループが１度も実行されなかった時に行いたい処理をここに書く)

while文の特徴は条件式が満たされる限りループ処理をすることですね。
for文では予めループする回数が決まるのに対して、while文は不定なことがあるのが大きな違いです。
これが個人的にwhile文を使わないようにして欲しい理由につながります。

while_sample.pyの一つ目のループを以下のように変更して実行すると大量の0が出力され続けます。
<<注意>>
実行する場合は止め方をよく頭に入れておいてください。

while_sample.py

i = 0
while i < 10:
    print(i)
    #i += 1

<<止め方>>
上部の■をクリックすれば止まります。
jupyter notebookでは簡単な操作で実行を中断できるので便利ですね〜

変数iの値が変わらないためにいつまでも条件式i < 10が満たされ続けてしまい、処理が無限に行われてしまうためこのようなことが発生します。
このような状況を無限ループと言います。
今回はprint関数で出力しているため異常が分かり易いですが、例えばこれが1000行のコードの中で、print関数などによる出力もない状態で発生したらどうでしょう？

一生懸命書いたコードがなぜかエラーで動かない！
ではなく
一生懸命書いたコードがエラーもないのに反応しない！

という状況になります。
初心者の頃は無限ループなんてそう簡単には気づけないためずーっと頭を悩ませることになりかねません。
以上の理由から、while文でなければ書けないようなループはまずないでしょうから、基本的にfor文を使用するようにしましょう。

不連続な関数を描こう

長くなりましたが、条件分岐とループ処理を用いて不連続な関数を書いてみましょう！
graph_plot.pyの関数fの部分を次のように変更しましょう。

graph_plot.py

# リストを用いたバージョン
def f(x):
    result = []
    for i in x:
        if i < 0:
            result.append(i + 3)
        else:
            result.append(i ** 2)
    return result

graph_plot.py

# numpy配列を用いたバージョン
def f(x):
    result = np.zeros(len(x))
    for i in range(len(x)):
        if x[i] < 0:
            result[i] = x[i] + 3
        else:
            result[i] = x[i] ** 2
    return result

こんな感じのグラフがプロットされればOKです。

めんどくさい？

めんどくさいって？間違いない。
ということでスマートな書き方も紹介しておきます。

graph_plot.py

def f(x):
    return np.where(x < 0, x + 3, x ** 2)

numpyのwhere関数は俗にいう三項演算子というやつです。
詳しくはググりましょう。
ちなみに頑張れば標準の書き方でもそれなりにスマートになります。

graph_plot.py

def f(x):
    return [i + 3 if i < 0 else i ** 2 for i in x]

リスト内包表記とif文の三項演算子を組み合わせたものですね。

list_comprehension_grammer.py

[(処理) for (変数名) in (配列やリストなど)]

ternary_operator_grammer.py

(条件式が真の時の処理) if (条件式) else (条件式が偽の時の処理)

とはいえ読みにくいし複雑です。
パッケージの偉大さがよくわかります。

初めてのPythonシリーズ記事

• 初めてのPython ~環境構築編~
• 初めてのPython ~コーディング編~

---

1. 正確にはリスト型のクラスが持つappendメソッドです。 ↩

2. 0以下の整数値は空のリストを返します。試してみてください。 ↩

3. try文は条件分岐と言えなくもないです。 ↩

4. 実際はイテレータ(ループ処理可能な)オブジェクトを返します。 ↩