/* some functions for invoking the RecognizeChooseApplyCycle above. That function is * protected so we invoke it through one of these four functions. This functions will * not work, however, if one has not yet initiated the generation process to establish * the fields of the Generation object. */ public candidate generateOneCandidate() { int[] numOfCalls = new int[numOfRuleSets]; /* this copy set is needed because array are reference types and the RCA cycle * will modify the numOfCalls inside of it. */ maxNumOfCalls.CopyTo(numOfCalls, 0); candidate newCand = seed.copy(); RecognizeChooseApplyCycle(newCand, seed.activeRuleSetIndex, numOfCalls); return(newCand); }
/// <summary> /// Calls one rule on candidate - the rule is determined by the choose function. /// </summary> /// <param name = "cand">The cand.</param> /// <param name = "startingRuleSet">The starting rule set.</param> /// <returns></returns> public virtual candidate CallOneRuleOnCandidate(candidate cand = null, int startingRuleSet = -1) { if (cand == null) { cand = Host; } if (startingRuleSet == -1) { startingRuleSet = cand.activeRuleSetIndex; } /* the RecognizeChooseApplyCycle requires an array of ruleSet limits, * since we only intend to make one call on the activeRuleSet we make * an array (it should initialize to all zeros) of the proper length * and set its one value at the activeRuleSetIndex to 1. */ var numOfCalls = new int[NumOfRuleSets]; numOfCalls[cand.activeRuleSetIndex] = 1; var newCand = cand.copy(); /* here the main cycle is invoked. First, we must pass a copy of the candidate * to the RCA cycle since the apply set will modify it, and then move the prevoius * state onto the prevStates under the candidate. It is not incorrect to state * merely the candidate here, but the prevStates will not be stored correctly.*/ RecognizeChooseApplyCycle(newCand, startingRuleSet, numOfCalls); return(newCand); }
private candidate GenerateCand() { candidate cand = null; while (cand == null) { cand = Seed.copy(); while (true) { cand = agent.ChooseAndApplyAnyOption(cand); if (cand == null) { Console.WriteLine("Fail, Rebuild"); break; } if (agent.IsTerminalCandidate(cand)) { //Console.WriteLine("Choose terminal rule."); break; } //Console.WriteLine("Choose non-terminal rule."); } } return(cand); }
/// <summary> /// Generates all neighbors of the current. /// </summary> /// <param name = "current">The current.</param> /// <param name = "IncludingParent">if set to <c>true</c> [including parent].</param> /// <param name = "MaxNumber">The max number.</param> /// <returns></returns> public virtual List <candidate> GenerateAllNeighbors(candidate current = null, Boolean IncludingParent = false, int MaxNumber = int.MaxValue) { if (current == null) { current = Host; } var rand = new Random(); var neighbors = new List <candidate>(); var options = Rulesets[current.activeRuleSetIndex].recognize(current.graph, InParallel); while (MaxNumber < options.Count) { var i = rand.Next(options.Count); options.RemoveAt(i); } if (IncludingParent) { var parent = current.copy(); parent.undoLastRule(); neighbors.Add(parent); } if (InParallel) { Parallel.ForEach(options, opt => { var child = current.copy(); SearchProcess.transferLmappingToChild(child.graph, current.graph, opt); opt.apply(child.graph, null); child.addToRecipe(opt); neighbors.Add(child); }); } else { foreach (var opt in options) { var child = current.copy(); SearchProcess.transferLmappingToChild(child.graph, current.graph, opt); opt.apply(child.graph, null); child.addToRecipe(opt); neighbors.Add(child); } } return(neighbors); }
/// <summary> /// Copies the candidate graph, transfers the L-mapping, and returns the resultant candidate. /// </summary> public candidate CopyAndApplyOption(option opt, candidate cand, bool doMinimize) { var newCand = cand.copy(); var newOpt = opt.copy(); SearchProcess.transferLmappingToChild(newCand.graph, cand.graph, newOpt); ApplyOption(newOpt, newCand, doMinimize); return(newCand); }
/// <summary> /// Generates one candidate. A simple function for invoking the RecognizeChooseApplyCycle. /// That function is protected so we invoke it through a function like this. /// </summary> /// <param name = "cand">The cand to build upon (if null, then the seed will be used).</param> /// <param name = "startingRuleSet">The starting rule set (if unspecified then the candidate's active ruleset will be used.</param> /// <returns></returns> public virtual candidate GenerateOneCandidate(candidate cand = null, int startingRuleSet = -1) { if (cand == null) { cand = Host; } if (startingRuleSet == -1) { startingRuleSet = cand.activeRuleSetIndex; } var numOfCalls = (int[])MaxNumOfCalls.Clone(); /* this copy set is needed because array are reference types and the RCA cycle * will modify the numOfCalls inside of it. */ var newCand = cand.copy(); RecognizeChooseApplyCycle(newCand, startingRuleSet, numOfCalls); return(newCand); }
protected override void Run() { Stack <candidate> candidates = new Stack <candidate>(); candidate current = null; Boolean found = false; candidates.Push(seedCandidate); while (!found && (candidates.Count != 0) && !SearchIO.terminateRequest) { current = candidates.Pop(); SearchIO.iteration = current.recipe.Count; SearchIO.miscObject = candidates.Count; if (isCurrentTheGoal(current)) { found = true; } else { int rsIndex = current.activeRuleSetIndex; List <option> ruleChoices = rulesets[rsIndex].recognize(current.graph); foreach (option opt in ruleChoices) { candidate child = current.copy(); transferLmappingToChild(child.graph, current.graph, opt.location); opt.apply(child.graph, null); child.addToRecipe(opt); candidates.Push(child); } } } SearchIO.addAndShowGraphWindow(current.graph, "cand1"); Save(settings.outputDirectory + "\\DFScandidate.xml", current); }
/// <summary> /// Returns whether the graph violates angle or carboxyl-blocking constraints. /// </summary> private static bool IsValidChild(candidate cand, option opt) { var newCand = cand.copy(); var newOpt = opt.copy(); SearchProcess.transferLmappingToChild(newCand.graph, cand.graph, newOpt); newOpt.apply(newCand.graph, null); var mol = OBFunctions.designgraphtomol(newCand.graph); var mapping = OBFunctions.findcarboxylates(mol); if (mapping.Count < 2) { return(true); } var carbA = mol.GetAtom(mapping[0][1]); // carbon in carboxylate var aA = mol.GetAtom(mapping[0][3]); // atom that the carbon connects to var carbB = mol.GetAtom(mapping[1][1]); var aB = mol.GetAtom(mapping[1][3]); var pAngle = OBFunctions.pairwiseangle(carbA, aA, carbB, aB); // angle between carboxylates return(!OBFunctions.carboxylatesBlocked(mol, aA, carbA, aB, carbB) && pAngle >= AngleFloor); }
private void Generate() { Console.WriteLine("ddddd!"); var agent = new Algorithms.Random(settings); var linkerSet = new HashSet <string>(); for (var e = 0; e < NUM_EPOCH; e++) { Console.WriteLine("Epoch: {0}", e); for (var t = 0; t < NUM_TRAIL; t++) { Console.WriteLine("Trail: {0}", t); for (var total_rule = TOTAL_RULE_MIN; total_rule < TOTAL_RULE_MAX + 1; total_rule++) { candidate cand = null; while (cand == null) { cand = Seed.copy(); Console.WriteLine("Total Intermediate Rules: {0}", total_rule); for (var step = 0; step < total_rule; step++) { cand = agent.ChooseAndApplyOption(cand); if (cand == null) { Console.WriteLine("Fail on step {0}", step + 1); break; } } if (cand == null) { continue; } //var carboxOpt = agent.ChooseAndApplyOption(cand); cand = agent.ChooseAndApplyCarboxOptionBestAngle(cand); //cand = agent.ChooseAndApplyCarboxOptionUsingEstimator(cand, computation, client, _runDirectory); if (cand == null) { Console.WriteLine("Fail on finding final carbox"); } } var candSmile = OBFunctions.moltoSMILES(OBFunctions.designgraphtomol(cand.graph)); var linkerName = AbstractAlgorithm.GetLinkerName(cand); //Console.WriteLine(candSmile); Console.WriteLine(linkerName); if (linkerSet.Contains(linkerName)) { total_rule--; continue; } linkerSet.Add(linkerName); var coeff = Path.Combine(_runDirectory, "data", "linker" + linkerName + ".coeff"); var lmpdat = Path.Combine(_runDirectory, "data", "linker" + linkerName + ".lmpdat"); agent.Converter.moltoUFF(OBFunctions.designgraphtomol(cand.graph), coeff, lmpdat, false, 100); double piority = 0; if (CARBOXTYPE == "estimator") { piority = -Convert.ToDouble(client.SendMessage("[Predict]" + " " + linkerName)); } else { piority = AbstractAlgorithm.Rand.NextDouble(); computation.CalculateFeature(linkerName); } //mutex.WaitOne(); jobBuffer.Add(linkerName, piority, e); //mutex.ReleaseMutex(); } } if (CARBOXTYPE == "estimator") { while (true) { var on_simulation = jobBuffer.Num_simulating(); if (on_simulation == 0) { break; } Console.WriteLine("Wait for current {0} linkers to finish simulation....", on_simulation); Thread.Sleep(10000); } client.SendMessage("[FitModel]"); } } allSubmitFlag = true; }
/// <summary> /// Generates all neighbors of the current. /// </summary> /// <param name = "current">The current.</param> /// <param name = "IncludingParent">if set to <c>true</c> [including parent].</param> /// <param name = "MaxNumber">The max number.</param> /// <returns></returns> public static List <candidate> GenerateAllNeighbors(candidate current, IList <ruleSet> Rulesets, Boolean IncludingParent = false, bool InParallel = false, bool includeStopCondition = false, int MaxNumber = int.MaxValue) { var rand = new Random(); var neighbors = new List <candidate>(); var ruleset = Rulesets[current.activeRuleSetIndex]; var options = ruleset.recognize(current.graph, InParallel); if (options.Count == 0) { var noRuleCandidate = current.copy(); noRuleCandidate.activeRuleSetIndex = ruleset.nextRuleSet(GenerationStatuses.NoRules); neighbors.Add(noRuleCandidate); return(neighbors); } while (MaxNumber < options.Count) { var i = rand.Next(options.Count); options.RemoveAt(i); } if (IncludingParent) { var parent = current.copy(); parent.undoLastRule(); neighbors.Add(parent); } if (InParallel) { Parallel.ForEach(options, opt => { var child = current.copy(); SearchProcess.transferLmappingToChild(child.graph, current.graph, opt); opt.apply(child.graph, null); child.addToRecipe(opt); neighbors.Add(child); }); } else { foreach (var opt in options) { var child = current.copy(); SearchProcess.transferLmappingToChild(child.graph, current.graph, opt); opt.apply(child.graph, null); child.addToRecipe(opt); neighbors.Add(child); if (opt.ruleNumber == ruleset.TriggerRuleNum) { child.activeRuleSetIndex = ruleset.nextRuleSet(GenerationStatuses.TriggerRule); } else { child.activeRuleSetIndex = ruleset.nextRuleSet(GenerationStatuses.Normal); } } } var stopCandidate = current.copy(); stopCandidate.activeRuleSetIndex = ruleset.nextRuleSet(GenerationStatuses.Choice); neighbors.Add(stopCandidate); return(neighbors); }
public static void runSearchProcess() { userDefinedGoals udg = new userDefinedGoals(); Form2 inputBox = new Form2(udg); //inputBox.ShowDialog(); ruleSet.loadAndCompileSourceFiles(rulesets, Program.settings.recompileRules, Program.settings.compiledparamRules, Program.settings.execDir); List <candidate> candidates = new List <candidate>(); candidate current = null; candidate seedCandidate = new candidate(seed, Program.settings.numOfRuleSets); Boolean found = false; candidates.Add(seedCandidate); GearEvaluator ge = new GearEvaluator(udg); Guidance.PNormProportionalPopulationSelection GuidanceApproach = new Guidance.PNormProportionalPopulationSelection(0, Guidance.optimize.minimize, true, true, 1); int maxPop = 10000; while (!found && (candidates.Count != 0)) { current = candidates[0]; candidates.RemoveAt(0); SearchIO.iteration = current.recipe.Count; //RECOGNIZE List <option> ruleChoices = rulesets[0].recognize(current.graph); SearchIO.miscObject = candidates.Count; // if (current.recipe.Count >= 2) { found = isCurrentTheGoal(current, udg); if (found == true) { ge.evalGT(current); break; } } //else current.f0 = double.PositiveInfinity; for (int i = 0; i != ruleChoices.Count; i++) { candidate child = current.copy(); ruleChoices = rulesets[0].recognize(child.graph); ruleChoices[i].apply(child.graph, null); child.addToRecipe(ruleChoices[i]); child.f0 = double.NaN; child.f1 = double.NaN; child.f2 = double.NaN; ge.evalGT(child); child.f3 = (child.f0) / 100 + child.f1; //1 efficiency //2 mass //3 combination addChildToSortedCandList(candidates, child, 3); //candidates.Add(child); } } Program.addAndShowGraphDisplay(current.graph, "Here is your gear train!!!"); candidate.saveToXml(current, "testTuned", settings.outputDirectory); }