目次と前回の記事

これまでに作成したモジュール

以下のリンクから、これまでに作成したモジュールを見ることができます。

これまでに作成した AI

これまでに作成した AI の アルゴリズム は以下の通りです。

関数名	アルゴリズム
`ai1`	左上から順に空いているマスを探し、最初に見つかったマスに着手する
`ai2`	ランダムなマスに着手する

`ai_match` の改良その 6（AI の視点からの結果の表示）

前回の記事から引き続き、ai_match の改良を行います。

ai_match で AI どうし の対戦を行う目的は、ある AI が、別の AI に対して どれくらいの強さ を持つかを 調べる ことにあります。しかし、現状の ai_match は、特定の AI からの視点で結果を表示するのではなく、〇と × を担当した AI からの視点 で 結果を表示 しています。そのため、ai_match の表示から、どちら の AI が 強いか を知ることは困難です。

ai_match の表示を、例えば下記のように、ai[0] からの視点で勝ち、負け、引き分け の 回数と比率 を表示すれば、ai[0] と ai[1] の どちらが強い かが わかりやすく なります。

ai1 VS ai2
count
win    435 lose    110 draw     22
win    237 lose    303 draw     27

ratio
win  76.7% lose  19.4% draw   3.9%
win  41.8% lose  53.4% draw   4.8%

`ai[0]` からの視点の通算成績の回数の計算

上記のような表示を行うためには、ai[0] からの視点での 通算成績 の回数を計算する必要があります。そこで、下記のプログラムのように、count_list を計算した後で、count_list_ai0 という変数に、ai[0] からの視点の 通算成績 を計算した結果を代入することにします。なお、このプログラムを 繰り返し を使って記述することは可能ですが、かえって わかりづらくなる ので、本記事では下記のように記述することにします。

3 ~ 7 行目：win、lose、draw のそれぞれのキーの値に、ai[0] VS ai[1] の、ai[0] から見た通算成績 の勝数、敗数、引き分け数 を代入する dict
9 ~ 13 行目：win、lose、draw のそれぞれのキーの値に、ai[1] VS ai[0] の、ai[0] から見た通算成績 の勝数、敗数、引き分け数 を代入する dict

 1  count_list_ai0 = [
 2      # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
 3      { 
 4          "win": count_list[0][Marubatsu.CIRCLE],
 5          "lose": count_list[0][Marubatsu.CROSS],
 6          "draw": count_list[0][Marubatsu.DRAW],
 7      },
 8      # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
 9      { 
10          "win": count_list[1][Marubatsu.CROSS],
11          "lose": count_list[1][Marubatsu.CIRCLE],
12          "draw": count_list[1][Marubatsu.DRAW],
13      },
14  ]

ratio の比率の計算の修正

ratio の比率の計算は、count_list_ai0 を 使って計算 する必要があるので、下記のプログラムのように、比率を計算する部分の count_list を count_list_ai0 に修正します。

for i in range(2):
    for key in count_list_ai0[i]:
        ratio_list[i][key] = count_list_ai0[i][key] / match_num

修正箇所

for i in range(2):
-   for key in count_list[i]:
+   for key in count_list_ai0[i]:
-       ratio_list[i][key] = count_list[i][key] / match_num
+       ratio_list[i][key] = count_list_ai0[i][key] / match_num

結果の表示の修正

次に、ai_match を、先程示した、下記のように表示するように修正します。

ai1 VS ai2
count
win    435 lose    110 draw     22
win    237 lose    303 draw     27

ratio
win  76.7% lose  19.4% draw   3.9%
win  41.8% lose  53.4% draw   4.8%

通算成績 の回数を代入する変数が、count_list から count_list_ai0 に変化したので、結果を表示 する部分のプログラムをそのように修正します。なお、ratio_list は、count_list_ai0 を 使って計算 するように 修正済 なので、変更する必要は ありません。

また、count_list_ai0 のキーが "win"、"lose"、"draw" に変化したので、order_list の値も、下記のプログラムのように修正する必要があります。

order_list = [ "win", "lose", "draw" ]

修正箇所

-order_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW ]
+order_list = [ "win", "lose", "draw" ]

下記は、ai_match の通算成績を表示する部分を修正したプログラムです。

