Unity:AndroidでComputeShaderを使ってみました

画像処理では、並列計算による高速化が求められます。（常に…）
Compute Shader を使った並列計算による高速化は実装が簡単で効果抜群なのですが、DirectX 依存なので（と思い込んでいた私は） PC 上での動作に限られていると思っていました。

しかし、ふと Unity の Compute Shader って Android 用にビルドした場合も動作するのかな？
だとしたら、Unity すばらしいなって思いまして、さっそく試してみました。

左は入力のカラー画像、右は出力のグレースケール画像（…イラストは私が描きました）

できた！Unityすばらしい！

使った Compute Shader のコードはこちら↓

// file head
RWStructuredBuffer<uint> _Histogram;
RWTexture2D<float4> _Result;

// Gathering pass
Texture2D<float4> _Source;

uint2 _SourceSize;

// groupshared uint gs_histogram[256]; // group shared memory can be used in a Windows PC, but it could not be used in an Android platform. why?

#pragma kernel KHistogramGather
[numthreads(32, 32, 1)]
void KHistogramGather(uint3 id : SV_DispatchThreadID, uint3 _group_thread_id : SV_GroupThreadID)
{
	const uint thread_id = _group_thread_id.y * 32 + _group_thread_id.x;

	//if (thread_id == 0)
	//{
	//	for (int i = 0; i < 256; i++)
	//	{
	//		gs_histogram[i] = 0;
	//	}
	//}

	// GroupMemoryBarrierWithGroupSync();

	if (id.x < _SourceSize.x && id.y < _SourceSize.y)
	{
		float3 color = saturate(_Source[id.xy].xyz);

		// Convert color to grayscale
		float luminance = dot(color.rgb, float3(0.2125, 0.7154, 0.0721));
		uint idx_l = (uint)round(luminance * 255.0);

		// InterlockedAdd(gs_histogram[idx_l], 1);
		InterlockedAdd(_Histogram[idx_l], 1); // it is an alternative method for using a group shared memory
		_Result[id.xy] = float4(luminance, luminance, luminance, 1);
	}

	// GroupMemoryBarrierWithGroupSync();

	//if (thread_id == 0)
	//{
	//	for (int i = 0; i < 256; i++)
	//	{
	//		InterlockedAdd(_Histogram[i], gs_histogram[i]);
	//	}
	//}
}

単にグレースケール化するだけじゃなくて、輝度ヒストグラムまで構築するスグレモノなのですが
残念なことに groupshared メモリを使った高速化がAndroid上だけ、できないことが分かったのでコメントアウトしています。

シェーダーの利用はスクリプト側で行いますので、利用スクリプトの方も以下に載せます。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DeviceCameraBehaviour : MonoBehaviour {

    public GameObject resultCube;
    public ComputeShader RGBA2GRAY;
    public Texture2D Source;
    public RenderTexture Result;

    int _kernelIndex = 0;
    ComputeBuffer _HistogramBuffer = null;
    uint[] _emptyBuffer = new uint[256];
    uint[] _histogramBuffer = new uint[256];

    // Use this for initialization
    void Start () {

        Result = new RenderTexture(Source.width, Source.height, 0, RenderTextureFormat.ARGB32);
        Result.enableRandomWrite = true;
        Result.Create();

        _HistogramBuffer = new ComputeBuffer(256, sizeof(uint));
        for (int i = 0; i < _emptyBuffer.Length; i++)
        {
            _emptyBuffer[i] = 0;
        }
        _HistogramBuffer.SetData(_emptyBuffer);

        _kernelIndex = RGBA2GRAY.FindKernel("KHistogramGather");
        RGBA2GRAY.SetBuffer(_kernelIndex, "_Histogram", _HistogramBuffer);
    }
	
	// Update is called once per frame
	void Update () {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            DoComputeShader();

            Debug.Log("Time = " + Time.time.ToString("000.0000"));
            WebCamDevice[] devices = WebCamTexture.devices;
            for (int i = 0; i < devices.Length; i++)
                Debug.Log(devices[i].name);
        }
        for (int i = 0; i < Input.touchCount; ++i)
        {
            if (Input.GetTouch(i).phase == TouchPhase.Began)
            {

                // Construct a ray from the current touch coordinates
                Ray ray = Camera.main.ScreenPointToRay(Input.GetTouch(i).position);
                // Create a particle if hit
                if (Physics.Raycast(ray))
                {
                    DoComputeShader();

                    Debug.Log("Time = " + Time.time.ToString("000.0000"));
                    WebCamDevice[] devices = WebCamTexture.devices;
                    for (int j = 0; j < devices.Length; j++)
                        Debug.Log(devices[j].name);
                }
            }
        }
    }

    private void DoComputeShader()
    {
        RGBA2GRAY.SetTexture(_kernelIndex, "_Source", Source);
        RGBA2GRAY.SetTexture(_kernelIndex, "_Result", Result);
        RGBA2GRAY.SetVector("_SourceSize", new Vector2(Source.width, Source.height));
        _HistogramBuffer.SetData(_emptyBuffer);
        RGBA2GRAY.Dispatch(_kernelIndex, Mathf.CeilToInt(Source.width / 32f), Mathf.CeilToInt(Source.height / 32f), 1);
        _HistogramBuffer.GetData(_histogramBuffer);
        uint total = 0;
        for (int i = 0; i < _histogramBuffer.Length; i++)
        {
            total += _histogramBuffer[i];
        }
        Debug.Log("histogram total = " + total);
        resultCube.GetComponent<Renderer>().material.mainTexture = Result;
    }
}

