授業用資料

 

 数値シミュレーション

 情報システムの最適化

 IT経営戦略

 研究室情報

 授業資料等

  [english]



(このページは該当講座受講登録者向けの情報です)
python

前期

◆全員ブラインドタッチが出来るようにすること。
 練習用ソフトは何でも良いのですが、例えば下記を使ってとにかく 1日15分 を連続15日間続けて下さい。

 チェックテスト 寿司打(サウンドなしでやりましょう)
 http://typing.sakura.ne.jp/sushida/index.html
 速度はこの寿司打で、平均キータイプ数が 2.3回/秒 を超えないとダメです。

 HTML入門

 演習:自分の学生番号と名前を表示する
  演習用HTML(右クリックして保存)
 課題:自分で写真を撮って自己紹介ページを作る
  課題用サンプルHTML(右クリックして保存)
  課題用画像サンプル(右クリックして保存)
 HTMLファイルで画像が表示されない場合は、セキュリティーのためにブロックが掛っている場合がある。その際にはHTMLファイルを右クリック−[プロパティ]→下の方の[ブロックの解除]を選択する。

表を使ったHTML:1Qと2Qの各自の時間割を1つのWebページに上下で表示する
  テーブルの課題サンプル(右クリックして保存)
  ハイパーテキストの課題サンプル(右クリックして保存)

JavaScriptを使ったWebプログラミング
Web プログラミング入門
Web プログラミング入門(演習用サンプルファイル)
エクセルを使った回帰分析
サンプルデータ

プログラムを基礎から勉強する場合:Python入門の無料E-Learning環境(paizaラーニング)_ブラウザ画面上で実行できます)
Pythonによるプログラミング入門
Python実行環境(下記をクリックするとGoogle上でPythonが使えるようになります)
Google Colaboratory Python実行環境
PythonによるAIプログラミング入門 サンプルプログラム集
Google Colaboratoryに下記ソースプログラムを貼り付けて実行して下さい。
#Pythonの簡易プログラム(#以降はコメント)
a = 1; b = 10; c = a + b
print (c);
print ("こんにちは");

#繰り返し命令の例 
list=[0,1,2]
for i in list:
  print(i)#←字下げをしている部分が、繰り返しの範囲
#結果← これより下の結果はプログラムを実行した結果となるので、Google Colaboratoryに入力不要です。以下全て同様です。
#0← 結果の箇所の一番左の#は、この行を間違えてGoogle Colaboratoryに入力しても動くようにコメント#にしています。
#1
#2

#繰り返し命令の例 字下げで繰り返しの範囲を指定する 同じ処理ですが、繰り返しが100回とか、増えても記載が短くて済む
for i in range(3):#0から始まって1,2まで実行する。Rangeで指定した回数だけ実行する
  print(i)
#結果
#0
#1
#2

#結果に説明の文字を加える時は、整数のiも文字型strにする(この+記号は足し算では無く、文字列の連結の意味になる)
for i in range(3):
  print("i = " + str(i))
#結果
#i = 0
#i = 1
#i = 2

#条件分岐の例 条件分岐も 字下げで条件の範囲を指定する
even=0#偶数の合計
odd=0#奇数の合計
sum=0#合計
for i in range(10):#変数i=0.1,2,3,4,5,6,7,8,9 と代入して、10回実行する。
  if i%2==0:#2で割った余りが0なら偶数
    even=even+1
    sum = sum+1
  else:#2で割った余りが0でないなら奇数
    odd = odd+1
    sum = sum+1
print("合計 = " + str(sum))
print("偶数の合計 = " + str(even))
print("奇数の合計 = " + str(odd))

#多重繰り返し処理とデータフレーム
import copy # 列情報をコピーして代入する処理があるためにライブラリを読み込む
import pandas as pd # データフレームを利用するためpandasライブラリを読み込む
columns = [] # 列情報を格納するためのリスト変数
indexs = [] # 行列情報を格納するためのリスト変数
for column in range(1, 10): # 列columnの繰り返しループ:1の段から9の段まで(10の前まで実行)
  for line in range(1, 10): # 行lineの繰り返しループ:1の段から9の段まで(10の前まで実行)
    columns.append(column * line) # 九九を計算した積の結果を列リスト変数に順次追加する
  indexs.append(copy.copy(columns)) # 行列リスト変数indexsに、列情報(列リスト変数columns)に追加する
  columns.clear() #新しい計算をするために、古いデータが入っている列リスト変数columnsを初期化する
print("indexsの表示")
print(indexs) # 画面にindexsという行列リストを表示するが見にくい
df = pd.DataFrame(indexs) # 九九一覧がindexsという行列リストに入っているので、見やすくするためデータフレームに変換する
print("indexをデータフレームで表示")
df.head(9) # 画面にindexsという行列リストを表示するが改行されないので見にくい
# 実行結果 indexsの表示としてindexsという行列リストを表示しているが1つの行になってしまい、見にくいので、データフレームdfを使って方が見やすくしている。


#散布図を表示するプログラム
import matplotlib.pyplot as plt # 散布図を描画するためにグラフ描画ライブラリを読み込む

#x座標 来客数 1日目の来客数,2日目の来客数,・・・
visitors =[62,70,81,68,82,58,50,79,83,102,81,109,48,52,75,99,102,115,98,52,49,85,79,91,121,128,80,89,112,128]
#y座標 その(xの)来客数の日に、ドリンクが売れた数
energyDrink =[22,31,28,24,36,25,14,28,29,31,14,38,24,28,40,28,29,48,34,29,23,32,36,32,48,41,31,40,42,52]

plt.plot(visitors, energyDrink, 'o') #plot(x座標,y座標,種類)で結果の散布図をプロットする。o:丸 等
plt.show() # 散布図を画面に表示させる


#散布図に回帰直線を表示するプログラム
from sklearn.linear_model import LinearRegression#線形回帰分析用ライブラリ
import matplotlib.pyplot as plt #図形を描画する図形描画ライブラリ
import pandas as pd#データ分析ライブラリ
import math#乱数や数学関数を利用するためのライブラリ
import seaborn#図形を綺麗に描画するためのツール

visitors =[62,70,81,68,82,58,50,79,83,102,81,109,48,52,75,99,102,115,98,52,49,85,79,91,121,128,80,89,112,128]#1日の来店人数
energyDrink =[22,31,28,24,36,25,14,28,29,31,14,38,24,28,40,28,29,48,34,29,23,32,36,32,48,41,31,40,42,52]#1日のエナジードリンクの売上本数
beers =[31,30,46,34,35,30,28,40,34,58,39,53,20,28,31,51,56,60,44,22,29,43,35,47,57,69,40,42,67,64]# 1日のビールの売り上げ本数

modelLR = LinearRegression()#線形回帰にLinearRegressionクラスの利用を指定する
modelLR.fit(pd.DataFrame(visitors), pd.DataFrame(energyDrink))#fit(x座標,y座標)データを基に線形回帰分析を実行

plt.plot(visitors, energyDrink, 'o')#plot(x座標,y座標,種類)で結果の散布図をプロットする。o:丸、s:四角形、D:菱形 等
plt.plot(visitors, modelLR.predict(pd.DataFrame(visitors)), linestyle="solid")#図中に回帰直線を描画する
plt.show()

print('モデル関数の回帰変数 w1: %.3f' %modelLR.coef_)
print('モデル関数の切片 w2: %.3f' %modelLR.intercept_)
print('y= %.3fx + %.3f' % (modelLR.coef_ , modelLR.intercept_))
R2= modelLR.score(pd.DataFrame(visitors), pd.DataFrame(energyDrink))#決定係数R^2の算出
print('決定係数 R^2: ', R2)
print('(決定係数 R^2=回帰係数 r^2より)回帰係数 r = ',math.sqrt(R2))

#課題 これを基に30代の人数と、缶ビールの売り上げ本数の回帰分析をしなさい

#相関係数行列の計算
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

#%matplotlib inline#プログラムの情報出力を黒い画面では無く、JupitarNotebookに表示させる(GoogleColaboratoryでは使えないので#でコメントアウトで無効にする必要がある)
#ファイルの読み込み
df = pd.DataFrame({
'Name': ["Tanaka", "Aoyama", "Mizuno", "Suzuki", "Uchida", "Watanabe"],
'Age': [25, 45, 52, 22, 23, 41],
'Height(meters)': [1.65, 1.75, 1.75, 1.65, 1.75, 1.65],
'Weight(KG)': [69, 75, 75, 60, 63, 78],
'Salary(Ten thousand yen)': [450, 780, 1200, 400, 420, 650]
})

corrmat = df.corr()#相関係数行列を求める

f, ax = plt.subplots(figsize=(6, 4))#subplotsはfとaxを返す。figsize=(6, 4)は横が6で縦が4の描画サイズ。f Figure:グラフを描画するキャンバス全体のオブジェクト ax Axes:Figureオブジェクト内の個々のグラフのオブジェクト
sns.heatmap(corrmat, annot=True);#seabornで相関係数行列corrmatを濃淡で可視化する。annot=Trueでセル中に数値を表示する。

#CSV(Comma Separated Values)ファイルからデータをデータフレームに読み込む方法
# エクセルなどでcsv形式(文字コードUTF-8)で保存する。文字コードが指定出来なければcsvに保存した後でメモ帳で開いてUTF-8で上書保存する。
calendar2022_9.csv