2 行目：order_list を上記のように修正する
6 行目：count_list を count_list_ai0 に修正する

 1  # 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
 2  order_list = [ "win", "lose", "draw" ]
 3   
 4  # 通算成績の回数と比率の表示
 5  width = max(len(str(match_num)), 6)
 6  diff_list = [ ("count", count_list_ai0, f"{width}d"),
 7                ("ratio", ratio_list, f"{width}.1%") ]
 8  for title, data, format in diff_list:
 9      print(title)
10      for i in range(2):
11          for key in order_list:
12              print(f" {key} {data[i][key]:{format}}", end="")
13          print()
14      print()

修正箇所

# 〇の勝利、×の勝利、引き分けの順番で表示することを表す list 
-order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]
+order_list = ["win", "lose", "draw"] 

# 通算成績の回数と比率の表示
width = max(len(str(match_num)), 6)
-diff_list = [ ("count", count_list, f"{width}d"),
+diff_list = [ ("count", count_list_ai0, f"{width}d"),
              ("ratio", ratio_list, f"{width}.1%") ]
for title, data, format in diff_list:
    print(title)
    for i in range(2):
        for key in order_list:
            print(f" {key} {data[i][key]:{format}}", end="")
        print()
    print()

`ai_match` の修正

下記は、ai_match に対して上記の修正を行ったプログラムです。

from marubatsu import Marubatsu
from collections import defaultdict

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # ai[0] の勝利、勝利、引き分けの順番で表示することを表す list 
    order_list = ["win", "lose", "draw"] 

    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
            for key in order_list:
                print(f" {key} {data[i][key]:{format}}", end="")
            print()
        print()

修正箇所

from marubatsu import Marubatsu
from collections import defaultdict

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
+   count_list_ai0 = [
+       # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
+        { 
+           "win": count_list[0][Marubatsu.CIRCLE],
+           "lose": count_list[0][Marubatsu.CROSS],
+           "draw": count_list[0][Marubatsu.DRAW],
+       },
+       # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
+       { 
+           "win": count_list[1][Marubatsu.CROSS],
+           "lose": count_list[1][Marubatsu.CIRCLE],
+           "draw": count_list[1][Marubatsu.DRAW],
+       },
+   ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
-       for key in count_list[i]:
+       for key in count_list_ai0[i]:
-           ratio_list[i][key] = count_list[i][key] / match_num
+           ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # ai[0] の勝利、勝利、引き分けの順番で表示することを表す list 
-   order_list = [Marubatsu.CIRCLE, Marubatsu.CROSS, Marubatsu.DRAW]
+   order_list = ["win", "lose", "draw"] 

    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
-   diff_list = [ ("count", count_list, f"{width}d"),
+   diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
            for key in order_list:
                print(f" {key} {data[i][key]:{format}}", end="")
            print()
        print()

下記のプログラムを実行することで、ai[0] からの視点で、通算成績の回数と比率の表示が行われることが確認できます。なお、match_num の デフォルト値 である、10000 回 の対戦を行うと、数秒ほど時 間がかかる ので、対戦回数 に 1000 を指定 しています。

from ai import ai1, ai2

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count
 win     756 lose     203 draw      41
 win     446 lose     514 draw      40

ratio
 win   75.6% lose   20.3% draw    4.1%
 win   44.6% lose   51.4% draw    4.0%

`order_list` の廃止

前回の記事で説明したように、order_list は、count の 要素の値 を、dict から defaultdict に変更した結果、items メソッドを使った 繰り返し処理 で、count の キーの値 の 表示の順番 が 思い通り の順番に ならない場合がある ため 導入した ものです。

count_list_ai0 の 各要素 に代入された dict は、dict の リテラル で "win"、 "lose"、 "draw" のキーを記述した 順番通り でキーに 値を代入 するので、items メソッドを利用した 繰り返し処理 では、必ず "win"、 "lose"、 "draw" の順番でキーと キーの値 が 取り出され ます。従って、count_list_ai0 の場合は order_list は不要になります。

また、ratio_list の 各要素 に代入される dict は、count_list_ai0 の 各要素 に対する for 文 の 繰り返し処理 によってキーに 値が代入 されるので、"win"、 "lose"、 "draw" の順番でキーに 値が代入 されます。従って、比率の表示 でも order_list は不要です。

下記は、order_list を 使わない ように ai_match を修正したプログラムです。

order_list = ["win", "lose", "draw"] を削除する
5 行目：order_list を data[i].items() に修正し、繰り返しのたび に取り出すキーと キーの値 を key と value に代入する
6 行目：data[i][key] を key に修正する

この修正で、order_list を削除するだけでなく、6 行目 が簡潔になります。

1  def ai_match(ai, match_num=10000):
元と同じなので省略
2      for title, data, format in diff_list:
3          print(title)
4          for i in range(2):
5              for key, value in data[i].items():
6                  print(f" {key} {value:{format}}", end="")
7              print()
8      print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
            for key, value in data[i].items():
                print(f" {key} {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
-   # ai[0] の勝利、勝利、引き分けの順番で表示することを表す list 
-   order_list = ["win", "lose", "draw"] 

    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
-           for key, value in order_list:
+           for key, value in data[i].items():
-               print(f" {key} {data[i][key]:{format}}", end="")
+               print(f" {key} {value:{format}}", end="")
            print()
        print()

下記のプログラムを実行することで、修正後も正しく表示されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count
 win     798 lose     155 draw      47
 win     457 lose     504 draw      39

ratio
 win   79.8% lose   15.5% draw    4.7%
 win   45.7% lose   50.4% draw    3.9%

表示の修正その 1 （担当するマークの表示）

上記の表示では、それぞれ の行のデータで、ai[0] が どのマーク を担当しているかが わかりづらい ので、下記のように、各 行の先頭 に、ai[0] が担当する マークを表示 するように修正することにします。

ai1 VS ai2
count
o win     798 lose     152 draw      50
x win     436 lose     528 draw      36

ratio
o win   79.8% lose   15.2% draw    5.0%
x win   43.6% lose   52.8% draw    3.6%

そのためには、繰り返しの処理の中 で、各 行の先頭 に表示する 文字列 を要素とする list が必要になります。下記のプログラムでは、そのデータを item_text_list という名前の変数に代入しています。名前は、項目（item）の文字（text）のリストから付けました。

item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]

次に、下記のプログラムのように、結果を 表示する処理 を修正します。

4 行目：それぞれの 行を表示 する 繰り返し処理 の直前で、item_text_list[i] を表示するように修正する。その際に、改行しない ように end="" を記述する

 1  for title, data, format in diff_list:
 2      print(title)
 3      for i in range(2):
 4          print(item_text_list[i], end="")
 5          for key, value in data[i].items():
 6              print(f" {key} {value:{format}}", end="")
 7          print()
 8      print()

修正箇所

for title, data, format in diff_list:
    print(title)
    for i in range(2):
+       print(item_text_list[i], end="")
        for key, value in data[i].items():
            print(f" {key} {value:{format}}", end="")
        print()
    print()

下記は、上記の修正を行った ai_match のプログラムです。

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
            print(item_text_list[i], end="")
            for key, value in data[i].items():
                print(f" {key} {value:{format}}", end="")
            print()
        print()

全体のプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")

    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
            print(item_text_list[i], end="")
            for key, value in data[i].items():
                print(f" {key} {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 各行の先頭に表示する文字列のリスト
+   item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title)
        for i in range(2):
+           print(item_text_list[i], end="")
            for key, value in data[i].items():
                print(f" {key} {value:{format}}", end="")
            print()
        print()

下記のプログラムを実行することで、行の先頭 に マークが表示 されることが確認できます。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count
o win     804 lose     164 draw      32
x win     448 lose     508 draw      44

ratio
o win   80.4% lose   16.4% draw    3.2%
x win   44.8% lose   50.8% draw    4.4%

表示の修正その 2 （表形式での表示）

上記の表示では、win などの文字と数字が交互に 並んでいる 点が少し わかりにくい という問題があります。そこで、下記のように、表のような形式で表示することにします。

count    win   lose   draw
o        435    110     22
x        237    303     27

ratio    win   lose   draw
o      76.7%  19.4%   3.9%
x      41.8%  53.4%   4.8%

下記は、ai_match をそのように修正したプログラムです。

3 行目：end="" を記述して、count や ratio の表示の直後で 改行しない ようにする
4、5 行目：for 文 による 繰り返し処理 によって、data[0] のキーを 順番に取り出して、改行せず に表示する。その際に、キーの直前に 半角の空白 を表示することで、キーの表示 が くっつかない ようにしている
6 行目：print() を実行して改行する
9 行目：数字を表示する直前に、キーを表示する 必要が無くなった ので、items ではなく、values メソッドを使って、キーの値のみ を 取り出す ように修正する
10 行目：キーを 表示しない ように修正する

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      for title, data, format in diff_list:
 3          print(title, end="")
 4          for key in data[0]:
 5              print(f" {key}", end="")
 6          print()
 7          for i in range(2):
 8              print(item_text_list[i], end="")
 9              for value in data[i].values():
10                  print(f" {value:{format}}", end="")
11              print()
12          print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
            
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key}", end="")
        print()
        for i in range(2):
            print(item_text_list[i], end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    for title, data, format in diff_list:
-       print(title)
+       print(title, end="")
+       for key in data[0]:
+           print(f" {key}", end="")
+       print()
        for i in range(2):
            print(item_text_list[i], end="")
            for value in data[i].values():
-               print(f" {key} {value:{format}}", end="")
+               print(f" {value:{format}}", end="")
            print()
        print()

上記の 4 行目 の for 文 の 反復可能オブジェクト に data[0] を記述する点が わかりづらい と思いますので説明します。文章で説明すると長くなるので、箇条書きで説明します。

for 文 の 繰り返し処理 によって、 data には、count_list_ai0 と ratio_list が順番に代入される
この 2 つ の データ は、いずれも 2 つの要素 を持つ list であり、その 2 つの要素 は それぞれ data[0]、data[1] のように記述できる
先ほど説明したように、どの要素 も "win"、"lose"、"draw" の順番でキーに 値が代入 される dict である
従って、4 行目の for 文 の 反復可能オブジェクト に、data[0] と data[1] の どちらを記述 しても、キーは "win"、"lose"、"draw" の順番で 取り出される

上記から、4 行目の for 文 の 反復可能オブジェクト には data[0] または data[1] の どちらを記述 しても 構いません が、このような場合は、先頭の要素の data[0] を記述するのが一般的でしょう。なお、反復可能オブジェクト に count_list_ai0[0] や、ratio_list[0] などを記述しても かまいません。わかりやすい と思った記述を採用して下さい。

下記のプログラムを実行することで、表の形式 で表示されることが確認できますが、count と ratio の行と、データの表示 の行の 表示内容 が 上下でずれる という問題があります。このような、上下のずれが起きる原因について少し考えてみて下さい。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count win lose draw
o     762     195      43
x     448     516      36

ratio win lose draw
o   76.2%   19.5%    4.3%
x   44.8%   51.6%    3.6%

上下のずれの問題の修正

上下のずれ がおきる原因と 修正方法 は以下の通りです。

count、ratio と、o、x の 表示幅 が 異なる。o と x の 表示幅 を count、ratio と 同じ 5 文字 にすることで解決できる
win、lose、draw の 表示幅 が、数字の表示幅 と 異なる。これらの 表示幅 を、数字の 表示幅 である width に 合わせる ことで解決できる

下記は、そのように ai_match を修正したプログラムです。

5 行目：key の 書式指定 の 文字幅 に width を指定するように修正する
8 行目：item_text_list[i] の表示を f 文字列 を使って、書式指定 の 文字幅 に 5 を指定するように修正する

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      for title, data, format in diff_list:
 3          print(title, end="")
 4          for key in data[0]:
 5              print(f" {key:{width}}", end="")
 6          print()
 7          for i in range(2):
 8              print(f"{item_text_list[i]:5}", end="")
 9              for value in data[i].values():
10                  print(f" {value:{format}}", end="")
11              print()
12          print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")

    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:{width}}", end="")
        print()
        for i in range(2):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
-           print(f" {key}", end="")
+           print(f" {key:{width}}", end="")
        print()
        for i in range(2):
-           print(item_text_list[i], end="")
+           print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

下記のプログラムを実行すると、win、lose、draw と、その 下の数字 の ずれが解消されていない ことがわかります。その原因について少し考えてみて下さい。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count win     lose    draw   
o         787     167      46
x         453     519      28

ratio win     lose    draw   
o       78.7%   16.7%    4.6%
x       45.3%   51.9%    2.8%

揃えの修正

ずれが解消されない原因は、前回の記事で説明したように、f 文字列 では、書式指定 に 揃えを指定しない 場合は、文字列型 のデータは 左揃え で、数値型 のデータは 右揃え が 揃えに指定 されたことになるからです。従って、下記のプログラムのように、win、lose、draw の 書式指定 の揃えを 右揃え に指定することでこの問題を解決することができます。

5 行目：書式指定 の揃えに > を指定することで、key を 右揃え で表示する

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      for title, data, format in diff_list:
 3          print(title, end="")
 4          for key in data[0]:
 5              print(f" {key:>{width}}", end="")
 6          print()
 7          for i in range(2):
 8              print(f"{item_text_list[i]:5}", end="")
 9              for value in data[i].values():
10                  print(f" {value:{format}}", end="")
11              print()
12          print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")

    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
    
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(2):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
-           print(f" {key:{width}}", end="")
+           print(f" {key:>{width}}", end="")
        print()
        for i in range(2):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

下記のプログラムを実行するとで、意図通り に表示が行われることが確認できます。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count     win    lose    draw
o         780     173      47
x         436     537      27

ratio     win    lose    draw
o       78.0%   17.3%    4.7%
x       43.6%   53.7%    2.7%

行の先頭に表示する文字の、文字数が異なる場合の対処法

ai_match では、行の先頭 に表示する、count と ratio の文字列が 偶然同じ 5 文字 だったので 必要ありません でしたが、それらの 文字列の長さ が 異なる 場合は、下記のプログラムのように、表示する 文字幅 を変数に代入し、その 変数を使って 書式指定の 文字幅 を指定する必要があります。なお、変数に 文字幅 を代入しておくことで、後から 文字幅を 変更したい と思った時に、簡単に 変更できるようになる という利点が得られます。

2 行目：文字幅 を表す数値を title_width に代入する
4、9 行目：title_width を使って、書式指定 の 文字幅 を指定するように修正する

 1  def ai_match(ai, match_num=10000):
元と同じなので省略
 2      title_width = 5
 3      for title, data, format in diff_list:
 4          print(f"{title:{title_width}}", end="")
 5          for key in data[0]:
 6              print(f" {key:>{width}}", end="")
 7          print()
 8          for i in range(2):
 9              print(f"{item_text_list[i]:{title_width}}", end="")
10              for value in data[i].values():
11                  print(f" {value:{format}}", end="")
12              print()
13          print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {} ]
    for i in range(2):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num

    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    title_width = 5
    for title, data, format in diff_list:
        print(f"{title:{title_width}}", end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(2):
            print(f"{item_text_list[i]:{title_width}}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
+   title_width = 5
    for title, data, format in diff_list:
-       print(title, end="")
+       print(f"{title:{title_width}}", end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(2):
-           print(f"{item_text_list[i]:5", end="")
+           print(f"{item_text_list[i]:{title_width}}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

下記のプログラムを実行するとで、意図通り に表示が行われることが確認できます。興味がある方は、title_width の値を変更したり、diff_list の中の "count" と "ratio" を 長さの異なる文字列 に変更しても 意図通り に表示されることを確認してみて下さい。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count     win    lose    draw
o         788     192      20
x         440     534      26

ratio     win    lose    draw
o       78.8%   19.2%    2.0%
x       44.0%   53.4%    2.6%

`ai_match` の改良その 7（両方の対戦を合わせた結果の表示）

ai_match は、手番を入れ替えない場合 と、手番を入れ替えた場合 の表示を行いますが、〇×ゲーム は、〇の手番 と × の手番 で、有利不利 が 大きく異なる ゲームなので、それだけ では どちらが強いか が はっきりとしません。そこで、その両方の 対戦を合わせた 成績を計算して表示することで、どちらが強いか を 明確にする ことにします。

両方の対戦 を合わせた回数と比率は、count_list_ai0 と ratio_list の要素に代入するのが自然なので、それらの 2 番 の要素に代入することにします。

下記の表は、count_list_ai0 と ratio_list の インデックス と要素をまとめたものです。

インデックス	要素
0	順番を入れ替えない場合の対戦結果
1	順番を入れ替えた場合の対戦結果
2	両方の対戦を合わせた場合の対戦結果

両方の対戦を合わせた回数の計算

両方の対戦 を 合わせた回数 の計算は、count_list_ai0 の 0 番 と 1 番 の要素の win、lose、draw の それぞれ の 値の合計 なので、下記のプログラムのように、繰り返し処理 を使って計算することが できます。

1 行目：count_list_ai0 の 2 番 の要素として、空の dict を追加する
2、3 行目：count_list_ai0 の 0 番 の要素に代入された dict から順番に キーを取り出し、2 番 の要素の dict の そのキーの値 に、0 番 と 1 番 の要素の そのキーの値 の合計を計算して代入する

2 行目の for 文 の 反復可能オブジェクト に、count_list_ai[0] を記述した理由は、先程の「表示の修正その 2」で説明した理由と同じです。同様の理由で、反復可能オブジェクト に count_list_ai[1] を記述しても 構いません。

count_list_ai0.append({})
for key in count_list_ai0[0]:
    count_list_ai0[2][key] = count_list_ai0[0][key] + count_list_ai0[1][key]

ratio_list の 2 番 の要素は、0 番 と 1 番 の要素と 同じ方法 で計算できるので、ratio_list に関する プログラム は以下のように修正します。

1 行目：3 つ の 空の dict を要素として持つ list に修正する
2 行目：繰り返し の回数を 2 回から 3 回 に修正する

    ratio_list = [ {}, {}, {} ]
    for i in range(3):
        for key in ai_count_list[i]:
            ratio_list[i][key] = ai_count_list[i][key] / sum(ai_count_list[i])

次に、両方の対戦 を 合わせた 結果の 行の先頭 に表示する 文字列 を 決める 必要があります。両方の対戦 の合計なので、"total" と表示することにし、下記のプログラムのように、各行の 先頭に表示 する 文字列 を代入する item_text_list を修正します。

item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]

最後に、下記のプログラムの 1 行目のように、結果の行 を表示する 繰り返し処理 の回数を 2 から 3 に修正することで、両方の対戦を合わせた結果 が表示されるようになります。

for i in range(3):
    print(f"{item_text_list[i]:5}", end="")
    for value in data[i].values():
        print(f" {value:{format}}", end="")
    print()

修正箇所

-for i in range(2):
+for i in range(3):
    print(f"{item_text_list[i]:5}", end="")
    for value in data[i].values():
        print(f" {value:{format}}", end="")
    print()

下記は、ai_match を上記のように修正したプログラムです。

def ai_match(ai, match_num=10000):
元と同じなので省略
    # 両方の対戦の通算成績の合計を計算する
    count_list_ai0.append({})
    for key in count_list_ai0[0]:
        count_list_ai0[2][key] = count_list_ai0[0][key] + count_list_ai0[1][key]

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {}, {} ]
    for i in range(3):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
            
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(3):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

行番号のないプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")

    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # 両方の対戦の通算成績の合計を計算する
    count_list_ai0.append({})
    for key in count_list_ai0[0]:
        count_list_ai0[2][key] = count_list_ai0[0][key] + count_list_ai0[1][key]

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {}, {} ]
    for i in range(3):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
            
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(3):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
+   # 両方の対戦の通算成績の合計を計算する
+   count_list_ai0.append({})
+   for key in count_list_ai0[0]:
+       count_list_ai0[2][key] = count_list_ai0[0][key] + count_list_ai0[1][key]

    # それぞれの比率を計算し、ratio_list に代入する
-   ratio_list = [ {}, {} ]
+   ratio_list = [ {}, {}, {} ]
-   for i in range(2):
+   for i in range(3):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
            
    # 各行の先頭に表示する文字列のリスト
-   item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS ]    
+   item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
-       for i in range(2):
+       for i in range(3):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()

下記のプログラムを実行することで、total の行 が表示されるようになることが確認できますが、total の win の数字が 121.7% のように、100% を 超えてしまう という問題があることがわかります。このようなことが起きる原因について少し考えてみて下さい。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count     win    lose    draw
o         780     180      40
x         437     533      30
total    1217     713      70

ratio     win    lose    draw
o       78.0%   18.0%    4.0%
x       43.7%   53.3%    3.0%
total  121.7%   71.3%    7.0%

比率の計算の修正

問題は、下記の total の比率を計算するプログラムの 3 行目 の 計算式 にあります。

for i in range(3):
    for key in count_list_ai0[i]:
        ratio_list[i][key] = count_list_ai0[i][key] / match_num

具体的には、total の 試合数 は、入れ替えない場合 の match_num 回 と、入れ替えた場合 の match_num 回 の合計の、match_num * 2 回 です。それにも関わらず、上記のプログラムの 3 行目 では、比率を計算 する際に、match_num で 割っている 点が バグの原因 です。

このバグを修正する方法の一つは、下記のプログラムのように if 文 を使って、total の場合 の比率を計算する i が 2 の場合に match_num * 2 で割るという方法です。

for i in range(3):
    for key in count_list_ai0[i]:
        if i != 2:
            ratio_list[i][key] = count_list_ai0[i][key] / match_num
        else:
            ratio_list[i][key] = count_list_ai0[i][key] / (match_num * 2)

ただし、それぞれ の 試合数の合計 が count_list_ai0 の要素の win と lose と draw の キーの値 の合計であることに 気が付く ことができれば、以前の記事で紹介した、反復可能オブジェクト の 要素の合計 を計算する組み込み関数 sum を使って、上記のプログラムの処理を、下記のプログラムのように 簡潔に記述 することができます。

3 行目：count_list_ai0 の i 番 の要素に代入された dict の すべて の キーの値 の合計を sum と values メソッドを使って計算した値で、割り算 するように修正する

for i in range(3):
    for key in count_list_ai0[i]:
        ratio_list[i][key] = count_list_ai0[i][key] / sum(count_list_ai0[i].values())

dict の キーの値 の合計を計算する場合は、上記のプログラムのように、sum の 実引数 に、dict の キーの値 を要素として持つ 反復可能オブジェクト を返す values メソッドの 返り値 を記述する必要がある点に注意して下さい。これは、下記のプログラムの 1 行目のように、sum の 実引数 に、dict を そのまま記述 すると、dict の キーの値ではなく、キーの合計が計算されるからです。

a = { 1: 10, 2: 20, 3: 30 }
print(sum(a))           # キーの合計の 1 + 2 + 3 が計算される
print(sum(a.values()))  # キーの値の合計の 10 + 20 + 30 が計算される

実行結果

6
60

表示幅の修正

気づいていない方が多いのではないかと思いますが、実は、total の表示を導入したことによって、もう一つ表示に関するバグが 発生する可能性 が生じています。

それは、回数の total の行に表示される数字の 最大値 が match_num * 2 であることから、数字の 表示幅 が width = max(len(str(match_num)), 7) という計算式で計算される幅 よりも大きく なってしまう 可能性が生じるか らです。そのため、width を下記のように、match_num * 2 を 使って計算 するように修正する必要があります。

width = max(len(str(match_num * 2)), 7)

修正箇所

-width = max(len(str(match_num)), 7)
+width = max(len(str(match_num * 2)), 7)

`ai_match` の修正

下記は、ai_match を上記のように修正したプログラムです。

def ai_match(ai, match_num=10000):
元と同じなので省略
    for i in range(3):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / sum(count_list_ai0[i].values())

    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num)), 7)
