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;
    }
}
Esempio n. 3
0
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;
        //}
        //
    }
Esempio n. 5
0
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; 
    }
}