簡単にコードを解説してみますと

RGBA2GRAY というのが、Compute Shader で、先ほど示したコードで作ったシェーダーを Unity のエディタから紐づけます。
あとは、画像データを Source テクスチャとして用意して渡したら Disptach にて 32 分の 1 の幅と高さのスレッドグループ数を指定し実行しています。
なぜ 32 分の 1 にしなければいけないかというと、Compute Shader 側で[numthreads(32, 32, 1)]と、32 x 32のタイル領域ごとに処理をすると宣言しているからです。
Dispach で縦横のタイル数を指定してあげることで全画素についての処理が完成するというイメージを持っていただけると、理解しやすいかなって思います。

最後に Andorid のビルド設定ですが、以下のようにして、端末は2017年1月に購入した Phab 2 Pro で動作することを確認しました。（自身の携帯である Xperia Z3 では Compute Shader は動かなかった…）

今回の記事は以下のページを参考に作成しました。

まず Compute Shader を一度も触ったことがない人は、こちらの記事を参考にするとサクッとPC上で動作確認までできるようになると思います。
[Unity] UnityでComputeShaderを使う解説をしているページを訳してみた その2 - Qiita

次にテクスチャを入力に、Compute Shader で何かしら画素値を処理してテクスチャを出力する場合については次の記事を参考にします。
DirectCompute tutorial for Unity 3: Textures | Cheney Shen

ヒストグラムの計算については、次のプロジェクトの、このプルリクエストを参考にしました。（ヒストグラムなのに並列計算で高速化！？できないと思っていたので驚きましたよ、考えた人グッジョブです！）
Unity-Technologies / cinematic-image-effects / Pull request #31: [tcg] Histogram compute shader optimizations (~4x) — Bitbucket

Unity:uGUIにDebug.Logの内容を表示する方法１

UnityでDebug.Logした内容を、uGUIのUI画面でゲーム実行中に確認したい場合があります。
今回はその要望に応える形で次のようにログが流れる仕組みを作ったので、今後自分が再利用するために公開します。

Debug.Log をハンドリングするコードは次の通り

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class UILogBehaviour : MonoBehaviour {

    public Text TextPrefab;
    private RectTransform _myPanel;

	// Use this for initialization
	void Start () {
        _myPanel = GetComponent<RectTransform>();
    }
	
	// Update is called once per frame
	void Update () {
		
	}

    void OnEnable()
    {
        Application.logMessageReceived += Log;
    }

    void OnDisable()
    {
        Application.logMessageReceived -= Log;
    }

    public void Log(string logString, string stackTrace, LogType type)
    {
        Text logLine = Instantiate(TextPrefab, Vector3.zero, Quaternion.identity, _myPanel);
        logLine.name = "LogLine";
        logLine.text = logString;

        if (20 < _myPanel.transform.childCount)
        {
            Transform child = _myPanel.GetChild(1);
            GameObject.Destroy(child.gameObject);
        }
    }
}

