Exemple #1
0
 void Awake()
 {
     // academy = GetComponent<Academy>();
     // agentSpawner = GetComponent<EnvSpawner>();
     envIds   = agentSpawner.spawnableEnvDefinitions.Select(x => x.envId).ToArray();
     fontSize = 26;
     if (Screen.height < 720)
     {
         fontSize /= 2;
     }
     heightRequirments = (fontSize + 4) * (envIds.Length + 1);
     if (envIdIdex == -1)
     {
         var envId  = GetEnvId();
         var envDef = agentSpawner.spawnableEnvDefinitions.FirstOrDefault(x => x.envId == envId);
         envIdIdex = agentSpawner.spawnableEnvDefinitions.IndexOf(envDef);
     }
     // exit if we should not dispplay the menu
     if (ShouldInitalizeOnAwake())
     {
         var spawnPrefab = agentSpawner.GetPrefabFor(GetEnvId());
         agentSpawner.SpawnSpawnableEnv(this.gameObject, GetNumAgents(), spawnPrefab);
         return;
     }
     showPopUp = true;
 }
Exemple #2
0
        /// <summary>
        /// Initializes the environment, configures it and initialized the Academy.
        /// </summary>
        private void InitializeEnvironment()
        {
            originalGravity          = Physics.gravity;
            originalFixedDeltaTime   = Time.fixedDeltaTime;
            originalMaximumDeltaTime = Time.maximumDeltaTime;

            InitializeAcademy();
            Communicator communicator = null;

            var spawnPrefab            = agentSpawner.GetPrefabFor(GetAgentId());
            var spawnAgentPrefabs      = spawnPrefab.GetComponentsInChildren <Agent>();
            var spawnAgentPrefabBrains = spawnAgentPrefabs
                                         .Where(x => x.brain as LearningBrain != null)
                                         .Select(x => x.brain)
                                         .ToList();
            var spawnerEnabled      = spawnAgentPrefabBrains.Count > 0;
            var hubBrains           = broadcastHub.broadcastingBrains.Where(x => x != null).ToList();;
            var hubControlledBrains = broadcastHub.broadcastingBrains.Where(
                x => x != null && x is LearningBrain && broadcastHub.IsControlled(x));

            IEnumerable <Brain> exposedBrains =
                spawnerEnabled ? spawnAgentPrefabBrains : hubBrains;
            IEnumerable <Brain> controlledBrains = hubControlledBrains;

            if (spawnerEnabled)
            {
                controlledBrains = IsTrainingMode()
                    ? spawnAgentPrefabBrains
                    : new List <Brain>();
            }

            // Try to launch the communicator by usig the arguments passed at launch
            try
            {
                communicator = new RPCCommunicator(
                    new CommunicatorParameters
                {
                    port = ReadArgs()
                });
            }
            // If it fails, we check if there are any external brains in the scene
            // If there are : Launch the communicator on the default port
            // If there arn't, there is no need for a communicator and it is set
            // to null
            catch
            {
                communicator = null;
                if (controlledBrains.ToList().Count > 0)
                {
                    communicator = new RPCCommunicator(
                        new CommunicatorParameters
                    {
                        port = 5005
                    });
                }
            }
            foreach (LearningBrain brain in controlledBrains)
            {
                brain.SetToControlledExternally();
            }

            brainBatcher = new Batcher(communicator);

            foreach (var trainingBrain in exposedBrains)
            {
                trainingBrain.SetBatcher(brainBatcher);
            }

            if (communicator != null)
            {
                isCommunicatorOn = true;

                var academyParameters =
                    new CommunicatorObjects.UnityRLInitializationOutput();
                academyParameters.Name    = gameObject.name;
                academyParameters.Version = kApiVersion;
                foreach (var brain in exposedBrains)
                {
                    var bp = brain.brainParameters;
                    academyParameters.BrainParameters.Add(
                        bp.ToProto(brain.name, broadcastHub.IsControlled(brain)));
                }
                academyParameters.EnvironmentParameters =
                    new CommunicatorObjects.EnvironmentParametersProto();
                foreach (var key in resetParameters.Keys)
                {
                    academyParameters.EnvironmentParameters.FloatParameters.Add(
                        key, resetParameters[key]
                        );
                }

                var pythonParameters = brainBatcher.SendAcademyParameters(academyParameters);
                Random.InitState(pythonParameters.Seed);
                Application.logMessageReceived += HandleLog;
                logPath = Path.GetFullPath(".") + "/UnitySDK.log";
                using (var fs = File.Open(logPath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
                {
                    logWriter = new StreamWriter(fs);
                    logWriter.WriteLine(System.DateTime.Now.ToString());
                    logWriter.WriteLine(" ");
                    logWriter.Close();
                }
            }

            // If a communicator is enabled/provided, then we assume we are in
            // training mode. In the absence of a communicator, we assume we are
            // in inference mode.
            isInference = !isCommunicatorOn;

            BrainDecideAction += () => { };
            DestroyAction     += () => { };
            AgentSetStatus    += (m, d, i) => { };
            AgentResetIfDone  += () => { };
            AgentSendState    += () => { };
            AgentAct          += () => { };
            AgentForceReset   += () => { };

            // Configure the environment using the configurations provided by
            // the developer in the Editor.
            SetIsInference(!brainBatcher.GetIsTraining());
            ConfigureEnvironment();

            if (spawnerEnabled)
            {
                agentSpawner.SpawnSpawnableEnv(this.gameObject, GetNumAgents(), spawnPrefab);
            }
        }