目次と前回の記事

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

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

これまでに作成した AI

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

ルール	アルゴリズム
ルール1	左上から順に空いているマスを探し、最初に見つかったマスに着手する
ルール2	ランダムなマスに着手する
ルール3	真ん中のマスに優先的に着手する既に埋まっていた場合はランダムなマスに着手する
ルール4	真ん中、隅のマスの順で優先的に着手する既に埋まっていた場合はランダムなマスに着手する
ルール5	勝てる場合に勝つそうでない場合はランダムなマスに着手する
ルール6	勝てる場合に勝つそうでない場合は相手の勝利を阻止するそうでない場合はランダムなマスに着手する
ルール6改	勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合はランダムなマスに着手する
ルール7	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手の勝利を阻止するそうでない場合はランダムなマスに着手する
ルール7改	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合はランダムなマスに着手する
ルール8	真ん中のマスに優先的に着手するそうでない場合は勝てる場合に勝つそうでない場合は相手が勝利できる着手を行わないそうでない場合は、次の自分の手番で勝利できるように、「自 2 敵 0 空 1」が 1 つ以上存在する局面になる着手を行うそうでない場合はランダムなマスに着手する

基準となる ai2 との 対戦結果（単位は %）は以下の通りです。太字は ai2 VS ai2 よりも 成績が良い 数値を表します。欠陥の列は、アルゴリズム に欠陥があるため、ai2 との 対戦成績 が 良くても強い とは 限らない ことを表します。欠陥の詳細については、関数名のリンク先の説明を見て下さい。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分	欠陥
`ai1` `ai1s`	78.1	17.5	4.4	44.7	51.6	3.8	61.4	34.5	4.1	あり
`ai2` `ai2s`	58.7	28.8	12.6	29.1	58.6	12.3	43.9	43.7	12.5
`ai3` `ai3s`	69.3	19.2	11.5	38.9	47.6	13.5	54.1	33.4	12.5
`ai4` `ai4s`	83.0	9.5	7.4	57.2	33.0	9.7	70.1	21.3	8.6	あり
`ai5` `ai5s`	81.2	12.3	6.5	51.8	39.8	8.4	66.5	26.0	7.4
`ai6`	88.9	2.2	8.9	70.3	6.2	23.5	79.6	4.2	16.2
`ai6s`	88.6	1.9	9.5	69.4	9.1	21.5	79.0	5.5	15.5
`ai7` `ai7s`	95.8	0.2	4.0	82.3	2.4	15.3	89.0	1.3	9.7
`ai8s`	98.2	0.1	1.6	89.4	2.5	8.1	93.8	1.3	4.9

用語の定義

これまでの記事で行ってきたいくつかの表記は、長く分かりづらいので、今回の記事から、下記の表記を行うことにします。

表記	これまでの記事での表記
ライン	直線（line）上に並んだ 3 マス
「自 x 敵 y 空 z」が存在する着手	自分の手番で着手を行った結果、「自 x 敵 y 空 z」が 1 つ以上存在する局面になる着手

必要条件と十分条件

これまでの記事では、強い AI を作るために、さまざまな条件 を考えてきましたが、それらの条件は、必要条件、十分条件、その どちらでもない条件 に分類されます。この分類は、条件によって AI が 強くなるかどうか に大きく関わる 重要な概念 なので、今回の記事では、最初にこの分類について、ルール 8 の条件を元に説明します。

ルール 8 の条件

ルール 8 には、さまざまな条件 がありますが、最後の「ランダムなマスに着手する」という条件は、強い AI を作るための 条件ではない ので、それを削除した、下記の条件 について 考える ことにします。以後の説明では、それぞれの条件を、条件 1 のように番号を使って表記することにします。

真ん中 のマスに 優先的 に着手する
そうでない場合は 勝てる場合 に勝つ
そうでない場合は相手が 勝利できる 着手を 行わない
そうでない場合は、次の 自分の手番 で 勝利できる ように、「自 2 敵 0 空 1」が存在する着手 を行う

十分条件

ある 目的を達成 するために、その条件を 満たしていれば 必ず 目的を達成できる ような条件のことを、十分条件 と呼びます。ルール 8 の条件の中で、「勝てる場合 に勝つ」という 条件 2 は、必ず勝利できる ので、強いAI の 目的を達成できる、十分条件 です。

十分条件 を 満たす ことで、必ず 目的を達成 することが できる ので、ルール に 十分条件 を 組み込む ことで、多くの場合 で AI を 強くする ことが できます。また、どんな場合 でも AI が 弱くなること は ありません。

ピンとこない人がいると思いますので、そのようなことが起きる理由について説明します。〇× ゲームの ある局面 が、下記の条件 を 満たす 場合の事を考えてみて下さい。

3 つの合法手 A、B、C が存在する
合法手 A が〇×ゲームに勝つための 十分条件 を 満たし、残りの B と C は 満たさない

この 十分条件 を ルール に 組み込んだ AI と そうでない AI が選択する着手と、その結果は 以下の表 のようになります。

	着手	結果
組み込んだ AI	A	必ず勝利する
組み込んでいない AI	A、B、C	A を選んだ場合は必ず勝利する B、C を選んだ場合はどうなるかわからない

表からわかるように、この 十分条件 を 組み込んだ AI のほうが、組み込んでいない AI よりも 勝率が悪くなる ことは 決してありません。また、上記では、合法手の数を 3 つとしましたが、合法手の数 が いくつであっても同様 です。

なお、以下の条件が満たされる場合は、AI の強さ は 変わりません。

A 以外 を選択した 後の局面 に対して、ルールを適用 した結果、必ず勝利 する場合
ルールの 他の条件 によって、A 以外 が 選択されない 場合
A 以外 の 合法手 が 存在しない 場合

上記の説明は、以前の記事での ルール 5 の検証と同様ですが、今回はルール 5 だけでなく、十分条件 を 満たす場合 に 一般化 しています。

十分条件 を ルールに組み込むこ とで、AI が 強くならない場合 があるが、弱くなる ことは 決してない ので、十分条件 であることが 分かっていれば、 安心して ルールに 組み込む ことが できる。

一般的 に、十分条件 は、目的を 達成する ための 条件の一部 でしかありません。そのことは、条件 2 のみ を ルール とする、ルール5 によって作られた ai5 より も 強い AI を、実際に 作成できている ことから 明らか でしょう。

必要条件

ある 目的を達成 するために、必要となる条件のことを 必要条件 と呼びます。ルール 8 の、「相手が 勝利できる 着手を 行わない」という 条件 3 は、この 条件を満たす着手 を 行わない と、次の相手の手番で 相手が勝利してしまう 可能性があるので、必要条件 です。

必要条件 は、目的の達成 を保証するものでは ありません が、少なくとも その条件 を 満たさなければ、目的を達成 することは 不可能 なので、AI のルールに 必要条件 を 加える ことで、AI が 強くなること が 期待できます。また、AI が 弱くなる ことは ありません。

ピンとこない人がいると思いますので、そのようなことが起きる理由について説明します。〇× ゲームの ある局面 が、下記の条件 を 満たす 場合の事を考えてみて下さい。

3 つの合法手 A、B、C が存在する
合法手 A が〇×ゲームに勝つための 必要条件 を 満たし、残りの B と C は 満たさない

この 必要条件 を ルール に 組み込んだ AI と そうでない AI が選択する着手と、その結果は 以下の表 のようになります。

	着手	結果
組み込んだ AI	A	どうなるかはわからない
組み込んでいない AI	A、B、C	A を選んだ場合はどうなるかはわからない B、C を選んだ場合は、勝利することはない

表から、組み込んでいない AI は絶対に 勝利できない B と C を 選択する可能性 がありますが、組み込んだ AI は、それらを選択することは ありません。そのため、組み込んだ AI のほうが、組み込んでいない AI よりも 勝率が悪くなる ことは 決してありません。また、上記では、合法手の数を 3 つとしましたが、合法手の数 が いくつであっても同様 です。

なお、以下の条件が満たされる場合は、AI の強さ は 変わりません。

A を選択した 後の局面 に対して、ルールを適用 した結果、必ず勝利できない 場合
ルールの 他の条件 によって、A 以外 が 選択されない 場合
A 以外 の 合法手 が 存在しない 場合

必要条件 を ルールに組み込むこ とで、AI が 強くならない場合 があるが、弱くなる ことは 決してない ので、必要条件 であることが 分かっていれば、 安心して ルールに 組み込む ことが できる。

十分条件 と 必要条件 で、上記のように 同じ結論 が得られましたが、それぞれの 結論がでる理由 は以下のように 異なります。

十分条件 は、目的を 達成する選択 を行うことで、AI を強くできる
必要条件 は、目的を 達成しない選択 を 行わない ことで、AI を強くできる

なお、あまりにも 緩い必要条件 を 満たしても、目的の達成 には ほとんど寄与しない 点に注意して下さい。例えば、テストで 100 点を取る という目的に対する 必要条件 として、テストを受ける という条件が考えられます。テストを受けなければ 絶対に 100 点を取れない ので、この条件 はれっきとした 必要条件 ですが、よほど簡単なテストでない限り、テストを受けるだけ で 100 点をとる ことができることは まずない でしょう。

必要条件 と 十分条件 を ルールに加える ことで、AI を 強くできる根拠 を示しましたが、必要条件 と 十分条件 を むやみに加えても、AI が思ったように 強くならない ことが良くあります。次は、どのような 必要条件と十分条件を 考えればよいか について説明します。