import pandas as pd # データを表形式で処理が可能なpandasを読み込む
df = pd.read_csv('https://toyotani.org/lib/datas/calendar2022_9.csv').fillna('') # 外部のcsvデータ(メモ帳などで文字コードをUTF-8にしておく)を、データフレームの変数dfに読み込む。データの無い箇所はNan(Not a Number)が自動代入されるので、Nanをfillna('')ですべて空文字に置き換える
df.head(6) # 確認のためにデータフレームの内容を上から6行を表示する
# 実行結果 csvの1行目が本来はデータの各項目を入力すべきだが、年と月のデータを入れているために下記のように列名の中に年と月が表示されている

# これが嫌な場合は csvの1行目に ,,,,,,と追加して、2行目からデータを記載すると良い。下記の1行目の,,,,,,は7列分の空データをカンマ6つで区切って入力している。そうする事で1行目は列の項目名であり、空項目が代入され、年と月の行は2行目以降のデータ行として表示される。
 

#エクセルファイルからデータをデータフレーム(2次元の表を扱うオブジェクト(ツール))に読み込む方法
# 元のエクセルデータ
calendar2022_9.xlsx


import pandas as pd # データを表形式で処理するデータフレームを利用するためにpandasを読み込む
df = pd.read_excel('https://toyotani.org/lib/datas/calendar2022_9.xlsx').fillna('') # 外部のエクセルデータを、データフレームの変数dfに読み込む。データの無い箇所はNan(Not a Number)が自動代入されるので、Nanをfillna('')ですべて空文字に置き換える
df.head(6) # 確認のためにデータフレームの内容を上から6行を表示する
# 実行結果

#列名(項目名の変更:新たにdf_newというデータフレームを作成して、そこに新しい項目名にする)
df_new = df.rename(columns={'Unnamed: 0': 'Sunday','Unnamed: 1': 'Monday','Unnamed: 2': 'Tuesday','Unnamed: 3': 'Wednesday','Unnamed: 4': 'Thursday','Unnamed: 5': 'Friday','Unnamed: 6': 'Saturday',})

df_new.head(6) # 確認のためにデータフレームの内容を上から6行を表示する

df_new['Monday']# Mondayの列を抽出

df_new[3:4]#3行目から4未満(3行目を抽出)


#CSV(Comma Separated Values)ファイルからデータを読み込んで相関係数行列を求める方法

#上記のようなエクセルファイルを、カンマで区切られたCSV形式のファイルに変換する。エクセルでcsv形式(文字コードUTF-8)で保存する。文字コードが指定出来なければcsvに保存した後でメモ帳で開いてUTF-8で上書保存する。

#右をクリックするとダウンロードできるので、それを動画を参考にGoogleColaboratoryにアップするCorrelation.csv
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv('Correlation.csv')

corrmat = df.corr()#相関係数行列を求める
f, ax = plt.subplots(figsize=(6, 4))#subplotsはfとaxを返す。figsize=(6, 4)は横が6で縦が4の描画サイズ。f Figure:グラフを描画するキャンバス全体のオブジェクト ax Axes:Figureオブジェクト内の個々のグラフのオブジェクト
sns.heatmap(corrmat, annot=True);#seabornで相関係数行列corrmatを濃淡で可視化する。annot=Trueでセル中に数値を表示する。


#K-meansによるクラスタリング分析:教師なし学習
#アンケートを行った結果 横軸に炭酸の強さ、縦軸に甘さをプロットすると次のようになった


#「炭酸の強さ」と「甘み」を-100から100までの間で好きな値を回答し、横軸に炭酸、縦軸に甘みとしてプロットする。
import numpy as np
from sklearn.cluster import KMeans
from sklearn import metrics
import matplotlib.pyplot as plt

#炭酸の強さの好み -100 to 100
coca_x = np.array([-41, -9, 19, 10, -80, -28, 18, -3, -15, -42, -5, -36, -39, -24, -4, -47, 0, 2, -12, -14, -22, 18, 0, -15, 4, -40, -6, -44, -28, -42, 17, 39, 69, 32, 30, -2, 28, 24, 44, 16, 8, 78, 19, 58, -11, 15, 27, 58, -14, 28, 36, 24, 12, 8, 4, 44, 43, 63, 17, 46])
#甘さの強さ -100 to 100
coca_y = np.array([-52, -28, -7, 46, -28, -3, -13, 39, -11, 52, 18, 22, -41, 1, -20, 4, 20, 54, -26, 69, -30, 11, -34, 10, -17, -32, 21, -31, 21, -37, -9, -1, -11, 1, -14, -45, 27, 48, -9, 17, 48, 29, 82, -28, 37, 9, -57, 15, -12, -13, 37, -44, 0, 10, -10, -34, -8, 39, -14, -28])
# 1次元目をcoca_x(炭酸),2次元目をcoca_y(甘さ)とする行列を作成
coca = np.c_[coca_x, coca_y]
#x軸とy軸の幅を設定する
plt.xlim([-100, 100]) #X軸が-100から100まで
plt.ylim([-100, 100]) #Y軸が-100から100まで

#散布図を作成
plt.scatter(coca_x, coca_y)#x,yの散布図をプロットする
plt.show()

kmeans = KMeans(n_clusters=2)
kmeans_model = kmeans.fit(coca)
print(kmeans_model.labels_)


# 色とマーカーの形を設定
colors = ['b','r','g']#b:Blue、r:Red、g:Green
markers = ['o','s','x']#o:〇印、s:□、x:×
for i, l in enumerate(kmeans_model.labels_):# kmeans_model.labels_の中にグループ0と1で分類される。iは各点のデータの数(全データ)をループする。lはクラスタの分類数(2や3)だけループする。
  plt.plot(coca_x[i],coca_y[i], color=colors[l],marker=markers[l], ls='None') #0は青の丸、1は赤の四角
  plt.xlim([-100, 100])
  plt.ylim([-100, 100])
plt.show()



#決定木による機械学習:教師あり学習
#アンケートを行った結果、Cコーラが好きな人(青)、Pコーラが好きな人(オレンジ)をプロットすると次のようになった。


#決定木を表示させるには、まず次を実行して決定木を表示させるツールを組み込む必要がある
!sudo apt install graphviz
!pip install dtreeviz

#次をセルに貼り付けて実行して決定木を表示させる
import numpy as np
from sklearn import tree
from sklearn.tree import plot_tree
from sklearn.tree import export_graphviz
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split # 元データを学習用と評価用に自動分割するプログラムを読み込む処理
from sklearn.metrics import accuracy_score # 推測結果を評価をする際に便利なライブラリ(プログラム群)

from six import StringIO
import pydotplus
from IPython.display import Image

#炭酸の強さの好み -100 to 100
coca_x = np.array([ -41, -9, 19, 10, -80, -28, 18, -3, -15, -42, -5, -36, -39, -24, -4, -47, 0, 2, -12, -14, -22, 18, 0, -15, 4, -40, -6, -44, -28, -42, 7, 39, 69, 32, 30, -2, 28, 24, 44, 16, 8, 78, 19, 58, -11, 15, 27, 58, -14, 28, 36, 24, 12, 8, 4, 44, 43, 63, 17, 46])
#甘さの好み -100 to 100
coca_y = np.array([-52, -28, -7, 46, -28, -3, -13, 39, -11, 52, 18, 22, -41, 1, -20, 4, 20, 54, -26, 69, -30, 11, -34, 10, -17, -32, 21, -31, 21, -37, -9, -1, -11, 1, -14, -45, 27, 48, -9, 17, 48, 29, 82, -28, 37, 9, -57, 15, -12, -13, 37, -44, 0, 10, -10, -34, -8, 39, -14, -28])
#どちらのコーラが好きか 1:Pコーラ、2:Cコーラ
answer = np.array([1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1, 2, 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2])

# 説明変数の格納 1次元目をcoca_x(炭酸),2次元目をcoca_y(甘さ)とする行列を作成
coca = np.c_[coca_x, coca_y]
print("説明変数を出力\n", coca)

#目的変数の格納
print("目的変数を出力\n", answer)

#学習用データと評価用データに分割
x_train, x_test, y_train, y_test = train_test_split(coca, answer, test_size=0.3,random_state=0)#学習用を7割、評価用を3割に振り分ける
print("学習用の目的変数を出力\n", y_train)
print("学習用の説明変数を出力\n", x_train)
print("評価用の目的変数を出力\n", y_test)
print("評価用の説明変数を出力\n", x_test)

#機械学習モデルに決定木を選択
clf = tree.DecisionTreeClassifier()

#機械学習
clf.fit(x_train, y_train)

for i in range(len(x_train)):#教師データに分けた後に、散布図を表示させて決定木の結果を検証できるようにする
  plt.scatter(x_train[i,0], x_train[i,1], color= 'red' if y_train[i] == 1 else 'blue', marker='o')

#全評価用データを使って予測
predict = clf.predict(x_test)
print("評価用全データに対する予測結果を出力\n", predict)
print("評価用全データに対する正解率を出力\n", accuracy_score(y_test, predict))

