Version : Unity 2021.3.5f1

Unity ML-Agents 2.0 을 이용한 Flappy Bird 훈련

ML-Agents 를 이용하여 Flappy Bird 를 교육시켰다.

Flappy Bird는 중력의 영향을 받아 아래 계속 떨어지고 점프를 통하여 위쪽으로 가속도를 줄 수 있다.

파이프는 배경과 같은 속도로 랜덤하게 나오도록 설계 ( 파이프[위/아래] 사이의 거리는 레벨에 따라 다르다. )

점수는 파이프와 파이프 사이에 오프젝트를 만들어 부딛히면 점수를 주고 바닥에 닿거나 파이프에 부딛히면 점수를 깍고 에피소드를 다시 시작한다.

관측하는 값은 자신의 Y 포지션과 가속도 (음 로컬이 문제인가….)

파이프와 파이프 사이의 거리는 커리큘럼 파라미터에 따라 달라진다. (60은 default)

저음 레벨이 낮을 경우에는 학습을 하고 있다고 느낄 정도로 정말 잘하지만

점점 가면 갈 수록 학습의 능률이 떨어지고 포기하는 경우의 수가 많아진다.

아마 인공지능의 컨트롤로 극복할 수 없는 환경이 되어서 포기하는 듯 하다. (내가 플레이 해도 못 깬다 ㅋㅋ )

Heuristic(휴리스틱-직접 컨트롤, 환경을 테스트 해볼 수 있다.)은 딜레이가 좀 있어서 미세한 컨트롤은 무리…

ML-Agents 를 사용하는 방법이 어렵다기 보다는 환경을 구성하는 부분에서 가장 많은 시간을 잡아먹었다. (교육에는 환경이 중요하다@!)

이번에 ML-Agent의 기본적인 사용법을 익힌 것이 가장 큰 수확

커리큘럼 파라미터 (Curriculum Parameter)

behaviors:
  FlyBird:
    trainer_type: ppo
    hyperparameters:
      batch_size: 256
      buffer_size: 4096
      learning_rate: 0.0003
      beta: 0.005
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
      learning_rate_schedule: constant
    network_settings:
      normalize: false
      hidden_units: 256
      num_layers: 2
      vis_encode_type: simple
    reward_signals:
      extrinsic:
        gamma: 0.95
        strength: 1.0
    keep_checkpoints: 5
    max_steps: 9000000
    time_horizon: 128
    summary_freq: 20000
environment_parameters:
  LevelUp:
    curriculum:
      - name: Lesson0
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.10
        value: 100
      - name: Lesson1
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.15
        value: 95
      - name: Lesson2
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.20
        value: 90
      - name: Lesson3
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.25
        value: 85
      - name: Lesson4
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.30
        value: 80
      - name: Lesson5
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.35
        value: 75
      - name: Lesson6
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.4
        value: 70
      - name: Lesson7
        completion_criteria:
          measure: progress
          behavior: FlyBird
          signal_smoothing: true
          min_lesson_length: 100
          threshold: 0.45
        value: 65
      - name: Lesson9
        value: 60

BirdAgent.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
using UnityEngine.Events;

public class BirdAgent : Agent
{
    public GameMain GameMain;
    EnvironmentParameters m_ResetParams;


    public Rigidbody2D rBody; 
    public float jumpForce = 25f;
    private bool Diecheck = false;

    public UnityAction onDIe;

    public override void Initialize()
    {
        m_ResetParams = Academy.Instance.EnvironmentParameters;
        this.rBody = this.gameObject.GetComponent<Rigidbody2D>();
        ConfigureAgent();
    }

    public override void OnEpisodeBegin()
    {
        this.Diecheck = false;
        this.transform.localPosition = new Vector3(-40f, 15f, 0f);

    }

    public override void CollectObservations(VectorSensor sensor)
    {
        sensor.AddObservation(this.gameObject.transform.localPosition.y); // 1
        //sensor.AddObservation(StepCount/MaxStep); // 1
        sensor.AddObservation(this.rBody.velocity.y); // 1
    }