使い方：このスクリプトを VerticalLayoutGroup コンポーネントを付けた Panel に追加して、最初の子要素の Text を TextPrefab に渡します。

すると 20 件以上ログが流れたら、古いログのラインから順番に消えていきます。
テスト用に Space キーを押したらログが流れる仕組みを次のように書いて、テストしました。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DeviceCameraBehaviour : MonoBehaviour {

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log("Time = " + Time.time.ToString("000.0000"));
        }
	}
}

Android などの実機で、デバイスの設定がどうなっているかなどを簡易に確認する方法として使えると思い、作ってみました。
以上です。

対戦ゲームで一喜一憂するAI

強化学習でまるばつゲーム（3目ならべ）を作ったことがありましたが、ふと相手の手や自分の手に関して一喜一憂するAIが作れるのではないかと思ったわけです。
作ってみます。

AIには最近扱いに慣れてきたSDユニティちゃんを使わせてもらおうと思います。
感情表現としては、用意されている表情でやってみますか。

smile2, confuse, sad, scold, strain, surprise, damaged, relux の計 8 種類の感情表現とします。

状況に応じて、どの感情を表すかは後で決めることにしますか。
まずは対戦ゲームの方を完成させます。

簡単なユースケース駆動開発をしてみます。
まずは「リトライ（開始）ボタン」を押すとゲームが最初からやり直しとなります。
最初に「先攻後攻決めアニメ」が走ります。
自分の番になると、「青い Your Turn」のボードが一瞬出てきて消えます。
「盤面」の「マス」にホバーすると「半透明の〇 or ×マーク」がマス内に表示されます。
ホバーするマス目ごとに「SDユニティちゃん」が「感情表現」を変化させます。
配置したいマスをクリックすると、「配置音」と同時に「不透明の〇×マーク」がマス内に配置されます。
配置されたマス目ごとに「SDユニティちゃん」が「感情表現」を変化させます。
相手の番になると「赤い Enemy Turn」のボードが一瞬でてきて消えます。
「SDユニティちゃん」が感情表現しながら、マウスをホバーして「半透明の〇 or ×マーク」がマス内に表示され、そのマスごとに「感情表現」を変えます。
意思決定をしたら、SDユニティちゃんは、空いているマスに配置、「配置音」と同時に「不透明の〇×マーク」がマス内に配置されます。
配置されたマス目ごとに「SDユニティちゃん」が「感情表現」を変化させます。
「ゲームが終了、勝敗」が決まると、「SDユニティちゃん」が「感情表現」を変化させます。
「リトライ（開始）ボタン」を押すとゲームが最初からやり直しとなります。

ここで出てきたオブジェクトを列挙します。
・リトライ（開始）ボタン
・先攻後攻決めアニメ
・赤い Enemy Turn ボード、青い Your Turn　ボード
・盤面/マス
・SDユニティちゃん
・感情
・配置音
・半透明、不透明の〇×マーク
・ゲーム結果、勝敗
まずはこれらのアセットを準備します。

…そろいました。

ではユースケースを実装してみましょう。
「リトライ（開始）ボタン」を押すとゲームが最初からやり直し
「先攻後攻決めアニメ」が走る
自分・相手の番になると、「青い・赤い Turn」のボードが一瞬出てきて消える
「盤面」の「マス」にマウスがホバーすると「半透明の〇 or ×マーク」がマス内に表示
ホバーするマス目ごとに「SDユニティちゃん」が「感情表現」を変化させます。
配置したいマスをクリックすると、「配置音」と同時に「不透明の〇×マーク」がマス内に配置される。
相手の番になると「赤い Enemy Turn」のボードが一瞬でてきて消える。

とりあえず、今ここまで実装を進めてます。