必要十分条件

必要条件 と 十分条件 の 両方を満たす ような条件のことを 必要十分条件 と呼び、以下のような性質を持ちます。

目的を 達成できない条件 は 含まれない
目的を 達成できる条件 を すべて含む

必要十分条件 の数は一つですが、必要条件 や 十分条件 を満たす条件は複数あります。

必要条件、十分条件、必要十分条件 の関係を図で書くと、下図のようになります。

それぞれの条件 を、以前の記事で説明した、集合として考えると、それぞれの条件は、下記のような 包含関係 にあります。これらのことから、必要条件、必要十分条件、十分条件 の順で、条件が厳しくなる ことがわかります。

$必要条件 ⊃ 必要十分条件 ⊃ 十分条件$

必要十分条件 を知ることで、その条件 に 従うこと が できれば¹、必ず目的を達成 することが できます。しかし、実際には、必要条件 や 十分条件 が わかっても、必要十分条件 が何であるかがはっきりと わからない ことが 良くあります。実際に、〇×ゲーム の 強い AI を作成 するための 必要条件 と 十分条件 は既に いくつか示しました が、必要十分条件 を考えることは簡単なこと ではありません。

わかりやすいように、〇×ゲーム以外の 具体例 を挙げて説明します。「漢字のテストで良い点数をとる」という目的に対する 必要条件 ははっきりとは 分かりません が、必要条件 や 十分条件 であれば、下記のように 簡単に考える ことが できます。

必要条件 の一つは「漢字の勉強をする」である
十分条件 の一つは「国語辞典の漢字をすべて暗記する」である

ただし、上記のような 簡単すぎる必要条件 は目的を達成の 役に立ちません し、厳しすぎる十分条件 は 実行することが困難 という意味であまり 役に立ちません。

必要十分条件 が 分からない場合 は、できるだけ厳しい 条件の 必要条件 と、できるだけ緩い 条件の 十分条件 を考え、2 つ の 中間の性質 を持つ、必要十分条件 に 近い条件 で 目的の達成 を 試みる ことになります。例えば、上記の例の場合は より厳しい必要条件 と、より緩い十分条件 として下記のような条件を考え、その 中間の条件 で勉強を行います。

必要条件 に 勉強時間 を指定した「漢字の勉強を 1 日 30 分勉強する」を考える
漢字のテストには 漢字の意味 は 必要ない ので、十分条件 を 緩めた「国語辞典の漢字の読み方だけをすべて暗記する」を考える

下図左 は 元の条件 を、下図右 は 新しい条件 を 図で表した ものです。実際に採用 するのは 色のついている部分 の いずれかの条件 で、新しい条件 を考えることで、色のついている部分 の 面積が減る ので、採用する条件 が 必要十分条件 に より近く なる 可能性が高くなる ことが分かります。

必要十分条件 が わからない場合 は、必要十分条件 に 近くなる ように、できるだけ厳しい必要条件 と、できるだけ緩い十分条件 を考え、その 中間の性質 をもつ条件を利用することで、目的の達成 を 試みる という方法がある。

上記で できるだけ厳しい必要条件 と述べましたが、厳しくしすぎる と 必要条件 では なくなって しまいます。また、厳しさの限界 を 見つける のは簡単なことでは ありません。例えば、漢字のテスト の例の場合は、一日に 勉強する時間 を 増やす ことで、条件を厳しく することは できます が、例えば「漢字の勉強を 1 日 10 時間勉強する」のように、厳しくしすぎて しまうと、必要条件 では なくなってしまう からです。これは、十分条件 の場合も同様で、緩くしすぎる と 十分条件 では なくなってしまいます。

これは あたりまえ のことで、必要条件 の 厳しさの限界 が、必要十分条件 であり、そもその 必要十分条件 が何であるかが わからないこと に 困っている からです。

複数の必要条件、十分条件

上記の説明を聞くと、必要条件 と 十分条件 は、最も厳しい（緩い）ものを 1 つだけ考えればよい と思う人がいるかもしれませんが、そうではありません。異なる 必要条件や十分条件が 包含関係にない 場合は、複数の 必要条件 や 十分条件 を 考える価値 が あります。

下図は、包含関係にない、必要条件 1 と 必要条件 2 を表したものです。この 2 つの十分条件 の 両方を満たす ような条件の 水色の面積 は、元の 必要条件 1 と 必要条件 2 の それぞれの面積 よりも 小さくなっている ので、条件が厳しくなる ことが分かります。

下図は、包含関係にない、十分条件 1 と 十分条件 2 を表したものです。この 2 つの十分条件 の いずれかを満たす ような 条件の面積 は、元の 十分条件 1 と 十分条件 2 の それぞれの面積 よりも 大きくなっている ので、条件が緩くなる ことが分かります。

逆に言えば、包含関係 にある複数の 必要条件 や 十分条件 は、そのうちの 最も厳しい（緩い）条件以外 は 必要ありません。

条件 3 が必要条件ではないことの説明

以前の記事で、〇×ゲームに勝つ方法 について考察し、 勝つため の条件として、「自 2 敵 0 空 1」が 存在する着手 を行う 必要がある という考察を行いました。このことから、直観的 に、ルール 8 の『「自 2 敵 0 空 1」が 存在する着手 を行う』という 条件 4 は 必要条件 であるように 思えるかもしれません が、実際には 必要条件ではありません。

確かに、〇×ゲーム に 勝つため には、ゲームが開始してから終了するまでの間の いずれかの局面 で、「自 2 敵 0 空 1」が 存在する着手 を 行う必要がある ことは 間違いありません が、それを いつ行うべきか についての考察は、以前の記事では 行っていません。そのため、ある局面 で「自 2 敵 0 空 1」が 存在する着手 を 行うことができたとしても、その着手を すぐに行う ことが勝利するために 必要である とは 限りません。

条件 4 は以前に考察した 必要条件 と 異なり、「自 2 敵 0 空 1」が 存在する着手 を 行うことができる 場合に、すぐに着手を行う という条件なので、必要条件 ではありません。

そのような細かい違いはどうでも良いのではないかと思う人がいるかもしれませんが、細かい違いであっても、目的の達成 に 大きな影響を及ぼす可能性 があるので重要です。

別の言葉 で説明すると、目的を達成 するために、必ず行わなければならない ことであったとしても、すぐに行わず に、後回し にしたほうが 良い場合がある ということです。もちろん、逆に 後回し に してはいけない場合 も あります。

ピンとこない人が多い と思いますので、いくつかの 具体例で説明 します。本当はゲームの例だけで説明をしたかったのですが、大富豪やオセロなどのゲームに詳しくない人には意味が分からない説明になるので、最初の例 は ゲームとは関係のない例 で説明します。

カップ麺を食べる 際に、お湯を注いで蓋をした後に、必ず食べる前に 蓋を開ける必要 があります。つまり、蓋を開ける ことが、カップ麺を食べる ための 必要条件 です。しかし、蓋を開ける必要がある からといって、お湯を注いだ直後 に 蓋を開けた場合 は おいしいカップ麺 が 食べられません。この場合は、3 分待ってから 蓋を 開けるべき です。

大富豪 というトランプの ゲームの目的 は、自分の手持ちの カードをすべて捨てる ことなので、カードを捨てる ことが勝つための 必要条件 になります。しかし、強いカード をゲームの 早いうちに捨ててしまう と、ゲームの終盤に弱いカードしか手元に残らなくなってしまうため、ゲームに 勝つこと が 困難になります。

オセロ というゲームは、ゲーム終了時に 自分の色の駒の数 が 多いほうが勝利 します。そのため 初心者 は、ゲームの序盤から 自分の色 の 駒の数が多くなる ような着手を 行う人が多い ようですが、実際には序盤で そのような着手 を行うと、大きく不利 になる場合が多く、勝つこと が 困難になります。

必要条件でも十分条件でもない条件

ルール 8 の 条件 4 は、必要条件 では ありません が、どのタイミング で「自 2 敵 0 空 1」が 存在する着手 を 行えば良いよいか については、現時点での考察では はっきりとしていません。また、実際に どのタイミング で「自 2 敵 0 空 1」が 存在する着手 を 行えば良いよいか を考察して 見つける ことは 簡単ではありません。興味がある方は少し考えてみて下さい。簡単に答えが出せない ことが 実感できる のではないかと思います。

そのような場合に、どこかで必ず「自 2 敵 0 空 1」が 存在する着手 を 行う必要がある のだから、必要条件ではない 条件 4 を 入れる価値がある と判断して 採用する という 考え方があり、実際に そのような理由 で、必要条件 でも 十分条件 でもない条件をルールに 組み込む ことが 良く行われます。

そのようなことが行われる理由は、目的を達成 するために有効な、必要条件 や 十分条件 を 満たす条件 を 数多く考える ことが、困難な場合が多い からです。また、思いついた場合 でも、本当に その条件 が 必要条件 や 十分条件 であるかどうかの 証明を行う ことが 難しい場合 が 良くあります。なお、上記で 有効な という条件をつけたのは、先程の例で挙げた「テストの勉強をする」、「辞書を暗記する」のような、ほとんど 意味のない、緩い必要条件 や、厳しい十分条件 であれば、いくらでも考えることができる からです。

