/// <summary> /// Sets the Rneuron /// </summary> /// <param name="rneuron"></param> public void SetRneuronWithInputs(Rneuron rneuron) { var rneuronId = rneuron.ID; int cnt = 0; IComparer <RlmInputKey> distinctComparer = new RlmInputKeyDistinctComparer(); IComparer <RlmInputKey> linearComparer = new RlmInputKeyLinearComparer(); // TODO must implement repopulation of data arrays for loading network // build dynamic inputs foreach (var i in rneuron.Input_Values_Rneurons) { double inputDoubleValue = 0; if (i.DotNetType == typeof(bool).ToString()) { bool boolVal = Convert.ToBoolean(i.Value); inputDoubleValue = (boolVal) ? 1 : 0;; } else { inputDoubleValue = Convert.ToDouble(i.Value); } doubleInputs[cnt].Add(inputDoubleValue); results[cnt].Resize(doubleInputs[cnt].DataArray.Length); cnt++; } Rneurons.TryAdd(rneuronId, rneuron); rneuronIds.Add(rneuronId); }
/// <summary> /// Sets the Rneuron /// </summary> /// <param name="rneuron"></param> public void SetRneuronWithInputs(Rneuron rneuron) { var rneuronId = rneuron.ID; // add rneuron to cache Rneurons.TryAdd(rneuronId, rneuron); bool isFirstInput = true; RlmInputValue lastInputValue = null; int cnt = 0; IComparer <RlmInputKey> distinctComparer = new RlmInputKeyDistinctComparer(); IComparer <RlmInputKey> linearComparer = new RlmInputKeyLinearComparer(); // build dynamic inputs foreach (var i in rneuron.Input_Values_Reneurons) { RlmInputKey inputKey = new RlmInputKey() { Value = i.Value, InputNum = cnt, Type = i.InputType }; inputKey.DoubleValue = (i.InputType == Enums.RlmInputType.Linear) ? Convert.ToDouble(i.Value) : 0D; RlmInputValue inputVal = null; if (!isFirstInput) { if (lastInputValue.RelatedInputs == null) { lastInputValue.RelatedInputs = new SortedList <RlmInputKey, RlmInputValue>(i.InputType == Enums.RlmInputType.Linear ? linearComparer : distinctComparer); } if (!lastInputValue.RelatedInputs.TryGetValue(inputKey, out inputVal)) { inputVal = new RlmInputValue(); lastInputValue.RelatedInputs.Add(inputKey, inputVal); } lastInputValue = inputVal; } else { if (DynamicInputs == null) { DynamicInputs = new SortedList <RlmInputKey, RlmInputValue>(i.InputType == Enums.RlmInputType.Linear ? linearComparer : distinctComparer); } isFirstInput = false; if (!DynamicInputs.TryGetValue(inputKey, out inputVal)) { inputVal = new RlmInputValue(); DynamicInputs.Add(inputKey, inputVal); } lastInputValue = inputVal; } cnt++; } lastInputValue.RneuronId = rneuronId; }
//save rneuron public async void saveRneuron(Rneuron rneuron) { using (RlmDbEntities db = new RlmDbEntities(databaseName)) { try { if (networkLoaded) { Task.Delay(5000).Wait(); Rneuron _rneuron = db.Rneurons.Add(rneuron); _rneuron.Rnetwork_ID = networkID; foreach (var rn in _rneuron.Input_Values_Reneurons) { db.Input_Values_Reneurons.Add(rn); } await db.SaveChangesAsync(); } } catch (Exception ex) { RlmDbLogger.Error(ex, databaseName, "saveRneuron"); } } }
/// <summary> /// Gets existing Rneuron and creates a new one if not existing /// </summary> /// <param name="inputs">Inputs with value</param> /// <param name="rnetworkID">Current NetworkId</param> /// <returns></returns> public GetRneuronResult GetRneuronFromInputs(IEnumerable <RlmIOWithValue> inputs, long rnetworkID) { // generate key based on input values long rneuronId = Util.GenerateHashKey(inputs.Select(a => a.Value).ToArray()); // create new rneuron if not exists if (!Rneurons.ContainsKey(rneuronId)) { var rneuron = new Rneuron() { ID = rneuronId, Rnetwork_ID = rnetworkID }; int cnt = 0; foreach (var i in inputs) { // create IVR instance var ivr = new Input_Values_Rneuron() { ID = Util.GenerateHashKey(rneuronId, i.ID), Value = i.Value, Input_ID = i.ID, Rneuron_ID = rneuronId, DotNetType = i.DotNetType, InputType = i.Type }; rneuron.Input_Values_Rneurons.Add(ivr); double value; if (i.DotNetType == typeof(bool).ToString()) { bool boolVal = Convert.ToBoolean(i.Value); value = (boolVal) ? 1D : 0D; } else { value = Convert.ToDouble(ivr.Value); } doubleInputs[cnt].Add(value); results[cnt].Resize(doubleInputs[cnt].DataArray.Length); cnt++; } Rneurons.TryAdd(rneuronId, rneuron); rneuronIds.Add(rneuronId); retValGetRneuronFromInputs.Rneuron = rneuron; retValGetRneuronFromInputs.ExistsInCache = false; } else { retValGetRneuronFromInputs.Rneuron = Rneurons[rneuronId]; retValGetRneuronFromInputs.ExistsInCache = true; } return(retValGetRneuronFromInputs); }
internal static RlmCycleOutput CoreCycleProcess(RlmNetwork rnn_net, RlmCycle rnn_cyc, IEnumerable <Models.RlmIOWithValue> rnn_ins, RlmNetworkType rnnType, IEnumerable <Models.RlmIOWithValue> rnn_outs, double cyclescore, IEnumerable <RlmIdea> ideas = null, IEnumerable <long> excludeSolutions = null) { var memoryMgr = rnn_net.MemoryManager; // temp benchmark only //rnn_net.CurrentCycleCount++; // temp benhcmark only // Determine if any inputs are of Linear type bool hasLinearInputs = rnn_ins.Any(a => a.Type == RlmInputType.Linear); // update input momentums if (hasLinearInputs) { foreach (var item in rnn_ins) { if (item.Type == RlmInputType.Linear) { var inputMomentumObj = rnn_net.InputMomentums[item.ID]; inputMomentumObj.SetInputValue(Convert.ToDouble(item.Value)); item.InputMomentum = inputMomentumObj; } } } //Get rneuron GetRneuronResult rneuronFound = memoryMgr.GetRneuronFromInputs(rnn_ins, rnn_net.CurrentNetworkID); Rneuron neuron = rneuronFound.Rneuron; //Holds the solution instance GetSolutionResult solutionFound = new GetSolutionResult(); Solution solution = null; IEnumerable <Models.RlmIO> outputs = rnn_net.Outputs; bool completelyRandom = false; double randomnessValue = rnn_net.RandomnessCurrentValue; if (rnnType == RlmNetworkType.Supervised) { //Supervised, get solution and record ideal score solutionFound = memoryMgr.GetSolutionFromOutputs(rnn_outs); solution = solutionFound.Solution; cyclescore = IDEAL_SCORE; } else if (rnnType == RlmNetworkType.Unsupervised && randomnessValue > 0) { //TODO: This should be based upon the randomization factor double randomProbability = Util.GetRandomDoubleNumber(0, 100); bool random = randomProbability <= randomnessValue; //Idea //ToDo: Implement Ideas //The idea implementation will not be added until core functionality works. It is an "extra" and the network can learn without it. In fact, since it reduces load, we need //to test without it in place first. Otherwise networks that don't have an applicable "idea" may crash //System.Diagnostics.Debug.WriteLine("Threshold: " + randomnThreshold); long?bestSolutionId = null; if (!random) { // get best solution solution = memoryMgr.GetBestSolution(rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0); bestSolutionId = solution?.ID; if (solution == null) { completelyRandom = true; solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, bestSolutionId, ideas); } else { solutionFound.Solution = solution; solutionFound.ExistsInCache = true; } } else if (random && outputs.Count() > 1) { solution = memoryMgr.GetBestSolution(rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0); bestSolutionId = solution?.ID; completelyRandom = true; solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, bestSolutionId, ideas); } else { completelyRandom = true; solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, ideas: ideas); } solution = solutionFound.Solution; } else // Predict { solution = memoryMgr.GetBestSolution(rnn_ins, predict: true, predictLinearTolerance: rnn_net.PredictLinear, excludeSolutions: excludeSolutions); //db.GetBestSolution(rnn_net.CurrentNetworkID, new List<long>() { neuron.ID }, true); if (solution == null) { completelyRandom = true; solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs, ideas: ideas); solution = solutionFound.Solution; #region TODO cousin node search //// no solution found AND all inputs are Distinct //if (!hasLinearInputs) //{ // completelyRandom = true; // //solution = GetRandomSolutionFromOutput(db, rnn_net.CurrentNetworkID, outputs, false); // solutionFound = memoryMgr.GetRandomSolutionFromOutput(randomnessValue, outputs); //GetRandomSolutionFromOutput(db, rnn_net, outputs, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0); //} //else // has linear //{ // // TODO need to change the methods used below to MemoryManager // //// gets all the known inputs // //var knownInputs = DetermineKnownInputs(db, rnn_ins, rnn_net.CousinNodeSearchToleranceIncrement); // //if (knownInputs.Count > 0) // //{ // // // holds the top cases for each known input // // var topCases = new List<Case>(); // // foreach (var item in knownInputs) // // { // // // gets the top solution for the current input with incremental checks based on the linear bracket // // var topCase = GetBestKnownCase(db, item, rnn_net.CousinNodeSearchToleranceIncrement); // // if (topCase != null) // // { // // topCases.Add(topCase); // // } // // } // // // determine which Case has the highest score and get it's corresponding solution // // solution = topCases.OrderByDescending(a => a.Session.DateTimeStop) // // .ThenByDescending(a => a.CycleEndTime) // // .ThenByDescending(a => a.CycleScore) // // .ThenByDescending(a => a.Session.SessionScore) // // .Take(1) // // .Select(a => a.Solution) // // .FirstOrDefault(); // //} // //else // if no known inputs then we get solution randomly // //{ // // completelyRandom = true; // // //solution = GetRandomSolutionFromOutput(db, rnn_net.CurrentNetworkID, outputs, false); // // solution = GetRandomSolutionFromOutput(db, rnn_net, outputs, rnn_ins, (hasLinearInputs) ? rnn_net.LinearToleranceCurrentValue : 0); // //} //} #endregion //solutionFound.Solution = solution; //solutionFound.ExistsInCache = false; } else { solutionFound.Solution = solution; solutionFound.ExistsInCache = true; } } //Document score, solution in Case var newCase = RecordCase(rnn_cyc , rneuronFound , rnn_ins , rnn_outs , cyclescore , solutionFound , 0 //ToDo: Pass the current maturity factor setting , completelyRandom //ToDo: pass whether or not the result was completely randomly generated , 0 //ToDo: pass sequential count ); // set Current case reference rnn_net.CurrentCase = newCase; var cycleOutput = new RlmCycleOutput(newCase.ID, newCase.Rneuron_ID, newCase.Solution_ID, rnn_net.Outputs, solution.Output_Values_Solutions); cycleOutput.CompletelyRandom = completelyRandom; return(cycleOutput); }
/// <summary> /// Gets existing Rneuron and creates a new one if not existing /// </summary> /// <param name="inputs">Inputs with value</param> /// <param name="rnetworkID">Current NetworkId</param> /// <returns></returns> public GetRneuronResult GetRneuronFromInputs(IEnumerable <RlmIOWithValue> inputs, long rnetworkID) { GetRneuronResult retVal = new GetRneuronResult(); Rneuron rneuron = null; // generate key based on input values long rneuronId = Util.GenerateHashKey(inputs.Select(a => a.Value).ToArray()); // create new rneuron if not exists if (!Rneurons.TryGetValue(rneuronId, out rneuron)) { rneuron = new Rneuron() { ID = rneuronId, Rnetwork_ID = rnetworkID }; bool isFirstInput = true; RlmInputValue lastInputValue = null; int cnt = 0; IComparer <RlmInputKey> distinctComparer = new RlmInputKeyDistinctComparer(); IComparer <RlmInputKey> linearComparer = new RlmInputKeyLinearComparer(); foreach (var i in inputs) { // create IVR instance var ivr = new Input_Values_Rneuron() { ID = Util.GenerateHashKey(rneuronId, i.ID), Value = i.Value, Input_ID = i.ID, Rneuron_ID = rneuronId, DotNetType = i.DotNetType, InputType = i.Type }; rneuron.Input_Values_Reneurons.Add(ivr); RlmInputKey inputKey = new RlmInputKey() { Value = ivr.Value, InputNum = cnt, Type = i.Type }; inputKey.DoubleValue = (i.Type == Enums.RlmInputType.Linear) ? Convert.ToDouble(ivr.Value) : 0D; RlmInputValue inputVal = null; if (!isFirstInput) { if (lastInputValue.RelatedInputs == null) { lastInputValue.RelatedInputs = new SortedList <RlmInputKey, RlmInputValue>(i.Type == Enums.RlmInputType.Linear ? linearComparer : distinctComparer); } if (!lastInputValue.RelatedInputs.TryGetValue(inputKey, out inputVal)) { inputVal = new RlmInputValue(); lastInputValue.RelatedInputs.Add(inputKey, inputVal); } lastInputValue = inputVal; } else { if (DynamicInputs == null) { DynamicInputs = new SortedList <RlmInputKey, RlmInputValue>(i.Type == Enums.RlmInputType.Linear ? linearComparer : distinctComparer); } isFirstInput = false; if (!DynamicInputs.TryGetValue(inputKey, out inputVal)) { inputVal = new RlmInputValue(); DynamicInputs.Add(inputKey, inputVal); } lastInputValue = inputVal; } cnt++; } lastInputValue.RneuronId = rneuronId; Rneurons.TryAdd(rneuronId, rneuron); //rneuron_queue.Add(retVal); //if (Rneurons.TryAdd(rneuronId, retVal)) //{ //} //Rneurons2.Enqueue(retVal); //rneuron_queue.Add(retVal); retVal.Rneuron = rneuron; retVal.ExistsInCache = false; } else { retVal.Rneuron = rneuron; retVal.ExistsInCache = true; } return(retVal); }