public override void OnReset()
{
targetGameObject = null;
componentName = null;
fieldName = null;
fieldValue = null;
}
public void SetVariable(string name, SharedVariable item)
{
if (!Variables.ContainsKey(name))
{
Variables.Add(name, item);
}
}
public override void OnReset()
{
targetGameObject = null;
componentName = null;
propertyName = null;
propertyValue = null;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="numOfChunks">The number of chunks.</param>
/// <param name="numOfClasses">The range of classes.</param>
/// <param name="noise">The noise level.</param>
/// <param name="weights">The weight shared variable the from training model.</param>
public TestModel(int numOfChunks, int numOfClasses, double noise, SharedVariable<Vector>[] weights)
: base(numOfClasses, noise)
{
NumberOfChunks = numOfChunks;
this.weights = weights;
InitModel();
}
/// <summary>
/// Set the weight shared variables.
/// </summary>
/// <param name="index">The class ID.</param>
/// <param name="numOfFeatures">The number of features in the class.</param>
public void SetWeight(int index, int numOfFeatures)
{
SharedWeight = (index == 0)
? SharedVariable<Vector>.Random(VectorGaussian.PointMass(Vector.Zero(numOfFeatures)))
: SharedVariable<Vector>.Random(
VectorGaussian.FromMeanAndPrecision(
Vector.Zero(numOfFeatures),
PositiveDefiniteMatrix.Identity(numOfFeatures)));
}
public override void OnReset()
{
// Reset the properties back to their original values
textFormat = string.Empty;
logError = false;
arg0 = null;
arg1 = null;
arg2 = null;
arg3 = null;
}
public override void OnReset()
{
targetGameObject = null;
componentName = null;
methodName = null;
parameter1 = null;
parameter2 = null;
parameter3 = null;
parameter4 = null;
storeResult = null;
}
private void inspector_SharedVariableUpdated(SharedVariable sharedVariable)
{
this.BeginInvoke(new EventHandler(delegate(object o, EventArgs e)
{
ListViewItem item = lvSharedVariableList.Items[sharedVariable.Name];
int ixLU = lvSharedVariableList.Columns["LastUpdated"].Index;
int ixLW = lvSharedVariableList.Columns["LastWriter"].Index;
item.SubItems[ixLU].Text = sharedVariable.LastUpdated.ToString("hh:mm:ss");
item.SubItems[ixLW].Text =
String.IsNullOrEmpty(sharedVariable.LastWriter) ? "(Unknown)" : sharedVariable.LastWriter;
lvSharedVariableList.Refresh();
pgSharedVarProperties.Refresh();
}));
}
private void inspector_SharedVariableAdded(Inspector inspector, SharedVariable sharedVariable)
{
this.BeginInvoke(new EventHandler (delegate(object o, EventArgs e)
{
string[] row = { sharedVariable.Name,
sharedVariable.TypeName + (sharedVariable.IsArray ? "[]" : String.Empty),
sharedVariable.LastUpdated.ToString("hh:mm:ss"),
String.IsNullOrEmpty(sharedVariable.LastWriter) ? "(Unknown)" : sharedVariable.LastWriter
};
ListViewItem item = new ListViewItem(row);
item.Name = sharedVariable.Name;
item.Tag = sharedVariable;
lvSharedVariableList.Items.Add(item);
item.BackColor = (item.Index % 2 == 0) ? Color.White : Color.LightGray;
lvSharedVariableList.Refresh();
}));
}
/// <summary>
/// Constructs a multi-component Bayes Point Machine using shared variables for chunking data
/// </summary>
/// <param name="nClass">Number of components (classes)</param>
/// <param name="nFeatures">Number of features</param>
/// <param name="noisePrec">Noise precision</param>
/// <param name="trainChunkSize">Chunk size for training</param>
/// <param name="testChunkSize">Chunk size for testing</param>
public BPM_Shared(int nClass, int nFeatures, double noisePrec, int trainChunkSize, int testChunkSize)
{
this.nClass = nClass;
this.nFeatures = nFeatures;
this.trainChunkSize = trainChunkSize;
this.testChunkSize = testChunkSize;
NoisePrec = noisePrec;
feature = new Range(nFeatures).Named("feature");
// The set of weight vectors (one for each component) are shared between all data chunks
w = new SharedVariable<Vector>[nClass];
VectorGaussian wPrior0 = VectorGaussian.PointMass(Vector.Zero(nFeatures));
VectorGaussian wPrior = VectorGaussian.FromMeanAndPrecision(Vector.Zero(nFeatures), PositiveDefiniteMatrix.Identity(nFeatures));
for (int c = 0; c < nClass; c++)
{
w[c] = (c == 0)
? SharedVariable<Vector>.Random(VectorGaussian.PointMass(Vector.Zero(nFeatures))).Named("w_" + c)
: SharedVariable<Vector>.Random(wPrior).Named("w_" + c);
}
trainModel = SpecifyTrainModel("_train", trainChunkSize);
testModel = SpecifyTestModel("_test", testChunkSize);
}
public static void DrawSharedVariableValue(SharedVariable sharedVariable, int width)
{
if (sharedVariable == null)
{
return;
}
try
{
switch (sharedVariable.ValueType)
{
case SharedVariableTypes.Int:
sharedVariable.SetValue(EditorGUILayout.IntField((int)sharedVariable.GetValue(), new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Float:
sharedVariable.SetValue(EditorGUILayout.FloatField((float)sharedVariable.GetValue(), new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Bool:
sharedVariable.SetValue(EditorGUILayout.Toggle((bool)sharedVariable.GetValue(), EditorStyles.toggle, new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.String:
sharedVariable.SetValue(EditorGUILayout.TextField((string)sharedVariable.GetValue(), new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Vector2:
sharedVariable.SetValue(VariableInspector.Vector2Field((Vector2)sharedVariable.GetValue()));
break;
case SharedVariableTypes.Vector3:
sharedVariable.SetValue(VariableInspector.Vector3Field((Vector3)sharedVariable.GetValue()));
break;
case SharedVariableTypes.Vector4:
sharedVariable.SetValue(VariableInspector.Vector4Field((Vector4)sharedVariable.GetValue()));
break;
case SharedVariableTypes.Quaternion:
{
Vector4 vector = VariableInspector.QuaternionToVector4((Quaternion)sharedVariable.GetValue());
Vector4 vector2 = VariableInspector.Vector4Field(vector);
if (vector != vector2)
{
sharedVariable.SetValue(new Quaternion(vector2.x, vector2.y, vector2.z, vector2.w));
}
break;
}
case SharedVariableTypes.Color:
sharedVariable.SetValue(EditorGUILayout.ColorField((Color)sharedVariable.GetValue(), new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Rect:
sharedVariable.SetValue(EditorGUILayout.RectField((Rect)sharedVariable.GetValue(), new GUILayoutOption[0]));
break;
case SharedVariableTypes.GameObject:
sharedVariable.SetValue(EditorGUILayout.ObjectField((GameObject)sharedVariable.GetValue(), typeof(GameObject), true, new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Transform:
sharedVariable.SetValue(EditorGUILayout.ObjectField((Transform)sharedVariable.GetValue(), typeof(Transform), true, new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
case SharedVariableTypes.Object:
sharedVariable.SetValue(EditorGUILayout.ObjectField((UnityEngine.Object)sharedVariable.GetValue(), typeof(UnityEngine.Object), true, new GUILayoutOption[]
{
GUILayout.Width((float)width)
}));
break;
}
}
catch (Exception)
{
}
}
private void SharedVariables_SharedVariableAdded(SharedVariableCollection collection, SharedVariable variable)
{
if (variable == null)
return;
if (this.InvokeRequired)
{
if (!this.IsHandleCreated || this.Disposing || this.IsDisposed)
return;
this.BeginInvoke(dlgShvSharedVariableAdded, collection, variable);
return;
}
if(lvSharedVariables.Items.Count < (collection.Count -1))
{
UpdateSharedVariables();
return;
}
ListViewItem lvi = lvSharedVariables.Items.Add(variable.Name);
lvi.Tag = variable;
lvSharedVariables.Refresh();
}
public IEnumerator Do(SharedData share, SharedVariable variable)
{
prevActive = share.view.NameTextWindowImage.gameObject.activeSelf;
share.view.NameTextWindowImage.gameObject.SetActive(true);
yield break;
}
public IEnumerator Undo(SharedData share, SharedVariable variable)
{
yield break;
}
public IEnumerator Do(SharedData share, SharedVariable variable)
{
share.view.NameText.text += variable.FindValue(share.model_.parameters[0]);
yield break;
}
public IEnumerator Undo(SharedData share, SharedVariable variable)
{
// Groupまで巻き戻す
yield break;
}
private bool isValid(SharedVariable sv)
{
return(null != sv && !sv.IsNone);
}
private void LearnAPIClick5LabelModel(
int numLabels,
bool learnScoreMean,
bool learnScorePrec,
bool learnJudgePrec,
bool learnClickPrec,
bool learnThresholds,
double nominalScoreMean,
double nominalScorePrec,
double nominalJudgePrec,
double nominalClickPrec,
int[] labels,
int[] clicks,
int[] exams,
int chunkSize,
int nPasses,
bool printToConsole,
out Gaussian margScoreMean,
out Gamma margScorePrec,
out Gamma margJudgePrec,
out Gamma margClickPrec,
out Gaussian[] margThresh)
{
//------------------------------------------------------
// Observations
//------------------------------------------------------
Gaussian[][][] allObs = getClickObservations(numLabels, chunkSize, labels, clicks, exams);
int numChunks = allObs.Length;
////-------------------------------------------------------------
//// Prior distributions
////-------------------------------------------------------------
Gaussian priorScoreMean = Gaussian.FromMeanAndVariance(nominalScoreMean, learnScoreMean ? 1 : 0);
Gamma priorScorePrec = Gamma.FromMeanAndVariance(nominalScorePrec, learnScorePrec ? 1 : 0);
Gamma priorJudgePrec = Gamma.FromMeanAndVariance(nominalJudgePrec, learnJudgePrec ? 1 : 0);
Gamma priorClickPrec = Gamma.FromMeanAndVariance(nominalClickPrec, learnClickPrec ? 1 : 0);
Gaussian[] priorThreshMean;
CalculatePriors(learnThresholds, numLabels, out priorThreshMean);
////-----------------------------------------------------
//// Creates shared variables
////-----------------------------------------------------
int numThresholds = numLabels + 1;
SharedVariable <double> scoreMean = SharedVariable <double> .Random(priorScoreMean).Named("scoreMean");
SharedVariable <double> scorePrec = SharedVariable <double> .Random(priorScorePrec).Named("scorePrec");
SharedVariable <double> judgePrec = SharedVariable <double> .Random(priorJudgePrec).Named("judgePrec");
SharedVariable <double> clickPrec = SharedVariable <double> .Random(priorClickPrec).Named("clickPrec");
SharedVariable <double>[] thresholds = new SharedVariable <double> [numThresholds];
for (int t = 0; t < numThresholds; t++)
{
thresholds[t] = SharedVariable <double> .Random(priorThreshMean[t]).Named("threshMeans" + t);
}
//----------------------------------------------------------------------------------
// The model
//----------------------------------------------------------------------------------
Model model = new Model(numChunks);
VariableArray <Gaussian>[] clickObs = new VariableArray <Gaussian> [numLabels];
Variable <int>[] clickObsLength = new Variable <int> [numLabels];
for (int i = 0; i < numLabels; i++)
{
clickObsLength[i] = Variable.New <int>().Named("clickObsLength" + i);
Range r = new Range(clickObsLength[i]).Named("dataCount" + i);
clickObs[i] = Variable.Array <Gaussian>(r).Named("Obs" + i);
VariableArray <double> scores = Variable.Array <double>(r).Named("scores" + i);
VariableArray <double> scoresJ = Variable.Array <double>(r).Named("scoresJ" + i);
VariableArray <double> scoresC = Variable.Array <double>(r).Named("scoresC" + i);
scores[r] = Variable <double> .GaussianFromMeanAndPrecision(scoreMean.GetCopyFor(model), scorePrec.GetCopyFor(model)).ForEach(r);
scoresJ[r] = Variable <double> .GaussianFromMeanAndPrecision(scores[r], judgePrec.GetCopyFor(model));
scoresC[r] = Variable <double> .GaussianFromMeanAndPrecision(scores[r], clickPrec.GetCopyFor(model));
Variable.ConstrainBetween(scoresJ[r], thresholds[i].GetCopyFor(model), thresholds[i + 1].GetCopyFor(model));
Variable.ConstrainEqualRandom <double, Gaussian>(scoresC[r], clickObs[i][r]);
r.AddAttribute(new Sequential());
}
InferenceEngine engine = new InferenceEngine();
//----------------------------------------------------------
// Outer loop iterates over a number of passes
// Inner loop iterates over the unique labels
//----------------------------------------------------------
for (int pass = 0; pass < nPasses; pass++)
{
for (int c = 0; c < numChunks; c++)
{
for (int i = 0; i < numLabels; i++)
{
clickObsLength[i].ObservedValue = allObs[c][i].Length;
clickObs[i].ObservedValue = allObs[c][i];
}
// Infer the output messages
model.InferShared(engine, c);
if (printToConsole)
{
margScoreMean = scoreMean.Marginal <Gaussian>();
margScorePrec = scorePrec.Marginal <Gamma>();
margJudgePrec = judgePrec.Marginal <Gamma>();
margClickPrec = clickPrec.Marginal <Gamma>();
margThresh = new Gaussian[numThresholds];
for (int i = 0; i < numThresholds; i++)
{
margThresh[i] = thresholds[i].Marginal <Gaussian>();
}
Console.WriteLine("****** Pass {0}, chunk {1} ******", pass, c);
Console.WriteLine("----- Marginals -----");
Console.WriteLine("scoreMean = {0}", margScoreMean);
Console.WriteLine("scorePrec = {0}", margScorePrec);
Console.WriteLine("judgePrec = {0}", margJudgePrec);
Console.WriteLine("clickPrec = {0}", margClickPrec);
for (int t = 0; t < numThresholds; t++)
{
Console.WriteLine("threshMean {0} = {1}", t, margThresh[t]);
}
}
}
}
margScoreMean = scoreMean.Marginal <Gaussian>();
margScorePrec = scorePrec.Marginal <Gamma>();
margJudgePrec = judgePrec.Marginal <Gamma>();
margClickPrec = clickPrec.Marginal <Gamma>();
margThresh = new Gaussian[numThresholds];
for (int i = 0; i < numThresholds; i++)
{
margThresh[i] = thresholds[i].Marginal <Gaussian>();
}
}
private void LearnClick5LabelModel(
int numLabels,
bool learnScoreMean,
bool learnScorePrec,
bool learnJudgePrec,
bool learnClickPrec,
bool learnThresholds,
double nominalScoreMean,
double nominalScorePrec,
double nominalJudgePrec,
double nominalClickPrec,
int[] labels,
int[] clicks,
int[] exams,
int chunkSize,
int nPasses,
bool printToConsole,
out Gaussian margScoreMean,
out Gamma margScorePrec,
out Gamma margJudgePrec,
out Gamma margClickPrec,
out Gaussian[] margThresh)
{
InferenceEngine engine = new InferenceEngine();
int numThresholds = numLabels + 1; // Includes end-points
//-------------------------------------------------------------
// Priors
//-------------------------------------------------------------
Gaussian priorScoreMean = Gaussian.FromMeanAndVariance(nominalScoreMean, learnScoreMean ? 1 : 0);
Gamma priorScorePrec = Gamma.FromMeanAndVariance(nominalScorePrec, learnScorePrec ? 1 : 0);
Gamma priorJudgePrec = Gamma.FromMeanAndVariance(nominalJudgePrec, learnJudgePrec ? 1 : 0);
Gamma priorClickPrec = Gamma.FromMeanAndVariance(nominalClickPrec, learnClickPrec ? 1 : 0);
Gaussian[] priorThreshMean;
CalculatePriors(learnThresholds, numLabels, out priorThreshMean);
//------------------------------------------------------
// Observations
//------------------------------------------------------
Gaussian[][][] clickObs = getClickObservations(numLabels, chunkSize, labels, clicks, exams);
int numChunks = clickObs.Length;
//-----------------------------------------------------
// Create an array of batch variables
//-----------------------------------------------------
Model model = new Model(numChunks);
SharedVariable <double, Gaussian> scoreMean = (SharedVariable <double, Gaussian>) SharedVariable <double> .Random(priorScoreMean).Named("scoreMean");
SharedVariable <double, Gamma> scorePrec = (SharedVariable <double, Gamma>) SharedVariable <double> .Random(priorScorePrec).Named("scorePrec");
SharedVariable <double, Gamma> judgePrec = (SharedVariable <double, Gamma>) SharedVariable <double> .Random(priorJudgePrec).Named("judgePrec");
SharedVariable <double, Gamma> clickPrec = (SharedVariable <double, Gamma>) SharedVariable <double> .Random(priorClickPrec).Named("clickPrec");
SharedVariable <double, Gaussian>[] threshMeans = new SharedVariable <double, Gaussian> [numThresholds];
for (int t = 0; t < numThresholds; t++)
{
threshMeans[t] = (SharedVariable <double, Gaussian>) SharedVariable <double, Gaussian> .Random(priorThreshMean[t]).Named("threshMeans" + t);
}
engine.Compiler.DeclarationProvider = Microsoft.ML.Probabilistic.Compiler.RoslynDeclarationProvider.Instance;
var info = GetType().GetMethod("Click5LabelModel", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var ca = engine.Compiler.CompileWithoutParams(info);
//----------------------------------------------------------
// Outer loop iterates over a number of passes
// Inner loop iterates over the unique labels
//----------------------------------------------------------
for (int pass = 0; pass < nPasses; pass++)
{
for (int c = 0; c < numChunks; c++)
{
Gaussian[] threshInputs = new Gaussian[threshMeans.Length];
for (int i = 0; i < threshInputs.Length; i++)
{
threshInputs[i] = ((SharedVariable <double, Gaussian>)threshMeans[i]).MessageToBatch(model, c);
}
ca.SetObservedValue("inputScoreMean", scoreMean.MessageToBatch(model, c));
ca.SetObservedValue("inputScorePrec", scorePrec.MessageToBatch(model, c));
ca.SetObservedValue("inputJudgePrec", judgePrec.MessageToBatch(model, c));
ca.SetObservedValue("inputClickPrec", clickPrec.MessageToBatch(model, c));
ca.SetObservedValue("inputThresh", threshInputs);
ca.SetObservedValue("clickObservations", clickObs[c]);
ca.Execute(10);
// Retrieve the output messages
model.InferShared(ca, c);
if (printToConsole)
{
Console.WriteLine("****** Pass {0}, chunk {1} ******", pass, c);
Console.WriteLine("----- Marginals -----");
Console.WriteLine("scoreMean = {0}", scoreMean.Marginal <Gaussian>());
Console.WriteLine("scorePrec = {0}", scorePrec.Marginal <Gamma>());
Console.WriteLine("judgePrec = {0}", judgePrec.Marginal <Gamma>());
Console.WriteLine("clickPrec = {0}", clickPrec.Marginal <Gamma>());
for (int t = 0; t < numThresholds; t++)
{
Console.WriteLine("threshMean {0} = {1}", t, threshMeans[t].Marginal <Gaussian>());
}
}
}
}
margScoreMean = scoreMean.Marginal <Gaussian>();
margScorePrec = scorePrec.Marginal <Gamma>();
margJudgePrec = judgePrec.Marginal <Gamma>();
margClickPrec = clickPrec.Marginal <Gamma>();
margThresh = new Gaussian[numThresholds];
for (int i = 0; i < margThresh.Length; i++)
{
margThresh[i] = threshMeans[i].Marginal <Gaussian>();
}
}
// Token: 0x060002BF RID: 703 RVA: 0x0001B53C File Offset: 0x0001973C
private static bool DrawSelectedVariable(IVariableSource variableSource, ref List <SharedVariable> variables, SharedVariable sharedVariable, ref int selectedVariableIndex, ref string selectedVariableName, ref int selectedVariableTypeIndex, ref bool deleted)
{
bool result = false;
GUILayout.BeginVertical(BehaviorDesignerUtility.SelectedBackgroundGUIStyle, new GUILayoutOption[0]);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Label("Name", new GUILayoutOption[]
{
GUILayout.Width(70f)
});
EditorGUI.BeginChangeCheck();
selectedVariableName = GUILayout.TextField(selectedVariableName, new GUILayoutOption[]
{
GUILayout.Width(140f)
});
if (EditorGUI.EndChangeCheck())
{
if (VariableInspector.VariableNameValid(variableSource, selectedVariableName))
{
variableSource.UpdateVariableName(sharedVariable, selectedVariableName);
}
result = true;
}
GUILayout.Space(10f);
bool enabled = GUI.enabled;
GUI.enabled = (enabled && selectedVariableIndex < variables.Count - 1);
if (GUILayout.Button(BehaviorDesignerUtility.DownArrowButtonTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(19f)
}))
{
SharedVariable value = variables[selectedVariableIndex + 1];
variables[selectedVariableIndex + 1] = variables[selectedVariableIndex];
variables[selectedVariableIndex] = value;
selectedVariableIndex++;
result = true;
}
GUI.enabled = (enabled && (selectedVariableIndex < variables.Count - 1 || selectedVariableIndex != 0));
GUILayout.Box(string.Empty, BehaviorDesignerUtility.ArrowSeparatorGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(1f),
GUILayout.Height(18f)
});
GUI.enabled = (enabled && selectedVariableIndex != 0);
if (GUILayout.Button(BehaviorDesignerUtility.UpArrowButtonTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(20f)
}))
{
SharedVariable value2 = variables[selectedVariableIndex - 1];
variables[selectedVariableIndex - 1] = variables[selectedVariableIndex];
variables[selectedVariableIndex] = value2;
selectedVariableIndex--;
result = true;
}
GUI.enabled = enabled;
if (GUILayout.Button(BehaviorDesignerUtility.VariableDeleteButtonTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(19f)
}) && EditorUtility.DisplayDialog("Delete Variable", "Are you sure you want to delete this variable?", "Yes", "No"))
{
deleted = true;
}
GUILayout.EndHorizontal();
GUILayout.Space(2f);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.Label("Type", new GUILayoutOption[]
{
GUILayout.Width(70f)
});
EditorGUI.BeginChangeCheck();
selectedVariableTypeIndex = EditorGUILayout.Popup(selectedVariableTypeIndex, VariableInspector.sharedVariableStrings, EditorStyles.toolbarPopup, new GUILayoutOption[]
{
GUILayout.Width(200f)
});
if (EditorGUI.EndChangeCheck() && VariableInspector.sharedVariableTypesDict[sharedVariable.GetType().Name] != selectedVariableTypeIndex)
{
if (BehaviorDesignerWindow.instance != null)
{
BehaviorDesignerWindow.instance.RemoveSharedVariableReferences(sharedVariable);
}
sharedVariable = VariableInspector.CreateVariable(selectedVariableTypeIndex, sharedVariable.Name, sharedVariable.IsGlobal);
variables[selectedVariableIndex] = sharedVariable;
result = true;
}
GUILayout.EndHorizontal();
EditorGUI.BeginChangeCheck();
GUILayout.Space(4f);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUI.enabled = VariableInspector.CanNetworkSync(sharedVariable.GetType().GetProperty("Value").PropertyType);
EditorGUI.BeginChangeCheck();
sharedVariable.NetworkSync = EditorGUILayout.Toggle(new GUIContent("Network Sync", "Sync this variable over the network. Requires Unity 5.1 or greator. A NetworkIdentity must be attached to the behavior tree GameObject."), sharedVariable.NetworkSync, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
result = true;
}
GUILayout.EndHorizontal();
GUI.enabled = enabled;
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
if (VariableInspector.DrawSharedVariable(variableSource, sharedVariable, true))
{
result = true;
}
if (BehaviorDesignerWindow.instance != null && BehaviorDesignerWindow.instance.ContainsError(null, selectedVariableIndex))
{
GUILayout.Box(BehaviorDesignerUtility.ErrorIconTexture, BehaviorDesignerUtility.PlainTextureGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(20f)
});
}
GUILayout.EndHorizontal();
BehaviorDesignerUtility.DrawContentSeperator(4, 7);
GUILayout.EndVertical();
GUILayout.Space(3f);
return(result);
}
// Token: 0x060002BD RID: 701 RVA: 0x0001B144 File Offset: 0x00019344
public static bool DrawAllVariables(bool showFooter, IVariableSource variableSource, ref List <SharedVariable> variables, bool canSelect, ref List <float> variablePosition, ref int selectedVariableIndex, ref string selectedVariableName, ref int selectedVariableTypeIndex, bool drawRemoveButton, bool drawLastSeparator)
{
if (variables == null)
{
return(false);
}
bool result = false;
if (canSelect && variablePosition == null)
{
variablePosition = new List <float>();
}
for (int i = 0; i < variables.Count; i++)
{
SharedVariable sharedVariable = variables[i];
if (sharedVariable != null)
{
if (canSelect && selectedVariableIndex == i)
{
if (i == 0)
{
GUILayout.Space(2f);
}
bool flag = false;
if (VariableInspector.DrawSelectedVariable(variableSource, ref variables, sharedVariable, ref selectedVariableIndex, ref selectedVariableName, ref selectedVariableTypeIndex, ref flag))
{
result = true;
}
if (flag)
{
if (BehaviorDesignerWindow.instance != null)
{
BehaviorDesignerWindow.instance.RemoveSharedVariableReferences(sharedVariable);
}
variables.RemoveAt(i);
if (selectedVariableIndex == i)
{
selectedVariableIndex = -1;
}
else if (selectedVariableIndex > i)
{
selectedVariableIndex--;
}
result = true;
break;
}
}
else
{
GUILayout.BeginHorizontal();
if (VariableInspector.DrawSharedVariable(variableSource, sharedVariable, false))
{
result = true;
}
if (drawRemoveButton && GUILayout.Button(BehaviorDesignerUtility.VariableDeleteButtonTexture, BehaviorDesignerUtility.PlainButtonGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(19f)
}) && EditorUtility.DisplayDialog("Delete Variable", "Are you sure you want to delete this variable?", "Yes", "No"))
{
if (BehaviorDesignerWindow.instance != null)
{
BehaviorDesignerWindow.instance.RemoveSharedVariableReferences(sharedVariable);
}
variables.RemoveAt(i);
if (canSelect)
{
if (selectedVariableIndex == i)
{
selectedVariableIndex = -1;
}
else if (selectedVariableIndex > i)
{
selectedVariableIndex--;
}
}
result = true;
break;
}
if (BehaviorDesignerWindow.instance != null && BehaviorDesignerWindow.instance.ContainsError(null, i))
{
GUILayout.Box(BehaviorDesignerUtility.ErrorIconTexture, BehaviorDesignerUtility.PlainTextureGUIStyle, new GUILayoutOption[]
{
GUILayout.Width(20f)
});
}
GUILayout.Space(10f);
GUILayout.EndHorizontal();
if (i != variables.Count - 1 || drawLastSeparator)
{
BehaviorDesignerUtility.DrawContentSeperator(2, 7);
}
}
GUILayout.Space(4f);
if (canSelect && (int)Event.current.type == 7)
{
if (variablePosition.Count <= i)
{
variablePosition.Add(GUILayoutUtility.GetLastRect().yMax);
}
else
{
variablePosition[i] = GUILayoutUtility.GetLastRect().yMax;
}
}
}
}
if (canSelect && variables.Count < variablePosition.Count)
{
for (int j = variablePosition.Count - 1; j >= variables.Count; j--)
{
variablePosition.RemoveAt(j);
}
}
if (showFooter && variables.Count > 0)
{
GUI.enabled = true;
GUILayout.Label("Select a variable to change its properties.", BehaviorDesignerUtility.LabelWrapGUIStyle, new GUILayoutOption[0]);
}
return(result);
}
private static object LoadField(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, Type fieldType, string fieldName, IVariableSource variableSource, object obj = null, FieldInfo fieldInfo = null)
{
string text = fieldType.Name + fieldName;
int num;
if (fieldIndexMap.TryGetValue(text, out num))
{
object obj2 = null;
if (typeof(IList).IsAssignableFrom(fieldType))
{
int num2 = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
if (fieldType.IsArray)
{
Type elementType = fieldType.GetElementType();
if (elementType == null)
{
return(null);
}
Array array = Array.CreateInstance(elementType, num2);
for (int i = 0; i < num2; i++)
{
object obj3 = LoadField(fieldSerializationData, fieldIndexMap, elementType, text + i, variableSource, obj, fieldInfo);
array.SetValue((!ReferenceEquals(obj3, null) && !obj3.Equals(null)) ? obj3 : null, i);
}
obj2 = array;
}
else
{
Type type = fieldType;
while (!type.IsGenericType)
{
type = type.BaseType;
}
Type type2 = type.GetGenericArguments()[0];
IList list;
if (fieldType.IsGenericType)
{
list = (TaskUtility.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type2
})) as IList);
}
else
{
list = (TaskUtility.CreateInstance(fieldType) as IList);
}
for (int j = 0; j < num2; j++)
{
object obj4 = LoadField(fieldSerializationData, fieldIndexMap, type2, text + j, variableSource, obj, fieldInfo);
list.Add((!ReferenceEquals(obj4, null) && !obj4.Equals(null)) ? obj4 : null);
}
obj2 = list;
}
}
else if (typeof(Task).IsAssignableFrom(fieldType))
{
if (fieldInfo != null && TaskUtility.HasAttribute(fieldInfo, typeof(InspectTaskAttribute)))
{
string text2 = BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], GetFieldSize(fieldSerializationData, num));
if (!string.IsNullOrEmpty(text2))
{
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text2);
if (typeWithinAssembly != null)
{
obj2 = TaskUtility.CreateInstance(typeWithinAssembly);
LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
}
}
}
else
{
if (taskIDs == null)
{
taskIDs = new Dictionary <ObjectFieldMap, List <int> >(new ObjectFieldMapComparer());
}
int item = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
ObjectFieldMap key = new ObjectFieldMap(obj, fieldInfo);
if (taskIDs.ContainsKey(key))
{
taskIDs[key].Add(item);
}
else
{
List <int> list2 = new List <int>();
list2.Add(item);
taskIDs.Add(key, list2);
}
}
}
else if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
obj2 = BytesToSharedVariable(fieldSerializationData, fieldIndexMap, fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], variableSource, true, text);
}
else if (typeof(UnityEngine.Object).IsAssignableFrom(fieldType))
{
int index = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
obj2 = IndexToUnityObject(index, fieldSerializationData);
}
else if (fieldType.Equals(typeof(int)) || fieldType.IsEnum)
{
obj2 = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(uint)))
{
obj2 = BytesToUInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(float)))
{
obj2 = BytesToFloat(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(double)))
{
obj2 = BytesToDouble(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(long)))
{
obj2 = BinaryDeserialization.BytesToLong(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(bool)))
{
obj2 = BinaryDeserialization.BytesToBool(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(string)))
{
obj2 = BinaryDeserialization.BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], BinaryDeserialization.GetFieldSize(fieldSerializationData, num));
}
else if (fieldType.Equals(typeof(byte)))
{
obj2 = BinaryDeserialization.BytesToByte(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector2)))
{
obj2 = BinaryDeserialization.BytesToVector2(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector3)))
{
obj2 = BinaryDeserialization.BytesToVector3(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector4)))
{
obj2 = BinaryDeserialization.BytesToVector4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Quaternion)))
{
obj2 = BinaryDeserialization.BytesToQuaternion(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Color)))
{
obj2 = BinaryDeserialization.BytesToColor(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Rect)))
{
obj2 = BinaryDeserialization.BytesToRect(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Matrix4x4)))
{
obj2 = BinaryDeserialization.BytesToMatrix4x4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(AnimationCurve)))
{
obj2 = BinaryDeserialization.BytesToAnimationCurve(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(LayerMask)))
{
obj2 = BinaryDeserialization.BytesToLayerMask(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.IsClass || (fieldType.IsValueType && !fieldType.IsPrimitive))
{
obj2 = TaskUtility.CreateInstance(fieldType);
BinaryDeserialization.LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
return(obj2);
}
return(obj2);
}
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
Type type3 = TaskUtility.SharedVariableToConcreteType(fieldType);
if (type3 == null)
{
return(null);
}
text = type3.Name + fieldName;
if (fieldIndexMap.ContainsKey(text))
{
SharedVariable sharedVariable = TaskUtility.CreateInstance(fieldType) as SharedVariable;
sharedVariable.SetValue(BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, type3, fieldName, variableSource, null, null));
return(sharedVariable);
}
}
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
return(TaskUtility.CreateInstance(fieldType));
}
return(null);
}
/// <summary>
/// Constructs an LDA model
/// </summary>
/// <param name="sizeVocab">Size of vocabulary</param>
/// <param name="numTopics">Number of topics</param>
public LDAShared(int numBatches, int sizeVocab, int numTopics)
{
SizeVocab = sizeVocab;
NumTopics = numTopics;
ThetaSparsity = Sparsity.Dense;
PhiSparsity = Sparsity.ApproximateWithTolerance(0.00000000001); // Allow for round-off error
NumDocuments = Variable.New<int>().Named("NumDocuments");
NumBatches = numBatches;
IterationsPerPass = new int[] { 1, 3, 5, 7, 9 };
//---------------------------------------------
// The model
//---------------------------------------------
Range D = new Range(NumDocuments).Named("D");
Range W = new Range(SizeVocab).Named("W");
Range T = new Range(NumTopics).Named("T");
NumWordsInDoc = Variable.Array<int>(D).Named("NumWordsInDoc");
Range WInD = new Range(NumWordsInDoc[D]).Named("WInD");
Evidence = SharedVariable<bool>.Random(new Bernoulli(0.5)).Named("Evidence");
Evidence.IsEvidenceVariable = true;
Phi = SharedVariable<Vector>.Random(T, CreateUniformDirichletArray(numTopics, sizeVocab, PhiSparsity)).Named("Phi");
// Phi definition sub-model - just one copy
PhiDefModel = new Model(1).Named("PhiDefModel");
IfBlock evidencePhiDefBlock = null;
EvidencePhiDef = Evidence.GetCopyFor(PhiDefModel).Named("EvidencePhiDef");
evidencePhiDefBlock = Variable.If(EvidencePhiDef);
PhiDef = Variable.Array<Vector>(T).Named("PhiDef");
PhiDef.SetSparsity(PhiSparsity);
PhiDef.SetValueRange(W);
PhiPrior = Variable.Array<Dirichlet>(T).Named("PhiPrior");
PhiDef[T] = Variable<Vector>.Random(PhiPrior[T]);
Phi.SetDefinitionTo(PhiDefModel, PhiDef);
evidencePhiDefBlock.CloseBlock();
// Document sub-model - many copies
DocModel = new Model(numBatches).Named("DocModel");
IfBlock evidenceDocBlock = null;
EvidenceDoc = Evidence.GetCopyFor(DocModel).Named("EvidenceDoc");
evidenceDocBlock = Variable.If(EvidenceDoc);
Theta = Variable.Array<Vector>(D).Named("Theta");
Theta.SetSparsity(ThetaSparsity);
Theta.SetValueRange(T);
ThetaPrior = Variable.Array<Dirichlet>(D).Named("ThetaPrior");
Theta[D] = Variable<Vector>.Random(ThetaPrior[D]);
PhiDoc = Phi.GetCopyFor(DocModel);
PhiDoc.AddAttribute(new MarginalPrototype(Dirichlet.Uniform(sizeVocab, PhiSparsity)));
Words = Variable.Array(Variable.Array<int>(WInD), D).Named("Words");
WordCounts = Variable.Array(Variable.Array<double>(WInD), D).Named("WordCounts");
using (Variable.ForEach(D))
{
using (Variable.ForEach(WInD))
{
using (Variable.Repeat(WordCounts[D][WInD]))
{
Variable<int> topic = Variable.Discrete(Theta[D]).Named("topic");
using (Variable.Switch(topic))
Words[D][WInD] = Variable.Discrete(PhiDoc[topic]);
}
}
}
evidenceDocBlock.CloseBlock();
// Initialization to break symmetry
ThetaInit = Variable.New<IDistribution<Vector[]>>().Named("ThetaInit");
Theta.InitialiseTo(ThetaInit);
EnginePhiDef = new InferenceEngine(new VariationalMessagePassing());
EnginePhiDef.Compiler.ShowWarnings = false;
EnginePhiDef.ModelName = "LDASharedPhiDef";
Engine = new InferenceEngine(new VariationalMessagePassing());
Engine.OptimiseForVariables = new IVariable[] { Theta, PhiDoc, EvidenceDoc };
Engine.Compiler.ShowWarnings = false;
Engine.ModelName = "LDAShared";
Engine.Compiler.ReturnCopies = false;
Engine.Compiler.FreeMemory = true;
}
/// <summary>
/// Executes a create_var command.
/// Requests the blackboard to create a variable with the specified name and size
/// </summary>
/// <param name="command">Command to execute</param>
protected virtual void CreateVarCommand(Command command)
{
SharedVariable variable;
bool result;
SharedVariableCollection sharedVariables = this.Parent.VirtualModule.SharedVariables;
Match match = SharedVariable.RxCreateSharedVariableValidator.Match(command.Parameters);
if (!match.Success)
{
SendResponse(command, false);
this.Parent.Log.WriteLine(7, this.Name + ": attempt to create variable failed");
return;
}
string varName = match.Result("${name}");
string varType = match.Result("${type}");
bool isArray = false;
string sArraySize;
int arraySize = -1;
if (String.IsNullOrEmpty(varType))
varType = "var";
if (!String.IsNullOrEmpty(match.Result("${array}")))
{
isArray = true;
sArraySize = match.Result("${size}");
if (!String.IsNullOrEmpty(sArraySize))
arraySize = Int32.Parse(sArraySize);
}
if (sharedVariables.Contains(varName))
{
variable = sharedVariables[varName];
result = variable.Type == varType;
result &= variable.IsArray == isArray;
result &= arraySize == variable.Size;
SendResponse(command, result);
this.Parent.Log.WriteLine(7, this.Name + ": attempt to create variable failed (already exists)");
return;
}
SharedVariable sv = new SharedVariable(this, varType, varName, isArray, arraySize);
sv.AllowedWriters.Add("*");
sharedVariables.Add(sv);
SendResponse(command, true);
if (this.Parent.Log.VerbosityTreshold < 3)
this.Parent.Log.WriteLine(2, this.Name + ": created variable " + varName);
else
this.Parent.Log.WriteLine(3, this.Name + ": created variable " + varName + " with " + Clamper.Clamp(command.StringToSend, 256));
}
public static SharedVariable DrawSharedVariable(Task task, GUIContent guiContent, FieldInfo fieldInfo, Type fieldType, SharedVariable sharedVariable)
{
if (!fieldType.Equals(typeof(SharedVariable)) && sharedVariable == null)
{
sharedVariable = (Activator.CreateInstance(fieldType, true) as SharedVariable);
if (TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) || TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable.IsShared = true;
}
GUI.changed = true;
}
if (sharedVariable == null || sharedVariable.IsShared)
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
string[] array = null;
int num = -1;
int num2 = FieldInspector.GetVariablesOfType((sharedVariable == null) ? null : sharedVariable.GetType().GetProperty("Value").PropertyType, sharedVariable != null && sharedVariable.IsGlobal, (sharedVariable == null) ? string.Empty : sharedVariable.Name, FieldInspector.behaviorSource, out array, ref num, fieldType.Equals(typeof(SharedVariable)));
Color backgroundColor = GUI.backgroundColor;
if (num2 == 0 && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
GUI.backgroundColor = Color.red;
}
int num3 = num2;
num2 = EditorGUILayout.Popup(guiContent.text, num2, array, BehaviorDesignerUtility.SharedVariableToolbarPopup, new GUILayoutOption[0]);
GUI.backgroundColor = backgroundColor;
if (num2 != num3)
{
if (num2 == 0)
{
if (fieldType.Equals(typeof(SharedVariable)))
{
sharedVariable = null;
}
else
{
sharedVariable = (Activator.CreateInstance(fieldType, true) as SharedVariable);
sharedVariable.IsShared = true;
}
}
else if (num != -1 && num2 >= num)
{
sharedVariable = GlobalVariables.Instance.GetVariable(array[num2].Substring(8, array[num2].Length - 8));
}
else
{
sharedVariable = FieldInspector.behaviorSource.GetVariable(array[num2]);
}
GUI.changed = true;
}
if (!fieldType.Equals(typeof(SharedVariable)) && !TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable = FieldInspector.DrawSharedVariableToggleSharedButton(sharedVariable);
GUILayout.Space(-3f);
}
GUILayout.EndHorizontal();
GUILayout.Space(3f);
}
else
{
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
ObjectDrawerAttribute[] array2;
ObjectDrawer objectDrawer;
if (fieldInfo != null && (array2 = (fieldInfo.GetCustomAttributes(typeof(ObjectDrawerAttribute), true) as ObjectDrawerAttribute[])).Length > 0 && (objectDrawer = ObjectDrawerUtility.GetObjectDrawer(task, array2[0])) != null)
{
objectDrawer.Value = sharedVariable;
objectDrawer.OnGUI(guiContent);
}
else
{
FieldInspector.DrawFields(task, sharedVariable, guiContent);
}
if (!TaskUtility.HasAttribute(fieldInfo, typeof(RequiredFieldAttribute)) && !TaskUtility.HasAttribute(fieldInfo, typeof(SharedRequiredAttribute)))
{
sharedVariable = FieldInspector.DrawSharedVariableToggleSharedButton(sharedVariable);
}
GUILayout.EndHorizontal();
}
return(sharedVariable);
}
/// <summary>
/// Constructs an LDA model
/// </summary>
/// <param name="numBatches">Number of batches</param>
/// <param name="sizeVocab">Size of vocabulary</param>
/// <param name="numTopics">Number of topics</param>
public LDAShared(int numBatches, int sizeVocab, int numTopics)
{
SizeVocab = sizeVocab;
NumTopics = numTopics;
ThetaSparsity = Sparsity.Dense;
PhiSparsity = Sparsity.ApproximateWithTolerance(1e-11); // Allow for round-off error
NumDocuments = Variable.New <int>().Named("NumDocuments");
NumBatches = numBatches;
IterationsPerPass = new[] { 1, 3, 5, 7, 9 };
//---------------------------------------------
// The model
//---------------------------------------------
var D = new Range(NumDocuments).Named("D");
var W = new Range(SizeVocab).Named("W");
var T = new Range(NumTopics).Named("T");
NumWordsInDoc = Variable.Array <int>(D).Named("NumWordsInDoc");
var WInD = new Range(NumWordsInDoc[D]).Named("WInD");
Evidence = SharedVariable <bool> .Random(new Bernoulli(0.5)).Named("Evidence");
Evidence.IsEvidenceVariable = true;
Phi = SharedVariable <Vector> .Random(T, CreateUniformDirichletArray(numTopics, sizeVocab, PhiSparsity)).Named("Phi");
// Phi definition sub-model - just one copy
PhiDefModel = new Model(1).Named("PhiDefModel");
IfBlock evidencePhiDefBlock = null;
EvidencePhiDef = Evidence.GetCopyFor(PhiDefModel).Named("EvidencePhiDef");
evidencePhiDefBlock = Variable.If(EvidencePhiDef);
PhiDef = Variable.Array <Vector>(T).Named("PhiDef");
PhiDef.SetSparsity(PhiSparsity);
PhiDef.SetValueRange(W);
PhiPrior = Variable.Array <Dirichlet>(T).Named("PhiPrior");
PhiDef[T] = Variable <Vector> .Random(PhiPrior[T]);
Phi.SetDefinitionTo(PhiDefModel, PhiDef);
evidencePhiDefBlock.CloseBlock();
// Document sub-model - many copies
DocModel = new Model(numBatches).Named("DocModel");
IfBlock evidenceDocBlock = null;
EvidenceDoc = Evidence.GetCopyFor(DocModel).Named("EvidenceDoc");
evidenceDocBlock = Variable.If(EvidenceDoc);
Theta = Variable.Array <Vector>(D).Named("Theta");
Theta.SetSparsity(ThetaSparsity);
Theta.SetValueRange(T);
ThetaPrior = Variable.Array <Dirichlet>(D).Named("ThetaPrior");
Theta[D] = Variable <Vector> .Random(ThetaPrior[D]);
PhiDoc = Phi.GetCopyFor(DocModel);
PhiDoc.AddAttribute(new MarginalPrototype(Dirichlet.Uniform(sizeVocab, PhiSparsity)));
Words = Variable.Array(Variable.Array <int>(WInD), D).Named("Words");
WordCounts = Variable.Array(Variable.Array <double>(WInD), D).Named("WordCounts");
using (Variable.ForEach(D))
{
using (Variable.ForEach(WInD))
{
using (Variable.Repeat(WordCounts[D][WInD]))
{
var topic = Variable.Discrete(Theta[D]).Named("topic");
using (Variable.Switch(topic))
{
Words[D][WInD] = Variable.Discrete(PhiDoc[topic]);
}
}
}
}
evidenceDocBlock.CloseBlock();
// Initialization to break symmetry
ThetaInit = Variable.New <IDistribution <Vector[]> >().Named("ThetaInit");
Theta.InitialiseTo(ThetaInit);
EnginePhiDef = new InferenceEngine(new VariationalMessagePassing());
EnginePhiDef.Compiler.ShowWarnings = false;
EnginePhiDef.ModelName = "LDASharedPhiDef";
Engine = new InferenceEngine(new VariationalMessagePassing())
{
OptimiseForVariables = new IVariable[] { Theta, PhiDoc, EvidenceDoc }
};
Engine.Compiler.ShowWarnings = false;
Engine.ModelName = "LDAShared";
Engine.Compiler.ReturnCopies = false;
Engine.Compiler.FreeMemory = true;
}
/// <summary>
/// Creates and configures the shared variables specified in the provided XML document for the specified blackboard
/// </summary>
/// <param name="doc">XML document which contains shared variables initialization data</param>
/// <param name="blackboard">Blackboard object in which the shared variables will be configured</param>
private static void SetupSharedVariables(XmlDocument doc, Blackboard blackboard)
{
if ((doc == null) || (blackboard == null))
throw new ArgumentNullException();
if (blackboard.virtualModule == null)
throw new Exception("Uninitialized blackboard");
int i, j;
ILogWriter log;
XmlDocument tmpDoc;
XmlNode node;
XmlNodeList xmlVarList;
XmlNodeList xmlWriterModuleList;
SharedVariable shVar;
List<string> writers;
string shVarName;
string shVarType;
string shVarValue;
bool shVarIsArray;
int bracketPos;
log = blackboard.log;
tmpDoc = new XmlDocument();
if (doc.GetElementsByTagName("sharedVariables").Count < 1)
{
log.WriteLine(1, "No shared variables was defined in XML file.");
return;
}
tmpDoc.LoadXml(doc.GetElementsByTagName("sharedVariables")[0].OuterXml);
#region Load of shared variables
// Load of shared variables
log.WriteLine(1, "Reading shared variables");
xmlVarList = tmpDoc.GetElementsByTagName("var");
for (i = 0; i < xmlVarList.Count; ++i)
{
#region Get variable Name
node = xmlVarList[i];
if ((node == null) || (node.Name != "var") || (node.Attributes["name"] == null))
continue;
shVarName = node.Attributes["name"].InnerText;
shVarType = (node.Attributes["type"] != null) ? node.Attributes["type"].InnerText : "var";
if (String.IsNullOrEmpty(shVarType) || !SharedVariable.RxVarTypeValidator.IsMatch(shVarType))
shVarType = "var";
bracketPos = shVarType.IndexOf("[");
if (shVarIsArray = (bracketPos != -1))
shVarType = shVarType.Remove(bracketPos);
if (blackboard.VirtualModule.SharedVariables.Contains(shVarName))
{
log.WriteLine(2, "Error loading shared variable " + shVarName + ". Variable already exists.");
continue;
}
#endregion
#region Get variable initial value
shVarValue = "";
if (node.Attributes["value"] != null)
{
shVarValue = node.Attributes["value"].Value;
}
else if (node.Attributes["fromFile"] != null)
{
shVarValue = node.Attributes["fromFile"].Value;
if (File.Exists(shVarValue))
{
try
{
shVarValue = File.ReadAllText(shVarValue);
}
catch
{
log.WriteLine(2, "Error loading variable content from file " + shVarValue + " for the shared variable " + shVarName + ". Variable was set to null");
shVarValue = "";
}
}
}
#endregion
#region Get list of modules with write permission
writers = new List<string>();
tmpDoc = new XmlDocument();
tmpDoc.LoadXml(node.OuterXml);
xmlWriterModuleList = tmpDoc.GetElementsByTagName("writers");
if (xmlWriterModuleList.Count == 1)
{
writers.Add(blackboard.VirtualModule.Name);
tmpDoc = new XmlDocument();
tmpDoc.LoadXml(xmlWriterModuleList[0].OuterXml);
xmlWriterModuleList = tmpDoc.GetElementsByTagName("writer");
for (j = 0; j < xmlWriterModuleList.Count; ++j)
{
node = xmlWriterModuleList[j];
if (node.InnerText == "*")
{
writers.Clear();
writers.Add("*");
break;
}
if (!blackboard.modules.Contains(node.InnerText))
continue;
else
writers.Add(node.InnerText);
/*
if (!writers.Contains(node.InnerText))
writers.Add(node.InnerText);
*/
}
}
else
writers.Add("*");
#endregion
#region Create and add the shared variable
shVar = new SharedVariable(blackboard.VirtualModule, shVarType, shVarName, shVarIsArray, -1);
//shVar.Data = shVarValue;
shVar.WriteStringData(blackboard.VirtualModule, shVarType, -1, shVarValue);
writers.Sort();
shVar.AllowedWriters = writers;
blackboard.VirtualModule.SharedVariables.Add(shVar);
log.WriteLine(4, "Added shared variable " + shVarType +" "+ shVarName);
#endregion
}
#endregion
}
/// <summary>
/// Initializes a new instance of SharedVariableInspectorWrapper
/// </summary>
public SharedVariableInspectorWrapper(SharedVariable sharedVar)
{
if (sharedVar == null)
throw new ArgumentNullException();
this.sharedVar = sharedVar;
}
public IEnumerator Undo(SharedData share, SharedVariable variable)
{
share.view.TextWindowImage.gameObject.SetActive(prevActive);
yield break;
}
// Token: 0x06000105 RID: 261 RVA: 0x00009A58 File Offset: 0x00007C58
public static void Load(TaskSerializationData taskData, BehaviorSource behaviorSource)
{
behaviorSource.EntryTask = null;
behaviorSource.RootTask = null;
behaviorSource.DetachedTasks = null;
behaviorSource.Variables = null;
FieldSerializationData fieldSerializationData;
if (taskData == null || (fieldSerializationData = taskData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
{
return;
}
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
BinaryDeserializationDeprecated.taskIDs = null;
if (taskData.variableStartIndex != null)
{
List <SharedVariable> list = new List <SharedVariable>();
Dictionary <string, int> dictionary = ObjectPool.Get <Dictionary <string, int> >();
for (int i = 0; i < taskData.variableStartIndex.Count; i++)
{
int num = taskData.variableStartIndex[i];
int num2;
if (i + 1 < taskData.variableStartIndex.Count)
{
num2 = taskData.variableStartIndex[i + 1];
}
else if (taskData.startIndex != null && taskData.startIndex.Count > 0)
{
num2 = taskData.startIndex[0];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
dictionary.Clear();
for (int j = num; j < num2; j++)
{
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
}
SharedVariable sharedVariable = BinaryDeserializationDeprecated.BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, taskData.variableStartIndex[i], behaviorSource, false, string.Empty);
if (sharedVariable != null)
{
list.Add(sharedVariable);
}
}
ObjectPool.Return <Dictionary <string, int> >(dictionary);
behaviorSource.Variables = list;
}
List <Task> list2 = new List <Task>();
if (taskData.types != null)
{
for (int k = 0; k < taskData.types.Count; k++)
{
BinaryDeserializationDeprecated.LoadTask(taskData, fieldSerializationData, ref list2, ref behaviorSource);
}
}
if (taskData.parentIndex.Count != list2.Count)
{
Debug.LogError("Deserialization Error: parent index count does not match task list count");
return;
}
for (int l = 0; l < taskData.parentIndex.Count; l++)
{
if (taskData.parentIndex[l] == -1)
{
if (behaviorSource.EntryTask == null)
{
behaviorSource.EntryTask = list2[l];
}
else
{
if (behaviorSource.DetachedTasks == null)
{
behaviorSource.DetachedTasks = new List <Task>();
}
behaviorSource.DetachedTasks.Add(list2[l]);
}
}
else if (taskData.parentIndex[l] == 0)
{
behaviorSource.RootTask = list2[l];
}
else if (taskData.parentIndex[l] != -1)
{
ParentTask parentTask = list2[taskData.parentIndex[l]] as ParentTask;
if (parentTask != null)
{
int index = (parentTask.Children != null) ? parentTask.Children.Count : 0;
parentTask.AddChild(list2[l], index);
}
}
}
if (BinaryDeserializationDeprecated.taskIDs != null)
{
foreach (BinaryDeserializationDeprecated.ObjectFieldMap objectFieldMap in BinaryDeserializationDeprecated.taskIDs.Keys)
{
List <int> list3 = BinaryDeserializationDeprecated.taskIDs[objectFieldMap];
Type fieldType = objectFieldMap.fieldInfo.FieldType;
if (typeof(IList).IsAssignableFrom(fieldType))
{
if (fieldType.IsArray)
{
Type elementType = fieldType.GetElementType();
Array array = Array.CreateInstance(elementType, list3.Count);
for (int m = 0; m < array.Length; m++)
{
array.SetValue(list2[list3[m]], m);
}
objectFieldMap.fieldInfo.SetValue(objectFieldMap.obj, array);
}
else
{
Type type = fieldType.GetGenericArguments()[0];
IList list4 = TaskUtility.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type
})) as IList;
for (int n = 0; n < list3.Count; n++)
{
list4.Add(list2[list3[n]]);
}
objectFieldMap.fieldInfo.SetValue(objectFieldMap.obj, list4);
}
}
else
{
objectFieldMap.fieldInfo.SetValue(objectFieldMap.obj, list2[list3[0]]);
}
}
}
}
public IEnumerator Do(SharedData share, SharedVariable variable)
{
share.view.NameText.text = "";
yield break;
}
private int getVariablesOfType(SharedVariable thisVariable, SkillData _data, out string[] names)
{
int result = 0;
int num = 1;
List<string> list = new List<string>();
list.Add("None");
if (_data.Variables != null)
{
foreach (var item in _data.Variables.Values)
{
if (item.GetType().Equals(thisVariable.GetType()))
{
list.Add(item.name);
if (item.name.Equals(thisVariable.name))
{
result = num;
}
num++;
}
}
}
names = list.ToArray();
return result;
}
public IEnumerator Event(SharedData share, SharedVariable variable, EventData e)
{
yield break;
}
protected void OnSharedVariableUpdated(SharedVariable sharedVariable)
{
if (this.SharedVariableUpdated != null)
this.SharedVariableUpdated(sharedVariable);
}
public ManipulatorManager(string leftPortName, string rightPortName)
{
this.status = new ArmControlStatus();
if (leftPortName == "disable")
{
this.status.LeftArmEnable = false;
}
if (rightPortName == "disable")
{
this.status.RightArmEnabled = false;
}
if (string.IsNullOrEmpty(leftPortName))
{
leftPortName = "COM5";
}
if (string.IsNullOrEmpty(rightPortName))
{
rightPortName = "COM9";
}
this.leftArmSerialPort = new SerialPort(leftPortName, 57600, Parity.None, 8, StopBits.One);
this.rightArmSerialPort = new SerialPort(rightPortName, 57600, Parity.None, 8, StopBits.One);
this.status.LeftComPort = leftPortName;
this.status.RightComPort = rightPortName;
this.leftArm = new Manipulator(this.leftArmSerialPort, ArmType.LeftArm);
this.rightArm = new Manipulator(this.rightArmSerialPort, ArmType.RightArm);
this.leftArm.ArmPositionChanged += new ArmPositionChangedEH(leftArm_ArmPositionChanged);
this.rightArm.ArmPositionChanged += new ArmPositionChangedEH(rightArm_ArmPositionChanged);
this.laEndEffectorType = TypeOfEndEffector.gripper;
this.raEndEffectorType = TypeOfEndEffector.hand;
this.mapObstacles = new SortedList <string, MapObstacle>();
this.mapNodes = new SortedList <string, MapNode>();
this.leftPredefPos = new SortedList <string, PredefPosition>();
this.leftPredefMovs = new SortedList <string, PredefMovement>();
this.rightPredefPos = new SortedList <string, PredefPosition>();
this.rightPredefMovs = new SortedList <string, PredefMovement>();
this.optLeftPath = new MapOptimalPath();
this.optRightPath = new MapOptimalPath();
this.leftGoal = new MapGoalPoint();
this.rightGoal = new MapGoalPoint();
this.lowBat = new SharedVariable <bool>("bat_alert");
this.sharedVarLeftArmPos = new DoubleArraySharedVariable("leftArmPos");
this.sharedVarRightArmPos = new DoubleArraySharedVariable("rightArmPos");
this.sharedVarEndEffectorType = new StringSharedVariable("endEffectorType");
this.cmdMan = new CommandManager();
this.cnnMan = new ConnectionManager("ARMS", 2080, this.cmdMan);
this.cnnMan.ClientConnected += new System.Net.Sockets.TcpClientConnectedEventHandler(cnnMan_ClientConnected);
this.cnnMan.ClientDisconnected += new System.Net.Sockets.TcpClientDisconnectedEventHandler(cnnMan_ClientDisconnected);
this.status.Running = true;
this.checkSystemThread = new Thread(new ThreadStart(this.CheckSystemThreadTask));
this.checkSystemThread.IsBackground = true;
this.checkSystemThread.Start();
}
private bool isValid(SharedVariable sv) {
return null != sv && !sv.IsNone;
}
private void TraceVariable(SharedVariable sv)
{
string s = String.Format("[Tracer] {0}{1} {2} = {3}",
sv.Type, sv.IsArray ? "[]" : String.Empty,
sv.Name,
sv.ReadStringData());
this.consoleManager.Report(s);
}
static private ClickModelMarginals Model2(int numLabels, bool allowNoExams)
{
// Inference engine must be EP because of the ConstrainBetween constraint
InferenceEngine engine = new InferenceEngine();
if (!(engine.Algorithm is Algorithms.ExpectationPropagation))
{
Console.WriteLine("This example only runs with Expectation Propagation");
return(null);
}
engine.NumberOfIterations = 10;
// Includes lower and upper bounds
int numThresholds = numLabels + 1;
// Partition the dat into chunks to improve the schedule
int chunkSize = 200;
// Maximum number of passes through the data
int maxPasses = 5;
// The marginals at any given stage.
ClickModelMarginals marginals = new ClickModelMarginals(numLabels);
// Compare the marginals with the previous marginals to create
// a convergence criterion
Gaussian prevMargScoreMean;
Gamma prevMargJudgePrec;
Gamma prevMargClickPrec;
double convergenceThresh = 0.01;
// Get the arrays of human judgement labels, clicks, and examinations
int[] labels;
int[] clicks;
int[] exams;
string fileName = Path.Combine(
#if NETCORE
Path.GetDirectoryName(typeof(ClickModel).Assembly.Location), // work dir is not the one with Microsoft.ML.Probabilistic.Tests.dll on netcore and neither is .Location on netfull
#endif
"TutorialData", "ClickModel.txt");
if (!File.Exists(fileName))
{
fileName = Path.Combine(
#if NETCORE
Path.GetDirectoryName(typeof(ClickModel).Assembly.Location), // work dir is not the one with Microsoft.ML.Probabilistic.Tests.dll on netcore and neither is .Location on netfull
#endif
"..", "Samples", "C#", "ExamplesBrowser", "TutorialData", "ClickModel.txt");
}
LoadData(fileName, allowNoExams, out labels, out clicks, out exams);
// Convert the raw click data into uncertain Gaussian observations chunk-by-chunk
Gaussian[][][] allObs = getClickObservations(numLabels, chunkSize, labels, clicks, exams);
int numChunks = allObs.Length;
//-------------------------------------------------------------
// Specify prior distributions
//-------------------------------------------------------------
Gaussian priorScoreMean = Gaussian.FromMeanAndVariance(0.5, 1.0);
Gamma priorScorePrec = Gamma.FromMeanAndVariance(2.0, 0.0);
Gamma priorJudgePrec = Gamma.FromMeanAndVariance(2.0, 1.0);
Gamma priorClickPrec = Gamma.FromMeanAndVariance(2.0, 1.0);
Gaussian[] priorThresholds;
CreateThresholdPriors(numLabels, out priorThresholds);
//-----------------------------------------------------
// Create shared variables - these are the variables
// which are shared between all chunks
//-----------------------------------------------------
Model model = new Model(numChunks);
SharedVariable <double> scoreMean = SharedVariable <double> .Random(priorScoreMean).Named("scoreMean");
SharedVariable <double> scorePrec = SharedVariable <double> .Random(priorScorePrec).Named("scorePrec");
SharedVariable <double> judgePrec = SharedVariable <double> .Random(priorJudgePrec).Named("judgePrec");
SharedVariable <double> clickPrec = SharedVariable <double> .Random(priorClickPrec).Named("clickPrec");
SharedVariable <double>[] thresholds = new SharedVariable <double> [numThresholds];
for (int t = 0; t < numThresholds; t++)
{
thresholds[t] = SharedVariable <double> .Random(priorThresholds[t]).Named("threshold" + t);
}
//----------------------------------------------------------------------------------
// The model
//----------------------------------------------------------------------------------
// Gaussian click observations are given to the model - one set of observations
// per label class. Also the number of observations per label class is given to the model
VariableArray <Gaussian>[] observationDistribs = new VariableArray <Gaussian> [numLabels];
Variable <int>[] numberOfObservations = new Variable <int> [numLabels];
// For each label, and each observation (consisting of a human judgement and
// a Gaussian click observation), there is a latent score variable, a judgement
// score variable, and a click score variable
for (int i = 0; i < numLabels; i++)
{
numberOfObservations[i] = Variable.New <int>().Named("NumObs" + i);
Range r = new Range(numberOfObservations[i]).Named("N" + i);
observationDistribs[i] = Variable.Array <Gaussian>(r).Named("Obs" + i);
VariableArray <double> scores = Variable.Array <double>(r).Named("Scores" + i);
VariableArray <double> scoresJ = Variable.Array <double>(r).Named("ScoresJ" + i);
VariableArray <double> scoresC = Variable.Array <double>(r).Named("ScoresC" + i);
scores[r] = Variable.GaussianFromMeanAndPrecision(scoreMean.GetCopyFor(model), scorePrec.GetCopyFor(model)).ForEach(r);
scoresJ[r] = Variable.GaussianFromMeanAndPrecision(scores[r], judgePrec.GetCopyFor(model));
scoresC[r] = Variable.GaussianFromMeanAndPrecision(scores[r], clickPrec.GetCopyFor(model));
Variable.ConstrainEqualRandom(scoresC[r], observationDistribs[i][r]);
Variable.ConstrainBetween(scoresJ[r], thresholds[i].GetCopyFor(model), thresholds[i + 1].GetCopyFor(model));
}
//----------------------------------------------------------
// Outer loop iterates over a number of passes
// Inner loop iterates over the unique labels
//----------------------------------------------------------
Console.WriteLine("Training: sample size: " + labels.Length + "\n");
for (int pass = 0; pass < maxPasses; pass++)
{
prevMargScoreMean = marginals.marginalScoreMean;
prevMargJudgePrec = marginals.marginalJudgePrec;
prevMargClickPrec = marginals.marginalClickPrec;
for (int c = 0; c < numChunks; c++)
{
for (int i = 0; i < numLabels; i++)
{
numberOfObservations[i].ObservedValue = allObs[c][i].Length;
observationDistribs[i].ObservedValue = allObs[c][i];
}
model.InferShared(engine, c);
// Retrieve marginals
marginals.marginalScoreMean = scoreMean.Marginal <Gaussian>();
marginals.marginalScorePrec = scorePrec.Marginal <Gamma>();
marginals.marginalJudgePrec = judgePrec.Marginal <Gamma>();
marginals.marginalClickPrec = clickPrec.Marginal <Gamma>();
for (int i = 0; i < numThresholds; i++)
{
marginals.marginalThresh[i] = thresholds[i].Marginal <Gaussian>();
}
Console.WriteLine("\n****** Pass {0}, chunk {1} ******", pass, c);
Console.WriteLine("----- Marginals -----");
Console.WriteLine("scoreMean = {0}", marginals.marginalScoreMean);
Console.WriteLine("scorePrec = {0}", marginals.marginalScorePrec);
Console.WriteLine("judgePrec = {0}", marginals.marginalJudgePrec);
Console.WriteLine("clickPrec = {0}", marginals.marginalClickPrec);
for (int t = 0; t < numThresholds; t++)
{
Console.WriteLine("threshMean {0} = {1}", t, marginals.marginalThresh[t]);
}
}
// Test for convergence
if (marginals.marginalScoreMean.MaxDiff(prevMargScoreMean) < convergenceThresh &&
marginals.marginalJudgePrec.MaxDiff(prevMargJudgePrec) < convergenceThresh &&
marginals.marginalClickPrec.MaxDiff(prevMargClickPrec) < convergenceThresh)
{
Console.WriteLine("\n****** Inference converged ******\n");
break;
}
}
return(marginals);
}
private bool isValid(SharedVariable sv)
{
return(sv != null && !sv.get_IsNone());
}
static private ClickModelMarginals Model2(int numLabels, bool allowNoExams)
{
// Inference engine must be EP because of the ConstrainBetween constraint
InferenceEngine engine = new InferenceEngine();
if (!(engine.Algorithm is ExpectationPropagation))
{
Console.WriteLine("This example only runs with Expectation Propagation");
return null;
}
engine.NumberOfIterations = 10;
// Includes lower and upper bounds
int numThresholds = numLabels + 1;
// Partition the dat into chunks to improve the schedule
int chunkSize = 200;
// Maximum number of passes through the data
int maxPasses = 5;
// The marginals at any given stage.
ClickModelMarginals marginals = new ClickModelMarginals(numLabels);
// Compare the marginals with the previous marginals to create
// a convergence criterion
Gaussian prevMargScoreMean;
Gamma prevMargJudgePrec;
Gamma prevMargClickPrec;
double convergenceThresh = 0.01;
// Get the arrays of human judgement labels, clicks, and examinations
int[] labels;
int[] clicks;
int[] exams;
string fileName = @"data\ClickModel.txt";
if (!File.Exists(fileName))
fileName = @"..\Samples\C#\ExamplesBrowser\data\ClickModel.txt";
LoadData(fileName, allowNoExams, out labels, out clicks, out exams);
// Convert the raw click data into uncertain Gaussian observations chunk-by-chunk
Gaussian[][][] allObs = getClickObservations(numLabels, chunkSize, labels, clicks, exams);
int numChunks = allObs.Length;
//-------------------------------------------------------------
// Specify prior distributions
//-------------------------------------------------------------
Gaussian priorScoreMean = Gaussian.FromMeanAndVariance(0.5, 1.0);
Gamma priorScorePrec = Gamma.FromMeanAndVariance(2.0, 0.0);
Gamma priorJudgePrec = Gamma.FromMeanAndVariance(2.0, 1.0);
Gamma priorClickPrec = Gamma.FromMeanAndVariance(2.0, 1.0);
Gaussian[] priorThresholds;
CreateThresholdPriors(numLabels, out priorThresholds);
//-----------------------------------------------------
// Create shared variables - these are the variables
// which are shared between all chunks
//-----------------------------------------------------
Model model = new Model(numChunks);
SharedVariable<double> scoreMean = SharedVariable<double>.Random(priorScoreMean).Named("scoreMean");
SharedVariable<double> scorePrec = SharedVariable<double>.Random(priorScorePrec).Named("scorePrec");
SharedVariable<double> judgePrec = SharedVariable<double>.Random(priorJudgePrec).Named("judgePrec");
SharedVariable<double> clickPrec = SharedVariable<double>.Random(priorClickPrec).Named("clickPrec");
SharedVariable<double>[] thresholds = new SharedVariable<double>[numThresholds];
for (int t = 0; t < numThresholds; t++) {
thresholds[t] = SharedVariable<double>.Random(priorThresholds[t]).Named("threshold" + t);
}
//----------------------------------------------------------------------------------
// The model
//----------------------------------------------------------------------------------
// Gaussian click observations are given to the model - one set of observations
// per label class. Also the number of observations per label class is given to the model
VariableArray<Gaussian>[] observationDistribs = new VariableArray<Gaussian>[numLabels];
Variable<int>[] numberOfObservations = new Variable<int>[numLabels];
// For each label, and each observation (consisting of a human judgement and
// a Gaussian click observation), there is a latent score variable, a judgement
// score variable, and a click score variable
for (int i = 0; i < numLabels; i++) {
numberOfObservations[i] = Variable.New<int>().Named("NumObs" + i);
Range r = new Range(numberOfObservations[i]).Named("N" + i);
observationDistribs[i] = Variable.Array<Gaussian>(r).Named("Obs" + i);
VariableArray<double> scores = Variable.Array<double>(r).Named("Scores" + i);
VariableArray<double> scoresJ = Variable.Array<double>(r).Named("ScoresJ" + i);
VariableArray<double> scoresC = Variable.Array<double>(r).Named("ScoresC" + i);
scores[r] = Variable.GaussianFromMeanAndPrecision(scoreMean.GetCopyFor(model), scorePrec.GetCopyFor(model)).ForEach(r);
scoresJ[r] = Variable.GaussianFromMeanAndPrecision(scores[r], judgePrec.GetCopyFor(model));
scoresC[r] = Variable.GaussianFromMeanAndPrecision(scores[r], clickPrec.GetCopyFor(model));
Variable.ConstrainEqualRandom(scoresC[r], observationDistribs[i][r]);
Variable.ConstrainBetween(scoresJ[r], thresholds[i].GetCopyFor(model), thresholds[i + 1].GetCopyFor(model));
}
//----------------------------------------------------------
// Outer loop iterates over a number of passes
// Inner loop iterates over the unique labels
//----------------------------------------------------------
Console.WriteLine("Training: sample size: " + labels.Length + "\n");
for (int pass = 0; pass < maxPasses; pass++) {
prevMargScoreMean = marginals.marginalScoreMean;
prevMargJudgePrec = marginals.marginalJudgePrec;
prevMargClickPrec = marginals.marginalClickPrec;
for (int c = 0; c < numChunks; c++) {
for (int i = 0; i < numLabels; i++) {
numberOfObservations[i].ObservedValue = allObs[c][i].Length;
observationDistribs[i].ObservedValue = allObs[c][i];
}
model.InferShared(engine,c);
// Retrieve marginals
marginals.marginalScoreMean = scoreMean.Marginal<Gaussian>();
marginals.marginalScorePrec = scorePrec.Marginal<Gamma>();
marginals.marginalJudgePrec = judgePrec.Marginal<Gamma>();
marginals.marginalClickPrec = clickPrec.Marginal<Gamma>();
for (int i = 0; i < numThresholds; i++)
marginals.marginalThresh[i] = thresholds[i].Marginal<Gaussian>();
Console.WriteLine("\n****** Pass {0}, chunk {1} ******", pass, c);
Console.WriteLine("----- Marginals -----");
Console.WriteLine("scoreMean = {0}", marginals.marginalScoreMean);
Console.WriteLine("scorePrec = {0}", marginals.marginalScorePrec);
Console.WriteLine("judgePrec = {0}", marginals.marginalJudgePrec);
Console.WriteLine("clickPrec = {0}", marginals.marginalClickPrec);
for (int t = 0; t < numThresholds; t++)
Console.WriteLine("threshMean {0} = {1}", t, marginals.marginalThresh[t]);
}
// Test for convergence
if (marginals.marginalScoreMean.MaxDiff(prevMargScoreMean) < convergenceThresh &&
marginals.marginalJudgePrec.MaxDiff(prevMargJudgePrec) < convergenceThresh &&
marginals.marginalClickPrec.MaxDiff(prevMargClickPrec) < convergenceThresh) {
Console.WriteLine("\n****** Inference converged ******\n");
break;
}
}
return marginals;
}
protected void OnSharedVariableAdded(SharedVariable sharedVariable)
{
if (this.SharedVariableAdded != null)
this.SharedVariableAdded(this, sharedVariable);
}
public void GetShare()
{
SharedVariable sharedVariable = behaviorTree.GetVariable("shader");
}
private void sv_Updated(SharedVariable sharedVariable)
{
OnSharedVariableUpdated(sharedVariable);
}
public void LoadTask(Task task, Behavior owner, ref int id)
{
if (task == null)
{
return;
}
this.mTask = task;
this.mTask.Owner = owner;
this.mTask.ID = id++;
this.mTask.NodeData.NodeDesigner = this;
this.mTask.NodeData.InitWatchedFields(this.mTask);
if (!this.mTask.NodeData.FriendlyName.Equals(string.Empty))
{
this.mTask.FriendlyName = this.mTask.NodeData.FriendlyName;
this.mTask.NodeData.FriendlyName = string.Empty;
}
this.LoadTaskIcon();
this.Init();
RequiredComponentAttribute[] array;
if (this.mTask.Owner != null && (array = (this.mTask.GetType().GetCustomAttributes(typeof(RequiredComponentAttribute), true) as RequiredComponentAttribute[])).Length > 0)
{
Type componentType = array[0].ComponentType;
if (typeof(Component).IsAssignableFrom(componentType) && this.mTask.Owner.gameObject.GetComponent(componentType) == null)
{
this.mTask.Owner.gameObject.AddComponent(componentType);
}
}
List <Type> baseClasses = FieldInspector.GetBaseClasses(this.mTask.GetType());
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
for (int i = baseClasses.Count - 1; i > -1; i--)
{
FieldInfo[] fields = baseClasses[i].GetFields(bindingAttr);
for (int j = 0; j < fields.Length; j++)
{
if (typeof(SharedVariable).IsAssignableFrom(fields[j].FieldType) && !fields[j].FieldType.IsAbstract)
{
SharedVariable sharedVariable = fields[j].GetValue(this.mTask) as SharedVariable;
if (sharedVariable == null)
{
sharedVariable = (Activator.CreateInstance(fields[j].FieldType) as SharedVariable);
}
if (TaskUtility.HasAttribute(fields[j], typeof(RequiredFieldAttribute)) || TaskUtility.HasAttribute(fields[j], typeof(SharedRequiredAttribute)))
{
sharedVariable.IsShared = true;
}
fields[j].SetValue(this.mTask, sharedVariable);
}
}
}
if (this.isParent)
{
ParentTask parentTask = this.mTask as ParentTask;
if (parentTask.Children != null)
{
for (int k = 0; k < parentTask.Children.Count; k++)
{
NodeDesigner nodeDesigner = ScriptableObject.CreateInstance <NodeDesigner>();
nodeDesigner.LoadTask(parentTask.Children[k], owner, ref id);
NodeConnection nodeConnection = ScriptableObject.CreateInstance <NodeConnection>();
nodeConnection.LoadConnection(this, NodeConnectionType.Fixed);
this.AddChildNode(nodeDesigner, nodeConnection, true, true, k);
}
}
this.mConnectionIsDirty = true;
}
}