一方、必要条件 や 十分条件 であることは 証明できない が、有効そうである 条件であれば、証明を行う必要がない ので、気軽に考える ことが できます。実際に ルール 8 の「真ん中のマス に 優先的に着手 する」という 条件 1 は、必要条件 であることは 証明されていません が、有効である 可能性が高い ことを以前の記事で考察し、実際に ルール 3 に 組み込んだ結果、強くなる ことが 確認できました。

必要条件 でも 十分条件 でもない条件は、ルールに組み込む ことによって 弱くなる可能性 があります。そのため、その条件が 有効であるか どうかはどうかは、その条件を ルール に 組み込んでいない 他の AI と対戦 して 比較する ことで 確認する 必要があります。比較した結果、強くなっていれば採用し、弱くなっていれば 採用を見送り ます。

下図の 薄い水色 が、必要条件 でも 十分条件 でも ない条件 の例です。図からわかるように、必要条件の外 に はみ出している部分 があり、その部分 によって 選択が行われる と、目的が達成できなく なります。また、必要十分条件 に 重なっている部分 によって 選択が行われる と、目的が達成 できます。従って、必要条件 や 十分条件 を 考える場合 と同様に、必要十分条件 に 近くなるような条件 を 考える ことが重要になります。

以前の記事でも言及しましたが、ルールベースの AI は、必要条件 でも 十分条件 でもない 条件を追加 することで、下記のような 問題が発生 することが多いため、ルールベースで 強い AI を作るのはかなり 困難な作業 になります。

以前の記事の ルール 4 で追加した「真ん中、隅のマスの順で 優先的 に着手する」という条件のように、一見すると AI が強くなっている ように見える が、実際には特定の AI に 対してのみ強く なっているという場合がある
条件が増える と、条件どうし の相性や矛盾などの問題で、突然 AI が弱くなる という 現象が発生 することがある
条件が増える と、ルール が 複雑になりすぎて、何を行っているか が 分かりづらくなる²
条件が増える と、新しい 有効な 条件を考える ことが困難になる
条件が増える と、新しい条件 を追加してもほとんど AI が 強くならなく なる

従って、最近の AI は人間が ルールを考える というルールベースではなく、AI が 自動的 に ルール を発見する、機械学習 という手法を使ったものが主流になっています。〇×ゲームの AI を機械学習で作成する方法については、今後の記事で紹介します。

なお、〇×ゲーム は、単純なゲームなので、ルールベース でも 最強の AI を作ることが可能なので、引き続きルールベースで〇×ゲームの AI を作成します。

ルールベースの AI の作成手順

ルールベースの AI の 一般的 な 作成手順 をまとめます。本記事 でも、実際に 下記の手順 でこれまで 〇×ゲーム の AI を作成 してきました。

必要十分条件 を 考える ことが できれば、それを ルールに組み込む ことで 最強の AI を 作成できる が、一般的 には 必要十分条件 が 分からない ことが多い
十分条件 を考え、ルール に 組み込む ことで、AI を 強くする
必要条件 を考え、ルール に 組み込む ことで、AI を 強くする
必要条件 でも 十分条件 でもない、有望そうな条件 を考え、ルール に 組み込んで AI を実装し、他の AI と 対戦する ことでその 性能を確かめる
- 強くなっていれば その 条件を採用 する
- 強くならない（弱くなっている）場合は、その条件を破棄する³

2 つ目の十分条件を組み込んだ AI

ルール 8 の 条件 2 は、現在の局面 で 勝利できる場合 に 勝利する というものでしたが、未来の局面 で 必ず勝利できる場合 でも 強い AI の 目的を達成 することが できます。そこで、次の 自分の手番 の局面で 必ず勝利できる ための条件を 考える ことができれば、それを 十分条件 と みなす ことが できます。〇×ゲームにある程度慣れている方には当たり前の事かもしれませんが、それがどのような条件であるかについて少し考えてみて下さい。

まず、前提条件 を明確にすることにします。次の 自分の手番 で 勝利できる ということから、「現在の局面 で 勝利できない」という 条件が必要 です。また、次の 相手の手番 で 相手が勝利 すると目的が 達成できない ので、「次の 相手の手番 で相手が 勝利しない」という 条件が必要 になります。これらは、ルール 8 の 条件 2 と 3 によって 判定できます。

ルール 8 の 条件 4 の着手を行っても、必ず勝利 できるとは 限らない理由 は、〇×ゲーム は、自分と相手 が交互に 着手を行う ゲームなので、「自 2 敵 0 空 1」が 存在する着手 を行っても、次の 相手の手番 で「自 2 敵 0 空 1」の ライン の 空いているマス に相手が 着手を行う ことで、邪魔をされてしまう 可能性がある からです。

しかし、「自 2 敵 0 空 1」の ライン が 2 つ以上 ある場合は、次の 相手の手番 で 邪魔をできる のは、そのうちの 1 つ の ラインだけ です。例えば、下図の局面の場合、× が次の 〇の手番 での 勝利を阻止 するためには、2 つ ある 黄色のマス に着手を 行う必要 がありますが、自分の手番 で行える着手は 1 マスだけ なので、どちらか の 黄色のマス は必ず 空のまま 残ってしまうので、次の 〇の手番 で〇が 必ず勝利 することが できます。

従って、次の 自分の手番 の局面で 必ず勝利できる ための条件は、以下のようになることが分かります。

ルール 8 の 条件 2 を 満たさない
ルール 8 の 条件 3 を 満たさない
「自 2 敵 0 空 1」が 2 つ以上 存在する着手を行う

同様に、2 手先 や 3 手先 の 自分の手番 で自分が 必ず勝利できる条件 を考え、それを 十分条件 と みなす ことが できます が、でそのような条件を みつける のは 簡単ではありません。数手先 の 未来の局面 を 本格的 に 考慮に入れる AI については、ルールベースの次の、探索型の AI の所で説明します。

ルール 9 の定義

上記の条件 を ルール 8 に 加えた、ルール 9 を下記のように定義する事にします。新しい条件 は、十分条件 なので、十分条件でない ルール 8 の 条件 4 よりも 優先順位 を 高くする 必要があります。下記が ルール 9 の定義_ です。なお、新しい条件 の内容に 合わせて、ルール 8 の 条件 4 を、『「自 2 敵 0 空 1」が 存在する着手 を行う』から『「自 2 敵 0 空 1」が 1 つ存在 する着手を行う』のように修正しました。

今回から、それぞれの 条件の種類 を 表で示す ようにしました。種類の列が空欄になっている条件は、必要条件 でも、十分条件 でもないことを表します。また、条件は 優先順位 の 高い順 に 並んでいる ので、「そうでない場合は」は削除しました。

条件	種類
真ん中のマスに優先的に着手する
勝てる場合に勝つ	十分条件
相手が勝利できる着手を行わない	必要条件
次の自分の手番で必ず勝利できるように、「自 2 敵 0 空 1」が 2 つ以上存在する着手を行う	十分条件
次の自分の手番で勝利できるように、「自 2 敵 0 空 1」が 1 つ存在する着手を行う
ランダムなマスに着手する

ルール 9 の 評価値 をどのように設定すればよいかについて少し考えてみて下さい。

評価値の設定

下記は、ルール 8 の 評価値 の設定です。

優先順位	局面の状況	評価値
1	真ん中のマスに着手している	`3`
2	自分が勝利している	`2`
4	「自 2 敵 0 空 1」が 1 つ以上存在する	`1`
5	「自 2 敵 0 空 1」が存在しない	`0`
3	相手が勝利できる	`-1`

上記の表に、ルール 9 の『「自 2 敵 0 空 1」が 2 つ以上存在する』という 新しい条件 を追加した状態の 評価値を設定 する必要があります。

下記の表は、ルール 9 の 条件の優先順位 に注意しながら 評価値 を設定した例です。上 2 つ の 評価値 は、新しい条件の追加に合わせて修正しました。

優先順位	局面の状況	評価値
1	真ん中のマスに着手している	`4`
2	自分が勝利している	`3`
4	「自 2 敵 0 空 1」が 2 つ以上存在する	`2`
5	「自 2 敵 0 空 1」が 1 つ存在する	`1`
6	「自 2 敵 0 空 1」が存在しない	`0`
3	相手が勝利できる	`-1`

マークのパターンを数える関数の定義

『「自 2 敵 0 空 1」が 2 つ以上存在する』という条件を判定するためには、マークパターン の数を 数える 必要がありますが、enum_markpats は、マークのパターン が 存在するかどうか を計算するだけで、数を 数える機能 を 持たない ので、利用することは できません。そこで、マークのパターン の数を 数える 下記の メソッド を定義する事にします。

名前：マーク（mark）の パターン（pattern）を 数える（count）ので、count_markpats という名前にする
処理：インスタンスの局面の マークのパターン を 数える
入力：なし
出力：マークのパターン を 数えた データを 返り値 として返す

enum_markpats を修正し、マークのパターン を 数える機能 を追加するという方法も 考えられます が、名前に列挙（enumerate）の単語が入ったメソッドで、列挙とは 異なる 数える（count）という処理を 行うようにする と、プログラムが わかりづらくなる ので、本記事では 別の名前 の メソッドを定義 する事にします。

数を 数える処理 は、count_marks と同様に、以前の記事で紹介した、defaultdict を利用する方法が 考えられます。count_marks では、defaultdict のキーに マーク を表す 文字列 を利用しましたが、count_markpats では、マークのパターン を 数える 必要があるので、defaultdict が 使えない と 思う人 が いるかもしれません。実際には、dict や defaultdict は、キーに ハッシュ可能なオブジェクト を利用でき、前回の記事で、マークのパターン を表すデータを ハッシュ可能なオブジェクト である NamedTuple に変更したので、マークのパターン を defaultdict を使って 数える ことが可能です。下記は、count_markpats の定義で、enum_markpats を修正することで、簡単に定義 することが できます。

