static PyObject *UtilsC_maximization_beta(PyObject *self, PyObject *args){
PyObject *q_Z,*Z_tilde,*graph;
PyArrayObject *q_Zarray,*Z_tildearray,*grapharray;
npy_float64 beta,gamma,Gr,gradientStep;
int j,J,K,k,ni,maxNeighbours,nn,MaxItGrad;
PyArg_ParseTuple(args, "dOOiiOdiid", &beta,&q_Z,&Z_tilde,&J,&K,&graph,&gamma,&maxNeighbours,&MaxItGrad,&gradientStep);
q_Zarray = (PyArrayObject *) PyArray_ContiguousFromObject(q_Z,PyArray_FLOAT64,2,2);
Z_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(Z_tilde,PyArray_FLOAT64,2,2);
grapharray = (PyArrayObject *) PyArray_ContiguousFromObject(graph,PyArray_INT,2,2);
npy_float64 tmp2[K],Emax,Sum,tmp,Pzmi;
Gr = gamma;
ni = 0;
while( (ni<MaxItGrad) && (fabs(Gr) > eps) ){
Gr = gamma;
for (j=0;j<J;j++){
Emax = 0;
for (k=0;k<K;k++){
tmp2[k] = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours) {
tmp2[k] += beta * GetValue(Z_tildearray,k,GetValueInt(grapharray,j,nn));
nn++;
}
if (tmp2[k] > Emax) Emax = tmp2[k];
}
Sum = 0;
for (k=0;k<K;k++){
Sum += exp(tmp2[k] - Emax);
}
for (k=0;k<K;k++){
tmp = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours) {
tmp += GetValue(Z_tildearray,k,GetValueInt(grapharray,j,nn));
nn++;
}
Pzmi = exp(beta * tmp - Emax) / (Sum + eps);
Gr += tmp * ( Pzmi - GetValue(q_Zarray,k,j) );
}
}
beta -= gradientStep*Gr;
ni++;
}
if (eps > beta) beta = 0.01;
Py_DECREF(grapharray);
Py_DECREF(q_Zarray);
Py_DECREF(Z_tildearray);
Py_INCREF(Py_None);
return Py_BuildValue("d", beta);
}
int
main ( int argc, char* argv[] ){
NodeObj Main = NewNode();
SetPropInt(Main, "State", Starting);
TimeUpdate();
DebugPrint ( "Entering Main", __FILE__, __LINE__, PROG_FLOW);
ProcessCmdLine(Main, argc, argv);
Init(Main);
InstallObjects();
LoadDefaultApp(Main);
DebugPrint ( "Entering Main Loop.", __FILE__, __LINE__, PROG_FLOW);
while(IsRunning(Main)){
MainLoop(Main);
// improvement: get delay from next scheduled item, min of 10 usecs
usleep(10);
}
DebugPrint ( "No more tasks scheduled, cleaning up and exiting", __FILE__, __LINE__, PROG_FLOW);
if (GetValueInt(GetPropNode(Main, "PrintNodes"))) {
DebugPrint ( "Dumping Main Node on exit because -p was passed on command line.\n", __FILE__, __LINE__, PROG_FLOW);
PrintNode(Main);
}
return 0;
}
static PyObject *UtilsC_expectation_Z(PyObject *self, PyObject *args){
PyObject *q_Z,*Z_tilde,*graph,*Sigma_A,*m_A,*sigma_M,*Beta,*mu_M;
PyArrayObject *q_Zarray,*Z_tildearray,*grapharray,*Sigma_Aarray,*m_Aarray,*sigma_Marray,*Betaarray,*mu_Marray;
int j,J,K,k,m,maxNeighbours,nn,M;
PyArg_ParseTuple(args, "OOOOOOOOiiii",&Sigma_A,&m_A,&sigma_M, &Beta,&Z_tilde,&mu_M,&q_Z,&graph,&M,&J,&K,&maxNeighbours);
q_Zarray = (PyArrayObject *) PyArray_ContiguousFromObject(q_Z,PyArray_FLOAT64,3,3);
Z_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(Z_tilde,PyArray_FLOAT64,3,3);
grapharray = (PyArrayObject *) PyArray_ContiguousFromObject(graph,PyArray_INT,2,2);
Sigma_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_A,PyArray_FLOAT64,3,3);
sigma_Marray = (PyArrayObject *) PyArray_ContiguousFromObject(sigma_M,PyArray_FLOAT64,2,2);
m_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(m_A,PyArray_FLOAT64,2,2);
mu_Marray = (PyArrayObject *) PyArray_ContiguousFromObject(mu_M,PyArray_FLOAT64,2,2);
Betaarray = (PyArrayObject *) PyArray_ContiguousFromObject(Beta,PyArray_FLOAT64,1,1);
npy_float64 tmp[K],Emax,Sum,alpha[K],Malpha,extern_field,Gauss[K],local_energy,energy[K],Probas[K];
for (j=0;j<J;j++){
for (m=0;m<M;m++){
Malpha = 0;
for (k=0;k<K;k++){
alpha[k] = -0.5*GetValue3D(Sigma_Aarray,m,m,j) / (eps + GetValue(sigma_Marray,m,k) );
Malpha += alpha[k]/K;
}
for (k=0;k<K;k++){
alpha[k] /= Malpha;
tmp[k] = 0;
nn = 0;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours){
tmp[k] += GetValue3D(Z_tildearray,m,k,GetValueInt(grapharray,j,nn));
nn++;
}
}
Emax = 0;
for (k=0;k<K;k++){
energy[k] = 0;
extern_field = log( normpdf(GetValue(m_Aarray,j,m),GetValue(mu_Marray,m,k), sqrt(GetValue(sigma_Marray,m,k)) ) +eps);
if (extern_field < -100) extern_field = -100;
extern_field += alpha[k];
local_energy = GetValue(Betaarray,m,0) * tmp[k];
energy[k] += local_energy + extern_field;
if (energy[k] > Emax) Emax = energy[k];
}
Sum = 0;
for (k=0;k<K;k++){
Probas[k] = exp( energy[k] - Emax );
Sum += Probas[k];
}
for (k=0;k<K;k++){
GetValue3D(Z_tildearray,m,k,j) = Probas[k] / (Sum + eps);
}
}
}
/*--------------------------------------------------------------*/
for (j=0;j<J;j++){
for (m=0;m<M;m++){
Malpha = 0;
for (k=0;k<K;k++){
alpha[k] = -0.5*GetValue3D(Sigma_Aarray,m,m,j) / (eps + GetValue(sigma_Marray,m,k) );
Malpha += alpha[k]/K;
}
for (k=0;k<K;k++){
tmp[k] = 0;
nn = 0;
alpha[k] /= Malpha;
while(GetValueInt(grapharray,j,nn) != -1 && nn<maxNeighbours){
tmp[k] += GetValue3D(Z_tildearray,m,k,GetValueInt(grapharray,j,nn));
nn++;
}
}
Emax = 0;
for (k=0;k<K;k++){
energy[k] = 0;
extern_field = alpha[k];
local_energy = GetValue(Betaarray,m,0) * tmp[k];
energy[k] += local_energy + extern_field;
if (energy[k] > Emax) Emax = energy[k];
Gauss[k] = normpdf(GetValue(m_Aarray,j,m),GetValue(mu_Marray,m,k), sqrt(GetValue(sigma_Marray,m,k)) );
}
Sum = 0;
for (k=0;k<K;k++){
Probas[k] = exp( energy[k] - Emax );
Sum += Probas[k];
}
for (k=0;k<K;k++){
GetValue3D(q_Zarray,m,k,j) = Gauss[k]*Probas[k] / (Sum + eps);
}
Sum = 0;
for (k=0;k<K;k++){
Sum += GetValue3D(q_Zarray,m,k,j);
}
for (k=0;k<K;k++){
GetValue3D(q_Zarray,m,k,j) /= Sum;
}
}
}
Py_DECREF(grapharray);
Py_DECREF(q_Zarray);
Py_DECREF(Z_tildearray);
Py_DECREF(m_Aarray);
Py_DECREF(mu_Marray);
Py_DECREF(Sigma_Aarray);
Py_DECREF(Betaarray);
Py_DECREF(sigma_Marray);
Py_INCREF(Py_None);
return Py_None;
}
void
Init(NodeObj Main){
char * logname;
NodeObj RegObjList;
/* just hum along, add in the parts to initialize base object as I find we need them. */
DebugPrint ( "Entering Init function.", __FILE__, __LINE__, PROG_FLOW);
/* Set the name of the main object */
SetName (Main, "Main");
/* Create a place to store registered Objects */
SetPropInt(Main, "RegObjList", 1);
RegObjList = GetPropNode(Main, "RegObjList");
ObjSetRegObjList(RegObjList);
/* activate the main object */
SetPropInt(Main, "State", Running);
/* Insert release info into the Main node properties */
SetPropStr(Main, "ReleaseMajor", RELEASEMAJOR);
SetPropStr(Main, "ReleaseName", RELEASENAME);
SetPropStr(Main, "ReleaseMinor", RELEASEMINOR);
SetPropStr(Main, "ReleaseLevel", RELEASELEVEL);
SetPropStr(Main, "Copyright", COPYRIGHT);
SetPropStr(Main, "Author", AUTHOR);
SetPropStr(Main, "ReleaseTag", RELEASETAG);
/* process the command line */
/* print out the help text if printhelp is turned on */
if (GetValueInt(GetPropNode(Main, "printhelp"))) {
printf ("%s %s.%s %s - (C) %s %s\n%s\nhttp://grokthink.org\n\n Usage: framework <options>\n\n Options:\n\n -h : This help screen\n -d : Become a server process\n -l <logfile> : logfile to output debug info\n -p : Print Main Nodes on exit\n -t : Perform Unit Testing of library functions\n -v <number> : Verbose level from 0 to 9, inclusive\n\n", RELEASENAME, RELEASEMAJOR, RELEASEMINOR, RELEASELEVEL, COPYRIGHT, AUTHOR, RELEASETAG);
}
/* if -t command line argument is set, perform unit test */
if (GetValueInt(GetPropNode(Main, "UnitTest"))) {
PerformTesting();
}
/* if deamon option was turned on, become a deamon */
if (GetValueInt(GetPropNode(Main, "deamon"))) {
// also turn off logging in debug print.
// because part of becoming a deamon is eliminating stdout
DebugPrint ( "Becoming a Deamon.", __FILE__, __LINE__, PROG_FLOW);
become_deamon ();
}
/* if logname is given, set the debug print to use the logfile */
logname = GetValueStr(GetPropNode(Main, "logname"));
if (logname && strlen(logname)) {
// set up the debug print to output to logfile
// turn on normal debug printing
DebugPrint ( "Verbose Logging Enabled.", __FILE__, __LINE__, PROG_FLOW);
;
}
/* set the logging level for debug print */
DebugPrint ( "Logging Level Set.", __FILE__, __LINE__, PROG_FLOW);
/* Setup task list */
Tasks = CreateList();
}