#推測計算
sample_coca = np.c_[-50, 0]#炭酸の強さが-40, 甘さが-50の人は上記にはいないが、Pコーラの1に分類されるはず
predict = clf.predict(sample_coca)
print("炭酸の強さが-50, 甘さが0の人の推測値(1:Pコーラ、2:Cコーラ)\n", predict)

dot_data = StringIO() #dotファイル情報の格納先
export_graphviz(clf, out_file=dot_data,
  feature_names=["Strength of carbonic acid", "Strength of sweetness"],#炭酸の強さと、酸味の強さ
  class_names=["P Cola","C Cola"],#どちらが好きなのか(答え)を表示
  filled=True, rounded=True,
  special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
Image(graph.create_png())

#下記は教師用データの散布図(赤がPコーラ、青がCコーラ)

下記は決定木の各ツリー情報(各ツリーの条件によってグループ分けをしている)
まず横軸の炭酸の強さStrength of carbonic acidの値3で、左側にPコーラ、右側にCコーラが好きな人を大きく分けている。value=[22,20]はPコーラが好きな人が22人、Cコーラが好きな人が20人いるという事を示している。その次は横軸-14.5でPコーラが好きな人(12人)を左に分け右側は横軸18.5でCコーラが好きな人(13人)を分けている。このように各データについてグループ分けが行われている。



#複数モデル利用が可能な機械学習:教師あり学習
#アンケートを行った結果、Cコーラが好きな人(青)、Pコーラが好きな人(オレンジ)をプロットすると次のようになった。

import numpy as np # 数値計算を効率的に行うためのライブラリ(プログラム群)
import matplotlib.pyplot as plt# データの散布図などグラフ描画を行うライブラリ(プログラム群)
from sklearn.model_selection import train_test_split # 元データを学習用と評価用に自動分割するプログラムを読み込む処理
from sklearn.metrics import accuracy_score # 推測結果を評価をする際に便利なライブラリ(プログラム群)
from sklearn import tree # 決定木を利用する際に必要となるライブラリ(プログラム群)
from sklearn.neural_network import MLPClassifier # ニューラルネットワークNNを利用する際に必要となるライブラリ(プログラム群)
from sklearn import svm # SVMを利用する際に必要となるライブラリ(プログラム群)
from sklearn.linear_model import LogisticRegression # ロジスティクス回帰を利用する際に必要となるライブラリ(プログラム群)
from sklearn.ensemble import RandomForestClassifier # ランダムフォレストを利用する際に必要となるライブラリ(プログラム群)
from sklearn.preprocessing import StandardScaler# データの標準化を行うライブラリ(プログラム群)
#炭酸の強さの好み -100 to 100
coca_x = np.array([ -41, -9, 19, 10, -80, -28, 18, -3, -15, -42, -5, -36, -39, -24, -4, -47, 0, 2, -12, -14, -22, 18, 0, -15, 4, -40, -6, -44, -28, -42, 7, 39, 69, 32, 30, -2, 28, 24, 44, 16, 8, 78, 19, 58, -11, 15, 27, 58, -14, 28, 36, 24, 12, 8, 4, 44, 43, 63, 17, 46])
#甘さの好み -100 to 100
coca_y = np.array([-52, -28, -7, 46, -28, -3, -13, 39, -11, 52, 18, 22, -41, 1, -20, 4, 20, 54, -26, 69, -30, 11, -34, 10, -17, -32, 21, -31, 21, -37, -9, -1, -11, 1, -14, -45, 27, 48, -9, 17, 48, 29, 82, -28, 37, 9, -57, 15, -12, -13, 37, -44, 0, 10, -10, -34, -8, 39, -14, -28])
#どちらのコーラが好きか 1:Pコーラ、2:Cコーラ
answer = np.array([1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1, 2, 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2 , 2])

# 説明変数の格納 1次元目をcoca_x(炭酸),2次元目をcoca_y(甘さ)とする行列を作成
coca = np.c_[coca_x, coca_y]
print("説明変数を出力\n", coca)

#目的変数の格納
print("目的変数を出力\n", answer)

#学習用データと評価用データに分割
x_train, x_test, y_train, y_test = train_test_split(coca, answer, test_size=0.3,random_state=0)#学習用を7割、評価用を3割に振り分ける
print("学習用に振り分けられたデータの目的変数を出力\n", y_train)
print("学習用に振り分けられたデータの説明変数を出力\n", x_train)
print("評価用に振り分けられたデータの目的変数を出力\n", y_test)
print("評価用に振り分けられたデータの説明変数を出力\n", x_test)

plt.scatter(x_train[:,0], x_train[:,1], c='blue', marker='o', label='train data')#学習用データの散布図
plt.scatter(x_test[:,0], x_test[:,1], c='red', marker='o', s=60, label='test data')#評価用データの散布図
plt.legend(loc='upper left')


#重要な個所:次のコメント操作で分析方法を(決定木、ランダムフォレスト、ニューラル、SVM、ロジスティク回帰)変える。
#clf = tree.DecisionTreeClassifier() #機械学習モデルに決定木decision treeを選択:分類木と回帰木を組み合わせたツリー(樹形図)を利用して目的変数を推測する
clf = RandomForestClassifier()#機械学習モデルに ランダムフォレストを選択:決定木を大量に利用(平均値等)して目的変数を推測する
#clf = MLPClassifier(solver="sgd",random_state=0,max_iter=10000)#機械学習モデルにニューラルネットワークを選択:人間の脳内にある神経細胞(ニューロン)とそのつながりの強弱を模したモデルで目的変数を推測する
#clf = svm.SVC()#機械学習にSupport Vector Machine(SVM)を選択:グループ分けをする線に最も近いデータ点を利用して目的変数を推測する
#clf = LogisticRegression()#機械学習モデルにLogistic Regressionロジスティック回帰を選択:ロジスティック関数(シグモイド関数)を利用して目的変数(2値に限定)に対して推測を行う

#指定されたモデルで機械学習を実行
clf.fit(x_train, y_train)

#全評価用データを使って予測
print("評価用全データに対する正解率を出力\n", clf.score(x_test, y_test))

#推測計算
sample_coca = np.c_[-50, 0]#炭酸の強さが-50, 甘さが0の人は上記にはいないが、Pコーラの1に分類されるはず
predict = clf.predict(sample_coca)
print("炭酸の強さが-50, 甘さが0の人の推測値(1:Pコーラ、2:Cコーラ)\n", predict)


#複数モデル利用が可能な機械学習:教師あり学習(データを外部のエクセルファイルから読み込む方法 下記赤色部分が上記プログラムとの変更点)
#次のようにエクセルファイル(右クリックで一度、自分のパソコンにダウンロード)をサーバーにアップロードします。

#左のメニューから[フォルダ]をクリックして、[アップロード]アイコンを選択します。

#次に、ファイルを選択して[開く]を押すと、アップロードしたファイルはランタイム・・・というメッセージがでますが、これはデータは一時的に保管されますが、次回接続時は削除されるという事です。ここではOKを押します。次回にこのプログラムを実行する際には、事前に上記と同じ操作をしてデータをアップロードしてから実行して下さい。

#左にmyData.xlsが表示されていますので、プログラムから読み込めるようになりました。


#アンケートを行った結果、Cコーラが好きな人(青)、Pコーラが好きな人(オレンジ)をプロットすると次のようになった。

import numpy as np # 数値計算を効率的に行うためのライブラリ(プログラム群)
import matplotlib.pyplot as plt# データの散布図などグラフ描画を行うライブラリ(プログラム群)
from sklearn.model_selection import train_test_split # 元データを学習用と評価用に自動分割するプログラムを読み込む処理
from sklearn.metrics import accuracy_score # 推測結果を評価をする際に便利なライブラリ(プログラム群)
from sklearn import tree # 決定木を利用する際に必要となるライブラリ(プログラム群)
from sklearn.neural_network import MLPClassifier # ニューラルネットワークNNを利用する際に必要となるライブラリ(プログラム群)
from sklearn import svm # SVMを利用する際に必要となるライブラリ(プログラム群)
from sklearn.linear_model import LogisticRegression # ロジスティクス回帰を利用する際に必要となるライブラリ(プログラム群)
from sklearn.ensemble import RandomForestClassifier # ランダムフォレストを利用する際に必要となるライブラリ(プログラム群)
from sklearn.preprocessing import StandardScaler# データの標準化を行うライブラリ(プログラム群)
import pandas as pd

df = pd.read_excel('https://toyotani.org/lib/lib/myData.xlsx')#上記のファイルが無くても動くように、インターネット上からエクセルのデータをpandas(pd)というデータ管理ツールを使って読み込みます
#df = pd.read_excel('myData.xlsx')#エクセルのデータを読み込む これが本来のプログラムです
#df = pd.read_excel('myData.xlsx','Sheet2', header = None)#エクセルで見出し(ヘッダ)行が無い場合は、このようにヘッダ無を指定する。Sheet2は読み込むシートを指定してデータを読み込む
np_list = df.to_numpy() #pandasでエクセルファイルを読み込んだ後に、データをnumpyというデータ分析に便利なツールでマトリックスの行列に変換する(アンケートデータを方向に抽出する必要があるため)
#炭酸の強さの好み -100 to 100
coca_x = np_list[:, 0] #1列目(プログラム内では0から始まる)のデータを抽出して coca_xに代入する(炭酸の強さの好み -100 to 100)
#甘さの好み -100 to 100
coca_y = np_list[:, 1] #2列目(プログラム内では1)のデータを抽出して coca_xに代入する(炭酸の強さの好み -100 to 100)
#どちらのコーラが好きか 1:Pコーラ、2:Cコーラ
answer = np_list[:, 2] #3列目(プログラム内では3)のデータを抽出して coca_xに代入する(炭酸の強さの好み -100 to 100)

# 説明変数の格納 1次元目をcoca_x(炭酸),2次元目をcoca_y(甘さ)とする行列を作成
coca = np.c_[coca_x, coca_y]
print("説明変数を出力\n", coca)

#目的変数の格納
print("目的変数を出力\n", answer)

#学習用データと評価用データに分割
x_train, x_test, y_train, y_test = train_test_split(coca, answer, test_size=0.3,random_state=0)#学習用を7割、評価用を3割に振り分ける
print("学習用に振り分けられたデータの目的変数を出力\n", y_train)
print("学習用に振り分けられたデータの説明変数を出力\n", x_train)
print("評価用に振り分けられたデータの目的変数を出力\n", y_test)
print("評価用に振り分けられたデータの説明変数を出力\n", x_test)

plt.scatter(x_train[:,0], x_train[:,1], c='blue', marker='o', label='train data')#学習用データの散布図
plt.scatter(x_test[:,0], x_test[:,1], c='red', marker='o', s=60, label='test data')#評価用データの散布図
plt.legend(loc='upper left')


#重要な個所:次のコメント操作で分析方法を(決定木、ランダムフォレスト、ニューラル、SVM、ロジスティク回帰)変える。
#clf = tree.DecisionTreeClassifier() #機械学習モデルに決定木decision treeを選択:分類木と回帰木を組み合わせたツリー(樹形図)を利用して目的変数を推測する
clf = RandomForestClassifier()#機械学習モデルに ランダムフォレストを選択:決定木を大量に利用(平均値等)して目的変数を推測する
#clf = MLPClassifier(solver="sgd",random_state=0,max_iter=10000)#機械学習モデルにニューラルネットワークを選択:人間の脳内にある神経細胞(ニューロン)とそのつながりの強弱を模したモデルで目的変数を推測する
#clf = svm.SVC()#機械学習にSupport Vector Machine(SVM)を選択:グループ分けをする線に最も近いデータ点を利用して目的変数を推測する
#clf = LogisticRegression()#機械学習モデルにLogistic Regressionロジスティック回帰を選択:ロジスティック関数(シグモイド関数)を利用して目的変数(2値に限定)に対して推測を行う

#指定されたモデルで機械学習を実行
clf.fit(x_train, y_train)

#全評価用データを使って予測
print("評価用全データに対する正解率を出力\n", clf.score(x_test, y_test))

#推測計算
sample_coca = np.c_[-50, 0]#炭酸の強さが-50, 甘さが0の人は上記にはいないが、Pコーラの1に分類されるはず
predict = clf.predict(sample_coca)
print("炭酸の強さが-50, 甘さが0の人の推測値(1:Pコーラ、2:Cコーラ)\n", predict)


#主成分分析(教師無し機械学習)
#好きなコーラの味で炭酸の強さ、甘さ、酸味の強さについてアンケートを行った。そのデータを使って主成分分析を行い、主な主成分を算出し、どのような味の好みの人たちが存在するのかを明らかにする。次はアンケート結果を基に、Carbonic_acid(炭酸の強さ) Sweetness(甘みの強さ) Acidity(酸味の強さ)を3次元にプロットした図である(この3次元図ではよく分からない)。

import numpy as np# 数値計算やデータフレーム操作に関するライブラリをインポートする
import pandas as pd
import matplotlib.pyplot as plt #図やグラフを図示するためのライブラリをインポートする
from mpl_toolkits.mplot3d import Axes3D #3次元プロットするためのモジュール
from sklearn.preprocessing import StandardScaler# データ標準化ライブラリ
import sklearn #機械学習の代表的なpythonのライブラリ
from sklearn.decomposition import PCA #主成分分析ツール
from sklearn.cluster import KMeans #クラスタ分類ツール

#入力データ:炭酸の強さ -100 to 100
carbonic_acid = np.array([53, 47, 50, 43, 48, 45, 53, 29, 14, 20, 46, 40, 54, 10, 13, 40, 58, 34, 23, 18, -19, -12, -1, -13, -24, 0, 29, 19, -20, 7, -12, -5, 23, -5, 6, -15, 5, 5, 27, -15, 9, 9, -8, 3, -14, 11, 3, 1, 10, 11, 16, 0, -10, 1, 8, -19, -39, 10, 8, 9])
#入力データ:甘み -100 to 100
sweetness = np.array([-27, -38, -21, 45, -12, -3, -28, 12, -28, -15, 0, 13, 21, -4, 17, 6, -9, -15, -9, -14, -2, 15, 28, -24, -6, 20, 17, 5, 1, 11, -38, -9, 22, 19, -7, 6, -2, -14, 18, 43, -68, -28, -24, -22, -42, 11, -9, -23, 9, -62, -39, -27, 2, -18, -8, 5, 4, -25, 35, -17])
#入力データ:酸味の強さ -100 to 100
acidity = np.array([28, 26, 34, 44, 22, 41, 46, 35, 32, 40, 23, 38, 29, 37, 23, 44, 21, 26, 27, 21, 5, -7, -2, -15, 9, -5, -13, -3, -7, 2, -16, 7, -18, -24, 17, 1, -5, -2, 25, 6, -33, -44, -20, -44, -23, -39, -24, -57, -29, -45, -44, -50, -49, -46, -19, -16, 8, -39, -52, -31])
#入力項目名を設定 Carbonic_acid(炭酸の強さ) Sweetness(甘みの強さ) Acidity(酸味の強さ)
df = pd.DataFrame({'Carbonic_acid': carbonic_acid, 'Sweetness': sweetness, 'Acidity': acidity})
#display(df)#入力データの確認表示

# データを標準化する処理
sc = StandardScaler()
clustering_sc = sc.fit_transform(df)#データを変換するために必要な統計情報を計算して、正規化(標準化)する
std_data_df = pd.DataFrame(clustering_sc, columns = df.columns)#標準化されたデータフレーム(データ)
#display(std_data_df)#データの標準化処理結果を確認する際に表示する

#3次元グラフの枠を描画する
fig = plt.figure()
ax = Axes3D(fig)
ax.set_xlabel("Carbonic_acidity")#各軸にラベルを表示
ax.set_ylabel("Sweetness")#各軸にラベルを表示
ax.set_zlabel("Acidity")#各軸にラベルを表示
ax.plot(df.loc[:,'Carbonic_acid'],df.loc[:,'Sweetness'],df.loc[:,'Acidity'],marker="o",linestyle='None')#散布図を描画する際に、linestyle='None'にしないと線が引かれる
plt.show()#最後に.show()を書いてグラフ表示

# KMeansによるクラスタリング分類処理
kmeans = KMeans(n_clusters=3, random_state=0)
clusters = kmeans.fit(clustering_sc)
#print(clusters.labels_)#クラスタリングの分類結果を確認する際に表示する
df['cluster']=clusters.labels_

#sklearnのPCAを利用した主成分分析
pca = PCA()
pca.fit(clustering_sc)
clustering_sc_pca = pca.transform(clustering_sc)
pca_df = pd.DataFrame(clustering_sc_pca)
pca_df['cluster'] = df['cluster']
print(pca_df)#主成分分析PCAの結果を表示

# データを主成分空間に写像
pca_cor = pca.transform(std_data_df)

eig_vec = pd.DataFrame(pca.components_.T, columns=["Principal Component{}".format(x + 1) for x in range(len(std_data_df.columns))] , index = std_data_df.columns)
# 各主成分 因子負荷量 固有ベクトル

display(eig_vec)
#この各主成分の因子負荷量を見ると第1主成分の因子負荷量は炭酸が0.64、酸味が0.7と強めで甘さが0.28と、「炭酸と酸味が強く甘くない」コーラが好きな人達であることがわかる。第2主成分は炭酸がマイナスで甘さが0.91、酸味が0.0と炭酸が弱く甘みが強く、「炭酸が弱く酸味もほどほどで甘みが強い」味のコーラが好きな人達である。第3主成分は炭酸が0.64と強めで甘さが0.29と少し甘いが、酸味が-0.7と「炭酸が強く酸味が全く無く甘くない」コーラが好きな人達であることがわかる。

# 固有値
eig = pd.DataFrame(pca.explained_variance_).T
#display(eig)

# 寄与率
ev = pd.DataFrame(pca.explained_variance_ratio_, index=["Principal Component{}".format(x + 1) for x in range(len(std_data_df.columns))], columns=['寄与率']).T

display(ev)

# 累積寄与率
t_ev = pd.DataFrame(pca.explained_variance_ratio_.cumsum(), index=["Principal Component{}".format(x + 1) for x in range(len(std_data_df.columns))], columns=['累積寄与率']).T

display(t_ev)
#第1主成分から第3主成分までの累計が1になっているため、元のデータは第1主成分から第2、第3主成分で構成されている事が分かる。

# 主成分得点
print('主成分得点')
cor = pd.DataFrame(pca_cor, columns=["Principal Component{}".format(x + 1) for x in range(len(std_data_df.columns))])
display(cor)

for i in df['cluster'].unique():#第一主成分と第二主成分でプロットする
  tmp = pca_df.loc[pca_df['cluster'] == i]
  plt.scatter(tmp[0], tmp[1])
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.show()


# 累積寄与率を図にして表示する
import matplotlib.ticker as ticker
plt.gca().get_xaxis().set_major_locator(ticker.MaxNLocator(integer=True))
plt.plot([0] + list( np.cumsum(pca.explained_variance_ratio_)), "-o")
plt.xlabel("Number of Principal Component")
plt.ylabel("Cumulative contribution rate")
plt.grid()
plt.show()

#上記の表と同じであるが、それを図示すると上のようになり、第1主成分から第3主成分までの累計寄与率が1になっているため、元のデータは第1主成分が53%を占め、第2が34%、第3主成分までを合わせると100%に達する事が分かる。

#サポートベクタマシンSVMによる文字認識:自分でAIに機械学習をさせる方法
# 例えば 0 の画像は、グレー濃度表記で8×8で下記のデータ形式になっている。

#上記は0という数字であると、AIに機械学習させる
from sklearn.model_selection import train_test_split
from sklearn import datasets,svm,metrics
from sklearn.metrics import accuracy_score

digits = datasets.load_digits()#0-9の画像データを読み込む
print(digits.data)
x = digits.images#画像データ(画像の濃度)
y = digits.target#正解値データ(1とか3とかの)
#二次元配列を一次元配列に変換8bit×8bit(8行×8列)を64個のデータに並べなおす
x = x.reshape((-1,64))

import matplotlib.pyplot as plt
images_and_labels = list(zip(digits.images, digits.target))#画像データと正解値をリスト形式に保存しなおす(繰り返し処理を簡単にするため)
# 画像データセットの最初から10つ[:10]を取り出して評価する
for index, (image, label) in enumerate(images_and_labels[:10]):
    plt.subplot(3, 4, index + 1)#画像を複数の領域(3行×4列)に分ける、最後のindex+1は画像を描画する場所(何番目か)を指定している
    plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    plt.axis('off')
    plt.title('Training: %i' % label)
plt.show()

# 元のデータを学習用データと、後で検証するためのテスト用データに分割する
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2)

