Example #1
0
def test_io_score_t1t2():

    rng = irm.RNG()

    for D1_N, D2_N in [(10, 20), (20, 30), (200, 300)]:
        for model_name in ["BetaBernoulliNonConj", 
                           "LogisticDistance", 
                           "LinearDistance"]: 

            d = {'domains' : {'d1' : {'N' : D1_N}, 
                              'd2' : {'N' : D2_N}},
                    'relations' : {'R1' : {'relation' : ('d1', 'd2'), 
                                           'model' : model_name}}}

            l = {}

            new_latent, new_data = data.synth.prior_generate(l, d)

            irm_model = irmio.create_model_from_data(new_data, rng=rng)
            irmio.set_model_latent(irm_model, new_latent, rng=rng)

            s1 = irm_model.total_score()

            extracted_latent = irmio.get_latent(irm_model)

            irm_model2 = irmio.create_model_from_data(new_data, rng=rng)
            irmio.set_model_latent(irm_model, extracted_latent, rng=rng)

            s2 = irm_model.total_score()
            np.testing.assert_approx_equal(s1, s2, 5)
Example #2
0
def test_simple_nonconj():
    rng = irm.RNG()
    irm_model = irmio.create_model_from_data(data_simple_nonconj, rng=rng)
    
    irmio.set_model_latent(irm_model, latent_simple_nonconj, rng=rng)
    
    a = irm_model.domains['d1'].get_assignments()
    axes = irm_model.relations['R1'].get_axes()
    axes_objs = [(irm_model.domains[dn], irm_model.domains[dn].get_relation_pos('R1')) 
                 for dn in axes]

    comps = model.get_components_in_relation(axes_objs,
                                             irm_model.relations['R1'])

    g0 = a[0]
    g1 = a[2]
    g2 = a[4]

    assert_approx_equal(comps[g0, g0]['p'], 0.0)
    assert_approx_equal(comps[g0, g1]['p'], 0.01)
    assert_approx_equal(comps[g0, g2]['p'], 0.02)

    assert_approx_equal(comps[g1, g0]['p'], 0.1)
    assert_approx_equal(comps[g1, g1]['p'], 0.11)
    assert_approx_equal(comps[g1, g2]['p'], 0.12)


    assert_approx_equal(comps[g2, g0]['p'], 0.2)
    assert_approx_equal(comps[g2, g1]['p'], 0.21)
    assert_approx_equal(comps[g2, g2]['p'], 0.22)
Example #3
0
def test_io_score_t1t2():

    rng = irm.RNG()

    for D1_N, D2_N in [(10, 20), (20, 30), (200, 300)]:
        for model_name in ["BetaBernoulliNonConj", "LogisticDistance", "LinearDistance"]:

            d = {
                "domains": {"d1": {"N": D1_N}, "d2": {"N": D2_N}},
                "relations": {"R1": {"relation": ("d1", "d2"), "model": model_name}},
            }

            l = {}

            new_latent, new_data = data.synth.prior_generate(l, d)

            irm_model = irmio.create_model_from_data(new_data, rng=rng)
            irmio.set_model_latent(irm_model, new_latent, rng=rng)

            s1 = irm_model.total_score()

            extracted_latent = irmio.get_latent(irm_model)

            irm_model2 = irmio.create_model_from_data(new_data, rng=rng)
            irmio.set_model_latent(irm_model, extracted_latent, rng=rng)

            s2 = irm_model.total_score()
            np.testing.assert_approx_equal(s1, s2, 5)