意思決定をしたら、SDユニティちゃんは、空いているマスに配置、「配置音」と同時に「不透明の〇×マーク」がマス内に配置されます。
配置されたマス目ごとに「SDユニティちゃん」が「感情表現」を変化させます。
「ゲームが終了、勝敗」が決まると、「SDユニティちゃん」が「感情表現」を変化させます。
「リトライ（開始）ボタン」を押すとゲームが最初からやり直しとなります。

をやりました。

次のだけ入っていない
「SDユニティちゃん」が感情表現しながら、マウスをホバーして「半透明の〇 or ×マーク」がマス内に表示され、そのマスごとに「感情表現」を変えます。

時間が空いてしまって、熱量が足りない…
気が向いたら、入れようと思います。

一喜一憂するAIは、わかっていても対戦していてなかなか楽しいことがわかりました。

この作品はユニティちゃんライセンス条項の元に提供されています

Unity:mecanimのイロハ

SD Toon シェーダーの Unityちゃんで、ステート遷移によってアニメーションが変化する仕組み mecanim を勉強してみようと思います。
ほんとに今更ですが、基本的なところを触ってみます。

ボーンの入ったモデルと、そのボーンを動かすアニメーションクリップを用意します。
具体的にはモーションを設定した FBX ファイルをどこからか持ってくるという作業です。

今回は SD Toon Unity ちゃんとしました。
入手場所はこちら
unity-chan.com

手順をわかりやすく、まっさらなシーンに Unity ちゃんのモデルを配置してみます。

メッシュにはディフォルトのマテリアルが割り当てられているので Toon フォルダにある body 用、face 用 hair 用などをそれぞれのメッシュに割り当てます。
加えて、ディレクショナルライトを3つつくり、それぞれ別のレイヤーだけに影を落とすようにし
body, face, hair, head のレイヤーを変更し
Lighting にて Ambient を Skybox から Color White に設定します。
するとこんな見た目に変化します。

Model をそのまま配置しただけですが、ディフォルトで Animator と Avatar まで割り当たっていました。
これは便利なのでそのまま使いましょう。

次に AnimatorController を作ります。

最初はブレンドツリーというステートを一つ作ってみます。
このステートをダブルクリックすると、次のようなブレンドに関するUIが出てきます。（すでに別途 Walk と Run のモーションをブレンドするように追加した状態です。最初は何もないよ）

Blend パラメータを調整すれば、二つのモーションをその割合でブレンドするようになります。
そのほかのパラメータ設定は調整次第ですね。ここまで基本的なことができれば、モーションブレンドの基本は OK だと思います。

次に、アニメーションイベントをやってみます。

アニメーションクリップを見てみると、Walk に関しては次のようにアニメーションイベントが設定されています。

Animator が設定されている階層に、スクリプトコンポーネントを配置して、ここにある Function 名の関数を用意してみます。
すると、アニメーションが開始されたタイミングでこの関数が呼ばれます。

要は、モーションのあるタイミングで表情や音、エフェクトなどを発生させたいときなどに、これらのイベントをモーションに仕込んでおくと便利なことになりそうです。
何処にイベントを仕込んだのか、一覧表示できるとうれしいですが、そういうところ気が利かない機能かもしれません。（どこからも呼ばれないはずの関数が呼ばれてしまうというバグが残りそう…）

public class UnityChanBehaviour : MonoBehaviour {
    public AnimationClip[] animations;
    // Use this for initialization
    void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
		
	}

    public void OnCallChangeFace(string str)
    {
        int ichecked = 0;
        foreach (var animation in animations)
        {
            if (str == animation.name)
            {
                ChangeFace(str);
                break;
            }
            else if (ichecked <= animations.Length)
            {
                ichecked++;
            }
            else
            {
                //str指定が間違っている時にはデフォルトで
                str = "default@unitychan";
                ChangeFace(str);
            }
        }
    }

    void ChangeFace(string str)
    {
        //isKeepFace = true;
        //current = 1;
        //anim.CrossFade(str, 0);
    }
}

次に基本的な機能の、ブレンドマスクを見てみます。
例えば、先ほどのアニメーションイベントにて呼ばれた関数で、顔の表情だけを別のアニメーションにしてみたいと思います。

ブレンドマスクにはこんな感じで、faceだけ適用する旨を設定します。