# 教師データを元にAIに機械学習を行う
clf = svm.LinearSVC()#clf:classifier (分類器)
clf.fit(x_train, y_train)#教師(トレーニング)データでAIに機械学習を実施

# AIに予測させて、全体で何%正解したのかを表示
y_pred = clf.predict(x_test)#テストデータで予測させる
print('0から9までの数字全ての画像を与えた際の、AIの正解率:')
print(accuracy_score(y_test, y_pred))#予測値がどれだけ一致するかを評価する

print('特定の文字列を認識')
y_pred1 = clf.predict(digits.data[6:7])#特定の数予測したい場合は[6:7]として[該当の開始番号:該当の終了番号+1]とする。これは6番目(数字は6)を指定している
print('Training6の画像データを与えて、AIが予測した数字:')
print(y_pred1)

#Pythonによる文字認識:tesseract-ocr-jpnという、日本語文字認識の機械学習済のツールを利用する方法
事前準備
サンプルの写真を右ボタンでダウンロードする。
#設定ファイルとサンプル画像のGoogle Colaboratoryへのアップロード
次のコードを実行し、Google Colaboratory Python実行環境に、上記ファイルをアップロードする。(実行後、「ファイル選択」が表示されるので、それを教えてはファイルを選択し、アップロードをクリックしてアップロードを押す)
from google.colab import files
uploaded = files.upload()
#-----------ここまでが事前準備 下記が文字認識のプログラム
#文字認識のライブラリを使えるようにインストールする(はじめは以下2つの命令で1セットと考えて良い)
!sudo apt-get install tesseract-ocr-jpn
#文字認識のライブラリを使えるようにする
!pip install pytesseract
from PIL import Image#文字認識のライブラリを使えるようにする
import pytesseract#文字認識のライブラリを使えるようにする
myimg = Image.open('toyotaniHP.png')#文字の含まれている画像ファイル名を指定する
text_out = pytesseract.image_to_string(myimg,lang='jpn', config='--psm 6')#文字認識を実行する,psmページセグメンテーションモード(5:縦書 など)
print(text_out)#文字認識の結果を出力する