    public override void OnActionReceived(ActionBuffers actions)
    {
        this.AddReward(1 / (float)this.MaxStep);

        var discreteActions = actions.DiscreteActions;

        if (discreteActions[0] == 1)
        {
            this.rBody.velocity = Vector2.up * this.jumpForce;
        }     
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var discreteActions = actionsOut.DiscreteActions;

        if (Input.GetKey(KeyCode.Space))
        {
            discreteActions[0] = 1;

        }
        else
        {
            discreteActions[0] = 0;
        }
    }



    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject.tag == "Target")
        {
            Debug.Log("Target");
            this.AddReward(0.02f);
            Destroy(collision.gameObject);
        }
        else
        {
            if (!Diecheck)
            {
                this.Diecheck = true;
                AddReward(-0.3f);
                this.onDIe();
                EndEpisode();
            }
        }
    }


    void ConfigureAgent()
    {
       this.GameMain.Level =(int)m_ResetParams.GetWithDefault("LevelUp", 60);
    }

    private void FixedUpdate()
    {
        this.ConfigureAgent();
    }


}

GameMain.cs

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


public class GameMain : MonoBehaviour
{
    public GameObject env; 

    public GameObject pipePrefabs;
    private Pipe pipe;

    public BirdAgent birdAgent;


    public GameObject GroundPrefabs;
    private Ground ground;

    private List<GameObject> pipesList = new List<GameObject>();
    private List<GameObject> GroundList = new List<GameObject>();

    public GameObject backGround;
    private SpriteRenderer backGroundRender;
    public int DieCount = 0;


    public float pipe_groundSpeed = 40f;
    public int Level = 80;
    public float pipeInitTIme = 1.5f;



    private void Awake()
    {
        Application.runInBackground = true;
        StartGameInit();
        this.backGroundRender = this.backGround.GetComponent<SpriteRenderer>();
    }

    void Start()
    {
        StartCoroutine(CreatePipeRoutine());

        this.birdAgent.onDIe = (() => {
            this.DieCount++;
            Debug.Log(this.DieCount);
            this.birdAgent.OnEpisodeBegin();
            // Destroy(birdGO);
            this.StartGameInit();

            StartCoroutine(BackGroundCoroutine());

        });
    }

    public void StartGameInit()
    {
        foreach (var item in this.pipesList)
        {
            if (item != null)
            {
                Destroy(item.gameObject);
            }
        }

        foreach (var item in this.GroundList)
        {
            if (item != null)
            {
                Destroy(item.gameObject);
            }
        }

        this.pipesList = new List<GameObject>();
        this.GroundList = new List<GameObject>();
        
        var groundGO = Instantiate<GameObject>(this.GroundPrefabs);
        groundGO.transform.SetParent(this.env.transform);
        groundGO.transform.localPosition = new Vector3(100f, 10f, -1f);
        this.ground = groundGO.GetComponent<Ground>();
        this.ground.ChangeGroundSpeed(this.pipe_groundSpeed); // 땅 속도 변경
        this.GroundList.Add(groundGO);

        groundGO = Instantiate<GameObject>(this.GroundPrefabs);
        groundGO.transform.SetParent(this.env.transform);

        groundGO.transform.localPosition = new Vector3(312f, 10f, -1f);
        this.ground = groundGO.GetComponent<Ground>();
        this.ground.ChangeGroundSpeed(this.pipe_groundSpeed); // 땅 속도 변경
        this.GroundList.Add(groundGO);
        groundGO = Instantiate<GameObject>(this.GroundPrefabs);
        groundGO.transform.SetParent(this.env.transform);

        groundGO.transform.localPosition = new Vector3(150f, 10f, -1f);
        this.ground = groundGO.GetComponent<Ground>();
        this.ground.ChangeGroundSpeed(this.pipe_groundSpeed); // 땅 속도 변경
        this.GroundList.Add(groundGO);



    }