あとは Face という、もう一つのレイヤーを AnimationController に追加して、そこに表情のステートを追加します。遷移をいちいち書かないのがポイント。

アニメーションイベントで呼ばれる関数にて、CrossFade 関数を呼べば、遷移をかかずとも、そのステートに遷移します。

    public void OnCallChangeFace(string str)
    {
        int ichecked = 0;
        foreach (var animation in animations)
        {
            if (str == animation.name)
            {
                ChangeFace(str);
                break;
            }
            else if (ichecked <= animations.Length)
            {
                ichecked++;
            }
            else
            {
                //str指定が間違っている時にはデフォルトで
                str = "default@unitychan";
                ChangeFace(str);
            }
        }
    }

    void ChangeFace(string str)
    {
        anim.CrossFade(str, 0.4f);
    }

歩いているときに飛んでくるアニメーションイベントでスマイルし

走っているときに飛んでくるアニメーションイベントで驚きます。

gif アニメをとるとこんなイメージです。

mecanimの基本的な機能はこんなところでしょうか。
もっと便利な機能を見つけましたら、またどこかで書こうと思います。

この作品はユニティちゃんライセンス条項の元に提供されています

Unity:楽曲のビートに合わせてオブジェクトを振動させる

ちょっとテンションが上がるBGMをかけながら作業していたところ
ふと、Audio の低音と同期して振動するオブジェクトができないかな？
なんて思いついたので、ちょっと調べて解決したので、解決方法を書いておきます。

情報ソースはこちら
docs.unity3d.com

using UnityEngine;

public class WaveOutputter : MonoBehaviour
{
    float[] _spectrum = new float[256];
    float _lastLow = 0;

    [Range(0, 1)]
    public float t = 1;

    void Start()
    {
    }

    void Update()
    {
        AudioListener.GetSpectrumData(_spectrum, 0, FFTWindow.Rectangular);
        float low = 0;
        for (int i = 1; i < 3; i++)
            low += _spectrum[i];

        low = _lastLow * (1 - t) + low * t;
        transform.localScale = Vector3.one * 0.05f * low + Vector3.one;
        _lastLow = low;
    }
}

3目ならべ（〇×ゲーム）で最強のAIを作る

表題の通り、今回は3目ならべで最強のAIを作りました。
最も勝利確率の高いマスを赤く示してくれるツールとなっています。

具体的にどうしたかというと
前回作った強化学習のコードの一部を次の通り、変更してみました。
変更の意図としてはBellman方程式のModelの部分にて、着手可能なすべての手に対して均等に着手する確率を割り振ってみたらどうなるか、というものです。

    private void LearnAction(Action action)
    {
        LearnState(action.state);
        action.reward = action.state.reward + 0.999f * GetSumReward(action.state);
    }

    private float GetSumReward(State state)
    {
        if (0 == state.actions.Count)
        {
            return 0;
        }
        float sumReward = 0;
        for (int i = 0; i < state.actions.Count; i++)
        {
            sumReward += state.actions[i].reward / state.actions.Count;
        }
        return sumReward;
    }

何故最強と言えるのか、それを確かめる作業をしてみましょう。
今回作った行動の報酬の通りに打つ先手をAIとして、すべての着手を調べてみます。
ここでAIは常に同じ状況で同じ手を返すため、すべての着手を調べることができます。

作った行動と状態の樹形図をたどるようにして、先手をAIにした場合の後手の人間があらゆる手を打ったとしてその後の勝敗を調べました。
その時の全数検査のコードがこちら

結果は、後手の人間が勝利した回数 = 0 引き分けた回数 = 4 負けた回数 = 72 となりました。
対局パターン数は76ということでした。