#PythonによるWebカメラからの顔認識:あくまでも自分のPCのJupitarNotebook で実行し、Webカメラから画像を取得して リアルタイムに顔を認識するプログラム
#もしくはローカルPCのAnacondaコンソールで実行し、Webカメラから画像を取得して 顔を認識するプログラム
#このソースファイル・プログラムコードを右ボタンでダウンロードする。
#顔認識の機械学習済みデータファイルを右ボタンでダウンロードする。
#顔認識の機械学習済みデータファイルhaarcascade_frontalface_alt.xmlをWebにアップする
#!pip install opencv-python #OpenCVがインストールされていない場合に実行
import cv2
filepass='haarcascade_frontalface_alt.xml'#機械学習済みのデータファイル
face_cascade = cv2.CascadeClassifier(filepass)#機械学習済みデータファイルの読み込み
web_camera = cv2.VideoCapture(0) # Webカメラチャンネル番号を指定(最初は0で、増設すると1,2,3と増える。標準は最初なので0)

# 撮影=ループ中にフレーム(画像キャプチャー)を1枚ずつ取得(qキーで撮影終了)
while True:
  ret, frame = web_camera.read() # フレームを取得
  gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  faces = face_cascade.detectMultiScale(gray, scaleFactor=1.3, minNeighbors=5)
  for x, y, w, h in faces:
    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 5)
    face = frame[y: y + h, x: x + w]
    face_gray = gray[y: y + h, x: x + w]
    cv2.putText(frame, 'Face Detect!->End to Push [q]', (10,50), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (255,255,255), 2, cv2.LINE_AA)

  cv2.imshow('web_camera', frame) # フレームを画面に表示
  # キー操作があればwhileループを抜ける
  if cv2.waitKey(1) & 0xFF == ord('q'):
    break

# 撮影用オブジェクトとウィンドウの解放
web_camera.release()
cv2.destroyAllWindows()


#Pythonによる顔認識
事前準備 #設定ファイルとサンプル画像のGoogle Colaboratoryへのアップロード
haarcascade_frontalface_alt.xmlと、sample_pict.jpgを別々に2回に分けて次のようにアップします。
サンプルの写真を右ボタンでダウンロードする。
顔認識の機械学習済みデータファイルを右ボタンでダウンロードする。
次のコードを実行し、Google Colaboratory Python実行環境に、上記ファイルをアップロードする。(2ファイルあるので、2回実施)
from google.colab import files
uploaded = files.upload()

#顔認識プログラム
import cv2 #画像処理ライブラリ CV(Computer Vision) が使えるようにする
import matplotlib.pyplot as plt #写真を表示できるようにグラフィックライブラリを読み込む

# 画像読込み
origin_img = cv2.imread("sample_pict.jpg") #自分でアップロードした写真を指定して読み込む
# 基の画像は描画して壊さないように、画像をコピーして利用する
img = origin_img.copy()

# 顔を識別する機械学習済ファイルの読み込み
cascade_path = "haarcascade_frontalface_alt.xml"#顔を識別するAI機械学習済特徴量データを指定
cascade = cv2.CascadeClassifier(cascade_path)# カスケード分類器(学習済みの特徴量データ)を読み込む

grayscale_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)# 画像グレースケール化
# 顔検出処理:  minSize 最小サイズ指定(100px×100px)
front_face_list = cascade.detectMultiScale(grayscale_img, minSize = (100, 100))# 検出された複数の顔をリスト形式にしてfront_face_listに保存

print("検出判定 [X,Y,幅,高]")# 検出判定
print(front_face_list)#検出された顔の座長X,Y,幅,高をコンソールに出力
if len(front_face_list) == 0:# 検出が無ければ失敗Failedと表示して終了
  print("Failed")
  quit()

print("検出位置 [X,Y,幅,高]")# 検出位置描画
for (x,y,w,h) in front_face_list:#リストfront_face_listに複数の顔情報があるので、全て一つずつ繰り返し取り出す
  print("[x,y] = %d,%d [w,h] = %d,%d" %(x, y, w, h))# 識別できた顔のX,Yや幅と高さを出力
  cv2.rectangle(img, (x,y), (x+w, y+h), (0, 0, 255), thickness=10)# 画像の顔部分を四角く囲む

# 顔検出画像表示
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))# コンピュータのメモリ内に顔を四角く囲った画像を貼り付ける
plt.show()# コンピュータメモリ内の画像を画面に表示する
cv2.imwrite("result_output.jpg", img)# 顔検出画像をファイルに出力する

# 検出画像を個別にファイル(face_x座標-y座長.jpg)として出力
for (x,y,w,h) in front_face_list:#リストfront_face_listに複数の顔情報があるので、全て一つずつ繰り返し取り出す
  face_img = origin_img[y:y+h, x:x+w]#顔の部分の画像を、座標と幅、高さを指定して切り取る
  filename = "face_" + str(x) + "-" + str(y) + ".jpg"#顔の画像ファイル名をface_x座標-y座長.jpgとする
  cv2.imwrite(filename, face_img)#画像をファイルに書き出す

