【Unity】第四回 オセロAI開発 〜ML-Agentsの強化学習を用いたAIの作成〜【ゲームAI】

        /// <summary>
        /// プレイヤー作成処理
        /// </summary>
        /// <param name="playerType">プレイヤータイプ</param>
        /// <param name="stoneState">プレイヤーの石の色</param>
        /// <param name="putStoneAction">ストーンを置く処理</param>
        /// <returns>作成したプレイヤー</returns>
        public IPlayer CreatePlayer(PlayerType playerType, StoneState stoneState, Action<StoneState, int, int> putStoneAction)
        {
            IPlayer player = null;
            switch (playerType)
            {
・・・略・・・
                // Prefabを読み込んで設定
                case PlayerType.MlAgentAIPlayerLearn1:
                    player = new MlAgentsAIPlayer(stoneState, putStoneAction);
                    player.OnInstantiate(_assetsService.LoadAssets("Player/MLAgentAIPlayerLearn1"));
                    break;
                case PlayerType.MlAgentAIPlayerLearn2:
                    player = new MlAgentsAIPlayer(stoneState, putStoneAction);
                    player.OnInstantiate(_assetsService.LoadAssets("Player/MLAgentAIPlayerLearn2"));
                    break;
            }
            return player;
        }

        /// <summary>
        /// ストーン情報
        /// </summary>
        private StoneState[,] _stoneStates;
        private StoneIndex[] _canPutStoneIndices;
        private StoneState _myStoneState;
        private StoneIndex _selectStoneIndex;

        /// <summary>
        /// ストーン探索処理
        /// </summary>
        /// <param name="stoneStates">ストーン状態配列</param>
        /// <param name="canPutStoneIndices">置けるマスのインデックス配列</param>
        /// <param name="myStoneState">自分のストーンの色</param>
        /// <returns>探索結果(置くインデックス)</returns>
        public async UniTask<StoneIndex> OnSearchSelectStone(StoneState[,] stoneStates, StoneIndex[] canPutStoneIndices, StoneState myStoneState)
        {
            // ストーン状態を設定
            _stoneStates = stoneStates;
            _canPutStoneIndices = canPutStoneIndices;
            _myStoneState = myStoneState;
            _selectStoneIndex = null;

            // 決定を要求する
            RequestDecision();

            // 置く位置を探索したら返却する
            await UniTask.WaitWhile(() => _selectStoneIndex == null);
            return _selectStoneIndex;
        }

using System;
using Reversi.Managers;
using Reversi.Players.Agents;
using Reversi.Stones;
using Reversi.Stones.Stone;

namespace Reversi.Players.AI
{
    /// <summary>
    /// MLAgentsを使用したAI
    /// </summary>
    public class MlAgentsAIPlayer : Player
    {
        private ReversiAIAgent _agent;
        public MlAgentsAIPlayer(StoneState myStoneState, Action<StoneState, int, int> putStoneAction) : base(myStoneState, putStoneAction) { }

        protected override void StartThink()
        {
            // エージェントクラスを取得
            if (_agent == null && PlayerGameObject != null)
            {
                _agent = PlayerGameObject.GetComponent<ReversiAIAgent>();
            }
            // 思考開始
            StartThinkAsync();
        }

        /// <summary>
        /// 選択するストーンを考える
        /// </summary>
        private async void StartThinkAsync()
        {
            // 考える時間
            await WaitSelectTime(200);

            // ストーン探索処理
            var canPutStones = StoneCalculator.GetAllCanPutStonesIndex(StoneStates, MyStoneState);
            SelectStoneIndex = await _agent.OnSearchSelectStone(StoneStates, canPutStones.ToArray(), MyStoneState);
        }

