Unity MlAgent 使用介绍

最新推荐文章于 2024-08-25 07:29:13 发布
最新推荐文章于 2024-08-25 07:29:13 发布
阅读量3.3k 收藏 8
点赞数
分类专栏： Unity 游戏 经验分享 文章标签： unity 深度学习 tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MoonWinding/article/details/121935861
版权
游戏 同时被 3 个专栏收录
27 篇文章 6 订阅
订阅专栏
Unity
21 篇文章 1 订阅
订阅专栏
经验分享
17 篇文章 0 订阅
订阅专栏

分享github 工程：https://github.com/IsaWinding/mlagent02.git

1.本文介绍要一个战斗中，英雄Ai行为操作用MlAgent来训练操作

在这里插入图片描述
图中为英雄训练的次数，生成的不同.onnx 文件。

在这里插入图片描述
训练次数较少的时候，训练的英雄会随机在周围的墙边移动
随着训练次数变多，训练的英雄会直接奔向敌方小兵的位置，进行攻击操作。
英雄行为脚本：

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

public class UnitAgent : Agent
{
    private Unit player;
    public override void Initialize()
    {
        player = this.GetComponent<Unit>();
        MaxStep = 20000;
    }
    public override void CollectObservations(VectorSensor sensor)
    {
        if (player == null)
            player = this.GetComponent<Unit>();
        if (player == null)
            return;
        sensor.AddObservation(player.transform.localPosition);
        sensor.AddObservation(player.curHp);
        sensor.AddObservation(player.Target);
        if (player.Target != null && !player.Target.IsDead())
        {
            sensor.AddObservation(player.Target.transform.localPosition);
            sensor.AddObservation(player.Target.curHp);
        }
        else
        {
            sensor.AddObservation(Vector3.zero);
            sensor.AddObservation(0);
        }
    }
    public override void OnActionReceived(ActionBuffers actions)
    {
        var controlSignal = Vector3.zero;
        var vectorAction = actions.ContinuousActions;
        controlSignal.x = vectorAction[0];
        controlSignal.z = vectorAction[1];
        
        player.MoveByDir(controlSignal);
        if (vectorAction[2] > 0f){
            player.AtkAjust(()=> {
                AddReward(0.1f);
            },()=> {
                AddReward(1f);
            });
        }
        //死亡重启
        if (player.curHp <= 0)
        {
            //AddReward(-3f);
            EndEpisode();
        }
        //越界重启
        if (Mathf.Abs(player.transform.localPosition.y) >= 2 || Mathf.Abs(player.transform.localPosition.x) >= 20 ||
            Mathf.Abs(player.transform.localPosition.x) >= 20)
        {
            //AddReward(-1f);
            EndEpisode();
        }
    }
    public override void OnEpisodeBegin()
    {
        if (player == null)
            player = this.GetComponent<Unit>();
        if (player == null)
            return;
        player.ResetBattleField();
    }
    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var continuousActionsOut = actionsOut.ContinuousActions;
        continuousActionsOut[0] = Input.GetAxis("Horizontal");
        continuousActionsOut[1] = Input.GetAxis("Vertical");
        continuousActionsOut[2] = Input.GetAxis("Jump");
    }
}

单位逻辑脚本：

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

public class Unit:MonoBehaviour
{
    [HideInInspector]
    public int id;
    public UnitInfo info;
    public AIPolicy aiPolicy;

