C# MLAgents代理isn'；我在训练方面没有进步

我最近一直在研究一对能够保持自我平衡的腿，这对腿应该可以防止角色摔倒。每个AgentReset，腿部重置其所有必要的因素，如pos、rot和vel，角色下方的地板随机更改旋转角度小于5度。尽管如此，不管我对经纪人的观察次数做了什么，他仍然没有真正从错误中吸取教训。现在，我是机器学习新手，所以对我放松点！我错过了什么？谢谢大家!

一些注释： 我不确定RayPerceptionSensorComponent3D是如何工作的。也许有人能帮我找到正确的方向

代理脚本：

using MLAgents;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MLAgents.Sensor;
using Random = UnityEngine.Random;

public class BalanceAgent : Agent
{
    private BalancingArea area;
    public GameObject floor;
    public GameObject waist;
    public GameObject buttR;
    public GameObject buttL;
    public GameObject thighR;
    public GameObject thighL;
    public GameObject legR;
    public GameObject legL;
    public GameObject footR;
    public GameObject footL;

    public GameObject[] bodyParts = new GameObject[9];
    public HingeJoint[] hingeParts = new HingeJoint[9];
    public JointLimits[] jntLimParts = new JointLimits[9];

    public Vector3[] posStart = new Vector3[9];
    public Vector3[] eulerStart = new Vector3[9];

    public RayPerceptionSensorComponent3D raySensors;

    float rayDist = 0;
    float rayAngle = 0;
    Vector3 rayFloorAngle = new Vector3(0,0,0);
    Vector3 rayPoint = new Vector3(0,0,0);

    int rotAgent = 0;

    public void Start() {
        bodyParts = new GameObject[] { waist, buttR, buttL, thighR, thighL, legR, legL, footR, footL };             //Waist = 0, footL = 8.

        for (int i = 0; i < bodyParts.Length; i++) {
            posStart[i] = bodyParts[i].transform.position;
            eulerStart[i] = bodyParts[i].transform.eulerAngles;
            if (bodyParts[i].GetComponent<HingeJoint>() != null) {
                hingeParts[i] = bodyParts[i].GetComponent<HingeJoint>();
                jntLimParts[i] = hingeParts[i].limits;
            }
        }
    }

    public override void InitializeAgent() {
        base.InitializeAgent();
        area = GetComponentInParent<BalancingArea>();
    }

    public override void AgentReset() {
        floor.transform.eulerAngles = new Vector3(Random.Range(-5, 5), 0, Random.Range(-5, 5));
        print("Reset! - " + rotAgent);
        for (int i = 0; i < bodyParts.Length; i++) {
            bodyParts[i].transform.position = posStart[i];
            bodyParts[i].transform.eulerAngles = eulerStart[i];
            if (bodyParts[i].GetComponent<HingeJoint>() != null) {
                jntLimParts[i].max = 1;
                jntLimParts[i].min = -1;
            }
            bodyParts[i].GetComponent<Rigidbody>().velocity = Vector3.zero;
            bodyParts[i].GetComponent<Rigidbody>().angularVelocity = Vector3.zero;
        }
    }

