/// <summary> /// Choose the next node for an ant to visit. This is based on probability. /// </summary> /// <param name="currentIndex">The step we are at in the path.</param> /// <param name="ant">The ant being evaluated.</param> /// <returns>The node we will move into.</returns> private int PickNextNode(int currentIndex, DiscreteAnt ant) { if (currentIndex == 0 || Random.NextDouble() < PR) { int index; do { index = Random.NextInt(0, _graph.Count); } while (ant.WasVisited(index)); return(index); } double[] prob = CalculateProbability(currentIndex, ant); double r = Random.NextDouble(); double sum = 0; for (int i = 0; i < _graph.Count; i++) { sum += prob[i]; if (sum >= r) { return(i); } } // should not happen! return(-1); }
void Crossover(IGenerateRandom rnd, UniverseRunner crossoverParent1, UniverseRunner crossoverParent2) { double[] parent1 = crossoverParent1.PhysicsRules.Data; double[] parent2 = crossoverParent2.PhysicsRules.Data; double[] child = PhysicsRules.Data; int len = parent1.Length; var p1 = (int)(rnd.NextDouble() * len); var p2 = (int)(rnd.NextDouble() * len); for (int i = 0; i < PhysicsRules.Data.Length; i++) { if (i < p1) { child[i] = parent1[i]; } else if (i >= p1 && i <= p2) { child[i] = parent2[i]; } else if (i > p2) { child[i] = parent1[i]; } } }
public void Process() { long tries = 0; int success = 0; int lastUpdate = 0; for (int i = 0; i < 1000000000; i++) { // pick a point at random. double x = _rnd.NextDouble(); double y = _rnd.NextDouble(); tries++; // was the point inside of a circle? if (x * x + y * y <= 1) { success++; } lastUpdate++; if (lastUpdate >= 1000000) { double pi = 4 * (double)success / tries; Console.WriteLine("Tries=" + tries + ", pi=" + pi); lastUpdate = 0; } } }
/// <summary> /// Perform a mutate on a parent and generate a new child. The parent is not changed. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="sourcePhysics">The parent object.</param> /// <param name="probChange">The probability of changing an individual element.</param> /// <param name="perturb">The amount that an object is changed by.</param> public void Mutate(IGenerateRandom rnd, IPhysics sourcePhysics, double probChange, double perturb) { PhysicsRules.CopyData(sourcePhysics.Data); for (int i = 0; i < sourcePhysics.Data.Length; i++) { if (rnd.NextDouble() < probChange) { PhysicsRules.Data[i] += perturb * rnd.NextDouble(-1, 1); } } }
/// <summary> /// Randomize the long term memory, with the specified random number generator. /// </summary> /// <param name="rnd">A random number generator.</param> public void Reset(IGenerateRandom rnd) { for (int i = 0; i < _longTermMemory.Length; i++) { _longTermMemory[i] = rnd.NextDouble(-1, 1); } }
/// <inheritdoc /> public override void TrainingBatch(IGenerateRandom rnd) { for (var i = 0; i < _active.Length; i++) { _active[i] = rnd.NextDouble() > DropoutProbability; } }
public void BackgroundThread() { if (_uniformMode) { while (!_requestStop) { ReportNumber(_rnd.NextDouble()); } } else { while (!_requestStop) { ReportNumber(_rnd.NextGaussian()); } } Action a = () => { ButtonStart.IsEnabled = true; ButtonStop.IsEnabled = false; ComboDistribution.IsEnabled = true; ComboGenerator.IsEnabled = true; }; Dispatcher.BeginInvoke(a); }
/// <summary> /// Pick a operator based on the number of parents available. /// </summary> /// <param name="rnd">A random number generator.</param> /// <param name="maxParents">The maximum number of parents available.</param> /// <returns>The operator that was selected.</returns> public IEvolutionaryOperator PickMaxParents(IGenerateRandom rnd, int maxParents) { // determine the total probability of eligible operators double total = 0; foreach (ObjectHolder <IEvolutionaryOperator> holder in ObjList) { if (holder.Obj.ParentsNeeded <= maxParents) { total += holder.Probability; } } // choose an operator double r = rnd.NextDouble() * total; double current = 0; foreach (ObjectHolder <IEvolutionaryOperator> holder in ObjList) { if (holder.Obj.ParentsNeeded <= maxParents) { current += holder.Probability; if (r < current) { return(holder.Obj); } } } return(null); }
/// <summary> /// The constructor. /// </summary> /// <param name="theAlgorithm">The algorithm to fit.</param> /// <param name="theScore">The score function.</param> /// <param name="thePopulationSize">The population size.</param> public ContinuousACO(IMLMethod theAlgorithm, IScoreFunction theScore, int thePopulationSize) { Epsilon = .75; _algorithm = theAlgorithm; _populationSize = thePopulationSize; _score = theScore; Random = new MersenneTwisterGenerateRandom(); _paramCount = theAlgorithm.LongTermMemory.Length; _population = new ContinuousAnt[thePopulationSize * 2]; _weighting = new double[thePopulationSize]; for (int i = 0; i < _population.Length; i++) { _population[i] = new ContinuousAnt(_paramCount, _score.ShouldMinimize); for (int j = 0; j < _paramCount; j++) { _population[i].Params[j] = Random.NextDouble(-1, 1); } } UpdateScore(); Array.Sort(_population); ComputeWeighting(); SampleSolutions(); Array.Sort(_population); }
/// <summary> /// v = k * U(0,1) * v /// /// The components of the vector are multiplied /// by k and a random number. /// A new random number is generated for each /// component. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="v">Array of doubles.</param> /// <param name="k">A scaler.</param> public static void MulRand(IGenerateRandom rnd, double[] v, double k) { for (int i = 0; i < v.Length; i++) { v[i] *= k * rnd.NextDouble(); } }
/// <summary> /// v = U(-1, 1) * maxValue /// <p/> /// Randomise each component of a vector to /// [-maxValue, maxValue]. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="v">An array of doubles.</param> /// <param name="maxValue">Maximum value +/-.</param> public static void Randomise(IGenerateRandom rnd, double[] v, double maxValue) { for (int i = 0; i < v.Length; i++) { v[i] = (2 * rnd.NextDouble() - 1) * maxValue; } }
/// <summary> /// Randomize the properties between (-1,1). /// </summary> /// <param name="rnd">A random number generator.</param> public void Randomize(IGenerateRandom rnd) { for (int i = 0; i < _prop.Length; i++) { _prop[i] = rnd.NextDouble(-1, 1); } }
/// <summary> /// Randomly move to a new location. To specify a new randomization function, override this method. /// </summary> /// <param name="memory">The long term memory.</param> public void PerformRandomize(double[] memory) { for (int i = 0; i < memory.Length; i++) { memory[i] = _rnd.NextDouble(_lowRange, _highRange); } }
public void Reset(IGenerateRandom rnd) { for (int i = 0; i < _weights.RowCount; i++) { for (int j = 0; j < _weights.ColumnCount; j++) { _weights[i, j] = rnd.NextDouble(-1, 1); } } }
public SOMColors() { InitializeComponent(); network = CreateNetwork(); gaussian = new NeighborhoodRBF(RBFEnum.Gaussian, WIDTH, HEIGHT); train = new BasicTrainSOM(network, 0.01, null, gaussian); train.ForceWinner = false; samples = AIFH.Alloc2D <double>(15, 3); for (int i = 0; i < 15; i++) { samples[i][0] = rnd.NextDouble(-1, 1); samples[i][1] = rnd.NextDouble(-1, 1); samples[i][2] = rnd.NextDouble(-1, 1); } train.SetAutoDecay(100, 0.8, 0.003, 30, 5); }
/// <summary> /// The constructor. /// </summary> /// <param name="rnd">A random number generator.</param> /// <param name="numConst">The number of constants.</param> /// <param name="numVar">The number of variables.</param> /// <param name="minConstValue">The minimum amount for a constant.</param> /// <param name="maxConstValue">The maximum amount for a constant.</param> public EvaluateExpression(IGenerateRandom rnd, int numConst, int numVar, double minConstValue, double maxConstValue) { constValues = new double[numConst]; varCount = numVar; for (int i = 0; i < constValues.Length; i++) { constValues[i] = rnd.NextDouble(minConstValue, maxConstValue); } }
/// <inheritdoc /> public void Iteration() { var len = _algorithm.LongTermMemory.Length; _k++; _currentTemperature = CoolingSchedule(); for (var cycle = 0; cycle < _cycles; cycle++) { // backup current state var oldState = new double[len]; Array.Copy(_algorithm.LongTermMemory, 0, oldState, 0, len); // randomize the method PerformRandomize(_algorithm.LongTermMemory); // did we improve it? Only keep the new method if it improved (greedy). var trialError = _score.CalculateScore(_algorithm); // was this iteration an improvement? If so, always keep. var keep = false; if (trialError < _currentError) { keep = true; } else { _lastProbability = CalcProbability(_currentError, trialError, _currentTemperature); if (_lastProbability > _rnd.NextDouble()) { keep = true; } } if (keep) { _currentError = trialError; // better than global error if (trialError < _globalBestError) { _globalBestError = trialError; Array.Copy(_algorithm.LongTermMemory, 0, oldState, 0, len); Array.Copy(_algorithm.LongTermMemory, 0, _globalBest, 0, len); } } else { Array.Copy(oldState, 0, _algorithm.LongTermMemory, 0, len); } } }
/// <inheritdoc /> public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring, int offspringIndex) { var parent = (IArrayGenome)parents[parentIndex]; offspring[offspringIndex] = owner.Population.GenomeFactory.Factor(); var child = (IArrayGenome)offspring[offspringIndex]; child.Copy(parent); int length = parent.Count; var iswap1 = (int)(rnd.NextDouble() * length); var iswap2 = (int)(rnd.NextDouble() * length); // can't be equal if (iswap1 == iswap2) { // move to the next, but // don't go out of bounds if (iswap1 > 0) { iswap1--; } else { iswap1++; } } // make sure they are in the right order if (iswap1 > iswap2) { int temp = iswap1; iswap1 = iswap2; iswap2 = temp; } child.Swap(iswap1, iswap2); }
/// <summary> /// Run until state stabilizes. /// </summary> public void EstablishEquilibrium() { var count = NeuronCount; if (_on == null) { _on = new int[count]; _off = new int[count]; } for (var i = 0; i < count; i++) { _on[i] = 0; _off[i] = 0; } for (var n = 0; n < _runCycles * count; n++) { Run((int)_random.NextDouble(0, count - 1)); } for (var n = 0; n < _annealCycles * count; n++) { var i = (int)_random.NextDouble(0, count - 1); Run(i); if (CurrentState[i] > 0) { _on[i]++; } else { _off[i]++; } } for (var i = 0; i < count; i++) { CurrentState[i] = _on[i] > _off[i] ? 1 : 0; } }
/// <inheritdoc /> public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring, int offspringIndex) { var parent = (IArrayGenome) parents[parentIndex]; offspring[offspringIndex] = owner.Population.GenomeFactory.Factor(); var child = (IArrayGenome) offspring[offspringIndex]; child.Copy(parent); int length = parent.Count; var iswap1 = (int) (rnd.NextDouble()*length); var iswap2 = (int) (rnd.NextDouble()*length); // can't be equal if (iswap1 == iswap2) { // move to the next, but // don't go out of bounds if (iswap1 > 0) { iswap1--; } else { iswap1++; } } // make sure they are in the right order if (iswap1 > iswap2) { int temp = iswap1; iswap1 = iswap2; iswap2 = temp; } child.Swap(iswap1, iswap2); }
/// <inheritdoc /> public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring, int offspringIndex) { var parent = (DoubleArrayGenome) parents[parentIndex]; offspring[offspringIndex] = parent.Population.GenomeFactory.Factor(); var child = (DoubleArrayGenome) offspring[offspringIndex]; for (int i = 0; i < parent.Count; i++) { double value = parent.Data[i]; value += (perturbAmount - (rnd.NextDouble()*perturbAmount*2)); child.Data[i] = value; } }
/// <inheritdoc /> public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring, int offspringIndex) { var parent = (DoubleArrayGenome)parents[parentIndex]; offspring[offspringIndex] = parent.Population.GenomeFactory.Factor(); var child = (DoubleArrayGenome)offspring[offspringIndex]; for (int i = 0; i < parent.Count; i++) { double value = parent.Data[i]; value += (perturbAmount - (rnd.NextDouble() * perturbAmount * 2)); child.Data[i] = value; } }
/// <summary> /// Randomize the weights of the neural network. /// </summary> public void Reset() { for (int i = 0; i < _rbm.Length; i++) { HiddenLayer layer = _layers[i]; double a = 1.0 / layer.InputCount; for (int j = 0; j < layer.OutputCount; j++) { for (int k = 0; k < layer.InputCount; k++) { layer.Weights[j][k] = Random.NextDouble(-a, a); } } } }
/// <summary> /// Select a probability distribution function (PDF). /// </summary> /// <returns>The PDF index.</returns> private int SelectPDF() { int l = 0; double temp = 0; double r = Random.NextDouble(); for (int i = 0; i < _populationSize; i++) { temp += _weighting[i] / _sumWeighting; if (r < temp) { l = i; break; } } return(l); }
/// <summary> /// Generate a random choice, but skip one of the choices. /// </summary> /// <param name="theGenerator">Random number generator.</param> /// <param name="skip">The choice to skip.</param> /// <returns>The random choice.</returns> public int Generate(IGenerateRandom theGenerator, int skip) { double totalProb = 1.0 - _probabilities[skip]; double throwValue = theGenerator.NextDouble() * totalProb; double accumulator = 0.0; for (int i = 0; i < skip; i++) { accumulator += _probabilities[i]; if (accumulator > throwValue) { return(i); } } for (int i = skip + 1; i < _probabilities.Length; i++) { accumulator += _probabilities[i]; if (accumulator > throwValue) { return(i); } } for (int i = 0; i < skip; i++) { if (_probabilities[i] != 0.0) { return(i); } } for (int i = skip + 1; i < _probabilities.Length; i++) { if (_probabilities[i] != 0.0) { return(i); } } return(-1); }
/// <summary> /// Generate a random choice, based on the probabilities provided to the constructor. /// </summary> /// <param name="theGenerator"></param> /// <returns>The random choice.</returns> public int Generate(IGenerateRandom theGenerator) { double r = theGenerator.NextDouble(); double sum = 0.0; for (int i = 0; i < _probabilities.Length; i++) { sum += _probabilities[i]; if (r < sum) { return(i); } } for (int i = 0; i < _probabilities.Length; i++) { if (_probabilities[i] != 0.0) { return(i); } } throw new AIFHError("Invalid probabilities."); }
/// <summary> /// Perform one training iteration. This will execute the specified number of cycles at the current /// temperature. /// </summary> public void Iteration() { // Is this the first time through, if so, then setup. if (_k == 0) { _currentScore = Evaluate(); FoundNewBest(); _globalBestScore = _currentScore; } // incrament the current iteration counter _k++; // obtain the correct temperature _currentTemperature = CoolingSchedule(); // perform the specified number of cycles for (int cycle = 0; cycle < _cycles; cycle++) { // backup current state BackupState(); // randomize the method MoveToNeighbor(); // did we improve it? Only keep the new method if it improved (greedy). double trialScore = Evaluate(); // was this iteration an improvement? If so, always keep. bool keep = false; if (trialScore < _currentScore) { // it was better, so always keep it keep = true; } else { // it was worse, so we might keep it _lastProbability = CalcProbability(_currentScore, trialScore, _currentTemperature); if (_lastProbability > _rnd.NextDouble()) { keep = true; } } // should we keep this position? if (keep) { _currentScore = trialScore; // better than global error if (trialScore < _globalBestScore) { _globalBestScore = trialScore; FoundNewBest(); } } else { // do not keep this position RestoreState(); } } }
/// <summary> /// Generate a random choice, but skip one of the choices. /// </summary> /// <param name="theGenerator">Random number generator.</param> /// <param name="skip">The choice to skip.</param> /// <returns>The random choice.</returns> public int Generate(IGenerateRandom theGenerator, int skip) { var totalProb = 1.0 - _probabilities[skip]; var throwValue = theGenerator.NextDouble()*totalProb; var accumulator = 0.0; for (var i = 0; i < skip; i++) { accumulator += _probabilities[i]; if (accumulator > throwValue) { return i; } } for (var i = skip + 1; i < _probabilities.Length; i++) { accumulator += _probabilities[i]; if (accumulator > throwValue) { return i; } } for (var i = 0; i < skip; i++) { if (_probabilities[i] != 0.0) { return i; } } for (var i = skip + 1; i < _probabilities.Length; i++) { if (_probabilities[i] != 0.0) { return i; } } return -1; }
public void Reset(IGenerateRandom rnd) { for (var i = 0; i < _weights.RowCount; i++) { for (var j = 0; j < _weights.ColumnCount; j++) { _weights[i, j] = rnd.NextDouble(-1, 1); } } }
/// <summary> /// v = U(-1, 1) * maxValue /// <p /> /// Randomise each component of a vector to /// [-maxValue, maxValue]. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="v">An array of doubles.</param> /// <param name="maxValue">Maximum value +/-.</param> public static void Randomise(IGenerateRandom rnd, double[] v, double maxValue) { for (var i = 0; i < v.Length; i++) { v[i] = (2*rnd.NextDouble() - 1)*maxValue; } }
/// <summary> /// v = k * U(0,1) * v /// The components of the vector are multiplied /// by k and a random number. /// A new random number is generated for each /// component. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="v">Array of doubles.</param> /// <param name="k">A scaler.</param> public static void MulRand(IGenerateRandom rnd, double[] v, double k) { for (var i = 0; i < v.Length; i++) { v[i] *= k*rnd.NextDouble(); } }
void Crossover(IGenerateRandom rnd, UniverseRunner crossoverParent1, UniverseRunner crossoverParent2) { double[] parent1 = crossoverParent1.PhysicsRules.Data; double[] parent2 = crossoverParent2.PhysicsRules.Data; double[] child = PhysicsRules.Data; int len = parent1.Length; var p1 = (int) (rnd.NextDouble()*len); var p2 = (int) (rnd.NextDouble()*len); for (int i = 0; i < PhysicsRules.Data.Length; i++) { if (i < p1) { child[i] = parent1[i]; } else if (i >= p1 && i <= p2) { child[i] = parent2[i]; } else if (i > p2) { child[i] = parent1[i]; } } }
/// <summary> /// Generate a random choice, based on the probabilities provided to the constructor. /// </summary> /// <param name="theGenerator"></param> /// <returns>The random choice.</returns> public int Generate(IGenerateRandom theGenerator) { var r = theGenerator.NextDouble(); var sum = 0.0; for (var i = 0; i < _probabilities.Length; i++) { sum += _probabilities[i]; if (r < sum) { return i; } } for (var i = 0; i < _probabilities.Length; i++) { if (_probabilities[i] != 0.0) { return i; } } throw new AIFHError("Invalid probabilities."); }
/// <summary> /// Perform a mutate on a parent and generate a new child. The parent is not changed. /// </summary> /// <param name="rnd">Random number generator.</param> /// <param name="sourcePhysics">The parent object.</param> /// <param name="probChange">The probability of changing an individual element.</param> /// <param name="perturb">The amount that an object is changed by.</param> public void Mutate(IGenerateRandom rnd, IPhysics sourcePhysics, double probChange, double perturb) { PhysicsRules.CopyData(sourcePhysics.Data); for (int i = 0; i < sourcePhysics.Data.Length; i++) { if (rnd.NextDouble() < probChange) { PhysicsRules.Data[i] += perturb*rnd.NextDouble(-1, 1); } } }
/// <inheritdoc /> public object Sample(IGenerateRandom rnd) { return rnd.NextDouble(_start, _stop); }
/// <inheritdoc /> public object Sample(IGenerateRandom rnd) { return(rnd.NextDouble(_start, _stop)); }