元と同じなので省略

全体のプログラム

def ai_match(ai, match_num=10000):
    print(f"{ai[0].__name__} VS {ai[1].__name__}")
    
    mb = Marubatsu()

    # ai[0] VS ai[1] と ai[1] VS a[0] の対戦を match_num 回行い、通算成績を数える
    count_list = [ defaultdict(int), defaultdict(int)]
    for _ in range(match_num):
        count_list[0][mb.play(ai, verbose=False)] += 1
        count_list[1][mb.play(ai=[ai[1], ai[0]], verbose=False)] += 1

    # ai[0] から見た通算成績を計算する
    count_list_ai0 = [
        # ai[0] VS ai[1] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[0][Marubatsu.CIRCLE],
            "lose": count_list[0][Marubatsu.CROSS],
            "draw": count_list[0][Marubatsu.DRAW],
        },
        # ai[1] VS ai[0] の場合の、ai[0] から見た通算成績
        { 
            "win": count_list[1][Marubatsu.CROSS],
            "lose": count_list[1][Marubatsu.CIRCLE],
            "draw": count_list[1][Marubatsu.DRAW],
        },
    ]           

    # 両方の対戦の通算成績の合計を計算する
    count_list_ai0.append({})
    for key in count_list_ai0[0]:
        count_list_ai0[2][key] = count_list_ai0[0][key] + count_list_ai0[1][key]

    # それぞれの比率を計算し、ratio_list に代入する
    ratio_list = [ {}, {}, {} ]
    for i in range(3):
        for key in count_list_ai0[i]:
            ratio_list[i][key] = count_list_ai0[i][key] / sum(count_list_ai0[i].values())
            
    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
    width = max(len(str(match_num * 2)), 7)
    diff_list = [ ("count", count_list_ai0, f"{width}d"),
                  ("ratio", ratio_list, f"{width}.1%") ]
    for title, data, format in diff_list:
        print(title, end="")
        for key in data[0]:
            print(f" {key:>{width}}", end="")
        print()
        for i in range(3):
            print(f"{item_text_list[i]:5}", end="")
            for value in data[i].values():
                print(f" {value:{format}}", end="")
            print()
        print()

