def test_EncodedDataset_constructor(self): dataset = ch.datasets.TupleDataset([ Entry("entry1", [Example(([10, 20, 30], ), 10)], dict([["HEAD", True], ["SORT", False]])), Entry("entry2", [Example(([30, 20, 10], ), [10, 20, 30])], dict([["HEAD", False], ["SORT", True]])) ]) cdataset = EncodedDataset( Dataset(dataset, DatasetMetadata(1, set(["HEAD", "SORT"]), 256, 5))) [(types0, values0, attribute0), (types1, values1, attribute1)] = list(cdataset) self.assertTrue(np.all([[[0, 1], [1, 0]]] == types0)) self.assertTrue( np.all([[[266, 276, 286, 512, 512], [266, 512, 512, 512, 512]]] == values0)) self.assertTrue(np.all(np.array([1, 0]) == attribute0)) self.assertTrue(np.all([[[0, 1], [0, 1]]] == types1)) self.assertTrue( np.all([[[286, 276, 266, 512, 512], [266, 276, 286, 512, 512]]] == values1)) self.assertTrue(np.all(np.array([0, 1]) == attribute1))
def test_search(self): # example of access examples = [ Example([2, [10, 20, 30]], 30), Example([1, [-10, 30, 40]], 30) ] def pred(examples): LINQ, _ = generate_io_samples.get_language(50) LINQ = [f for f in LINQ if not "IDT" in f.src] prob = dict() for function in LINQ: for name in function.src.split(" "): if name == "ACCESS": prob[name] = 0.8 else: prob[name] = 0.2 return prob result = search( os.path.join(os.getcwd(), "DeepCoder_Utils", "enumerative-search", "search"), 1000, 256, examples, 2, pred) self.assertTrue(result.is_solved) self.assertAlmostEqual(0.8, result.probabilities["ACCESS"]) self.assertAlmostEqual(0.2, result.probabilities["HEAD"]) self.assertEqual(1, result.explored_nodes) self.assertEqual(" %2 <- access %0 %1\n", result.solution)
def to_batch_seq(sql_data, table_data, idxes, st, ed, is_train=True): """ :return: """ examples = [] for i in range(st, ed): sql = sql_data[idxes[i]] table = table_data[sql['db_id']] process_dict = process(sql, table) for c_id, col_ in enumerate(process_dict['col_set_iter']): for q_id, ori in enumerate(process_dict['q_iter_small']): if ori in col_: process_dict['col_set_type'][c_id][0] += 1 schema_linking(process_dict['question_arg'], process_dict['question_arg_type'], process_dict['one_hot_type'], process_dict['col_set_type'], process_dict['col_set_iter'], sql) col_table_dict = get_col_table_dict(process_dict['tab_cols'], process_dict['tab_ids'], sql) table_col_name = get_table_colNames(process_dict['tab_ids'], process_dict['col_iter']) process_dict['col_set_iter'][0] = ['count', 'number', 'many'] rule_label = None if 'rule_label' in sql: rule_label = [eval(x) for x in sql['rule_label'].strip().split(' ')] if is_valid(rule_label, col_table_dict=col_table_dict, sql=sql) is False: continue example = Example( src_sent=process_dict['question_arg'], col_num=len(process_dict['col_set_iter']), vis_seq=(sql['question'], process_dict['col_set_iter'], sql['query']), tab_cols=process_dict['col_set_iter'], sql=sql['query'], one_hot_type=process_dict['one_hot_type'], col_hot_type=process_dict['col_set_type'], table_names=process_dict['table_names'], table_len=len(process_dict['table_names']), col_table_dict=col_table_dict, cols=process_dict['tab_cols'], table_col_name=table_col_name, table_col_len=len(table_col_name), tokenized_src_sent=process_dict['col_set_type'], tgt_actions=rule_label ) example.sql_json = copy.deepcopy(sql) examples.append(example) if is_train: examples.sort(key=lambda e: -len(e.src_sent)) return examples else: return examples
def test_example_embed_embed_minibatch_with_different_number_of_inputs( self): embed = ExampleEmbed(2, 2, 1, (np.arange(5) + 1).reshape((5, 1))) """ EmbedId 0 (-2) -> 1 1 (-1) -> 2 2 ( 0) -> 3 3 ( 1) -> 4 4 (NULL) -> 5 """ metadata = DatasetMetadata(2, set([]), 2, 2) e0 = examples_encoding( [Example([[0, 1]], 0), Example([[1]], 1)], metadata) e1 = examples_encoding( [Example([1, [0, 1]], [0]), Example([0, [0, 1]], [])], metadata) state_embeddings = embed.forward(np.array([e0.types, e1.types]), np.array([e0.values, e1.values])) self.assertEqual((2, 2, 3, 2 + 2 * 1), state_embeddings.shape) self.assertTrue( np.allclose([0, 1, 3, 4], state_embeddings.array[0, 0, 0])) # Input of e00 self.assertTrue( np.allclose([0, 0, 5, 5], state_embeddings.array[0, 0, 1])) # Input of e00 # Output of e00 self.assertTrue( np.allclose([1, 0, 3, 5], state_embeddings.array[0, 0, 2])) self.assertTrue( np.allclose([0, 1, 4, 5], state_embeddings.array[0, 1, 0])) # Input of e01 self.assertTrue( np.allclose([0, 0, 5, 5], state_embeddings.array[0, 1, 1])) # Input of e01 # Output of e01 self.assertTrue( np.allclose([1, 0, 4, 5], state_embeddings.array[0, 1, 2])) self.assertTrue( np.allclose([1, 0, 4, 5], state_embeddings.array[1, 0, 0])) # Input of e10 self.assertTrue( np.allclose([0, 1, 3, 4], state_embeddings.array[1, 0, 1])) # Input of e10 # Output of e10 self.assertTrue( np.allclose([0, 1, 3, 5], state_embeddings.array[1, 0, 2])) self.assertTrue( np.allclose([1, 0, 3, 5], state_embeddings.array[1, 1, 0])) # Input of e11 self.assertTrue( np.allclose([0, 1, 3, 4], state_embeddings.array[1, 1, 1])) # Input of e11 # Output of e11 self.assertTrue( np.allclose([0, 1, 5, 5], state_embeddings.array[1, 1, 2]))
def to_batch_seq(sql_data, schema_data,idxes, st, ed, is_train=True): """ :return: """ examples = [] for i in range(st, ed): sql = sql_data[idxes[i]] schema_id = sql['db_id'] tab_cols = [] tab_ids = [] for i in schema_data[schema_id]["column_names"]: tab_cols.append(i[1]) tab_ids.append(i[0]) col_set = [''.join(col) for col in sql['column_names']][:-1] col_table_dict = get_col_table_dict(tab_cols, tab_ids, col_set) rule_label = None if 'label_str' in sql: try: rule_label = [eval(x) for x in sql['label_str'].strip().split(' ')] except: continue ''' TODO: 以后再去这部分改 if is_valid(rule_label, col_table_dict=col_table_dict, sql=sql) is False: print('*'*50) continue ''' example = Example( src_sent=sql['question_tokens'], src_len=len(sql['question_tokens']), col_names=sql['column_names'], col_len=len(sql['column_names']), feature_c = sql['column_features'], table_names=sql['table_names'], table_len=len(sql['table_names']), value_name=sql['values'], value_len = len(sql['values']), col_table_dict=col_table_dict, tgt_actions=rule_label, ) example.sql_json = copy.deepcopy(sql) examples.append(example) if is_train: examples.sort(key=lambda e: -len(e.src_sent)) return examples else: return examples
def test_dataset_metadata(self): e0 = Entry("HEAD", [Example([[10, 20]], 10)], dict([["HEAD", True], ["TAKE", False]])) e1 = Entry("TAKE", [Example([1, [10, 20]], 10)], dict([["HEAD", False], ["TAKE", True]])) dataset = ch.datasets.TupleDataset([e0, e1]) stats = dataset_metadata(dataset) self.assertEqual(2, stats.max_num_inputs) self.assertEqual(set(["HEAD", "TAKE"]), stats.symbols)
def test_TrainingClassifier(self): embed = ExampleEmbed(1, 2, 2) encoder = Encoder(10) decoder = Decoder(2) classifier = TrainingClassifier(ch.Sequential(embed, encoder, decoder)) metadata = DatasetMetadata(1, set([]), 2, 2) e = examples_encoding( [Example([[0, 1]], 0), Example([[1]], 1)], metadata) labels = np.array([[1, 1]]) loss = classifier(np.array([e.types]), np.array([e.values]), labels) loss.grad = np.ones(loss.shape, dtype=np.float32) # backward does not throw an error loss.backward()
def test_predict_with_neural_network(self): examples = [ Example([2, [10, 20, 30]], 30), Example([1, [-10, 30, 40]], 30) ] metadata = DatasetMetadata(2, set(["MAP", "HEAD"]), 256, 5) model_shape = ModelShapeParameters(metadata, 3, 2, 10) m = InferenceModel(model_shape) pred = predict_with_neural_network(model_shape, m) prob = pred(examples) encoding = examples_encoding(examples, metadata) prob_dnn = m.model(np.array([encoding.types]), np.array([encoding.values])).array[0] self.assertAlmostEqual(prob_dnn[0], prob["HEAD"]) self.assertAlmostEqual(prob_dnn[1], prob["MAP"])
def test_search_when_pred_throws_error(self): # example that do not correspond to any programs examples = [ Example([2, [10, 20, 30]], -255), Example([1, [-10, 30, 40]], -255) ] def pred(examples): raise RuntimeError("test") result = search( os.path.join(os.getcwd(), "DeepCoder_Utils", "enumerative-search", "search"), 1000, 256, examples, 2, pred) self.assertFalse(result.is_solved) self.assertEqual(-1, result.explored_nodes) self.assertEqual(dict([]), result.probabilities) self.assertEqual("", result.solution)
def test_search_with_invalid_examples(self): # example that do not correspond to any programs examples = [ Example([2, [10, 20, 30]], -255), Example([1, [-10, 30, 40]], -255) ] def pred(examples): LINQ, _ = generate_io_samples.get_language(50) LINQ = [f for f in LINQ if not "IDT" in f.src] prob = dict() for function in LINQ: for name in function.src.split(" "): prob[name] = 1.0 return prob result = search( os.path.join(os.getcwd(), "DeepCoder_Utils", "enumerative-search", "search"), 1000, 256, examples, 2, pred) self.assertFalse(result.is_solved) self.assertEqual(-1, result.explored_nodes) self.assertEqual("", result.solution)
def test_Encoder(self): embed = ExampleEmbed(1, 2, 1, (np.arange(5) + 1).reshape((5, 1))) encoder = Encoder(1, initialW=ch.initializers.One(), initial_bias=ch.initializers.Zero()) self.assertEqual(6, len(list(encoder.params()))) """ state_embeddings: (N, e, 2, 4) -> h1: (N, e, 1) -> h2: (N, e, 2) -> output: (N, e, 2) """ metadata = DatasetMetadata(1, set([]), 2, 2) e = examples_encoding( [Example([[0, 1]], 0), Example([[1]], 1)], metadata) state_embeddings = embed(np.array([e.types]), np.array([e.values])) layer_encodings = encoder(state_embeddings) self.assertEqual((1, 2, 1), layer_encodings.shape) for i in range(1): for j in range(2): h = np.array(state_embeddings[i, j, :, :].array.sum()) h = F.sigmoid(F.sigmoid(F.sigmoid(h))) self.assertEqual(h.array, layer_encodings.array[i, j])
def test_example_embed_embed_one_sample(self): embed = ExampleEmbed(1, 2, 1, (np.arange(5) + 1).reshape((5, 1))) self.assertEqual(1, len(list(embed.params()))) """ EmbedId 0 (-2) -> 1 1 (-1) -> 2 2 ( 0) -> 3 3 ( 1) -> 4 4 (NULL) -> 5 """ e = examples_encoding( [Example([[0, 1]], 0), Example([[1]], 1)], DatasetMetadata(1, set([]), 2, 2)) state_embeddings = embed.forward(np.array([e.types]), np.array([e.values])) self.assertEqual((1, 2, 2, 2 + 2 * 1), state_embeddings.shape) self.assertTrue( np.allclose([0, 1, 3, 4], state_embeddings.array[0, 0, 0])) # Input of e1 self.assertTrue( np.allclose([1, 0, 3, 5], state_embeddings.array[0, 0, 1])) # Output of e1 self.assertTrue( np.allclose([0, 1, 4, 5], state_embeddings.array[0, 1, 0])) # Input of e2 self.assertTrue( np.allclose([1, 0, 4, 5], state_embeddings.array[0, 1, 1])) # Output of e2 # backward does not throw an error state_embeddings.grad = np.ones(state_embeddings.shape, dtype=np.float32) state_embeddings.backward()
def to_batch_seq(datas, idxes, st, ed, is_train=True): examples = [] for i in range(st, ed): feature = datas[idxes[i]]['feature'] label = datas[idxes[i]]['label'] decoder_pob = datas[idxes[i]]['decoder_pob'] type = [x.split('.')[-1][:-2] for x in datas[idxes[i]]['type']] one_hot_type = np.zeros((len(feature), 4)) for id_x, t_v in enumerate(type): if t_v == 'WikiSqlSelectColumnAction': one_hot_type[id_x][0] = 1 elif t_v == 'ApplyRuleAction': one_hot_type[id_x][1] = 1 elif t_v == 'GenTokenAction': one_hot_type[id_x][2] = 1 elif t_v == 'ReduceAction': one_hot_type[id_x][3] = 1 else: raise NotImplementedError("wrong type for ", t_v) assert len(feature) == len(label) example = Example( feature, np.expand_dims(np.array(label), axis=1), decoder_pob=decoder_pob, one_hot_type=one_hot_type ) examples.append(example) if is_train: examples.sort(key=lambda e: -len(e.confidence)) return examples else: return examples
def test_examples_encoding_if_num_inputs_is_too_large(self): metadata = DatasetMetadata(0, set([]), 2, 2) self.assertRaises( RuntimeError, lambda: examples_encoding( [Example([1, [0, 1]], [0]), Example([0, [0, 1]], [])], metadata))