03. ML-Agents - Ray Perception Sensor 3D

🔷 실습 3

- bad item에 부딪히면 -1, good item에 부딪히면 +1

- Raycast 발사하여 관측

- good item / bad item

- 이산값 DiscreteActions

 

 

 

🔷 트레이닝 환경 구축

🔶 기본세팅

- 씬 생성(MummyRay)

 

 

 

- 빈 게임오브젝트 (Stage)

- Cube (Floor)

    - Scale : 50, 0.1, 50

 

 

 

- 빈게임오브젝트(Walls)

- Cube (Wall)

    - Scale : 50, 3, 1

 

 

 

 

- Agent 추가

    - Position : 0, 0.05, 0

 

 

 

https://assetstore.unity.com/packages/3d/characters/creatures/rpg-monster-duo-pbr-polyart-157762

- RPG Monster Duo PBR Polyart 다운 > 임포트

 

 

 

- Slime, TurtleShell 추가

 

 

 

- Slime, TurtleShell -> GoodItem, BadItem으로 이름 변경

 

 

 

- Sphere Collider 추가

    - Center : 0, 0.5, 0

    - Radius : 0.7

 

 

 

- 태그 추가 후 각각의 오브젝트에 태그 달기

 

 

 

- MummyRayAgent.cs 생성

 

 

 

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

public class MummyRayAgent : Agent
{
    public override void Initialize()
    {

    }

