public void SaveEpisode(double reward, bool win, int steps, double epsilon, double alpha)
{
EpisodeData episode = new EpisodeData(ord, reward, win, steps, epsilon, alpha);
trainingEps_.Add(episode);
ord++;
}
private void ClearEpData()
{
speedSum = 0;
epData = new EpisodeData();
timeSteps = 0;
_checkpointManager.epTime = 0;
epData.wallHit = 0;
epData.collidedWith = "";
distanceCovered = 0;
avgSpeed = 0;
maxSpeed = 0;
epData.totalReward = 0;
_checkpointManager.rewardFromCheckpoints = 0;
_checkpointManager.rewardFromFinaCheckpoint = 0;
_checkpointManager.rewardFromTimeLimit = 0;
rewardFromWall = 0;
rewardFromSpeed = 0;
rewardFromTime = 0;
rewardFromBrakes = 0;
}
public void AddEpDataTolist(EpisodeData epData)
{
epsData.Add(epData);
var jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(epsData, Formatting.Indented);
fullPath = SAVE_FOLDER + fileName;
File.WriteAllText(fullPath, jsonData);
}
private EpisodeBehavior CreateNewEpisodeBox(EpisodeData data, Transform episodesTransform)
{
GameObject box = GameObject.Instantiate(MainScript.Instance.EpisodePrefab);
box.name = data.Season + "." + data.Episode + ":" + data.Title;
EpisodeBehavior behavior = box.GetComponent <EpisodeBehavior>();
behavior.Data = data;
behavior.Series = this;
box.transform.SetParent(episodesTransform, false);
return(behavior);
}
private void CreateShowList(EpisodeData episodeData, List <string> subjectLines)
{
var sb = new StringBuilder();
sb.AppendLine($"Series: {episodeData.Series.Title}");
sb.AppendLine();
sb.AppendLine($"Episode Title: {episodeData.Episode.Title}");
sb.AppendLine();
sb.AppendLine($"Episode Number: {episodeData.Episode.EpisodeNumber}");
sb.AppendLine();
subjectLines.Add(sb.ToString());
}
// Update is called once per frame
void Update()
{
KeyInputHandler();
if (!sliding && !timeLineAsset.paused && timeLineAsset.currentScene < (int)slider.value)
{
timeLineAsset.timer = timeLineAsset.timer + 10f * Time.deltaTime;
timeLineAsset.currentScene = (int)timeLineAsset.timer;
EpisodeData epiData = CalculateEpisodeData(timeLineAsset.currentScene);
timeLineAsset.currentSeason = epiData.seasonIndex;
timeLineAsset.currentEpisode = epiData.episodeIndex;
expisodeCounter.text = String.Format("Season {0}, Episode {1}, Scene {2}/{3}", epiData.seasonIndex + 1, epiData.episodeIndex + 1, CalculateSceneProgrerss(timeLineAsset.currentScene) + 1, timeLineAsset.scenesInEachEpisode[CalculateEpiIndex(timeLineAsset.currentScene)]);
// if (timeLineAsset.currentScene == (int)slider.value)
// {
// sliding = true;
// }
}
}
private EpisodeData CalculateEpisodeData(int sceneIndex)
{
EpisodeData epiData = new EpisodeData(0, 0);
int epiIndex = CalculateEpiIndex(sceneIndex);
int tmp = 0;
for (int i = 0; i < seasons.Length; i++)
{
tmp += seasons[i].Count;
if (epiIndex < tmp)
{
epiData.seasonIndex = i;
epiData.episodeIndex = seasons[i].Count - (tmp - epiIndex);
return(epiData);
}
}
return(epiData);
}
public BusinessLayer.Entities.EpisodeData TranslateEpisodeDataGPToLocal(Generated.ResultEpisodeData gpRes)
{
EpisodeData localRes = new EpisodeData();
try
{
if (gpRes != null)
{
localRes = new EpisodeData(); // Objecto local não tem atributos
}
}
catch (Exception ex)
{
Debug.WriteLine("Erro a realizar o convert de EpisodeData");
return(localRes);
}
return(localRes);
}
private void addEpisodeData(int season, int episode, string url, bool hd)
{
EpisodeData newEpisode = new EpisodeData(season, episode, url, hd);
if (episodeList.Contains(newEpisode))
{
if (hd && !newEpisode.HasHD())
{
newEpisode.SetURL(url, true);
}
if (!hd && newEpisode.GetURL() == null)
{
newEpisode.SetURL(url);
}
}
else
{
episodeList.Add(newEpisode);
}
}
public void EndRun()
{
// Construct file string in memory
StringBuilder sb = new StringBuilder();
sb.AppendFormat("epsilon: {0}, {1}, {2}", agent_.startEpsilon, agent_.endEpsilon, agent_.epsilonDecay).AppendLine();
sb.AppendFormat("alpha: {0}, {1}, {2}", agent_.startLearningRate, agent_.endLearningRate, agent_.learningDecay).AppendLine();
sb.AppendFormat("gamma: {0}", agent_.gamma).AppendLine();
sb.AppendFormat("training_time: {0}", DateTime.Now - startTime_).AppendLine();
sb.AppendFormat("training_episodes: {0}", trainingEps_.Count).AppendLine();
sb.AppendFormat("validation_episodes: {0}", validationEps_.Count).AppendLine();
sb.AppendLine("Training: ord, reward, win, steps");
for (int i = 0; i < trainingEps_.Count; i++)
{
EpisodeData episode = trainingEps_[i];
sb.AppendFormat("{0}, {1:F4}, {2}, {3}, {4}, {5}",
episode.ord, episode.reward, episode.win ? 1 : 0, episode.steps,
episode.epsilon, episode.alpha);
sb.AppendLine();
}
sb.AppendLine("Validation: ord, reward, win, steps");
for (int i = 0; i < validationEps_.Count; i++)
{
EpisodeData episode = validationEps_[i];
sb.AppendFormat("{0}, {1:F4}, {2}, {3}, {4}, {5}",
episode.ord, episode.reward, episode.win ? 1 : 0, episode.steps,
episode.epsilon, episode.alpha);
sb.AppendLine();
}
// Write the file
string sceneName = EditorSceneManager.GetActiveScene().name;
string time = DateTime.Now.ToString("hh-mm-ss");
string date = DateTime.Now.ToString("dd-MM-yy");
System.IO.File.WriteAllText(sceneName + "_" + date + "_" + time + ".txt", sb.ToString());
}
private IEnumerator IncreaseSceneIndex(int value)
{
sliding = true;
targetSliderValue = value;
while (timeLineAsset.currentScene != value)
{
//Debug.Log(timeLineAsset.paused);
if (!timeLineAsset.paused)
{
timeLineAsset.currentScene++;
EpisodeData epiData = CalculateEpisodeData(timeLineAsset.currentScene);
timeLineAsset.currentSeason = epiData.seasonIndex;
timeLineAsset.currentEpisode = epiData.episodeIndex;
expisodeCounter.text = String.Format("Season {0}, Episode {1}, Scene {2}/{3}", epiData.seasonIndex + 1, epiData.episodeIndex + 1, CalculateSceneProgrerss(timeLineAsset.currentScene) + 1, timeLineAsset.scenesInEachEpisode[CalculateEpiIndex(timeLineAsset.currentScene)]);
yield return(new WaitForSeconds(0.01f));
}
else
{
yield return(null);
}
}
sliding = false;
}
private static EpisodeData LineToData(string line)
{
EpisodeData ret = new EpisodeData();
string[] splitString = line.Split('\t');
string[] splitSeasonLine = splitString[0].Split('.');
string seasonString = splitSeasonLine[0];
string episodeString = splitSeasonLine[1];
string imdbString = splitString[3];
string nealsonString = splitString[2].Split('[')[0];
ret.Title = splitString[1];
ret.Season = Convert.ToInt32(seasonString);
ret.Episode = Convert.ToInt32(episodeString);
ret.ImdbRating = Convert.ToSingle(imdbString);
if (nealsonString != "N/A")
{
ret.NealsonRating = Convert.ToSingle(nealsonString);
}
return(ret);
}
public void SaveValidationEpisode(double reward, bool win, int steps)
{
EpisodeData episode = new EpisodeData(ord, reward, win, steps, 0, 0);
validationEps_.Add(episode);
}
private static string GetEpisodeLabel(EpisodeData episode, int season)
{
return($"{season}x{episode.Episode:D2}: {episode.Title}\n{episode.Rating:#0.0}");
}
//for now, it doesn't make much sense to calculate stats but from the last evaluation episode, so that's what we will do
//regardless of sourceOption
public List <Stat> getVariableStats(List <LoggedVariableViewModel> variables)
{
ExperimentData experimentData = SimionLogFile.load(m_logFilePath);
List <Stat> stats = new List <Stat>();
foreach (LoggedVariableViewModel var in variables)
{
int varIndex = m_variablesInLog.FindIndex((name) => name == var.name);
Stat newStat = new Stat(m_name, var.name);
newStat.avg = experimentData.doForEpisodeVar(experimentData.numEpisodes, varIndex,
(episode, vIndex) => { return(EpisodeData.calculateVarAvg(episode, vIndex)); });
newStat.stdDev = experimentData.doForEpisodeVar(experimentData.numEpisodes, varIndex,
(episode, vIndex) => { return(EpisodeData.calculateStdDev(episode, vIndex)); });
newStat.min = experimentData.doForEpisodeVar(experimentData.numEpisodes, varIndex,
(episode, vIndex) => { return(EpisodeData.calculateMin(episode, vIndex)); });
newStat.max = experimentData.doForEpisodeVar(experimentData.numEpisodes, varIndex,
(episode, vIndex) => { return(EpisodeData.calculateMax(episode, vIndex)); });
stats.Add(newStat);
}
return(stats);
}
public string GetOffLineFileName()
{
return(EpisodeData.GetOffLineFileName());
}
//we can use directly the name of the plots as the name of the variables
//it should be enough for now
public void plotData(List <PlotViewModel> plots, string sourceOption)
{
List <VarPlotInfo> varInfoList = new List <VarPlotInfo>();
try
{
//init the series and get the index of each logged variable
plots.ForEach((plot) =>
{
VarPlotInfo varInfo = new VarPlotInfo();
varInfo.plot = plot;
varInfo.seriesId = plot.addLineSeries(m_name);
varInfo.varIndexInLogFile = m_variablesInLog.FindIndex((name) => name == plot.name);
varInfo.avg = 0.0;
varInfoList.Add(varInfo);
});
ExperimentData experimentData = SimionLogFile.load(m_logFilePath);
foreach (VarPlotInfo var in varInfoList)
{
int varIndex = var.varIndexInLogFile;
if (sourceOption == ReportsWindowViewModel.m_optionAllEvalEpisodes)
{
experimentData.doForEachEvalEpisode(episode =>
{
double avg = EpisodeData.calculateVarAvg(episode, varIndex);
var.plot.addLineSeriesValue(var.seriesId, episode.index, avg);
});
}
else if (sourceOption == ReportsWindowViewModel.m_optionLastEvalEpisode)
{
experimentData.doForEpisodeSteps(experimentData.numEpisodes,
step =>
{
var.plot.addLineSeriesValue(var.seriesId, step.stepIndex
, step.data[var.varIndexInLogFile]);
});
}
}
// EpisodeData.calculateVarAvg
// ,plots[var].addLineSeriesValue(varInfoList[var].seriesId,varIndex);
// varInfoList[var].addValue(step.data[varInfoList[var].varIndexInLogFile]);
// else plots[var].addLineSeriesValue(varInfoList[var].seriesId, step.stepIndex
// , step.data[varInfoList[var].varIndexInLogFile]);
// experimentData.doForEachEvalEpisode(EpisodeData.calculateVarAvg, varIndex);
// }
// }
// foreach (EpisodeData episodeData in experimentData.episodes)
// {
// //do we have to draw data from this step?
// if (episodeData.type == m_episodeTypeEvaluation &&
// (sourceOption == PlotEditorWindowViewModel.m_optionAllEvalEpisodes
// || (sourceOption == PlotEditorWindowViewModel.m_optionLastEvalEpisode
// && episodeData.index == experimentData.numEpisodes)))
// {
// foreach (StepData step in episodeData.steps)
// {
// for (int var = 0; var < varInfoList.Count; var++)
// {
// if (sourceOption == PlotEditorWindowViewModel.m_optionAllEvalEpisodes)
// varInfoList[var].addValue(step.data[varInfoList[var].varIndexInLogFile]);
// else plots[var].addLineSeriesValue(varInfoList[var].seriesId, step.stepIndex
// , step.data[varInfoList[var].varIndexInLogFile]);
// }
// }
// }
// }
// //end of episode
// if (episodeType == m_episodeTypeEvaluation && sourceOption == PlotEditorWindowViewModel.m_optionAllEvalEpisodes)
// {
// for (int var = 0; var < varInfoList.Count; var++ )
// {
// plots[var].addLineSeriesValue(varInfoList[var].seriesId, episodeIndex
// , varInfoList[var].avg / (double)numLoggedSteps);
// }
// }
// }
// }
// logFile.Close();
//}
//catch(Exception ex)
//{
// Console.WriteLine(ex.ToString());
//}
}
catch (Exception ex)
{
Console.WriteLine("Error generating plots");
Console.WriteLine(ex.ToString());
}
}
public static Episode FromData(IServiceContext serviceContext, string podcastFileName, EpisodeData data)
{
Episode episode = new Episode(serviceContext, podcastFileName, data.Uri);
episode.Uri = data.Uri;
episode.Title = data.Title;
episode.Description = data.Description;
episode.PublishDate = new DateTimeOffset(data.PublishDateTicks, TimeSpan.FromTicks(0));
return(episode);
}
void AddEpisode(EpisodeData data, int index)
{
allEpisodes[index] = data;
}
public AbortHelper(PatientData patientData, EpisodeData episodeData)
{
Patient = patientData;
Episode = episodeData;
}
