vf1D getWeights(DSL_network &network, string &childName) {
int childIdx = network.FindNode(childName.c_str());
DSL_node* node = network.GetNode(childIdx);
int handle = node->Handle();
DSL_nodeDefinition *def = node->Definition();
const DSL_Dmatrix &cpt = *def->GetMatrix();
const DSL_intArray &parents = network.GetParents(handle);
int parentCount = parents.NumItems();
DSL_intArray coords;
unsigned int colSize = def->GetNumberOfOutcomes();
unsigned int rowSize = cpt.GetSize() / colSize;
vf1D weights(rowSize, 0.0);
unsigned int rowIdx = 0;
for (int elemIdx = 0; elemIdx < cpt.GetSize(); elemIdx += colSize) {
cpt.IndexToCoordinates(elemIdx, coords);
double mult = 1.0;
for (int parentIdx = 0; parentIdx < parentCount; parentIdx ++) {
DSL_node *parentNode = network.GetNode(parents[parentIdx]);
const DSL_Dmatrix &parent_cpt = *parentNode->Definition()->GetMatrix();
mult *= parent_cpt[coords[parentIdx]];
}
weights[rowIdx++] = mult;
}
return weights;
}
void printCPT(DSL_node *node) {
DSL_network* net = node->Network(); // node network
int handle = node->Handle();
DSL_nodeDefinition *def = node->Definition();
const DSL_Dmatrix &cpt = *def->GetMatrix();
const DSL_idArray &outcomes = *def->GetOutcomesNames();
const DSL_intArray &parents = net->GetParents(handle);
int parentCount = parents.NumItems();
DSL_intArray coords;
// for (int elemIdx = 0; elemIdx < cpt.GetSize(); elemIdx ++) { for (int parentIdx = 0; parentIdx < parentCount; parentIdx ++){ } }
for (int elemIdx = 0; elemIdx < cpt.GetSize(); elemIdx ++) {
string name = "";
cpt.IndexToCoordinates(elemIdx, coords);
//cout << "P(" << node->GetId() << " = " << outcomes[coords[parentCount]] << " | ";
for (int parentIdx = 0; parentIdx < parentCount; parentIdx ++) {
DSL_node *parentNode = net->GetNode(parents[parentIdx]);
if(elemIdx == 0) {
cout << parentNode->GetId()<< " ";
if(parentIdx == parentCount-1) {
cout<< node->GetId() <<endl;
}
}
const DSL_idArray &parentStates = *parentNode->Definition()->GetOutcomesNames();
//cout << parentNode->GetId() << " = " << parentStates[coords[parentIdx]];
name += parentStates[coords[parentIdx]];
name += " ";
}
name += outcomes[coords[parentCount]];
cout << name << " " << cpt[elemIdx] << endl;
//cout << ") = " << cpt[elemIdx] << endl;
}
}
cptMap get_cptmap(DSL_node *node) {
DSL_network* net = node->Network(); // node network
int handle = node->Handle();
DSL_nodeDefinition *def = node->Definition();
const DSL_Dmatrix &cpt = *def->GetMatrix();
const DSL_idArray &outcomes = *def->GetOutcomesNames();
const DSL_intArray &parents = net->GetParents(handle);
int parentCount = parents.NumItems();
DSL_intArray coords;
cptMap cptmap;
for (int elemIdx = 0; elemIdx < cpt.GetSize(); elemIdx ++) {
cpt.IndexToCoordinates(elemIdx, coords);
//cout << "P(" << node->GetId() << " = " << outcomes[coords[parentCount]] << " | ";
keyMap km;
for (int parentIdx = 0; parentIdx < parentCount; parentIdx ++) {
// if (parentIdx > 0) cout << ", ";
DSL_node *parentNode = net->GetNode(parents[parentIdx]);
const DSL_idArray &parentStates = *parentNode->Definition()->GetOutcomesNames();
km[string(parentNode->GetId())] = string(parentStates[coords[parentIdx]]);
//cout << parentNode->GetId() << " = " << parentStates[coords[parentIdx]];
}
//printMap(km);
if (cptmap.count(km) == 0){
valMap vm;
vm[string(outcomes[coords[parentCount]])] = cpt[elemIdx];
cptmap[km] = vm;
} else {
cptmap[km][string(outcomes[coords[parentCount]])] = cpt[elemIdx];
}
//cout << ") = " << cpt[elemIdx] << endl;
}
return cptmap;
}
LearningInfo(string data_infile, string network_infile, string child_name) {
if (dataSet.ReadFile(data_infile.c_str()) != DSL_OKAY) {
cout << "Cannot read data file... exiting." << endl;
exit(1);
}
if (originalNet.ReadFile(network_infile.c_str(), DSL_XDSL_FORMAT) != DSL_OKAY) {
cout << "Cannot read network... exiting." << endl;
exit(1);
}
string err;
if (dataSet.MatchNetwork(originalNet, matches, err) != DSL_OKAY) {
cout << "Cannot match network... exiting." << endl;
exit(1);
}
for(unsigned int i=0 ; i < matches.size() ; ++i) {
matchNetToData[matches[i].node] = matches[i].column;
matchDataToNet[matches[i].column] = matches[i].node;
}
childIdx = originalNet.FindNode(child_name.c_str());
childNode = originalNet.GetNode(childIdx);
if (childNode->Definition()->GetType() != (DSL_CHANCE | DSL_DISCRETE | DSL_NOISY_MAX) ) {
cout << "Child should be a NoisyMAX... exiting" << endl;
// ewentualnie zmienic na noisy-max ręcznie
exit(1);
}
childMAXDefinition = new DSL_noisyMAX(*(childNode->Definition()));
DSL_intArray &parents = originalNet.GetParents(childNode->Handle());
numberOfParents = parents.NumItems();
parentIndices = vector<int>(numberOfParents, 0);
for(int i=0; i<numberOfParents; ++i)
parentIndices[i] = parents[i];
childDimension = childNode->Definition()->GetNumberOfOutcomes();
parentDimensions = vector<int>(numberOfParents, 0);
sumParentDimensions = 0;
parentOutcomesStrengths = vector<DSL_intArray>(numberOfParents);
minimalNumberOfParameters = 1; // minimal number of unique parameters to calculate (count leak right away)
for(int parentIdx = 0 ; parentIdx < numberOfParents ; ++parentIdx) {
DSL_node *parentNode = originalNet.GetNode(parentIndices[parentIdx]);
sumParentDimensions += (parentDimensions[parentIdx] = parentNode->Definition()->GetNumberOfOutcomes()); //parent dimension is equal to the number of outcomes
parentOutcomesStrengths[parentIdx] = childMAXDefinition->GetParentOutcomeStrengths(parentIdx);
//for (int stateIdx=0 ; stateIdx < parentDimensions[parentIdx] ; ++stateIdx)
// cout << parentOutcomesStrengths[parentIdx][stateIdx] << " ";
//cout << endl;
minimalNumberOfParameters += parentDimensions[parentIdx] - 1; // (each parent dimension reduced by one) because we don't count distinguished states of parents
distinguishedStates[parentIdx] = parentOutcomesStrengths[parentIdx][parentDimensions[parentIdx] - 1];
}
int sumOffset = 0;
parameterRowOffset = vi1D(numberOfParents + 1, 0); // +1 so we know the offset for LEAK column
for(int parentIdx = 0; parentIdx < numberOfParents ; ++parentIdx) {
parameterRowOffset[parentIdx] = sumOffset;
sumOffset += parentDimensions[parentIdx] - 1;
}
parameterRowOffset[numberOfParents] = sumOffset;
parametersRowLength = minimalNumberOfParameters;
minimalNumberOfParameters *= (childDimension - 1); // number of unique rows, last row is always 1.0 - sum
// DEBUG(minimalNumberOfParameters);
// DEBUG(childDimension);
// DEBUGV(parentDimensions);
// DEBUGV(parameterRowOffset);
//for(int j=0; j< 7 ; ++j) {
// DSL_datasetVarInfo vi = ds.GetVariableInfo(j);
// cout << "discreete:" << vi.discrete << " id:" << vi.id << endl << " missingInt:" << vi.missingInt << " mF:" << vi.missingFloat << "snames:"<< endl;
// for(int i=0;i<vi.stateNames.size(); ++i)
// cout << vi.stateNames[i]<< " ";
// cout <<endl;
//}
//for(int i = 0; i < ds.GetNumberOfRecords(); ++i) {
// vector<int> row(ds.GetNumberOfVariables(), 0);
// int sum_ones = 0;
// for(int j = 0; j < ds.GetNumberOfVariables(); ++j) {
// sum_ones += (row[j] = ds.GetInt(j,i));
// }
//}
//vector<int> rd = ds.GetIntData(0);
//cout <<"RDSize:"<<rd.size()<< endl;
//for(int i=0;i<rd.size();++i) {
// cout << vi.stateNames[rd[i]] << endl;
//}
//
}
void DSLPNLConverter::CreateFactors(DSL_network& dslNet, CBNet* pnlBNet)
{
int i,j,k;
// Read number of nodes in the net
int numberOfNodes = dslNet.GetNumberOfNodes();
// This is a way PNL likes it
pnlBNet->AllocFactors();
DSL_Dmatrix* dslMatrix;
CCPD* pnlCPD;
for (i=0;i<numberOfNodes;i++)
{
// Get parents of the ith node
// IMPORTANT -- we should preserve order from DSL_network, since
// probabilities will be according DSL ordering
DSL_intArray dslParents;
dslParents = dslNet.GetParents(dslNet.FindNode(theIds[i]));
// establish sizes and allocate memory
int numberOfNodesInDomain = dslParents.NumItems() + 1;
int* domain = new int[numberOfNodesInDomain];
CNodeType** nodeTypes = new CNodeType*[numberOfNodesInDomain];
// establish members of the domain
for (j=0;j<numberOfNodesInDomain-1;j++)
domain[j] = dslParents[j];
domain[numberOfNodesInDomain-1] = i;
// Fill up node types
for (j=0;j<numberOfNodesInDomain;j++)
nodeTypes[j] = const_cast <CNodeType*> (pnlBNet->GetNodeType(domain[j]));
// Read CPT from SMILE
dslNet.GetNode(dslNet.FindNode(theIds[i]))->Definition()->GetDefinition(&dslMatrix);
// Alloc space for CPT
int sizeOfCPT = dslMatrix->GetSize();
float* flatCPT = new float[sizeOfCPT];
// Here we convert 'copy' numbers from SMILE to PNL
// The painful part is convert double to float.
// Additionally we check if after conversion they sum-up to 1
int numberOfMyStates = nodeTypes[numberOfNodesInDomain-1]->GetNodeSize();
int iterations = sizeOfCPT/numberOfMyStates;
for (j=0;j<iterations;j++)
{
float sum = 0.0f;
for (k=0;k<numberOfMyStates;k++)
{
flatCPT[j*numberOfMyStates+k] = static_cast <float> (dslMatrix->Subscript(j*numberOfMyStates+k));
sum += flatCPT[j*numberOfMyStates+k];
}
if (sum!=1.0f)
{
for (k=0;k<numberOfMyStates;k++)
flatCPT[j*numberOfMyStates+k] /= sum;
}
}
#ifdef DSLPNL_DEBUG
std::cerr << "Node "<< i << " domain : ";
for (j=0;j<numberOfNodesInDomain;j++)
{
std::cerr << domain[j] << " ";
}
std::cerr << std::endl;
for (j=0;j<sizeOfCPT;j++)
std::cerr << flatCPT[j] << " ";
std::cerr << std::endl;
#endif
CModelDomain* pMD = pnlBNet->GetModelDomain();
pnlCPD = CTabularCPD::Create(domain, numberOfNodesInDomain, pMD, flatCPT);
if (pnlCPD==NULL)
{
std::cout << "We got a problem with creating CPD" << std::endl;
return;
}
pnlBNet->AttachFactor(pnlCPD);
delete[] nodeTypes;
delete[] domain;
delete[] flatCPT;
}
}