public static void For( int start, int stop, int stepLength, ForLoopBody loopBody, bool close ) { // get instance of parallel computation manager Parallel instance = new Parallel (); instance.Initialize (); instance.ForLoop (start,stop,stepLength,loopBody, close); }
/// <summary> /// Responsible for population migration /// </summary> /// <param name="iteration"></param> private void MigratePopulation(int iteration) { switch (iteration) { case 0: // Migrate values between populations Parallel.For(0, 5, migrationIteration => _populationArray[migrationIteration].Migrate(_populationArray[5 + migrationIteration], 15, new EliteSelection())); break; case 1: // Migrate values between populations for (int i = 0; i < 10; i += 2) { _populationArray[i].Migrate(_populationArray[i + 1], 15, new EliteSelection()); } break; //case 2: // // Migrate values between populations // Parallel.For(0, 5, // migrationIteration => // _populationArray[migrationIteration].Migrate(_populationArray[9 - migrationIteration], // 15, new EliteSelection())); // break; } }
private static void CallDependencies(Computation c, bool executeBefore) { TaskParallel.ForEach(c.TransformationRule.Dependencies, requirement => { if (requirement.ExecuteBefore == executeBefore) { requirement.HandleDependency(c); } }); }
public static void Handle(List <A> aArray) { int incorrectCount = 0; object o = new object(); Par.ForEach(aArray, async a => { if (a.Incorrect) { lock (o) { incorrectCount++; } } else { Thread.Sleep(a.I * 1000); Console.WriteLine(a.I); } }); Console.WriteLine($"Total incorrect {incorrectCount}"); }
private void split(DecisionNode root, double[][] input, int[] output) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Statistics.Tools.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) root.Output = output[0]; return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. int predictors = attributes.Count(x => x == false); if (predictors <= attributes.Length - maxHeight) { root.Output = Statistics.Tools.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. double[] scores = new double[predictors]; double[] entropies = new double[predictors]; double[] thresholds = new double[predictors]; int[][][] partitions = new int[predictors][][]; // Retrieve candidate attribute indices int[] candidates = new int[predictors]; for (int i = 0, k = 0; i < attributes.Length; i++) if (!attributes[i]) candidates[k++] = i; // For each attribute in the data set #if SERIAL for (int i = 0; i < scores.Length; i++) #else Parallel.For(0, scores.Length, i => #endif { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i], out thresholds[i]); } #if !SERIAL ); #endif // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainEntropy = entropies[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; var maxGainThreshold = thresholds[maxGainIndex]; // Mark this attribute as already used attributes[maxGainAttribute] = true; double[][] inputSubset; int[] outputSubset; // Now, create next nodes and pass those partitions as their responsibilities. if (tree.Attributes[maxGainAttribute].Nature == DecisionVariableKind.Discrete) { // This is a discrete nature attribute. We will branch at each // possible value for the discrete variable and call recursion. DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; // Create a branch for each possible value for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree) { Parent = root, Value = i + maxGainRange.Min, Comparison = ComparisonKind.Equal, }; inputSubset = input.Submatrix(maxGainPartition[i]); outputSubset = output.Submatrix(maxGainPartition[i]); split(children[i], inputSubset, outputSubset); // recursion } root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else if (maxGainPartition.Length > 1) { // This is a continuous nature attribute, and we achieved two partitions // using the partitioning scheme. We will branch on two possible settings: // either the value is higher than a currently detected optimal threshold // or it is lesser. DecisionNode[] children = { new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.LessThanOrEqual }, new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.GreaterThan } }; // Create a branch for lower values inputSubset = input.Submatrix(maxGainPartition[0]); outputSubset = output.Submatrix(maxGainPartition[0]); split(children[0], inputSubset, outputSubset); // Create a branch for higher values inputSubset = input.Submatrix(maxGainPartition[1]); outputSubset = output.Submatrix(maxGainPartition[1]); split(children[1], inputSubset, outputSubset); root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else { // This is a continuous nature attribute, but all variables are equal // to a constant. If there is only a constant value as the predictor // and there are multiple output labels associated with this constant // value, there isn't much we can do. This node will be a leaf. // We will set the class label for this node as the // majority of the currently selected output classes. outputSubset = output.Submatrix(maxGainPartition[0]); root.Output = Statistics.Tools.Mode(outputSubset); } attributes[maxGainAttribute] = false; }
private void split(DecisionNode root, double[][] input, int[] output, int height) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Measures.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) { root.Output = output[0]; } return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. // how many variables have been used less than the limit int[] candidates = Matrix.Find(attributeUsageCount, x => x < join); if (candidates.Length == 0 || (maxHeight > 0 && height == maxHeight)) { root.Output = Measures.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. If the tree // is part of a random forest, only consider a percentage // of the candidate attributes at each split point if (MaxVariables > 0) { candidates = Vector.Sample(candidates, MaxVariables); } var scores = new double[candidates.Length]; var thresholds = new double[candidates.Length]; var partitions = new int[candidates.Length][][]; // For each attribute in the data set Parallel.For(0, scores.Length, ParallelOptions, i => { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i], out thresholds[i]); }); // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; var maxGainThreshold = thresholds[maxGainIndex]; // Mark this attribute as already used attributeUsageCount[maxGainAttribute]++; double[][] inputSubset; int[] outputSubset; // Now, create next nodes and pass those partitions as their responsibilities. if (tree.Attributes[maxGainAttribute].Nature == DecisionVariableKind.Discrete) { // This is a discrete nature attribute. We will branch at each // possible value for the discrete variable and call recursion. DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; // Create a branch for each possible value for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree) { Parent = root, Value = i + maxGainRange.Min, Comparison = ComparisonKind.Equal, }; inputSubset = input.Get(maxGainPartition[i]); outputSubset = output.Get(maxGainPartition[i]); split(children[i], inputSubset, outputSubset, height + 1); // recursion } root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else if (maxGainPartition.Length > 1) { // This is a continuous nature attribute, and we achieved two partitions // using the partitioning scheme. We will branch on two possible settings: // either the value is greater than a currently detected optimal threshold // or it is less. DecisionNode[] children = { new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.LessThanOrEqual }, new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.GreaterThan } }; // Create a branch for lower values inputSubset = input.Get(maxGainPartition[0]); outputSubset = output.Get(maxGainPartition[0]); split(children[0], inputSubset, outputSubset, height + 1); // Create a branch for higher values inputSubset = input.Get(maxGainPartition[1]); outputSubset = output.Get(maxGainPartition[1]); split(children[1], inputSubset, outputSubset, height + 1); root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else { // This is a continuous nature attribute, but all variables are equal // to a constant. If there is only a constant value as the predictor // and there are multiple output labels associated with this constant // value, there isn't much we can do. This node will be a leaf. // We will set the class label for this node as the // majority of the currently selected output classes. outputSubset = output.Get(maxGainPartition[0]); root.Output = Measures.Mode(outputSubset); } attributeUsageCount[maxGainAttribute]--; }
private void split(DecisionNode root, double[][] input, int[] output) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Statistics.Tools.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) { root.Output = output[0]; } return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. int predictors = attributes.Count(x => x == false); if (predictors == 0) { root.Output = Statistics.Tools.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. double[] scores = new double[predictors]; double[] entropies = new double[predictors]; double[] thresholds = new double[predictors]; int[][][] partitions = new int[predictors][][]; // Retrieve candidate attribute indices int[] candidates = new int[predictors]; for (int i = 0, k = 0; i < attributes.Length; i++) { if (!attributes[i]) { candidates[k++] = i; } } // For each attribute in the data set Parallel.For(0, scores.Length, i => { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i], out thresholds[i]); }); // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainEntropy = entropies[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; var maxGainThreshold = thresholds[maxGainIndex]; // Mark this attribute as already used attributes[maxGainAttribute] = true; double[][] inputSubset; int[] outputSubset; // Now, create next nodes and pass those partitions as their responsabilities. if (tree.Attributes[maxGainAttribute].Nature == DecisionAttributeKind.Discrete) { DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree) { Parent = root, Value = i + maxGainRange.Min, Comparison = ComparisonKind.Equal, }; inputSubset = input.Submatrix(maxGainPartition[i]); outputSubset = output.Submatrix(maxGainPartition[i]); split(children[i], inputSubset, outputSubset); // recursion } root.Branches = new DecisionBranchNodeCollection(maxGainAttribute, children); } else { DecisionNode[] children = { new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.LessThanOrEqual }, new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.GreaterThan } }; inputSubset = input.Submatrix(maxGainPartition[0]); outputSubset = output.Submatrix(maxGainPartition[0]); split(children[0], inputSubset, outputSubset); inputSubset = input.Submatrix(maxGainPartition[1]); outputSubset = output.Submatrix(maxGainPartition[1]); split(children[1], inputSubset, outputSubset); root.Branches = new DecisionBranchNodeCollection(maxGainAttribute, children); } attributes[maxGainAttribute] = false; }
void InitializePCpu() { int N = cc.c.N; const float DistanceScale = 100.0f; const float eps = 2.22e-16f; int bandSize = Math.Min(N, MaxGroupNumberHyp * GroupSizeHyp); PBuf = gpu.CreateBufferRW(bandSize * N, 4, 1); P2Buf = gpu.CreateBufferDynamic(bandSize * N, 4, 7); // dynamic buffer for fast uploading. Linked to Pcpu[] on HLSL. int blockSize = 128; // Calculate so many rows per dispatch. cpuP = new float[N][]; for (int i = 0; i < N; i++) { cpuP[i] = new float[N]; } using (var distanceBuf = gpu.CreateBufferRW(blockSize * N, 4, 0)) using (var stagingBuf = gpu.CreateStagingBuffer(distanceBuf)) using (var sd = gpu.LoadShader("TsneDx.PartialDistance2.cso")) { gpu.SetShader(sd); for (int iBlock = 0; iBlock < N; iBlock += blockSize) { cc.c.blockIdx = iBlock; cc.Upload(); gpu.Run(blockSize); int iBlock2 = Math.Min(iBlock + blockSize, N); int blockLen = (iBlock2 * (iBlock2 - 1) - iBlock * (iBlock - 1)) / 2; float[] ret = gpu.ReadRange <float>(stagingBuf, distanceBuf, blockLen); int idx = 0; for (int row = iBlock; row < iBlock2; row++) { Array.Copy(ret, idx, cpuP[row], 0, row); idx += row; } } } double distanceFactor = double.MinValue; MT.For(1, N, i => { float maxV = cpuP[i].Max(); lock (this) distanceFactor = Math.Max(distanceFactor, maxV); }); if (distanceFactor == 0) { throw new System.Exception("Distance metric degenerated: all components are zero."); } // Scale the distance to managable range [0, 100.0] to avoid degredation // with exp function. distanceFactor = DistanceScale / distanceFactor; MT.For(1, N, i => { for (int j = 0; j < i; j++) { cpuP[i][j] = (float)(cpuP[i][j] * distanceFactor); } }); MT.For(0, N, i => { for (int j = 0; j < i; j++) { cpuP[j][i] = cpuP[i][j]; } cpuP[i][i] = 0; }); int bSize = MaxGroupNumberHyp * GroupSizeHyp; using (var sd = gpu.LoadShader("TsneDx.Dist2Affinity.cso")) using (var stagingBuf = gpu.CreateStagingBuffer(PBuf)) { gpu.SetShader(sd); for (int iBlock = 0; iBlock < N; iBlock += bSize) { cc.c.blockIdx = iBlock; cc.Upload(); int iBlock2 = Math.Min(N, iBlock + bSize); using (var ws = gpu.NewWriteStream(PBuf)) for (int row = iBlock; row < iBlock2; row++) { ws.WriteRange(cpuP[row]); } gpu.Run(MaxGroupNumberHyp); using (var rs = gpu.NewReadStream(stagingBuf, PBuf)) for (int row = iBlock; row < iBlock2; row++) { rs.ReadRange(cpuP[row], 0, N); } } } double sum = 0; MT.For(0, N, i => { double sum2 = 0.0; for (int j = i + 1; j < N; j++) { cpuP[i][j] += cpuP[j][i]; sum2 += cpuP[i][j]; } lock (this) sum += sum2; }); if (sum == 0) { throw new System.Exception("Perplexity too small!"); } sum *= 2; MT.For(0, N, i => { for (int j = i + 1; j < N; j++) { cpuP[i][j] = (float)Math.Max(cpuP[i][j] / sum, eps); cpuP[j][i] = cpuP[i][j]; } cpuP[i][i] = 1.0f; }); }