    private AIPath path;
    public Unit Target;
    private UnitAni unitAni;
    public float followDistance { get { return info.flowRange; } }
    public float warnDistance { get { return info.warRange; } }
    public float atkDistance { get { return info.atkRange; } }
    public float moveSpeed { get { return info.moveSpeed; } }
    public float curHp { get { return info.hp; }set { info.hp = value; } } 
    public float MaxHp { get { return info.hpMax; } }
    private float atkCd { get { return info.atkCd; } }
    private float atk { get { return info.atk; } }
    public CampType campType { get { return info.campType; } }
    private float nextAtkTime = 0f;
    private bool IsNeedBackToHome = false;
    private bool isAttack = false;
    private bool isAttackTarget = false;
    private bool isMoveToTargetPos = false;
    private Vector3 findTargetPos;
    private Vector3 targetPos;
    private bool isCanReborn = true;
    private Vector3 bornPos;
    public List<Unit> AllUnits;
    public UnitManager manager;
    public void ResetBattleField()
    {
        manager.OnEpisodeBegin();
    }
    public void CreatUnit(int pId,UnitInfo pInfo,Vector3 pBornPos, AIPolicy pAIPolicy, AIPath pPath)
    {
        id = pId;
        info = pInfo;
        bornPos = pBornPos;
        aiPolicy = pAIPolicy;
        path = pPath.InitByGOList();
        path.Init();
        unitAni = this.gameObject.GetComponent<UnitAni>();
    }
    public void SetColor(Color pColor)
    {
        var mat = GetComponentInChildren<Material>();
        mat.SetColor("",pColor);
    }
    public void OnEpisodeBegin()
    {
        Idle();
        isAttackTarget = false;
        CancelInvoke("Reborn");
        Reborn();
    }
    public void OnAiAction(List<Unit> allUnits)
    {
        AllUnits = allUnits;
        if (IsDead())
            return;
        if(aiPolicy != null)
            aiPolicy.OnRun(allUnits);
    }

    public void Idle(){
        SetCurTarget(null);
        StopAttack();
        StopMove();
        unitAni.PlayAniByType(AniNameType.Idle, 1);
    }
    public void StopMove(){isMoveToTargetPos = false;}
    public void Attack(){isAttack = true;}
    public void StopAttack(){isAttack = false;}
    public void SetCurTarget(Unit pCharacterInput){
        Target = pCharacterInput;
        findTargetPos = this.transform.position;
    }
    public bool NeedBackToHome(){
        if (IsNeedBackToHome)
            return true;
        if (Target == null)
            return false;
        if (Target.IsDead())
            return true;
        var distance = Vector3.Distance(this.transform.position, findTargetPos);
        return distance >= followDistance;
    }
    public void SelectAdjustTarget(List<Unit> pAllUnits){
        var unit = GetOneUnitInRange(pAllUnits,warnDistance);
        SetCurTarget(unit);
    }
    public bool IsDead(){return info.hp <= 0;}
    public bool IsHaveTarget(){return Target != null;}
    public void BackToHome(){
        var distance = Vector3.Distance(this.transform.position, findTargetPos);
        if (distance >= 1){
            IsNeedBackToHome = true;
            SetCurTarget(null);
            MoveToTargetPos(findTargetPos);
        }
        else{
            IsNeedBackToHome = false;
        }
    }
    public void OnLoopMove(){
        if (path.IsReachNextPoint(this.transform.position))
        {
            path.OnReachNextPoint();
        }
        var nextPos = path.GetNextPoint();
        if (nextPos != null)
            MoveToTargetPos(nextPos.pos);
        else
            Idle();
    }
    public void MoToCurTarget(){
        StopAttack();
        MoveToTargetPos(Target.transform.position);
    }
    public void MoveByDir(Vector3 pDir)
    {
        var targetPos = this.transform.position + pDir.normalized*2f;
        MoveToTargetPos(targetPos);
    }
    public void MoveToTargetPos(Vector3 pTargetPos){
        StopAttack();
        targetPos = pTargetPos;
        isMoveToTargetPos = true;
    }
    public void FaceToCurTarget(){
        if(Target != null)
            this.transform.LookAt(Target.transform.position);
    }
    private bool IsInRange(Unit pTarget, float pRange)
    {
        var targetPos = pTarget.transform.position;
        var selfPos = this.transform.position;
        if (Vector3.Distance(targetPos, selfPos) <= pRange){
            return true;
        }
        return false;
    }
    public bool CurTargetInRange(float pRange){
        if (Target != null && !Target.IsDead())
        {
            return IsInRange(Target, pRange);
        }
        return false;
    }
    public bool IsCanCampSelect(CampType pTargetCampType)
    {
        if (campType == CampType.PlayerA)
        {
            return pTargetCampType == CampType.PlayerB || pTargetCampType == CampType.Monster;
        }
        else if (campType == CampType.PlayerB)
        {
            return pTargetCampType == CampType.PlayerA || pTargetCampType == CampType.Monster;
        }
        else if (campType == CampType.Monster)
        {
            return pTargetCampType == CampType.PlayerA || pTargetCampType == CampType.PlayerB;
        }
        return false;
    }
    public Unit GetOneUnitInRange(List<Unit> pAllUnits,float pRange)
    {
        for (var i = 0; i < pAllUnits.Count; i++){
            var unit_ = pAllUnits[i];
            if (!unit_.IsDead() && IsCanCampSelect(unit_.campType) &&IsInRange(pAllUnits[i], pRange))
                return pAllUnits[i];
        }
        return null;
    }
    public bool NeedSelectTarget(List<Unit> pAllUnits)//是否需要重新选择追踪目标
    {
        if (Target != null && !Target.IsDead() && IsInRange(Target, followDistance))
            return false;
        var character = GetOneUnitInRange(pAllUnits,warnDistance);
        return character != null;
    }
    private void OnDead()
    {
        isAttack = false;
        isAttackTarget = false;
        isMoveToTargetPos = false;
        Target = null;
        unitAni.PlayAniByType(AniNameType.Dead, 6);
        if (isCanReborn)
        {
            Invoke("Reborn", 2f);
            isCanReborn = false;
        }
    }
    public void HpChange(float pOld, float hp)
    {
        //characterHp.SetHpInfo(hp, MaxHp);
        if (hp <= 0){
            OnDead();
        }
    }

