SEXP Decode_Chain(SEXP _crf) { CRF crf(_crf); crf.Init_Labels(); crf.Decode_Chain(); return(crf._labels); }
SEXP Infer_Chain(SEXP _crf) { CRF crf(_crf); crf.Init_Belief(); crf.Infer_Chain(); return(crf._belief); }
SEXP Decode_Tree(SEXP _crf) { CRF crf(_crf); crf.Init_Labels(); crf.Init_NodeBel(); crf.Decode_Tree(); return(crf._labels); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double x_std, y_std, w_smooth; double x_std_b, y_std_b, r_std, g_std, b_std, w_bilateral; int width, height, labels; // check input and output parameters if (nrhs < 12 ) { mexErrMsgTxt("12 inputs required (unary, color_image, x_std, y_std, w_smooth, x_std_bilateral, y_std_bilateral, r_std, g_std, b_std, w_bilateral, img_width, img_height)"); } // unary (be careful about c++ index and matlab index) if(!mxIsSingle(prhs[0])) { mexErrMsgTxt("Input matrix 1 must be float."); } float *unary = (float *) mxGetData(prhs[0]); labels = mxGetM(prhs[0]); if (!mxIsUint8(prhs[1])) { mexErrMsgTxt("Input matrix 2 must be uint8."); } if (mxGetM(prhs[1]) != 3) { mexErrMsgTxt("Input matrix 2 must have 3 channels (channel * width * height)."); } unsigned char * img = (unsigned char *) mxGetPr(prhs[1]); x_std = mxGetScalar(prhs[2]); y_std = mxGetScalar(prhs[3]); w_smooth = mxGetScalar(prhs[4]); x_std_b = mxGetScalar(prhs[5]); y_std_b = mxGetScalar(prhs[6]); r_std = mxGetScalar(prhs[7]); g_std = mxGetScalar(prhs[8]); b_std = mxGetScalar(prhs[9]); w_bilateral = mxGetScalar(prhs[10]); width = mxGetScalar(prhs[11]); height = mxGetScalar(prhs[12]); plhs[0] = mxCreateNumericMatrix(height, width, mxINT32_CLASS, mxREAL); plhs[1] = mxCreateNumericMatrix(height*width*labels, 1, mxSINGLE_CLASS, mxREAL); int *map = (int *)mxGetData(plhs[0]); float *prob = (float *)mxGetData(plhs[1]); int iter = 10; DenseCRF2D crf(width, height, labels); crf.setUnaryEnergy( unary); crf.addPairwiseGaussian( x_std, y_std, w_smooth); crf.addPairwiseBilateral( x_std_b, y_std_b, r_std, g_std, b_std, img, w_bilateral); crf.map(iter, map, prob); }
SEXP Sample_Cutset(SEXP _crf, SEXP _size, SEXP _engine) { CRFclamped crf(_crf); crf.Init_Belief(); crf.Init_Samples(1); crf.original.Init_Samples(_size); crf.Sample_Cutset(INTEGER_POINTER(AS_INTEGER(_size))[0], INTEGER_POINTER(AS_INTEGER(_engine))[0]); return(crf.original._samples); }
SEXP Infer_TRBP(SEXP _crf, SEXP _maxIter, SEXP _cutoff, SEXP _verbose) { int maxIter = INTEGER_POINTER(AS_INTEGER(_maxIter))[0]; double cutoff = NUMERIC_POINTER(AS_NUMERIC(_cutoff))[0]; int verbose = INTEGER_POINTER(AS_INTEGER(_verbose))[0]; CRF crf(_crf); crf.Init_Belief(); crf.Infer_TRBP(maxIter, cutoff, verbose); return(crf._belief); }
SEXP MRF_Stat(SEXP _crf, SEXP _instances) { CRF crf(_crf); int nInstances = INTEGER_POINTER(GET_DIM(_instances))[0]; int nPar = INTEGER_POINTER(AS_INTEGER(GetVar(_crf, "n.par")))[0]; PROTECT(_instances = AS_NUMERIC(_instances)); double *instances = NUMERIC_POINTER(_instances); SEXP _nodePar; PROTECT(_nodePar = AS_INTEGER(GetVar(_crf, "node.par"))); int *nodePar = INTEGER_POINTER(_nodePar); SEXP _edgePar = GetVar(_crf, "edge.par"); int **edgePar = (int **) R_alloc(crf.nEdges, sizeof(int *)); SEXP _edgeParI, _temp; PROTECT(_edgeParI = NEW_LIST(crf.nEdges)); for (int i = 0; i < crf.nEdges; i++) { SET_VECTOR_ELT(_edgeParI, i, _temp = AS_INTEGER(GetListElement(_edgePar, i))); edgePar[i] = INTEGER_POINTER(_temp); } SEXP _stat; PROTECT(_stat = NEW_NUMERIC(nPar)); double *stat = NUMERIC_POINTER(_stat); SetValues(_stat, stat, 0.0); int *y = (int *) R_allocVector<int>(crf.nNodes); for (int n = 0; n < nInstances; n++) { for (int i = 0; i < crf.nNodes; i++) { y[i] = instances[n + nInstances * i] - 1; int p = nodePar[i + crf.nNodes * y[i]] - 1; if (p >= 0 && p < nPar) stat[p]++; } for (int i = 0; i < crf.nEdges; i++) { int p = edgePar[i][y[crf.EdgesBegin(i)] + crf.nStates[crf.EdgesBegin(i)] * y[crf.EdgesEnd(i)]] - 1; if (p >= 0 && p < nPar) stat[p]++; } } UNPROTECT(4); return(_stat); }
SEXP Decode_LBP(SEXP _crf, SEXP _maxIter, SEXP _cutoff, SEXP _verbose) { int maxIter = INTEGER_POINTER(AS_INTEGER(_maxIter))[0]; double cutoff = NUMERIC_POINTER(AS_NUMERIC(_cutoff))[0]; int verbose = INTEGER_POINTER(AS_INTEGER(_verbose))[0]; CRF crf(_crf); crf.Init_Labels(); crf.Init_NodeBel(); crf.Decode_LBP(maxIter, cutoff, verbose); return(crf._labels); }
bool cmpx(State *state, Instruction instr) { auto flags = 0; Type a, b; if (instr.l == 0) { if (std::numeric_limits<Type>::is_signed) { a = little_endian::signExtend<32, Type>(gpr(instr.rA)); } else { a = little_endian::zeroExtend<32, Type>(gpr(instr.rA)); } } else { a = static_cast<Type>(gpr(instr.rA)); } if (Flags & CmpxImmediate) { if (std::numeric_limits<Type>::is_signed) { b = little_endian::signExtend<16, Type>(instr.simm); } else { b = instr.uimm; } } else if (instr.l == 0) { if (std::numeric_limits<Type>::is_signed) { b = little_endian::signExtend<32, Type>(gpr(instr.rB)); } else { b = little_endian::zeroExtend<32, Type>(gpr(instr.rB)); } } else { b = static_cast<Type>(gpr(instr.rB)); } if (a < b) { flags |= ppc::Cr::Negative; } else if (a > b) { flags |= ppc::Cr::Positive; } else { flags |= ppc::Cr::Zero; } flags |= state->reg.xer.so; crf(instr.crfD) = flags; return true; }
void RingoShadowTable::addReaction (OracleEnv &env, RingoIndex &index, const char *rowid, int blockno, int offset) { OracleLOB crf(env); crf.createTemporaryBLOB(); crf.write(0, index.getCrf()); OracleStatement statement(env); statement.append("INSERT INTO %s VALUES(:rxnrowid, :blockno, :offset, :crf, :rxnhash)", _table_name.ptr()); statement.prepare(); statement.bindStringByName(":rxnrowid", rowid, strlen(rowid) + 1); statement.bindIntByName(":blockno", &blockno); statement.bindIntByName(":offset", &offset); statement.bindBlobByName(":crf", crf); statement.bindStringByName(":rxnhash", index.getHashStr(), strlen(index.getHashStr()) + 1); statement.execute(); }
int main( int argc, char* argv[]){ if (argc<4){ printf("Usage: %s image annotations output\n", argv[0] ); return 1; } // Number of labels const int M = 21; // Load the color image and some crude annotations (which are used in a simple classifier) int W, H, GW, GH; unsigned char * im = readPPM( argv[1], W, H ); if (!im){ printf("Failed to load image!\n"); return 1; } unsigned char * anno = readPPM( argv[2], GW, GH ); if (!anno){ printf("Failed to load annotations!\n"); return 1; } if (W!=GW || H!=GH){ printf("Annotation size doesn't match image!\n"); return 1; } /////////// Put your own unary classifier here! /////////// Eigen::MatrixXf unary = computeUnary( getLabeling( anno, W*H, M ), M ); /////////////////////////////////////////////////////////// // Setup the CRF model DenseCRF2D crf(W, H, M); // Specify the unary potential as an array of size W*H*(#classes) // packing order: x0y0l0 x0y0l1 x0y0l2 .. x1y0l0 x1y0l1 ... crf.setUnaryEnergy( unary ); // add a color independent term (feature = pixel location 0..W-1, 0..H-1) // x_stddev = 3 // y_stddev = 3 // weight = 3 crf.addPairwiseGaussian( 3, 3, new PottsCompatibility( 3 ) ); // add a color dependent term (feature = xyrgb) // x_stddev = 60 // y_stddev = 60 // r_stddev = g_stddev = b_stddev = 20 // weight = 10 crf.addPairwiseBilateral( 80, 80, 13, 13, 13, im, new PottsCompatibility( 10 ) ); // Do map inference // Eigen::MatrixXf Q = crf.startInference(), t1, t2; // printf("kl = %f\n", crf.klDivergence(Q) ); // for( int it=0; it<5; it++ ) { // crf.stepInference( Q, t1, t2 ); // printf("kl = %f\n", crf.klDivergence(Q) ); // } // VectorXs map = crf.currentMap(Q); VectorXs map = crf.map(5); // Store the result unsigned char *res = colorize( map, W, H ); writePPM( argv[3], W, H, res ); delete[] im; delete[] anno; delete[] res; }
SEXP MRF_Update(SEXP _crf) { CRF crf(_crf); crf.Update_Pot(); return (_crf); }
// ***************************************** // Gateway routine void mexFunction(int nlhs, mxArray * plhs[], // output variables int nrhs, const mxArray * prhs[]) // input variables { // Macros declarations // For the outputs #define PAIRSWISEKERNELS_OUT plhs[0] // For the inputs #define HEIGHT_IN prhs[0] #define WIDTH_IN prhs[1] #define LABELING_IN prhs[2] #define PAIRWISEFEATURES_IN prhs[3] #define NUMPAIRWISES_IN prhs[4] #define HSTD_IN prhs[5] #define WSTD_IN prhs[6] #define THETA_P_X_IN prhs[7] #define THETA_P_Y_IN prhs[8] // Check the input parameters if (nrhs < 1 || nrhs > 9) mexErrMsgTxt("Wrong number of input parameters."); // Get the size of the image int height = (int) mxGetScalar(HEIGHT_IN); int width = (int) mxGetScalar(WIDTH_IN); // Get the labeling short * labelingIn = (short *) mxGetData(LABELING_IN); // Get the pairwise features float * pairwiseFeaturesIn = (float *) mxGetData(PAIRWISEFEATURES_IN); // Get the standard deviations of the (x,y) coordinates float hstd_in = (float) mxGetScalar(HSTD_IN); float wstd_in = (float) mxGetScalar(WSTD_IN); // Get the theta_p int theta_p_x = (float) mxGetScalar(THETA_P_X_IN); int theta_p_y = (float) mxGetScalar(THETA_P_Y_IN); // Create the CRF to compute the pairwise potentials. height and width // represents the size of the image, and 2 is the amount of classes // (background and vessels) DenseCRF2D crf(height, width, 2); // Get the pairwise features int numPairwiseFeatures = (int) mxGetScalar(NUMPAIRWISES_IN); float * pairwiseFeatures = (float *) mxGetData(PAIRWISEFEATURES_IN); // Assign the pairwise features for (int pairw = 0; pairw < numPairwiseFeatures; pairw++) { // Encode the pairwise features float * single_PairwiseFeatures = new float[width * height * 3]; float mean_h = height / 2; float mean_w = width / 2; for (int h = 0; h < height; h++) { for (int w = 0; w < width; w++) { single_PairwiseFeatures[(w+h*width)*3+0] = pairwiseFeatures[h + height * (w + width * pairw)]; single_PairwiseFeatures[(w+h*width)*3+1] = (((float) (h - mean_h)) / hstd_in) / theta_p_y; single_PairwiseFeatures[(w+h*width)*3+2] = (((float) (w - mean_w)) / wstd_in) / theta_p_x; } } //Assign the pairwise features crf.addPairwiseEnergy(single_PairwiseFeatures, 3, 1.0); delete [] single_PairwiseFeatures; } // Declare the output variables mwSize dims[3] = {height, width, numPairwiseFeatures}; PAIRSWISEKERNELS_OUT = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL); float * pairwiseKernels = (float *) mxGetData(PAIRSWISEKERNELS_OUT); // Compute the pairwise energy for (int pairw = 0; pairw < numPairwiseFeatures; pairw++) { float * pairwiseEnergy = new float[width * height]; crf.pairwiseEnergy(labelingIn, pairwiseEnergy, pairw); for (int w = 0; w < width; w++) { for (int h = 0; h < height; h++) { pairwiseKernels[h + height * (w + width * pairw)] = (float) pairwiseEnergy[w + width * h]; } } delete [] pairwiseEnergy; } return; }
int main( int argc, char* argv[]){ if (argc<4){ printf("Usage: %s image annotations output\n", argv[0] ); return 1; } // Number of labels [use only 4 to make our lives a bit easier] const int M = 4; // Load the color image and some crude annotations (which are used in a simple classifier) int W, H, GW, GH; unsigned char * im = readPPM( argv[1], W, H ); if (!im){ printf("Failed to load image!\n"); return 1; } unsigned char * anno = readPPM( argv[2], GW, GH ); if (!anno){ printf("Failed to load annotations!\n"); return 1; } if (W!=GW || H!=GH){ printf("Annotation size doesn't match image!\n"); return 1; } // Get the labeling VectorXs labeling = getLabeling( anno, W*H, M ); const int N = W*H; // Get the logistic features (unary term) // Here we just use the color as a feature Eigen::MatrixXf logistic_feature( 4, N ), logistic_transform( M, 4 ); logistic_feature.fill( 1.f ); for( int i=0; i<N; i++ ) for( int k=0; k<3; k++ ) logistic_feature(k,i) = im[3*i+k] / 255.; for( int j=0; j<logistic_transform.cols(); j++ ) for( int i=0; i<logistic_transform.rows(); i++ ) logistic_transform(i,j) = 0.01*(1-2.*random()/RAND_MAX); // Setup the CRF model DenseCRF2D crf(W, H, M); // Add a logistic unary term crf.setUnaryEnergy( logistic_transform, logistic_feature ); // Add simple pairwise potts terms crf.addPairwiseGaussian( 3, 3, new PottsCompatibility( 1 ) ); // Add a longer range label compatibility term crf.addPairwiseBilateral( 80.0f, 80.0f, 13.0f, 13.0f, 13.0f, &*im, new MatrixCompatibility::MatrixCompatibility( Eigen::MatrixXf::Identity(M,M) ) ); // Choose your loss function // LogLikelihood objective( labeling, 0.01 ); // Log likelihood loss // Hamming objective( labeling, 0.0 ); // Global accuracy // Hamming objective( labeling, 1.0 ); // Class average accuracy // Hamming objective( labeling, 0.2 ); // Hamming loss close to intersection over union IntersectionOverUnion objective( labeling ); // Intersection over union accuracy int NIT = 5; const bool verbose = true; Eigen::MatrixXf learning_params( 3, 3 ); // Optimize the CRF in 3 phases: // * First unary only // * Unary and pairwise // * Full CRF learning_params<<1,0,0, 1,1,0, 1,1,1; for( int i=0; i<learning_params.rows(); i++ ) { // Setup the energy CRFEnergy energy( crf, objective, NIT, learning_params(i,0), learning_params(i,1), learning_params(i,2) ); energy.setL2Norm( 1e-3 ); // Minimize the energy Eigen::VectorXf p = minimizeLBFGS( energy, 2, true ); // Save the values int id = 0; if( learning_params(i,0) ) { crf.setUnaryParameters( p.segment( id, crf.unaryParameters().rows() ) ); id += crf.unaryParameters().rows(); } if( learning_params(i,1) ) { crf.setLabelCompatibilityParameters( p.segment( id, crf.labelCompatibilityParameters().rows() ) ); id += crf.labelCompatibilityParameters().rows(); } if( learning_params(i,2) ) crf.setKernelParameters( p.segment( id, crf.kernelParameters().rows() ) ); } // Return the parameters std::cout<<"Unary parameters: "<<crf.unaryParameters().transpose()<<std::endl; std::cout<<"Pairwise parameters: "<<crf.labelCompatibilityParameters().transpose()<<std::endl; std::cout<<"Kernel parameters: "<<crf.kernelParameters().transpose()<<std::endl; // Do map inference VectorXs map = crf.map(NIT); // Store the result unsigned char *res = colorize( map, W, H ); writePPM( argv[3], W, H, res ); delete[] im; delete[] anno; delete[] res; }
SEXP MRF_NLL(SEXP _crf, SEXP _par, SEXP _instances, SEXP _infer, SEXP _env) { CRF crf(_crf); int nInstances = INTEGER_POINTER(GET_DIM(_instances))[0]; int nPar = INTEGER_POINTER(AS_INTEGER(GetVar(_crf, "n.par")))[0]; PROTECT(_par = AS_NUMERIC(_par)); double *par = NUMERIC_POINTER(_par); double *crfPar = NUMERIC_POINTER(GetVar(_crf, "par")); for (int i = 0; i < nPar; i++) crfPar[i] = par[i]; SEXP _parStat; PROTECT(_parStat = AS_NUMERIC(GetVar(_crf, "par.stat"))); double *parStat = NUMERIC_POINTER(_parStat); SEXP _nll = GetVar(_crf, "nll"); double *nll = NUMERIC_POINTER(_nll); *nll = 0.0; double *gradient = NUMERIC_POINTER(GetVar(_crf, "gradient")); for (int i = 0; i < nPar; i++) gradient[i] = 0.0; crf.Update_Pot(); SEXP _belief; PROTECT(_belief = eval(_infer, _env)); *nll = NUMERIC_POINTER(AS_NUMERIC(GetListElement(_belief, "logZ")))[0] * nInstances; for (int i = 0; i < nPar; i++) { *nll -= par[i] * parStat[i]; gradient[i] = -parStat[i]; } SEXP _nodePar, _nodeBel; PROTECT(_nodePar = AS_INTEGER(GetVar(_crf, "node.par"))); PROTECT(_nodeBel = AS_NUMERIC(GetListElement(_belief, "node.bel"))); int *nodePar = INTEGER_POINTER(_nodePar); double *nodeBel = NUMERIC_POINTER(_nodeBel); for (int i = 0; i < crf.nNodes; i++) { for (int k = 0; k < crf.nStates[i]; k++) { int p = nodePar[i + crf.nNodes * k] - 1; if (p >= 0 && p < nPar) { gradient[p] += nodeBel[i + crf.nNodes * k] * nInstances; } } } SEXP _edgePar = GetVar(_crf, "edge.par"); SEXP _edgeBel = GetListElement(_belief, "edge.bel"); SEXP _edgeParI, _edgeBelI, _temp; PROTECT(_edgeParI = NEW_LIST(crf.nEdges)); PROTECT(_edgeBelI = NEW_LIST(crf.nEdges)); for (int i = 0; i < crf.nEdges; i++) { SET_VECTOR_ELT(_edgeParI, i, _temp = AS_INTEGER(GetListElement(_edgePar, i))); int *edgePar = INTEGER_POINTER(_temp); SET_VECTOR_ELT(_edgeBelI, i, _temp = AS_NUMERIC(GetListElement(_edgeBel, i))); double *edgeBel = NUMERIC_POINTER(_temp); for (int k = 0; k < crf.nEdgeStates[i]; k++) { int p = edgePar[k] - 1; if (p >= 0 && p < nPar) { gradient[p] += edgeBel[k] * nInstances; } } } UNPROTECT(7); return(_nll); }
SEXP CRF_NLL(SEXP _crf, SEXP _par, SEXP _instances, SEXP _nodeFea, SEXP _edgeFea, SEXP _nodeExt, SEXP _edgeExt, SEXP _infer, SEXP _env) { CRF crf(_crf); int nInstances = INTEGER_POINTER(GET_DIM(_instances))[0]; int nPar = INTEGER_POINTER(AS_INTEGER(GetVar(_crf, "n.par")))[0]; int nNodeFea = INTEGER_POINTER(AS_INTEGER(GetVar(_crf, "n.nf")))[0]; int nEdgeFea = INTEGER_POINTER(AS_INTEGER(GetVar(_crf, "n.ef")))[0]; PROTECT(_par = AS_NUMERIC(_par)); double *par = NUMERIC_POINTER(_par); double *crfPar = NUMERIC_POINTER(GetVar(_crf, "par")); for (int i = 0; i < nPar; i++) crfPar[i] = par[i]; PROTECT(_instances = AS_NUMERIC(_instances)); double *instances = NUMERIC_POINTER(_instances); SEXP _nodePar; PROTECT(_nodePar = AS_INTEGER(GetVar(_crf, "node.par"))); int *nodePar = INTEGER_POINTER(_nodePar); SEXP _edgePar = GetVar(_crf, "edge.par"); int **edgePar = (int **) R_alloc(crf.nEdges, sizeof(int *)); SEXP _edgeParI, _temp; PROTECT(_edgeParI = NEW_LIST(crf.nEdges)); for (int i = 0; i < crf.nEdges; i++) { SET_VECTOR_ELT(_edgeParI, i, _temp = AS_INTEGER(GetListElement(_edgePar, i))); edgePar[i] = INTEGER_POINTER(_temp); } SEXP _nll = GetVar(_crf, "nll"); double *nll = NUMERIC_POINTER(_nll); *nll = 0.0; double *gradient = NUMERIC_POINTER(GetVar(_crf, "gradient")); for (int i = 0; i < nPar; i++) gradient[i] = 0.0; int *y = (int *) R_allocVector<int>(crf.nNodes); SEXP _nodeFeaN = _nodeFea; SEXP _edgeFeaN = _edgeFea; SEXP _nodeExtN = _nodeExt; SEXP _edgeExtN = _edgeExt; for (int n = 0; n < nInstances; n++) { if (!isNull(_nodeFea) && isNewList(_nodeFea)) _nodeFeaN = GetListElement(_nodeFea, n); if (!isNull(_edgeFea) && isNewList(_edgeFea)) _edgeFeaN = GetListElement(_edgeFea, n); if (!isNull(_nodeExt) && isNewList(_nodeExt)) _nodeExtN = GetListElement(_nodeExt, n); if (!isNull(_edgeExt) && isNewList(_edgeExt)) _edgeExtN = GetListElement(_edgeExt, n); crf.Update_Pot(_nodeFeaN, _edgeFeaN, _nodeExtN, _edgeExtN); for (int i = 0; i < crf.nNodes; i++) y[i] = instances[n + nInstances * i] - 1; SEXP _belief; PROTECT(_belief = eval(_infer, _env)); SEXP _nodeBel; PROTECT(_nodeBel = AS_NUMERIC(GetListElement(_belief, "node.bel"))); double *nodeBel = NUMERIC_POINTER(_nodeBel); SEXP _edgeBel = GetListElement(_belief, "edge.bel"); double **edgeBel = (double **) R_alloc(crf.nEdges, sizeof(double *)); SEXP _edgeBelI, _temp; PROTECT(_edgeBelI = NEW_LIST(crf.nEdges)); for (int i = 0; i < crf.nEdges; i++) { SET_VECTOR_ELT(_edgeBelI, i, _temp = AS_NUMERIC(GetListElement(_edgeBel, i))); edgeBel[i] = NUMERIC_POINTER(_temp); } *nll += NUMERIC_POINTER(AS_NUMERIC(GetListElement(_belief, "logZ")))[0] - crf.Get_LogPotential(y); if (!isNull(_nodeFeaN)) { PROTECT(_nodeFeaN = AS_NUMERIC(_nodeFeaN)); double *nodeFea = NUMERIC_POINTER(_nodeFeaN); if (!ISNAN(nodeFea[0])) { for (int i = 0; i < crf.nNodes; i++) { int s = y[i]; for (int j = 0; j < nNodeFea; j++) { double f = nodeFea[j + nNodeFea * i]; if (f != 0) { for (int k = 0; k < crf.nStates[i]; k++) { int p = nodePar[i + crf.nNodes * (k + crf.maxState * j)] - 1; if (p >= 0 && p < nPar) { if (k == s) { gradient[p] -= f; } gradient[p] += f * nodeBel[i + crf.nNodes * k]; } } } } } } UNPROTECT(1); } if (!isNull(_edgeFeaN)) { PROTECT(_edgeFeaN = AS_NUMERIC(_edgeFeaN)); double *edgeFea = NUMERIC_POINTER(_edgeFeaN); if (!ISNAN(edgeFea[0])) { for (int i = 0; i < crf.nEdges; i++) { int s = y[crf.EdgesBegin(i)] + crf.nStates[crf.EdgesBegin(i)] * y[crf.EdgesEnd(i)]; for (int j = 0; j < nEdgeFea; j++) { double f = edgeFea[j + nEdgeFea * i]; if (f != 0) { for (int k = 0; k < crf.nEdgeStates[i]; k++) { int p = edgePar[i][k + crf.nEdgeStates[i] * j] - 1; if (p >= 0 && p < nPar) { if (k == s) { gradient[p] -= f; } gradient[p] += f * edgeBel[i][k]; } } } } } } UNPROTECT(1); } if (!isNull(_nodeExtN) && isNewList(_nodeExtN)) { for (int i = 0; i < nPar; i++) { SEXP _nodeExtI = GetListElement(_nodeExtN, i); if (!isNull(_nodeExtI)) { PROTECT(_nodeExtI = AS_NUMERIC(_nodeExtI)); double *nodeExt = NUMERIC_POINTER(_nodeExtI); if (!ISNAN(nodeExt[0])) { for (int j = 0; j < crf.nNodes; j++) { int s = y[j]; for (int k = 0; k < crf.nStates[j]; k++) { double f = nodeExt[j + crf.nNodes * k]; if (k == s) { gradient[i] -= f; } gradient[i] += f * nodeBel[j + crf.nNodes * k]; } } } UNPROTECT(1); } } } if (!isNull(_edgeExtN) && isNewList(_edgeExtN)) { for (int i = 0; i < nPar; i++) { SEXP _edgeExtI = GetListElement(_edgeExtN, i); if (!isNull(_edgeExtI) && isNewList(_edgeExtI)) { for (int j = 0; j < crf.nEdges; j++) { SEXP _edgeExtII = GetListElement(_edgeExtI, j); if (!isNull(_edgeExtII)) { PROTECT(_edgeExtII = AS_NUMERIC(_edgeExtII)); double *edgeExt = NUMERIC_POINTER(_edgeExtII); if (!ISNAN(edgeExt[0])) { int s = y[crf.EdgesBegin(j)] + crf.nStates[crf.EdgesBegin(j)] * y[crf.EdgesEnd(j)]; for (int k = 0; k < crf.nEdgeStates[j]; k++) { double f = edgeExt[k]; if (k == s) { gradient[i] -= f; } gradient[i] += f * edgeBel[j][k]; } } UNPROTECT(1); } } } } } UNPROTECT(3); } UNPROTECT(4); return(_nll); }
SEXP CRF_Update(SEXP _crf, SEXP _nodeFea, SEXP _edgeFea, SEXP _nodeExt, SEXP _edgeExt) { CRF crf(_crf); crf.Update_Pot(_nodeFea, _edgeFea, _nodeExt, _edgeExt); return (_crf); }
/* Get register by name */ Test::Register Test::getRegister(ppc::Interpreter::State &state, const std::string &name) { std::smatch smatch; /* General Purpose Register */ std::regex gpr("%r([0-9]+)"); if (std::regex_match(name, smatch, gpr) && smatch.size() == 2) { auto reg = std::stol(smatch[1].str()); if (reg >= 0 && reg <= 31) { return Register(RegisterType::Integer64, &state.reg.gpr[reg]); } } /* FPU Register */ std::regex fpr("%f([0-9]+)"); if (std::regex_match(name, smatch, fpr) && smatch.size() == 2) { auto reg = std::stol(smatch[1].str()); if (reg >= 0 && reg <= 31) { return Register(RegisterType::Double64, &state.reg.fpr[reg]); } } /* XER Link Register */ if (name.compare("%lr") == 0) { return Register(RegisterType::Integer64, &state.reg.lr); } /* XER Carry */ if (name.compare("%xer[ca]") == 0) { return Register(RegisterType::BitField64, little_endian::make_bit_field(state.reg.xer.value, 34, 35)); } /* XER Overflow */ if (name.compare("%xer[ov]") == 0) { return Register(RegisterType::BitField64, little_endian::make_bit_field(state.reg.xer.value, 33, 34)); } /* Condition Register Field */ std::regex crf("%crf([0-9]+)"); if (std::regex_match(name, smatch, crf) && smatch.size() == 2) { auto field = std::stol(smatch[1].str()); if (field >= 0 && field <= 8) { return Register(RegisterType::BitField32, state.reg.cr.crn[field]); } } /* Condition Register Bit */ std::regex crb("%crb([0-9]+)"); if (std::regex_match(name, smatch, crb) && smatch.size() == 2) { auto bit = std::stol(smatch[1].str()); if (bit >= 0 && bit <= 31) { return Register(RegisterType::BitField32, little_endian::make_bit_field(state.reg.cr.value, bit, bit)); } } return Register(); }