#結果→
#提出課題 自分で写真を用意(スマホで写メで撮った写真を添付でNu-mail(G-Mail)で添付で送ると、文字列になる)して、それをアップロードして、顔認識をして下さい。
変更箇所:旧>origin_img = cv2.imread("sample_pict.jpg")
変更箇所:新>origin_img = cv2.imread("ここは長い文字列になりますので、Nu-mailから文字列をコピー&ペースト")

出来たら、顔認識課題を開いて[prt Sc]キー(Print Screen)キーを押して(画面イメージをメモリに保存し)、[ctl]+[v](もしくはメニューの編集から貼り付け)で貼り付けて提出して下さい。


#KerasのニューラルネットワークNNを使った機械学習による洋服のカテゴリ分類(TensorFlowのKerasを利用)
from keras.models import Sequential#keras.modelsからニューラルネットワークのSequentialを読み込む
from keras.layers import Activation, Dense, Dropout#NNで利用するツールを読み込む Activation活性化関数、Dense全結合層、Dropout学習時に無効化
from keras.optimizers import RMSprop #NNで利用するオプティマイザ(最適化アルゴリズム)
import numpy as np #行列計算ライブラリ
from tensorflow import keras #モジュールのtensorflow.pyの変数kerasをimportする
import matplotlib.pyplot as plt #図形や写真描画をするためのライブラリ
import pandas as pd
import seaborn as sn
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt

def plot_history(history):#精度の履歴をプロットする関数plot_historyの定義(引数:historyに学習用データ並びに評価用データに対する精度が保存されている)
  plt.plot(history.history['accuracy'],"o-",label="training_accuracy") #学習用データに対する精度をプロット
  plt.plot(history.history['val_accuracy'],"o-",label="validation_accuracy") #評価用データに対する精度をプロット
  plt.title('model accuracy') #タイトル表示
  plt.xlabel('epoch') #x軸に繰り返しエポック数epochを表示
  plt.ylabel('accuracy') #y軸に精度accuracyを表示
  plt.legend(loc="lower right") #凡例の表示を右下に指定する
  plt.gray() #グレースケール画像を指定(白色が黄色で表示されるため)
  plt.show() #画面描画
  

  # 損失の履歴を画面にプロットする
  plt.plot(history.history['loss'],"o-",label="training_loss",) #学習用データに対する損失値をプロット
  plt.plot(history.history['val_loss'],"o-",label="validation_loss") #評価用データに対する損失値をプロット
  plt.title('model loss') #タイトル表示
  plt.xlabel('epoch') #x軸に繰り返しエポック数epochを表示
  plt.ylabel('loss') #y軸に損失lossを表示
  plt.legend(loc='upper right') #凡例の表示を右下に指定する
  plt.gray()
  plt.show() #画面に図を表示する
  

def plot_confusionmatrix(y_true, y_pred): #混同行列の画面表示
  class_names = ['T-Shirt', 'Slacks', 'Parker', 'Dress', 'Coat',#洋服の種類名をここで定義する
  'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Boots']
  labels = sorted(list(set(y_true))) #項目名を評価用データを昇順に並べる
  confusion_matrix_data = confusion_matrix(y_true, y_pred, labels=labels) #評価用データとその予測値を参照して、混同行列データを作成する
  df_cmx = pd.DataFrame(confusion_matrix_data, index=class_names, columns=class_names) #混同行列データをデータフレームに入れる
  plt.figure(figsize = (12,7)) #混同行列ヒートマップの表示サイズを横1200ピクセル×700ピクセルの大きさで準備する
  sn.heatmap(df_cmx, annot=True, fmt='g' ,square = True) #混同行列をヒートマップで作図する
  plt.yticks(rotation=0)
  plt.xlabel("Prediction", fontsize=13, rotation=0)
  plt.ylabel("True", fontsize=13)
  plt.show()#混同行列を画面に表示する
  

#ここからmain文開始
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()#kerasのdatasetsモジュールからネット経由で洋服のデータセットをダウンロード
#10のクラスにラベル付けされた,50,000枚の32x32訓練用カラー画像,10,000枚のテスト用画像のデータセットを学習用データと評価用データに分けて変数に保存する

#データセットの配布元: GitHub「fashion-mnist/zalandoresearch」。The MIT License (MIT) Copyright © [2017] Zalando SE, https://tech.zalando.com 出典: Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. Han Xiao, Kashif Rasul, Roland Vollgraf. arXiv:1708.07747

#入力データをリスト表示
plt.figure(figsize=(10,6))#ファッションデータ描画用に横幅を1000ピクセル(指定の数に100をかけてピクセルに換算)、高さを600ピクセルの画像描画用領域を確保する
plt.xticks([])#x軸のメモリを非表示にする(画像を並べるだけなので、軸の目盛り表記は不要)
plt.yticks([])#x軸のメモリを非表示にする
for i in range(21):#0から1,2,3と、21回繰り返す(横7個×縦3個=21個分)
  plt.subplot(3, 7, i+1)#機械学習用(train)教師データの画像を3行×5列の領域に並べて表示する
  plt.title(str(x_train[i]))#タイトル描画
  plt.xticks([])#x軸のメモリを非表示にする(画像を並べるだけなので、軸の目盛り表記は不要)
  plt.yticks([])#x軸のメモリを非表示にする
  plt.gray()
  plt.imshow(x_train[i].reshape(28,28), cmap=None)#教師データ画像を表示する
plt.show()

x_train = x_train.reshape((60000, 28 * 28))#2次元縦28×横28=784ピクセルのデータ60000個を、reshapeによって60000個の1次元784ピクセルの1次元データに変換する
x_train = x_train.astype('float32') / 255 #データを(0から255までの)256諧調を255で割って、0.0から1.0に正規化する
x_test = x_test.reshape((10000, 28 * 28))#2次元縦28×横28=784ピクセルのデータ10000個を、reshapeによって10000個の1次元784ピクセルの1次元データに変換する
x_test = x_test.astype('float32') / 255 #データを256諧調から、0.0から1.0に正規化する

# NNのモデルを作成する
model = keras.models.Sequential() #NNのモデルを順番に下記の順で生成する
model.add(Dense(units=512,input_dim=28*28))#ニューラルネットワークを生成:中間層が512個、入力層が28*28=784個のニューロンを生成(追加)
model.add(Activation('relu')) #閾値を計算する活性化関数ReLU(Rectified Linear Unit)ランプ関数で入力が0以下の時は出力も0、入力が0より大きい場合はそのままの値を出力する。
model.add(Dropout(0.2)) #過学習の予防でドロップアウト機能を用いて、全結合の層とのつながりを「20%」無効化する
model.add(Dense(units=10)) #ニューロン10個で構成される中間層を生成(追加)する
model.add(Activation('softmax')) #出力層の活性化関数にsoftmax関数を適用して、最大1で滑らかでソフトな曲線になる。
model.compile(loss='sparse_categorical_crossentropy',optimizer=RMSprop(),metrics=['accuracy'])#トレーニング(機械学習)に時間が掛かるので、その時のアルゴリズムを最適化する。
# ラベルが整数なので、損失関数としてsparse_categorical_crossentropy を用いる。RMSpropはAdaGradを改良したアルゴリズムで勾配の2乗の指数移動平均を取る

# NNによる機械学習を実行
history = model.fit(x_train, y_train, #機械学習用データを入力データx_train,出力データが y_trainとして記憶させる
    batch_size=128,#128くらいやると良いが、演習では時間が無く小さくしている
    epochs=50,#50くらいやると良いが、演習では時間が無く小さくしている
    verbose=1, #障害解析などに必要な詳細情報を出力するためのログ出力レベル
    validation_data=(x_test, y_test))#評価用データとして入力データx_test,出力データが y_testとして指定する(まだ評価は実行はしない)
    # 機械学習に対する精度の履歴データをhistoryに保存する
plot_history(history) #機械学習をした時の精度の履歴データhistoryを画面に表示する

score = model.evaluate(x_test, y_test, verbose=1)#評価用データとして入力データx_test,出力データが y_testとして実行して評価する。その結果をscoreに代入する。verboseは1:計算途中のログ表示有、0:ログ無し

print('loss=', score[0])#画面に損失関数lossを表示する
print('accuracy=', score[1])#画面に精度accuracyを表示する

predict_y=model.predict(x_test) #評価用データx_testを使って、その商品の商品カテゴリpredict_yを推測させる
predict_classes=np.argmax(predict_y,axis=1)

plot_confusionmatrix(y_test, predict_classes)#正解と推測の混同行列を表示する