    private void Reborn()
    {
        isAttack = false;
        isAttackTarget = false;
        isMoveToTargetPos = false;
        Target = null;
        curHp = MaxHp;
        //SetHpInfo();
        RpcReborn();
    }
    private void RpcReborn()
    {
        this.transform.position = bornPos;
        isCanReborn = true;
    }
    private float oldHp;
    public void OnDamage(float pDamage, System.Action pAtkCB, System.Action pKillCB)
    {
        oldHp = curHp;
        curHp -= pDamage;
        if (curHp > MaxHp)
            curHp = MaxHp;
        if (curHp < 0)
            curHp = 0;
      
        HpChange(oldHp, curHp);
        //SetHpInfo();
        if (curHp <= 0){
            pKillCB?.Invoke();
        }
        pAtkCB?.Invoke();
    }
    public void AtkAjust(System.Action pAtkCB,System.Action pKillCB)
    {
        if (Target != null && !Target.IsDead()&& IsInRange(Target, followDistance))
        {
            if (IsInRange(Target, atkDistance))
                AtkCurTarget(pAtkCB, pKillCB);
            else { 
                MoveToCurTarget();
            }
        }
        else
        {
            SelectAdjustTarget(AllUnits);
            MoveToCurTarget();
        }
    }
    public void MoveToCurTarget()
    {
        if(Target!= null)
            MoveToTargetPos(Target.transform.position);
    }
    public void AtkCurTarget(System.Action pAtkCB, System.Action pKillCB)
    {
        StopMove();
        this.transform.LookAt(Target.transform);
        var curTime = Time.realtimeSinceStartup;
        if (curTime >= nextAtkTime)
        {
            isAttackTarget = true;
            nextAtkTime = curTime + atkCd;
            unitAni.PlayAniByType(AniNameType.Attack, 4, () => {
                DoNormalAttack(pAtkCB, pKillCB);
                isAttackTarget = false;
            });
        }
    }
    public void DoNormalAttack(System.Action pAtkCB, System.Action pKillCB)
    {
        if (Target != null)
            Target.OnDamage(atk, pAtkCB, pKillCB);
    }
    private Vector3 GetMoveDir(Vector3 pTargetPos){
        var dir = pTargetPos - this.transform.position;
        return dir.normalized * moveSpeed;
    }

    private void FixedUpdate()
    {
        if (IsDead())
            return;
        //curTime += Time.deltaTime;
        if (isAttack)
        {
            var curTime = Time.realtimeSinceStartup;
            if (curTime >= nextAtkTime)
            {
                nextAtkTime = curTime + atkCd;
                unitAni.PlayAniByType(AniNameType.Attack, 4, () =>
                {
                    isAttack = false;
                    DoNormalAttack(null, null);
                });
            }
        }
        if (isMoveToTargetPos && !isAttackTarget)
        {
            if (Vector3.Distance(targetPos, this.transform.position) <= 1)
            {
                isMoveToTargetPos = false;
            }
            else
            {
                this.transform.localPosition += GetMoveDir(targetPos) * Time.deltaTime;
                this.transform.LookAt(targetPos);
                unitAni.PlayAniByType(AniNameType.Move, 3);
            }
        }

        if (!isAttack && !isMoveToTargetPos&&!isAttackTarget)
        {
            unitAni.PlayAniByType(AniNameType.Idle, 1);
        }
    }
}

