//create new network
public async void SaveNetwork(Rnetwork rnetwork, Input_Output_Type io_type, List <Input> inputs, List <Output> outputs)
{
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
try
{
//ready network for saving
Rnetwork _newNetwork = db.Rnetworks.Add(rnetwork);
//add inputs to io_type
foreach (Input input in inputs)
{
io_type.Inputs.Add(input);
}
//add outputs to io_type
foreach (Output output in outputs)
{
io_type.Outputs.Add(output);
}
//ready io_type for saving
Input_Output_Type _ioType = db.Input_Output_Types.Add(io_type);
//save to database
await db.SaveChangesAsync();
}
catch (Exception ex)
{
RlmDbLogger.Error(ex, databaseName, "SaveNetwork");
}
}
}
//Process new inputs/outputs during create new network
private object ProcessNewIO(Rnetwork net, RlmIO io, Boolean ProcessAsOutput = false)
{
object retVal = null;
Input_Output_Type iot;
//Create Type
iot = new Input_Output_Type()
{
ID = Util.GenerateHashKey(io.DotNetType), Name = io.DotNetType, DotNetTypeName = io.DotNetType
};
if (consoleDisplay)
{
Console.WriteLine("Creating new Input_Output_Type: " + io.DotNetType);
}
if (!ProcessAsOutput)
{
//ToDo: Check for unique names
//Create Input
Input newio = new Input()
{
ID = Util.GenerateHashKey(io.Name), Name = io.Name, Rnetwork_ID = net.ID, Input_Output_Type_ID = iot.ID, Input_Output_Type = iot, Min = io.Min, Max = io.Max, Type = io.Type
};
io.ID = newio.ID;
retVal = newio;
if (consoleDisplay)
{
Console.WriteLine("Create new Input: " + newio.Name);
}
}
else
{
//ToDo: Check for unique names
//Create Output
Output newio = new Output()
{
ID = Util.GenerateHashKey(io.Name), Name = io.Name, Rnetwork_ID = net.ID, Input_Output_Type_ID = iot.ID, Input_Output_Type = iot, Min = io.Min, Max = io.Max
};
io.ID = newio.ID;
retVal = newio;
if (consoleDisplay)
{
Console.WriteLine("Create new Output: " + newio.Name);
}
}
return(retVal);
}
/// <summary>
/// Save the new network and send it to a task. It also starts the database workers
/// </summary>
/// <param name="rnetwork"></param>
/// <param name="io_types"></param>
/// <param name="inputs"></param>
/// <param name="outputs"></param>
/// <param name="rnn_net"></param>
public void NewNetwork(Rnetwork rnetwork, List <Input_Output_Type> io_types, List <Input> inputs, List <Output> outputs, IRlmNetwork rnn_net)
{
//todo: rnn dbmanager and save
dbSavingTime.Start();
RlmDbLogger.Info("\n" + string.Format("[{0:G}]: Started saving data for {1}...", DateTime.Now, Network.DatabaseName), Network.DatabaseName);
Task t1 = Task.Run(() =>
{
rlmDb.SaveNetwork(rnetwork, io_types, inputs, outputs, rnn_net);
});
t1.Wait();
StartRlmDbWorkers();
}
public void SaveNetwork(Rnetwork rnetwork, List <Input_Output_Type> io_types, List <Input> inputs, List <Output> outputs, IRlmNetwork rnn_net)
{
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
try
{
//ready network for saving
Rnetwork _newNetwork = db.Rnetworks.Add(rnetwork);
foreach (var _in in inputs)
{
Input_Output_Type _iotype = io_types.FirstOrDefault(a => a.DotNetTypeName == _in.Input_Output_Type.DotNetTypeName);
_in.Input_Output_Type = _iotype;
db.Inputs.Add(_in);
}
foreach (var _out in outputs)
{
Input_Output_Type _iotype = io_types.FirstOrDefault(a => a.DotNetTypeName == _out.Input_Output_Type.DotNetTypeName);
_out.Input_Output_Type = _iotype;
db.Outputs.Add(_out);
}
//save to database
db.SaveChanges();
rlm = _newNetwork;
networkID = _newNetwork.ID;
networkLoaded = true;
rnn_net.MemoryManager.InitStorage(inputs, outputs);
}
catch (Exception ex)
{
networkLoaded = false;
RlmDbLogger.Error(ex, databaseName, "SaveNetwork");
}
}
}
/// <summary>
/// Save created network
/// </summary>
/// <param name="rnetwork">current rnetwork</param>
/// <param name="io_type">type of input and output</param>
/// <param name="inputs">List of inputs</param>
/// <param name="outputs">List of outputs</param>
public void NewNetwork(Rnetwork rnetwork, Input_Output_Type io_type, List <Input> inputs, List <Output> outputs)
{
//todo: rnn dbmanager and save
rlmDb.SaveNetwork(rnetwork, io_type, inputs, outputs);
double r = 1.0;
double s = 1.0;
foreach (var input in inputs)
{
r *= input.Max;
}
rneuronsBoundedCapacity = Convert.ToInt32(r);
foreach (var output in outputs)
{
s *= output.Max;
}
solutionsBoundedCapacity = Convert.ToInt32(s);
}
/// <summary>
/// Save created network
/// </summary>
/// <param name="rnetwork">current rnetwork</param>
/// <param name="io_type">type of input and output</param>
/// <param name="inputs">List of inputs</param>
/// <param name="outputs">List of outputs</param>
public void NewNetwork(Rnetwork rnetwork, Input_Output_Type io_type, List <Input> inputs, List <Output> outputs)
{
//todo: rnn dbmanager and save
rlmDb.SaveNetwork(rnetwork, io_type, inputs, outputs);
double r = 1.0;
double s = 1.0;
foreach (var input in inputs)
{
r *= input.Max;
}
rneuronsBoundedCapacity = Convert.ToInt32(r);
foreach (var output in outputs)
{
s *= output.Max;
}
solutionsBoundedCapacity = Convert.ToInt32(s);
//Rneurons = new ConcurrentDictionary<long, Rneuron>(iConcurrencyLevel, rneuronsBoundedCapacity);
//Solutions = new ConcurrentDictionary<long, Solution>(iConcurrencyLevel, solutionsBoundedCapacity);
}
/// <summary>
/// Sets up a new network and sets the network as current network to use in training.
/// </summary>
/// <param name="name">Your preferred network name</param>
/// <param name="inputs">List of input types for your created network</param>
/// <param name="outputs">List of output types for your created network</param>
public void NewNetwork(string name, IEnumerable <RlmIO> inputs, IEnumerable <RlmIO> outputs)
{
//Create new network
Rnetwork newnet = new Rnetwork {
ID = Util.GenerateHashKey(name), Name = name, DateTimeCreated = DateTime.Now
};
CurrentNetworkID = newnet.ID;
CurrentNetworkName = newnet.Name;
// initialize Case Order
CaseOrder = 0;
Console.WriteLine("Create new network: " + newnet.Name);
//Inputs
var inputsForDb = new List <Input>();
var outputsForDb = new List <Output>();
var ioTypesForDb = new List <Input_Output_Type>();
int count = 0;
foreach (RlmIO io in inputs)
{
count++;
var newio = ProcessNewIO(newnet, io, false) as Input;
Input newin = new Input()
{
HashedKey = newio.HashedKey, ID = newio.ID, Input_Output_Type = newio.Input_Output_Type, Input_Output_Type_ID = newio.Input_Output_Type_ID, Max = newio.Max, Min = newio.Min, Name = newio.Name, Input_Values_Reneurons = newio.Input_Values_Reneurons, Rnetwork = newio.Rnetwork, Rnetwork_ID = newio.Rnetwork_ID, Type = newio.Type, Order = count
};
inputsForDb.Add(newin);
InputMomentums.Add(newin.ID, new RlmInputMomentum()
{
InputID = newin.ID
});
if (!ioTypesForDb.Any(a => a.DotNetTypeName == newio.Input_Output_Type.DotNetTypeName))
{
ioTypesForDb.Add(newin.Input_Output_Type);
newio.Input_Output_Type = null;
}
}
Inputs = inputs;
//Outputs
count = 0;
foreach (RlmIO io in outputs)
{
count++;
var newio = ProcessNewIO(newnet, io, true) as Output;
Output newout = new Output()
{
HashedKey = newio.HashedKey, ID = newio.ID, Input_Output_Type = newio.Input_Output_Type, Input_Output_Type_ID = newio.Input_Output_Type_ID, Max = newio.Max, Min = newio.Min, Name = newio.Name, Output_Values_Solutions = newio.Output_Values_Solutions, Rnetwork = newio.Rnetwork, Rnetwork_ID = newio.Rnetwork_ID, Order = count
};
outputsForDb.Add(newout);
if (!ioTypesForDb.Any(a => a.DotNetTypeName == newio.Input_Output_Type.DotNetTypeName))
{
ioTypesForDb.Add(newout.Input_Output_Type);
newio.Input_Output_Type = null;
}
// add dynamic output collection
MemoryManager.DynamicOutputs.TryAdd(newio.ID, new HashSet <SolutionOutputSet>());
}
Outputs = outputs;
SessionCountInitial = SessionCount;
//create new network
MemoryManager.NewNetwork(newnet, ioTypesForDb, inputsForDb, outputsForDb, this);
}
//load network
public LoadRnetworkResult LoadNetwork(string name, IRlmNetwork rnetwork)
{
var retVal = new LoadRnetworkResult();
IRlmNetwork rnn = rnetwork;
List <Input> inputs = new List <Input>();
List <Output> outputs = new List <Output>();
var watch = new Stopwatch();
watch.Start();
Rnetwork network;
try
{
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
//find network by name
network = db.Rnetworks.FirstOrDefault(a => a.Name == name);
}
if (network == null)
{
//Throw an error
Console.WriteLine("Network name '" + name + "' does not exist in the database:" + databaseName);
}
else
{
this.rlm = network;
// set rnetwork details
retVal.CurrentNetworkId = networkID = this.rlm.ID;
retVal.CurrentNetworkName = this.rlm.Name;
List <Input> rnnInputs = null;
List <Output> rnnOutputs = null;
var tasks = new List <Task>();
int taskCnt = Environment.ProcessorCount / 2;
int batchSizeRn = 0;
int batchSizeIvr = 0;
var rnCountTask = Task.Run(() =>
{
Stopwatch cntWatch = new Stopwatch();
cntWatch.Start();
var subTasks = new Task[3];
int totalInputs = 0;
int totalRneurons = 0;
int totalIvrs = 0;
subTasks[0] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalInputs = ctx.Inputs.Count();
}
});
subTasks[1] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalRneurons = ctx.Rneurons.Count();
}
});
subTasks[2] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalIvrs = ctx.Input_Values_Reneurons.Count();
}
});
Task.WaitAll(subTasks);
batchSizeRn = Convert.ToInt32(Math.Ceiling(totalRneurons / (double)taskCnt));
batchSizeIvr = Convert.ToInt32(Math.Ceiling(totalIvrs / (double)taskCnt));
while (batchSizeIvr % totalInputs != 0)
{
batchSizeIvr++;
}
cntWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Count elapsed: {cntWatch.Elapsed}");
});
tasks.Add(rnCountTask);
var bestSolTask = Task.Run(() =>
{
IEnumerable <BestSolution> bestSolutions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
bestSolutions = ctx.Database.SqlQuery <BestSolution>(@"
SELECT
main.[Rneuron_ID] as [RneuronId],
main.[Solution_ID] as [SolutionId],
MAX(main.[CycleScore]) as [CycleScore],
MAX(sess.[SessionScore]) as [SessionScore],
MAX(main.[CycleEndTime]) as [CycleEndTime]
FROM [Cases] main
INNER JOIN [Sessions] sess ON main.[Session_ID] = sess.[ID]
GROUP BY main.[Rneuron_ID], main.[Solution_ID]").ToList();
}
if (bestSolutions != null)
{
foreach (var item in bestSolutions)
{
rnetwork.MemoryManager.SetBestSolution(item);
}
}
});
tasks.Add(bestSolTask);
var inputTask = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
// get inputs
rnnInputs = ctx.Inputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
}
retVal.Inputs = rnetwork.Inputs = rnnInputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max,
Type = a.Type
});
rnetwork.InputMomentums.Clear();
foreach (var item in rnetwork.Inputs)
{
if (item.Type == Enums.RlmInputType.Linear)
{
rnetwork.InputMomentums.Add(item.ID, new RlmInputMomentum()
{
InputID = item.ID
});
}
}
retVal.InputMomentums = rnetwork.InputMomentums;
});
tasks.Add(inputTask);
var outputTask = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
// get outputs
rnnOutputs = ctx.Outputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
}
retVal.Outputs = rnetwork.Outputs = rnnOutputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max
});
foreach (var output in rnetwork.Outputs)
{
// add dynamic output collection
rnetwork.MemoryManager.DynamicOutputs.TryAdd(output.ID, new HashSet <SolutionOutputSet>());
}
});
tasks.Add(outputTask);
var sessionsTask = Task.Run(() =>
{
IEnumerable <Session> sessions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
// get sessions and save to MemoryManager cache
sessions = ctx.Sessions.OrderBy(a => a.DateTimeStart).ToList();
// set CaseOrder to the last case saved in db
retVal.CaseOrder = ctx.Cases.OrderByDescending(a => a.Order).Select(a => a.Order).FirstOrDefault();
}
if (sessions != null)
{
//set sessions count
retVal.SessionCount = sessions.Count();
foreach (var item in sessions)
{
rnetwork.MemoryManager.Sessions.TryAdd(item.ID, item);
}
}
});
tasks.Add(sessionsTask);
var rneuronsTask = Task.WhenAll(inputTask, rnCountTask).ContinueWith((t) =>
{
Stopwatch rn_sw = new Stopwatch();
rn_sw.Start();
var subTasks = new List <Task>();
// made input dictionary to help in setting the Dynamic inputs
var inputDic = rnnInputs.ToDictionary(a => a.ID, a => a);
var rneurons = new ConcurrentBag <Rneuron>();
var ivrs = new ConcurrentDictionary <long, List <Input_Values_Rneuron> >();
//IEnumerable<Rneuron> rneurons = null;
Stopwatch subProcessWatch = new Stopwatch();
subProcessWatch.Start();
for (int i = 0; i < taskCnt; i++)
{
int batchNum = i;
subTasks.Add(Task.Run(() =>
{
Rneuron[] results;
using (var ctx = new RlmDbEntities(databaseName))
{
results = ctx.Rneurons.OrderBy(a => a.ID).Skip(batchNum * batchSizeRn).Take(batchSizeRn).ToArray();
}
foreach (var item in results)
{
rneurons.Add(item);
}
}));
subTasks.Add(Task.Run(() =>
{
Input_Values_Rneuron[] results;
using (var ctx = new RlmDbEntities(databaseName))
{
results = ctx.Input_Values_Reneurons.OrderBy(a => a.Rneuron_ID).Skip(batchNum * batchSizeIvr).Take(batchSizeIvr).ToArray();
}
foreach (var item in results.GroupBy(a => a.Rneuron_ID))
{
ivrs.TryAdd(item.Key, item.ToList());
}
}));
}
Task.WaitAll(subTasks.ToArray());
subProcessWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Get data: {subProcessWatch.Elapsed}");
subTasks.Clear();
subProcessWatch.Restart();
for (int i = 0; i < taskCnt; i++)
{
int batchNum = i;
subTasks.Add(Task.Run(() =>
{
//Stopwatch sw = new Stopwatch();
//sw.Start();
//IEnumerable<Rneuron> rneurons = null;
//using (var ctx = new RlmDbEntities(databaseName))
//{
// rneurons = ctx.Rneurons
// .Include(a => a.Input_Values_Reneurons)
// .OrderBy(a => a.ID)
// .Skip(batchNum * batchSizeRn)
// .Take(batchSizeRn)
// .ToList();
//}
//sw.Stop();
//System.Diagnostics.Debug.WriteLine($"Task: {Task.CurrentId}, Get Data: {sw.Elapsed}");
//sw.Restart();
//sw.Start();
foreach (var item in rneurons.Skip(batchNum * batchSizeRn).Take(batchSizeRn))
{
// set input type and dotnettype
item.Input_Values_Reneurons = ivrs[item.ID];
foreach (var ivr in item.Input_Values_Reneurons)
{
var input = inputDic[ivr.Input_ID];
ivr.InputType = input.Type;
ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
ivr.Input = input;
}
item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
rnetwork.MemoryManager.SetRneuronWithInputs(item);
}
//sw.Stop();
//System.Diagnostics.Debug.WriteLine($"Task: {Task.CurrentId}, Process Data: {sw.Elapsed}");
}));
}
/** old batching code
* int totalRneurons = db.Rneurons.Count();
* int pageCount = 100;
* var helper = new StaticPagedList<Rneuron>(
* Enumerable.Empty<Rneuron>(), 1, pageCount, totalRneurons);
* Parallel.For(1, helper.PageCount + 1, i =>
* {
*
* using (var rdb = new RlmDbEntities(databaseName))
* {
* var data = rdb.Rneurons.Include(a => a.Input_Values_Reneurons).OrderBy(u => u.ID).ToPagedList(i, helper.PageSize).ToList();
*
* foreach (var item in data)
* {
* // set input type and dotnettype
* foreach (var ivr in item.Input_Values_Reneurons)
* {
* var input = inputDic[ivr.Input_ID];
* ivr.InputType = input.Type;
* ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
* ivr.Input = input;
* }
*
* item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
*
* rnetwork.MemoryManager.SetRneuronWithInputs(item);
* }
* }
* });
*
* if (rneurons != null)
* {
* foreach (var item in rneurons)
* {
* // set input type and dotnettype
* foreach (var ivr in item.Input_Values_Reneurons)
* {
* var input = inputDic[ivr.Input_ID];
* ivr.InputType = input.Type;
* ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
* ivr.Input = input;
* }
*
* item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
*
* rnetwork.MemoryManager.SetRneuronWithInputs(item);
* }
* } */
Task.WaitAll(subTasks.ToArray());
subProcessWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Process data: {subProcessWatch.Elapsed}");
rn_sw.Stop();
System.Diagnostics.Debug.WriteLine($"Total rneuron task elapsed: {rn_sw.Elapsed}");
;
});
tasks.Add(rneuronsTask);
var solutionTask = outputTask.ContinueWith((t) =>
{
IEnumerable <Solution> solutions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
// get solutions and save to MemoryManager cache
solutions = ctx.Solutions.Include(a => a.Output_Values_Solutions).ToList();
}
if (solutions != null)
{
foreach (var item in solutions)
{
rnetwork.MemoryManager.SetSolutionWithOutputs(item);
}
}
});
tasks.Add(solutionTask);
Task.WaitAll(tasks.ToArray());
retVal.Loaded = true;
}
}
catch (Exception ex)
{
RlmDbLogger.Error(ex, databaseName, "LoadNetwork");
}
watch.Stop();
System.Diagnostics.Debug.WriteLine($"Load Network Elapsed: {watch.Elapsed}");
return(retVal);
}
//load network
public LoadRnetworkResult LoadNetwork(string name, IRlmNetwork rnetwork)
{
var retVal = new LoadRnetworkResult();
IRlmNetwork rnn = rnetwork;
List <Input> inputs = new List <Input>();
List <Output> outputs = new List <Output>();
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
try
{
//find network by name
var network = from net in db.Rnetworks
where net.Name.ToLower() == name.ToLower()
select net;
if (network.Count() == 0)
{
//Throw an error
Console.WriteLine("Network name '" + name + "' does not exist in the database:" + db.Database.Connection.ToString());
}
else
{
var rnetworkFromDb = network.First <Rnetwork>();
this.rlm = rnetworkFromDb;
// set rnetwork details
retVal.CurrentNetworkId = networkID = this.rlm.ID;
retVal.CurrentNetworkName = this.rlm.Name;
// get inputs
var rnnInputs = db.Inputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
rnetwork.Inputs = rnnInputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max,
Type = a.Type
});
rnetwork.InputMomentums.Clear();
foreach (var item in rnetwork.Inputs)
{
if (item.Type == Enums.RlmInputType.Linear)
{
rnetwork.InputMomentums.Add(item.ID, new RlmInputMomentum()
{
InputID = item.ID
});
}
}
// get outputs
var rnnOutputs = db.Outputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
rnetwork.Outputs = rnnOutputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max
});
foreach (var output in rnetwork.Outputs)
{
// add dynamic output collection
rnetwork.MemoryManager.DynamicOutputs.TryAdd(output.ID, new HashSet <SolutionOutputSet>());
}
// initialize MemoryManager dictionaries (Rneurons, Solutions, etc...)
//rnetwork.MemoryManager.InitStorage(rnetwork.Inputs.Select(a =>
//{
// return new Input
// {
// ID = a.ID,
// Max = a.Max,
// Min = a.Min,
// Name = a.Name,
// Rnetwork_ID = rnetwork.CurrentNetworkID,
// Type = a.Type
// };
//}).ToList(), rnetwork.Outputs.Select(a => {
// return new Output
// {
// ID = a.ID,
// Max = a.Max,
// Min = a.Min,
// Name = a.Name,
// Rnetwork_ID = rnetwork.CurrentNetworkID
// };
//}).ToList());
// get sessions and save to MemoryManager cache
var sessions = db.Sessions.OrderBy(a => a.DateTimeStart).ToList();
foreach (var item in sessions)
{
rnetwork.MemoryManager.Sessions.TryAdd(item.ID, item);
}
//set sessions count
retVal.SessionCount = sessions.Count;
// set CaseOrder to the last case saved in db
var lastCase = db.Cases.OrderByDescending(a => a.Order).FirstOrDefault();
if (lastCase != null)
{
retVal.CaseOrder = lastCase.Order;
}
// made input dictionary to help in setting the Dynamic inputs
var inputDic = rnnInputs.ToDictionary(a => a.ID, a => a);
// get Rneurons and save to MemoryManager cache
//var rneurons = db.Rneurons.Include(a => a.Input_Values_Reneurons).ToList();
//batching
int totalRneurons = db.Rneurons.Count();
int pageCount = 100;
var helper = new StaticPagedList <Rneuron>(
Enumerable.Empty <Rneuron>(), 1, pageCount, totalRneurons);
Parallel.For(1, helper.PageCount + 1, i =>
{
using (var rdb = new RlmDbEntities(databaseName))
{
var data = rdb.Rneurons.Include(a => a.Input_Values_Reneurons).OrderBy(u => u.ID).ToPagedList(i, helper.PageSize).ToList();
foreach (var item in data)
{
// set input type and dotnettype
foreach (var ivr in item.Input_Values_Reneurons)
{
var input = inputDic[ivr.Input_ID];
ivr.InputType = input.Type;
ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
ivr.Input = input;
}
item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
rnetwork.MemoryManager.SetRneuronWithInputs(item);
}
}
});
//end batching
//foreach (var item in rneurons)
//{
// // set input type and dotnettype
// foreach (var ivr in item.Input_Values_Reneurons)
// {
// var input = inputDic[ivr.Input_ID];
// ivr.InputType = input.Type;
// ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
// ivr.Input = input;
// }
// item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
// rnetwork.MemoryManager.SetRneuronWithInputs(item);
//}
// get solutions and save to MemoryManager cache
var solutions = db.Solutions.Include(a => a.Output_Values_Solutions).ToList();
foreach (var item in solutions)
{
rnetwork.MemoryManager.SetSolutionWithOutputs(item);
}
// get best solutions and save to MemoryManager cache
//var solCount = db.Database.SqlQuery<Int32>(@"SELECT COUNT(*) FROM(SELECT
// main.[Rneuron_ID] as [RneuronId],
// main.[Solution_ID] as [SolutionId],
// MAX(main.[CycleScore]) as [CycleScore],
// MAX(sess.[SessionScore]) as [SessionScore],
// MAX(main.[CycleEndTime]) as [CycleEndTime]
// FROM[Cases] main
// INNER JOIN[Sessions] sess ON main.[Session_ID] = sess.[ID]
// GROUP BY main.[Rneuron_ID], main.[Solution_ID]) AS a").First();
var bestSolutions = db.Database.SqlQuery <BestSolution>(@"
SELECT
main.[Rneuron_ID] as [RneuronId],
main.[Solution_ID] as [SolutionId],
MAX(main.[CycleScore]) as [CycleScore],
MAX(sess.[SessionScore]) as [SessionScore],
MAX(main.[CycleEndTime]) as [CycleEndTime]
FROM [Cases] main
INNER JOIN [Sessions] sess ON main.[Session_ID] = sess.[ID]
GROUP BY main.[Rneuron_ID], main.[Solution_ID]")
.ToList();
foreach (var item in bestSolutions)
{
rnetwork.MemoryManager.SetBestSolution(item);
}
retVal.Loaded = true;
}
}
catch (Exception ex)
{
RlmDbLogger.Error(ex, databaseName, "LoadNetwork");
}
}
return(retVal);
}