class_names = ['T-Shirt', 'Slacks', 'Parker', 'Dress', 'Coat',#洋服の種類名をここで定義する
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Boots']

predict_labels = model.predict(x_test)#機械学習に基づく予測を計算する
true_labels = y_test#答えを設定する

figure = plt.figure(figsize=(10, 6))
for index in range(21):#0から1,2,3と、15回繰り返す(横5個×縦3個=15個分)
  plt.subplot(3,7,index+1)#train教師データの画像を5個×5個の領域に並べて表示する
  plt.xticks([])#x軸のメモリを非表示にする(画像を並べるだけなので、軸の目盛り表記は不要)
  plt.yticks([])#x軸のメモリを非表示にする
  predict_index = np.argmax(predict_labels[index]) #予測した分類番号を取得する
  true_index =true_labels[index] #正解の分類番号を取得する
  plt.imshow(x_test[index].reshape(28,28), cmap=None)#教師データ画像を表示する
  plt.xlabel("{} ({})".format(class_names[predict_index],#画面に予測した分類名を表示する
    class_names[true_index]),#カッコ内( )に正解の分類名を表示する
    color=("blue" if predict_index == true_index else "red"))#予測が当たっていたら青色で、間違っていたら赤色で表示する。正解はカッコ内
  

#CNNによる洋服のカテゴリ分類(TensorFlowのKerasを利用)
import numpy as np #行列計算ライブラリ
import matplotlib.pyplot as plt #図形や写真描画をするためのライブラリ
import tensorflow as tf #深層学習でGPUを簡単に使うことができる行列計算ライブラリ
from tensorflow import keras #よりニューラルネットワークの実装の際に便利な機能がまとめられたライブラリ
import pandas as pd #データ解析ライブラリ。今回は混合行列作成の際にデータフレームを利用するために読み込む
import seaborn as sn #グラフや図を見栄え良くするライブラリ
from sklearn.metrics import confusion_matrix #混合行列を作成するためのライブラリ

def plot_history(history):#精度の履歴をプロットする関数plot_historyの定義(引数:historyに学習用データ並びに評価用データに対する精度が保存されている)
    plt.plot(history.history['accuracy'],"o-",label="training_accuracy") #学習用データに対する精度をプロット
    plt.plot(history.history['val_accuracy'],"o-",label="validation_accuracy") #評価用データに対する精度をプロット
    plt.title('model accuracy') #タイトル表示
    plt.xlabel('epoch') #x軸にエポック数epochを表示
    plt.ylabel('accuracy') #y軸に精度accuracyを表示
    plt.legend(loc="lower right") #凡例の表示を右下に指定する
    plt.gray()
    plt.show() #画面描画
  

    # 損失の履歴をプロット
    plt.plot(history.history['loss'],"o-",label="training_loss",) #学習用データに対する損失値をプロット
    plt.plot(history.history['val_loss'],"o-",label="validation_loss") #評価用データに対する損失値をプロット
    plt.title('model loss') #タイトル表示
    plt.xlabel('epoch') #x軸にエポック数epochを表示
    plt.ylabel('loss') #y軸に損失lossを表示
    plt.legend(loc='upper right') #凡例の表示を右下に指定する
    plt.gray()
    plt.show() #画面に図を表示する
  

def plot_confusionmatrix(y_true, y_pred): #混同行列の画面表示
    class_names = ['T-Shirt', 'Slacks', 'Parker', 'Dress', 'Coat',#洋服の種類名をここで定義する
    'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Boots']
    labels = sorted(list(set(y_true))) #項目名を評価用データを昇順に並べる
    confusion_matrix_data = confusion_matrix(y_true, y_pred, labels=labels) #評価用データとその予測値を参照して、混同行列データを作成する
    df_cmx = pd.DataFrame(confusion_matrix_data, index=class_names, columns=class_names) #混同行列データをデータフレームに入れる
    plt.figure(figsize = (12,7)) #混同行列ヒートマップの表示サイズを横1200ピクセル×700ピクセルの大きさで準備する
    sn.heatmap(df_cmx, annot=True, fmt='g' ,square = True) #混同行列をヒートマップで作図する
    plt.yticks(rotation=0)
    plt.xlabel("Prediction", fontsize=13, rotation=0)
    plt.ylabel("True", fontsize=13)
    plt.gray()#グレー表示を指定する
    plt.show()#混同行列を画面に表示する
  

#ここからmain文開始
(train_images, train_labels), (test_images, test_labels) = keras.datasets.fashion_mnist.load_data()#kerasのdatasetsモジュールからネット経由で洋服のデータセットをダウンロード

#データセットの配布元: GitHub「fashion-mnist/zalandoresearch」。The MIT License (MIT) Copyright © [2017] Zalando SE, https://tech.zalando.com 出典: Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. Han Xiao, Kashif Rasul, Roland Vollgraf. arXiv:1708.07747

class_names = ['T-Shirt', 'Slacks', 'Parker', 'Dress', 'Coat',#洋服の種類名をここで定義する
'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Boots']
train_labels_onehot = keras.utils.to_categorical(train_labels, 10)#one hot表現とは該当列のみ1を立てて、他は0で埋める形式のデータである。
test_labels_onehot = keras.utils.to_categorical(test_labels, 10)

train_images = train_images.astype("float32") / 255.0 #train教師データの画素値を0.0から1.0に正規化をする(最大値が255のため255で割る)
test_images = test_images.astype("float32") / 255.0 #testテストデータの画素値を0.0から1.0に正規化をする(最大値が255のため255で割る)

#入力データをリスト表示
plt.figure(figsize=(10,6))#ファッションデータ描画用に横幅を1000ピクセル(指定の数に100をかけてピクセルに換算)、高さを600ピクセルの画像描画用領域を確保する
for i in range(15):#0から1,2,3と、15回繰り返す(横5個×縦5個=15個分)
  plt.subplot(3,5,i+1)#train教師データの画像を5個×5個の領域に並べて表示する
  plt.xticks([])#x軸のメモリを非表示にする(画像を並べるだけなので、軸の目盛り表記は不要)
  plt.yticks([])#x軸のメモリを非表示にする
  plt.imshow(train_images[i], cmap=plt.cm.binary)#教師データ画像を表示する
  plt.xlabel("{}".format(class_names[train_labels[i]]),color=("green"))#教師データの名前(ラベル)を表示する
plt.show()#混同行列を画面に表示する


# CNNのモデルを作成する
model = keras.Sequential([ #モデルの構築:この書式は非常に長く、順に記載するが、順番に Conv2D, MaxPooling2D, Dropout, ・・・指定した順に中間層を追加する
  keras.layers.Conv2D(filters=64, kernel_size=(2,2), padding="same", activation="relu", input_shape=(28,28,1)),#フィルター数はカーネルや特徴量検出器の数
    # filters=64 64枚のフィルター(特徴量検出器)を使う
    # kernel_size=(2,2) 図では赤枠の3×3であるが、ここでは2×2の画像を探索対象にする
    # padding="same"特徴マップの周囲を0で埋めて(ゼロパディング)出力も同じサイズにする。padding="valid"とすると特徴マップの周囲に0は入れないため、出力の特徴マップデータは小さくなる。
    # activation="relu"ReLU(Rectified Linear Unit)- ランプ関数: 0より大きい数はそのままで、0以下は0に置き換える関数を採用する

  keras.layers.MaxPooling2D(pool_size=(2,2)),#2×2の画像を探索して、最大値で置き換えて画像サイズを小さくする(プーリング)。通常はデータのサイズが大きいために、この畳み込み処理やプーリングを繰り返してサイズを小さくする。

  keras.layers.Dropout(0.3),#過学習を回避するためにドロップアウト層を追加する。ニューラルネットワークの中間層のニューロンをランダムに非活性化させることによって、機械学習を難しくさせて、汎化性能を向上させる役割がある。(値は任意だが一般には0.25から0.3くらい)
  keras.layers.Conv2D(filters=32, kernel_size=(2,2), padding="same", activation="relu"),#畳込み層(レイヤー):上記を繰り返す事で、大きな画像を小さくすることが出来る。また特徴量の畳み込み計算を行う
  keras.layers.MaxPooling2D(pool_size=(2,2)),#図は赤枠3×3であるが、ここでは2×2の領域(カーネル)内で最大値のみを取り出して、レイヤーを縮小してデータ量を減らす
  keras.layers.Dropout(0.3),#過学習を回避するためにドロップアウト層を追加する(値は任意だが一般には0.25から0.3くらい)

  keras.layers.Flatten(),#8x8の二次元配列を64要素の一次元配列に直すして、次にニューラルネットワークの入力層にする。
  keras.layers.Dense(256, activation="relu"),#ニューラルネットワークの中間層をユニット数256として作成する。閾値を計算する活性化関数ReLU(Rectified Linear Unit)ランプ関数で入力が0以下の時は出力も0、入力が0より大きい場合はそのままの値を出力する。
  keras.layers.Dropout(0.5),#過学習を回避するためにドロップアウト層を追加する。
  keras.layers.Dense(10, activation="softmax")#ニューラルネットワークの中間層をさらにユニット数10で作成する。活性化関数は各データを正規化しての出力値の合計が1.0(=100%)になるように変換して出力する関数。各出力値の範囲は0.0〜1.0となる。softmax関数を使うため、最大1で滑らかでソフトな曲線になる。
])
#この設定で左側に画像データを畳み込み処理をした特徴量が入力層になり、右側の出力層に洋服の分類番号がセットされる。この後の機械学習でその入力を行うとその出力値になるように、ニューラルネットワークの重みが自動計算される。

model.compile(optimizer=tf.optimizers.Adam(),#トレーニング(機械学習)に時間が掛かるので、その時のアルゴリズムを最適化する
    loss='categorical_crossentropy',#複数の画像があり、それぞれTシャツやスニーカーなど、1つのラベルに分類する問題ではcategorical_crossentropyを指定する。2値分類の時はbinary_crossentropyを指定する
    metrics=["accuracy"])#評価関数であり、学習の評価として正解率も計算するように指定している

history = model.fit(train_images[:,:,:,None], train_labels_onehot, #機械学習用データを入力データx_train,出力データが y_trainとして記憶させる
  batch_size=128,#128くらいやると良いが、演習では時間が無く小さくしている
  epochs=10,#50くらいやると良いが、演習では時間が無く小さくしている
  verbose=1, #障害解析などに必要な詳細情報を出力するためのログ出力レベル
  validation_data=(test_images[:,:,:,None], test_labels_onehot))#評価用データとして入力データx_test,出力データが y_testとして指定する(まだ評価は実行はしない)
  # 機械学習に対する精度の履歴データをhistoryに保存する
plot_history(history) #機械学習をした時の精度の履歴データhistoryを画面に表示する

labels = model.predict(test_images[:,:,:,None])#機械学習に基づく予測を計算する
score = model.evaluate(test_images[:,:,:,None], test_labels_onehot)#機械学習の予測結果が一致しているかを評価する
print('機械学習による予測結果の評価: ', score)
score_loss, score_metrics = model.evaluate(test_images[:,:,:,None], test_labels_onehot)#機械学習の予測結果が一致しているかを評価する
print('機械学習後の損失関数値: ', score_loss)
print('機械学習後の評価関数値: ', score_metrics)

figure = plt.figure(figsize=(10, 6))
for index in range(15):#0から1,2,3と、15回繰り返す(横5個×縦3個=15個分)
  plt.subplot(3,5,index+1)#train教師データの画像を5個×5個の領域に並べて表示する
  plt.xticks([])#x軸のメモリを非表示にする(画像を並べるだけなので、軸の目盛り表記は不要)
  plt.yticks([])#x軸のメモリを非表示にする
  predict_index = np.argmax(labels[index]) #予測した分類番号を取得する
  true_index = np.argmax(test_labels_onehot[index]) #正解の分類番号を取得する
  plt.imshow(test_images[index], cmap=plt.cm.binary)#教師データ画像を表示する
  plt.xlabel("{} ({})".format(class_names[predict_index],#画面に予測した分類名を表示する
    class_names[true_index]),#カッコ内( )に正解の分類名を表示する
    color=("blue" if predict_index == true_index else "red"))#予測が当たっていたら青色で、間違っていたら赤色で表示する
#参考(教師データ)

#結果(青は正解、赤は不正解)



#OpenCVのカスケード分類器を利用したAI信号認識プログラム:機械学習で赤い信号を認識
#機械学習に使った赤信号の教師データ画像の例(機械学習時には、これらを基に1000枚以上の画像を自動生成して実行した)

   
   
#AI認識に利用した画像


import cv2
from google.colab.patches import cv2_imshow# GoogleColaboratoryでcv_imshowを実行するのに利用
import urllib.request as req # URL指定でファイルをダウンロードするのに利用

url_img = 'https://www.toyotani.org/lib/lib/red_signal.jpg' # 歩行者信号で赤信号の写真 Web上のデータの場所を指定(既にファイルがあればこの処理不要)
#url_img = 'https://www.toyotani.org/lib/lib/blue_signal.jpg' # 歩行者信号で青信号の写真 Web上のデータの場所を指定(既にファイルがあればこの処理不要)
req.urlretrieve(url_img, "target.jpg") # 入力画像としてGoogleColaboratoryに保存(既にファイルがあればこの処理不要)
img = cv2.imread("target.jpg") # 入力画像の読み込み

# カスケード型識別器(自作:歩行者赤信号の学習結果)学習時に画像特徴量を抽出しそこから分類器を作成する手法

xml_red = 'https://www.toyotani.org/lib/lib/RED_cascade.xml' # Web上のデータの場所を指定(既にファイルがあればこの処理不要)
xml_blue = 'https://www.toyotani.org/lib/lib/BLUE_cascade.xml' # Web上のデータの場所を指定(既にファイルがあればこの処理不要)
req.urlretrieve(xml_red , "RED_cascade.xml") # 学習後のデータファイルとしてGoogleColaboratoryに保存(既にファイルがあればこの処理不要)
req.urlretrieve(xml_blue, "BLUE_cascade.xml") # 学習後のデータファイルとしてGoogleColaboratoryに保存(既にファイルがあればこの処理不要)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 入力画像をグレースケールにしてデータ量を小さくして処理をする

#赤信号の認識
cascade = cv2.CascadeClassifier("RED_cascade.xml") # RED_cascade.xmlは機械学習後のデータファイル
signal = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=2, minSize=(20, 20))# gray:グレースケール画像を読み込む, scaleFactor:デフォルトは1.1で1.0より大きい値で指定する。画像スケールを何度も変化させて探索する時の縮小率, minNeighbors:デフォルトは3で最低でもこの数だけの近傍矩形を含む, minSize:検出の最小サイズ
# 領域を四角形で囲む
for (x, y, w, h) in signal:
  print("x,y,w,h=",x,y,w,h)#x,y座標と幅と高さ
  # 四角描画を始点のx,yから、終点のx+w, y+hまで枠を書く
  cv2.rectangle(img, (x, y), (x + w, y+h), (128,128,255), 5) #薄い赤色で信号を囲む

