/// <summary>
/// Loads the priors of BCC and CBCC.
/// </summary>
/// <returns>A BCC posterior instance with the loaded priors.</returns>
BCC.Posteriors ToPriors()
{
int numClasses = Mapping.LabelCount;
int numTasks = Mapping.TaskCount;
int numWorkers = Mapping.WorkerCount;
CommunityModel.Posteriors cbccPriors = new CommunityModel.Posteriors();
BCC.Posteriors priors = IsCommunityModel ? cbccPriors : new BCC.Posteriors();
/// Loads the prior of the background probabilities of the tasks
priors.BackgroundLabelProb = BackgroundLabelProb;
/// Loads the prior of the confusion matrix of each worker
priors.WorkerConfusionMatrix = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerConfusionMatrix.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, lab => WorkerConfusionMatrix[wid][lab]));
}
else
{
return(Util.ArrayInit(numClasses, lab => Dirichlet.Uniform(numClasses)));
}
});
/// Loads the true label constraint of each task
priors.TrueLabelConstraint = Util.ArrayInit(numTasks,
t =>
{
string tid = Mapping.TaskIndexToId[t];
if (TrueLabelConstraint.ContainsKey(tid))
{
return(TrueLabelConstraint[Mapping.TaskIndexToId[t]]);
}
else
{
return(Discrete.Uniform(numClasses));
}
});
/// Loads the priors of the parameters of CBCC
if (IsCommunityModel)
{
cbccPriors.CommunityConfusionMatrix = CommunityConfusionMatrix;
cbccPriors.WorkerScoreMatrixConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerScoreMatrixConstraint.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, lab => WorkerScoreMatrixConstraint[wid][lab]));
}
else
{
return(Util.ArrayInit(numClasses, lab => VectorGaussian.Uniform(numClasses)));
}
});
cbccPriors.CommunityProb = CommunityProb;
cbccPriors.CommunityScoreMatrix = CommunityScoreMatrix;
cbccPriors.WorkerCommunityConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (CommunityConstraint.ContainsKey(wid))
{
return(CommunityConstraint[wid]);
}
else
{
return(Discrete.Uniform(CommunityCount));
}
});
}
priors.Evidence = ModelEvidence;
return(priors);
}
public void CreateModel(int NumTasks, int NumClasses, int VocabSize, int numBatches = 3)
{
WorkerCount = Variable.New <int>().Named("WorkerCount");
// Set up inference engine
Engine = new InferenceEngine(new VariationalMessagePassing());
// Set engine flags
Engine.Compiler.WriteSourceFiles = true;
Engine.Compiler.UseParallelForLoops = true;
evidence = Variable.Bernoulli(0.5).Named("evidence");
IfBlock block = Variable.If(evidence);
// Set up ranges
n = new Range(NumTasks).Named("N");
c = new Range(NumClasses).Named("C");
k = new Range(WorkerCount).Named("K");
WorkerTaskCount = Variable.Array <int>(k).Named("WorkerTaskCount");
kn = new Range(WorkerTaskCount[k]).Named("KN");
WorkerTaskIndex = Variable.Array(Variable.Array <int>(kn), k).Named("Task");
WorkerTaskIndex.SetValueRange(n);
// Initialise truth
BackgroundLabelProbPrior = Variable.New <Dirichlet>().Named("TruthProbPrior");
BackgroundLabelProb = Variable <Vector> .Random(BackgroundLabelProbPrior).Named("TruthProb");
BackgroundLabelProb.SetValueRange(c);
// Truth distributions
TrueLabel = Variable.Array <int>(n).Named("Truth");
TrueLabel[n] = Variable.Discrete(BackgroundLabelProb).ForEach(n);
//VocabSize = Variable.New<int>();
w = new Range(VocabSize).Named("W");
ProbWord = Variable.Array <Vector>(c).Named("ProbWord");
ProbWord.SetValueRange(w);
WordCount = Variable.Array <int>(n).Named("WordCount");
nw = new Range(WordCount[n]).Named("WN");
Words = Variable.Array(Variable.Array <int>(nw), n).Named("Word");
ProbWordPrior = Variable.New <Dirichlet>().Named("ProbWordPrior");
ProbWord[c] = Variable <Vector> .Random(ProbWordPrior).ForEach(c);
// Initialise user profiles
ConfusionMatrixPrior = Variable.Array(Variable.Array <Dirichlet>(c), k).Named("WorkerConfusionMatrixPrior");
WorkerConfusionMatrix = Variable.Array(Variable.Array <Vector>(c), k).Named("WorkerConfusionMatrix");
WorkerConfusionMatrix[k][c] = Variable <Vector> .Random(ConfusionMatrixPrior[k][c]);
WorkerConfusionMatrix.SetValueRange(c);
// Vote distributions
WorkerLabel = Variable.Array(Variable.Array <int>(kn), k).Named("WorkerLabel");
using (Variable.ForEach(k))
{
var trueLabel = Variable.Subarray(TrueLabel, WorkerTaskIndex[k]).Named("TrueLabelSubarray");
trueLabel.SetValueRange(c);
using (Variable.ForEach(kn))
{
using (Variable.Switch(trueLabel[kn]))
{
WorkerLabel[k][kn] = Variable.Discrete(WorkerConfusionMatrix[k][trueLabel[kn]]);
}
}
}
// Words inference
using (Variable.ForEach(n))
{
using (Variable.Switch(TrueLabel[n]))
{
Words[n][nw] = Variable.Discrete(ProbWord[TrueLabel[n]]).ForEach(nw);
}
}
block.CloseBlock();
}
BCCPosteriors ToPriors()
{
int numClasses = Mapping.LabelCount;
int numTasks = Mapping.TaskCount;
int numWorkers = Mapping.WorkerCount;
CBCCPosteriors cbccPriors = new CBCCPosteriors();
BCCPosteriors priors = IsCommunityModel ? cbccPriors : new BCCPosteriors();
priors.BackgroundLabelProb = BackgroundLabelProb;
priors.WorkerConfusionMatrix = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerConfusionMatrix.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, c => WorkerConfusionMatrix[wid][c]));
}
else
{
return(Util.ArrayInit(numClasses, c => Dirichlet.Uniform(numClasses)));
}
});
priors.TrueLabelConstraint = Util.ArrayInit(numTasks,
t =>
{
string tid = Mapping.TaskIndexToId[t];
if (TrueLabelConstraint.ContainsKey(tid))
{
return(TrueLabelConstraint[Mapping.TaskIndexToId[t]]);
}
else
{
return(Discrete.Uniform(numClasses));
}
});
if (IsCommunityModel)
{
cbccPriors.CommunityConfusionMatrix = CommunityConfusionMatrix;
cbccPriors.WorkerScoreMatrixConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (WorkerScoreMatrixConstraint.ContainsKey(wid))
{
return(Util.ArrayInit(numClasses, c => WorkerScoreMatrixConstraint[wid][c]));
}
else
{
return(Util.ArrayInit(numClasses, c => VectorGaussian.Uniform(numClasses)));
}
});
cbccPriors.CommunityProb = CommunityProb;
cbccPriors.CommunityScoreMatrix = CommunityScoreMatrix;
cbccPriors.WorkerCommunityConstraint = Util.ArrayInit(numWorkers,
w =>
{
string wid = Mapping.WorkerIndexToId[w];
if (CommunityConstraint.ContainsKey(wid))
{
return(CommunityConstraint[wid]);
}
else
{
return(Discrete.Uniform(CommunityCount));
}
});
}
priors.Evidence = ModelEvidence;
return(priors);
}