    public override void AgentAction(float[] vectorAction) {

        float buttRDir = 0;
        int buttRVec = (int)vectorAction[0];
        switch (buttRVec) {
            case 1:
                buttRDir = 0;
                break;
            case 2:
                buttRDir = .2f;
                break;
            case 3:
                buttRDir = -.2f;
                break;
        }
        jntLimParts[1].max += buttRDir;
        jntLimParts[1].min = jntLimParts[1].max - 1;
        hingeParts[1].limits = jntLimParts[1];

        float buttLDir = 0;
        int buttLVec = (int)vectorAction[1];
        switch (buttLVec) {
            case 1:
                buttLDir = 0;
                break;
            case 2:
                buttLDir = .2f;
                break;
            case 3:
                buttLDir = -.2f;
                break;
        }
        jntLimParts[2].max += buttLDir;
        jntLimParts[2].min = jntLimParts[2].max - 1;
        hingeParts[2].limits = jntLimParts[2];

        float thighRDir = 0;
        int thighRVec = (int)vectorAction[2];
        switch (thighRVec) {
            case 1:
                thighRDir = 0;
                break;
            case 2:
                thighRDir = .2f;
                break;
            case 3:
                thighRDir = -.2f;
                break;
        }
        jntLimParts[3].max += thighRDir;
        jntLimParts[3].min = jntLimParts[3].max - 1;
        hingeParts[3].limits = jntLimParts[3];

        float thighLDir = 0;
        int thighLVec = (int)vectorAction[3];
        switch (thighLVec) {
            case 1:
                thighLDir = 0;
                break;
            case 2:
                thighLDir = .2f;
                break;
            case 3:
                thighLDir = -.2f;
                break;
        }
        jntLimParts[4].max += thighLDir;
        jntLimParts[4].min = jntLimParts[4].max - 1;
        hingeParts[4].limits = jntLimParts[4];

        float legRDir = 0;
        int legRVec = (int)vectorAction[4];
        switch (legRVec) {
            case 1:
                legRDir = 0;
                break;
            case 2:
                legRDir = .2f;
                break;
            case 3:
                legRDir = -.2f;
                break;
        }
        jntLimParts[5].max += legRDir;
        jntLimParts[5].min = jntLimParts[5].max - 1;
        hingeParts[5].limits = jntLimParts[5];

        float legLDir = 0;
        int legLVec = (int)vectorAction[5];
        switch (legLVec) {
            case 1:
                legLDir = 0;
                break;
            case 2:
                legLDir = .2f;
                break;
            case 3:
                legLDir = -.2f;
                break;
        }
        jntLimParts[6].max += legLDir;
        jntLimParts[6].min = jntLimParts[6].max - 1;
        hingeParts[6].limits = jntLimParts[6];

        float footRDir = 0;
        int footRVec = (int)vectorAction[6];
        switch (footRVec) {
            case 1:
                footRDir = 0;
                break;
            case 2:
                footRDir = .2f;
                break;
            case 3:
                footRDir = -.2f;
                break;
        }
        jntLimParts[7].max += footRDir;
        jntLimParts[7].min = jntLimParts[7].max - 1;
        hingeParts[7].limits = jntLimParts[7];

        float footLDir = 0;
        int footLVec = (int)vectorAction[7];
        switch (footLVec) {
            case 1:
                footLDir = 0;
                break;
            case 2:
                footLDir = .2f;
                break;
            case 3:
                footLDir = -.2f;
                break;
        }
        jntLimParts[8].max += footLDir;
        jntLimParts[8].min = jntLimParts[8].max - 1;
        hingeParts[8].limits = jntLimParts[8];

        float waistDir = 0;
        int waistVec = (int)vectorAction[8];
        switch (footLVec) {
            case 1:
                waistDir = 0;
                break;
            case 2:
                waistDir = .2f;
                break;
            case 3:
                waistDir = -.2f;
                break;
        }
       // waist.transform.Rotate(0, waistDir, 0);

        //buttR = vectorAction[0]; //Right or none
        //if (buttR == 2) buttR = -1f; //Left

        if (waist.transform.position.y > -1.4f) {
            AddReward(.02f);
        }
        else {
            AddReward(-.03f);
        }

        if (waist.transform.position.y <= -3) {
            Done();
            print("He fell too far...");
        }

        RaycastHit hit;
        Ray r;
        if (Physics.Raycast(waist.transform.position, -waist.transform.up, out hit)) {
            rayDist = hit.distance;
            rayPoint = hit.point;
            rayAngle = Vector3.Angle(waist.transform.position, hit.normal);
            rayFloorAngle = hit.collider.transform.eulerAngles;
        }


    }

    public override void CollectObservations() {

        for(int i = 0; i < bodyParts.Length; i++) {
            AddVectorObs(bodyParts[i].transform.position);
            AddVectorObs(bodyParts[i].transform.eulerAngles);
            AddVectorObs(bodyParts[i].GetComponent<Rigidbody>().velocity);
            AddVectorObs(bodyParts[i].GetComponent<Rigidbody>().angularVelocity);
            AddVectorObs(jntLimParts[i].max);
            AddVectorObs(jntLimParts[i].min);
            AddVectorObs(raySensors);
            AddVectorObs(rayDist);
            AddVectorObs(rayPoint);
            AddVectorObs(rayAngle);
            AddVectorObs(rayFloorAngle);
        }
    }
}

