void updateLog()
{
// １つ加える
var data = new Log.Data {
TimeStamp = this.CurrentTimeStamp, Longitude = this.Longitude, Latitude = this.Latitude
};
this.log.actualData.Add(data);
}
static int GetTotalNumSamples(Log.Data data)
{
int totalNumSamples = 0;
foreach (Log.Episode episode in data.Episodes)
{
totalNumSamples += episode.steps.Count - 1;
}
return(totalNumSamples);
}
public bool DrawRandomSample(Log.Data logData)
{
Log.Episode episode;
Random randomGenerator = new Random();
int episodeIndex = randomGenerator.Next() % logData.TotalNumEpisodes;
if (episodeIndex < logData.EvaluationEpisodes.Count)
{
episode = logData.EvaluationEpisodes[episodeIndex];
}
else
{
episode = logData.TrainingEpisodes[episodeIndex - logData.TrainingEpisodes.Count];
}
if (episode.steps.Count <= 1)
{
return(false);
}
int stepIndex = randomGenerator.Next() % (episode.steps.Count - 1);
Log.Step step = episode.steps[stepIndex]; //%(numSteps-1) because we need s and s_p
int dataOffset = 0;
//copy s
for (int i = 0; i < State.Length; i++)
{
State[i] = step.data[i];
}
//copy a
dataOffset = State.Length;
for (int i = 0; i < Action.Length; i++)
{
Action[i] = step.data[dataOffset + i];
}
//copy r
dataOffset += Action.Length;
for (int i = 0; i < Reward.Length; i++)
{
Reward[i] = step.data[dataOffset + i];
}
//copy s_p from next step
step = episode.steps[stepIndex + 1];
dataOffset = 0;
for (int i = 0; i < State_p.Length; i++)
{
State_p[i] = step.data[i];
}
return(true);
}
/// <summary>
/// Creates a Track object from a logged experimental unit and a list of reports
/// </summary>
/// <param name="expUnit">The logged experimental unit</param>
/// <param name="reports">The list of reports we want</param>
/// <returns></returns>
public static Track LoadTrackData(LoggedExperimentalUnitViewModel expUnit, List <Report> reports)
{
Log.Data Log = new Log.Data();
Log.Load(expUnit.LogFileName);
if (!Log.SuccessfulLoad || Log.TotalNumEpisodes == 0)
{
return(null);
}
Track track = new Track(expUnit.ForkValues, expUnit.LogFileName, expUnit.LogDescriptorFileName, expUnit.ExperimentFileName);
SeriesGroup dataSeries;
int variableIndex;
foreach (Report report in reports)
{
variableIndex = expUnit.GetVariableIndex(report.Variable);
switch (report.Type)
{
case ReportType.LastEvaluation:
Log.Episode lastEpisode = Log.EvaluationEpisodes[Log.EvaluationEpisodes.Count - 1];
dataSeries = new SeriesGroup(report);
Series series = LogFileUtils.GetVariableData(lastEpisode, report, variableIndex);
if (series != null)
{
dataSeries.AddSeries(series);
track.AddVariableData(report, dataSeries);
}
break;
case ReportType.EvaluationAverages:
track.AddVariableData(report
, LogFileUtils.GetAveragedData(Log.EvaluationEpisodes, report, variableIndex));
break;
case ReportType.AllEvaluationEpisodes:
case ReportType.AllTrainingEpisodes:
dataSeries = new SeriesGroup(report);
List <Log.Episode> episodes;
if (report.Type == ReportType.AllEvaluationEpisodes)
{
episodes = Log.EvaluationEpisodes;
}
else
{
episodes = Log.TrainingEpisodes;
}
foreach (Log.Episode episode in episodes)
{
Series subSeries = LogFileUtils.GetVariableData(episode, report, variableIndex);
if (subSeries != null)
{
subSeries.Id = episode.index.ToString();
dataSeries.AddSeries(subSeries);
}
}
track.AddVariableData(report, dataSeries);
break;
}
}
return(track);
}
static void Main(string[] args)
{
//Parse the input arguments
const string inputFolderArg = "dir=";
const string numSamplesArg = "num-samples=";
const string outputFileArg = "output-file=";
string inputFolder = null;
int numSamples = 0;
string outputFilename = null;
string outputBinaryFilename = null;
foreach (string arg in args)
{
if (arg.StartsWith(inputFolderArg))
{
inputFolder = arg.Substring(inputFolderArg.Length);
}
if (arg.StartsWith(numSamplesArg))
{
numSamples = int.Parse(arg.Substring(numSamplesArg.Length));
}
if (arg.StartsWith(outputFileArg))
{
outputFilename = arg.Substring(outputFileArg.Length);
}
}
//check all required arguments are set
if (inputFolder == null || numSamples == 0 || outputFilename == null)
{
Console.WriteLine("ERROR. Usage: SimionLogToOfflineTraining " + inputFolderArg + "<dir> " + numSamplesArg + "<numTuples> " + outputFileArg + "<outputFile>");
return;
}
//check/set correct file extensions to output files
if (!outputFilename.EndsWith(Extensions.SampleFileDescriptor))
{
outputFilename += Extensions.SampleFileDescriptor;
}
outputBinaryFilename = Herd.Utils.RemoveExtension(outputFilename, 2) + Extensions.SampleBinaryFile;
//Traverse all the log files
string[] logDescriptorFiles = Directory.GetFiles(inputFolder, "*" + Herd.Files.Extensions.LogDescriptor, SearchOption.AllDirectories);
int numFiles = logDescriptorFiles.Length;
if (numFiles == 0)
{
Console.WriteLine("ERROR. No log files found in the provided directory: " + inputFolder);
return;
}
int numDesiredSamplesPerFile = numSamples / numFiles;
//We use the first descriptor as the common descriptor used for tuples. We are assuming they all have the same variables. BEWARE!!
Log.Descriptor commonDescriptor = new Log.Descriptor(logDescriptorFiles[0]);
Sampler sampler = new Sampler(commonDescriptor);
int numSavedSamples = 0;
using (FileStream outputStream = File.Create(outputBinaryFilename))
{
BinaryWriter writer = new BinaryWriter(outputStream);
Console.WriteLine("STARTED: Drawing " + numSamples + " samples from log files in folder " + inputFolder);
foreach (string logDescriptorFilename in logDescriptorFiles)
{
Log.Descriptor logDescriptor = new Log.Descriptor(logDescriptorFilename);
string folder = Path.GetDirectoryName(logDescriptorFilename);
Log.Data data = new Log.Data();
data.Load(folder + "\\" + logDescriptor.BinaryLogFile);
if (data.SuccessfulLoad)
{
if (sampler.State.Length + sampler.Action.Length + sampler.Reward.Length ==
logDescriptor.StateVariables.Count + logDescriptor.ActionVariables.Count + logDescriptor.RewardVariables.Count)
{
int totalNumSamples = GetTotalNumSamples(data);
int actualNumSamples = Math.Min(totalNumSamples - 1, numDesiredSamplesPerFile);
double percentSampled = 100 * ((double)actualNumSamples / (double)totalNumSamples);
Console.Write("Log file " + Path.GetFileName(logDescriptorFilename) + ":");
for (int i = 0; i < actualNumSamples; i++)
{
if (sampler.DrawRandomSample(data))
{
sampler.SaveLastSampleToBinaryFile(writer);
numSavedSamples++;
}
}
Console.WriteLine(string.Format(" sampled ({0:0.00}%)", percentSampled));
}
else
{
Console.WriteLine("File " + logDescriptorFilename + "skipped (missmatched variables in log)");
}
}
}
}
//Shuffle the samples in the file
Console.WriteLine("Shuffling samples in file");
ShuffleSamplesInFile(outputBinaryFilename, sampler);
//Save the descriptor
if (numSavedSamples > 0)
{
sampler.SaveSampleFileDescriptor(outputFilename, Path.GetFileName(outputBinaryFilename), numSavedSamples);
Console.WriteLine("FINISHED: " + numSavedSamples + " samples were drawn from the log files and saved\nDescriptor: " + outputFilename + "\nBinary data: " + outputBinaryFilename);
}
}