寻路路径

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

public enum PathType
{
	Once = 1,
	Loop = 2,
	PingPong = 3,

}
[System.Serializable]
public class PathPoint
{
	public Vector3 pos;
	public PathPoint NextPoint;
	public PathPoint PrePoint;
	public PathPoint(Vector3 pPos)
	{
		pos = pPos;
	}
}

[System.Serializable]
public class AIPath
{
	[HideInInspector]
	public List<PathPoint> Paths = new List<PathPoint>();
	public List<GameObject> PathGos = new List<GameObject>();
	public PathType pathType = PathType.Loop;
	private PathPoint nextPoint;
	public void SetAdjustTwoPointPath(Vector3 pMiddlePos, float pDistance)
	{
		Paths.Clear();
		var posR = pMiddlePos + Vector3.right * pDistance;
		var pathPointR = new PathPoint(posR);
		Paths.Add(pathPointR);
		var posL = pMiddlePos + Vector3.right * -pDistance;
		var pathPointL = new PathPoint(posL);
		Paths.Add(pathPointL);
	}
	public AIPath InitByGOList()
	{
		var aiPath = new AIPath();
		aiPath.Paths.Clear();
		foreach (var temp in (PathGos))
		{
			var pathPointR = new PathPoint(temp.transform.position);
			aiPath.Paths.Add(pathPointR);
		}
		return aiPath;
	}

	public void Init()
	{
		for (var i = 0; i < Paths.Count; i++)
		{
			var path = Paths[i];
			if (i == 0)
			{
				path.NextPoint = Paths[i + 1];
				if (pathType == PathType.Loop)
					path.PrePoint = Paths[Paths.Count - 1];
			}
			else if (i == Paths.Count - 1)
			{
				if (pathType == PathType.Loop)
					path.NextPoint = Paths[0];
				path.PrePoint = Paths[i - 1];
			}
			else
			{
				path.NextPoint = Paths[i + 1];
				path.PrePoint = Paths[i - 1];
			}
		}
		nextPoint = Paths[0];
	}
	public PathPoint GetNextPoint()
	{
		return nextPoint;
	}
	public bool IsReachNextPoint(Vector3 pos)
	{
		if (Mathf.Abs(nextPoint.pos.x - pos.x) <= 1)
			return true;
		return false;
	}
	private bool isForward = true;
	public void OnReachNextPoint()
	{
		if (pathType == PathType.Once)
		{
			nextPoint = nextPoint.NextPoint;
		}
		else if (pathType == PathType.Loop)
		{
			nextPoint = nextPoint.NextPoint;
		}
		else if (pathType == PathType.PingPong)
		{
			if (isForward)
			{
				if (nextPoint.NextPoint != null)
					nextPoint = nextPoint.NextPoint;

				else
				{
					nextPoint = nextPoint.PrePoint;
					isForward = false;
				}
			}
			else
			{
				if (nextPoint.PrePoint != null)
					nextPoint = nextPoint.PrePoint;
				else
				{
					nextPoint = nextPoint.NextPoint;
					isForward = true;
				}
			}
		}
	}
}

ai策略代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public enum AIPolicyType
{ 
    None = 0,
    Soldier = 1,
    Tower = 2,
    Hero = 3
}

public class TowerPolicy : AIPolicy{
    protected override List<AIAction> allActions {
        get {
            if (allActions_ == null)
            {
                allActions_ = new List<AIAction>() {
                    new AttackToTargetAction(),
                    new SelectTargetAction(),
                    new IdleAction()};
            }
            return allActions_;
        }
    }
    public TowerPolicy(Unit pMonsterAi)
    {
        bindAi = pMonsterAi;
    }
}
public class SoldierPolicy : AIPolicy{
    protected override List<AIAction> allActions {
        get {
            if (allActions_ == null)
            {
                allActions_ = new List<AIAction>() {
                    new AttackToTargetAction(),
                    new MoveToTargetAction(),
                    new SelectTargetAction(),
                    new MoveAction(),
                    new IdleAction()};
            }
            return allActions_;
        }
    }
    public SoldierPolicy(Unit pMonsterAi) {
        bindAi = pMonsterAi;
    }
}
public class AIPolicy
{
    protected List<AIAction> allActions_;
    protected virtual List<AIAction> allActions { get { return allActions_;} } 
    private AIAction curAiAction;
    protected Unit bindAi;
    
