protected IEnumerator Sequence (params IEnumerator[] children)
{
SequenceData sequence = new SequenceData ();
return Control (
sequence,
() => {
if (sequence.Index >= children.Length)
{
return Success;
}
IEnumerator child = children[sequence.Index];
// Fail on break or explicit failure
if (!child.MoveNext () || Failure.Equals (child.Current))
{
return Failure;
}
// Move to next on success
if (Success.Equals (child.Current))
{
sequence.Index = sequence.Index + 1;
}
return Running;
},
children
);
}
/// <summary>
/// Returns the loglikelihood that the graph have generated the given sequences
/// </summary>
/// <param name="g"></param>
/// <param name="evaluationData"></param>
/// <returns></returns>
//public double LogLikelihood(HiddenMarkovModel hmm, SequenceData evaluationData) {
public double LogLikelihood(SparseHiddenMarkovModel hmm, SequenceData evaluationData)
{
double loglikelihood = 0;
for (int i = 0; i < evaluationData.Count; i++)
loglikelihood += Math.Log(hmm.Evaluate(evaluationData[i]));
return loglikelihood;
}
private void backgroundRunUpdated(object o, EventArgs e)
{
if (!RunForm.backgroundIsRunning() && queuedNextSequence != null)
{
RunForm.beginBackgroundRunAsLoop(queuedNextSequence, RunForm.RunType.Run_Iteration_Zero, true, new EventHandler(backgroundRunUpdated));
queuedNextSequence = null;
backgroundRunUpdated(this, null);
return;
}
if (this.InvokeRequired)
{
this.BeginInvoke(new EventHandler(backgroundRunUpdated), new object[] { this, null });
}
else
{
if (RunForm.backgroundIsRunning())
{
bgRunButton.Text = "Queue as Loop in Background";
}
else
{
bgRunButton.Text = "Run as Loop in Background (^F9)";
}
}
}
public void Add(SequenceData sequence)
{
_Sequences = _Sequences.Append(sequence).ToArray();
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData)
{
//HMMGraph graph = RandomGraph(trainingData.NumSymbols);
HMMGraph graph;
//bestHMM = ModelConverter.Graph2HMM(graph);
bestHMM = SparseHiddenMarkovModel.FromCompleteGraph(trainingData.NumSymbols, trainingData.NumSymbols);
bestHMM.Learn(trainingData.GetNonempty(), baumwelchThreshold);
//while (bestHMM.States < maxStates)
while (bestHMM.NumberOfStates < maxStates)
{
WriteLine("Taking one more iteration");
//graph = ModelConverter.HMM2Graph(bestHMM);
graph = bestHMM.ToGraph();
Dictionary<int, double> nodePerformance = new Dictionary<int, double>();
Dictionary<int, int> nodeOccurence = new Dictionary<int, int>();
double hiddenStateSequenceProbability;
foreach (int[] signal in validationData.GetNonempty())
{
//int[] hiddenStateSequence = bestHMM.Decode(signal, out hiddenStateSequenceProbability);
int[] hiddenStateSequence = bestHMM.Viterby(signal, out hiddenStateSequenceProbability);
for (int j = 0; j < hiddenStateSequence.Length; j++)
{
if (nodePerformance.ContainsKey(hiddenStateSequence[j]))
{
//nodePerformance[hiddenStateSequence[j]] += (Math.Log(hiddenStateSequenceProbability) + Math.Log(bestHMM.Emissions[hiddenStateSequence[j], signal[j]]));
nodePerformance[hiddenStateSequence[j]] += (Math.Log(hiddenStateSequenceProbability) + Math.Log(bestHMM.EmissionProbability(hiddenStateSequence[j], signal[j])));
nodeOccurence[hiddenStateSequence[j]]++;
}
else
{
nodePerformance.Add(hiddenStateSequence[j], (Math.Log(hiddenStateSequenceProbability) + Math.Log(bestHMM.EmissionProbability(hiddenStateSequence[j], signal[j]))));
nodeOccurence.Add(hiddenStateSequence[j], 1);
}
}
}
foreach (int node in nodeOccurence.Keys)
{
nodePerformance[node] /= nodeOccurence[node];
}
int weakPoint = nodePerformance.Keys.Aggregate((a, b) => ((nodePerformance[b] < nodePerformance[a]) ? b : a));
SplitWorstPerformingNode(graph, weakPoint);
//bestHMM = ModelConverter.Graph2HMM(graph);
bestHMM = SparseHiddenMarkovModel.FromGraph(graph);
WriteLine("Running BaumWelch");
bestHMM.Learn(trainingData.GetNonempty(), baumwelchThreshold); //Run the BaumWelch algorithm
WriteLine("");
WriteLine("Log Likelihood: " + LogLikelihood(bestHMM, trainingData));
}
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var cond = args[0] as SingleSelectParameter;
var operand = args[1] as SequenceMultiSelectParameter;
List <SequenceData> targets = new List <SequenceData>();
targets.Add(env.SelectedSequence);
foreach (var sequence in operand.Value)
{
if (sequence != env.SelectedSequence)
{
targets.Add(sequence);
}
}
Func <decimal?[], int> condFunc = (x) => - 1;
string opName = "";
switch (cond.Value)
{
case 0:
condFunc = (x) => {
if (!x.Any(v => v.HasValue))
{
return(-1);
}
return(x.Select((v, i) => new KeyValuePair <int, decimal?>(i, v)).Aggregate((a, b) => (!a.Value.HasValue ? b : !b.Value.HasValue ? a : a.Value.Value > b.Value.Value ? a : b)).Key);
};
opName = "Greatest";
break;
case 1:
condFunc = (x) => {
if (!x.Any(v => v.HasValue))
{
return(-1);
}
return(x.Select((v, i) => new KeyValuePair <int, decimal?>(i, v)).Aggregate((a, b) => (!a.Value.HasValue ? b : !b.Value.HasValue ? a : a.Value.Value < b.Value.Value ? a : b)).Key);
};
opName = "Least";
break;
case 2:
condFunc = (x) => {
for (int i = 0; i < x.Length; i++)
{
if (x[i].HasValue)
{
return(i);
}
}
return(-1);
};
opName = "NotEmpty";
break;
}
var labels = ToLabelByCondition(targets, condFunc);
return(SequenceData.FromLabelSequence(labels, PathEx.GiveName(opName, targets.Select(p => p.Title))));
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
decimal hz = ((NumberParameter)args[0]).Value;
SequenceData ret = new SequenceData(TimeSeriesValuesCalculation.GetResampled(env.SelectedSequence.Values, 1M / hz), new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Resampled", env.SelectedSequence.Title, hz.ToString()));
ret.Type = SequenceType.Numeric;
return(ret);
}
public PulseSampleTimes getPulseSampleTimes(double remainderTime, double sampleDuration, double sequenceTimestepDuration)
{
double remainderTimeAtEnd = remainderTime;
int nSamplesInSequenceTimestep = 0;
SequenceData.computeNSamplesAndRemainderTime(ref nSamplesInSequenceTimestep, ref remainderTimeAtEnd, sequenceTimestepDuration, sampleDuration);
return(getPulseSampleTimes(nSamplesInSequenceTimestep, sampleDuration));
}
public IList <SequenceData> OutputSequence(IList <MotionObjectInfo> selected, IList <ProcParam <MotionProcEnv> > args, IEnumerable <ReadOnlyMotionFrame> frames, ProgressInformation progressInfo)
{
MotionObjectSingleSelectParameter main = args[0] as MotionObjectSingleSelectParameter;
SingleSelectParameter unit = args[1] as SingleSelectParameter;
bool useRatio = unit.Value == 0;
MotionObjectInfo firstAxis = main.Value;
MotionObjectInfo secondAxis = selected.Where(info => info.IsTypeOf(typeof(LineObject)) && info != firstAxis).First();
IList <MotionObjectInfo> pointInfoList = selected.Where(info => info.IsTypeOf(typeof(PointObject))).ToList();
List <SequenceData> ret = new List <SequenceData>();
foreach (MotionObjectInfo pointInfo in pointInfoList)
{
TimeSeriesValues values = new TimeSeriesValues("axis1", "axis2", "axis3");
foreach (var frame in frames)
{
PointObject point = frame[pointInfo] as PointObject;
LineObject line1 = frame[firstAxis] as LineObject;
LineObject line2 = frame[secondAxis] as LineObject;
decimal?[] relValues = null;
if (point != null && line1 != null && line2 != null)
{
Vector3 anchor = line1.Position;
Vector3 pointRelPos = point.Position - anchor;
Vector3 axis1 = line1.Edge;
Vector3 axis2 = line2.Edge;
Vector3 axis1norm = Vector3.Normalize(axis1);
Vector3 axis2norm = Vector3.Normalize(axis2);
Vector3 axis3 = Vector3.Cross(axis1norm, axis2norm) * (float)Math.Sqrt(axis1.Length() * axis2.Length());
if (!useRatio)
{
axis1 = Vector3.Normalize(axis1);
axis2 = Vector3.Normalize(axis2);
axis3 = Vector3.Normalize(axis3);
}
float[,] mat = new float[, ] {
{ axis1.X, axis2.X, axis3.X }, { axis1.Y, axis2.Y, axis3.Y }, { axis1.Z, axis2.Z, axis3.Z }
};
float[] vec = new float[] { pointRelPos.X, pointRelPos.Y, pointRelPos.Z };
SimultaneousEquations solve = SimultaneousEquations.Solve(mat, vec);
if (solve.Answers.Length == 3)
{
relValues = new decimal?[3];
try {
relValues[0] = (decimal)solve.Answers[0];
relValues[1] = (decimal)solve.Answers[1];
relValues[2] = (decimal)solve.Answers[2];
} catch (OverflowException) { relValues = null; }
}
}
values.SetValue(frame.Time, relValues);
}
SequenceData data = new SequenceData(values, null, PathEx.GiveName("RelPos", pointInfo.Name));
ret.Add(data);
}
return(ret);
}
private double[] ComputeViterbyScores(SequenceData validationData, bool normalise = false)
{
double[] scores = new double[NumberOfStates];
foreach (int[] signal in validationData.GetNonempty())
{
double probability;
double[] subscore = new double[NumberOfStates];
int[] occurenceCount = new int[NumberOfStates];
//int[] hiddenStateSequence = hmm.Viterby(signal, out probability);
int[] hiddenStateSequence = hmm.Decode(signal, out probability);
if (hiddenStateSequence == null)
{
continue;
}
for (int t = 0; t < signal.Length; t++)
{
//subscore[hiddenStateSequence[t]] += hmm.EmissionProbability(hiddenStateSequence[t], signal[t]);
subscore[hiddenStateSequence[t]] += hmm.Emissions[hiddenStateSequence[t], signal[t]];
occurenceCount[hiddenStateSequence[t]]++;
}
for (int i = 0; i < NumberOfStates; i++)
{
if (occurenceCount[i] > 0)
{
subscore[i] = ((probability * subscore[i]) / occurenceCount[i]);
}
scores[i] += subscore[i];
}
}
for (int i = 0; i < NumberOfStates; i++)
{
scores[i] /= validationData.Count;
}
if (normalise)
{
double sum = 0;
for (int i = 0; i < NumberOfStates; i++)
{
sum += scores[i];
}
for (int i = 0; i < NumberOfStates; i++)
{
scores[i] /= sum;
}
}
return scores;
}
private void loadCalSequence_Click(object sender, EventArgs e)
{
if (Storage.sequenceData != null)
{
SequenceData calibrationShotSequence = Storage.SaveAndLoad.LoadSequenceWithFileDialog();
setCalibrationSequence(calibrationShotSequence);
}
}
public void PulseDeserializationTest()
{
SequenceData seq = (SequenceData)SharedTestFunctions.loadTestFile("pulseSerTest.seq", typeof(SequenceData));
Assert.IsNotNull(seq.DigitalPulses[0]);
Assert.AreEqual("testPulse", seq.DigitalPulses[0].PulseName);
Assert.AreEqual(1.5, seq.DigitalPulses[0].startDelay.getBaseValue());
Assert.AreEqual(2.5, seq.DigitalPulses[0].pulseDuration.getBaseValue());
}
/// <summary>
/// 既定のコンストラクタ
/// </summary>
/// <param title="controller">コントローラ</param>
/// <param title="current">選択されたシーケンス</param>
public SequenceProcEnv(SequenceViewerController controller, SequenceData selected)
{
if (controller == null)
{
throw new ArgumentNullException("controller", "'controller' cannot be null");
}
_controller = controller;
_selectedSequence = selected;
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var border = ((LabelSelectParameter)args[0]).Value;
var left = ((NumberParameter)args[1]).Value;
var right = ((NumberParameter)args[2]).Value;
var percent = ((BooleanParameter)args[3]).Value;
var withEmpty = ((BooleanParameter)args[4]).Value;
ICSLabelSequence current = env.SelectedSequence.GetLabelSequence();
ICSLabelSequence ret = env.SelectedSequence.GetLabelSequence();
var currentLabels = current.EnumerateLabels().ToList();
for (int i = 0; i < currentLabels.Count; i++)
{
if (border.Contains(currentLabels[i].LabelText))
{
decimal begin, end;
if (percent)
{
begin = currentLabels[i].BeginTime - left * currentLabels[i].Duration / 100;
end = currentLabels[i].EndTime + right * currentLabels[i].Duration / 100;
}
else
{
begin = currentLabels[i].BeginTime - left;
end = currentLabels[i].EndTime + right;
}
if (begin > end)
{
begin += (end - begin) / 2;
end = begin;
}
if (begin < end)
{
ret.SetLabel(begin, end, currentLabels[i].LabelText);
}
if (begin > currentLabels[i].BeginTime)
{
string prev = "";
if (i > 0 && !withEmpty)
{
prev = currentLabels[i - 1].LabelText;
}
ret.SetLabel(currentLabels[i].BeginTime, begin, prev);
}
if (end < currentLabels[i].EndTime)
{
string post = "";
if (i < currentLabels.Count - 1 && !withEmpty)
{
post = currentLabels[i + 1].LabelText;
}
ret.SetLabel(end, currentLabels[i].EndTime, post);
}
}
}
return(SequenceData.FromLabelSequence(ret, PathEx.GiveName("extend", env.SelectedSequence.Title)));
}
public void SequenceDataConstructorTest()
{
SequenceData target = new SequenceData();
Assert.IsTrue(target.VersionNumberAtFirstCreation.isValid(),
"Invalid/unparseable version number in DataStructures. Please" +
" ensure DataStructures version number string is of the form" +
" X.YZ");
}
public RunLog(DateTime runTime, DateTime listStartTime, SequenceData sequence, SettingsData settings, string sequenceFileName, string settingsFileName)
{
this.runTime = runTime;
this.listStartTime = listStartTime;
this.runSequence = sequence;
this.runSettings = settings;
this.SequenceFileName = sequenceFileName;
this.SettingsFileName = settingsFileName;
}
void OnGUI_Chord(SequenceData parent, ChordData chord)
{
int index = parent.chords.IndexOf(chord);
EditorGUILayout.BeginHorizontal();
{
string clipName = (chord.clip != null ? chord.clip.name : "Chord");
chord.debug_isFoldedOut = EditorGUILayout.Foldout(chord.debug_isFoldedOut, clipName);
if (GUILayout.Button(" + "
, EditorStyles.miniButtonLeft
, GUILayout.MaxWidth(32.0f)))
{
int position = parent.MoveChord(index, -1);
SwitchValue(ref parent.chords[index].debug_isFoldedOut, ref parent.chords[position].debug_isFoldedOut);
}
if (GUILayout.Button(" - "
, EditorStyles.miniButtonRight
, GUILayout.MaxWidth(32.0f)))
{
int position = parent.MoveChord(index, 1);
SwitchValue(ref parent.chords[index].debug_isFoldedOut, ref parent.chords[position].debug_isFoldedOut);
}
if (GUILayout.Button("Remove"
, EditorStyles.miniButtonRight
, GUILayout.MaxWidth(128.0f)))
{
parent.RemoveChord(index);
}
}
EditorGUILayout.EndHorizontal();
if (chord.debug_isFoldedOut == false)
{
return;
}
++EditorGUI.indentLevel;
chord.type = (ChordData.Type)EditorGUILayout.EnumPopup("Type: ", chord.type);
switch (chord.type)
{
case ChordData.Type.PRESS:
chord.timingStart = chord.timingStop = EditorGUILayout.FloatField("Timing: ", chord.timingStop);
break;
case ChordData.Type.HOLD:
chord.timingStart = EditorGUILayout.FloatField("Timing Start: ", chord.timingStart);
chord.timingStop = EditorGUILayout.FloatField("Timing Stop: ", chord.timingStop);
break;
}
chord.clip = (AudioClip)EditorGUILayout.ObjectField("Clip: ", chord.clip, typeof(AudioClip), false);
--EditorGUI.indentLevel;
}
public OperationExecution(ISequenceOperation operation, SequenceViewerController controller, SequenceData current)
{
if (operation == null)
{
throw new ArgumentNullException("operation", "'operation' cannot be null");
}
_operation = operation;
_controller = controller;
_current = current;
}
public void AddToSequence(int formationIndex)
{
SequenceData sd = new SequenceData(formationIndex, formations[formationIndex].GetRelativePosition());
if (waveSequence == null)
{
waveSequence = new List <SequenceData>();
}
waveSequence.Add(sd);
}
/// <summary>
/// 既定のコンストラクタ
/// </summary>
/// <param title="controller">コントローラ</param>
/// <param title="current">選択されたシーケンス</param>
public SequenceProcEnv(SequenceViewerController controller)
: this(controller, null)
{
SequenceView tmp = controller.GetFocusedView();
if (tmp != null)
{
_selectedSequence = tmp.Sequence;
}
}
public static SequenceMode createSequenceMode(SequenceData sequence)
{
SequenceMode ans = new SequenceMode();
foreach (TimeStep step in sequence.TimeSteps)
{
ans.TimestepEntries.Add(step, new ModeEntry(step.StepEnabled, step.StepHidden));
}
return(ans);
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var sequence = TimeSeriesValuesCalculation.AbsoluteLength(env.SelectedSequence.Values);
sequence.ColumnNames[0] = "Abs Value";
SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Abs", env.SelectedSequence.Title));
ret.Type = SequenceType.Numeric;
return(ret);
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var sequence = TimeSeriesValuesCalculation.Differentiate(env.SelectedSequence.Values);
sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Diff " + n));
SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Diff", env.SelectedSequence.Title));
ret.Type = SequenceType.Numeric;
return(ret);
}
void Update()
{
time_ms += Time.deltaTime;
deadzoneTime_ms += Time.deltaTime;
Debug.Log("sequenceState: " + System.Enum.GetName(typeof(SequenceState), sequenceState));
if (sequenceState == SequenceState.Playing)
{
sequenceWindowClosure = SequenceWindowClosure.Open;
sequenceTime_ms += Time.deltaTime;
timeSinceLastPress_ms += Time.deltaTime;
// If we have enough keys to assess whether the sequence can be validated, do so.
if (currentKeySequenceLogs["Event"].Count == keysToPress.GetLength(0))
{
sequenceWindowClosure = SequenceWindowClosure.ClosedByInputThreshold;
SequenceData sequenceData = CheckCapturedKeys();
InputData inputData = new InputData();
inputData.validity = InputValidity.Rejected;
inputData.confidence = 0;
inputData.inputNumber = sequenceData.sequenceNumber;
inputData.type = InputType.KeySequence;
if (sequenceData.sequenceValidity == SequenceValidity.Accepted)
{
inputData.validity = InputValidity.Accepted;
inputData.confidence = 1;
}
//if (state == SequenceValidity.Accepted) {
onKeySequenceFinished.Invoke(sequenceData, inputData);
onInputFinished.Invoke(inputData);
//}
sequenceState = SequenceState.Stopped;
}
else if (deadzoneTime_ms > deadzoneTimeLimit_ms)
{
sequenceWindowClosure = SequenceWindowClosure.ClosedByDeadzone;
Debug.Log("No key pressed for " + deadzoneTimeLimit_ms + "seconds, sequence stopped.");
SequenceData sequenceData = CheckCapturedKeys();
InputData inputData = new InputData();
inputData.validity = InputValidity.Rejected;
inputData.confidence = 0;
inputData.inputNumber = sequenceData.sequenceNumber;
inputData.type = InputType.KeySequence;
//if (state == SequenceValidity.Accepted) {
onKeySequenceFinished.Invoke(sequenceData, inputData);
onInputFinished.Invoke(inputData);
//}
sequenceState = SequenceState.Stopped;
}
}
else
{
sequenceTime_ms = 0f;
timeSinceLastPress_ms = 0f;
}
}
public ScriptVariable Call(IList <ScriptVariable> args, ScriptConsole console)
{
if (args == null)
{
throw new ArgumentNullException("args", "args cannot be null");
}
if (args.Count < 1)
{
throw new ArgumentException("args must have one or more elements", "args");
}
if (args[0] == null)
{
throw new ArgumentException("first element of args cannot be null", "args");
}
string viewerName = args[0].ToString();
SequenceView viewer = SequenceViewerController.Singleton.GetViewByTitle(viewerName);
if (viewer == null)
{
throw new ArgumentException("first element of args must be resultSequence name : " + viewerName, "args");
}
SequenceProcEnv env2 = new SequenceProcEnv(console.SequenceController, viewer.Sequence);
IList <ProcParam <SequenceProcEnv> > parameters = this.Operation.GetParameters() ?? new ProcParam <SequenceProcEnv> [0];
if (args.Count != parameters.Count + 1)
{
throw new ArgumentException(string.Format(global::MotionDataHandler.Properties.Settings.Default.Msg_NumberOfArgumentsRequired, parameters.Count + 1));
}
for (int i = 0; i < parameters.Count; i++)
{
string errorStr = "";
if (!parameters[i].FromScriptVariable(env2, args[i + 1], ref errorStr))
{
throw new ArgumentException(string.Format(global::MotionDataHandler.Properties.Settings.Default.Msg_InvalidNthArgument + ": {1}", i + 1, errorStr ?? ""), "args");
}
}
SequenceData resultSequence = this.Operation.Operate(parameters, env2);
ScriptVariable ret = null;
if (resultSequence != null)
{
console.SequenceController.AddSequence(resultSequence, viewer.IsLocked);
ret = new StringVariable(resultSequence.Title);
}
console.SequenceController.DoAllocationChanged();
if (this.Operation.ReplacesInternalData)
{
env2.SelectedSequence.IsDataChanged = true;
}
return(ret);
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var timeBefore = ((NumberParameter)args[0]).Value;
var timeAfter = ((NumberParameter)args[1]).Value;
var exclude = ((NumberParameter)args[2]).Value;
var sequence = TimeSeriesValuesCalculation.TimeSmooth(env.SelectedSequence.Values, timeBefore + timeAfter, -timeAfter, exclude);
SequenceData ret = new SequenceData(sequence, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Smooth", env.SelectedSequence.Title));
ret.Type = SequenceType.Numeric;
return(ret);
}
public Sequence(SequenceData data)
{
Data = data;
_Scores = new SequenceScoreHolder(Data.Stages.Count);
_Stages = new Stage[data.Stages.Count];
for (int i = 0; i < _Stages.Length; i++)
{
_Stages[i] = new Stage(Data.Stages[i], _Scores.Scores[i], data.Name + " stage " + (i + 1), this);
}
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var keepEmpty = args[0] as BooleanParameter;
var sequence = TimeSeriesValuesCalculation.AverageFlat(env.SelectedSequence.Values, keepEmpty.Value);
sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Avg " + n));
SequenceData ret = new SequenceData(sequence, null, PathEx.GiveName("Average", env.SelectedSequence.Title));
ret.Type = SequenceType.Numeric;
return(ret);
}
public void getTimeStepAtTimeTest()
{
SequenceData target = (SequenceData)SharedTestFunctions.loadTestFile("gettimesteptestseq.seq", typeof(SequenceData), true, null);
Assert.AreEqual("1", target.getTimeStepAtTime(.5).StepName);
Assert.AreEqual("1", target.getTimeStepAtTime(.5).StepName);
Assert.AreEqual("1", target.getTimeStepAtTime(1).StepName);
Assert.AreEqual("2", target.getTimeStepAtTime(1.5).StepName);
Assert.AreEqual("4", target.getTimeStepAtTime(4).StepName);
Assert.IsNull(target.getTimeStepAtTime(-1));
Assert.IsNull(target.getTimeStepAtTime(10));
}
public override bool FromScriptVariable(SequenceProcEnv environment, ScriptVariable variable, ref string errorMessage)
{
SequenceData parent = environment.SelectedSequence;
if (this.Parent != null && this.Parent.Value != null)
{
parent = this.Parent.Value;
}
IList <ScriptVariable> list = variable.ToList();
List <int> ret = new List <int>();
foreach (ScriptVariable v in list)
{
switch (v.Type)
{
case ScriptVariableType.Number:
int index = v.ToInteger();
if (index < 0 || index >= parent.Values.ColumnCount)
{
errorMessage = MotionDataHandler.Properties.Settings.Default.Msg_IndexOutOfRange + ": " + index.ToString();
return(false);
}
ret.Add(index);
break;
case ScriptVariableType.String:
string name = v.ToString();
int index2 = -1;
for (int i = 0; i < parent.Values.ColumnNames.Length; i++)
{
if (parent.Values.ColumnNames[i] == name)
{
index2 = i;
break;
}
}
if (index2 == -1)
{
errorMessage = MotionDataHandler.Properties.Settings.Default.Msg_ColumnNameNotFound;
return(false);
}
ret.Add(index2);
return(true);
default:
errorMessage = MotionDataHandler.Properties.Settings.Default.Msg_SpecifyIndexOfColumnOrColumnName;
return(false);
}
}
this.Value = ret;
return(true);
}
public SequenceData Operate(IList <ProcParam <SequenceProcEnv> > args, SequenceProcEnv env)
{
var stddev = ((NumberParameter)args[0]).Value;
var details = (int)((NumberParameter)args[1]).Value;
var exclude = ((NumberParameter)args[2]).Value;
var sequence = TimeSeriesValuesCalculation.Gaussian(env.SelectedSequence.Values, stddev, details, exclude);
sequence.SetColumnNames(env.SelectedSequence.Values.ColumnNames.Select(n => "Gauss " + n).ToArray());
SequenceData ret = new SequenceData(sequence, new LabelingBorders(env.SelectedSequence.Borders), PathEx.GiveName("Gaussian", env.SelectedSequence.Title, stddev.ToString()));
ret.Type = SequenceType.Numeric;
return(ret);
}
public bool GetSequence(int index, out SequenceData sequence)
{
if (index < 0 || index >= sequences.Count)
{
Debug.LogError("Index out of range, Sequence #"
+ index.ToString()
+ " doesn't exist!");
sequence = null;
return(false);
}
sequence = sequences[index];
return(true);
}
public bool GetSequence(int index, out SequenceData sequence)
{
if (index < 0 || index >= sequences.Count)
{
Debug.LogError("Index out of range, Sequence #"
+ index.ToString()
+ " doesn't exist!");
sequence = null;
return false;
}
sequence = sequences[index];
return true;
}
/// <summary>
/// 记录日志
/// </summary>
/// <param name="taskId">任务ID</param>
/// <param name="type">类型</param>
/// <param name="result">日志内容</param>
public void Info(string taskId, string type, string result)
{
TaskLog tlog = new TaskLog();
SequenceData seq = new SequenceData();
tlog.idx = seq.GetIdx();
tlog.taskid = taskId;
tlog.server = Dns.GetHostName();
tlog.type = type;
tlog.createtime = DateTime.Now.ToString();
tlog.message = string.Format("任务ID：{0},时间:{1},信息：{2}", taskId, DateTime.Now, result);
Data.TaskLogData tl = new TaskLogData();
tl.Insert(tlog);
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData)
{
//hmm = SparseHiddenMarkovModel.FromCompleteGraph(2, trainingData.NumSymbols);
hmm = new HiddenMarkovModel(trainingData.NumSymbols, 4);
double likelihood = 0.0;
double newLikelihood = Double.MinValue;
do
{
//HMMGraph graph = hmm.ToGraph();
HMMGraph graph = ModelConverter.HMM2Graph(hmm);
//CutEdges(graph, epsilon);
double[] viterbyScores = ComputeViterbyScores(validationData, true);
int[] statesToSplit = IdentifyWeakStates(viterbyScores).ToArray();
foreach (int weakPoint in statesToSplit)
{
SplitState(graph, weakPoint);
}
WriteLine(String.Format("Added {0} states", statesToSplit.Length));
//WriteLine(String.Format("Removed {0} states", RemoveUnpopularStates(graph, viterbyScores)));
//hmm = SparseHiddenMarkovModel.FromGraph(graph);
hmm = ModelConverter.Graph2HMM(graph);
WriteLine("Running Baum Welch...");
//hmm.Learn(trainingData.GetNonempty(), 0.0, 8);
hmm.Learn(trainingData.GetNonempty(), 8);
likelihood = newLikelihood;
newLikelihood = 0.0;
foreach (int[] signal in validationData.GetNonempty())
{
newLikelihood += hmm.Evaluate(signal, true);
}
WriteLine(String.Empty);
WriteLine(String.Format("Number of HMM States: {0}", NumberOfStates));
//WriteLine(String.Format("Transition Sparsity; {0}", hmm.TransitionSparsity));
WriteLine(String.Format("Log Likelihood: {0}", newLikelihood));
WriteLine(String.Empty);
}
while (Math.Abs(newLikelihood - likelihood) > convergenceThreshold);
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData) {
HMMGraph graph = new HMMGraph(trainingData.NumSymbols);
//Add nodes and set initial and emission probabilities
for (int i = 0; i < states; i++) {
Node new_node = new Node();
for (int s = 0; s < trainingData.NumSymbols; s++)
new_node.SetEmission(s, ran.NextDouble());
new_node.InitialProbability = ran.NextDouble();
graph.AddNode(new_node);
}
//Add random transmissions. Each node will have at most Log(n) edges in both directions
//for (int i = 0; i < graph.Nodes.Count; i++)
//{
// List<Node> shuffled = graph.Nodes.Select(e => e).ToList();
// Utilities.Shuffle(shuffled);
// int upperBound = (int)Math.Ceiling(Math.Log(graph.Nodes.Count));
// if (upperBound >= graph.Nodes.Count)
// upperBound = graph.Nodes.Count - 1;
// for (int p = 0; p <= upperBound; p++)
// {
// Node from = graph.Nodes[i];
// Node to = graph.Nodes[p];
// from.SetTransition(to, ran.NextDouble());
// }
//}
int numberOfTransitions = (int)Math.Ceiling(Math.Log(states));
foreach (Node node in graph.Nodes)
{
for (int i = 0; i < numberOfTransitions; i++)
{
Node target;
while (node.Transitions.ContainsKey(target = graph.Nodes[ran.Next(states)]));
node.SetTransition(target, ran.NextDouble());
}
}
graph.Normalize();
hmm = SparseHiddenMarkovModel.FromGraph(graph);
hmm.Learn(trainingData.GetNonempty(), tolerance);
}
//Creates a DataTable with the proper number of rows and columns, and fills in the "time" column taking into account the analogInLogTimes defined in Atticus
public static DataTable InitializeDataTable(DataTable dataTable, SequenceData sequence,ServerSettings settings,List<string> analog_in_names)
{
int numOfChannels = analog_in_names.Count;
dataTable.Rows.Clear();
dataTable.Columns.Clear();
DataColumn[] dataColumn = new DataColumn[numOfChannels + 1];
dataColumn[0] = new DataColumn();
dataColumn[0].DataType = typeof(double);
dataColumn[0].ColumnName = "t";
for (int currentChannelIndex = 1; currentChannelIndex < numOfChannels + 1; currentChannelIndex++)
{
dataColumn[currentChannelIndex] = new DataColumn();
dataColumn[currentChannelIndex].DataType = typeof(double);
dataColumn[currentChannelIndex].ColumnName = analog_in_names[currentChannelIndex - 1];
}
dataTable.Columns.AddRange(dataColumn);
List<double> theTimes = new List<double>();
int samplesFreq = settings.AIFrequency;
foreach (AnalogInLogTime theLogTime in settings.AILogTimes)
{
double timestep = Math.Round(sequence.timeAtTimestep(theLogTime.TimeStep - 1), 3, MidpointRounding.AwayFromZero);
double timebefore = Math.Max(timestep - ((double)theLogTime.TimeBefore) / 1000, 0);
double timeafter = Math.Min(timestep + ((double)theLogTime.TimeAfter) / 1000, Math.Round(sequence.SequenceDuration, 3, MidpointRounding.AwayFromZero));
for (int k = (int)(timebefore * samplesFreq); k < (int)(timeafter * samplesFreq + 1); k++)
{
theTimes.Add((double)k / (double)samplesFreq);
}
}
theTimes = DedupCollection(theTimes);
theTimes.Sort();
int numOfRows = theTimes.Count;
for (int currentDataIndex = 0; currentDataIndex < numOfRows; currentDataIndex++)
{
object[] rowArr = new object[numOfChannels + 1];
dataTable.Rows.Add(rowArr);
dataTable.Rows[currentDataIndex][0] = theTimes[currentDataIndex];
}
return dataTable;
}
//Obtains the name of the shot, containing bound variables, the name and the description of the sequence
public static string get_fileStamp(SequenceData sequence, SettingsData settings, DateTime runTime)
{
string fileStamp;
if (!settings.UseParisStyleFileTimestamps)
{
fileStamp = "RunLog-" + CiceroUtilityFunctions.getTimeStampString(runTime);
}
else
{
fileStamp = number_to_string(runTime.Hour, 2) + number_to_string(runTime.Minute, 2) + number_to_string(runTime.Second, 2);
if (sequence.SequenceName != "")
fileStamp = fileStamp + "_" + ProcessName(sequence.SequenceName,sequence);
if (sequence.SequenceDescription != "")
fileStamp = fileStamp + "_" + ProcessName(sequence.SequenceDescription,sequence);
if (listBoundVariables(sequence) != "")
fileStamp = fileStamp + "_" + listBoundVariables(sequence);
}
return fileStamp;
}
//Obtains a list '_' separated of the bound variables and their values, reported in the name of the shot
public static string listBoundVariables(SequenceData sequence)
{
string listBoundVariableValues = "";
foreach (Variable var in sequence.Variables)
{
if (var.ListDriven && !var.PermanentVariable)
{
if (listBoundVariableValues != "")
{
listBoundVariableValues += "_";
}
listBoundVariableValues += var.VariableName + " = " + var.VariableValue.ToString();
}
}
return listBoundVariableValues;
}
//Looks for variable names in the sequence name or description to add the value afterwards
public static string ProcessName(string theName, SequenceData sequence)
{
string ans = theName;
foreach (Variable var in sequence.Variables)
{
if (!var.ListDriven || var.PermanentVariable)
{
if (theName.Contains(var.VariableName))
ans = ans.Replace(var.VariableName, var.VariableName + " = " + var.VariableValue.ToString());
}
}
return ans;
}
private void SetFormData()
{
SequenceData tmp = new SequenceData();
tmp.LoadLatest();
TextBoxUsername.Text = tmp.Username;
TextBoxLens.Text = tmp.Lens;
TextBoxLensMM.Text = tmp.LensMM;
TextBoxLensIris.Text = tmp.LensIris;
if(tmp.IRSourceCount == 0)
RadioIR0.IsChecked = true;
if (tmp.IRSourceCount == 1)
RadioIR1.IsChecked = true;
if (tmp.IRSourceCount == 2)
RadioIR2.IsChecked = true;
if (tmp.IRSourceCount == 3)
RadioIR3.IsChecked = true;
if (tmp.IRSourceCount == 4)
RadioIR4.IsChecked = true;
if (tmp.IRSourceCount == 5)
RadioIR5.IsChecked = true;
switch(tmp.CameraView)
{
case SequenceData.CameraViewEnum.Binocular:
RadioCameraViewBinocular.IsChecked = true;
break;
case SequenceData.CameraViewEnum.Monocular:
RadioCameraViewMonocular.IsChecked = true;
break;
case SequenceData.CameraViewEnum.Headmounted:
RadioCameraViewHeadmounted.IsChecked = true;
break;
}
}
private void SetData(SequenceData data)
{
Model[_annotationName] = data.Serialize();
}
void OnGUI_Chord(SequenceData parent, ChordData chord)
{
int index = parent.chords.IndexOf(chord);
EditorGUILayout.BeginHorizontal();
{
string clipName = (chord.clip != null ? chord.clip.name : "Chord");
chord.debug_isFoldedOut = EditorGUILayout.Foldout(chord.debug_isFoldedOut, clipName);
if (GUILayout.Button(" + "
, EditorStyles.miniButtonLeft
, GUILayout.MaxWidth(32.0f)))
{
int position = parent.MoveChord(index, -1);
SwitchValue(ref parent.chords[index].debug_isFoldedOut, ref parent.chords[position].debug_isFoldedOut);
}
if (GUILayout.Button(" - "
, EditorStyles.miniButtonRight
, GUILayout.MaxWidth(32.0f)))
{
int position = parent.MoveChord(index, 1);
SwitchValue(ref parent.chords[index].debug_isFoldedOut, ref parent.chords[position].debug_isFoldedOut);
}
if (GUILayout.Button("Remove"
, EditorStyles.miniButtonRight
, GUILayout.MaxWidth(128.0f)))
{
parent.RemoveChord(index);
}
}
EditorGUILayout.EndHorizontal();
if (chord.debug_isFoldedOut == false)
return;
++EditorGUI.indentLevel;
chord.type = (ChordData.Type)EditorGUILayout.EnumPopup("Type: ", chord.type);
switch (chord.type)
{
case ChordData.Type.PRESS:
chord.timingStart = chord.timingStop = EditorGUILayout.FloatField("Timing: ", chord.timingStop);
break;
case ChordData.Type.HOLD:
chord.timingStart = EditorGUILayout.FloatField("Timing Start: ", chord.timingStart);
chord.timingStop = EditorGUILayout.FloatField("Timing Stop: ", chord.timingStop);
break;
}
chord.clip = (AudioClip)EditorGUILayout.ObjectField("Clip: ", chord.clip, typeof(AudioClip), false);
--EditorGUI.indentLevel;
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData) {
//trainingData.AddSequences(validationData);
double[] initialProbabilities = new double[states];
double sum = 0.0;
for (int k = 0; k < states; k++)
{
initialProbabilities[k] = random.NextDouble();
sum += initialProbabilities[k];
}
for (int k = 0; k < states; k++)
{
initialProbabilities[k] /= sum;
}
double[,] transitionMatrix = new double[states, states];
for (int k = 0; k < states; k++)
{
sum = 0.0;
for (int l = 0; l < states; l++)
{
transitionMatrix[k, l] = random.NextDouble();
sum += transitionMatrix[k, l];
}
for (int l = 0; l < states; l++)
{
transitionMatrix[k, l] /= sum;
}
}
double[,] emissionMatrix = new double[states, testData.NumSymbols];
for (int k = 0; k < states; k++)
{
sum = 0.0;
for (int l = 0; l < testData.NumSymbols; l++)
{
emissionMatrix[k, l] = random.NextDouble();
sum += emissionMatrix[k, l];
}
for (int l = 0; l < testData.NumSymbols; l++)
{
emissionMatrix[k, l] /= sum;
}
}
//hmm = new HiddenMarkovModel(trainingData.NumSymbols, states);
hmm = new HiddenMarkovModel(transitionMatrix, emissionMatrix, initialProbabilities);
Stopwatch sw = new Stopwatch();
sw.Start();
hmm.Learn(trainingData.GetNonempty(), tolerance);
sw.Stop();
Console.WriteLine(sw.Elapsed.TotalSeconds);
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData)
{
hmm = SparseHiddenMarkovModel.FromCompleteGraph(1, trainingData.NumSymbols);
double temperature = 2;
double epsilon = 1.0;
double likelihood = 0.0;
double newLikelihood = Double.MinValue;
double lastSparsity = hmm.TransitionSparsity;
int stagnation = 1;
do
{
if (temperature > 2)
{
HMMGraph graph = hmm.ToGraph();
CutEdges(graph, epsilon);
if (hmm.TransitionSparsity != lastSparsity)
{
lastSparsity = hmm.TransitionSparsity;
stagnation = Math.Max(1, (stagnation - 1));
}
else
{
stagnation++;
}
//int numberOfStatesToAdd = Math.Max(0, (int)Math.Min(hmm.NumberOfStates, Math.Ceiling(Math.Log(Math.Pow(Math.Log(newLikelihood - likelihood), (1 / stagnation)) / (Math.Sqrt(temperature) * threshold)))));
//int numberOfStatesToAdd = (((stagnation / temperature) > threshold) ? 1 : 0);
int numberOfStatesToAdd = 1;
foreach (int weakPoint in IdentifyWeakStates(validationData, numberOfStatesToAdd))
{
SplitState(graph, weakPoint);
stagnation = 1;
}
if (numberOfStatesToAdd == 0)
{
stagnation *= 2;
}
hmm = SparseHiddenMarkovModel.FromGraph(graph);
WriteLine(String.Format("Added {0} states", numberOfStatesToAdd));
}
temperature *= Math.Max(2, Math.Sqrt(hmm.NumberOfStates));
//temperature *= Math.Max(2, stagnation);
epsilon = (1 / Math.Log(temperature));
double bwThreshold = Math.Pow(Math.Max(threshold, (1 / (-Math.Min((-1), Math.Log(Math.Min((1 - threshold), (1 / temperature)) / (1 - threshold)))))), stagnation);
//int bwIterations = Math.Max(1, (int)Math.Log(stagnation * temperature * threshold));
WriteLine(String.Format("Running Baum-Welch with threshold {0}...", bwThreshold));
//WriteLine(String.Format("Running Baum-Welch with {0} iterations...", bwIterations));
hmm.Learn(trainingData.GetNonempty(), bwThreshold);
//hmm.Learn(trainingData.GetNonempty(), 0.0, bwIterations);
likelihood = newLikelihood;
newLikelihood = 0.0;
foreach (int[] signal in validationData.GetNonempty())
{
newLikelihood += hmm.Evaluate(signal, true);
}
WriteLine(String.Empty);
WriteLine(String.Format("Stagnation: {0}", stagnation));
WriteLine(String.Format("Epsilon: {0}", epsilon));
WriteLine(String.Format("Number of HMM States: {0}", hmm.NumberOfStates));
WriteLine(String.Format("Transition Sparsity; {0}", hmm.TransitionSparsity));
WriteLine(String.Format("Log Likelihood: {0}", newLikelihood));
WriteLine(String.Empty);
}
while ((Math.Abs(newLikelihood - likelihood) * Math.Pow(epsilon, 2)) > threshold);
}
private IEnumerable<int> IdentifyWeakStates(SequenceData validationData)
{
double[] scores = ComputeViterbyScores(validationData, true);
return IdentifyWeakStates(scores);
}
private IEnumerable<int> IdentifyWeakStates(SequenceData validationData, int numberOfStates = 1)
{
double[] scores = ComputeViterbyScores(validationData);
return Enumerable.Range(0, NumberOfStates).OrderBy(i => scores[i]).Take(numberOfStates);
}
void OnGUI_Sequence(BallardData parent, SequenceData sequence)
{
sequence.debug_isFoldedOut = EditorGUILayout.Foldout(sequence.debug_isFoldedOut, sequence.name);
if (sequence.debug_isFoldedOut == false)
return;
++EditorGUI.indentLevel;
EditorGUILayout.BeginHorizontal();
{
GUILayout.Space((EditorGUI.indentLevel + 2) * 10.0f);
GUILayout.Label("Name: ", GUILayout.MaxWidth(64.0f));
sequence.name = EditorGUILayout.TextField(sequence.name);
if (GUILayout.Button("Add Chord"
, EditorStyles.miniButtonLeft
, GUILayout.MaxWidth(128.0f)))
{
sequence.AddChord(new ChordData());
}
if (GUILayout.Button("Remove Chord"
, EditorStyles.miniButtonRight
, GUILayout.MaxWidth(128.0f)))
{
int i = sequence.chords.Count - 1;
sequence.RemoveChord(i);
}
}
EditorGUILayout.EndHorizontal();
for (int i = 0; i < sequence.chords.Count; ++i)
{
OnGUI_Chord(sequence, sequence.chords[i]);
}
--EditorGUI.indentLevel;
}
public override void Learn(SequenceData trainingData, SequenceData validationData, SequenceData testData) {
}
private void RunCapture(object sender, RoutedEventArgs e)
{
// "Fake" calibration window that animates points
calWindow = new DummyCalibrationWindow();
// Set parameters
calWindow.SetSize(ScreenParameters.PrimaryResolution);
calWindow.calibrationControl.PointTransitionDuration = 1000;
calWindow.calibrationControl.PointDuration = 1000;
calWindow.calibrationControl.PointDiameter = 50;
// Register for event
calWindow.calibrationControl.OnPointStart += new RoutedEventHandler(calibrationControl_OnPointStart);
calWindow.calibrationControl.OnCalibrationEnd += new RoutedEventHandler(calibrationControl_OnCalibrationEnd);
// Stor data in SequenceData object
sequenceData = new SequenceData();
// Set sequnce info
SetSequenceInfo(sequenceData);
// Start animation, when the first point has been display, OnPoint event is occurs and we start storing images
calWindow.calibrationControl.Start();
}
public static SequenceData Deserialize([NotNull] string value)
{
Check.NotEmpty(value, nameof(value));
try
{
var data = new SequenceData();
var position = 0;
data.Name = ExtractValue(value, ref position);
data.Schema = ExtractValue(value, ref position);
data.StartValue = (long)AsLong(ExtractValue(value, ref position));
data.IncrementBy = (int)AsLong(ExtractValue(value, ref position));
data.MinValue = AsLong(ExtractValue(value, ref position));
data.MaxValue = AsLong(ExtractValue(value, ref position));
data.ClrType = AsType(ExtractValue(value, ref position));
data.IsCyclic = AsBool(ExtractValue(value, ref position));
return data;
}
catch (Exception ex)
{
throw new ArgumentException(RelationalStrings.BadSequenceString, ex);
}
}
private void SetSequenceInfo(SequenceData sd)
{
// Keep it simple, no data binding, just dump the data into the new session obj
sd.Username = TextBoxUsername.Text;
sd.DeviceName = TextBoxDevice.Text;
if(RadioIR0.IsChecked.Value)
sd.IRSourceCount = 0;
if (RadioIR1.IsChecked.Value)
sd.IRSourceCount = 1;
if (RadioIR2.IsChecked.Value)
sd.IRSourceCount = 2;
if (RadioIR3.IsChecked.Value)
sd.IRSourceCount = 3;
if (RadioIR4.IsChecked.Value)
sd.IRSourceCount = 4;
if (RadioIR5.IsChecked.Value)
sd.IRSourceCount = 5;
sd.Lens = TextBoxLens.Text;
sd.LensMM = TextBoxLensMM.Text;
sd.LensIris = TextBoxLensIris.Text;
if (RadioCameraViewBinocular.IsChecked.Value)
sd.CameraView = SequenceData.CameraViewEnum.Binocular;
if (RadioCameraViewMonocular.IsChecked.Value)
sd.CameraView = SequenceData.CameraViewEnum.Monocular;
if (RadioCameraViewHeadmounted.IsChecked.Value)
sd.CameraView = SequenceData.CameraViewEnum.Headmounted;
sd.Notes = TextBoxNotes.Text;
}
private IEnumerable<int> IdentifyWeakStates(SequenceData validationData, int numberOfStates = 1) //Using Viterby
{
double[] scores = new double[hmm.NumberOfStates];
foreach(int[] signal in validationData.GetNonempty())
{
double probability;
double[] subscore = new double[hmm.NumberOfStates];
int[] occurenceCount = new int[hmm.NumberOfStates];
int[] hiddenStateSequence = hmm.Viterby(signal, out probability);
if (hiddenStateSequence == null)
{
continue;
}
for (int t = 0; t < signal.Length; t++)
{
subscore[hiddenStateSequence[t]] += hmm.EmissionProbability(hiddenStateSequence[t], signal[t]);
occurenceCount[hiddenStateSequence[t]]++;
}
for (int i = 0; i < hmm.NumberOfStates; i++)
{
if (occurenceCount[i] > 0)
{
subscore[i] = ((probability * subscore[i]) / occurenceCount[i]);
}
scores[i] += subscore[i];
}
}
return Enumerable.Range(0, hmm.NumberOfStates).OrderBy(i => scores[i]).Take(numberOfStates);
//double worstScore = Double.MaxValue;
//int worstPerformer = 0;
//for (int i = 0; i < hmm.NumberOfStates; i++)
//{
// if (scores[i] < worstScore)
// {
// worstScore = scores[i];
// worstPerformer = i;
// }
//}
//yield return worstPerformer;
}