    public override void OnEpisodeBegin()
    {

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {

    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {

    }
}

- 기본 함수 작성

 

 

 

- MummyRayAgent.cs 넣기

- Behavior Name : MummyRay

 

 

 

- 컴포넌트 추가 : Ray Perception Sensor 3D

- 부채꼴모양의 레이를 쏨

 

 

 

- Ray의 시작점 조절

    - Start Vertical Offset : 0.5

    - End Vertical Offset : 0.5

 

 

 

- Detectable Tags : 레이로 검출하는 대상

    - Tag 3개 추가

 

 

 

- Rays per Direction : 4 : 몇 개의 레이를 쏠 것인지

- Max Ray Degrees : 80 : 레이 사이의 각도

- Ray Length : 30 : 레이의 길이

 

 

 

🔶 Agent 위치, 회전값 랜덤으로 생성

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

public class MummyRayAgent : Agent
{
    private new Transform transform;
    private new Rigidbody rigidbody;

    public float moveSpeed = 1.5f;
    public float turnSpeed = 200.0f;



    public override void Initialize()
    {
        // 한 에피소드(학습단위) 당 시도 횟수
        MaxStep = 5000;

        transform = GetComponent<Transform>();
        rigidbody = GetComponent<Rigidbody>();
    }

    public override void OnEpisodeBegin()
    {
        // 스테이지 초기화

        // 물리엔진 초기화
        rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;

        // 에이전트의 위치를 변경
        transform.localPosition = new Vector3(Random.Range(-22.0f, 22.0f), 0.05f, Random.Range(-22.0f, 22.0f));

        // 에이전트의 회전값 변경
        transform.localRotation = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {

    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {

    }
}

- Agent 위치, 회전값 랜덤으로 생성

 

 

 

- 컴포넌트 추가 : Rigidbody, Capsule Collider

- 각 컴포넌트 조절

 

 

 

🔶 good item, bad item 생성

- GoodItem, BadItem 프리팹화

 

 

 

- GoodItem, BadItem의 각각 Animator Controller 처리

- Idle만 하도록 Transition을 끊어줌

 

 

 

- GoodItem, BadItem 하이어라키 창에서 삭제

 

 

 

- StageManager.cs 생성

 

 

 

- Stage오브젝트에 StageManager.cs 넣기

 

 

 

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

public class StageManager : MonoBehaviour
{
    public GameObject goodItem;
    public GameObject badItem;

    public int goodItemCount = 30;
    public int badItemCount = 20;

    public List<GameObject> goodList = new List<GameObject>();
    public List<GameObject> badList = new List<GameObject>();

    void Start()
    {
        SetStageObject();
    }

    public void SetStageObject()
    {
        // Good Item 생성
        for (int i = 0; i < goodItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            goodList.Add(Instantiate(goodItem, transform.position + pos, rot, transform));
        }

        // Bad Item 생성
        for (int i = 0; i < badItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            badList.Add(Instantiate(badItem, transform.position + pos, rot, transform));
        }
    }
}

 

- GoodItem, BadItem  총 50개 생성

 

 

 

- GoodItem, BadItem 프리팹 연결

 

 

 

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

public class StageManager : MonoBehaviour
{
    public GameObject goodItem;
    public GameObject badItem;

    public int goodItemCount = 30;
    public int badItemCount = 20;

    public List<GameObject> goodList = new List<GameObject>();
    public List<GameObject> badList = new List<GameObject>();

    void Start()
    {
        SetStageObject();
    }

    public void SetStageObject()
    {
        foreach (var obj in goodList)
        {
            Destroy(obj);
        }
        foreach (var obj in badList)
        {
            Destroy(obj);
        }

        // List 초기화
        goodList.Clear();
        badList.Clear();

        // Good Item 생성
        for (int i = 0; i < goodItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            goodList.Add(Instantiate(goodItem, transform.position + pos, rot, transform));
        }

        // Bad Item 생성
        for (int i = 0; i < badItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            badList.Add(Instantiate(badItem, transform.position + pos, rot, transform));
        }
    }
}

- good item, bad item 생성

 

 

 

🔶 Agent 이동

- Space Size : 0 : 관측하는 값 개수 없음

- Discrete Branches : 2 : 이산값 (해당 프로젝트에서는 이동, 회전)

    - Branch 0 size : 3 : (정지, 전진, 후진)

    - Branch 1 size : 3 : (정지, 좌회전, 우회전)

 

 

 

- 컴포넌트 추가 : Decision Requester

 

 

 

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

public class MummyRayAgent : Agent
{
    private new Transform transform;
    private new Rigidbody rigidbody;

    public float moveSpeed = 1.5f;
    public float turnSpeed = 200.0f;



    public override void Initialize()
    {
        // 한 에피소드(학습단위) 당 시도 횟수
        MaxStep = 5000;

        transform = GetComponent<Transform>();
        rigidbody = GetComponent<Rigidbody>();
    }

    public override void OnEpisodeBegin()
    {
        // 스테이지 초기화

        // 물리엔진 초기화
        rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;

        // 에이전트의 위치를 변경
        transform.localPosition = new Vector3(Random.Range(-22.0f, 22.0f), 0.05f, Random.Range(-22.0f, 22.0f));

        // 에이전트의 회전값 변경
        transform.localRotation = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {
        var action = actions.DiscreteActions;
        Debug.Log($"[0] = {action[0]}, [1]: {action[1]}");
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var action = actionsOut.DiscreteActions;    // 이산(-1.0, 0.0, +1.0)

        actionsOut.Clear();

        // Branch 0 - 이동로직에 쓸 키 맵핑
        // Branch 0의 Size : 3
        //  정지    /   전진    /   후진
        //  Non     /   W       /   S
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.W))
        {
            action[0] = 1;
        }
        if (Input.GetKey(KeyCode.S))
        {
            action[0] = 2;
        }

        // Branch 1 - 회전로직에 쓸 키 맵핑
        // Branch 1의 Size : 3
        //  정지    /   좌회전  /   우회전
        //  Non     /   A       /   D
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.A))
        {
            action[1] = 1;
        }
        if (Input.GetKey(KeyCode.D))
        {
            action[1] = 2;
        }

    }
}

- 아이템이 흩뿌려지고, Agent가 움직이지는 않는 상태

---

 

 

 

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

public class StageManager : MonoBehaviour
{
    public GameObject goodItem;
    public GameObject badItem;

    public int goodItemCount = 30;
    public int badItemCount = 20;

    public List<GameObject> goodList = new List<GameObject>();
    public List<GameObject> badList = new List<GameObject>();

    public void SetStageObject()
    {
        foreach (var obj in goodList)
        {
            Destroy(obj);
        }
        foreach (var obj in badList)
        {
            Destroy(obj);
        }

        // List 초기화
        goodList.Clear();
        badList.Clear();

        // Good Item 생성
        for (int i = 0; i < goodItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            goodList.Add(Instantiate(goodItem, transform.position + pos, rot, transform));
        }

        // Bad Item 생성
        for (int i = 0; i < badItemCount; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-23.0f, 23.0f), 0.05f, Random.Range(-23.0f, 23.0f));
            Quaternion rot = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