なお、enum_markpats は削除せず、そのまま残しています。

5 行目：マークのパターン を 数える 変数を 初期化 する際に 代入する値 を、空の set から 空の defaultdict に修正する
10、12、15、18 行目：マークのパターン の キーの値 に 1 を足して 数を 数える

 1  from marubatsu import Marubatsu, Markpat
 2  from collections import defaultdict
 3
 4  def count_markpats(self):
 5      markpats = defaultdict(int)
 6 
 7      # 横方向と縦方向の判定
 8      for i in range(self.BOARD_SIZE):
 9          count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
10          markpats[count] += 1
11          count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
12          markpats[count] += 1
13      # 左上から右下方向の判定
14      count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
15      markpats[count] += 1
16      # 右上から左下方向の判定
17      count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
18      markpats[count] += 1
19
20      return markpats
21
22  Marubatsu.count_markpats = count_markpats

行番号のないプログラム

from marubatsu import Marubatsu, Markpat
from collections import defaultdict

def count_markpats(self):
    markpats = defaultdict(int)
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
        count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
        markpats[count] += 1
        count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
        markpats[count] += 1
    # 左上から右下方向の判定
    count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
    markpats[count] += 1
    # 右上から左下方向の判定
    count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
    markpats[count] += 1

    return markpats

Marubatsu.count_markpats = count_markpats

修正箇所

from marubatsu import Marubatsu, Markpat
from collections import defaultdict

-def enum_markpats(self):
+def count_markpats(self):
-   markpats = set()
+   markpats = defaultdict(int)
 
    # 横方向と縦方向の判定
    for i in range(self.BOARD_SIZE):
        count = self.count_marks(coord=[0, i], dx=1, dy=0, datatype="tuple")
-       markpats.add(count)
+       markpats[count] += 1
        count = self.count_marks(coord=[i, 0], dx=0, dy=1, datatype="tuple")
-       markpats.add(count)
+       markpats[count] += 1
    # 左上から右下方向の判定
    count = self.count_marks(coord=[0, 0], dx=1, dy=1, datatype="tuple")
-   markpats.add(count)
+   markpats[count] += 1
    # 右上から左下方向の判定
    count = self.count_marks(coord=[2, 0], dx=-1, dy=1, datatype="tuple")
-   markpats.add(count)
+   markpats[count] += 1

    return markpats

Marubatsu.count_markpats = count_markpats

下記は、いくつか の局面で、count_markpats を使って マークのパターン の数を 数える プログラムです。実行結果 から、正しく動作 することが確認できます。

from pprint import pprint
mb = Marubatsu()

print(mb)
pprint(mb.count_markpats())

mb.move(1, 1)
print(mb)
pprint(mb.count_markpats())

mb.move(0, 0)
print(mb)
pprint(mb.count_markpats())

mb.move(1, 0)
print(mb)
pprint(mb.count_markpats())

実行結果

Turn o
...
...
...

defaultdict(<class 'int'>, {Markpat(last_turn=0, turn=0, empty=3): 8})
Turn x
...
.O.
...

defaultdict(<class 'int'>,
            {Markpat(last_turn=0, turn=0, empty=3): 4,
             Markpat(last_turn=1, turn=0, empty=2): 4})
Turn o
X..
.o.
...

defaultdict(<class 'int'>,
            {Markpat(last_turn=0, turn=0, empty=3): 2,
             Markpat(last_turn=0, turn=1, empty=2): 3,
             Markpat(last_turn=1, turn=0, empty=2): 2,
             Markpat(last_turn=1, turn=1, empty=1): 1})
Turn x
xO.
.o.
...

defaultdict(<class 'int'>,
            {Markpat(last_turn=0, turn=0, empty=3): 2,
             Markpat(last_turn=0, turn=1, empty=2): 1,
             Markpat(last_turn=1, turn=0, empty=2): 2,
             Markpat(last_turn=1, turn=1, empty=1): 2,
             Markpat(last_turn=2, turn=0, empty=1): 1})

`ai9s` の定義

count_markpats を利用することで、ai9s は下記のプログラムのように定義できます。修正点 は、評価値の修正 と、markpats の キーの値 を使って 判定を行う 点です。

7、11 行目：評価値 を 評価値の表 に合わせて修正する
15 行目：markpats の「自 0 敵 2 空 1」の キーの数 が 正の場合 に、相手が 勝利できる と判定するように修正する
18 行目：markpats の「自 2 敵 0 空 1」の キーの数 が 2 以上 の場合は、次の 自分の手番 で自分が 必ず勝利できる と判定して、評価値 として 2 を返す
21 行目：markpats の「自 0 敵 2 空 1」の キーの数 が 1 の場合 に、次の 自分の手番 で自分が 勝利できる と判定するように修正する

 1  from ai import ai_by_score
 2
 3  def ai9s(mb, debug=False):
 4     def eval_func(mb):
 5          # 真ん中のマスに着手している場合は、評価値として 4 を返す
 6          if mb.last_move == (1, 1):
 7              return 4
 8   
 9          # 自分が勝利している場合は、評価値として 3 を返す
10          if mb.status == mb.last_turn:
11              return 3
12
13          markpats = mb.count_markpats()
14          # 相手が勝利できる場合は評価値として -1 を返す
15          if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
16              return -1
17          # 次の自分の手番で自分が必ず勝利できる場合は評価値として 2 を返す
18          elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
19              return 2
20          # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
21          elif markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
22              return 1
23          # それ以外の場合は評価値として 0 を返す
24          else:
25              return 0
26
27      return ai_by_score(mb, eval_func, debug=debug)

行番号のないプログラム

from ai import ai_by_score

def ai9s(mb, debug=False):
    def eval_func(mb):
        # 真ん中のマスに着手している場合は、評価値として 4 を返す
        if mb.last_move == (1, 1):
            return 4
    
        # 自分が勝利している場合は、評価値として 3 を返す
        if mb.status == mb.last_turn:
            return 3

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -1
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 2 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
            return 2
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
            return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

from ai import ai_by_score

-def ai8s(mb, debug=False):
+def ai9s(mb, debug=False):
    def eval_func(mb):
        # 真ん中のマスに着手している場合は、評価値として 4 を返す
        if mb.last_move == (1, 1):
-           return 3
+           return 4
    
        # 自分が勝利している場合は、評価値として 3 を返す
        if mb.status == mb.last_turn:
-           return 2
+           return 3

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
-       if Markpat(last_turn=0, turn=2, empty=1) in markpats:
+       if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -1
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 2 を返す
-       elif Markpat(last_turn=2, turn=0, empty=1) in markpats:
+       elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
-           return 1
+           return 2
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
+       elif markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
+           return 1
        # それ以外の場合は評価値として 0 を返す
        else:
            return 0

    return ai_by_score(mb, eval_func, debug=debug)

`ai2` と `ai8s` との対戦

基準となる ai2 と、これまで に作成した 最強の AI である ai8s と対戦することにします。まず、下記のプログラムで ai2 と対戦します。

from ai import ai_match, ai2, ai8s

ai_match(ai=[ai9s, ai2])

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

ai9s VS ai2
count     win    lose    draw
o        9867      15     118
x        8961     237     802
total   18828     252     920

ratio     win    lose    draw
o       98.7%    0.1%    1.2%
x       89.6%    2.4%    8.0%
total   94.1%    1.3%    4.6%

下記は、ai8s VS ai2 と ai9s VS ai2 の対戦結果の表です。ai2 に対して、ai9s のほうが、ai8s より 勝率が高くなる ことが確認できます。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
`ai8s`	97.3	1.5	1.3	86.1	8.5	5.4	91.7	5.0	3.3
`ai9s`	98.7	0.1	1.2	89.6	2.4	8.0	94.1	1.3	4.6

次に、ai8s と対戦を行います。実行結果 の 通算成績 から、ai9s が ai8s に 対して強くなっており、新しい条件 の 有効性 が確認できました。

ai_match(ai=[ai9s, ai8s])

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

ai9s VS ai8s
count     win    lose    draw
o        5019     397    4584
x         409    3365    6226
total    5428    3762   10810

ratio     win    lose    draw
o       50.2%    4.0%   45.8%
x        4.1%   33.7%   62.3%
total   27.1%   18.8%   54.0%

マークのパターンの考察

これまでのルール では、マークのパターン のうち、「自 0 敵 2 空 1」と「自 2 敵 0 空 1」のみを利用 してきましたが、他の マークのパターン も 局面の状況 を 表している と 考えられる ので、それぞれ の マークのパターン の考察を行うことにします。

下記の表は、マークのパターン の一覧で、10 種 類ある事が分かります。それぞれ の マークのパターン の性質がどのようなものであるかについて、少し考えてみて下さい。

自	敵	空
3	0	0
2	1	0
2	0	1
1	2	0
1	1	1
1	0	2
0	3	0
0	2	1
0	1	2
0	0	3

「自 3 敵 0 空 0」

このマークのパターンは、自分が勝利 していることを 表します が、自分の勝利 は、status 属性 で 判定済 なので、このマークのパターンを考慮する必要は ありません。

「自 0 敵 3 空 0」

このマークのパターンは、相手が勝利 していることを 表します が、〇×ゲーム は、自分の着手 によって 相手が勝利 することは あり得ない ので、このマークのパターンが出現することは ありません。従って、このマークのパターンを考慮する必要は ありません。

「自 2 敵 0 空 1」

このマークのパターンは、今回の記事 で 考察済 です。なお、このマークのパターンが 2 つ以上 ある場合に、その 数を区別 する 必要があるか どうかが気になる人がいるかもしれないので補足します。このマークのパターンが 2 つ以上 ある場合は、いくつであっても 次の自分の手番で 自分が勝利できる ことに 変わりはありません ので、このマークのパターンが 2 つ以上 の場合の 数の違い を 区別しなくても、AI の強さ に影響は 与えません。

「自 0 敵 2 空 1」

このマークのパターンは既に ルールの条件 に 組み込まれています。このマークのパターンが 1 つ以上 ある場合も、上記と同様に、いくつであっても、次の相手の手番で 相手が勝利できる ことに 変わりがない と思う人が多いのではないかと思います。実際には AI の強さ に少しだけ 影響を与える のですが、その点については次回の記事で説明することにします。興味がある方は、どのような影響を与えるかについて少し考えてみて下さい。

自と敵がのマークが両方あるパターン

「自 2 敵 1 空 0」、「自 1 敵 1 空 1」、「自 1 敵 2 空 0」の 3 種類 のマークのパターンは、その ライン に自分と敵の 両方のマーク が 配置されている ことを表します。〇×ゲーム は、一度配置 した マーク は ゲームが終了 するまで 変化しない ので、これらの マークのパターンの ライン は、今後のゲームの勝敗に 影響を与えない可能性が高い ことが考察できます。従って、このマークのパターンの数は AIの強さ に 影響を及ぼさない可能性が高い ことが推測できます。なお、絶対に 影響を及ぼさない という証明は 行っていない ので、あくまで 可能性が高い に 過ぎない 点に注意して下さい。

「自 0 敵 0 空 3」

このマークのパターンの ライン は、自分と相手の両方が、今後 勝利できる可能性がある ラインです。従って、このマークのパターンの数が どちらか に 有利に働く ということは なさそう なので、AI の強さ に影響を 及ぼさない可能性が高い ことが推測できます。

「自 1 敵 0 空 2」

〇×ゲーム に勝利するためには、「自 2 敵 0 空 1」が 存在する着手 を行う必要がありますが、そのため には、自分の 前の手番 で「自 1 敵 0 空 2」が 存在する着手 を 行う必要 があります。従って、ゲームが終了するまでの間 に必ず「自 1 敵 0 空 2」が 存在する着手 を行うことが、〇×ゲーム に 勝利するため の 必要条件 であることが分かります。

ただし、「自 2 敵 0 空 1」の場合と同様に、どのタイミング で「自 1 敵 0 空 2」が 存在する着手 を 行う必要 があるかまでは わかりません ので、必要条件 では ありません が、「自 1 敵 0 空 2」が 存在する着手 を すぐに行う という条件を考えることにします。

次に、「自 1 敵 0 空 2」の数を考察することにします。「自 1 敵 0 空 2」の数が多ければ 多い程、次の 自分の手番 で、「自 1 敵 0 空 2」が 残っている可能性が高くなる ので、「自 1 敵 0 空 2」の数が多いことが 望ましい ことが推測できます。

また、「自 1 敵 0 空 2」の 数を増やす ということは、相手が勝つ ことが できるライン を 減らす ことにも つながります。そのような理由 からも、「自 1 敵 0 空 2」の数が多いことが 望ましい ことが推測できます。

「自 0 敵 1 空 2」

相手の立場 から考えると、このマークのパターンは「自 1 敵 0 空 2」になるので、「自 0 敵 1 空 2」の 数が多い ということは、相手の勝利 の 可能性が高くなる ことが推測できます。従って、「自 0 敵 1 空 2」の数が 少ない ことが 望ましい ことが推測できます。

マークのパターンの考察のまとめ

下記は、上記の考察 を 表にまとめた ものです。

自	敵	空	考察
3	0	0	`status` 属性で確認済なので、考慮する必要はない
0	3	0	あり得ないので考慮する必要はない
2	0	1	既にルールに組み込まれているので新しく考慮する必要はない
0	2	1	既にルールに組み込まれているので新しく考慮する必要はない
2	1	0	どちらの勝利にも影響しない可能性が高いので考慮する必要はない
1	2	0	どちらの勝利にも影響しない可能性が高いので考慮する必要はない
1	1	1	どちらの勝利にも影響しない可能性が高いので考慮する必要はない
0	0	3	どちらの勝利にも影響しない可能性が高いので考慮する必要はない
1	0	2	多いほうが有利になる
0	1	2	少ないほうが有利になる

上記の表 から、以下の 2 つ の条件を ルールに組み込む ことで AI が 強くなる可能性が高い ことが 推測される ので、条件に組み込む ことにします。なお、いずれの条件 も、必要条件 でも 十分条件 でも ありません ので、組み込む ことで 弱くなる可能性 があります。

「自 1 敵 0 空 2」の数が 最も多い 着手を行う
「自 0 敵 1 空 2」の数が 最も少ない 着手を行う

ルール 10

まず、『「自 1 敵 0 空 2」の数が 最も多い 着手を行う』という条件を ルール 9 に追加した ルール 10 を定義する事にします。どのように定義すればよいかについて少し考えてみて下さい。

複数の条件が同時に満たされる場合のルール

ルール 9 まで は、すべての条件 には 明確な理由 を元にした 優先順位 があり、上位の条件 が 満たされた時点 で 評価値が決定 され、それより 下位の条件 は 考慮されません でした。

一方、ルール 9 の『「自 2 敵 0 空 1」が 1 つ存在 する』と、『「自 1 敵 0 空 2」の数が 最も多い』という条件が同時に 満たされた場合 に、どちらを優先すればよいか については、明確では ありません。従って、ルール 10 は、下記のように、同じ優先順位 に 複数の条件 が 存在する ように定義する必要があります。このような場合に、どのように評価値 を設定すればよいかについて少し考えてみて下さい。なお、長くて表が見づらいので、条件の内容を簡略化しました。

順位	条件	種類
1	真ん中のマスに優先的に着手する
2	勝てる場合に勝つ	十分条件
3	相手が勝利できる着手を行わない	必要条件
4	「自 2 敵 0 空 1」が 2 つ以上存在する着手を行う	十分条件
5	「自 2 敵 0 空 1」が 1 つ存在する着手を行う「自 1 敵 0 空 2」が最も多い着手を行う
6	ランダムなマスに着手する

同じ優先順位の条件に対する評価値の設定方法

同じ優先順位 の条件が 複数存在 する場合に、どのような 評価値 を 設定するか については、下記のように、それぞれの条件 が 満たされる場合 と 満たされない場合 の すべての組み合わせ を表にして考察すると良いでしょう。

	「自 2 敵 0 空 1」が 1 つ	「自 1 敵 0 空 2」が最も多い
組み合わせ 1	×	×
組み合わせ 2	〇	×
組み合わせ 3	×	〇
組み合わせ 4	〇	〇

片方の条件 が同じであれば、明らかに もう片方の条件 が 満たされる方 の 評価値 を 高くする必要 があります。そのため、上記の表 から、それぞれの組み合わせ に対する 評価値 には、下記のような 関係がある ことが 分かります。

組み合わせ 1 の評価値 < 組み合わせ 2 の評価値 < 組み合わせ 4 の評価値
組み合わせ 1 の評価値 < 組み合わせ 3 の評価値 < 組み合わせ 4 の評価値

上記の条件 を 満たす ことができれば、それぞれ の 組み合わせ の 評価値 を どのように設定 しても 構いません。評価値の設定方法 について少し考えてみて下さい。

最も簡単 な方法は、それぞれ の条件が単独で 満たされる場合 の 正の評価値 を 個別に設定 し、組み合わせ の 評価値を計算 する際に、合計を計算 するという方法でしょう。

よりふさわしい方法があれば、そちらを採用しても構いません。

例えば、『「自 2 敵 0 空 1」が 1 つ存在 する』が 満たされる場合 の 評価値 を A、『「自 1 敵 0 空 2」の数が 最も多い』が 満たされる場合 の 評価値 を B と設定した場合は、それぞれ の 組み合わせ の 評価値 は 下記の表 のように、簡単な方法 で計算できます。なお、A と B は 正の数 とし、具体的な値 は この後 で設定します。

	「自 2 敵 0 空 1」が 1 つ	「自 1 敵 0 空 2」が最も多い	評価値
組み合わせ 1	×	×	0
組み合わせ 2	〇	×	A
組み合わせ 3	×	〇	B
組み合わせ 4	〇	〇	A + B

先程の、それぞれ の 組み合わせ の 評価値 の関係を表す式に、上記の 評価値 を 当てはめる と下記の式になります。A と B は 正の値 なので、下記の 2 つ の式が 常に正しくなる ことは 明らか でしょう。

0 < A < A + B
0 < B < A + B

具体的な評価値の設定方法

上記の方針 で 評価値を設定 する場合は、A と B に どのような値 を設定すればよいかについて 考える必要 があります。A と B は それぞれ の条件の 評価値 を表すので、下記の表 のように、それぞれの条件 の 重要度 を 考慮した評価値 を設定する必要があります。

