simplestarの技術ブログ

目的を書いて、思想と試行、結果と考察、そして具体的な手段を記録します。

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を作りました。
最も勝利確率の高いマスを赤く示してくれるツールとなっています。

f:id:simplestar_tech:20170129120257j:plain

具体的にどうしたかというと
前回作った強化学習のコードの一部を次の通り、変更してみました。
変更の意図としては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 の樹形図をこの再帰処理に構築してもらいましょう。
そんなコードを書いてみます。

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

f:id:simplestar_tech:20170122173848j:plain

    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;
    }

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

f:id:simplestar_tech:20170129112556j:plain

期待どおりでしたか?

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

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

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

とっても簡単!強化学習の実践

強化学習とは?
それは、行動の結果得られる報酬が最も大きくなる行動を選択する仕組みにおいて
その報酬を計算して求めることです。

例えば「働けばお金がもらえる」という場合は「お金」が報酬となります。
報酬の設定のしかたは問題によって、また設定する人それぞれですので、デザイナーとしての腕の見せ所となるでしょう。

今回はお金を報酬にして、強化学習を行う非常に簡単なゲームを作ります。

まず最初に理論的な話を進めます。
お付き合いください。

最初に述べた、行動の結果得られる報酬が最も大きくなる行動を選択する仕組みとは、いったいどういったものなのでしょうか?

f:id:simplestar_tech:20170114185111j:plain

それは、上図の構成において、エージェントと呼ばれるキャラクターが行動Aか行動Bを報酬の大きい方を選んで行動する仕組みのことを指します。

ここで出てくる報酬Aと報酬Bを計算で求めることが強化学習です。

数学の記号を使わず報酬=~という形の計算式を立てると

報酬A=宝箱ゲット、お金いっぱい
報酬B=トラップによるダメージ、ケガしてお金もらえない

と表せます。
次に記号を使って表してみましょう。

f:id:simplestar_tech:20170114225045j:plain

U()で示した値は行動の後、状態S'a, 状態S'b, になったときに得られる金額の値を示しています。
つまり、行動によって得られる報酬です。
この値は今回のデザイナーである私が決めました。(とにかく宝箱側のスコアが高ければ良いという考えで設定しています。)

強化学習で出てくる式で、よく読者の理解を妨げるのが、ここでいう「報酬の大きい値を選択する」という処理まで計算式に含めるところです。
ではその式を見てみましょう。

f:id:simplestar_tech:20170115100038j:plain

πで表した値は戦略と呼ばれるもので、つまりは行動Aか行動Bいずれかを出力する関数を表します。
argmaxというのは報酬を最大にするactionを選ぶ操作を意味し、つまりは行動Aか行動Bいずれか報酬の大きいactionを選択するということを意味します。
戦略を決めるのは私たち人間です。
今回の私のデザインではactionにaが入ることになるでしょう。
エージェントとなるキャラクター性を示す戦略にすると、きっと愛着のあるAIが作れると思います。

ここまで見てきた計算式について、報酬は人の手によってあらかじめデザインされていますので、代入のみで完結しています。
では、もし報酬がデザインされていない行動が出てきた場合は、どのようにその報酬を設定すればよいのでしょうか?

次の図を見てください。

f:id:simplestar_tech:20170115102015j:plain

状態Sになる前に、状態S0が存在するとします。
状態S0から状態S0へと進むための行動Xの結果得られる報酬Xはどのようにして求めるか?という問題を今私たちは解こうとしています。

ここで、報酬X=~という数式を立ててみたいと思います。

報酬X=走る、疲れてお金もらえない

確かに、今までの報酬の決め方に従えばこれで完成なのですが、大半の読者は報酬設定が間違っていると指摘できると思います。
そう、状態Sは状態S0に比べてお金持ちになれる可能性が高くなっています。
この期待の高まりを式に反映させたのが次の式です。

報酬X=走る、疲れてお金もらえない + 宝箱ゲット、お金いっぱい or トラップによるダメージ、ケガしてお金もらえない