using MLAgents;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class BalancingArea : Area
{
    public List<BalanceAgent> BalanceAgent { get; private set; }
    public BalanceAcademy BalanceAcademy { get; private set; }
    public GameObject area;

    private void Awake() {
        BalanceAgent = transform.GetComponentsInChildren<BalanceAgent>().ToList();              //Grabs all agents in area
        BalanceAcademy = FindObjectOfType<BalanceAcademy>();                //Grabs balance acedemy
    }

    private void Start() {

    }

    public void ResetAgentPosition(BalanceAgent agent) {
        //agent.transform.position = new Vector3(area.transform.position.x, 0, area.transform.position.z);
       // agent.transform.eulerAngles = new Vector3(0,0,0);
    }

    // Update is called once per frame
    void Update()
    {

    }
}

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

public class BalanceAcademy : Academy
{

}

---

我认为人们很难快速遵循您的代码。强化学习（rf）有几个主要问题：

• 你用什么样的模型来存储你的知识？流行的有q表，也有使用q学习的深层神经元网络
• 你的奖励功能是什么？你是否使用过任何形式的惩罚

帮助我的是检查当某件事情成功时会进行哪些更新，以及何时会应用负面奖励。在此上下文中，还要检查此更新对您的模型意味着什么。它是否也会奖励成功之前的步骤

重要的是，模型能够逐步达到目标。例如，对于这个例子来说，一个好的奖励是时间的流逝和完美平衡的指标的结合

我希望它能帮助你朝着正确的方向发展

---

顺便说一句，强化学习与构建在其上的构建块相比非常具有挑战性，就像监督学习方法一样。这也有助于检查它们。我真的可以推荐fastai课程，这些课程都是免费的，而且是我所见过的最重要的机器学习领域的最佳课程。

我建议您查看github repo中的ML代理。您可能希望使用与爬虫相同的观察结果： 每个肢体的位置、旋转、速度和角速度加上身体的加速度和角加速度

我还建议从Crawler复制trainer_config.yaml设置，这样您就有了超参数的最佳起点

---

作为旁注，RayPerceptionSensorComponent3D在某种程度上是独立工作的，您不需要使用AddVectorObs（）将其添加到观测中，因为它会在幕后自动执行此操作。您也不再需要为光线感知向空间大小添加任何值。也就是说，对于这个问题，您可能根本不想使用光线感知 为什么不尝试使用transform.positions设置奖励，并在腰部接触地面时结束这一集（如检查腰部和地面之间的碰撞）（或者）检查腰部和其他部位是否处于相同的transform.position并相应地设置奖励

---

你也可以把你的unity项目文件链接起来。我想看看你在那里做了什么。

将此作为一种可能性，但你是否忘记在

命令中添加
--train
？这让我有过几次这样的经历。
对于207的观测空间，我强烈建议让您的代理训练超过10公里的距离。500万或更多可能是合理的。真的，试着长时间的训练，比如一夜之间，看看是否有什么不同的事情发生。同时拥有ML机器人训练的多个副本也有助于加快训练速度。尝试制作环境的多个副本。（我建议将机器人和飞机放在一个空的游戏对象中，然后复制8-16次）你不需要做任何特殊的事情，只要复制并正常运行，其他副本也会训练。
对于第一个问题，很遗憾，我不懂。再说一次，我对这一切都很陌生！我所能说的就是我在用蟒蛇来训练我的ML特工。它只是保存到一个“.nn”文件。尽管对于第二个问题，在靠近底部的代理脚本中，我检查了腰围是否处于某个高度。如果是，+奖励，否则-奖励。谢谢。我一直在尝试设置它，以便让代理知道他什么时候在使用可能的光线投射，但我找不到关于它们的太多信息。我认为光线感知是一种方式，但显然不是。我如何设置光线投射，让我的经纪人看到他是如何与地面成角度的。。？谢谢。RayPerception目前正在实施，它不是为您试图使用它的目的而构建的。您必须修改相当多的ML代理代码，以便在代理的子对象上支持多个RayPerceptionSensorComponents。值得注意的是，光线感知有点像一种廉价的视觉形式。即使人类不能很好地平衡仅有的（超高级）视力，我们也需要一个功能正常的前庭系统。类似地，机器人需要陀螺仪和加速度计。我想你已经选择了最难的方法，哈哈！