修正箇所

def ai_match(ai, match_num=10000):
元と同じなので省略
    for i in range(3):
        for key in count_list_ai0[i]:
-           ratio_list[i][key] = count_list_ai0[i][key] / match_num
+           ratio_list[i][key] = count_list_ai0[i][key] / sum(count_list_ai0[i].values())

    # 各行の先頭に表示する文字列のリスト
    item_text_list = [ Marubatsu.CIRCLE, Marubatsu.CROSS, "total" ]    
    
    # 通算成績の回数と比率の表示
-   width = max(len(str(match_num)), 7)
+   width = max(len(str(match_num * 2)), 7)
元と同じなので省略

下記のプログラムを実行することで、total の行 が 正しく表示 されるようになったことが確認できます。

ai_match(ai=[ai1, ai2], match_num=1000)

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count     win    lose    draw
o         770     196      34
x         456     506      38
total    1226     702      72

ratio     win    lose    draw
o       77.0%   19.6%    3.4%
x       45.6%   50.6%    3.8%
total   61.3%   35.1%    3.6%

`ai1` と `ai2` の対戦

AI どうし の対戦を行い、結果を表示 する関数が完成したので、これまでに作成した ai1 と ai2 で対戦を行うことにします。以前の記事で説明したように、基準となる ai2 に対し、ai1 VS ai2 と ai2 VS ai2 で対戦を行います。なお、まだ 強い AI は 作成していない ので、それまでに作成した 最も強い AI との対戦を 行う必要 は まだありません。

