int main(int argc, char** argv) {
int maxnumit = 0;
int maxrec = -1;
const char *budget_type_str = NULL;
const char *stage = NULL;
const char *training = NULL;
const char *dev = NULL;
const char *path = NULL;
const char * etransform_str = NULL;
const char *kernel_str = NULL;
const char *rbf_lambda_str = NULL;
#ifdef NDEBUG
log_info("ai-parse %s (Release)", VERSION);
#else
log_info("ai-parse %s (Debug)", VERSION);
#endif
struct argparse_option options[] = {
OPT_HELP(),
//OPT_BOOLEAN('f', "force", &force, "force to do", NULL),
OPT_INTEGER('v', "verbosity", &verbosity, "Verbosity level. Minimum (Default) 0. Increasing values increase parser verbosity.", NULL),
OPT_STRING('o', "modelname", &modelname, "Model name", NULL),
OPT_STRING('p', "path", &path, "CoNLL base directory including sections", NULL),
OPT_STRING('s', "stage", &stage, "[ optimize | train | parse ]", NULL),
OPT_INTEGER('n', "maxnumit", &maxnumit, "Maximum number of iterations by perceptron. Default is 50", NULL),
OPT_STRING('t', "training", &training, "Training sections for optimize and train. Apply sections for parse", NULL),
OPT_STRING('d', "development", &dev, "Development sections for optimize", NULL),
OPT_STRING('e', "epattern", &epattern, "Embedding Patterns", NULL),
OPT_INTEGER('l', "edimension", &edimension, "Embedding dimension", NULL),
OPT_INTEGER('m', "maxrec", &maxrec, "Maximum number of training instance", NULL),
OPT_STRING('x', "etransform", &etransform_str, "Embedding Transformation", NULL),
OPT_STRING('k', "kernel", &kernel_str, "Kernel Type", NULL),
OPT_INTEGER('a', "bias", &bias, "Polynomial kernel additive term. Default is 1", NULL),
OPT_INTEGER('c', "concurrency", &num_parallel_mkl_slaves, "Parallel MKL Slaves. Default is 90% of all machine cores", NULL),
OPT_INTEGER('b', "degree", &polynomial_degree, "Degree of polynomial kernel. Default is 4", NULL),
OPT_STRING('z', "lambda", &rbf_lambda_str, "Lambda multiplier for RBF Kernel.Default value is 0.025"),
OPT_STRING('u', "budget_type", &budget_type_str, "Budget control methods. NONE|RANDOM", NULL),
OPT_INTEGER('g', "budget_size", &budget_target, "Budget Target for budget based perceptron algorithms. Default 50K", NULL),
OPT_END(),
};
struct argparse argparse;
argparse_init(&argparse, options, usage, 0);
argc = argparse_parse(&argparse, argc, argv);
int max_threads = mkl_get_max_threads();
log_info("There are max %d MKL threads", max_threads);
if (num_parallel_mkl_slaves == -1) {
num_parallel_mkl_slaves = (int) (max_threads * 0.9);
if (num_parallel_mkl_slaves == 0)
num_parallel_mkl_slaves = 1;
}
log_info("Number of MKL Slaves is set to be %d", num_parallel_mkl_slaves);
mkl_set_num_threads(num_parallel_mkl_slaves);
if (1 == mkl_get_dynamic())
log_info("Intel MKL may use less than %i threads for a large problem", num_parallel_mkl_slaves);
else
log_info("Intel MKL should use %i threads for a large problem", num_parallel_mkl_slaves);
check(stage != NULL && (strcmp(stage, "optimize") == 0 || strcmp(stage, "train") == 0 || strcmp(stage, "parse") == 0),
"Choose one of -s optimize, train, parse");
check(path != NULL, "Specify a ConLL base directory using -p");
check(edimension != 0, "Set embedding dimension using -l");
check(modelname != NULL, "Provide model name using -o");
if (budget_type_str != NULL) {
if (strcmp(budget_type_str, "RANDOM") == 0 || strcmp(budget_type_str, "RANDOMIZED") == 0) {
budget_method = RANDOMIZED;
} else if (strcmp(budget_type_str, "NONE") == 0) {
budget_method = NONE;
} else {
log_err("Unknown budget control type %s", budget_type_str);
goto error;
}
} else {
budget_method = NONE;
}
if (training == NULL) {
log_warn("training section string is set to %s", DEFAULT_TRAINING_SECTION_STR);
training = strdup(DEFAULT_TRAINING_SECTION_STR);
}
if (dev == NULL && (strcmp(stage, "optimize") == 0 || strcmp(stage, "train") == 0)) {
log_info("development section string is set to %s", DEFAULT_DEV_SECTION_STR);
dev = strdup(DEFAULT_DEV_SECTION_STR);
}
check(epattern != NULL, "Embedding pattern is required for -s optimize,train,parse");
if (etransform_str == NULL) {
log_info("Embedding transformation is set to be QUADRATIC");
etransform = DEFAULT_EMBEDDING_TRANFORMATION;
} else if (strcmp(etransform_str, "LINEAR") == 0) {
etransform = LINEAR;
} else if (strcmp(etransform_str, "QUADRATIC") == 0) {
etransform = QUADRATIC;
} else if (strcmp(etransform_str, "CUBIC") == 0) {
etransform = CUBIC;
} else {
log_err("Unsupported transformation type for embedding %s", etransform_str);
}
if (strcmp(stage, "optimize") == 0 || strcmp(stage, "train") == 0) {
if (maxnumit <= 0) {
log_info("maxnumit is set to %d", DEFAULT_MAX_NUMIT);
maxnumit = DEFAULT_MAX_NUMIT;
}
}
if (kernel_str != NULL) {
if (strcmp(kernel_str, "POLYNOMIAL") == 0) {
log_info("Polynomial kernel will be used with bias %f and degree %d", bias, polynomial_degree);
kernel = KPOLYNOMIAL;
} else if (strcmp(kernel_str, "GAUSSIAN") == 0 || strcmp(kernel_str, "RBF") == 0) {
if (rbf_lambda_str != NULL) {
rbf_lambda = (float) atof(rbf_lambda_str);
}
log_info("RBF/GAUSSIAN kernel will be used with lambda %f ", rbf_lambda);
kernel = KRBF;
} else {
log_err("Unsupported kernel type %s. Valid options are LINEAR, POLYNOMIAL, and RBF/GAUSSIAN", kernel_str);
goto error;
}
}
if (strcmp(stage, "optimize") == 0) {
void *model = optimize(maxnumit, maxrec, path, training, dev, edimension);
char* model_filename = (char*) malloc(sizeof (char) * (strlen(modelname) + 7));
check_mem(model_filename);
sprintf(model_filename, "%s.model", modelname);
FILE *fp = fopen(model_filename, "w");
if (kernel == KLINEAR) {
PerceptronModel pmodel = (PerceptronModel) model;
dump_PerceptronModel(fp, edimension, pmodel->embedding_w_best, pmodel->best_numit);
PerceptronModel_free(pmodel);
} else if (kernel == KPOLYNOMIAL || kernel == KRBF) {
KernelPerceptron kpmodel = (KernelPerceptron) model;
dump_KernelPerceptronModel(fp, kpmodel);
}
log_info("Model is dumped into %s file", model_filename);
fclose(fp);
} else if (strcmp(stage, "parse") == 0) {
char* model_filename = (char*) malloc(sizeof (char) * (strlen(modelname) + 7));
check_mem(model_filename);
sprintf(model_filename, "%s.model", modelname);
FILE *fp = fopen(model_filename, "r");
check(fp != NULL, "%s could not be opened", model_filename);
void *model;
if (kernel == KLINEAR)
model = load_PerceptronModel(fp);
else
model = load_KernelPerceptronModel(fp);
fclose(fp);
check(model != NULL, "Error in loading model file");
log_info("Model loaded from %s successfully", model_filename);
parseall(model, path, training, edimension);
} else {
log_info("Waiting for implementation");
}
return (EXIT_SUCCESS);
error:
return (EXIT_FAILURE);
}
void StVKReducedStiffnessMatrix::Evaluate(double * q, double * Rq)
{
// this is same as EvaluateSubset with start=0, end=quadraticSize
/*
int i,j,k;
int output;
// reset to free terms
int index = 0;
int indexEntry = 0;
for(output=0; output<r; output++)
{
for(i=output; i<r; i++)
{
Rq[indexEntry] = freeCoef_[index];
index++;
indexEntry++;
}
indexEntry += output + 1;
}
// add linear terms
index = 0;
indexEntry = 0;
for(output=0; output<r; output++)
{
for(i=output; i<r; i++)
{
for(j=0; j<r; j++)
{
Rq[indexEntry] += linearCoef_[index] * q[j];
index++;
}
indexEntry++;
}
indexEntry += output + 1;
}
// add quadratic terms
index = 0;
indexEntry = 0;
for(output=0; output<r; output++)
{
for(i=output; i<r; i++)
{
for(j=0; j<r; j++)
for(k=j; k<r; k++)
{
Rq[indexEntry] += quadraticCoef_[index] * q[j] * q[k];
index++;
}
indexEntry++;
}
indexEntry += output + 1;
}
// make symetric
for(output=0; output<r; output++)
for(i=0; i<output; i++)
Rq[ELT(r,i,output)] = Rq[ELT(r,output,i)];
*/
if (useSingleThread)
{
#if defined(WIN32) || defined(linux)
mkl_max_threads = mkl_get_max_threads();
mkl_dynamic = mkl_get_dynamic();
mkl_set_num_threads(1);
mkl_set_dynamic(0);
#elif defined(__APPLE__)
//setenv("VECLIB_MAXIMUM_THREADS", "1", true);
#endif
}
// reset to free terms
memcpy(buffer1,freeCoef_,sizeof(double)*quadraticSize);
// add linear terms
// multiply linearCoef_ and q
// linearCoef_ is r x quadraticSize array
cblas_dgemv(CblasColMajor, CblasTrans,
r, quadraticSize,
1.0,
linearCoef_, r,
q, 1,
1.0,
buffer1, 1);
// compute qiqj
int index = 0;
for(int output=0; output<r; output++)
for(int i=output; i<r; i++)
{
qiqj[index] = q[output] * q[i];
index++;
}
// update Rq
// quadraticCoef_ is quadraticSize x quadraticSize matrix
// each column gives quadratic coef for one matrix entry
cblas_dgemv(CblasColMajor, CblasTrans,
quadraticSize, quadraticSize,
1.0,
quadraticCoef_, quadraticSize,
qiqj, 1,
1.0,
buffer1, 1);
// unpack into a symmetric matrix
int i1=0,j1=0;
for(int i=0; i< quadraticSize; i++)
{
Rq[ELT(r,i1,j1)] = buffer1[i];
Rq[ELT(r,j1,i1)] = buffer1[i];
j1++;
if(j1 == r)
{
i1++;
j1 = i1;
}
}
if (useSingleThread)
{
#if defined(WIN32) || defined(linux)
mkl_set_num_threads(mkl_max_threads);
mkl_set_dynamic(mkl_dynamic);
#elif defined(__APPLE__)
//unsetenv("VECLIB_MAXIMUM_THREADS");
#endif
}
}
void StVKReducedInternalForces::Evaluate(double * q, double * fq)
{
/* // unoptimized version
// reset to zero
int i,j,k,l;
for(l=0; l<r; l++)
fq[l] = 0;
// add linear terms
int index = 0;
for(l=0; l<r; l++)
for(i=0; i<r; i++)
{
fq[l] += linearCoef_[index] * q[i];
index++;
}
// add quadratic terms
index = 0;
for(l=0; l<r; l++)
for(i=0; i<r; i++)
for(j=i; j<r; j++)
{
fq[l] += quadraticCoef_[index] * q[i] * q[j];
index++;
}
// add cubic terms
index = 0;
for(l=0; l<r; l++)
for(i=0; i<r; i++)
for(j=i; j<r; j++)
for(k=j; k<r; k++)
{
fq[l] += cubicCoef_[index] * q[i] * q[j] * q[k];
index++;
}
*/
if (useSingleThread)
{
#if defined(_WIN32) || defined(WIN32) || defined(linux)
mkl_max_threads = mkl_get_max_threads();
mkl_dynamic = mkl_get_dynamic();
mkl_set_num_threads(1);
mkl_set_dynamic(0);
#elif defined(__APPLE__)
//setenv("VECLIB_MAXIMUM_THREADS", "1", true);
#endif
}
// add linear terms
// multiply linearCoef_ and q
// linearCoef_ is r x r array
cblas_dgemv(CblasColMajor, CblasTrans,
r, r,
1.0,
linearCoef_, r,
q, 1,
0.0,
fq, 1);
// compute qiqj
int index = 0;
for(int output=0; output<r; output++)
for(int i=output; i<r; i++)
{
qiqj[index] = q[output] * q[i];
index++;
}
// add quadratic terms
// quadraticCoef_ is quadraticSize x r matrix
// each column gives quadratic coef for one force vector component
cblas_dgemv(CblasColMajor, CblasTrans,
quadraticSize, r,
1.0,
quadraticCoef_, quadraticSize,
qiqj, 1,
1.0,
fq, 1);
// add cubic terms
// cubicCoef_ is cubicSize x r matrix
// each column gives cubicSize coef for one force vector component
int size = quadraticSize;
double * qiqjPos = qiqj;
double * cubicCoefPos = cubicCoef_;
for(int i=0; i<r; i++)
{
cblas_dgemv(CblasColMajor, CblasTrans,
size, r,
q[i],
cubicCoefPos, cubicSize,
qiqjPos, 1,
1.0,
fq, 1);
int param = r-i;
size -= param;
qiqjPos += param;
cubicCoefPos += param * (param+1) / 2;
}
if (addGravity)
{
for(int i=0; i<r; i++)
fq[i] -= reducedGravityForce[i];
}
if (useSingleThread)
{
#if defined(_WIN32) || defined(WIN32) || defined(linux)
mkl_set_num_threads(mkl_max_threads);
mkl_set_dynamic(mkl_dynamic);
#elif defined(__APPLE__)
//unsetenv("VECLIB_MAXIMUM_THREADS");
#endif
}
}