A と B の関係	A と B の重要度
A > B	A の条件のほうが、B の条件よりも重要度が高い
A = B	A の条件と B の条件の重要度が同程度か、関係が不明である
A < B	A の条件のほうが、B の条件よりも重要度が低い

今回の場合、『「自 2 敵 0 空 1」が 1 つ存在 する』と『「自 1 敵 0 空 2」が 最も多い』の どちら の条件が 重要であるか は わかっていません。また、仮に 片方が重要 だとしても、どれくらい重要 であるかは わからない ことが 良くあります。そのような場合 は、以下のような 試行錯誤 による方法で 評価値 を設定するのが 一般的 です。

とりあえず おおざっぱに 評価値 を設定して AI を実装 する
実装した AI と 他の AI を対戦させて、強さを評価 する
A または B の 評価値 を 少し変化 させて、対戦させる
手順 2 と 3 を 何度も繰り返し、最も成績が良い 評価値の 組み合わせ を採用する

試行錯誤 の回数が 多くなればなるほど、手間と時間が増大します。そのため、上記の 手順 3 で、効率よく A や B の 評価値 を 変化させながら、上記の手順 を 行う必要 があります。その方法については、機械学習の手法を紹介する際に説明する予定です。

今回の条件 の場合は、上記の試行錯誤 は 数回だけ行う ことにします。

まず、A の 評価値 として、とりあえず 1 を設定 することにします。次に B の評価値 を 決める必要 がありますが、これまでのように、特定の数 を設定することは できません。その理由について少し考えてみて下さい。

数を考慮する評価値の設定方法

ルール 9 まで の条件では、その 条件が満たされるかどうか で 評価値が決まりました。一方、ルール 10 で追加する『「自 1 敵 0 空 2」が 最も多い』という条件は、マークのパターン の数が 多いほど 評価値が 大きくなる ように 評価値を設定 する必要があります。

そのような場合に 最も簡単 な 評価値 の 計算方法 は、$a$ を 正の数、$x$ を マークのパターン の数とした場合に、下記の式 で計算するという方法です。

$評価値 = a × x$

最もわかりやすい のは、$a$ に 1 を設定する場合で、その場合の 評価値 は、マークのパターンの数 を表す $x$ になります。$x$ が 増えれば、評価値も増える ので、「自 1 敵 0 空 2」が 最も多い場合 の 評価値 が 最も高くなる ことは 明らか でしょう。

今回は、B の 評価値 として、この $x$ を採用することにします。

$x$ が 増えれば、評価値 が 増える という 条件が満たされる のであれば、評価値 の式は どのような式 でも 構いません。例えば、下記の式でも かまいません が、特に理由がない限り、先程紹介した 最も簡単な式 を採用するのが 一般的 でしょう。

$評価値 = a × x^2$

ルール 10 の評価値の設定

下記は、上記を元 に、ルール 10 の 評価値を設定 した表です。「個別」の列には、同じ優先順位 の条件の 個別の評価値 を記述します。「評価値」の列が？になっているのは、新しい条件 を追加したため、評価値 を 設定し直す 必要があるためです。？に 評価値 を 設定する方法 について少し考えてみて下さい。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		？
2	自分が勝利している		？
4	「自 2 敵 0 空 1」が 2 つ以上存在する		？
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`1` `x`	？
6	「自 2 敵 0 空 1」が存在しない		？
3	相手が勝利できる		？

『「自 2 敵 0 空 1」が存在しない』場合の評価値

まず、優先順位 が 6 の『「自 2 敵 0 空 1」が 存在しない』場合の 評価値 について考えることにします。この条件 は、優先順位 が 6 の所に記述されていますが、実際には、優先順位 が 5 の『「自 1 敵 0 空 2」が x 個存在 する』という条件と 同時に満たされる 条件で、どちら の条件が 優先度が高いか は わかっていません。従って、この条件 は 優先順位 が 5 の 条件の中 に 入れる必要 があります。

『「自 2 敵 0 空 1」が 存在しない』という条件は、『「自 2 敵 0 空 1」が 1 つ存在 する』という条件が 満たされなかった場合 の条件なので、この条件が満たされる場合の 評価値 は 0 になります。下記は、そのように修正 した表です。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		？
2	自分が勝利している		？
4	「自 2 敵 0 空 1」が 2 つ以上存在する		？
5	「自 2 敵 0 空 1」が 1 つ存在する「自 2 敵 0 空 1」が存在しない「自 1 敵 0 空 2」が x 個存在する	`1` `0` `x`	？
3	相手が勝利できる		？

個別の 評価値 が 0 の条件は、評価値の計算 に 影響を与えない ので、表に記述 する意味が ありません。そのため、上記の表 は、下記のように まとめる ことが できます。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		？
2	自分が勝利している		？
4	「自 2 敵 0 空 1」が 2 つ以上存在する		？
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`1` `x`	？
3	相手が勝利できる		？

評価値の範囲の計算

表の 評価値 の列の値は、上から大きい順 に 並べる必要 があります。現時点 では、優先順位 が 5 の 個別の評価値のみ が 決まっている ので、その 評価値 について考察します。

優先順位 が 5 の 評価値 は、個別の 評価値 の合計になので、評価値の値 は状況によって 変化します が、その範囲を計算することは可能です。

下記の、それぞれ の 組み合わせ の 評価値 の関係を表す式から、評価値 の 最小値 が 0 で、最大値 が A + B であることが分かります。

0 < A < A + B
0 < B < A + B

今回の場合は、A が 1 で、B が x なので、優先順位 が 5 の 評価値 の範囲は 0 ～ 1 + x になります。下記は、そのことを 表に加えた ものです。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		？
2	自分が勝利している		？
4	「自 2 敵 0 空 1」が 2 つ以上存在する		？
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`1` `x`	`0 ～ 1 + x`
3	相手が勝利できる		？

次に、範囲の中 に x という変数が 入っている ので、x が とる値 の範囲を 考える必要 があります。x は、「自 1 敵 0 空 2」の マークのパターン の数を表し、その 最大値 は、ラインの数 である 8 なので、x の 最大値 は 8 であることが わかります。

実際には、相手も着手 を行うので、「自 1 敵 0 空 2」の数が 8 になる ことは ありません が、？の 値を設定 するために、厳密な x の範囲 を計算する 必要はない ので、8 として計算する ことにします。

下記は、優先順位 が 5 の 評価値の範囲 を 計算しやすい ように、個別の条件 の 評価値 の横に、それぞれの範囲を追加し、それを元に 評価値の範囲 を計算したものです。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		？
2	自分が勝利している		？
4	「自 2 敵 0 空 1」が 2 つ以上存在する		？
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`1` (`0～1`) `x` (`0～8`)	`0～9`
3	相手が勝利できる		？

評価値の範囲 が 分かった ので、？を 下記の表 のように 決める ことができます。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		`12`
2	自分が勝利している		`11`
4	「自 2 敵 0 空 1」が 2 つ以上存在する		`10`
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`1` (`0～1`) `x` (`0～8`)	`0～9`
3	相手が勝利できる		`-1`

`ai10s` の定義

評価値 が 決まった ので、ai10s を定義します。

ai9s では、それぞれの 優先順位 の 条件の判定 を 1 つの if 文 で 行っていました が、ai10s では、優先順位 が 5 の 評価値 を 計算する前 にその if 文 を 終了する必要 があります。

その後で 同じ優先順位 が 5 の条件の 評価値 を加算する 計算を行う 際には、下記のプログラムのように、評価値 を 計算する変数 を用意し、条件が満たされる たびに加算し、最後に 計算した評価値 を return 文で返す という処理を行います。

5、9、17 行目：評価値 を表に合わせて修正する
20 行目：評価値の合計 を計算する局所変数 score を 0 で 初期化 する
22、23 行目：「自 2 敵 0 空 1」が 1 つ存在 する場合に 評価値 に 1 を加算 する
25 行目：評価値 に「自 1 敵 0 空 2」の個数を加算する
28 行目：計算した評価値 を 返り値 として返す

 1  def ai10s(mb, debug=False):
 2      def eval_func(mb):
 3          # 真ん中のマスに着手している場合は、評価値として 12 を返す
 4          if mb.last_move == (1, 1):
 5              return 12
 6   
 7          # 自分が勝利している場合は、評価値として 11 を返す
 8          if mb.status == mb.last_turn:
 9              return 11
10
11          markpats = mb.count_markpats()
12          # 相手が勝利できる場合は評価値として -1 を返す
13          if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
14              return -1
15          # 次の自分の手番で自分が必ず勝利できる場合は評価値として 10 を返す
16          elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
17              return 10
18
19          # 評価値の合計を計算する変数を 0 で初期化する
20          score = 0
21          # 次の自分の手番で自分が勝利できる場合は評価値に 1 を加算する
22          if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
23              score += 1
24          # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
25          score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
26        
27          # 計算した評価値を返す
28          return score
29
30      return ai_by_score(mb, eval_func, debug=debug)

行番号のないプログラム

def ai10s(mb, debug=False):
    def eval_func(mb):      
        # 真ん中のマスに着手している場合は、評価値として 12 を返す
        if mb.last_move == (1, 1):
            return 12
    
        # 自分が勝利している場合は、評価値として 11 を返す
        if mb.status == mb.last_turn:
            return 11

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -1
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 10 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
            return 10

        # 評価値の合計を計算する変数を 0 で初期化する
        score = 0        
        # 次の自分の手番で自分が勝利できる場合は評価値に 1 を加算する
        if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
            score += 1
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
        score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
        
        # 計算した評価値を返す
        return score

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