            badList.Add(Instantiate(badItem, transform.position + pos, rot, transform));
        }
    }
}

- Start() 삭제 : SetStageObject() 함수를 호출했었음

    - MummyRayAgent.cs에서 호출할 것이기 때문에 삭제

 

 

 

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

public class MummyRayAgent : Agent
{
    private new Transform transform;
    private new Rigidbody rigidbody;

    public float moveSpeed = 1.5f;
    public float turnSpeed = 200.0f;
    private StageManager stageManager;



    public override void Initialize()
    {
        // 한 에피소드(학습단위) 당 시도 횟수
        MaxStep = 5000;

        transform = GetComponent<Transform>();
        rigidbody = GetComponent<Rigidbody>();
        stageManager = transform.parent.GetComponent<StageManager>();
    }

    public override void OnEpisodeBegin()
    {
        // 스테이지 초기화
        stageManager.SetStageObject();

        // 물리엔진 초기화
        rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;

        // 에이전트의 위치를 변경
        transform.localPosition = new Vector3(Random.Range(-22.0f, 22.0f), 0.05f, Random.Range(-22.0f, 22.0f));

        // 에이전트의 회전값 변경
        transform.localRotation = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {
        var action = actions.DiscreteActions;
        Debug.Log($"[0] = {action[0]}, [1]: {action[1]}");

        Vector3 dir = Vector3.zero;
        Vector3 rot = Vector3.zero;

        // Branch 0 : 정지 / 전진 / 후진
        switch (action[0])
        {
            case 1: dir = transform.forward; break;
            case 2: dir = -transform.forward; break;
        }

        // Branch 1 : 정지 / 좌회전 / 우회전
        switch (action[1])
        {
            case 1: rot = -transform.up; break;
            case 2: rot = transform.up; break;
        }

        transform.Rotate(rot, Time.fixedDeltaTime * turnSpeed);
        rigidbody.AddForce(dir * moveSpeed, ForceMode.VelocityChange);

        // 마이너스 페널티를 적용
        AddReward(-1 / (float)MaxStep);
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var action = actionsOut.DiscreteActions;    // 이산(-1.0, 0.0, +1.0)

        actionsOut.Clear();

        // Branch 0 - 이동로직에 쓸 키 맵핑
        // Branch 0의 Size : 3
        //  정지    /   전진    /   후진
        //  Non     /   W       /   S
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.W))
        {
            action[0] = 1;
        }
        if (Input.GetKey(KeyCode.S))
        {
            action[0] = 2;
        }

        // Branch 1 - 회전로직에 쓸 키 맵핑
        // Branch 1의 Size : 3
        //  정지    /   좌회전  /   우회전
        //  Non     /   A       /   D
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.A))
        {
            action[1] = 1;
        }
        if (Input.GetKey(KeyCode.D))
        {
            action[1] = 2;
        }

    }
}

- 스테이지 초기화 : SetStageObject() 함수 호출

- 이동 및 회전 처리

 

 

 

🔶 리워드 부여

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

public class MummyRayAgent : Agent
{
    private new Transform transform;
    private new Rigidbody rigidbody;

    public float moveSpeed = 1.5f;
    public float turnSpeed = 200.0f;
    private StageManager stageManager;



    public override void Initialize()
    {
        // 한 에피소드(학습단위) 당 시도 횟수
        MaxStep = 5000;

        transform = GetComponent<Transform>();
        rigidbody = GetComponent<Rigidbody>();
        stageManager = transform.parent.GetComponent<StageManager>();
    }