        protected override void EndGame(PlayerResultState resultState)
        {
            // ゲームを終了させる
            _agent.OnGameEnd(resultState);
        }
    }
}

        /// <summary>
        /// 観察
        /// </summary>
        public override void CollectObservations(VectorSensor sensor)
        {
            var learnStoneStates = ConvertLearnStoneStates(_stoneStates, _myStoneState);
            sensor.AddObservation(learnStoneStates);
        }

        /// <summary>
        /// ストーン状態配列を学習形式に変換して返却する
        /// </summary>
        private float[] ConvertLearnStoneStates(StoneState[,] stoneStates, StoneState myStoneState)
        {
            var convStoneStates = new float[stoneStates.Length];
            for (var i = 0; i < stoneStates.Length; i++)
            {
                var x = i % stoneStates.GetLength(0);
                var z = i / stoneStates.GetLength(0);
                convStoneStates[i] = ConvertLearnStoneState(stoneStates[x, z], myStoneState);
            }
            return convStoneStates;
        }

        /// <summary>
        /// ストーン状態を学習形式に変換して返却する
        /// </summary>
        private float ConvertLearnStoneState(StoneState stoneState, StoneState myStoneState)
        {
            // 何も置いてない：0
            if (stoneState == StoneState.Empty) return 0.0f;
            // 自分の色：1、相手の色：2
            return stoneState == myStoneState ? 1.0f : 2.0f;
        }

        /// <summary>
        /// 行動
        /// </summary>
        public override void OnActionReceived(ActionBuffers actions)
        {
            // ストーンを置く
            var discreteActions = actions.DiscreteActions;
            var index = discreteActions[0];
            var x = index % _stoneStates.GetLength(0);
            var z = index / _stoneStates.GetLength(0);
            var selectIndex = new StoneIndex(x, z);

            // 何故かマスクが効かないことがあったので、置ける場所かどうかのチェックを行う
            var isExist = false;
            foreach (var canPutStoneIndex in _canPutStoneIndices)
            {
                if (canPutStoneIndex.Equals(selectIndex)) isExist = true;
            }
            // 置けない場所に置こうとしたら再度行動をリクエスト
            if (!isExist)
            {
                RequestDecision();
                return;
            }
            _selectStoneIndex = selectIndex;
        }

        /// <summary>
        /// 行動のマスク
        /// </summary>
        public override void WriteDiscreteActionMask(IDiscreteActionMask actionMask)
        {
            // 置くことが可能なストーンを調べる
            for (var i = 0; i < _stoneStates.Length; i++)
            {
                var x = i % _stoneStates.GetLength(0);
                var z = i / _stoneStates.GetLength(0);
                var isCanPutStone = false;
                foreach (var canPutStoneIndex in _canPutStoneIndices)
                {
                    if (x == canPutStoneIndex.X && z == canPutStoneIndex.Z)
                    {
                        isCanPutStone = true;
                    }
                }
                // 置くことが可能なストーンのみ活性にする
                actionMask.SetActionEnabled(0, i, isCanPutStone);
            }
        }

        /// <summary>
        /// ゲーム終了処理
        /// </summary>
        /// <param name="resultState">勝敗結果</param>
        public void OnGameEnd(PlayerResultState resultState)
        {
            // 結果に応じて報酬を与える
            switch (resultState)
            {
                case PlayerResultState.Win:
                    SetReward(1.0f);
                    break;
                case PlayerResultState.Lose:
                    SetReward(-1.0f);
                    break;
            }
            // エピソード終了
            EndEpisode();
        }

        /// <summary>
        /// ヒューリスティック処理
        /// </summary>
        /// <param name="actionsOut"></param>
        public override void Heuristic(in ActionBuffers actionsOut)
        {
            // 置けるマスの中からランダムで決定する
            var stoneIndex = _canPutStoneIndices[UnityEngine.Random.Range(0, _canPutStoneIndices.Length)];
            var index = stoneIndex.Z * _stoneStates.GetLength(0) + stoneIndex.X;
            var discreteActions = actionsOut.DiscreteActions;
            discreteActions[0] = index;
        }

behaviors:
  Reversi:
    # トレーナー種別
    trainer_type: ppo
    
    # ハイパーパラメータ
    hyperparameters:
        
      # PPO、SAC共通
      batch_size: 32
      buffer_size: 320
      learning_rate: 3.0e-4
      learning_rate_schedule: constant
      
      # PPO固有
      beta: 0.005
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
    
    # ニューラルネットワーク
    network_settings:
      normalize: true
      hidden_units: 128
      num_layers: 2
      vis_encode_type: simple
    
    # 報酬シグナル
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    
    # 基本設定
    max_steps: 500000
    time_horizon: 1000
    summary_freq: 5000
    
    # セルフプレイ
    self_play:
        save_steps: 10000
        team_change: 50000
        swap_steps: 10000
        play_against_latest_model_ratio: 0.5
        window: 10
        initial_elo: 1200.0

behaviors:
  Reversi:
    # トレーナー種別
    trainer_type: ppo
    
    # ハイパーパラメータ
    hyperparameters:
        
      # PPO、SAC共通
      batch_size: 32
      buffer_size: 320
      learning_rate: 3.0e-4
      learning_rate_schedule: linear # 学習率を上げていく
      
      # PPO固有
      beta: 0.005
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
    
    # ニューラルネットワーク
    network_settings:
      normalize: true
      hidden_units: 128
      num_layers: 2
      vis_encode_type: simple
    
    # 報酬シグナル
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    
    # 基本設定
    max_steps: 500000
    time_horizon: 1000
    summary_freq: 5000