Siempre que un ser humano aprende un nuevo tema, ya se trate de un instrumento musical o un nuevo idioma, siempre hay un tema de “ensayo y error”. El intento de conseguir la correcta colocación de los dedos en el violín o la correcta pronunciación de una palabra extranjera a menudo implica equivocarse varias veces.

Esta es una manera bien conocida la gente aprende, y es el análogo dibujamos cuando se trata de aprendizaje automático. Una máquina de aprendizaje agente “aprende” de una manera muy similar a la forma en que los seres humanos aprendemos. Sin embargo, difiere drásticamente de aprendizaje humanos del aprendizaje automático, debido a que un ser humano puede ser muestra Cómo llevar a cabo una tarea, mientras que una máquina no puede.

¿O pueden? ¿Podemos demostrar una tarea a un equipo? Podríamos entrenar a un agente mediante la demostración de la tarea? La respuesta a esta pregunta interesante es

En este tutorial, vamos a “sobrealimentación” nuestra AI aprendiendo cómo entrenar a un agente de aprendizaje de máquina Unidad a través de la demostración. También vamos a estar buscando la manera de ajustar algunos parámetros especiales (llamados “hiperparámetros”) que harán que el proceso de formación mucho más rápido y más preciso. Y para mí, tener un agente aprender mediante la demostración es una manera mucho más intuitiva de interactuar con la máquina de aprendizaje. Esto no sólo ahorra en el tiempo de desarrollo para usted, pero ayudará a tomar agentes aún más complicado!