つまり、先手において最強のAI（少なくとも負けることがないAI）ができていることを確認できました。
今度は後手用のAIも作ってみましょう。
次回へ続きます。

    int _humanWinCount = 0;
    int _humanDrawCount = 0;
    int _humanLoseCount = 0;
    int _gamePatternCount = 0;

    void Start ()
    {
        _globalState = new State() { reward = 0 };
        _currentState = _globalState;
        PutTrue(_globalState);
        LearnState(_globalState);
        AIPut(_globalState);

        Debug.Log("Human win = " + _humanWinCount + " draw = " + _humanDrawCount + " lose = " + _humanLoseCount);
        Debug.Log("Pattern Count = " + _gamePatternCount);
    }

    private void AIPut(State state)
    {
        float minmax = 0;
        int actionOffset = -1;
        if (_mark)
        {
            minmax = float.MinValue;
            for (int i = 0; i < state.actions.Count; i++)
            {
                if (minmax < state.actions[i].reward)
                {
                    minmax = state.actions[i].reward;
                    actionOffset = i;
                }
            }
        }
        else
        {
            minmax = float.MaxValue;
            for (int i = 0; i < state.actions.Count; i++)
            {
                if (minmax > state.actions[i].reward)
                {
                    minmax = state.actions[i].reward;
                    actionOffset = i;
                }
            }
        }
        if (-1 != actionOffset)
        {
            State nextState = state.actions[actionOffset].state;
            _mark = !_mark;
            PutTest(nextState);
        }
    }

    private void PutTest(State state)
    {
        if (0 == state.actions.Count)
        {
            bool win = state.reward > 0;

            if (win)
                ++_humanLoseCount;
            else
                ++_humanDrawCount;
            ++_gamePatternCount;
        }
        for (int i = 0; i < state.actions.Count; i++)
        {
            State nextState = state.actions[i].state;
            _mark = !_mark;

            if(nextState.reward < 0)
            {
                ++_humanWinCount;
                ++_gamePatternCount;
            }
            else
                AIPut(nextState);
        }
    }

3目ならべで強化学習すると、どうなる？→こうなる

前回の記事ははじめての強化学習ということで、Bellman方程式を使ってきわめて単純な経路分岐問題を解いてみました。
今回はもう少し複雑な経路問題を解いてみたいと思います。

お題は「3目ならべ」です。

先攻後攻が決まったら、まずは 3x3 のマス目の 9つのうち、いずれかに先行が〇を描き
その後は互いに余ったマスに×と〇を描いていき、3つ先に並べた方が勝利するゲームです。

理論的な話はもう理解できているので
さっそく、全パターンを走査するプログラムを書いてみましょう。

ということで、書きました。

    bool?[] _masume = new bool?[9];

    int[][] _finish = new int[8][];

	void Start ()
    {
        for (int i = 0; i < _masume.Length; i++)
        {
            _masume[i] = null;
        }
        _finish[0] = new int[3] { 0, 1, 2 };
        _finish[1] = new int[3] { 3, 4, 5 };
        _finish[2] = new int[3] { 6, 7, 8 };

        _finish[3] = new int[3] { 0, 3, 6 };
        _finish[4] = new int[3] { 1, 4, 7 };
        _finish[5] = new int[3] { 2, 5, 8 };

        _finish[6] = new int[3] { 0, 4, 8 };
        _finish[7] = new int[3] { 2, 4, 6 };

        PutTrue();
    }

    private bool IsFinish(int[] finish, bool ex)
    {
        return (ex == _masume[finish[0]] && ex == _masume[finish[1]] && ex == _masume[finish[2]]);
    }

    private void PutTrue()
    {
        for (int i = 0; i < _masume.Length; i++)
        {
            if (null == _masume[i])
            {
                bool ex = true;
                _masume[i] = ex;
                bool win = false;
                for (int k = 0; k < _finish.Length; k++)
                {
                    if (IsFinish(_finish[k], ex))
                    {
                        win = true;
                        break;
                    }
                }
                if (!win)
                    PutFalse();
                _masume[i] = null;
            }
        }
    }

    private void PutFalse()
    {
        for (int j = 0; j < _masume.Length; j++)
        {
            if (null == _masume[j])
            {
                bool ex = false;
                _masume[j] = ex;
                bool win = false;
                for (int k = 0; k < _finish.Length; k++)
                {
                    if (IsFinish(_finish[k], ex))
                    {
                        win = true;
                        break;
                    }
                }
                if (!win)
                    PutTrue();
                _masume[j] = null;
            }
        }
    }

勝利判定付きです。

では、強化学習するための、State と Action の樹形図をこの再帰処理に構築してもらいましょう。
そんなコードを書いてみます。

