def make_gp(self, ripl):
        ripl.assume('make_linear', VentureFunction(makeLinear, [t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_periodic', VentureFunction(makePeriodic, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_se',VentureFunction(makeSquaredExponential,[t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_noise', VentureFunction(makeNoise, [t.NumberType()], t.AnyType("VentureFunction")))

        ripl.assume('a','(mem (lambda (i) (tag (quote parameter) i (uniform_continuous 0.1 8))))')
        ripl.assume('sn','(tag (quote parameter) 10 (uniform_continuous 0.01 3))')
        ripl.assume('sf','(mem (lambda (i) (tag (quote parameter) i (uniform_continuous 0.1 8 ))))')
        ripl.assume('sf2','(mem (lambda (i) (tag (quote parameter) i(uniform_continuous 0.1 8 ))))')
        ripl.assume('p','(mem (lambda (i) (tag (quote parameter) i (uniform_continuous 0.1 8))))')
        ripl.assume('l','(mem (lambda (i) (tag (quote parameter) i (uniform_continuous 0.1 8))))')
        ripl.assume('l2','(mem (lambda (i) (tag (quote parameter) i (uniform_continuous 0.1 8))))')
        
        ripl.assume('lin1', "(apply_function make_linear ( a 0)  )")
        ripl.assume('lin2', "(apply_function make_linear ( a 1)  )")
        ripl.assume('lin3', "(apply_function make_linear ( a 2)  )")
        ripl.assume('per1', "(apply_function make_periodic ( l 3) ( p 4) ( sf 5) )")
        ripl.assume('se1', "(apply_function make_se ( sf2 6) ( l2 7))")
        ripl.assume('se2', "(apply_function make_se ( sf2 8) ( l2 9))")


        ripl.assume('wn', "(apply_function make_noise sn)")

         #### GP Structure Prior

        ###### for simplicity, I start with the max amount of kernel per type given

        ripl.assume("max_lin","(array  lin1 lin2 lin3 )")
        ripl.assume("max_per","(array  per1 )")
        ripl.assume("max_se","(array  se1 se2)")
        ripl.assume("max_wn","(array wn)")

        ripl.bind_foreign_sp("gp_grammar", typed_nr(Grammar(), [t.HomogeneousArrayType(t.HomogeneousArrayType(t.AnyType())),t.AnyType()], covfunctionType, min_req_args=0))

        ripl.assume("cov_structure","(tag (quote grammar) 0 (gp_grammar (array max_lin max_wn max_per max_se) 2 ))")
        #ripl.bind_foreign_sp("covfunc_interpreter",typed_nr(GrammarInterpreter(), [t.AnyType()], t.AnyType()))
        #ripl.assume("interp","(covfunc_interpreter grammar)")

        ripl.assume('gp','(tag (quote model) 0 (make_gp_part_der zero cov_structure))')
Ejemplo n.º 2
0
def run_cgm_experiment(patient_number):
    mat_contents =scio.loadmat("../data/glucose"+patient_number)
    X = mat_contents['Glucose']

    X = X[np.nonzero(X)]


    ripl = shortcuts.make_lite_church_prime_ripl()

    ripl.bind_foreign_sp("make_gp_part_der",gp_der.makeGPSP)
    ripl.bind_foreign_sp("covfunc_interpreter",typed_nr(GrammarInterpreter(), [t.AnyType()], t.AnyType()))
    ripl.bind_foreign_sp("subset",typed_nr(Subset(), [t.ListType(),t.SimplexType()], t.ListType()))

    ripl.assume('make_const_func', VentureFunction(makeConstFunc, [t.NumberType()], constantType))
    ripl.assume('zero', "(apply_function make_const_func 0)")
    ripl.assume("func_times", makeLiftedMult(lambda x1, x2: np.multiply(x1,x2)))
    ripl.assume("func_plus", makeLiftedAdd(lambda x1, x2: x1 + x2))

    ripl.assume('make_linear', VentureFunction(makeLinear, [t.NumberType()], t.AnyType("VentureFunction")))
    ripl.assume('make_periodic', VentureFunction(makePeriodic, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
    ripl.assume('make_se',VentureFunction(makeSquaredExponential,[t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
    ripl.assume('make_rq',VentureFunction(makeRQ, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))


    ripl.assume('a','(tag (quote parameter) 0 (log  (uniform_continuous  0 5)))')
    ripl.assume('sf1','(tag (quote parameter) 1 (log (uniform_continuous  0 5 )))')
    ripl.assume('p',' (tag (quote parameter) 2 (log (uniform_continuous  0.01 5)))')
    ripl.assume('l',' (tag (quote parameter) 3 (log (uniform_continuous  0 5)))')

    ripl.assume('l1',' (tag (quote parameter) 4 (log (uniform_continuous  0 5)))')
    ripl.assume('sf_rq','(tag (quote parameter) 5 (log (uniform_continuous 0 5)))')
    ripl.assume('l_rq','(tag (quote parameter) 6 (log (uniform_continuous 0 5)))')
    ripl.assume('alpha','(tag (quote parameter)7 (log (uniform_continuous 0 5)))')
    ripl.assume('sf',' (tag (quote parameter) 8 (log (uniform_continuous  0 5)))')

    ripl.assume('lin1', "(apply_function make_linear a   )")
    ripl.assume('per1', "(apply_function make_periodic l  p  sf ) ")
    ripl.assume('se1', "(apply_function make_se sf1 l1)")
    ripl.assume('rq', "(apply_function make_rq l_rq sf_rq alpha)")


    ripl.assume('interp','covfunc_interpreter')

    # Grammar
    ripl.assume('cov_compo',"""
     (lambda (l )
        (if (lte ( size l) 1)
             (first l)
                 (if (flip)
                     (apply_function func_plus (first l) (cov_compo (rest l)))
                     (apply_function func_times (first l) (cov_compo (rest l)))
            )
    ))
    """)
    number = 4
    total_perms =0
    perms = []
    for i in range(number):
        perms.append((len(list(itertools.permutations([j for j in range(i+1)])))))
        total_perms+=perms[i]
    simplex = "( simplex  "
    for i in range(number):
        simplex+=str(float(perms[i])/total_perms) + " "

    simplex+=" )"
    #print(' (tag (quote grammar) 0 (subset (list lin1 per1 se1 se2 rq) '+simplex + ' ))')
    ripl.assume('s',' (tag (quote hyper) 0 (subset (list lin1 per1 se1 rq) '+simplex + ' ))')
    ripl.assume('cov','(tag (quote hyper) 1 (cov_compo s))')

    ripl.assume('gp',"""(tag (quote model) 0
                        (make_gp_part_der zero cov))""")


    makeObservations([i for i in range(X.shape[0])],X,ripl)
    ripl.infer("(repeat "+steps+" (do (mh (quote hyper) one 1) (mh (quote parameter) one 5)))")
    # prediction

    fig = plt.figure(figsize=(figlength,figheigth), dpi=200)
    for i in range(number_curves):
        xpost= np.random.uniform(0,X.shape[0]+5,200)
        sampleString=genSamples(xpost,ripl)
        ypost = ripl.sample(sampleString)
        yp = [y_temp for (x_temp,y_temp) in sorted(zip(xpost,ypost))]
        pl.plot(sorted(xpost),yp,c="red",alpha=alpha_value,linewidth=2)

    #pl.locator_params(nbins=4)
    #plt.axis((-2,2,-1,3))
    #pl.plot(X,color='blue')
    pl.scatter(range(X.shape[0]),X,color='black',marker='x',s=50,edgecolor='blue',linewidth='1.5')
    non_zero_index = np.nonzero(X)
    X = X[non_zero_index]
    time_stamps = get_time_stamps(patient)
    time_stamps=[time_stamps[i] for i in non_zero_index[0]]
    pl.xlabel('Time',fontsize=font_size)
    pl.ylabel('mg/dL',fontsize=font_size)
    pl.xticks(fontsize=font_size)
    pl.yticks(fontsize=font_size)
    ax = pl.gca()
    ax.set_xlim([0, X.shape[0]+5])
    ax.set_ylim([np.min(X)-10,np.max(X)+10])
    ticks = ax.get_xticks()
    time_stamps[0]=''
    ax.set_xticklabels([time_stamps[int(i)] for i in ticks[:-1]])

    fig.savefig(path+'posterior_samples_patient_'+patient_number+'_'+str(number_predictive_samples)+'_'+str(number_curves)+'a_'+str(alpha_value)+'_'+exp_run+'.png', dpi=fig.dpi,bbox_inches='tight')
Ejemplo n.º 3
0
def makeObservations(x,y,gp_str='(gp '):
    xString = genSamples(x,gp_str)
    ripl.observe(xString, array(y))

def genSamples(x,gp_str='(gp '):
    sampleString=gp_str+' (array '
    for i in range(len(x)):
        sampleString+= str(x[i]) + ' '
    sampleString+='))'
    #print(sampleString)
    return sampleString
    
ripl = shortcuts.make_lite_church_prime_ripl()

ripl.bind_foreign_sp("make_gp_part_der",gp_der.makeGPSP)
ripl.bind_foreign_sp("covfunc_interpreter",typed_nr(GrammarInterpreter(), [t.AnyType()], t.AnyType())) 
ripl.bind_foreign_sp("subset",typed_nr(Subset(), [t.ListType(),t.SimplexType()], t.ListType()))

ripl.assume('make_const_func', VentureFunction(makeConstFunc, [t.NumberType()], constantType))
ripl.assume('zero', "(apply_function make_const_func 0)")
ripl.assume("func_times", makeLiftedMult(lambda x1, x2: np.multiply(x1,x2)))
ripl.assume("func_plus", makeLiftedAdd(lambda x1, x2: x1 + x2))

ripl.assume('make_linear', VentureFunction(makeLinear, [t.NumberType()], t.AnyType("VentureFunction")))
ripl.assume('make_periodic', VentureFunction(makePeriodic, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
ripl.assume('make_se',VentureFunction(makeSquaredExponential,[t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
ripl.assume('make_rq',VentureFunction(makeRQ, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))

    
ripl.assume('a','(tag (quote parameter) 0 (log  (uniform_continuous  0 5)))')
ripl.assume('sf1','(tag (quote parameter) 1 (log (uniform_continuous  0 5 )))')
Ejemplo n.º 4
0
def run_cgm_experiment(patient_number,exp_index):
    if not glob.glob('/home/ulli/Dropbox/cgm/patient_structure_'+patient_number+'/*_'+str(exp_index)):
        mat_contents =scio.loadmat("../data/glucose"+patient_number)
        X = mat_contents['Glucose']



        X = X[np.nonzero(X)]
        if not os.path.exists('/home/ulli/Dropbox/cgm/patient_structure_'+patient_number+'/'):
            os.makedirs('/home/ulli/Dropbox/cgm/patient_structure_'+patient_number+'/')
        ripl = shortcuts.make_lite_church_prime_ripl()

        ripl.bind_foreign_sp("make_gp_part_der",gp_der.makeGPSP)
        ripl.bind_foreign_sp("covfunc_interpreter",typed_nr(GrammarInterpreter(), [t.AnyType()], t.AnyType()))
        ripl.bind_foreign_sp("subset",typed_nr(Subset(), [t.ListType(),t.SimplexType()], t.ListType()))

        ripl.assume('make_const_func', VentureFunction(makeConstFunc, [t.NumberType()], constantType))
        ripl.assume('zero', "(apply_function make_const_func 0)")
        ripl.assume("func_times", makeLiftedMult(lambda x1, x2: np.multiply(x1,x2)))
        ripl.assume("func_plus", makeLiftedAdd(lambda x1, x2: x1 + x2))

        ripl.assume('make_linear', VentureFunction(makeLinear, [t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_periodic', VentureFunction(makePeriodic, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_se',VentureFunction(makeSquaredExponential,[t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))
        ripl.assume('make_rq',VentureFunction(makeRQ, [t.NumberType(), t.NumberType(), t.NumberType()], t.AnyType("VentureFunction")))


        ripl.assume('a','(tag (quote parameter) 0 (log  (uniform_continuous  0 5)))')
        ripl.assume('sf1','(tag (quote parameter) 1 (log (uniform_continuous  0 5 )))')
        ripl.assume('p',' (tag (quote parameter) 2 (log (uniform_continuous  0.01 5)))')
        ripl.assume('l',' (tag (quote parameter) 3 (log (uniform_continuous  0 5)))')

        ripl.assume('l1',' (tag (quote parameter) 4 (log (uniform_continuous  0 5)))')
        ripl.assume('sf_rq','(tag (quote parameter) 5 (log (uniform_continuous 0 5)))')
        ripl.assume('l_rq','(tag (quote parameter) 6 (log (uniform_continuous 0 5)))')
        ripl.assume('alpha','(tag (quote parameter)7 (log (uniform_continuous 0 5)))')
        ripl.assume('sf',' (tag (quote parameter) 8 (log (uniform_continuous  0 5)))')

        ripl.assume('lin1', "(apply_function make_linear a   )")
        ripl.assume('per1', "(apply_function make_periodic l  p  sf ) ")
        ripl.assume('se1', "(apply_function make_se sf1 l1)")
        ripl.assume('rq', "(apply_function make_rq l_rq sf_rq alpha)")


        ripl.assume('interp','covfunc_interpreter')

        # Grammar
        ripl.assume('cov_compo',"""
         (lambda (l )
            (if (lte ( size l) 1)
                 (first l)
                     (if (flip)
                         (apply_function func_plus (first l) (cov_compo (rest l)))
                         (apply_function func_times (first l) (cov_compo (rest l)))
                )
        ))
        """)
        number = 4
        total_perms =0
        perms = []
        for i in range(number):
            perms.append((len(list(itertools.permutations([j for j in range(i+1)])))))
            total_perms+=perms[i]
        simplex = "( simplex  "
        for i in range(number):
            simplex+=str(float(perms[i])/total_perms) + " "

        simplex+=" )"
        #print(' (tag (quote grammar) 0 (subset (list lin1 per1 se1 se2 rq) '+simplex + ' ))')
        ripl.assume('s',' (tag (quote hyper) 0 (subset (list lin1 per1 se1 rq) '+simplex + ' ))')
        ripl.assume('cov','(tag (quote hyper) 1 (cov_compo s))')

        ripl.assume('gp',"""(tag (quote model) 0
                            (make_gp_part_der zero cov))""")


        makeObservations([i for i in range(X.shape[0])],X,ripl)
        ripl.infer("(repeat "+steps+" (do (mh (quote hyper) one 1) (mh (quote parameter) one 5)))")

        touch('/home/ulli/Dropbox/cgm/patient_structure_'+patient_number+'/',ripl.sample('(interp cov )')+'_'+str(exp_index))