void iter2_conjgrad(void* _conf,
const struct operator_s* normaleq_op,
unsigned int D,
const struct operator_p_s** prox_ops,
const struct linop_s** ops,
const struct operator_p_s* xupdate_op,
long size, float* image, const float* image_adj,
const float* image_truth,
void* obj_eval_data,
float (*obj_eval)(const void*, const float*))
{
assert(0 == D);
assert(NULL == prox_ops);
assert(NULL == ops);
UNUSED(xupdate_op);
struct iter_conjgrad_conf* conf = _conf;
float eps = md_norm(1, MD_DIMS(size), image_adj);
if (checkeps(eps))
goto cleanup;
conjgrad(conf->maxiter, conf->l2lambda, eps * conf->tol, size, (void*)normaleq_op, select_vecops(image_adj), operator_iter, image, image_adj, image_truth, obj_eval_data, obj_eval);
cleanup:
;
}
void iter2_conjgrad(iter_conf* _conf,
const struct operator_s* normaleq_op,
unsigned int D,
const struct operator_p_s* prox_ops[D],
const struct linop_s* ops[D],
const float* biases[D],
const struct operator_p_s* xupdate_op,
long size, float* image, const float* image_adj,
struct iter_monitor_s* monitor)
{
assert(0 == D);
assert(NULL == prox_ops);
assert(NULL == ops);
assert(NULL == biases);
UNUSED(xupdate_op);
auto conf = CAST_DOWN(iter_conjgrad_conf, _conf);
float eps = md_norm(1, MD_DIMS(size), image_adj);
if (checkeps(eps))
goto cleanup;
conjgrad(conf->maxiter, conf->l2lambda, eps * conf->tol, size, select_vecops(image_adj),
OPERATOR2ITOP(normaleq_op), image, image_adj, monitor);
cleanup:
;
}
static void inverse(void* _data, float alpha, float* dst, const float* src)
{
struct irgnm_s* data = _data;
md_clear(1, MD_DIMS(data->size), dst, FL_SIZE);
float eps = md_norm(1, MD_DIMS(data->size), src);
conjgrad(100, alpha, 0.1f * eps, data->size, (void*)data, select_vecops(src), normal, dst, src, NULL, NULL, NULL);
}
static void sense_reco(struct sense_data* data, complex float* imgs, const complex float* kspace)
{
complex float* adj = md_alloc(DIMS, data->imgs_dims, CFL_SIZE);
md_clear(DIMS, data->imgs_dims, imgs, CFL_SIZE);
sense_adjoint(data, adj, kspace);
long size = md_calc_size(DIMS, data->imgs_dims);
conjgrad(100, data->alpha, 1.E-3, 2 * size, data, &cpu_iter_ops, sense_normal,
(float*)imgs, (const float*)adj, NULL, NULL, NULL);
md_free(adj);
}
int main (void)
{
float x[4], y[5], d[4];
int i,j;
a = sf_floatalloc2(4,5);
a[0][0] = 1.; a[0][1] = 1.; a[0][2] = 1.; a[0][3] = 0.;
a[1][0] = 1.; a[1][1] = 2.; a[1][2] = 0.; a[1][3] = 0.;
a[2][0] = 1.; a[2][1] = 3.; a[2][2] = 1.; a[2][3] = 0.;
a[3][0] = 1.; a[3][1] = 4.; a[3][2] = 0.; a[3][3] = 1.;
a[4][0] = 1.; a[4][1] = 5.; a[4][2] = 1.; a[4][3] = 1.;
y[0]=3.; y[1]=3.; y[2]=5.; y[3]=7.; y[4] = 9.;
printf ("y = \n");
for (i=0; i < 5; i ++) {
printf (" %10.2f",y[i]);
}
printf ("\n");
printf ("a = \n");
for (j=0; j < 5; j ++) {
for (i=0; i < 4; i ++) {
printf (" %10.2f",a[j][i]);
}
printf("\n");
}
printf("\n");
matmult_lop(true,false,4,5,d,y);
conjgrad(normal, 4, d, NULL, x, 7, 0.0);
printf ("x = ");
for (i=0; i < 4; i ++) {
printf (" %12.8f",x[i]);
}
printf ("\n");
exit(0);
}
int main(int argc, char* argv[])
{
int nr, nc, nx, niter;
float *x, tol;
sf_file row_in, col_in, row_out, col_out;
sf_init(argc,argv);
row_in = sf_input("in");
col_in = sf_input("col_in");
row_out = sf_output("out");
col_out = sf_output("col_out");
if (!sf_histint(row_in,"n1",&nr)) sf_error("No n1= in input");
if (!sf_histint(col_in,"n1",&nc)) sf_error("No n1= in input");
nx = nr+nc;
x = sf_floatalloc(nx);
/* read input - B'd */
sf_floatread(x,nr,row_in);
sf_floatread(x+nr,nc,col_in);
if (!sf_getint("niter",&niter)) niter=10; /* number of iterations */
if (!sf_getfloat("tol",&tol)) tol=0.0f; /* CG tolerance */
/* Run PCG */
cr_init(nr,nc);
conjgrad(cr_apply,nx,x,x,x,niter,tol);
/* write output */
sf_floatwrite(x,nr,row_out);
sf_floatwrite(x+nr,nc,col_out);
exit(0);
}
int main(int argc, char **argv)
{
double fret; /* Frank energy */
double start, end; /* for timing */
double **grid; /* 2D grid */
int **lock; /* locked cells */
double **fgrid; /* fullgrid */
int **flock; /* locked cells (fullgrid) */
char fname[128] = "log";
char gname[128] = "grid";
char suffix[128];
int iter = 0;
long maxiter;
int flag, rank, np; /* MPI variables */
float t0; /* starting "temperature" */
FILE *log_fp;
t_par par[2];
int sep, ba;
MPI_Init(&argc, &argv);
MPI_Initialized(&flag);
if (flag != 1) MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc < 11 || argc > 12) {
if (rank == 0) printf("Usage: <%s> <x length> <y length> <monte carlo steps> <temp> <major axis> <minor axis> <align> <theta> <separation> <boundary angle> [id]\n", argv[0]);
MPI_Finalize();
exit(1);
}
nx = atoi(argv[1]);
ny = atoi(argv[2]);
maxiter = atoi(argv[3]);
t0 = atof(argv[4]);
par[0].major = par[1].major = atoi(argv[5]);
par[0].minor = par[1].minor = atoi(argv[6]);
if (strcmp(argv[7], "para") != 0 && strcmp(argv[7], "perp") != 0) {
if (rank == 0) printf("Alignment must be para or perp\n");
MPI_Finalize();
exit(1);
}
strcpy(par[0].align, argv[7]);
strcpy(par[1].align, argv[7]);
par[0].theta = 0;
par[1].theta = atof(argv[8]);
sep = atoi(argv[9]);
ba = atoi(argv[10]);
if (argc == 12) id = atoi(argv[11]);
else id = 1;
par[0].cy = par[1].cy = ny / 2;
par[0].cx = nx / 2 - par[0].major - sep / 2;
par[1].cx = nx / 2 + par[1].major + sep / 2 - 1;
sprintf(suffix, "r%dx%d_t%.0f_s%d_a%d_%d_%s",
par[0].major, par[0].minor, par[1].theta, sep, ba, id, par[0].align);
par[1].theta = PI * par[1].theta / 180.0;
random_key key;
int success = initialise(&grid, &lock, par, sep, ba, suffix, &key);
int all_succeeded;
MPI_Allreduce(&success, &all_succeeded, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
if (all_succeeded != np) {
MPI_Finalize();
return 0;
}
strcat(gname, suffix);
print(grid, gname);
fret = func(grid, lock, 0);
if (rank == 0) {
printf("Initial Frank Energy: %f\n", fret);
strcat(fname, suffix);
log_fp = fopen(fname, "w");
}
start = MPI_Wtime();
monte(grid, lock, maxiter, t0, log_fp, suffix, key);
end = MPI_Wtime();
grid2root(grid, &fgrid);
lock2root(lock, &flock);
prncont(fgrid, "testgrid");
fret = func(grid, lock, 0);
if (rank == 0) conjgrad(fgrid, flock, 10000, &fret, log_fp, suffix, par, sep);
if (rank == 0) {
printf("End Frank Energy: %f\n", fret);
printf("No. iterations: %d\n", iter);
printf("Time taken: %f\n", end - start);
}
MPI_Finalize();
return 0;
}
void LayerNet::anx_dd ( TrainingSet *tptr , struct LearnParams *lptr )
{
int itry, n_escape, n_retry, bad_count, new_record, refined ;
long seed ;
double err, prev_err, best_err, start_of_loop_error, best_inner_error ;
double initial_accuracy, final_accuracy ;
char msg[80] ;
LayerNet *worknet, *worknet2, *bestnet ;
n_escape = n_retry = 0 ;
/*
Allocate scratch memory
*/
MEMTEXT ( "ANX_DD::learn new worknet, bestnet" ) ;
worknet = new LayerNet ( model , outmod , outlin , nin , nhid1 , nhid2 ,
nout , 0 , 0 ) ;
bestnet = new LayerNet ( model , outmod , outlin , nin , nhid1 , nhid2 ,
nout , 0 , 1 ) ;
if ((worknet == NULL) || (! worknet->ok)
|| (bestnet == NULL) || (! bestnet->ok)) {
memory_message ( "to learn" ) ;
if (worknet != NULL)
delete worknet ;
if (bestnet != NULL)
delete bestnet ;
errtype = 0 ;
return ;
}
if ((lptr->method == METHOD_AN2_CJ) || (lptr->method == METHOD_AN2_LM)) {
worknet2 = new LayerNet ( model , outmod , outlin , nin , nhid1 , nhid2 ,
nout , 0 , 0 ) ;
if ((worknet2 == NULL) || (! worknet2->ok)) {
if (worknet2 != NULL)
delete worknet2 ;
delete worknet ;
delete bestnet ;
memory_message ( "to learn" ) ;
errtype = 0 ;
return ;
}
}
else
worknet2 = NULL ;
/*
Start by annealing around the starting weights. These will be zero if the
net was just created. If it was restored or partially trained already,
they will be meaningful. Anneal1 guarantees that it will not return all
zero weights if there is at least one hidden layer, even if that means
that the error exceeds the amount that could be attained by all zeros.
*/
best_err = best_inner_error = 1.e30 ;
if ((lptr->method == METHOD_AN1_CJ) || (lptr->method == METHOD_AN1_LM))
anneal1 ( tptr , lptr , worknet , 1 , 0 ) ;
else if ((lptr->method == METHOD_AN2_CJ) || (lptr->method == METHOD_AN2_LM))
anneal2 ( tptr , lptr , worknet , worknet2 , 1 ) ;
/*
Do direct descent optimization, finding local minimum.
Then anneal to break out of it. If successful, loop back up to
do direct descent again. Otherwise restart totally random.
*/
bad_count = 0 ; // Handles flat local mins
refined = 0 ; // Did we ever refine to high resolution? Not yet.
new_record = 0 ; // Refine every time a new inner error record set
initial_accuracy = pow ( 10.0 , -lptr->cj_acc ) ;
final_accuracy = initial_accuracy * pow ( 10.0 , -lptr->cj_refine ) ;
for (itry=1 ; ; itry++) {
if (neterr < best_err) { // Keep track of best
copy_weights ( bestnet , this ) ;
best_err = neterr ;
}
sprintf ( msg , "Try %d (best=%lf):", itry, best_err ) ;
normal_message ( msg ) ;
if (neterr <= lptr->quit_err)
break ;
start_of_loop_error = neterr ;
if ((lptr->method == METHOD_AN1_CJ) || (lptr->method == METHOD_AN2_CJ))
err = conjgrad ( tptr , 32767 , initial_accuracy ,
lptr->quit_err , lptr->cj_progress ) ;
else if ((lptr->method==METHOD_AN1_LM) || (lptr->method==METHOD_AN2_LM))
err = lev_marq ( tptr , 32767 , initial_accuracy ,
lptr->quit_err , lptr->cj_progress ) ;
neterr = fabs ( err ) ; // err<0 if user pressed ESCape
sprintf ( msg , " Gradient err=%lf", neterr ) ;
progress_message ( msg ) ;
if (neterr < best_err) { // Keep track of best
copy_weights ( bestnet , this ) ;
best_err = neterr ;
}
if (err <= lptr->quit_err) { // err<0 if user pressed ESCape
if (err < -1.e29) // or insufficient memory
printf ( "\nInsufficient memory for gradient learning." ) ;
break ;
}
seed = flrand() - (long) (itry * 97) ; // Insure new seed for anneal
sflrand ( seed ) ;
prev_err = neterr ; // So we can see if anneal helped
if ((lptr->method == METHOD_AN1_CJ) || (lptr->method == METHOD_AN1_LM))
anneal1 ( tptr , lptr , worknet , 0 , itry ) ;
else if ((lptr->method==METHOD_AN2_CJ) || (lptr->method==METHOD_AN2_LM))
anneal2 ( tptr , lptr , worknet , worknet2 , 0 ) ;
sprintf ( msg , " Anneal err=%lf", neterr ) ;
progress_message ( msg ) ;
if (neterr < best_err) { // Keep track of best
copy_weights ( bestnet , this ) ;
best_err = neterr ;
}
if (best_err <= lptr->quit_err)
break ;
if (neterr < best_inner_error) { // Keep track of best inner for refine
best_inner_error = neterr ;
new_record = 1 ; // Tells us to refine
}
if ((prev_err - neterr) > 1.e-7) { // Did we break out of local min?
if ((start_of_loop_error - neterr) < 1.e-3)
++bad_count ; // Avoid many unprofitable iters
else
bad_count = 0 ;
if (bad_count < 4) {
++n_escape ; // Count escapes from local min
continue ; // Escaped, so gradient learn again
}
}
/*
After first few tries, and after each inprovement thereafter, refine
to high resolution
*/
if ((itry-n_escape >= lptr->cj_pretries) && (new_record || ! refined)) {
if (! refined) { // If refining the best of the pretries
copy_weights ( this , bestnet ) ; // Get that net
neterr = best_err ;
}
refined = 1 ; // Only force refine once
new_record = 0 ; // Reset new inner error record flag
progress_message ( " REFINING" ) ;
if ((lptr->method == METHOD_AN1_CJ) || (lptr->method == METHOD_AN2_CJ))
err = conjgrad ( tptr , 0 , final_accuracy ,
lptr->quit_err , lptr->cj_progress ) ;
else if ((lptr->method==METHOD_AN1_LM)|| (lptr->method==METHOD_AN2_LM))
err = lev_marq ( tptr , 0 , final_accuracy ,
lptr->quit_err , lptr->cj_progress ) ;
neterr = fabs ( err ) ; // err<0 if user pressed ESCape
sprintf ( msg , " Attained err=%lf", neterr ) ;
progress_message ( msg ) ;
if (neterr < best_err) { // Keep track of best
copy_weights ( bestnet , this ) ;
best_err = neterr ;
}
}
if (++n_retry > lptr->retries)
break ;
progress_message ( " RESTART" ) ;
zero_weights () ; // Failed to break out, so retry random
seed = flrand() - (long) (itry * 773) ; // Insure new seed for anneal
sflrand ( seed ) ;
if ((lptr->method == METHOD_AN1_CJ) || (lptr->method == METHOD_AN1_LM))
anneal1 ( tptr , lptr , worknet , 1 , itry ) ;
else if ((lptr->method==METHOD_AN2_CJ) || (lptr->method==METHOD_AN2_LM))
anneal2 ( tptr , lptr , worknet , worknet2 , 1 ) ;
}
FINISH:
copy_weights ( this , bestnet ) ;
neterr = best_err ;
MEMTEXT ( "AN1_DD::learn delete worknet, bestnet" ) ;
delete worknet ;
delete bestnet ;
sprintf ( msg , "%d successful escapes, %d retries", n_escape, n_retry ) ;
normal_message ( msg ) ;
return ;
}
/* Fit the curve to the given points */
static void mcv_fit(mcv *p,
int verb, /* Vebosity level, 0 = none */
int order, /* Number of curve orders, 1..MCV_MAXORDER */
mcvco *d, /* Array holding scattered initialisation data */
int ndp, /* Number of data points */
double smooth /* Degree of smoothing, 1.0 = normal */
) {
int i;
double *sa; /* Search area */
double *pms; /* Parameters to optimise */
double min, max;
p->verb = verb;
p->smooth = smooth;
p->luord = order+2; /* Add two for offset and scale */
if (p->pms != NULL)
free(p->pms);
if ((p->pms = (double *)calloc(p->luord, sizeof(double))) == NULL)
error ("Malloc failed");
if ((pms = (double *)calloc(p->luord, sizeof(double))) == NULL)
error ("Malloc failed");
if ((sa = (double *)calloc(p->luord, sizeof(double))) == NULL)
error ("Malloc failed");
if ((p->dv = (double *)calloc(p->luord, sizeof(double))) == NULL)
error ("Malloc failed");
#ifdef DEBUG
printf("mcv_fit with %d points (noos = %d)\n",ndp,p->noos);
#endif
/* Establish the range of data values */
min = 1e38; /* Locate min, and make that offset */
max = -1e38; /* Locate max */
for (i = 0; i < ndp; i++) {
if (d[i].v < min)
min = d[i].v;
if (d[i].v > max)
max = d[i].v;
#ifdef DEBUG
printf("point %d is %f %f\n",i,d[i].p,d[i].v);
#endif
}
if (p->noos) {
p->pms[0] = min = 0.0;
p->pms[1] = max = 1.0;
} else {
/* Set offset and scale to reasonable values */
p->pms[0] = min;
p->pms[1] = max - min;
}
p->dra = max - min;
if (p->dra <= 1e-12)
error("Mcv max - min %e too small",p->dra);
/* Use powell to minimise the sum of the squares of the */
/* input points to the curvem, plus a parameter damping factor. */
p->d = d;
p->ndp = ndp;
for (i = 0; i < p->luord; i++)
sa[i] = 0.2;
#ifdef NEVER
if (powell(&p->resid, p->luord-p->noos, p->pms+p->noos, sa+p->noos, POWTOL, MAXITS,
mcv_opt_func, (void *)p, NULL, NULL) != 0)
error ("Mcv fit powell failed");
#else
if (conjgrad(&p->resid, p->luord-p->noos, p->pms+p->noos, sa+p->noos, POWTOL, MAXITS,
mcv_opt_func, mcv_dopt_func, (void *)p, NULL, NULL) != 0) {
#ifndef NEVER
fprintf(stderr,"Mcv fit conjgrad failed with %d points:\n",ndp);
for (i = 0; i < ndp; i++) {
fprintf(stderr," %d: %f -> %f\n",i,d->p, d->v);
}
#endif
error ("Mcv fit conjgrad failed");
}
#endif
free(p->dv);
p->dv = NULL;
free(sa);
free(pms);
}
