/* @author Andrew DeBiase */
    private Tuple <Chromosome2, Chromosome2> Crossover(Chromosome2 parentOne, Chromosome2 parentTwo)
    {
        int jointsLength = parentOne.jointMovements.Length;
        int crossPoint   = Random.Range(1, jointsLength);

        for (int i = crossPoint; i < jointsLength; i++)
        {
            Tuple <float, Vector3>[] temp = parentOne.jointMovements[i];
            parentOne.jointMovements[i] = parentTwo.jointMovements[i];
            parentTwo.jointMovements[i] = temp;
        }

        return(new Tuple <Chromosome2, Chromosome2>(parentOne, parentTwo));
    }
    /*
     * Handles mutating a chromosome passed in by adding a randomly generated value
     * to the torques of the chromosome
     * @author Ernest Essuah Mensah
     */
    private Chromosome2 Mutate(Chromosome2 parent)
    {
        // Copy torques from parent to mutate
        Tuple <float, Vector3>[][] jointMovements = parent.jointMovements;

        int mutationIndex = Random.Range(0, parent.jointMovements.Length);

        for (int i = 0; i < COMPLEX_CHROMOSOME_LENGTH; i++)
        {
            Tuple <float, Vector3> current = parent.jointMovements[mutationIndex][i];

            // Pick a random axis to mutate
            // 0: x-axis; 1: y-axis, 2: z-axis
            int     mutationAxis = Random.Range(0, 2);
            float   mutation     = Random.Range(-INIT_TORQUE_MAG, INIT_TORQUE_MAG);
            Vector3 newMovement;

            if (mutationAxis == 0)
            {
                newMovement = new Vector3(current.Item2.x + mutation, current.Item2.y, current.Item2.z);
            }
            else if (mutationAxis == 1)
            {
                newMovement = new Vector3(current.Item2.x, current.Item2.y + mutation, current.Item2.z);
            }
            else
            {
                newMovement = new Vector3(current.Item2.x, current.Item2.y, current.Item2.z + mutation);
            }

            // Mutate the time between joint movements
            float mutationTime = Random.Range(-MAX_TIME_BETWEEN_TORQUES, MAX_TIME_BETWEEN_TORQUES);

            float newTime = Mathf.Max(current.Item1 + mutationTime, 0);

            jointMovements[mutationIndex][i] = new Tuple <float, Vector3>(newTime, newMovement);
        }

        return(new Chromosome2(jointMovements));
    }
Beispiel #3
0
    // This should be called right after the golfer is instantiated
    public void InitializeAgent(Chromosome2 newChrom, GolferSettings newSettings, float holeDistOffset = 0)
    {
        chrom       = newChrom;
        jointsInUse = new Rigidbody[chrom.jointMovements.Length];
        settings    = newSettings;
        // hide the golf hole if we don't need it
        if (settings.fitnessFunc == GolferSettings.Fitness.drivingDist)
        {
            hole.gameObject.SetActive(false);
        }
        else
        {   // position the hole based on the distance it's supposed to be from the golfer, maintaining the y-coordinate
            hole.position  = transform.position - Vector3.right * (settings.holeDist + holeDistOffset) + new Vector3(0, hole.position.y, 0);
            actualHoleDist = Vector3.Distance(transform.position, hole.position);
        }

        // Destroy the joint connecting the club to the second hand if we're going one-handed
        if (settings.clubGrip == GolferSettings.ClubGrip.oneHand)
        {
            Destroy(secondHandJoint);
        }
    }
    // --------------- ACTUAL GENETIC ALGORITHM STUFF BELOW ----------------


    /* @author Matthew Graber, Azhdaha Fayyaz, Andrew DeBiase, Vladislav Dozorov */
    // Here is where the actual simulations are managed
    private IEnumerator Simulate()
    {
        // ----------- CREATE INITIAL POPULATION, SET UP SIMULATION ------------

        float holeDistOffset;

        // Initialize arrays
        chroms       = new Chromosome2[numAgents];
        agents       = new GameObject[numAgents];
        fitnesses    = new float[numAgents];
        fitnessTrack = new float[numGens, numAgents]; // 2D array with fitness for each gen

        // determine the number of joints based on whether we're using the golfer's full body or not
        int numJoints = (moveableJoints == GolferSettings.MoveableJointsExtent.fullBody ? 12 : 8);

        // initialize chromosomes with random values
        for (int i = 0; i < chroms.Length; i++)
        {
            // create Vector3 array of random torques to give to the chromosome
            Tuple <float, Vector3>[][] initJointMovements = new Tuple <float, Vector3> [numJoints][];
            for (int j = 0; j < initJointMovements.Length; j++)
            {
                initJointMovements[j] = new Tuple <float, Vector3> [COMPLEX_CHROMOSOME_LENGTH];
                for (int k = 0; k < COMPLEX_CHROMOSOME_LENGTH; k++)
                {
                    initJointMovements[j][k] = new Tuple <float, Vector3>(Random.Range(0f, MAX_TIME_BETWEEN_TORQUES),
                                                                          new Vector3(Random.Range(-INIT_TORQUE_MAG, INIT_TORQUE_MAG),
                                                                                      Random.Range(-INIT_TORQUE_MAG, INIT_TORQUE_MAG),
                                                                                      Random.Range(-INIT_TORQUE_MAG, INIT_TORQUE_MAG)));
                }
            }
            chroms[i] = new Chromosome2(initJointMovements);
        }

        // ----------- RUN THE SIMULATION ------------

        for (int i = 0; i < numGens; i++)
        {
            // display the current generation number
            currentGenText.text = "" + (i + 1) + " / " + numGens;

            // Determine the random hole distance offset for this generation
            // (if holeDistRand == 0 then it will just be 0)
            holeDistOffset = Random.Range(-holeDistRand, holeDistRand);


            // have each agent do several swings and average the fitnesses of those swings
            // clear out fitnesses array
            fitnesses = new float[numAgents];
            for (int swingNum = 0; swingNum < NUM_SWINGS_PER_GEN; swingNum++)
            {
                // Instantiate new agents, give them their respective chromosomes, tell them to start swinging their clubs
                for (int j = 0; j < agents.Length; j++)
                {
                    agents[j] = Instantiate(agentPrefab, new Vector3(PARALLEL_POSITION_OFFSET, 0, -j * DIST_BETWEEN_AGENTS), Quaternion.identity);
                    agents[j].GetComponent <GolferBrain2>().InitializeAgent(chroms[j], settings, holeDistOffset);
                    agents[j].GetComponent <GolferBrain2>().BeginSwinging();
                }

                // Allow this generation to run for the specified time.
                // Execution of this code pauses here until time is up, then automatically resumes.
                yield return(new WaitForSeconds(timePerGen));

                // Get the fitnesses of the agents and then clear them out
                for (int j = 0; j < agents.Length; j++)
                {
                    fitnesses[j] += agents[j].GetComponent <GolferBrain2>().GetFitness();
                    Destroy(agents[j]);
                }
            }
            // complete the calculation of the average fitnesses over those three swings for the gen
            for (int j = 0; j < fitnesses.Length; j++)
            {
                fitnesses[j] = fitnesses[j] / NUM_SWINGS_PER_GEN;
            }

            // Track fitness
            // Initialize best chrom & fit as the first one
            if (i == 0)
            {
                bestChrom   = chroms[0];
                bestFitness = fitnesses[0];
            }

            // Add fitnesses to 2d fitnessTrack array
            // Assign new best chrom if there is one
            for (int j = 0; j < agents.Length; j++)
            {
                fitnessTrack[i, j] = fitnesses[j];

                if (fitnessTrack[i, j] > bestFitness)
                {
                    bestFitness = fitnessTrack[i, j];
                    bestChrom   = chroms[j];
                }
            }

            // create new chromosome array
            Chromosome2[] newChroms = new Chromosome2[chroms.Length];

            /* find most fit individuals
             *  by sorting the fitnesses array in descending order,
             *  then taking the first however many biggest fitnesses
             *  and putting their respective chromosomes in the new chromosome array
             */
            float[] sortedFitnesses = fitnesses;
            Array.Sort(sortedFitnesses);
            Array.Reverse(sortedFitnesses);
            for (int j = 0; j < numElites; j++)
            {
                try {
                    newChroms[j] = chroms[Array.FindIndex(fitnesses, x => x == sortedFitnesses[j])];
                }
                catch {
                    Debug.LogWarning("something weird happened");
                }
            }

            // Andrew DeBiase
            // Crossover selection
            for (int pair = numElites; pair < chroms.Length; pair += 2)
            {
                //Tournament selection with 2 candidates for each parent
                // first parent:
                int cand1idx = Random.Range(0, numAgents);
                int cand2idx = Random.Range(0, numAgents);
                while (cand1idx == cand2idx)
                {
                    cand2idx = Random.Range(0, numAgents);
                }
                int par1idx = (fitnesses[cand1idx] > fitnesses[cand2idx] ? cand1idx : cand2idx);
                // second parent
                cand1idx = Random.Range(0, numAgents);
                cand2idx = Random.Range(0, numAgents);
                while (cand1idx == cand2idx)
                {
                    cand2idx = Random.Range(0, numAgents);
                }
                int par2idx = (fitnesses[cand1idx] > fitnesses[cand2idx] ? cand1idx : cand2idx);

                // determine if we crossover
                float crossValue = Random.Range(0.0f, 1.0f);
                if (crossValue < crossoverProb)
                {
                    // crossover
                    Tuple <Chromosome2, Chromosome2> xresult = Crossover(chroms[par1idx], chroms[par2idx]);
                    newChroms[pair]     = xresult.Item1;
                    newChroms[pair + 1] = xresult.Item2;
                }
                else
                {   // don't crossover, just send the parents on to the new array
                    newChroms[pair]     = chroms[par1idx];
                    newChroms[pair + 1] = chroms[par2idx];
                }
            }

            //Vladislav Dozorov
            //Handle when mutation occurs
            for (int candmidx = numElites; candmidx < newChroms.Length; candmidx++)
            {
                float mutationValue = Random.Range(0.0f, 1.0f);
                if (mutationValue <= mutationProb)
                {
                    newChroms[candmidx] = Mutate(newChroms[candmidx]);
                }
            }
        }
        completionText.SetActive(true);
        // ExportCSV()
        GetComponent <Exporter>().FinishedSimulation();
        yield break;
    }