    private IEnumerator CreatePipeRoutine()
    {

        while (true)
        {
            int num = 150 - this.Level;

            int randfirst = Random.Range(3, num);


            int randsecond = num - randfirst;

            var topGO = Instantiate<GameObject>(this.pipePrefabs);
            topGO.transform.SetParent(this.env.transform);
            this.pipe = topGO.GetComponent<Pipe>();
            this.pipe.SettingPipe(Pipe.eDirType.UP, randfirst);
            this.pipe.removePipe = ((pipe) => {
                pipesList.Remove(pipe); } );
            this.pipe.ChangePipeSpeed(this.pipe_groundSpeed);
            this.pipesList.Add(topGO);
            topGO.transform.localPosition = new Vector3(71f, -22f, -0.5997626f);
            

            topGO = Instantiate<GameObject>(this.pipePrefabs);
            topGO.transform.SetParent(this.env.transform);
            this.pipe = topGO.GetComponent<Pipe>();
            this.pipe.SettingPipe(Pipe.eDirType.Down, randsecond);
            this.pipe.removePipe = ((pipe) => {
                pipesList.Remove(pipe);
            });
            topGO.transform.localPosition = new Vector3(71f, 31f, -0.5997626f);
            this.pipe.ChangePipeSpeed(this.pipe_groundSpeed);
            this.pipesList.Add(topGO);
            yield return new WaitForSeconds(this.pipeInitTIme);

        }
    }

    private IEnumerator BackGroundCoroutine()
    {
        this.backGroundRender.color = new Color(255f, 0, 0f);

        yield return new WaitForSeconds(0.3f);

        this.backGroundRender.color = new Color(255f, 255f, 255f);
    }

}

Pipe.cs

using UnityEngine;
using UnityEngine.Events;

public class Pipe : MonoBehaviour
{
    public enum eDirType { UP = 1, Down = -1 };
    public eDirType dirType = eDirType.UP;
    public int[] arr = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
    public GameObject headGO;
    public GameObject bodyGO;
    public float moveSpeed = 20;
    public GameObject target;

    public UnityAction<GameObject> removePipe;


    // Update is called once per frame
    void Update()
    {
        this.transform.Translate(Vector3.left * moveSpeed * Time.deltaTime);

        if (this.transform.localPosition.x < -70f)
        {
            removePipe(this.gameObject);
            Destroy(this.gameObject);
        }
    }

    public void SettingPipe(eDirType Type, int rand)
    {
        //rand += level;
        this.dirType = Type;
        var localScale = this.bodyGO.transform.localScale;
        // localScale.y = (int)this.dirType * this.arr[rand];
        localScale.y = (float)this.dirType * rand;
        this.bodyGO.transform.localScale = localScale;
        //this.headGO.transform.localPosition = new Vector3(this.headGO.transform.localPosition.x,
        //(int)this.dirType * ((float)arr[rand]/10) * 3, this.headGO.transform.localPosition.z);
        this.headGO.transform.localPosition = new Vector3(this.headGO.transform.localPosition.x,
        ((((int)this.dirType) * ((float)rand / 10) * 3)) + ((int)this.dirType * 1.5f), this.headGO.transform.localPosition.z);

        if (Type == eDirType.Down)
        {
            Destroy(this.target.gameObject);
        }
        else
        {
            this.target.transform.localPosition = new Vector3(this.headGO.transform.localPosition.x, this.headGO.transform.localPosition.y + 12f, this.headGO.transform.localPosition.z);
        }
    }

    public void ChangePipeSpeed(float speed)
    {
        this.moveSpeed = speed;
    }

}

Test.cs

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

public class Test : MonoBehaviour
{
    public GameObject envPrefabs;
    void Start()
    {
        int x = 0;
        int y = 0;

        for (int i = 0; i < 10; i++)
        {

            Instantiate<GameObject>(this.envPrefabs).transform.position = new Vector3(x, y, 0);

            x += 300;

            if (x >= 1500)
            {
                x = 0;
                y += 300;
            }
        }
    }
}

The post Unity ML-Agents 2.0 (Flappy Bird 훈련) appeared first on 어제와 내일의 나 그 사이의 이야기.

유니티의 ML-Agents 2.0 TUTORIAL 영상을 대략적인 정리한 글입니다.