はい、ということで書きました。
ちゃんと樹形図を作ってくれています。

    class Action
    {
        public int i = -1;
        public float reward = 0;
        public State state = null;
    }

    class State
    {
        public float reward = 0;
        public List<Action> actions = new List<Action>();
    }

    bool?[] _masume = new bool?[9];

    int[][] _finish = new int[8][];

    int _gameover = 0;

	void Start ()
    {
        for (int i = 0; i < _masume.Length; i++)
        {
            _masume[i] = null;
        }
        _finish[0] = new int[3] { 0, 1, 2 };
        _finish[1] = new int[3] { 3, 4, 5 };
        _finish[2] = new int[3] { 6, 7, 8 };

        _finish[3] = new int[3] { 0, 3, 6 };
        _finish[4] = new int[3] { 1, 4, 7 };
        _finish[5] = new int[3] { 2, 5, 8 };

        _finish[6] = new int[3] { 0, 4, 8 };
        _finish[7] = new int[3] { 2, 4, 6 };

        State state0 = new State() { reward = 0 };
        PutTrue(state0);
    }

    private bool IsFinish(int[] finish, bool ex)
    {
        bool isGameOver = (ex == _masume[finish[0]] && ex == _masume[finish[1]] && ex == _masume[finish[2]]);
        if (isGameOver)
            _gameover++;
        return isGameOver;
    }

    private void PutTrue(State state)
    {
        for (int i = 0; i < _masume.Length; i++)
        {
            if (null == _masume[i])
            {
                State newState = new State();
                state.actions.Add(new Action() { i = i, reward = 0, state = newState });
                bool ex = true;
                _masume[i] = ex;
                bool win = false;
                for (int k = 0; k < _finish.Length; k++)
                {
                    if (IsFinish(_finish[k], ex))
                    {
                        newState.reward = 1;
                        win = true;
                        break;
                    }
                }
                if (!win)
                    PutFalse(newState);
                _masume[i] = null;
            }
        }
    }

    private void PutFalse(State state)
    {
        for (int j = 0; j < _masume.Length; j++)
        {
            if (null == _masume[j])
            {
                State newState = new State();
                state.actions.Add(new Action() { i = j, reward = 0, state = newState });
                bool ex = false;
                _masume[j] = ex;
                bool win = false;
                for (int k = 0; k < _finish.Length; k++)
                {
                    if (IsFinish(_finish[k], ex))
                    {
                        newState.reward = -1;
                        win = true;
                        break;
                    }
                }
                if (!win)
                    PutTrue(newState);
                _masume[j] = null;
            }
        }
    }

ゲームオーバー数をざっと数えてみたところ21万回だったので21万の枝葉ができる樹形図となっている模様。
一応先攻だったときの報酬として、〇で勝てば+1、×で勝てば-1という形で State の reward を決めさせてもらいました。

あとは、この樹形図を使って学習するコードを書く必要がありますね。
書いてみます。

書きました。

    private void LearnState(State state)
    {
        for (int i = 0; i < state.actions.Count; i++)
        {
            Action action = state.actions[i];
            LearnAction(action);
        } 
    }

    private void LearnAction(Action action)
    {
        LearnState(action.state);
        action.reward = action.state.reward + 0.9f * GetMaxReward(action.state);
    }

    private float GetMaxReward(State state)
    {
        if (0 == state.actions.Count)
        {
            return 0;
        }
        float maxReward = float.MinValue;
        for (int i = 0; i < state.actions.Count; i++)
        {
            if (maxReward < state.actions[i].reward)
                maxReward = state.actions[i].reward;
        }
        return maxReward;
    }

学習結果を表示すると次の通りです。

期待どおりでしたか？

そう、実は相手の着手も自分が打てるという条件と等しい学習方法ですので
相手が最弱手を打つことを想定して行動の報酬を決定しています。
つまり何処に打つにしても、必ず5手で勝利するため、報酬は同じとなってしまいました。

ということで
3目ならべで強化学習すると、どうなる？→こうなる
を示しました。

ちゃんとしたAIにするには、いつか勉強した MinMax法 を使うのがよさそうです。
記事は次に続きます。