下記は、その対戦結果です。

ai_match(ai=[ai1, ai2])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai1 VS ai2
count     win    lose    draw
o        7811    1753     436
x        4467    5156     377
total   12278    6909     813

ratio     win    lose    draw
o       78.1%   17.5%    4.4%
x       44.7%   51.6%    3.8%
total   61.4%   34.5%    4.1%

ai_match(ai=[ai2, ai2])

実行結果（実行結果はランダムなので下記とは異なる場合があります）

ai2 VS ai2
count     win    lose    draw
o        5867    2876    1257
x        2908    5858    1234
total    8775    8734    2491

ratio     win    lose    draw
o       58.7%   28.8%   12.6%
x       29.1%   58.6%   12.3%
total   43.9%   43.7%   12.5%

この結果を 表にまとめます。この表は、関数名 の関数と、基準となる ai2 で 複数回対戦 した際の、「o を担当 した場合」、「x を担当 した場合」、「両方を合わせた 場合」、のそれぞれの勝率、敗率、引き分け率 を % の単位 で表記したものです。なお、回数の データ は 強さを評価 する際に 必要がない ので 表には入れない ことにします。

また、ai2 VS ai2 の 対戦結果 を基準とし、それよりも 勝率が高い、または、敗率が低い 数値は、基準となる ai2 に対して強い AI であることを表すため、 太字で表記 します。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
`ai1`	78.1	17.5	4.4	44.7	51.6	3.8	61.4	34.5	4.1
`ai2`	58.7	28.8	12.6	29.1	58.6	12.3	43.9	43.7	12.5

表から、ai1 は ai2 に 対して強い AI であることが わかります。ただし、以前の記事で説明したように、基準となる ai2 よりも強い からと言って、その AI が 他の ai2 より弱い AI より強い とは 限らない 点に注意して下さい。ai1 が 実際にそうである ように、ai2 と 相性が良い せいで、ai1 が ai2 に 大きく勝ち越す ような 場合がある からです。

また、ai2 VS ai2 の合計の 勝率と敗率 が 約 43% で ほぼ同じ であるという、同じ AI どうし で対戦した場合の 当然の結果 が得られたことが確認できます。

以後は、新しい AI を作成 するたびに、この 表を更新 していくことで、作成した AI の 強さの評価 を 行います。

本記事で入力したプログラム

以下のリンクから、本記事で入力して実行した JupyterLab のファイルを見ることができます。

今回の記事では、marubatsu.py は修正していないので、marubatsu_new.py はありません。

以下のリンクは、今回の記事で更新した ai.py です。

次回の記事