これが強化学習の説明で最初に出てくる方程式 Bellman equation の原始的な姿です。

そういえば

報酬A=宝箱ゲット、お金いっぱい
報酬B=トラップによるダメージ、ケガしてお金もらえない

と定義していましたので、この原始的な式は次の形で表せます。

報酬X=走る、疲れてお金もらえない + 報酬A or 報酬B

さて、戦略πを採用すると、必ず報酬の大きい方を選ぶことになりますから、今回の私のデザインに従えば、式は次の形になります。

報酬X=走る、疲れてお金もらえない + 報酬A

そろそろ記号を使った数式で報酬Xを表してみます。

f:id:simplestar_tech:20170115105156j:plain

U(S)は状態Sへ進むための行動の報酬Xを表しています。
R(S)は走る、疲れてお金もらえないという状態Sそのものから得られる報酬を表しています。今回の私のデザインであればR(S)=0です。
maxは最も大きな値を選択して返す関数を表しています。
U(S'action)は、報酬Aまたは報酬Bいずれかを示しています。

ここで、報酬Xに報酬Aが減衰することなくそのままの値として代入されてしまいますが、これで本当に良いのでしょうか?
たとえば行動Xを行っている間に、誰かが先に宝箱を開けてお金を持っていってしまっているかもしれません。

そこで、割引率を考慮しようという発想が生まれます。
次の式が広く知れわたっている Bellman equation の姿です。

f:id:simplestar_tech:20170115110909j:plain

より詳細を学んで、この式が Bellman equation の形と違うと指摘する人が出てくると思いますが
Bellman equation に出てくる Model は、今回の私のデザインでは 1 ですので、確率表記は省略されています。
その方が最初は理解しやすいのでそうしています。

私たちはここまで、「もし報酬がデザインされていない行動が出てきた場合は、どのようにその報酬を設定すればよいのでしょうか?」
という問題に対して考えてきました。
今ならば答えられます。

Bellman equation を使って求めればよいのです。

それでは強化学習を実践してみましょう。
実践編の最初の作業としては、行動の結果得られる報酬が最も大きくなる行動を選択する仕組みというものから作ってみましょう。

f:id:simplestar_tech:20170115115027j:plain

作りました。

実装の方も概念を共有した後、コードを示したいと思います。

学習過程にて変動する行動に付随する報酬と、固定された状態に設定される報酬があります。
状態には行動リストがあり、行動には結果の状態があります。
それをつなぎ合わせて、Bellman equation を解く式をプログラムすると次の通り

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

public struct StateInfo
{
    public float reward;
    public ActionInfo[] actions;
}

public struct ActionInfo
{
    public float reward;
    public StateInfo targetState;
}

public class AgentBehaviour : MonoBehaviour {

    public float _gamma = 0.99f;
    public StateInfo[] _states = new StateInfo[4];

	void Start () {
        StateInfo state0 = new StateInfo();
        state0.reward = 0;
        state0.actions = new ActionInfo[1];

        StateInfo state = new StateInfo();
        state.reward = 0;
        state.actions = new ActionInfo[2];

        StateInfo stateA = new StateInfo();
        stateA.reward = 1000000;
        stateA.actions = null;

        StateInfo stateB = new StateInfo();
        stateB.reward = 0;
        stateB.actions = null;

        state0.actions[0].targetState = state;
        state.actions[0].targetState = stateA;
        state.actions[1].targetState = stateB;

        _states[0] = state0;
        _states[1] = state;
        _states[2] = stateA;
        _states[3] = stateB;

        int count = 3;
        while (0 < --count)
        {
            Learn();
        }
    }

    private void Learn()
    {
        for (int i = 0; i < _states.Length; i++)
        {
            LearnState(ref _states[i]);
        }
    }

    private void LearnState(ref StateInfo state)
    {
        if (null != state.actions)
        {
            for (int j = 0; j < state.actions.Length; j++)
            {
                LearnAction(ref state.actions[j]);
            }
        }
    }

    private void LearnAction(ref ActionInfo action)
    {
        action.reward = action.targetState.reward + _gamma * GetMaxReward(ref action.targetState);
    }

    private static float GetMaxReward(ref StateInfo targetState)
    {
        if (null == targetState.actions)
        {
            return 0;
        }

        float maxReward = 0;
        for (int i = 0; i < targetState.actions.Length; i++)
        {
            if (maxReward < targetState.actions[i].reward)
            {
                maxReward = targetState.actions[i].reward;
            }
        }
        return maxReward;
    }
}

繰り返し計算を2回すると、行動の報酬が収束することを確認しました。
これが、最も単純な強化学習の例だと思います。

あとは、この学習結果を参照して、最も大きな報酬の行動を選択して行動する仕組みを書けば、ゲームの完成です。
ゲームの実装はハンザツなので省略します。

ユニティちゃんライセンス

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

強化学習の Value Iteration と Q-Learning の違い

強化学習には Value Iteration と Q-Learning の2通りの学習方法が存在します。

Value Iteration で登場する Model が既知か、未知かを見て
未知の場合は、試行錯誤を繰り返す Q-Learning しか選べません。

Value Iteration にて登場する報酬は人間のさじ加減で決めます。
行動と結果の組み合わせを示す Model もまた、人間のさじ加減で決めます。
Model の見当がつかない場合は Q-Learning に逃げます。
Q-Learning とは試行錯誤を続けて、ずっとずっと試行錯誤を続けて、いつの日か人間のさじ加減で決めた報酬が得られたなら、それまでの行動経路の評価値をちょっとだけ上げるという学習方法です。
このときの評価値のちょっとした上げ方も人間のさじ加減で決めます。

いくつか解説を見てきましたが、ハンザツなままとらえている人が多いですね。
私はこんな風に、すっきりととらえてみました。

間違えたら、その行動を避けるようになり
当たったら、それまでの行動を取りやすくなる
これなら確かに、経験から学ぶ人にそっくりな行動を取るのかもしれませんね。

エピソード(思い出)を記録し、呼び起こす強化学習

強化学習について(私が知識を増やすために)学んでいますが、Value Iteration と Q-Learning の違いを書く前に(この後書こうと思っています。)
一つ昔に高校時代の友人から教えてもらった、エピソードに紐づく知識というものとの組み合わせを思いつきました。
simplestar-tech.hatenablog.com

↑この時に友人に教わった。

強化学習は状態とその時選択できる行動に評価値が与えられるというだけで、エピソードまでは思い起こせません。
これから行われるだろう未来は、強化学習時に無数に調べてきたわけですが、実行時は結果的に評価値という数字しか知識に残っていません。

行動選択はできるようになりますが、どうして?と尋ねられても、評価値が高いからという答えしか返せないのです。
そこで、その行動の評価値を大きく変動させた強烈なエピソードを思い出として記録し、未来予測として、どうして?と尋ねられた時に答える。
という、人工知能を作ってみたら、AIからその時の気持ちのようなものを教えてもらえるような気がしてきました。

という、アイディアを忘れないように書き留めておくという記事でした。

AI的な調べもの

最近、社内の勉強会でその存在を再確認したのですが、みなさんは OpenAI をご存知ですか?

OpenAI は組織名のようです。
コンテンツは Gym にあるとのことです。

OpenAI Gymは、強化学習を開発、評価するための プラットフォームです。
色々な環境が用意されているようで、次のリンクで一覧できました。
OpenAI Gym

ところで強化学習というのは、環境に対して行動の選択肢から行動を選択して行動し、その報酬(Reward)を最終的な結果から推定して、何度もこれを繰り返すことにより経験的にその推定Rewardが最大になる行動を選べるようにする手法です。

重要なので「経験的にその推定Rewardが最大」というところを強調しますが、つまりはローカルミニマムでさえなく、今までで一番良かった(かもしれない)試行結果に落ち着くということです。

強化学習について調べていたところ、次のQiitaの記事が、知りたいことをたくさん書いてくれていました。
qiita.com

まぁ、人間もRewardの推定を間違えている人がいますし
頭が良くても、学習データが間違っていると、これもまた誤ったローカルミニマムに陥りますので
「強化学習」=「間違える機械学習」というイメージを持っています。

追記:
時間をおいて深く読んでみたところ、疑問に思うところがあるので別の資料を当たりながら、自分なりの理解メモを追記しておきます。
まず、この等式をBellman equationと言います。と示されている式
選択肢aが複数あり、その中からひとつa選択したときにs'が無数に存在するため、∑計算ができるという式です。
無数にs'が存在することを言及していなかったので、ちょっと悩みました。
次に、value iteration の変数決定について疑問に思いました。
報酬を設定するという操作が、どういう操作なのか、例えば、人が考えるおよその値を設定し、その値をすこしずつ変化させるのか?
それよりも、一体何が収束するのか?書かれていないので調べることになりました。
調べた結果、現在わかっている範囲では初期値にすべての報酬を0とするという手法。
しかし、びっくりしたことに、そうすると計算を繰り返しても0しか返ってきませんので、何も変化が生まれません。
なるほど自分が疑問に思っていることは正しいようだが、利用したい側の立場としてはうれしくないですね。
は!書いていて気づいたことに、0以外になる瞬間が存在していました。
それは、正解が確定した瞬間と失敗が確定した瞬間です。
そのときに報酬が+1,-1になるようにしておけば、その一手前にて報酬が更新されます。
そこから波紋が広がるように、報酬の更新が走るんですね。
その報酬更新がいつか収束することが期待できるようで、このようにして報酬を決める手法がValue Iterationです。
どうやら私はそのValue Iterationの問題点をずっと指摘していたようです。
正解するまで計算を繰り返さないかぎり、値の更新が行われないということは、大量の計算が必要ということを示しており、一般的にValue Iterationでは、解を求めることは難しいケースが多いとのことです。
もう一つ、Q-Learningというものがあるそうで、次はそちらを理解してみたいと思います。

プラス、人間の行動の動機としての、欲求について知りたかったので、心理学の方を調べてみました。

その点について良さそうな記事を見つけました。
人生の学習 - マズローの心理学

なんとも、人生における幸せな生活とは何かについて考えさせられる記事でしたが
同じような欲求をデジタルなAIにも持たせてみようと考えてみました。

マズローの心理学の話で参考になった部分は次の二つ

「ヨナ・コンプレックス」と呼ばれる、欲求に気付くまいと潜在意識に押し込める臆病な行動
「欲求の段階説」という考え方
人の欲求は6つの段階
1.「生理的欲求」食事とか睡眠とかの欲求
2.「安全の欲求」1.が安定すること
3.「社会的欲求と愛・所属の欲求」人間社会で生きる者としては2.と同じかな?と私は思っている
4.「評価欲求」(他の人から価値ある人だと見なされること、他の人の中で価値ある人であること)
5.「自己実現の欲求」(道徳的であること、問題解決、先入観を持たないこと、事実を受け入れること)
6.「自己超越の欲求」(創造性、自発性、子供のような素朴さ、文化の超越、至高体験

なるほど、これらについて強化学習のRewardを設計してみようかと思います。

調べることから始めていたのですが、ここで目的がだんだん形になってきました。
頑張って言葉にすると、AIが行動するマイクロワールドを作り、それを観察できるオンラインゲームを作ってみたいと考えています。

いつかの AI の記事を書いているときに、AI に身体性を持たせる必要があると結論づけて終わっていたと思います。(終わっていなかったらごめん、あとで確認する)
その身体性をマイクロワールドの中で与えてあげようという試みです。

次回は、本当に簡単なものを作ってみようと思います。