    public override void OnEpisodeBegin()
    {
        // 스테이지 초기화
        stageManager.SetStageObject();

        // 물리엔진 초기화
        rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;

        // 에이전트의 위치를 변경
        transform.localPosition = new Vector3(Random.Range(-22.0f, 22.0f), 0.05f, Random.Range(-22.0f, 22.0f));

        // 에이전트의 회전값 변경
        transform.localRotation = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {
        var action = actions.DiscreteActions;
        Debug.Log($"[0] = {action[0]}, [1]: {action[1]}");

        Vector3 dir = Vector3.zero;
        Vector3 rot = Vector3.zero;

        // Branch 0 : 정지 / 전진 / 후진
        switch (action[0])
        {
            case 1: dir = transform.forward; break;
            case 2: dir = -transform.forward; break;
        }

        // Branch 1 : 정지 / 좌회전 / 우회전
        switch (action[1])
        {
            case 1: rot = -transform.up; break;
            case 2: rot = transform.up; break;
        }

        transform.Rotate(rot, Time.fixedDeltaTime * turnSpeed);
        rigidbody.AddForce(dir * moveSpeed, ForceMode.VelocityChange);

        // 마이너스 페널티를 적용
        AddReward(-1 / (float)MaxStep);
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var action = actionsOut.DiscreteActions;    // 이산(-1.0, 0.0, +1.0)

        actionsOut.Clear();

        // Branch 0 - 이동로직에 쓸 키 맵핑
        // Branch 0의 Size : 3
        //  정지    /   전진    /   후진
        //  Non     /   W       /   S
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.W))
        {
            action[0] = 1;
        }
        if (Input.GetKey(KeyCode.S))
        {
            action[0] = 2;
        }

        // Branch 1 - 회전로직에 쓸 키 맵핑
        // Branch 1의 Size : 3
        //  정지    /   좌회전  /   우회전
        //  Non     /   A       /   D
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.A))
        {
            action[1] = 1;
        }
        if (Input.GetKey(KeyCode.D))
        {
            action[1] = 2;
        }
    }

    void OnCollisionEnter(Collision coll)
    {
        if (coll.collider.CompareTag("GOOD_ITEM"))
        {
            // 가속도가 붙을 수 있기때문에 물리력 초기화
            rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;
            Destroy(coll.gameObject);
            AddReward(1.0f);
        }

        if (coll.collider.CompareTag("BAD_ITEM"))
        {
            AddReward(-1.0f);
            EndEpisode();
        }

        if (coll.collider.CompareTag("WALL"))
        {
            AddReward(-0.1f);
        }

    }

}

- 충돌 체크

- 리워드

• 가만히 있을 수도 있으므로 페널티 부여
  • AddReward(-1 / (float)MaxStep)
  • 최적화된 페널티임

• 벽에 부딪히지 않도록 페널티 부여
  • AddReward(-0.1f)
  • 임시값이므로 조절 필요
  • 만약 Agent가 벽에 부딪히는게 감수할만한 패널티로 판단하여 벽에 부딪힌다면, 패널티 값을 올려야 함.

 

 

 

🔶 리워드 받을 때마다 바닥 색상 변경

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

public class MummyRayAgent : Agent
{
    private new Transform transform;
    private new Rigidbody rigidbody;
    private StageManager stageManager;

    public float moveSpeed = 1.5f;
    public float turnSpeed = 200.0f;

    private Renderer floorRd;
    public Material goodMAT, badMAT;
    private Material originMAT;



    public override void Initialize()
    {
        // 한 에피소드(학습단위) 당 시도 횟수
        MaxStep = 5000;

        transform = GetComponent<Transform>();
        rigidbody = GetComponent<Rigidbody>();
        stageManager = transform.parent.GetComponent<StageManager>();
        floorRd = transform.parent.Find("Floor").GetComponent<Renderer>();
        originMAT = floorRd.material;
    }
    // 바닥의 색상을 환원시키는 로직
    IEnumerator RevertMaterial(Material changeMAT)
    {
        floorRd.material = changeMAT;
        yield return new WaitForSeconds(0.2f);
        floorRd.material = originMAT;
    }

    public override void OnEpisodeBegin()
    {
        // 스테이지 초기화
        stageManager.SetStageObject();

        // 물리엔진 초기화
        rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;

        // 에이전트의 위치를 변경
        transform.localPosition = new Vector3(Random.Range(-22.0f, 22.0f), 0.05f, Random.Range(-22.0f, 22.0f));

        // 에이전트의 회전값 변경
        transform.localRotation = Quaternion.Euler(Vector3.up * Random.Range(0, 360));

    }