#青信号の認識
cascade = cv2.CascadeClassifier("BLUE_cascade.xml") # RED_cascade.xmlは機械学習後のデータファイル
signal = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=2, minSize=(20, 20))
# 領域を四角形で囲む
for (x, y, w, h) in signal:
  print("x,y,w,h=",x,y,w,h)#x,y座標と幅と高さ
  # 四角描画を始点のx,yから、終点のx+w, y+hまで枠を書く
  cv2.rectangle(img, (x, y), (x + w, y+h), (128,255,128), 5) #薄い青色で信号を囲む

# 結果画像を保存
cv2.imwrite("result.jpg",img)
#結果画像を画面表示
cv2_imshow(img)
#認識結果

#151 198 68 68 326 461 98 98
#この後、改良を進めたが、実際に信号を認識させる場合は、今回のような点灯している内側のレンズ部分だけでなく、下のように無点灯の部分や、外側の枠までを含めて次のように学習させた方が認識率は上がる事が分かった。

#下記の左は実際に組み込み型PC・小型PCに実装した例で、中央の黒色がPC本体、左下がバッテリー、右下がWebカメラ、奥の白は視覚障碍者向けの振動子である。赤信号や青信号で特定のサインを手に伝えることによって、視覚障がい者は信号を判別する事ができる。右側写真はこれを視覚障碍者が操作できるようにキャリー型にした試作機である。ただしカスケード分類では、入力画像が斜めになったり歪んだりすると認識精度が悪くなるため認識精度を向上させるためCNN等を適用すると処理が重たく自動判定が遅くなる。そこでさらに高速なアルゴリズムを適用するなど試行錯誤を行っている。このように組み込み型の製品を考えると、本体の処理能力やアルゴリズムなどのバランスを総合的に判断して全体を設計する必要がある。


#動画から人を抽出するプログラム

サンプル動画を右ボタンでダウンロードする。
#動画を読み込みながら、人を検知するプログラム
#Google.colab用imshow(image)画像表示用サポートパッチのインポート
from google.colab.patches import cv2_imshow
import numpy as np
import cv2
import urllib.request as req # URL指定でファイルをダウンロードするのに利用

#人を検出したら画像に、それを囲むように四角を表示する
def draw_detections(img, rects, thickness = 3):
  for x, y, w, h in rects:
    pad_w, pad_h = int(0.15 * w), int(0.05 * h)
    cv2.rectangle(img, (x + pad_w, y + pad_h), (x + w - pad_w, y + h - pad_h), (0, 255, 0), thickness)

#検出を行う関数
def detect(filename):
  image = filename #画像の読み込み
  hog = cv2.HOGDescriptor() #人間のHOG特徴量を設定する関数(この2行で1セット)
  hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) #人間のHOG特徴量を設定する関数
  #人の認識AI関数
  found, w = hog.detectMultiScale(image, hitThreshold = 0, winStride = (8,8), padding = (0,0), scale = 1.05 ) # 検出の実行

  draw_detections(image, found) #認識した箇所に緑の四角を描画する
  cv2_imshow(image) #基の画像に認識した箇所の四角を描画したものを画面に表示する

url_img = 'https://www.toyotani.org/lib/lib/human.mp4' # Web上のデータの場所を指定(既にファイルがあればこの処理不要)
req.urlretrieve(url_img, "human.mp4") # 入力画像としてGoogleColaboratoryに保存(既にファイルがあればこの処理不要)
cap = cv2.VideoCapture("human.mp4")# 入力画像の読み込み

# メインの処理部分
while(cap.isOpened()):#動画を開いて、1フレーム毎に読み込んで認識処理を行う
  ret, frame = cap.read()#動画を開いて、1フレーム毎に画像を読み込む
  detect(frame)#認識処理を行う
cap.release()

その他

数値シミュレーションエクセルファイル

数値シミュレーションJavaファイル

数値シミュレーション2次元解析Javaファイル