    public AIPolicy() { }
    public AIPolicy(Unit pMonsterAi) {
        bindAi = pMonsterAi;
    }
    public void OnRun(List<Unit> pAllUnits)
    {
        for (var i = 0; i < allActions.Count; i++)
        {
            if (allActions[i].IsPass(bindAi, pAllUnits))
            {
                curAiAction = allActions[i];
                break;
            }
        }
        curAiAction.OnAcion(bindAi, pAllUnits);
    }
}
public class BackToHomeAction : AIAction{
    public override AIConditioner Conditioner { get { if (conditioner == null) conditioner = new BackToHomeConditioner(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits){
        pBindAi.BackToHome();
    }
}
public class AttackToTargetAction : AIAction
{
    public override AIConditioner Conditioner { get { if (conditioner == null) conditioner = new AttackToTargetConditioner(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits)
    {
        pBindAi.StopMove();
        pBindAi.FaceToCurTarget();
        pBindAi.Attack();
    }
}
public class MoveToTargetAction : AIAction
{
    public override AIConditioner Conditioner { get { if (conditioner == null) conditioner = new MoveToTargetConditioner(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits)
    {
        pBindAi.MoToCurTarget();
    }
}
public class SelectTargetAction : AIAction
{
    public override AIConditioner Conditioner { get { if (conditioner == null) conditioner = new ForcusTargetConditioner(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits)
    {
        pBindAi.SelectAdjustTarget(pAllUnits);
    }
}
public class MoveAction : AIAction {
    public override AIConditioner Conditioner { get { if (conditioner == null) conditioner = new MoveConditioer(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits)
    {
        pBindAi.OnLoopMove();
    }
}
public class IdleAction : AIAction {
    public override AIConditioner Conditioner { get {if (conditioner == null) conditioner = new IdleConditoner(); return conditioner; } }
    public override void OnAcion(Unit pBindAi, List<Unit> pAllUnits)
    {
        pBindAi.Idle();
    }
}
public class AIAction
{
    protected AIConditioner conditioner;

    public virtual AIConditioner Conditioner { get { if (conditioner == null) conditioner = new AIConditioner(); return conditioner; } }
    public virtual void OnAcion(Unit pBindAi, List<Unit> pAllUnits) { }
    public bool IsPass(Unit pBindAi, List<Unit> pAllUnits) {
        return Conditioner.IsPass(pBindAi, pAllUnits);
    }
}

public class BackToHomeConditioner : AIConditioner//目标超出追踪范围，返回原地
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return pBindAi.NeedBackToHome();
    }
}
public class AttackToTargetConditioner : AIConditioner//攻击目标
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return pBindAi.CurTargetInRange(pBindAi.atkDistance);
    }
}
public class MoveToTargetConditioner : AIConditioner//追踪目标
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return pBindAi.CurTargetInRange(pBindAi.followDistance);
    }
}
public class ForcusTargetConditioner : AIConditioner//锁定目标
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return pBindAi.NeedSelectTarget(pAllUnits);
    }
}
public class MoveConditioer : AIConditioner //巡逻d 
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return !pBindAi.IsHaveTarget();
    }
}
public class IdleConditoner: AIConditioner//待机
{
    public override bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return !pBindAi.IsDead();
    }
}
public class AIConditioner
{
    public virtual bool IsPass(Unit pBindAi, List<Unit> pAllUnits)
    {
        return true;
    }
}

大部分核心代码分享了，感兴趣的同学，可以直接下载github 的资源测试了解。
再次分享github 工程：https://github.com/IsaWinding/mlagent02.git