-def ai9s(mb, debug=False):
+def ai10s(mb, debug=False):
    def eval_func(mb):       
        # 真ん中のマスに着手している場合は、評価値として 12 を返す
        if mb.last_move == (1, 1):
-           return 4
+           return 12
    
        # 自分が勝利している場合は、評価値として 11 を返す
        if mb.status == mb.last_turn:
-           return 3
+           return 11

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -1 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -1
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 10 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
-           return 2
+           return 10
        # 次の自分の手番で自分が勝利できる場合は評価値として 1 を返す
-       elif markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
-           return 1
-       # それ以外の場合は評価値として 0 を返す
-       else:
-           return 0

        # 評価値の合計を計算する変数を 0 で初期化する
+       score = 0
        # 次の自分の手番で自分が勝利できる場合は評価値に 1 を加算する
+       if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
+           score += 1
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
+       score += markpats[Markpat(last_turn=1, turn=0, empty=2)]       
        # 計算した評価値を返す
+       return score

    return ai_by_score(mb, eval_func, debug=debug)

`ai2` と `ai9s` との対戦

基準となる ai2 と、これまで に作成した 最強の AI である ai9s と対戦することにします。まず、下記のプログラムで ai2 と対戦します。

ai_match(ai=[ai10s, ai2])

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

ai10s VS ai2
count     win    lose    draw
o        9737       0     263
x        8564     263    1173
total   18301     263    1436

ratio     win    lose    draw
o       97.4%    0.0%    2.6%
x       85.6%    2.6%   11.7%
total   91.5%    1.3%    7.2%

下記は、ai9s VS ai2 と ai10s VS ai2 の 対戦結果 の表です。ai2 に対して、ai10s のほうが、ai9s より 勝率が若干低くなる ことが確認できます。このことから、新しい条件 が ai2 に対して 何らかの理由 で 若干不利 になる 可能性 があります。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
`ai9s`	98.7	0.1	1.2	89.6	2.4	8.0	94.1	1.3	4.6
`ai10s`	97.4	0.0	2.6	85.6	2.6	11.7	91.5	1.3	7.2

次に、ai9s と対戦を行います。実行結果 の 通算成績 の勝率が 約 40 %、敗率が 0 % となることから、ai10s が ai9s に 対して 大幅に強くなっている ことが確認できます。特に、ai9s に対する敗率が 0% は、これまでにない 大きな成果 であると言えるでしょう。

ai_match(ai=[ai10s, ai9s])

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

ai10s VS ai9s
count     win    lose    draw
o        7478       0    2522
x         791       0    9209
total    8269       0   11731

ratio     win    lose    draw
o       74.8%    0.0%   25.2%
x        7.9%    0.0%   92.1%
total   41.3%    0.0%   58.7%

評価値の調整

先程、評価値 の 設定方法 として、下記のような 方法を紹介 しました。

とりあえず おおざっぱに 評価値 を設定して AI を実装 する
実装した AI と 他の AI を対戦させて、強さを評価 する
A または B の 評価値 を 少し変化 させて、対戦させる
手順 2 と 3 を 何度も繰り返し、最も成績が良い 評価値の 組み合わせ を採用する

そこで、「自 2 敵 0 空 1」が 1 つ存在 する場合の 評価値 を 1 から 5 に 変えてみる ことにします。その際に、ai10s の下記の 3 行目 の score += 1 を score += 5 に 変えるだけで良い のではないかと 思う人がいるかもしれません が、それだけ では バグが発生 してしまいます。どのようなバグが発生するかについて少し考えてみて下さい。

        # 次の自分の手番で自分が勝利できる場合は評価値に 1 を加算する
        if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
            score += 1

下記は、「自 2 敵 0 空 1」が 1 つ存在 する場合の 評価値 を 5 に設定 した場合の表です。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		`12`
2	自分が勝利している		`11`
4	「自 2 敵 0 空 1」が 2 つ以上存在する		`10`
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`5` (`0～5`) `x` (`0～8`)	`0～13`
3	相手が勝利できる		`-1`

表から、優先順位 が 5 の 評価値 の範囲が 0 ~ 9 から、0 ~ 13 に変化したことがわかりますが、それ以外 の 優先順位 の 評価値 を 変えていない ので、優先順位 が 5 の 評価値 が、それより 上の行 の 評価値より も高くなってしまう 可能性が生じています。

下記は、新しい評価値 の範囲に 応じて、他の評価値 を修正した表です。修正する際 に、下記のように それぞれ の 優先順位 の 評価値 の間隔を 100 のように 大きな値にする ことで、評価値 の 計算式 を 多少修正 した場合でも、上下の行 の 評価値 の 大小関係 が 壊れにくくなる という工夫を行っています。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		`300`
2	自分が勝利している		`200`
4	「自 2 敵 0 空 1」が 2 つ以上存在する		`100`
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する	`5` (`0～5`) `x` (`0～8`)	`0～13`
3	相手が勝利できる		`-100`

下記のプログラムは、上記の評価値 を計算するように修正した ai10s です。

5、9、14，17 行目：評価値 を修正した
23 行目：評価値 の加算を 1 から 5 に修正した

 1  def ai10s(mb, debug=False):
 2      def eval_func(mb):      
 3          # 真ん中のマスに着手している場合は、評価値として 300 を返す
 4          if mb.last_move == (1, 1):
 5              return 300
 6   
 7          # 自分が勝利している場合は、評価値として 200 を返す
 8          if mb.status == mb.last_turn:
 9              return 200
10
11          markpats = mb.count_markpats()
12          # 相手が勝利できる場合は評価値として -100 を返す
13          if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
14              return -100
15          # 次の自分の手番で自分が必ず勝利できる場合は評価値として 100 を返す
16          elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
17              return 100
18
19          # 評価値の合計を計算する変数を 0 で初期化する
20          score = 0        
21          # 次の自分の手番で自分が勝利できる場合は評価値に 5 を加算する
22          if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
23              score += 5
24          # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
25          score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
26        
27          # 計算した評価値を返す
28          return score
29
30      return ai_by_score(mb, eval_func, debug=debug)

行番号のないプログラム

def ai10s(mb, debug=False):
    def eval_func(mb):      
        # 真ん中のマスに着手している場合は、評価値として 300 を返す
        if mb.last_move == (1, 1):
            return 300
    
        # 自分が勝利している場合は、評価値として 200 を返す
        if mb.status == mb.last_turn:
            return 200

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -100 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -100
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 100 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
            return 100

        # 評価値の合計を計算する変数を 0 で初期化する
        score = 0        
        # 次の自分の手番で自分が勝利できる場合は評価値に 5 を加算する
        if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
            score += 5
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
        score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
        
        # 計算した評価値を返す
        return score

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

def ai10s(mb, debug=False):
    def eval_func(mb):      
        # 真ん中のマスに着手している場合は、評価値として 300 を返す
        if mb.last_move == (1, 1):
-           return 12
+           return 300
    
        # 自分が勝利している場合は、評価値として 200 を返す
        if mb.status == mb.last_turn:
-           return 11
+           return 200

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -100 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
-           return -1
+           return -100
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 100 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
-           return 10
+           return 100

        # 評価値の合計を計算する変数を 0 で初期化する
        score = 0        
        # 次の自分の手番で自分が勝利できる場合は評価値に 5 を加算する
        if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
-           score += 1
+           score += 5
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
        score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
        
        # 計算した評価値を返す
        return score

    return ai_by_score(mb, eval_func, debug=debug)

修正した `ai10s` と `ai2`、`ai9s` との対戦

修正した ai10s で ai2、ai9s と対戦することにします。まず、下記のプログラムで ai2 と対戦します。

ai_match(ai=[ai10s, ai2])

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

ai10s VS ai2
count     win    lose    draw
o        9904       0      96
x        9002     305     693
total   18906     305     789

ratio     win    lose    draw
o       99.0%    0.0%    1.0%
x       90.0%    3.0%    6.9%
total   94.5%    1.5%    3.9%

下記は、先程の ai9s VS ai2 と ai10s VS ai2 の対戦結果に、今回の対戦結果 を 加えた表 です。今回の対戦結果では、ai9s VS ai2 とほぼ同じ成績になることが分かります。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
`ai9s`	98.7	0.1	1.2	89.6	2.4	8.0	94.1	1.3	4.6
`ai10s`(評価値 1)	97.4	0.0	2.6	85.6	2.6	11.7	91.5	1.3	7.2
`ai10s`(評価値 5)	99.0	0.0	1.0	90.0	3.0	6.9	94.5	1.5	3.9

次に、ai9s と対戦を行います。

ai_match(ai=[ai10s, ai9s])

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

ai10s VS ai9s
count     win    lose    draw
o        4878       0    5122
x         802       0    9198
total    5680       0   14320

ratio     win    lose    draw
o       48.8%    0.0%   51.2%
x        8.0%    0.0%   92.0%
total   28.4%    0.0%   71.6%

下記は、先程の ai10s VS ai9s 対戦結果に、今回の対戦結果 を 加えた表 です。表から、相変わらず ai9s に対しては ai10s は 強いものの、評価値 を 5 とすることで、〇を担当 した場合の勝率が かなり低くなる ことがわかります。このようなことが起きるのは、『「自 2 敵 0 空 1」が 1 つ存在する』場合の 評価値 を 高く設定しすぎた ことによって、『「自 2 敵 0 空 1」が 1 つ存在する』場合の 重要度 を、本来の重要度より も 高く見積もりすぎる という、過大評価 が行われてしまったせいです。