Version : Unity 2021.3.5f1

에피소드의 시작과 끝

(End&Start) 시작과 종료 조건을 사용할 때 고민해봐야할 것 

초기화 요소가 많을 경우 학습 속도의 저하 / 학습 노이즈를 제공할 수 있다.

EndEpisode // OnEpisodeBegin

초기화 요소가 적을경우

3D Ball 예제를 살펴보자

Hallway 예제

 Initialize()  ==> EndEpisode() =>  OnEpisodeBegin() ==> EndEpisode() => OnEpisodeBegin() ……..

초기화 요소가 많을경우

OnEpisodeBegin() 을 제거하고 EndEpisode()  다음에 씬전환을 해준다.

보상 

에이전트가 보상을 받을 수 있도록 해줘야한다.

Addreward 와  Setreward 를 잘 사용하자

예를 들어 에이전트가 목표와의 거리가 가까워졌는지 판단하고  이를 통해 보상을 주는 방법

특정구간 (체크포인트) 를 지날 때마다 점수를 주는방법

3D ball 과 환경과 같이 행동을 할때마다 보상을 주는 방법

에이전트가 행동을 할때마다 점수를 감점시키는 방법 등 다양한 방법이 있다.

알고리즘 하이퍼 파라미터 튜닝

참고자료들

https://github.com/Unity-Technologies/ml-agents/blob/main/docs/Training-ML-Agents.md

https://github.com/Unity-Technologies/ml-agents/blob/main/docs/Training-Configuration-File.md

예제의 Hallway 의 하이퍼 파라미터 

behaviors:
  Hallway:
    trainer_type: ppo
    hyperparameters:
      batch_size: 128
      buffer_size: 1024
      learning_rate: 0.0003
      beta: 0.03
      epsilon: 0.2
      lambd: 0.95
      num_epoch: 3
      learning_rate_schedule: linear
    network_settings:
      normalize: false
      hidden_units: 128
      num_layers: 2
      vis_encode_type: simple
      memory:
        sequence_length: 64
        memory_size: 128
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    keep_checkpoints: 5
    max_steps: 10000000
    time_horizon: 64
    summary_freq: 10000

behavior Name 을 동일하게 설정해야한다.  

traniner_type 

: 학습에 필요한 내장 알고리즘을 결정한다.    (기본값 : ppo)  / ppo, sac, poca

batch_size 

네트워크를 한번 학습할 때 몇개의 데이터를 사용할지 결정한다.

– 일반적인 설정 –   2의 배수로 설정을 추천

continuous action  (128~5120) 

Discrete action  (32~512)

buffer_size

: 정책을 업데이트 하기 전에 수집하는 경험의 데이터의 수

사이즈가 클수록 안정적인 학습이 가능합니다.

– 일반적인 설정 –   

2의 배수로 설정을 추천 + batch_size 의 배수로 설정

2048 ~ 409600

learning_rate

: 경사 하강법의 대한 초기학습률 

기본값 = 3e-4 ( 학습을 위한 초기 학습값 ) 

훈련이 불안정하거나 보상이 지속적으로 증가하지 않을 때 값을 줄인다.

beta  

: 정책을 더 무작위로 만드는 엔트로피 값입니다.

 이 값이 높을수록 더 랜덤 행동을 많이 하게 됩니다. ( 많은 탐험 수행 )

텐서보드에서 아직 학습이 잘되지 않았음에도 불구하고 엔트로피의 값이 너무 빠르게 떨어질경우 이 값을 높여야 합니다.

  기본값 = 5e-3  ( 학습을 위한 초기 학습값 ) 

cf > Discrete 환경에서는 엔트로피는 0 이하가 될 수 없지만 계산법의 차이로 

Continuous 환경에서는 엔트로피가 0 보다 작아질 수도 있다.

본인의 상황에 따라서 텐서 보드를 잘봐야한다.

epsilon 

 : 정책이 얼마나 빠르게 발전할지 결정합니다.  값을 줄일 수록 더 안정적이지만 학습의 속도가 느리다.