get Vamos a empezar y aprender a entrenar ML-agentes de la Unidad!
No se pierda! extremos de la oferta en

  • Accede a los más de 200 cursos
  • Nuevos cursos añadió mensual
  • Cancelar en cualquier momento
  • Los certificados de terminación

    ACCESO ahora

    Indice

    archivos de proyecto y visión general

    Los archivos de inicio que vamos a necesitar se puede descargar aquí: Los archivos de arranque. Este contiene una escena básica con unos cubitos, un límite, y una secuencia de comandos especiales que se utilizará como el “objetivo” de nuestro agente. El plan es tener un agente de desove al azar en una escena, localice la caja, y empujarla hacia la parte verde del medio ambiente.

    Lo que el

    Este proyecto surge a partir del ejemplo del paquete Unidad de LD-agentes que se pueden encontrar en la Unidad de Github (https://github.com/Unity-Technologies/ml-agents). Si usted tiene un vistazo a los archivos de arranque, hay un par de componentes de aquí que no son el foco de la guía de aprendizaje y por lo que no se explica plenamente. Principalmente cómo se codifican el agente y el guión de destino. Afortunadamente, no hay nada nuevo en los archivos de arranque así que si quieres saber cómo hacer que a partir de cero, disfrutar de los otros tutoriales ML-Agentes de la Dev Academia juego (una introducción a ML-Agentes de la unidad y cómo hacer objetivo AIS Objetos con Unity Agentes ml). Una vez que tenga los archivos de proyecto descargaron e importados, podemos empezar!

    Configuración del agente

    Observaciones Tomar

    Si usted tiene una mirada en el componente de parámetros de comportamiento en el agente, se dará cuenta de que el “tamaño del espacio de observación” se pone a cero.

    tamaño del espacio de observación es cero

    ¿Cómo entonces somos nosotros para tomar cualquier observación en absoluto? La respuesta es que usamos un especial, casi mágico componente llamado el componente “Ray Percepción del sensor 3D”.

    Búsqueda de la Percepción Ray componente sensor 3D

    añadir el componente Ray Percepción del sensor 3D para el agente

    Esto envía una serie de raycasts y los agrega automáticamente a la pila de observación. Lo que es más, los parámetros para el componente son muy intuitivos y los artilugios en el editor sólo se suman a la facilidad de uso. Por lo tanto, podemos utilizar este componente como la forma en que nuestro agente “ve” el mundo. Debido a esto, vamos a necesitar dos de ellos con la siguiente configuración:

    Dos Ray Componentes Percepción desplazados entre sí

    En esencia, lo que estamos haciendo es dar el agente de dos líneas de visión. Una de ellas es muy por encima del agente que se utilizará probablemente para asegurarse de que está en posición vertical y todavía en el medio ambiente, el otro es más baja y se utiliza para la detección de la caja y el objetivo. Uno de los puntos fuertes del componente sensor de rayos La percepción es que se observa básicamente todo sobre su objetivo detectable. Ya se trate de la velocidad, velocidad, color, incluso, el componente puede observar todo.

    Ahora, debido a esto, se puede tomar un tiempo para que la red neuronal para averiguar qué bits de información es útil. Así que lo que ganamos en la comodidad, también pierden en el entrenamiento de la velocidad. Esto no es mucho de un costo, sin embargo, ya que la codificación de cada raycast manualmente sería una tarea titánica. Debido a que estamos usando Raycasts, hay que asegurarse de que el agente en sí mismo no es detectado por el interruptor de la capa a “Ignorar Raycast.”

    Cambio de la capa de agente a

    Y tenemos que asegurarse de que el valor de “Número máximo de pasos” en el guión “PushAgent” no es cero.

    /

    Esto, básicamente, sólo establece la duración de un episodio. Si esto fuera cero, sería una longitud ilimitada. Y así, con nuestro agente ahora ver nuestro hermoso mundo y que posee el número apropiado de pasos máximos, vamos a saltar en las secuencias de comandos que vienen en el archivo de arranque para ver lo que está pasando bajo el capó.

    Una visión general del Agente de secuencias de comandos

    Como he mencionado anteriormente, no vamos a ir a través de cada línea de este guión pero tenemos necesidad de conocer los fundamentos de lo que está pasando.
    utilizando System.Collections; usando UnityEngine; usando Unity.MLAgents; PushAgent clase pública: Agente {///

    /// El suelo. Los límites se utilizan para generar los elementos. /// GameObject suelo público; área pública GameObject; [] HideInInspector areaBounds Bounds públicas; visualSettings VisualSettings privadas; GameObject objetivo público; bloque pública GameObject; [HideInInspector] pública GoalDetection goalDetect; useVectorObs bool públicas; Cuerpo rígido blockRigid; Cuerpo rígido agentRigid; groundMaterial material; Procesador groundRenderer; DefaultParameters EnvironmentParameters; void Awake () {visualSettings = FindObjectOfType (); } Public override void Initialize () {goalDetect = block.GetComponent (); goalDetect.agent = Este; agentRigid = getComponent (); blockRigid = block.GetComponent (); areaBounds = ground.GetComponent () límites.; groundRenderer = ground.GetComponent (); groundMaterial = groundRenderer.material; DefaultParameters = Academy.Instance.EnvironmentParameters; SetResetParameters (); } Public Vector3 GetRandomSpawnPos () {var foundNewSpawnLocation = false; var randomSpawnPos = Vector3.zero; while (foundNewSpawnLocation == false) {var randomPosX = Random.Range (-areaBounds.extents.x * visualSettings.spawnAreaMarginMultiplier, areaBounds.extents.x * visualSettings.spawnAreaMarginMultiplier); var randomPosZ = Random.Range (-areaBounds.extents.z * visualSettings.spawnAreaMarginMultiplier, areaBounds.extents.z * visualSettings.spawnAreaMarginMultiplier); randomSpawnPos = ground.transform.position + nuevo Vector3 (randomPosX, 1f, randomPosZ); si (Physics.CheckBox (randomSpawnPos, nuevo Vector3 (2.5f, 0.01f, 2.5f)) == false) {foundNewSpawnLocation = true; }} RandomSpawnPos regresar; } Public void ScoredAGoal () {AddReward (5f); EndEpisode (); StartCoroutine (GoalScoredSwapGroundMaterial (visualSettings.goalScoredMaterial, 0.5f)); } IEnumerator GoalScoredSwapGroundMaterial (mat material, tiempo float) {groundRenderer.material = estera; retorno rendimiento nuevos WaitForSeconds (tiempo); // Esperar 2 sec groundRenderer.material = groundMaterial; } Public void MoveAgent (float [] acto) {var = dirToGo Vector3.zero; var rotateDir = Vector3.zero; acción var = Mathf.FloorToInt (acto [0]); interruptor (acción) {case 1: dirToGo = transform.forward * 1f; descanso; caso 2: dirToGo = transform.forward * -1 septies; descanso; caso 3: rotateDir = transform.up * 1f; descanso; caso 4: rotateDir = transform.up * -1 septies; descanso; caso 5: dirToGo = transform.right * -0.75f; descanso; caso 6: dirToGo = transform.right * 0.75f; descanso; } Transform.rotate (rotateDir, Time.fixedDeltaTime * 200f); agentRigid.AddForce (dirToGo * visualSettings.agentRunSpeed, ForceMode.VelocityChange); } Void public override OnActionReceived (float [] vectorAction) {MoveAgent (vectorAction); AddReward (-1 septies / MaxStep); } Override public void heurístico (float [] actionsOut) {actionsOut [0] = 0; si (Input.GetKey (KeyCode.D)) {actionsOut [0] = 3; } Else if (Input.GetKey (KeyCode.W)) {actionsOut [0] = 1; } Else if (Input.GetKey (KeyCode.A)) {actionsOut [0] = 4; } Else if (Input.GetKey (KeyCode.S)) {actionsOut [0] = 2; }} Void ResetBlock () {block.transform.position = GetRandomSpawnPos (); blockRigid.velocity = Vector3.zero; blockRigid.angularVelocity = Vector3.zero; } Public override OnEpisodeBegin void () {rotación var = Random.Range (0, 4); var RotationAngle = rotación * 90f; area.transform.Rotate (nuevo Vector3 (0F, RotationAngle, 0f)); ResetBlock (); transform.position = GetRandomSpawnPos (); agentRigid.velocity = Vector3.zero; agentRigid.angularVelocity = Vector3.zero; SetResetParameters (); } Public void SetGroundMaterialFriction () {var = groundCollider ground.GetComponent (); groundCollider.material.dynamicFriction = defaultParameters.GetWithDefault ( «dynamic_friction», 1); groundCollider.material.staticFriction = defaultParameters.GetWithDefault ( «static_friction», 0); SetBlockProperties} public void () {var = escala defaultParameters.GetWithDefault ( «block_scale», 2); blockRigid.transform.localScale = nuevo Vector3 (escala, 0.75f, escala); blockRigid.drag = defaultParameters.GetWithDefault ( «block_drag», 0.5f); SetResetParameters} void () {SetGroundMaterialFriction (); SetBlockProperties (); }} 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197usingSystem.Collections; usingUnityEngine; usingUnity.MLAgents; publicclassPushAgent: Agente {///

    /// el suelo. Los límites se utilizan para generar el elements./// suelo publicGameObject; área publicGameObject; [HideInInspector] publicBounds areaBounds; privateVisualSettings visualSettings; meta publicGameObject; bloque publicGameObject; [HideInInspector] publicGoalDetection goalDetect; publicbooluseVectorObs; cuerpo rígido blockRigid; cuerpo rígido agentRigid ; material de groundMaterial; Renderizador groundRenderer; EnvironmentParameters DefaultParameters; voidAwake () {visualSettings = FindObjectOfType ();} publicoverridevoidInitialize () {goalDetect = block.GetComponent (); goalDetect.agent = esta; agentRigid = getComponent (); blockRigid = block.GetComponent (); areaBounds = ground.GetComponent () límites;. groundRenderer = ground.GetComponent (); groundMaterial = groundRenderer.material; DefaultParameters = Academy.Instance .EnvironmentParameters; SetResetParameters ();} publicVector3 GetRandomSpawnPos () {varfoundNewSpawnLocation = false; varrandomSpawnPos = Vector3.zero; while (foundNewSpawnL ocation == false) {varrandomPosX = Random.Range (-areaBounds.extents.x * visualSettings.spawnAreaMarginMultiplier, areaBounds.extents.x * visualSettings.spawnAreaMarginMultiplier); varrandomPosZ = Random.Range (-areaBounds.extents.z * visualSettings.spawnAreaMarginMultiplier , areaBounds.extents.z * visualSettings.spawnAreaMarginMultiplier); randomSpawnPos = ground.transform.position + newVector3 (randomPosX, 1f, randomPosZ), si (Physics.CheckBox (randomSpawnPos, newVector3 (2.5f, 0.01f, 2.5f)) = = false) {foundNewSpawnLocation = true;}} returnrandomSpawnPos;} publicvoidScoredAGoal () {AddReward (5f); EndEpisode (); StartCoroutine (GoalScoredSwapGroundMaterial (visualSettings.goalScoredMaterial, 0.5f));} IEnumerator GoalScoredSwapGroundMaterial (estera de material, floattime) {groundRenderer .material = estera; returnnewWaitForSeconds rendimiento (tiempo); // Esperar 2 secgroundRenderer.material = groundMaterial;} publicvoidMoveAgent (float [] acto) {vardirToGo = Vector3.zero; varrotateDir = Vector3.zero; varaction = Mathf.FloorToInt (acto [0]); interruptor (acción) {case1: dirToGo = transfor m.forward * 1f; break; case2: dirToGo = transform.forward * -1 septies; break; case3: rotateDir = transform.up * 1f; break; case4: rotateDir = transform.up * -1 septies; break; case5: dirToGo = transform.right * -0.75f; break; case6: dirToGo = transform.right * 0.75f; break;} transform.rotate (rotateDir, Time.fixedDeltaTime * 200f); agentRigid.AddForce (dirToGo * visualSettings.agentRunSpeed, ForceMode.VelocityChange );} publicoverridevoidOnActionReceived (float [] vectorAction) {MoveAgent (vectorAction); AddReward (-1 septies / MaxStep);} publicoverridevoidHeuristic (float [] actionsOut) {actionsOut [0] = 0; si (Input.GetKey (KeyCode.D) ) {actionsOut [0] = 3;} elseif (Input.GetKey (KeyCode.W)) {actionsOut [0] = 1;} elseif (Input.GetKey (KeyCode.A)) {actionsOut [0] = 4;} elseif (Input.GetKey (KeyCode.S)) {actionsOut [0] = 2;}} voidResetBlock () {block.transform.position = GetRandomSpawnPos (); blockRigid.velocity = Vector3.zero; blockRigid.angularVelocity = Vector3.zero ;} publicoverridevoidOnEpisodeBegin () {varrotation = Random.Range (0,4); varrotationAngle = rotación * 90f; area.transform.Rotate (newVector3 (0F, rotationAngl e, 0f)); ResetBlock (); transform.position = GetRandomSpawnPos (); agentRigid.velocity = Vector3.zero; agentRigid.angularVelocity = Vector3.zero; SetResetParameters ();} publicvoidSetGroundMaterialFriction () {vargroundCollider = ground.GetComponent (); groundCollider.material.dynamicFriction = defaultParameters.GetWithDefault ( «dynamic_friction», 1); groundCollider.material.staticFriction = defaultParameters.GetWithDefault ( «static_friction», 0);} publicvoidSetBlockProperties () {varscale = defaultParameters.GetWithDefault (» block_scale», 2); blockRigid.transform.localScale = newVector3 (escala, 0.75f, escala); blockRigid.drag = defaultParameters.GetWithDefault ( «block_drag», 0.5f);} voidSetResetParameters () {SetGroundMaterialFriction (); SetBlockProperties () ;}}

    un guión muy densa, pero la razón es tan complicado, no es porque tiene muchas cosas conceptualmente únicos pasando, pero porque es hacer frente a las acciones más básicas de mover el jugador y restablecer la escena cuando un extremos episodio . De hecho, los métodos “SetResetParameters”, “”, “SetBlockParamters SetGroundMaterialFriction”, “”, “GetRandomSpawnPos OnEpisodeBegin”, “ResetBlock” y “initialize” son todos negociación con el restablecimiento de todo.

    Las partes se debe prestar atención a (después de haber entendido lo que, básicamente, los métodos de reajuste hacen) son donde estamos asignar recompensas y la realización de acciones. Aviso, en la línea 79 estamos añadiendo una recompensa de 5 en el método “ScoredAGoal” que se llama externamente. Y estamos restando una recompensa en el método “OnActionRecieved” en la línea 130a. Este sistema da una recompensa muy grande para marcar un gol, pero también fomenta el agente que hacerlo rápidamente mediante el castigo ligeramente cada vez que utiliza una acción.

    Nótese también cuando estamos contando el agente para moverse en la MoveAgent los métodos “” “OnActionRecieved” y. Debido a que estamos utilizando un espacio de funcionamiento discreto (para aprender acerca de lo que es esto, visite la introducción tutorial https://gamedevacademy.org/unity-ml-agents-tutorial/), estamos usando un switch de los casos en la línea 100 para determinar en qué dirección ir. Parece como un guión muy ocupados, pero todo lo que estamos haciendo en realidad es la asignación de recompensas, la realización de acciones y restablecer el medio ambiente como lo hemos hecho siempre. Y así, con esta comprensión básica de la secuencia de comandos que alimenta nuestro agente, le permite llegar a la carne de este tutorial y entrenarlo.

    La formación del agente

    El primer intento – No Demostración

    he mencionado en la introducción que vamos a utilizar una manifestación para formar el agente. Pero, ¿qué ocurre si lo que acabamos de entrenar sin una demostración? Vamos a seguir adelante y tener un ir en esto. Duplicar el entorno varias veces

    Duplicación varios entornos de formación

    abrir una línea de comandos y ejecutar este comando
    mlagents-aprender –run-id = AIPushAgent1mlagents-aprender -. gestión de id = AIPushAgent

    exitosa obra en el Editor de la Unidad y va a empezar la formación


    deja de Formación en 50.000 pasos y ha acumulado una recompensa media de 1,819, que no es mucho.


    Podríamos subir el número de pasos para que sea entrenar más tiempo con la esperanza de que con el tiempo de trabajo, o que podría entrenarlo después de que hemos demostrado cómo llevar a cabo la tarea. No hay forma real de saber cuánto tiempo podría tomar para entrenar a este agente (el ejemplo de la Unidad tenía 15.000.000 pasos!) Así que estamos mejor simplemente hacer una demostración. Con eso, vamos a seguir adelante y toda desactivar, pero uno de los entornos en preparación para la demostración.


    El segundo intento – Con Demostración

    Unidad de LD-Agents tiene dos métodos de hacer el aprendizaje de imitación, GAIL y AC . AC es sinónimo de “ Comportamiento Clonación ” y que básicamente es un agente que exactamente lo que se demostró copias. Esto es útil sólo para el más básico de los agentes de AI. Es obvio que no vamos a utilizar antes de Cristo ya que nuestro agente y el bloque desovan en lugares al azar. Esto hace que sea imposible para un agente para ejecutar correctamente una tarea, ya que cada escenario es nuevo.

    Por lo tanto, vamos a utilizar GAIL que significa “ generativo Acusatorio imitación de aprendizaje .” Usando este método, se utilizan de manera efectiva dos redes neuronales. Uno de ellos es la política real de que el agente se operan sobre y la otra es una red especial llamado “discriminador”. El discriminador determina qué acciones u observaciones son originales (como en, si el agente se acercó con esa decisión propia) o si la acción u observación procedían de la manifestación. Si se trataba del propio agente, se asigna una recompensa. De esta manera, dos optimizaciones están trabajando en paralelo para darnos un agente más rápido y mejor. Para grabar una demostración, agregar un componente de “Demostración Recorder” al agente.



    manifestaciones de grabación Como de costumbre, la Unidad ha hecho muy intuitiva. Tenemos dos campos de cadena que especifica la ruta y el nombre de la manifestación. Y un booleano que podemos comprobar para comenzar demostrando. Llame a su demostración “PushBlockDemo” y vamos a crear una nueva carpeta llamada “manifestaciones” para guardar esta manifestación en.


    Ahora haga clic en el booleano “Record” y el juego a través de un par de episodios para obtener una demostración buena. Utilizar las teclas WASD para mover el agente alrededor y empujar el bloque en el verde



    Recuerde cómo las recompensas cesionarios agente. Si obtiene una meta que es +5 recompensas, el uso de acciones resta una recompensa por una pequeña cantidad. Así que intenta conseguir el bloque en el objetivo sin usar demasiadas acciones. Una vez que esté satisfecho con su manifestación, el modo de reproducción de salida, desmarque “Record” ( super importante, siempre recuerda esto! ), y simplemente refrescar la Demostraciones carpeta para ver su demostración.



    Si selecciona la manifestación y echar un vistazo al inspector, se le dirá cuántos episodios se reproduce a través y el número de premios que amasado.


    Para este proyecto, he encontrado que una recompensa media de más de 4,5 está bien, pero lo mejor es tratar de llegar lo más alto posible. Y así, con nuestra marca nueva demostración listo para ser lanzado en la red neuronal, vamos a seguir adelante y decir ML-Agentes de usar GAIL para entrenar el agente. Abre el archivo “configuration.yaml” ubicado en la carpeta “resultados”.


    comportamientos: PushAgent: hiperparámetros PPO:: trainer_type batch_size: 1024 buffer_size: 10240 learning_rate: 0,0003 beta: 0.005 epsilon: 0,2 lambd: 0,95 num_epoch: 3 learning_rate_schedule: network_settings lineales: Normalizar: falsos hidden_units: 128 num_layers: 2 vis_encode_type: simple memoria: null reward_signals: extrínseca: gamma: 0,99 fuerza: 1,0 init_path: keep_checkpoints nulo: 5 checkpoint_interval: 500000 max_steps: 500000 time_horizon: 64 summary_freq: 50000 roscados: true self_play: null behavioral_cloning: nullenv_settings: env_args nulo:: env_path nula base_port: 5005 num_envs: 1 de semillas: -1engine_settings: ancho: 84 altura: 84 quality_level: 5 time_scale: 20 target_frame_rate: -1 capture_frame_rate: 60 no_graphics: falseparameter_randomization: nullcurriculum: nullcheckpoint_settings: run_id: AIPushAgent initialize_from: null load_model: false hoja de vida: fuerza falsa: true train_model: false inferencia: falsedebug: false1234567891011121314151617181920212223242526272829303132333435 363738394041424344454647484950515253545556behaviors: PushAgent: trainer_type: ppohyperparameters: batch_size: 1024buffer_size: 10240learning_rate: 0.0003beta: 0.005epsilon: 0.2lambd: 0.95num_epoch: 3learning_rate_schedule: linearnetwork_settings: Normalizar: falsehidden_units: 128num_layers: 2vis_encode_type: simplememory: nullreward_signals: extrínseca: gamma: 0.99strength: 1.0 init_path: nullkeep_checkpoints: 5checkpoint_interval: 500000max_steps: 500000time_horizon: 64summary_freq: 50000threaded: trueself_play: nullbehavioral_cloning: nullenv_settings: env_path: nullenv_args: nullbase_port: 5005num_envs: 1seed: -1engine_settings: ancho: 84height: 84quality_level: 5time_scale: 20target_frame_rate: -1capture_frame_rate: 60no_graphics: falseparameter_randomization: nullcurriculum: nullcheckpoint_settings: run_id: AIPushAgentinitialize_from: nullload_model: falseresume: falseforce: truetrain_model: falseinference: falsedebug: false

    para integrar GAIL en el proceso de formación, tenemos que añadir estas líneas en “señales de recompensa”:
    reward_signals: Gail: gamma: 0,99 Fuerza: 1,0 demo_path: D: PushBlockAI Activos Demostraciones PushBlockDemo.demo12345reward_signals: Gail: gamma: 0.99strength: 1.0demo_path: D: PushBlockAI Activos Demostraciones PushBlockDemo.demo

    con el “demo_path” apuntando a donde se almacena su manifestación. Ahora, ya que estamos aquí en el archivo de configuración, ¿hay otros ajustes que se pueden manipular para hacer que el tren agente mejor? Vamos a echar un vistazo a los “hiperparámetros.” Este archivo de configuración casas lo que se llaman “hiperparámetros”, que son un conjunto especial de parámetros que afecta a la red neuronal en el nivel más granular. Por ejemplo, el valor “hidden_units” en la línea 15 es el número de neuronas que se van a utilizar en la red neural.

    Los “num_layers” en la línea 16 son el número de capas de neuronas que van a utilizar. Obviamente, los valores más grandes para ambos resultarán en el tiempo de entrenamiento más largo, pero es posible que tenga las neuronas adicionales si usted está entrenando un agente complejo. Vamos a seguir adelante y más del doble del número de neuronas para darnos un poco más de precisión.
    hidden_units: 256

    Tener un rápido vistazo a los otros valores, “gamma” en la línea 21 determina si el agente debe buscar una recompensa inmediata o el ejercicio de una política que ganar más premios en el largo plazo. Un valor más bajos en el primero, mientras que un valor más alto (como lo es en 0.99) buscará algo que gana recompensas a largo plazo. “Batch_size” y “BUFFER_SIZE”, en las líneas 5 y 6, respectivamente, determinar el número de experiencias que el agente debe utilizar antes de que actualiza la política y continúa en descenso de gradiente. Vamos a establecer este a 128 y 2.048, respectivamente, para darnos menos experiencias durante el descenso de gradiente, pero más cuando se trata de la actualización de la política. Estos deben ser múltiplos de uno al otro o bien la matemática no funciona.

    Hay muchos más valores de configuración en este documento, pero la final vamos a estar investigando es el valor “beta” en la línea 8. Esto influye en el número de acciones al azar el agente tomará. Un valor más alto hace que sea más aleatorio. Vamos a poner esto a 0.005 ya que la tarea no necesariamente requiere mucha desviación si el agente ha encontrado un camino que maximiza recompensas. Antes de guardar esto, vamos a aumentar el valor “max_steps”, en la línea 27, de 500.000 a 8.000.000 sólo para darnos un poco más de espacio para que el tren agente. Además, he tenido que eliminar la línea 51 debido a un error en el momento de la escritura. Guardar el archivo de configuración como “PushBlockAIConfig.yaml” en una ubicación adecuada (Acabo de elegir la carpeta Mis documentos) y luego volver a entrenar por la perforación de este comando:
    mlagents-aprender Documentos PushBlockAIConfig.yaml –run-id = PushBlockAI –force1mlagents-aprender Documentos PushBlockAIConfig.yaml – run-id = PushBlockAI – fuerza

    Asegúrese de habilitar todos los ambientes y después haga clic en juego.


    Para obtener una vista más detallada del proceso de formación, abrir una nueva ventana de comandos y ponche en este comando:
    tensorboard –logdir = resultados –port = 60061tensorboard – logdir = Resultados – port = 6006

    Ahora, podemos ir a un navegador Web y vaya a “http: // localhost: 6006 /”. Esto abrirá un gráfico como este:


    Esto nos dará información acerca de cosas como recompensas medios, la duración episodio, recompensas de GAIL, etc. Es un signo bueno si las recompensas han alcanzado 4 a 4,5.


    Puede importar la red neuronal y asignarla a nuestro agente.



    puede pulsar el botón Reproducir y ver el agente de empujar automáticamente el bloque en la zona verde.


    Conclusión

    Y eso es todo! Felicitaciones por terminar su agente de aprendizaje de máquina!

    A través de este tutorial, aprendió un nuevo método para la formación de nuestra máquina de agentes de aprendizaje – a través del poder de la manifestación. Al igual que cómo se podría mostrar un ser humano, logramos enseñar a nuestra AI empujar un bloque a un objetivo puramente llevando a cabo el acto de nosotros mismos.

    De hecho, ser capaz de tener tanto control sobre la formación agente es uno de los puntos fuertes de la unidad de LD-Agents. Además, el aprendizaje de la imitación es una forma mucho más intuitiva de la formación de una IA. Tiene mucho más sentido para mostrar el agente qué hacer, en lugar de esperanza que se da cuenta de qué hacer. Al completar este tutorial, sin embargo, se puede ver hasta qué punto avanzó un AI hizo con el aprendizaje de la máquina puede ser, y estamos seguros de que puede encontrar una multitud de aplicaciones para él en sus propios juegos!

    De cualquier manera, tienes otra herramienta en el cinturón de …

    Seguir haciendo grandes juegos!

    Mensajes relacionados

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *