/// <summary> /// Performs a single throw onto a roulette wheel where the wheel's space is unevenly divided between outcomes. /// The probabilty that a segment will be selected is given by that segment's value in the 'probabilities' /// array within the specified RouletteWheelLayout. The probabilities within a RouletteWheelLayout have already /// been normalised so that their total is always equal to 1.0. /// </summary> /// <param name="layout">The roulette wheel layout.</param> /// <param name="rng">Random number generator.</param> public static int SingleThrow(RouletteWheelLayout layout, FastRandom rng) { // Throw the ball and return an integer indicating the outcome. double throwValue = layout.ProbabilitiesTotal * rng.NextDouble(); double accumulator = 0.0; for (int i = 0; i < layout.Probabilities.Length; i++) { accumulator += layout.Probabilities[i]; if (throwValue < accumulator) { return(layout.Labels[i]); } } // We might get here through floating point arithmetic rounding issues. // e.g. accumulator == throwValue. // Find a nearby non-zero probability to select. // Wrap around to start of array. for (int i = 0; i < layout.Probabilities.Length; i++) { if (layout.Probabilities[i] != 0.0) { return(layout.Labels[i]); } } // If we get here then we have an array of zero probabilities. throw new SharpNeatException("Invalid operation. No non-zero probabilities to select."); }
/// <summary> /// Performs a single throw onto a roulette wheel where the wheel's space is unevenly divided between outcomes. /// The probabilty that a segment will be selected is given by that segment's value in the 'probabilities' /// array within the specified RouletteWheelLayout. The probabilities within a RouletteWheelLayout have already /// been normalised so that their total is always equal to 1.0. /// </summary> /// <param name="layout">The roulette wheel layout.</param> /// <param name="rng">Random number generator.</param> public static int SingleThrow(RouletteWheelLayout layout, FastRandom rng) { // Throw the ball and return an integer indicating the outcome. double throwValue = layout.ProbabilitiesTotal * rng.NextDouble(); double accumulator = 0.0; for(int i=0; i<layout.Probabilities.Length; i++) { accumulator += layout.Probabilities[i]; if(throwValue < accumulator) { return layout.Labels[i]; } } // We might get here through floating point arithmetic rounding issues. // e.g. accumulator == throwValue. // Find a nearby non-zero probability to select. // Wrap around to start of array. for(int i=0; i<layout.Probabilities.Length; i++) { if(layout.Probabilities[i] != 0.0) { return layout.Labels[i]; } } // If we get here then we have an array of zero probabilities. throw new SharpNeatException("Invalid operation. No non-zero probabilities to select."); }
/// <summary> /// Constructor which takes an existing maze genome parameters configuration and copies all of the parameters from it. /// </summary> /// <param name="copyFrom">The existing maze genome parameters configuration to copy.</param> public MazeGenomeParameters(MazeGenomeParameters copyFrom) { MutateWallStartLocationProbability = copyFrom.MutateWallStartLocationProbability; MutatePassageStartLocationProbability = copyFrom.MutatePassageStartLocationProbability; MutateAddWallProbability = copyFrom.MutateAddWallProbability; PerturbanceMagnitude = copyFrom.PerturbanceMagnitude; RouletteWheelLayout = new RouletteWheelLayout(copyFrom.RouletteWheelLayout); }
/// <summary> /// Default constructor, setting all maze genome parameters to their default and creating the roulette wheel layout. /// </summary> public MazeGenomeParameters() { MutateWallStartLocationProbability = DefaultMutateWallStartLocationProbability; MutatePassageStartLocationProbability = DefaultMutatePassageStartLocationProbability; MutateAddWallProbability = DefaultMutateAddWallProbability; PerturbanceMagnitude = DefaultPerturbanceMagnitude; // Create a new roulette wheel layout with the default probabilities RouletteWheelLayout = CreateRouletteWheelLayout(); }
public MarkovChain(MarkovChainNode[] nodes, int stepsPerActivation, FastRandom random) { _nodes = nodes; _stepsPerActivation = stepsPerActivation; _random = random; _rouletteWheels = new RouletteWheelLayout[nodes.Length]; for (int i = 0; i < nodes.Length; i++) _rouletteWheels[i] = new RouletteWheelLayout(nodes[i].TransitionProbabilities); }
/// <summary> /// Constructs an activation function library with a default set of activation functions. /// </summary> public DefaultCppnActivationFunctionLibrary() { _functionList = new List<ActivationFunctionInfo>(4); double[] probabilities = {0.25, 0.25, 0.25, 0.25}; _functionList.Add(new ActivationFunctionInfo(0, probabilities[0], Linear.__DefaultInstance)); _functionList.Add(new ActivationFunctionInfo(1, probabilities[1], BipolarSigmoid.__DefaultInstance)); _functionList.Add(new ActivationFunctionInfo(2, probabilities[2], Gaussian.__DefaultInstance)); _functionList.Add(new ActivationFunctionInfo(3, probabilities[3], Sine.__DefaultInstance)); _rwl = new RouletteWheelLayout(probabilities); _functionDict = CreateFunctionDictionary(_functionList); }
/// <summary> /// Constructs an activation function library with the provided list of activation functions. /// </summary> public DefaultActivationFunctionLibrary(IList<ActivationFunctionInfo> fnList) { // Build a RouletteWheelLayout based on the selection probability on each item. int count = fnList.Count; double[] probabilities = new double[count]; for(int i=0; i<count; i++) { probabilities[i] = fnList[i].SelectionProbability; } _rwl = new RouletteWheelLayout(probabilities); _functionList = fnList; // Build a dictionary of functions keyed on integer ID. _functionDict = CreateFunctionDictionary(_functionList); }
static Dictionary<string, double> morphEnglish(Dictionary<string, double> english, double[] digitProbs, double[] posProbs, int minLength = 0) { Dictionary<string, double> results = new Dictionary<string, double>(); FastRandom random = new FastRandom(); Console.WriteLine("Probs sum: {0}", digitProbs.Sum()); RouletteWheelLayout digitLayout = new RouletteWheelLayout(digitProbs); RouletteWheelLayout posLayout = new RouletteWheelLayout(posProbs); int alreadyNumbered = 0; foreach (string s in english.Keys) { bool numbered = false; for (int i = 0; i < s.Length; i++) if (s[i] >= '0' && s[i] <= '9') { alreadyNumbered++; numbered = true; break; } string morphedPassword = s; while (!numbered || morphedPassword.Length < minLength) { int toAdd = RouletteWheel.SingleThrow(digitLayout, random); int pos = RouletteWheel.SingleThrow(posLayout, random); if (pos == 0) break; else if (pos == 1) morphedPassword = toAdd + morphedPassword; else if (pos == 2) morphedPassword = morphedPassword + toAdd; else { pos = random.Next(morphedPassword.Length); morphedPassword = morphedPassword.Substring(0, pos) + toAdd + morphedPassword.Substring(pos, morphedPassword.Length - pos); } numbered = true; } double val; if (!results.TryGetValue(morphedPassword, out val)) results.Add(morphedPassword, 1); } Console.WriteLine("Had numbers already: {0}", alreadyNumbered); return results; }
/// <summary> /// Construct with default set of parameters. /// </summary> public NeatGenomeParameters() { _activationFn = SteepenedSigmoid.__DefaultInstance; _connectionWeightRange = DefaultConnectionWeightRange; _initialInterconnectionsProportion = DefaultInitialInterconnectionsProportion; _disjointExcessGenesRecombineProbability = DefaultDisjointExcessGenesRecombineProbability; _connectionWeightMutationProbability = DefaultConnectionWeightMutationProbability; _addNodeMutationProbability = DefaultAddNodeMutationProbability; _addConnectionMutationProbability = DefaultAddConnectionMutationProbability; _nodeAuxStateMutationProbability = DefaultNodeAuxStateMutationProbability; _deleteConnectionMutationProbability = DefaultDeleteConnectionMutationProbability; _rouletteWheelLayout = CreateRouletteWheelLayout(); _rouletteWheelLayoutNonDestructive = CreateRouletteWheelLayout_NonDestructive(); // Create a connection weight mutation scheme. _connectionMutationInfoList = CreateConnectionWeightMutationScheme_Default(); // No fitness history. _fitnessHistoryLength = 0; }
/// <summary> /// Copy constructor. /// </summary> public NeatGenomeParameters(NeatGenomeParameters copyFrom) { _feedforwardOnly = copyFrom._feedforwardOnly; _activationFn = copyFrom._activationFn; _connectionWeightRange = copyFrom._connectionWeightRange; _initialInterconnectionsProportion = copyFrom._initialInterconnectionsProportion; _disjointExcessGenesRecombineProbability = copyFrom._disjointExcessGenesRecombineProbability; _connectionWeightMutationProbability = copyFrom._connectionWeightMutationProbability; _addNodeMutationProbability = copyFrom._addNodeMutationProbability; _addConnectionMutationProbability = copyFrom._addConnectionMutationProbability; _nodeAuxStateMutationProbability = copyFrom._nodeAuxStateMutationProbability; _deleteConnectionMutationProbability = copyFrom._deleteConnectionMutationProbability; _rouletteWheelLayout = new RouletteWheelLayout(copyFrom._rouletteWheelLayout); _rouletteWheelLayoutNonDestructive = new RouletteWheelLayout(copyFrom._rouletteWheelLayoutNonDestructive); _connectionMutationInfoList = new ConnectionMutationInfoList(copyFrom._connectionMutationInfoList); _connectionMutationInfoList.Initialize(); _fitnessHistoryLength = copyFrom._fitnessHistoryLength; }
/// <summary> /// Copy constructor. /// </summary> public RouletteWheelLayout(RouletteWheelLayout copyFrom) { _probabilitiesTotal = copyFrom._probabilitiesTotal; _probabilities = (double[])copyFrom._probabilities.Clone(); _labels = (int[])copyFrom._labels.Clone(); }
/// <summary> /// Move the prey. The prey moves by a simple set of stochastic rules that make it more likely to move away from /// the agent, and moreso when it is close. /// </summary> public void MovePrey() { // Determine if prey will move in this timestep. (Speed is simulated stochastically) if(_rng.NextDouble() > _preySpeed) { return; } // Determine position of agent relative to prey. PolarPoint relPolarPos = PolarPoint.FromCartesian(_agentPos - _preyPos); // Calculate probabilities of moving in each of the four directions. This stochastic strategy is taken from: // Incremental Evolution Of Complex General Behavior, Faustino Gomez and Risto Miikkulainen (1997) // (http://nn.cs.utexas.edu/downloads/papers/gomez.adaptive-behavior.pdf) // Essentially the prey moves randomply but we bias the movements so the prey moves away from the agent, and thus // generally avoids getting eaten through stupidity. double T = MovePrey_T(relPolarPos.Radial); double[] probs = new double[4]; probs[0] = Math.Exp((CalcAngleDelta(relPolarPos.Theta, Math.PI/2.0) / Math.PI) * T * 0.33); // North. probs[1] = Math.Exp((CalcAngleDelta(relPolarPos.Theta, 0) / Math.PI) * T * 0.33); // East. probs[2] = Math.Exp((CalcAngleDelta(relPolarPos.Theta, Math.PI * 1.5) / Math.PI) * T * 0.33); // South. probs[3] = Math.Exp((CalcAngleDelta(relPolarPos.Theta, Math.PI) / Math.PI) * T * 0.33); // West. RouletteWheelLayout rwl = new RouletteWheelLayout(probs); int action = RouletteWheel.SingleThrow(rwl, _rng); switch(action) { case 0: // Move north. _preyPos._y = Math.Min(_preyPos._y + 1, _gridSize - 1); break; case 1: // Move east. _preyPos._x = Math.Min(_preyPos._x + 1, _gridSize - 1); break; case 2: // Move south. _preyPos._y = Math.Max(_preyPos._y - 1, 0); break; case 3: // Move west (is the best?) _preyPos._x = Math.Max(_preyPos._x - 1, 0); break; } }