기본값 = 0.2  ( 학습을 위한 초기 학습값, 추천 ) 

https://github.com/Unity-Technologies/ml-agents/blob/main/docs/Training-Configuration-File.md <- 참고 링크

lambd

: 가치 추정에 의존을 할지 아니면 실제 수렴하는 보상에 의존을 할 지 결정하는 값

 값이 작을 떄는 가치 추정에 의존을 하고 값이 높으면 실제 수령하는 보상에 의존한다.

– 일반적인 설정 –   

  0.9 ~0.95 

(미래의 보상을 평가할 때 이전까지의 보상을 기준으로 하는 정도).

람다값이 적을수록 지금까지의 보상을 기준으로 미래의 보상을 평가하게 됨.

지금까지의 경향을 유지하는 방향으로 굳어짐.

num_epoch

경험버퍼에 쌓인 데이터에 대하여 학습을 몇번 수행할지 결정합니다.

batch_size 가 커질수록 이 값도 커져야 합니다.

이 값이 작아지면 안정적으로 학습이 가능하지만 학습속도 는 느려진다.

기본값 = 3  ( 학습을 위한 초기 학습값 ) 

learning_rate 와 같이 학습의 안정성에 대한 파라미터

learning_rate_schedule

:  linear(PPO)  /  constant(SAC) 선택가능

linear – MaxStep에 따라 러닝메이트가 감소하면서 학습이 진행됩니다. ( beta 값이 하락 )

constant – beta 값이 유지됩니다.

에피소드의 길이가 긴 환경에 따라 점차 안정적인 학습을 요구하게 되어 베타값이 하락하면서 더 안정적인 학습을 진행

시간이 변함에 따라 learning rate를 어떻게 변경할지 결정한다. 

/  PPO의 경우 max step까지 학습률을 감소시키는 경우 더 안정적으로 학습이 수렴된다. 

/  SAC의 경우 전체 학습과정 동안 학습률을 유지하여 자연스럽게 큐 함수값이 수렴할 떄 까지 학습 

normalize

: 벡터 관측 입력을 정규화 할지 결정하는 값으로

단순하거나 Discrete 환경에서는 false

복잡하거나 Continuous 환경에서는 true 사용합니다. (공식적으로) <환경이 단순하면 그냥 false하자 >

(입력되는 벡터 관측값들이 정규화가 되어있는지 물어 보는 것.)

우리가 정규화 시킨 상태에서 true로 설정하면 학습성능이 향상된다.

hidden_units

: 인공신경망에 몇개의 유닛을 사용할지 결정을 합니다.

  단순한 환경일 경우 작게 그리고 복잡한 환경일수록 크게 설정

num_layers

:  앞서 설정한  hidden_units 의 개수를 결정합니다.

  – 일반적인 설정 –   

     2

vis_encode_type

: 시각적 관찰을 인코딩하는 인코더 유형

기본적으로 simple 20 x 20 을 사용하지만  값을 더 작거나 크게 만들 수 있다.

reward_signals:
              extrinsic:
                   gamma: 
                   strength: 

gamma

: 보상 신호의 감마는 할인율과 관련한 값입니다.

절대 1이 넘지 않아야 하고 값이 클수록 원시안적으로 값이 클수록 근시안적으로 에이전트가 행동합니다. 

값이 너무 클경우 유도하지 않는 행동을 함에도 불구하고 원시안적으로 행동함으로써 학습에 문제가 생긴다.

(미래의 보상을 현재 평가할 때 적용하는 할인률).

감마값이 적을수록 먼 미래의 보상을 현재에서는 낮게 평가하기 때문에 즉각적인 보상이 상대적으로 높게 평가 됨.

strength

: 설정한 보상에 곱할 인수  일반적으로  1 로 설정

keep_checkpoints

: 몇번 학습모델을 저장할지 설정

10,000,000 / 5 = 2,000,000 스탭마다 저장

max_steps

:  이 예제에서 맥스 스탭은 학습이 진행될 최대의 스텝입니다. (복잡할수록 높아야한다.)

이 값에 도달하게되면 학습이 종료됩니다.