評価値	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
1	74.8	0.0	25.2	7.9	0.0	92.1	41.3	0.0	58.7
5	48.8	0.0	51.2	8.0	0.0	92.0	28.4	0.0	71.6

適切な 評価値 を 求める ために、評価値 を 2、3、4 に設定して ai2、ai9s と対戦を行うことにします。なお、プログラムと実行結果は長くなるので省略し、結果の表 だけを 示します。興味がある方は、自分でプログラムを修正して対戦を行ってみて下さい。

ai2 との 対戦結果

評価値	o 勝	o 分	x 勝	x 負	x 分	勝	負	分
1	97.4	2.6	85.6	2.6	11.7	91.5	1.3	7.2
2	98.7	1.3	90.8	2.8	6.4	94.7	1.4	3.8
3	98.8	1.2	90.1	3.1	6.8	94.5	1.5	4.0
4	98.9	1.1	90.3	2.9	6.8	94.6	1.5	3.9
5	99.0	1.0	90.0	3.0	6.9	94.5	1.5	3.9

ai9s との 対戦結果

評価値	o 勝	o 分	x 勝	x 分	勝	分
1	74.8	25.2	7.9	92.1	41.3	58.7
2	55.6	44.4	8.2	91.8	31.9	68.1
3	49.5	50.5	8.8	91.2	29.1	70.9
4	49.4	50.6	7.9	92.1	28.7	71.3
5	48.8	51.2	8.0	92.0	28.4	71.6

上記の結果から、ai2 に対しては、評価値 が 2 以上 であれば どれもほぼ同じ で、ai9s に対しては 評価値 が 1 の場合が 最も成績が良い ことが分かります。ai2 と ai9s では、最も成績が良い 評価値が 異なります が、このような場合は どちらかを選択 する必要があります。本記事 では、下記のような理由で、評価値 として 1 を採用する ことにします。

ai2 より かなり強い ai9s に対する成績の方が重要と 考えられる
評価値 を 2 以上 にすると、ai9s に対する 対戦成績 が急激に 悪くなる

評価値 は整数である必要は ありません。興味と余裕がある方は、評価値 に 1.5 や 2.5 などを設定して対戦させてみて下さい。さらに良い評価値 を 見つける ことが できるかも しれません。

ルール 11

次に、『「自 0 敵 1 空 2」が 最も少ない 着手を行う』という条件を ルール 10 に追加した ルール 11 を定義する事にします。この条件は、ルール 10 の 優先順位 が 5 の 条件の一つ として追加することができるので、ルール 11 は 下記の表 のように定義できます。

順位	条件	種類
1	真ん中のマスに優先的に着手する
2	勝てる場合に勝つ	十分条件
3	相手が勝利できる着手を行わない	必要条件
4	「自 2 敵 0 空 1」が 2 つ以上存在する着手を行う	十分条件
5	「自 2 敵 0 空 1」が 1 つ存在する着手を行う「自 1 敵 0 空 2」が最も多い着手を行う「自 0 敵 1 空 2」が最も少ない着手を行う
6	ランダムなマスに着手する

評価値の設定

「自 0 敵 1 空 2」が 最も少ない 着手を 行うようにする ためには、「自 0 敵 1 空 2」の 数が多い程、評価値 を 低く計算 する必要があります。その方法は、簡単で「自 0 敵 1 空 2」の数を $x$ とした場合に、$評価値 = -x$ のように、負の評価値 を計算するように 式を設定 します。下記の表は、新しい 条件と評価値 を ルール 10 の 表に加えた ものです。

一般的 に 評価値 には、自分が 有利な場合 は 正の値 を、自分が 不利な場合 は 負の値 を 設定します。

順位	局面の状況	個別	評価値
1	真ん中のマスに着手している		`300`
2	自分が勝利している		`200`
4	「自 2 敵 0 空 1」が 2 つ以上存在する		`100`
5	「自 2 敵 0 空 1」が 1 つ存在する「自 1 敵 0 空 2」が x 個存在する「自 0 敵 1 空 2」が y 個存在する	`1` (`0～1`) `x` (`0～8`) `-y` (`-8~0`)	`-8～9`
3	相手が勝利できる		`-100`

優先順位 ごとの 評価値 の間隔を 大きくしておいた おかげで、優先順位 が 5 の条件に、新しい条件 を追加しても、他の優先順位 の 評価値 を 変更する必要 は ありません。

`ai11s` の定義と、`ai2`、`ai10s` との対戦

評価値 の表を元に、ai11s は下記のプログラムのように定義できます。なお、『「自 2 敵 0 空 1」が 1 つ存在する』場合の 評価値 は、1 に戻しました。

5、6 行目：「自 0 敵 1 空 2」が y 個存在 する場合に、評価値 から y を減算する

1  def ai11s(mb, debug=False):
2      def eval_func(mb):      
元と同じなので省略
3          # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
4          score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
5          # 「自 0 敵 1 空 2」の数だけ、評価値を減算する
6          score -= markpats[Markpat(last_turn=0, turn=1, empty=2)]
元と同じなので省略

行番号のないプログラム

def ai11s(mb, debug=False):
    def eval_func(mb):      
        # 真ん中のマスに着手している場合は、評価値として 300 を返す
        if mb.last_move == (1, 1):
            return 300
    
        # 自分が勝利している場合は、評価値として 200 を返す
        if mb.status == mb.last_turn:
            return 200

        markpats = mb.count_markpats()
        # 相手が勝利できる場合は評価値として -100 を返す
        if markpats[Markpat(last_turn=0, turn=2, empty=1)] > 0:
            return -100
        # 次の自分の手番で自分が必ず勝利できる場合は評価値として 100 を返す
        elif markpats[Markpat(last_turn=2, turn=0, empty=1)] >= 2:
            return 100

        # 評価値の合計を計算する変数を 0 で初期化する
        score = 0        
        # 次の自分の手番で自分が勝利できる場合は評価値に 1 を加算する
        if markpats[Markpat(last_turn=2, turn=0, empty=1)] == 1:
            score += 1
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
        score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
        # 「自 0 敵 1 空 2」の数だけ、評価値を減算する
        score -= markpats[Markpat(last_turn=0, turn=1, empty=2)]
        
        # 計算した評価値を返す
        return score

    return ai_by_score(mb, eval_func, debug=debug)

修正箇所

-def ai10s(mb, debug=False):
+def ai11s(mb, debug=False):
    def eval_func(mb):      
元と同じなので省略
        # 「自 1 敵 0 空 2」の数だけ、評価値を加算する
        score += markpats[Markpat(last_turn=1, turn=0, empty=2)]
+       # 「自 0 敵 1 空 2」の数だけ、評価値を減算する
+       score -= markpats[Markpat(last_turn=0, turn=1, empty=2)]
元と同じなので省略

ai11s の強さを確認するために、ai2、ai10s と対戦することにします。まず、下記のプログラムで ai2 と対戦します。

ai_match(ai=[ai11s, ai2])

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

ai11s VS ai2
count     win    lose    draw
o        9813       0     187
x        8251     193    1556
total   18064     193    1743

ratio     win    lose    draw
o       98.1%    0.0%    1.9%
x       82.5%    1.9%   15.6%
total   90.3%    1.0%    8.7%

下記は、ai11s VS ai2 と、評価値が 1 の場合の ai10s VS ai2 の 対戦結果 の表です。× を担当 する場合の成績が 若干悪くなっています が、成績は ほぼ同じ です。

関数名	o 勝	o 負	o 分	x 勝	x 負	x 分	勝	負	分
`ai10s`	97.4	0.0	2.6	85.6	2.6	11.7	91.5	1.3	7.2
`ai11s`	98.1	0.0	1.9	82.5	1.9	15.6	90.3	1.0	8.7

次に、ai10s と対戦を行います。

ai_match(ai=[ai10s, ai9s])

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

ai11s VS ai10s
count     win    lose    draw
o        2186       0    7814
x           0    5014    4986
total    2186    5014   12800

ratio     win    lose    draw
o       21.9%    0.0%   78.1%
x        0.0%   50.1%   49.9%
total   10.9%   25.1%   64.0%

実行結果 の 通算成績 から、ai11s が ai10s に 対して 弱くなってしまう ことが確認できました。何故このようになってしまったかにつては、次回の記事で説明することにします。

今回の記事のまとめ

今回の記事では、強い AI の ルール を作るための 条件の種類 として、必要条件、十分条件、その どちらでもない条件 について説明しました。

また、複数の条件 を 同時に考慮 する 評価値 の 計算方法 について説明しました。評価値 を利用することで、以前の記事で説明した、複数の条件 を 組み合わせて考慮 したい場合の 問題点 を解決することが できます。

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

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

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

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

次回の記事

たとえば、1000 年後の世界を自分の目で見る いう目的に対する 必要十分条件 は「1000年後まで生きる」ですが、その条件を達成することは現実的には 不可能 でしょう。なお、必要条件 の一つは「10 年以上生きる」、十分条件 の一つは「1100年後まで生きる」です ↩
既にルール 8 が分かりづらいと思っている方はいませんか？ ↩
その際に、次の条件 を 考える ために、強くならなかった理由 を 考察する と良いでしょう ↩