Example #4
0
def test_simple_nonconj():
    rng = irm.RNG()
    irm_model = irmio.create_model_from_data(data_simple_nonconj, rng=rng)

    irmio.set_model_latent(irm_model, latent_simple_nonconj, rng=rng)

    a = irm_model.domains["d1"].get_assignments()
    axes = irm_model.relations["R1"].get_axes()
    axes_objs = [(irm_model.domains[dn], irm_model.domains[dn].get_relation_pos("R1")) for dn in axes]

    comps = model.get_components_in_relation(axes_objs, irm_model.relations["R1"])

    g0 = a[0]
    g1 = a[2]
    g2 = a[4]

    assert_approx_equal(comps[g0, g0]["p"], 0.0)
    assert_approx_equal(comps[g0, g1]["p"], 0.01)
    assert_approx_equal(comps[g0, g2]["p"], 0.02)

    assert_approx_equal(comps[g1, g0]["p"], 0.1)
    assert_approx_equal(comps[g1, g1]["p"], 0.11)
    assert_approx_equal(comps[g1, g2]["p"], 0.12)

    assert_approx_equal(comps[g2, g0]["p"], 0.2)
    assert_approx_equal(comps[g2, g1]["p"], 0.21)
    assert_approx_equal(comps[g2, g2]["p"], 0.22)
Example #5
0
def test_simple_nonconj_inout():
    rng = irm.RNG()
    irm_model = irmio.create_model_from_data(data_simple_nonconj, rng=rng)
    
    irmio.set_model_latent(irm_model, latent_simple_nonconj, rng=rng)

    latent = irmio.get_latent(irm_model)
    irmio.latent_equality(latent_simple_nonconj, latent, data_simple_nonconj)
Example #6
0
def test_simple_nonconj_inout():
    rng = irm.RNG()
    irm_model = irmio.create_model_from_data(data_simple_nonconj, rng=rng)

    irmio.set_model_latent(irm_model, latent_simple_nonconj, rng=rng)

    latent = irmio.get_latent(irm_model)
    irmio.latent_equality(latent_simple_nonconj, latent, data_simple_nonconj)
Example #7
0
        data_filename = a[1][1]
        outfilename = latent_filename[:-(len("latent"))] + 'scores'
        if 'conj' in latent_filename:
            yield (latent_filename, data_filename), outfilename

@follows(t1_t2_datasets)
@follows(t1_t1_datasets)
@files(score_params)
def score((latent_filename, data_filename), outfilename):
    latent = pickle.load(open(latent_filename, 'r'))
    data = pickle.load(open(data_filename, 'r'))
    
    rng = irm.RNG()
        
    irm_model = irmio.create_model_from_data(data, rng=rng)
    irmio.set_model_latent(irm_model, latent, rng)

    # now we go through and score every possible latent
    domain_names = sorted(data['domains'].keys())
    domain_sizes = [data['domains'][dn]['N'] for dn in domain_names]
    
    # create the dict
    candidate_partitions = list(putil.enumerate_possible_latents(domain_sizes))
    CANDIDATE_N = len(candidate_partitions)
    scores = {}
    for cpi, cp in enumerate(candidate_partitions):
        t1 = time.time()
        for di, av in enumerate(cp):
            domain_name = domain_names[di]
            latent['domains'][domain_name]['assignment'] = av
        irmio.set_model_latent(irm_model, latent, rng)
Example #8
0
        outfilename = latent_filename[:-(len("latent"))] + 'scores'
        if 'conj' in latent_filename:
            yield (latent_filename, data_filename), outfilename


@follows(t1_t2_datasets)
@follows(t1_t1_datasets)
@files(score_params)
def score((latent_filename, data_filename), outfilename):
    latent = pickle.load(open(latent_filename, 'r'))
    data = pickle.load(open(data_filename, 'r'))

    rng = irm.RNG()

    irm_model = irmio.create_model_from_data(data, rng=rng)
    irmio.set_model_latent(irm_model, latent, rng)

    # now we go through and score every possible latent
    domain_names = sorted(data['domains'].keys())
    domain_sizes = [data['domains'][dn]['N'] for dn in domain_names]

    # create the dict
    candidate_partitions = list(putil.enumerate_possible_latents(domain_sizes))
    CANDIDATE_N = len(candidate_partitions)
    scores = {}
    for cpi, cp in enumerate(candidate_partitions):
        t1 = time.time()
        for di, av in enumerate(cp):
            domain_name = domain_names[di]
            latent['domains'][domain_name]['assignment'] = av
        irmio.set_model_latent(irm_model, latent, rng)