이 값에 따라서  learning rate 가 linear 일 경우  beta 값이 감소

time_horizon

: 경험 버퍼에 저장하기 전에 에이전트가 수집할 경험의 개수입니다.

에피소드가 끝나지 않고 2스텝에 도달하게 되면 에이전트는 점점 보상을 예측합니다.

이 값이 클수록 분산이 커지고 작을수록 분산이 작아집니다.

보상이 잦은 경우에는 작게 설정하는 것이 이상적입니다.

summary_freq

콘솔에 출력되는 학습의 주기입니다.

가독성을 키우기 위해 복잡하고 Maxstep이 높은 환경에서는 크게 단순한 환경에서는 작게 설정합니다.

(학습에 관한 파라미터는 아님)

The post Unity ML-Agents 2.0 에피소드 조건, 보상함수, 하이퍼 파라미터 설정 appeared first on 어제와 내일의 나 그 사이의 이야기.

유니티의 ML-Agents 2.0 TUTORIAL 영상을 대략적인 정리한 글입니다.

Version : Unity 2021.3.5f1

using Unity.MLAgents;

Agent 를 상속 받는다.

Agent 가 빨간줄로 표시되면 PackageManger 에서 우측 하단부의 Remove 버튼 대신에 업데이트를 눌러주면 해결된다.

Agent를 상속받은 스크립트를 가진 오브젝트는 

Behavior Parameters

Agent를 상속받은 Script

Decision Requester

이 세가지를 필수로 가지고 있어야 한다.

CMD 에서 확인 

(디폴트된 런아이들을 사용)

mlagents-learn --force

DiscreteActions  :  개별 작업

정수를 반환하기 때문에 참 / 거짓 Bool로 구현하기가 쉽고 

특정한 행동에 사용하기가 좋다.

public override void OnActionReceived(ActionBuffers actions)
    {
        int Discrete = actions.DiscreteActions[0];
        // Behavior Parameters 컴포넌트에서 Actions - Discreate Branches - Branche 0 size
        // Branche 0 size   2  =  0, 1

        int Discrete2 = actions.DiscreteActions[1];
        // Behavior Parameters 컴포넌트에서 Actions - Discreate Branches - Branche 1 size
        // Branche 1 size   3  =  0, 1, 2 

        int Discrete3 = actions.DiscreteActions[2];
        // Behavior Parameters 컴포넌트에서 Actions - Discreate Branches - Branche 2 size
        // Branche 0 size   5  =  0, 1, 2, 3, 4 

        Debug.LogFormat("Discrete : {0} / Discrete2 : {1} / Discrete3 : {2}", Discrete, Discrete2, Discrete3);

    }

ContinuousActions   :   연속 작업

특정 행동보다는 행동의 세기에 적절하게 사용할 수 있다.

public override void OnActionReceived(ActionBuffers actions)
    {
        // Unity Mathf.Clamp(A, b, c) = float A의 값이 float b와 float c 사이의 범위 이외의 값을 넘지 않도록 합니다.

  
        float Continuous1 =  Mathf.Clamp(actions.ContinuousActions[0], -1f, 1f);
        // Behavior Parameters 컴포넌트에서 Actions - Continuous Actions
        // 값 반환 -1f ~ 1f

        float Continuous2 = 2f * Mathf.Clamp(actions.ContinuousActions[1], -1f, 1f);
        // Behavior Parameters 컴포넌트에서 Actions - Continuous Actions
        // 값 반환 -2f ~ 2f

        float Continuous3 = 3f * Mathf.Clamp(actions.ContinuousActions[2], -1f, 1f);
        // Behavior Parameters 컴포넌트에서 Actions - Continuous Actions
        // 값 반환 -3f ~ 3f

        Debug.LogFormat("Continuous1 : {0} / Continuous2 : {1} / Continuous3 : {2}", Continuous1, Continuous2, Continuous3);

        // 값 반환 -1f ~ 1f

    }

Decision Requester  : 결정 주기

우리가 호출한 OnActionReceived 함수가 5번 호출될 때 마다 한번의 액션을 반환하는 설정