    public override void CollectObservations(VectorSensor sensor)
    {

    }

    public override void OnActionReceived(ActionBuffers actions)
    {
        var action = actions.DiscreteActions;
        Debug.Log($"[0] = {action[0]}, [1]: {action[1]}");

        Vector3 dir = Vector3.zero;
        Vector3 rot = Vector3.zero;

        // Branch 0 : 정지 / 전진 / 후진
        switch (action[0])
        {
            case 1: dir = transform.forward; break;
            case 2: dir = -transform.forward; break;
        }

        // Branch 1 : 정지 / 좌회전 / 우회전
        switch (action[1])
        {
            case 1: rot = -transform.up; break;
            case 2: rot = transform.up; break;
        }

        transform.Rotate(rot, Time.fixedDeltaTime * turnSpeed);
        rigidbody.AddForce(dir * moveSpeed, ForceMode.VelocityChange);

        // 마이너스 페널티를 적용
        AddReward(-1 / (float)MaxStep);
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var action = actionsOut.DiscreteActions;    // 이산(-1.0, 0.0, +1.0)

        actionsOut.Clear();

        // Branch 0 - 이동로직에 쓸 키 맵핑
        // Branch 0의 Size : 3
        //  정지    /   전진    /   후진
        //  Non     /   W       /   S
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.W))
        {
            action[0] = 1;
        }
        if (Input.GetKey(KeyCode.S))
        {
            action[0] = 2;
        }

        // Branch 1 - 회전로직에 쓸 키 맵핑
        // Branch 1의 Size : 3
        //  정지    /   좌회전  /   우회전
        //  Non     /   A       /   D
        //  0       /   1       /   2
        if (Input.GetKey(KeyCode.A))
        {
            action[1] = 1;
        }
        if (Input.GetKey(KeyCode.D))
        {
            action[1] = 2;
        }
    }

    void OnCollisionEnter(Collision coll)
    {
        if (coll.collider.CompareTag("GOOD_ITEM"))
        {
            // 가속도가 붙을 수 있기때문에 물리력 초기화
            rigidbody.velocity = rigidbody.angularVelocity = Vector3.zero;
            Destroy(coll.gameObject);
            AddReward(1.0f);

            StartCoroutine(RevertMaterial(goodMAT));
        }

        if (coll.collider.CompareTag("BAD_ITEM"))
        {
            AddReward(-1.0f);
            EndEpisode();

            StartCoroutine(RevertMaterial(badMAT));
        }

        if (coll.collider.CompareTag("WALL"))
        {
            AddReward(-0.1f);
        }

    }

}

 

 

 

- Materials 연결

 

 

 

🔶 스테이지 구성

- Stage 프리팹화

 

 

 

- Agent가 쏘는 Ray가 옆 스테이지에 닿지 않도록 충분한 거리를 두고 복사하기

 

 

 

🔷 트레이닝

- FoodCollector.yaml이 가장 적합해서 해당 파일을 복사

 

 

 

- behavior 이름과 동일하게 변경

- max_steps : 100만번으로 수정

 

 

 

- 트레이닝 시작

- MummyRay01파일로 한번이라도 트레이닝시켰으면 에러가 날 것

    - 처음부터 다시 시작 : $ mlagents-learn MummyRay.yaml --run-id=MummyRay01 --force

    - 멈춘 곳부터 이어서 시작 : $ mlagents-learn MummyRay.yaml --run-id=MummyRay01 --resume

 

 

 

- 유니티에서 play

 

 

 

🔶 트레이닝 summary

- good Item이 30개이기 때문에 30점이 만점

- item간의 간격이 좁기 때문에 실수로 충돌 -> 점수가 낮음

 

 

 

🔶 트레이닝 결과 확인해보기

- 모델파일(.onnx)을 프로젝트 창으로 가져오기

 

 

 

- Agent에 모델파일 연결

- Apply to Prefab

 

 

 

- 트레이닝 결과가 마음에 들지 않으면

    - max_steps를 늘리고

    - Behavior Parameter에 연결되어있는 모델을 해제시킨 후 

    - resume으로 다시 트레이닝