def test_space_train_dense(self):
     
     test_cases = [([("a","b","a_b")], self.space4, self.space5),
                   ([("a","b","a_b")], self.space4, self.space6),
                   ([("a","b","a_b"),("a","b","a_a")], self.space4, self.space7),
                   ]
         
     learners = [RidgeRegressionLearner(intercept=False, crossvalidation=False, param=0),
                 LstsqRegressionLearner(intercept=False),
                 LstsqRegressionLearner(intercept=True)]
                 
     for in_data, arg_space, phrase_space in test_cases:            
         for learner_ in learners:
             comp_model = FullAdditive(learner=learner_)
             
             comp_model.train(in_data, arg_space, phrase_space)
             comp_space = comp_model.compose(in_data, arg_space)
             
             np.testing.assert_array_almost_equal(comp_space.cooccurrence_matrix.mat,
                                                  phrase_space.cooccurrence_matrix.mat, 10)
                   
             self.assertListEqual(comp_space.id2column, phrase_space.id2column)
             self.assertDictEqual(comp_space.column2id, phrase_space.column2id)
             
             self.assertListEqual(comp_space.id2row, phrase_space.id2row)
             self.assertDictEqual(comp_space.row2id, phrase_space.row2id)
             
             self.assertEqual(comp_model._has_intercept, learner_._intercept)
 def test_full_additive(self):
     
     self.m12 = DenseMatrix(np.mat([[3,1],[9,2]]))
     self.m22 = DenseMatrix(np.mat([[4,3],[2,1]]))
     self.ph2 = DenseMatrix(np.mat([[18,11],[24,7]]))
     self.row = ["a", "b"]
     self.ft = ["f1","f2"]
     self.space1 = Space(DenseMatrix(self.m12), self.row, self.ft)
     self.space2 = Space(DenseMatrix(self.ph2), ["a_a","a_b"], self.ft)
     m = FullAdditive()
     self.assertRaises(IllegalStateError, m.export,self.prefix + ".full1")
     m.train([("a","b","a_b"),("a","a","a_a")], self.space1, self.space2)
 
     m.export(self.prefix + ".full2")
Beispiel #3
0
    def test_full_additive(self):

        self.m12 = DenseMatrix(np.mat([[3, 1], [9, 2]]))
        self.m22 = DenseMatrix(np.mat([[4, 3], [2, 1]]))
        self.ph2 = DenseMatrix(np.mat([[18, 11], [24, 7]]))
        self.row = ["a", "b"]
        self.ft = ["f1", "f2"]
        self.space1 = Space(DenseMatrix(self.m12), self.row, self.ft)
        self.space2 = Space(DenseMatrix(self.ph2), ["a_a", "a_b"], self.ft)
        m = FullAdditive()
        self.assertRaises(IllegalStateError, m.export, self.prefix + ".full1")
        m.train([("a", "b", "a_b"), ("a", "a", "a_a")], self.space1,
                self.space2)

        m.export(self.prefix + ".full2")
Beispiel #4
0
    def test_space_train_dense(self):

        test_cases = [
            ([("a", "b", "a_b")], self.space4, self.space5),
            ([("a", "b", "a_b")], self.space4, self.space6),
            ([("a", "b", "a_b"), ("a", "b", "a_a")], self.space4, self.space7),
        ]

        learners = [
            RidgeRegressionLearner(intercept=False,
                                   crossvalidation=False,
                                   param=0),
            LstsqRegressionLearner(intercept=False),
            LstsqRegressionLearner(intercept=True)
        ]

        for in_data, arg_space, phrase_space in test_cases:
            for learner_ in learners:
                comp_model = FullAdditive(learner=learner_)

                comp_model.train(in_data, arg_space, phrase_space)
                comp_space = comp_model.compose(in_data, arg_space)

                np.testing.assert_array_almost_equal(
                    comp_space.cooccurrence_matrix.mat,
                    phrase_space.cooccurrence_matrix.mat, 10)

                self.assertListEqual(comp_space.id2column,
                                     phrase_space.id2column)
                self.assertDictEqual(comp_space.column2id,
                                     phrase_space.column2id)

                self.assertListEqual(comp_space.id2row, phrase_space.id2row)
                self.assertDictEqual(comp_space.row2id, phrase_space.row2id)

                self.assertEqual(comp_model._has_intercept,
                                 learner_._intercept)
Beispiel #5
0
from composes.composition.full_additive import FullAdditive

#training data
train_data = [("good", "car", "good_car"),
              ("good", "book", "good_book")
              ]

#load an argument space
arg_space = io_utils.load("./data/out/ex10.pkl")

#load a phrase space
phrase_space = io_utils.load("data/out/PHRASE_SS.ex10.pkl")
print("Training phrase space")
print(phrase_space.id2row)
print(phrase_space.cooccurrence_matrix)

#train a FullAdditive model on the data
my_comp = FullAdditive()
my_comp.train(train_data, arg_space, phrase_space)

#print its parameters
print("\nA:", my_comp._mat_a_t.transpose())
print("B:", my_comp._mat_b_t.transpose())

#use the model to compose the train data
composed_space  = my_comp.compose([("good", "bike", "good_bike")],
                                  arg_space)
print("\nComposed space:")
print(composed_space.id2row)
print(composed_space.cooccurrence_matrix)
Beispiel #6
0
from composes.composition.full_additive import FullAdditive

#training data
train_data = [("good", "car", "good_car"),
              ("good", "book", "good_book")
              ]

#load an argument space
arg_space = io_utils.load("./data/out/ex10.pkl")

#load a phrase space
phrase_space = io_utils.load("data/out/PHRASE_SS.ex10.pkl")
print "Training phrase space"
print phrase_space.id2row
print phrase_space.cooccurrence_matrix

#train a FullAdditive model on the data
my_comp = FullAdditive()
my_comp.train(train_data, arg_space, phrase_space)

#print its parameters
print "\nA:", my_comp._mat_a_t.transpose()
print "B:", my_comp._mat_b_t.transpose()

#use the model to compose the train data
composed_space  = my_comp.compose([("good", "bike", "good_bike")], 
                                  arg_space)
print "\nComposed space:" 
print composed_space.id2row
print composed_space.cooccurrence_matrix