그러나 Take Actions Betwwn Decisions 가 체크되어 있으면 동일한 결정을 5번씩 호출

Heuristic  : 스스로 발견하게 하는

사용자가 직접 입력을 통해서 에이전트를 조정하여 액션 및 환경 메커니즘 등..을 확인 할 수 있습니다.

관찰

Vector / Camera / Sensor 를 이용하여 학습

위치 알려주거나 센서로 탐지 / 카메라를 이용한 이미지 감지는 학습시간이 오래걸린다

CollectObservations  :  수집 관찰

관측 개수와  Vector Observation – Space Size 의 크기를 맞추어 준다.

 Vector Observation – Stacked Vectors 

이전 그리고 그 이전의 Space Size 를 기록하는 공간입니다.

이 경우 전체의 Space Size 는 5 * 2  =  10 

지금 당장의 관측값만을 사용하는 것이 아닌 이전의 관측값까지 이용하기 위함입니다

학습이 가능한 공간 범위내로 가장 작게 설정하는 것을 추천합니다.

Ray perceptions Sensor 3D

Rays Per Direction   방향당 광선

Ray 의 방향당 광선의 수를 조절합니다.

Ray 의 수가 많을 수록 관측하는 값이 많아집니다.

Max Ray Degrees  최대 광선 각도

광선의 원뿔 크기로 90도를 사용하면 광선이 왼쪽으로 투사됩니다.

90보다 크면 뒤로 이동합니다.

값이 60도이면 광선이 중심선의 왼쪽과 오른쪽으로 30도 이상 확산됩니다.

Sphere Cast Radius  구면 주조 반지름

캐스팅할 구의 반경입니다. RayCast 의 경우 0으로 설정합니다.

Ray Length  광선 길이

투사할 광선의 길이를 설정합니다.

Ray Layer Mask    레이 레이어 마스크

광선이 닿을 수 있는 레이어를 제어합니다. ( 물체의 레이어가 체크되지 않으면 통과합니다. )

Detectable tags    감지 가능한 태그

감지 가능한 태그 목록을 추가해 줍니다

Stacked Raycasts  누적된 레이캐스트

신경망에 피드하기 전에 스택되는 레이캐스트 결과 수 입니다.

함께 쌓을 이전 관찰의 수를 지정합니다.

기본값 1은 현재 관측값만 보는 것을 의미합니다.

Start Vertical Offset    수직 오프셋 시작 

광선이 Y축을 따라 일부 오프셋에서 시작됨을 의미합니다(즉, 에이전트 중심 위 또는 아래).

End Vertical Offset    수직 오프셋 끝

광선이 Y축을 따라(즉, 수평선 위 또는 아래에서) 약간의 오프셋에서 종료된다는 것을 의미합니다.

The post Unity ML-Agents 2.0 행동 및 관측 설정 appeared first on 어제와 내일의 나 그 사이의 이야기.

Unity ML-Agents 2.0 설치 따라하기

Version : Unity 2021.3.5f1

Unity ML-Agents 2.0을 설치를 기록한 글입니다. 에이전트의 버전이 바뀌면 설치법이 달라질 수 있습니다.

(This article records the installation of Unity ML-Agent 2.0. If the version of the agent changes, the installation method may change.)

항상 유니티에서 제공하는 공식 문서를 확인하세요

https://unity.com/kr/products/machine-learning-agents <- 공식 사이트

홈페이지에서 Github에서 다운로드 클릭

Github에서 파일을 받아줍니다.

다운받은 프로젝트의 파일(ml-agents-main)을 프로젝트 폴더에 넣어줍니다.

최신버전 문서를 확인

문서에서 Installation 확인

유니티 버전과 파이썬 버젼을 확인합니다.

파이썬도 필요하니 설치해줍니다.

최신 버전도 좋지만 영상을 따라서 3.6.2 버전을 설치해줍니다.

Windows x86-64 web-based installer 설치

Add Python to 3.6 PATH 선택

강의를 따라서 Customize installation  

C:\ 에 Python 폴더를 생성 내부에 3.6.2 폴더를 또 생성하고 그 위치에 설치