MoonWinding
关注
专栏目录
Unity的ml-agent学习
ChangeW fafa的博客
12-04 646
学习资源 精讲blog 0. 导学知识 ML主要包括监督学习、非监督学习和增强学习三种范式 强化学习reinforcement learningpdf电子书 Unity的ml-agent，还必须知道Unity到底怎么玩。玩Unity需要使用C#语言，玩深度学习需要使用Python语言。 ...
游戏AI进化论：Unity ML-Agents如何让角色智商爆表？
java专栏
04-30 473
编写奖励逻辑在环境脚本中，定义当球达到目标位置时给予正奖励，否则随着时间推移给予负奖励，以此激励Agent学习有效策略。Csharp2{5// 时间惩罚系数79 {11 if (distanceToGoal < 1f) // 判断球是否到达目标12 {// 达到目标给予正奖励// 结束这一回合15 }16 else17 {// 时间流逝给予负奖励19 }20 }21}AddReward函数用于添加奖励，EndEpisode结束当前训练回合。
ML-Agent（Unity机器学习插件）
06-12
https://github.com/Unity-Technologies/ml-agents，Github上可以直接下载，介于国内Github网速太慢，上传一个下载好的。
Unity 对接 ML-Agents 初探
艾沃尼斯の飞空庭
02-24 1413
ML-Agents
Unity ML-Agents 项目教程
最新发布
gitblog_01006的博客
08-25 1055
Unity ML-Agents 项目教程 Unity_ML_AgentsThis is the code for "Unity AI" by Siraj Raval on Youtube 项目地址:https://gitcode.com/gh_mirrors/un/Unity_ML_Agents 1. 项目的目录结构及介绍 Unity ML-Agents 项目的目录结构如下： Unity_ML_...
Unity之ml-agents（一）：环境配置及初步使用
gls_nuaa的博客
02-15 5391
  ml-agents是Unity官方专门用来提供强化学习的工具包，关于ml-agents的介绍不是本文的重点。相比于其他的工具包只需要在package manager中导入，ml-agents需要进行一下简单的配置。这篇文章就对于配置过程及过程中可能遇到的一些问题给予解答。   Unity开源网址：https://github.com/Unity-Technologies/ml-agents   ml-agents的配置有CPU版和GPU版，因为目前GPU并没有提供太多的增益。本篇文章就介绍CPU的配置了
Unity的ML-agent训练教程（附环境配置流程）
hnbxs的博客
02-13 3722
1）创建虚拟环境接下来提过指令激活虚拟环境Unity2）在虚拟环境内配置需要用的库在GitHub上下载unity官方的ml-agent包仓库，下载到位置在anaconda prompt通过依次输入指令导入库文件一般会因为网速问题导致报错超时，可将指令改为如下形式或等待提示导入完成后输入指令若出现提示文本，则环境配置成功。
Unity ML-Agent 训练工业机械臂到达目标点 数字孪生
05-22
使用unity版本为2021.3.0f1 训练时间大概为几十分钟 可以实现在虚拟环境中训练机械臂抓取目标物体 可以修改目标物体出现的范围
Unity-mlagent-crawlers:腿数不同的机器人
04-02
《Unity-mlAgent-Crawlers：探索不同腿数机器人的智能控制》 Unity，作为一款强大的游戏开发引擎，不仅在游戏领域广泛应用，还在人工智能（AI）和机器学习（ML）研究中发挥着重要作用。其中，Unity的ml-agent扩展库...
unity插件ml-agent的安装和使用
枫闲言的博客
11-12 1917
感觉机器学习将占领游戏AI的趋势和可能性。 Unity Machine Learning Agents (ML-Agents) 是一款开源的 Unity 插件， 使得我们得以在游戏环境和模拟环境中训练智能 agents。 它可以使用 reinforcement learning（强化学习）、imitation learning（模仿学习）、neuroevolution（神经进化）或其他机器学习方...
Unity强化学习之ML-Agents的使用
热门推荐
小星AI
11-03 2万+
ML-Agents是游戏引擎Unity3D中的一个插件，也就是说，这个软件的主业是用来开发游戏的，实际上，它也是市面上用得最多的游戏引擎之一。而在几年前随着人工智能的兴起，越来越多的强化学习环境被开发出来，例如总所周知的OpenAI的Gym，还有许多实验室都采用的星际争霸2环境来进行多智能体强化学习的研究。作为一个对游戏开发和强化学习都非常感兴趣的人，了解到了ML-Agents这款插件，使得能够自己创造一个独一无二，，与众不同，又充，与众不同，又充满智慧的游戏AI成为可能。
ml-agents：Unity机器学习代理工具包
02-04
Unity ML-Agents工具包 （）（） Unity Machine Learning Agents工具包（ML-Agents）是一个开放源代码项目，使游戏和模拟能够用作训练智能代理的环境。 我们提供最新算法的实现（基于PyTorch），使游戏开发人员和业余爱好者可以轻松地训练2D，3D和VR / AR游戏的智能代理。 研究人员还可以使用提供的易于使用的Python API通过强化学习，模仿学习，神经进化或任何其他方法来训练Agent。 这些训练有素的代理可以用于多种目的，包括控制NPC行为（在多种设置下，例如多代理和对抗），自动测试游戏版本并评估预发布的不同游戏设计决策。 ML-A
Unity ML-Agents 之 环境配置（Anaconda 下载安装等），简单的搭建场景实现简单训练的Demo（内含详细步骤）.rar
09-01
Unity ML-Agents 之 环境配置（Anaconda 下载安装等），简单的搭建场景实现简单训练的Demo（内含详细步骤） 一、简单介绍 二、工程地址 三、效果预览 四、实现原理 五、涉及命令 六、注意事项 七、环境搭建 Anacoda 的下载 Anaconda 安装 Unity ML-Agents 资源下载 八、Anacoda 中构建 Unity 训练环境 创建环境 在环境中安装 mlagents 九、Unity 中集成 ML-Agents 十、结合 ML-Agents 和 Unity 开始训练 十一、使用训练好的模型，进行演示 十二、关键脚本
ml-agents-0.8.1 最新版基于unity的机器学习代理
06-23
ml-agents-0.8.1 最新版基于unity的机器学习代理,如果git上下载不了的朋友可以下载这个
unity ML-Agent 使用干货教程 每日更新中
炼丹炉里有煤灰
05-23 4409
安装 在我的另一篇教程里有详细的安装教程 https://mp.csdn.net/mdeditor/90413429# ml-agent 概念 这个哥们写的概念介绍文章狠不错 https://blog.csdn.net/u010019717/article/details/80382933 使用 首先为目标物体添加agent（Agent组件用于收集 目标信息，或驱动目标） 创建一个脚本，继承age...
Unity ML-Agent实践——环境搭建
qq_41959920的博客
10-15 1881
提示：转载请注明出处，若本文无意侵犯到您的合法权益，请及时与作者联系。 Unity ML-Agents实践——环境搭建 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、什么是Unity ML-Agents？ Unity ML-Agents是Unity公司推出的一款用于在Unity上使用的进行机器学习的开源的Unity 插件工具包，其全称为Unity Machine Learning Agents。该工具包标志着Unity开始正式尝试进军机器学习领
Unity的机器学习工具包ML-Agents
Peter的博客
12-02 2827
Github下载链接：https://github.com/Unity-Technologies/ml-agentsML-Agents是游戏引擎Unity3D中的一个插件，也就是说，这个软件的主业是用来开发游戏的，实际上，它也是市面上用得最多的游戏引擎之一。而在几年前随着人工智能的兴起，强化学习算法的不断改进，使得越来越多的强化学习环境被开发出来，例如总所周知的OpenAI的Gym，同时还有许多实验室都采用的星际争霸2环境来进行多智能体强化学习的研究。
Unity3D ML-Agent-0.8.1 学习一（基础教程）
王伟王胖胖的博客
05-19 3412
Ml-Aagent是什么就不介绍啦，百度就好，至于为什么要写这个，主要是因为最近在做深度学习研究，学到了强化学习，而我本身又有游戏经验和背景，而Unity3D刚好也有机器学习插件，正好把这些结合起来，看看能不能在游戏里发挥下。 所以最近都就开始研究这个，其实还有个大的想法，就是能不能用人工智能去重新定义游戏的开发，运营等环节，目前知道AI可以上色，可以作曲，可以写故事，可以生成动漫头像等等，这个系列的主题就是用AI去定义游戏开发中的角色AI，不用传统的硬编码，而用强化学习去训练，使得可以有更好的泛化能力，
深度强化学习_使用Unity ml-agent进行深度强化学习
weixin_39542608的博客
12-17 347
本文为 AI 研习社编译的技术博客，原标题 ：Deep Reinforcement Learning using Unity ml-agents作者 | João Ramos翻译 | 通夜 编辑 | 王立鱼原文链接：https://towardsdatascience.com/deep-reinforcement-learning-using-unity-ml-agents-8af8d407dd5...
Unity mlagent中强化学习ppo算法的参数怎么设置？
06-09
在Unity mlagent中使用PPO算法进行强化学习时，有一些参数需要进行设置，这些参数包括： 1. Learning Rate：学习率，即每次更新模型时的步长，一般设置为0.0003。 2. Discount Factor：折扣因子，即未来奖励的衰减...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值