/*--------------------------------------------------------*/ void AzsSvrg::_train_test() { if (rseed > 0) { srand(rseed); /* initialize the random seed */ } /*--- initialization ---*/ int dim = m_trn_x->rowNum(); reset_weights(dim); /*--- iterate ... ---*/ AzTimeLog::print("--- Training begins ... ", log_out); AzsSvrgData_fast prev_fast; AzsSvrgData_compact prev_compact; int ite; for (ite = 0; ite < ite_num; ++ite) { if (do_show_timing) AzTimeLog::print("--- iteration#", ite+1, log_out); if (doing_svrg(ite) && (ite-sgd_ite) % svrg_interval == 0) { if (do_show_timing) AzTimeLog::print("Computing gradient average ... ", log_out); if (do_compact) get_avg_gradient_compact(&prev_compact); else get_avg_gradient_fast(&prev_fast); } if (do_show_timing) AzTimeLog::print("Updating weights ... ", log_out); AzIntArr ia_dxs; const int *dxs = gen_seq(dataSize(), ia_dxs); int ix; for (ix = 0; ix < dataSize(); ++ix) { int dx = dxs[ix]; /* data point index */ AzDvect v_deriv(class_num); get_deriv(dx, &v_deriv); /* compute the derivatives */ if (doing_svrg(ite)) { if (do_compact) updateDelta_svrg_compact(dx, &v_deriv, prev_compact); else updateDelta_svrg_fast(dx, &v_deriv, prev_fast); } else { updateDelta_sgd(dx, &v_deriv); } flushDelta(); } show_perf(ite); } if (do_show_timing) AzTimeLog::print("--- End of training ... ", log_out); /*--- write predictions to a file if requested ---*/ if (s_pred_fn.length() > 0) { AzTimeLog::print("Writing predictions to ", s_pred_fn.c_str(), log_out); write_pred(m_tst_x, s_pred_fn.c_str()); } }
int main(int argc, char **argv) { set_new_handler(memory_err); #ifndef DEBUG unsigned seed = std::chrono::system_clock::now().time_since_epoch().count(); #else unsigned seed = 0; #endif seed_generator(seed); if (::strcmp(argv[1], "lit") == 0) { // For Rules TransPar par; get_args(par, argc, argv); // get arguments gen_rules(par); // generate rules (really, just transactions) } else if (::strcmp(argv[1], "seq") == 0) { // For Sequences SeqPar par; get_args(par, argc, argv); // get arguments gen_seq(par); // generate sequences } else if (::strcmp(argv[1], "tax") == 0) { // For Rules with Taxonomies TaxPar par; get_args(par, argc, argv); // get arguments gen_taxrules(par); // generate rules (really, just transactions) } else if (::strcmp(argv[1], "-version") == 0) { cout << VERSION << endl; return 0; } else { cerr << "Synthetic Data Generation, "; cerr << VERSION << endl; cerr << "Usage: " << argv[0] << " lit|tax|seq [options]\n"; cerr << " " << argv[0] << " lit|tax|seq -help For more detailed list of options\n"; return 1; } return 0; }
int process(unsigned nframes, void *v) { (void) v; float seq_sqr[nframes]; float seq_noise[nframes]; float sqr[nframes]; float noise[nframes]; float lfo_f_out[nframes]; float filter_in[nframes]; float *output = (float*) jack_port_get_buffer(port, nframes); void *josc_buf = jack_port_get_buffer(josc, nframes); jack_midi_event_t in_event; jack_nframes_t event_count = jack_midi_get_event_count(josc_buf); // tag::buf-read[] if(event_count) { for(unsigned i=0; i<event_count; i++) { jack_midi_event_get(&in_event, josc_buf, i); assert(*in_event.buffer == '/'); RtDataImpl d; ports.dispatch((char*)in_event.buffer+1, d); } } while(uToB.hasNext()) { RtDataImpl d; d.matches = 0; ports.dispatch(uToB.read()+1, d); if(d.matches == 0) fprintf(stderr, "Unknown Port '%s'\n", uToB.peak()); } // end::buf-read gen_seq(seq_sqr, seq_noise, &seq, nframes); gen_noise(noise, seq_noise, nframes); gen_square(sqr, seq_sqr, &osc, nframes); gen_lfo(lfo_f_out, &lfo, nframes); do_sum(filter_in, noise, sqr, nframes); do_filter(output, filter_in, lfo_f_out, &filter, nframes); return 0; }
LLVMValueRef gen_expr(compile_t* c, ast_t* ast) { LLVMValueRef ret; bool has_scope = ast_has_scope(ast); bool has_source = codegen_hassource(c); if(has_scope) { codegen_pushscope(c); // Dwarf a new lexical scope, if necessary. if(has_source) dwarf_lexicalscope(&c->dwarf, ast); } switch(ast_id(ast)) { case TK_SEQ: ret = gen_seq(c, ast); break; case TK_FVARREF: case TK_FLETREF: ret = gen_fieldload(c, ast); break; case TK_PARAMREF: ret = gen_param(c, ast); break; case TK_VAR: case TK_LET: ret = gen_localdecl(c, ast); break; case TK_VARREF: case TK_LETREF: ret = gen_localload(c, ast); break; case TK_IF: ret = gen_if(c, ast); break; case TK_WHILE: ret = gen_while(c, ast); break; case TK_REPEAT: ret = gen_repeat(c, ast); break; case TK_TRY: case TK_TRY_NO_CHECK: ret = gen_try(c, ast); break; case TK_MATCH: ret = gen_match(c, ast); break; case TK_CALL: ret = gen_call(c, ast); break; case TK_CONSUME: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_RECOVER: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_BREAK: ret = gen_break(c, ast); break; case TK_CONTINUE: ret = gen_continue(c, ast); break; case TK_RETURN: ret = gen_return(c, ast); break; case TK_ERROR: ret = gen_error(c, ast); break; case TK_IS: ret = gen_is(c, ast); break; case TK_ISNT: ret = gen_isnt(c, ast); break; case TK_ASSIGN: ret = gen_assign(c, ast); break; case TK_THIS: ret = gen_this(c, ast); break; case TK_TRUE: ret = LLVMConstInt(c->i1, 1, false); break; case TK_FALSE: ret = LLVMConstInt(c->i1, 0, false); break; case TK_INT: ret = gen_int(c, ast); break; case TK_FLOAT: ret = gen_float(c, ast); break; case TK_STRING: ret = gen_string(c, ast); break; case TK_TUPLE: ret = gen_tuple(c, ast); break; case TK_FFICALL: ret = gen_ffi(c, ast); break; case TK_AMP: ret = gen_addressof(c, ast); break; case TK_IDENTITY: ret = gen_identity(c, ast); break; case TK_DONTCARE: ret = GEN_NOVALUE; break; case TK_COMPILER_INTRINSIC: ast_error(ast, "unimplemented compiler intrinsic"); LLVMBuildUnreachable(c->builder); ret = GEN_NOVALUE; break; default: ast_error(ast, "not implemented (codegen unknown)"); return NULL; } if(has_scope) { codegen_popscope(c); if(has_source) dwarf_finish(&c->dwarf); } return ret; }
LLVMValueRef gen_expr(compile_t* c, ast_t* ast) { LLVMValueRef ret; bool has_scope = ast_has_scope(ast); if(has_scope) codegen_pushscope(c, ast); switch(ast_id(ast)) { case TK_SEQ: ret = gen_seq(c, ast); break; case TK_FVARREF: case TK_FLETREF: ret = gen_fieldload(c, ast); break; case TK_EMBEDREF: ret = gen_fieldptr(c, ast); break; case TK_PARAMREF: ret = gen_param(c, ast); break; case TK_VAR: case TK_LET: case TK_MATCH_CAPTURE: ret = gen_localdecl(c, ast); break; case TK_VARREF: case TK_LETREF: ret = gen_localload(c, ast); break; case TK_IF: ret = gen_if(c, ast); break; case TK_WHILE: ret = gen_while(c, ast); break; case TK_REPEAT: ret = gen_repeat(c, ast); break; case TK_TRY: case TK_TRY_NO_CHECK: ret = gen_try(c, ast); break; case TK_MATCH: ret = gen_match(c, ast); break; case TK_CALL: ret = gen_call(c, ast); break; case TK_CONSUME: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_RECOVER: ret = gen_expr(c, ast_childidx(ast, 1)); break; case TK_BREAK: ret = gen_break(c, ast); break; case TK_CONTINUE: ret = gen_continue(c, ast); break; case TK_RETURN: ret = gen_return(c, ast); break; case TK_ERROR: ret = gen_error(c, ast); break; case TK_IS: ret = gen_is(c, ast); break; case TK_ISNT: ret = gen_isnt(c, ast); break; case TK_ASSIGN: ret = gen_assign(c, ast); break; case TK_THIS: ret = gen_this(c, ast); break; case TK_TRUE: ret = LLVMConstInt(c->i1, 1, false); break; case TK_FALSE: ret = LLVMConstInt(c->i1, 0, false); break; case TK_INT: ret = gen_int(c, ast); break; case TK_FLOAT: ret = gen_float(c, ast); break; case TK_STRING: ret = gen_string(c, ast); break; case TK_TUPLE: ret = gen_tuple(c, ast); break; case TK_FFICALL: ret = gen_ffi(c, ast); break; case TK_ADDRESS: ret = gen_addressof(c, ast); break; case TK_DIGESTOF: ret = gen_digestof(c, ast); break; case TK_DONTCARE: ret = GEN_NOVALUE; break; case TK_COMPILE_INTRINSIC: ast_error(c->opt->check.errors, ast, "unimplemented compile intrinsic"); return NULL; case TK_COMPILE_ERROR: { ast_t* reason_seq = ast_child(ast); ast_t* reason = ast_child(reason_seq); ast_error(c->opt->check.errors, ast, "compile error: %s", ast_name(reason)); return NULL; } default: ast_error(c->opt->check.errors, ast, "not implemented (codegen unknown)"); return NULL; } if(has_scope) codegen_popscope(c); return ret; }