설치가 완료된 후에 CMD 창을 열어서 python –version 입력

나는 관리자 권한으로 실행

시스템 환경 변수 편집 실행

건드릴 부분은 없고 설치를 확인하는 절차 입니다.

유니티에서 ml agent 프로젝트를 불러온다.

해당 프로젝트와 내가 사용하는 버젼이 다르다는 뜻 Choose another Editor version 을 누르고

내 유니티 버전으로 변경해준다.

버전이 다르다고 하는데 continue 로 넘겨주고 기다려준다.

열리는 동안 아까 열어둔 CMD 창에서 PyTorch를 설치한다.

pip3 install torch~=1.7.1 -f https://download.pytorch.org/whl/torch_stable.html

https://github.com/Unity-Technologies/ml-agents/blob/release_19_docs/docs/Installation.md <- 링크

완료!

ml-agents 도 설치해주자

python -m pip install mlagents==0.28.0

pip 버전이 낮으므로 업그레이드 해주자 ( pip는 unity의 asset store 와 비슷하다 )

python -m pip install --upgrade pip

다시  ml-agents  설치

강의 영상과는 약간 다르다

완료!

자 이제 직접 훈련을 시켜보자

제 아래의 Getting Started 를 눌러보자

이제 열린 유니티 프로젝트에 3DBall 씬을 열어보자 

그리고 플레이

이미 학습되어진 아이들이 작동되고 있다.

이제 학습을 시켜보기 위해서 한마리만 빼고 비활성화해주자

https://github.com/Unity-Technologies/ml-agents/blob/release_19_docs/docs/Getting-Started.md

Getting-Started 아래쪽에보면 훈련관련 명령어가 있다.

우리는 이것을 사용한다.

아까 받은 파일인 ml-agents-main 에서  3DBall.yaml 이 있는 것을 확인한다.

ml-agents-main\ml-agents-main\config\ppo

윈도우 폴더 옵션에서 숨김파일, 폴더 및 드라이브 표시 체크

알려진 파일 형식의 파일 확장명 숨기기 해제

를 해주는 것을 추천한다.

cmd 창을 열고 ppo 위치로 이동하자

cd  폴더위치  를 이용하면 편하다

dir로 폴더 내부의 파일이 있는지 확인 하자

이제 명령어로 학습을 시켜보자 

mlagents-learn config/ppo/3DBall.yaml –run-id=first3DBallRun

ppo 위치에 있으므로 명령어를 바꾸어서 입력했다.

mlagents-learn 3DBall.yaml –run-id=first3DBallRun

그리고 유니티를 플레이 해준다.

훈련중!@!

훈련 종료는 CTRL + C 버튼으로 종료 

응답이 없을 시에는 엔터 몇 번 치고  CTRL + C 를 입력하면 된다.

훈련 결과 파일 onnx를 확인 할 수 있습니다.

그리고 그 파일을 유니티에 넣어줍니다.

그 다음 훈련한 파일을 agent에 넣어줍니다.

그리고 플레이 해줍니다.

훈련이 덜되서 계속 떨어 뜨리네요 ㅠ

이미 훈련을 끝낸 애들과 비교해보겠습니다.

우리가 훈련시킨 아이만… 계속 공을 떨어뜨리네요 ㅋㅋㅋ

추가로 훈련 과정을 그래프로 확인할 수 있다 

https://github.com/Unity-Technologies/ml-agents/blob/release_19_docs/docs/Getting-Started.md

CMD 창에서 

   ….. \ml-agents-main\ml-agents-main\config\ppo  위치로 들어가서

tensorboard --logdir results 입력

나오는 주소를 아무 주소창에 입력하고 이동 

아래와 같이 방금 우리가 한 훈련에 대한 정보가 나온다.

텐서보드를 사용하여 훈련에 관한 다양한 정보를 확인하는 방법인데 추후에 따로 정리할 예정

끝

The post Unity ML-Agents 2.0 설치 (ml-agents install) appeared first on 어제와 내일의 나 그 사이의 이야기.