├── .idea ├── .name ├── MultiTurnResponseSelection.iml ├── encodings.xml ├── misc.xml ├── modules.xml ├── vcs.xml └── workspace.xml ├── README.md ├── tensorflow_src ├── Evaluate.py ├── SCN.PY └── utils.py ├── test.txt ├── theano_src ├── CNN.py ├── Classifier.py ├── Optimization.py ├── PreProcess.py ├── RNN.py ├── SMN_Dynamic.py ├── SMN_Last.py ├── SMN_Static.py ├── SimAsImage.py └── logistic_sgd.py └── train.sample /.idea/.name: -------------------------------------------------------------------------------- 1 | MultiTurnResponseSelection -------------------------------------------------------------------------------- /.idea/MultiTurnResponseSelection.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 12 | -------------------------------------------------------------------------------- /.idea/encodings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/workspace.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 14 | 15 | 16 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 80 | 81 | 82 | 84 | 85 | 92 | 93 | 94 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 133 | 134 | 137 | 138 | 141 | 142 | 143 | 144 | 147 | 148 | 151 | 152 | 153 | 154 | 157 | 158 | 161 | 162 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 194 | 195 | 213 | 214 | 232 | 233 | 253 | 254 | 275 | 276 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 1485308173127 308 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 340 | 343 | 344 | 345 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Douban Conversation Corpus 2 | 3 | ## Data set 4 | We release Douban Conversation Corpus, comprising a training data set, a development set and a test set for retrieval based chatbot. The statistics of Douban Conversation Corpus are shown in the following table. 5 | 6 | | |Train|Val| Test | 7 | | ------------- |:-------------:|:-------------:|:-------------:| 8 | | session-response pairs | 1m|50k| 10k | 9 | | Avg. positive response per session | 1|1| 1.18 | 10 | | Fless Kappa | N\A|N\A|0.41 | 11 | | Min turn per session | 3|3| 3 | 12 | | Max ture per session | 98|91|45 | 13 | | Average turn per session | 6.69|6.75|5.95   | 14 | | Average Word per utterance | 18.56|18.50|20.74  | 15 | 16 | 17 | The test data contains 1000 dialogue context, and for each context we create 10 responses as candidates. We recruited three labelers to judge if a candidate is a proper response to the session. A proper response means the response can naturally reply to the message given the context. Each pair received three labels and the majority of the labels was taken as the final decision. 18 | 19 |
20 | As far as we known, this is the first human-labeled test set for retrieval-based chatbots. The entire corpus link https://www.dropbox.com/s/90t0qtji9ow20ca/DoubanConversaionCorpus.zip?dl=0 21 | 22 | 23 | ## Data template 24 | label \t conversation utterances (splited by \t) \t response 25 | 26 | 27 | ## Source Code 28 | We also release our source code to help others reproduce our result. The code has been tested under Ubuntu 14.04 with python 2.7. 29 | 30 | Please first run preprocess.py and edit the code with the correct path, and it will give you a .bin file. After that, please run SMN_Last.py with the generated .bin file, and the training loss will be printed on the screen. If you set the train_flag = False, it will give your predicted score with your model. 31 | 32 | Some tips: 33 | 34 | The 200-d word embedding is shared at https://1drv.ms/u/s!AtcxwlQuQjw1jF0bjeaKHEUNwitA . The shared file is a list has 3 elements, one of which is a word2vec file. Please Download it and replace the input path (Training data) in my scripy. 35 | 36 | Tensorflow resources: 37 | 38 | The tensorflow code requires several data set, which has been uploaded on the following path: 39 | 40 | Resource file: https://1drv.ms/u/s!AtcxwlQuQjw1jGn5kPzsH03lnG6U 41 | 42 | Worddict file: https://1drv.ms/u/s!AtcxwlQuQjw1jGrCjg8liK1wE-N9 43 | 44 | Requirement: tensorflow>=1.3 45 | 46 | 47 | ## Reference 48 | Please cite our paper if you use the data or code in this repos. 49 | 50 | Wu, Yu, et al. "Sequential Matching Network: A New Archtechture for Multi-turn Response Selection in Retrieval-based Chatbots." ACL. 2017. 51 | -------------------------------------------------------------------------------- /tensorflow_src/Evaluate.py: -------------------------------------------------------------------------------- 1 | def ComputeR10_1(scores,labels,count = 10): 2 | total = 0 3 | correct = 0 4 | for i in range(len(labels)): 5 | if labels[i] == 1: 6 | total = total+1 7 | sublist = scores[i:i+count] 8 | if max(sublist) == scores[i]: 9 | correct = correct + 1 10 | print(float(correct)/ total ) 11 | 12 | def ComputeR2_1(scores,labels,count = 2): 13 | total = 0 14 | correct = 0 15 | for i in range(len(labels)): 16 | if labels[i] == 1: 17 | total = total+1 18 | sublist = scores[i:i+count] 19 | if max(sublist) == scores[i]: 20 | correct = correct + 1 21 | print(float(correct)/ total ) -------------------------------------------------------------------------------- /tensorflow_src/SCN.PY: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | import pickle 3 | import utils 4 | from keras.preprocessing.sequence import pad_sequences 5 | import numpy as np 6 | import Evaluate 7 | 8 | embedding_file = r"D:\data\Ubuntu\embedding.pkl" 9 | evaluate_file = r"D:\data\Ubuntu\Evaluate.pkl" 10 | response_file =r"D:\data\Ubuntu\responses.pkl" 11 | history_file = r"D:\data\Ubuntu\utterances.pkl" 12 | 13 | class SCN(): 14 | def __init__(self): 15 | self.max_num_utterance = 10 16 | self.negative_samples = 1 17 | self.max_sentence_len = 50 18 | self.word_embedding_size = 200 19 | self.rnn_units = 200 20 | self.total_words = 434511 21 | self.batch_size = 40 22 | 23 | def LoadModel(self): 24 | #init = tf.global_variables_initializer() 25 | saver = tf.train.Saver() 26 | sess = tf.Session() 27 | #with tf.Session() as sess: 28 | #sess.run(init) 29 | saver.restore(sess,"neg5model\\model.5") 30 | return sess 31 | # Later, launch the model, use the saver to restore variables from disk, and 32 | # do some work with the model. 33 | # with tf.Session() as sess: 34 | # # Restore variables from disk. 35 | # saver.restore(sess, "/model/model.5") 36 | # print("Model restored.") 37 | 38 | def BuildModel(self): 39 | self.utterance_ph = tf.placeholder(tf.int32, shape=(None, self.max_num_utterance, self.max_sentence_len)) 40 | self.response_ph = tf.placeholder(tf.int32, shape=(None, self.max_sentence_len)) 41 | self.y_true = tf.placeholder(tf.int32, shape=(None,)) 42 | self.embedding_ph = tf.placeholder(tf.float32, shape=(self.total_words, self.word_embedding_size)) 43 | self.response_len = tf.placeholder(tf.int32, shape=(None,)) 44 | self.all_utterance_len_ph = tf.placeholder(tf.int32, shape=(None, self.max_num_utterance)) 45 | word_embeddings = tf.get_variable('word_embeddings_v', shape=(self.total_words,self. 46 | word_embedding_size), dtype=tf.float32, trainable=False) 47 | self.embedding_init = word_embeddings.assign(self.embedding_ph) 48 | all_utterance_embeddings = tf.nn.embedding_lookup(word_embeddings, self.utterance_ph) 49 | response_embeddings = tf.nn.embedding_lookup(word_embeddings, self.response_ph) 50 | sentence_GRU = tf.nn.rnn_cell.GRUCell(self.rnn_units, kernel_initializer=tf.orthogonal_initializer()) 51 | all_utterance_embeddings = tf.unstack(all_utterance_embeddings, num=self.max_num_utterance, axis=1) 52 | all_utterance_len = tf.unstack(self.all_utterance_len_ph, num=self.max_num_utterance, axis=1) 53 | A_matrix = tf.get_variable('A_matrix_v', shape=(self.rnn_units, self.rnn_units), initializer=tf.contrib.layers.xavier_initializer(), dtype=tf.float32) 54 | final_GRU = tf.nn.rnn_cell.GRUCell(self.rnn_units, kernel_initializer=tf.orthogonal_initializer()) 55 | reuse = None 56 | 57 | response_GRU_embeddings, _ = tf.nn.dynamic_rnn(sentence_GRU, response_embeddings, sequence_length=self.response_len, dtype=tf.float32, 58 | scope='sentence_GRU') 59 | self.response_embedding_save = response_GRU_embeddings 60 | response_embeddings = tf.transpose(response_embeddings, perm=[0, 2, 1]) 61 | response_GRU_embeddings = tf.transpose(response_GRU_embeddings, perm=[0, 2, 1]) 62 | matching_vectors = [] 63 | for utterance_embeddings, utterance_len in zip(all_utterance_embeddings, all_utterance_len): 64 | matrix1 = tf.matmul(utterance_embeddings, response_embeddings) 65 | utterance_GRU_embeddings, _ = tf.nn.dynamic_rnn(sentence_GRU, utterance_embeddings, sequence_length=utterance_len, dtype=tf.float32, 66 | scope='sentence_GRU') 67 | matrix2 = tf.einsum('aij,jk->aik', utterance_GRU_embeddings, A_matrix) # TODO:check this 68 | matrix2 = tf.matmul(matrix2, response_GRU_embeddings) 69 | matrix = tf.stack([matrix1, matrix2], axis=3, name='matrix_stack') 70 | conv_layer = tf.layers.conv2d(matrix, filters=8, kernel_size=(3, 3), padding='VALID', 71 | kernel_initializer=tf.contrib.keras.initializers.he_normal(), 72 | activation=tf.nn.relu, reuse=reuse, name='conv') # TODO: check other params 73 | pooling_layer = tf.layers.max_pooling2d(conv_layer, (3, 3), strides=(3, 3), 74 | padding='VALID', name='max_pooling') # TODO: check other params 75 | matching_vector = tf.layers.dense(tf.contrib.layers.flatten(pooling_layer), 50, 76 | kernel_initializer=tf.contrib.layers.xavier_initializer(), 77 | activation=tf.tanh, reuse=reuse, name='matching_v') # TODO: check wthether this is correct 78 | if not reuse: 79 | reuse = True 80 | matching_vectors.append(matching_vector) 81 | _, last_hidden = tf.nn.dynamic_rnn(final_GRU, tf.stack(matching_vectors, axis=0, name='matching_stack'), dtype=tf.float32, 82 | time_major=True, scope='final_GRU') # TODO: check time_major 83 | logits = tf.layers.dense(last_hidden, 2, kernel_initializer=tf.contrib.layers.xavier_initializer(), name='final_v') 84 | self.y_pred = tf.nn.softmax(logits) 85 | self.total_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.y_true, logits=logits)) 86 | tf.summary.scalar('loss', self.total_loss) 87 | optimizer = tf.train.AdamOptimizer(learning_rate=0.001) 88 | self.train_op = optimizer.minimize(self.total_loss) 89 | 90 | def Evaluate(self,sess): 91 | with open(evaluate_file, 'rb') as f: 92 | history, true_utt,labels = pickle.load(f) 93 | self.all_candidate_scores = [] 94 | history, history_len = utils.multi_sequences_padding(history, self.max_sentence_len) 95 | history, history_len = np.array(history), np.array(history_len) 96 | true_utt_len = np.array(utils.get_sequences_length(true_utt, maxlen=self.max_sentence_len)) 97 | true_utt = np.array(pad_sequences(true_utt, padding='post', maxlen=self.max_sentence_len)) 98 | low = 0 99 | while True: 100 | feed_dict = {self.utterance_ph: np.concatenate([history[low:low + 200]], axis=0), 101 | self.all_utterance_len_ph: np.concatenate([history_len[low:low + 200]], axis=0), 102 | self.response_ph: np.concatenate([true_utt[low:low + 200]], axis=0), 103 | self.response_len: np.concatenate([true_utt_len[low:low + 200]], axis=0), 104 | } 105 | candidate_scores = sess.run(self.y_pred, feed_dict=feed_dict) 106 | self.all_candidate_scores.append(candidate_scores[:, 1]) 107 | low = low + 200 108 | if low >= history.shape[0]: 109 | break 110 | all_candidate_scores = np.concatenate(self.all_candidate_scores, axis=0) 111 | Evaluate.ComputeR10_1(all_candidate_scores,labels) 112 | Evaluate.ComputeR2_1(all_candidate_scores,labels) 113 | 114 | 115 | 116 | 117 | def TrainModel(self,countinue_train = False, previous_modelpath = "model"): 118 | init = tf.global_variables_initializer() 119 | saver = tf.train.Saver() 120 | merged = tf.summary.merge_all() 121 | with tf.Session() as sess: 122 | writer = tf.summary.FileWriter("output2", sess.graph) 123 | train_writer = tf.summary.FileWriter('output2', sess.graph) 124 | with open(response_file, 'rb') as f: 125 | actions = pickle.load(f) 126 | with open(embedding_file, 'rb') as f: 127 | embeddings = pickle.load(f,encoding="bytes") 128 | with open(history_file, 'rb') as f: 129 | history, true_utt = pickle.load(f) 130 | # with open("data/biglearn_test_small.txt", encoding="utf8") as f: 131 | # lines = f.readlines() 132 | # history, true_utt = utils.build_evaluate_data(lines) 133 | history, history_len = utils.multi_sequences_padding(history, self.max_sentence_len) 134 | true_utt_len = np.array(utils.get_sequences_length(true_utt, maxlen=self.max_sentence_len)) 135 | true_utt = np.array(pad_sequences(true_utt, padding='post', maxlen=self.max_sentence_len)) 136 | actions_len = np.array(utils.get_sequences_length(actions, maxlen=self.max_sentence_len)) 137 | actions = np.array(pad_sequences(actions, padding='post', maxlen=self.max_sentence_len)) 138 | history, history_len = np.array(history), np.array(history_len) 139 | if countinue_train == False: 140 | sess.run(init) 141 | sess.run(self.embedding_init, feed_dict={self.embedding_ph: embeddings}) 142 | else: 143 | saver.restore(sess,previous_modelpath) 144 | low = 0 145 | epoch = 1 146 | while epoch < 10: 147 | n_sample = min(low + self.batch_size, history.shape[0]) - low 148 | negative_indices = [np.random.randint(0, actions.shape[0], n_sample) for _ in range(self.negative_samples)] 149 | negs = [actions[negative_indices[i], :] for i in range(self.negative_samples)] 150 | negs_len = [actions_len[negative_indices[i]] for i in range(self.negative_samples)] 151 | feed_dict = {self.utterance_ph: np.concatenate([history[low:low + n_sample]] * (self.negative_samples + 1), axis=0), 152 | self.all_utterance_len_ph: np.concatenate([history_len[low:low + n_sample]] * (self.negative_samples + 1), axis=0), 153 | self.response_ph: np.concatenate([true_utt[low:low + n_sample]] + negs, axis=0), 154 | self.response_len: np.concatenate([true_utt_len[low:low + n_sample]] + negs_len, axis=0), 155 | self.y_true: np.concatenate([np.ones(n_sample)] + [np.zeros(n_sample)] * self.negative_samples, axis=0) 156 | } 157 | _, summary = sess.run([self.train_op, merged], feed_dict=feed_dict) 158 | train_writer.add_summary(summary) 159 | low += n_sample 160 | if low % 102400 == 0: 161 | print("loss",sess.run(self.total_loss, feed_dict=feed_dict)) 162 | self.Evaluate(sess) 163 | if low >= history.shape[0]: 164 | low = 0 165 | saver.save(sess,"model/model.{0}".format(epoch)) 166 | print(sess.run(self.total_loss, feed_dict=feed_dict)) 167 | print('epoch={i}'.format(i=epoch)) 168 | epoch += 1 169 | 170 | if __name__ == "__main__": 171 | scn =SCN() 172 | scn.BuildModel() 173 | scn.TrainModel() 174 | #sess = scn.LoadModel() 175 | #scn.Evaluate(sess) 176 | #results = scn.BuildIndex(sess) 177 | #print(len(results)) 178 | 179 | #scn.TrainModel() -------------------------------------------------------------------------------- /tensorflow_src/utils.py: -------------------------------------------------------------------------------- 1 | import concurrent.futures 2 | import pickle 3 | import numpy as np 4 | from keras.preprocessing.sequence import pad_sequences 5 | from keras.preprocessing.text import text_to_word_sequence 6 | 7 | 8 | def build_data(lines, word_dict, tid=0): 9 | def word2id(c): 10 | if c in word_dict: 11 | return word_dict[c] 12 | else: 13 | return 0 14 | 15 | cnt = 0 16 | history = [] 17 | true_utt = [] 18 | for line in lines: 19 | fields = line.rstrip().lower().split('\t') 20 | utterance = fields[1].split('###') 21 | history.append([list(map(word2id, text_to_word_sequence(each_utt))) for each_utt in utterance]) 22 | true_utt.append(list(map(word2id, text_to_word_sequence(fields[2])))) 23 | cnt += 1 24 | if cnt % 10000 == 0: 25 | print(tid, cnt) 26 | return history, true_utt 27 | 28 | 29 | def build_evaluate_data(lines, tid=0): 30 | with open('worddata/word_dict.pkl', 'rb') as f: 31 | word_dict = pickle.load(f) 32 | 33 | def word2id(c): 34 | if c in word_dict: 35 | return word_dict[c] 36 | else: 37 | return 0 38 | 39 | cnt = 0 40 | history = [] 41 | true_utt = [] 42 | for line in lines: 43 | fields = line.rstrip().lower().split('\t') 44 | utterance = fields[-1].split('###') 45 | history.append([list(map(word2id, text_to_word_sequence(each_utt))) for each_utt in utterance]) 46 | true_utt.append(list(map(word2id, text_to_word_sequence(fields[0])))) 47 | cnt += 1 48 | if cnt % 10000 == 0: 49 | print(tid, cnt) 50 | return history, true_utt 51 | 52 | 53 | def multi_sequences_padding(all_sequences, max_sentence_len=50): 54 | max_num_utterance = 10 55 | PAD_SEQUENCE = [0] * max_sentence_len 56 | padded_sequences = [] 57 | sequences_length = [] 58 | for sequences in all_sequences: 59 | sequences_len = len(sequences) 60 | sequences_length.append(get_sequences_length(sequences, maxlen=max_sentence_len)) 61 | if sequences_len < max_num_utterance: 62 | sequences += [PAD_SEQUENCE] * (max_num_utterance - sequences_len) 63 | sequences_length[-1] += [0] * (max_num_utterance - sequences_len) 64 | else: 65 | sequences = sequences[-max_num_utterance:] 66 | sequences_length[-1] = sequences_length[-1][-max_num_utterance:] 67 | sequences = pad_sequences(sequences, padding='post', maxlen=max_sentence_len) 68 | padded_sequences.append(sequences) 69 | return padded_sequences, sequences_length 70 | 71 | 72 | def get_sequences_length(sequences, maxlen): 73 | sequences_length = [min(len(sequence), maxlen) for sequence in sequences] 74 | return sequences_length 75 | 76 | 77 | def load_data(total_words): 78 | process_num = 10 79 | executor = concurrent.futures.ProcessPoolExecutor(process_num) 80 | base = 0 81 | results = [] 82 | history = [] 83 | true_utt = [] 84 | word_dict = dict() 85 | vectors = [] 86 | with open('data/glove.twitter.27B.200d.txt', encoding='utf8') as f: 87 | lines = f.readlines() 88 | for i, line in enumerate(lines): 89 | line = line.split(' ') 90 | word_dict[line[0]] = i 91 | vectors.append(line[1:]) 92 | if i > total_words: 93 | break 94 | with open('worddata/embedding_matrix.pkl', "wb") as f: 95 | pickle.dump(vectors, f) 96 | with open("data/biglearn_train.old.txt", encoding="utf8") as f: 97 | lines = f.readlines() 98 | total_num = 1000000 99 | print(total_num) 100 | low = 0 101 | step = total_num // process_num 102 | print(step) 103 | while True: 104 | if low < total_num: 105 | results.append(executor.submit(build_data, lines[low:low + step], word_dict, base)) 106 | else: 107 | break 108 | base += 1 109 | low += step 110 | 111 | for result in results: 112 | h, t = result.result() 113 | history += h 114 | true_utt += t 115 | print(len(history)) 116 | print(len(true_utt)) 117 | pickle.dump([history, true_utt], open("worddata/train.pkl", "wb")) 118 | actions_id = [] 119 | with open('emb/actions.txt', encoding='utf8') as f: 120 | actions = f.readlines() 121 | 122 | def word2id(c): 123 | if c in word_dict: 124 | return word_dict[c] 125 | else: 126 | return 0 127 | 128 | for action in actions: 129 | actions_id.append([word2id(word) for word in text_to_word_sequence(action)]) 130 | with open('worddata/actions_embeddings.pkl', 'wb') as f: 131 | pickle.dump(actions_id, f) 132 | 133 | 134 | def evaluate(test_file, sess, actions, actions_len, max_sentence_len, utterance_ph, all_utterance_len_ph, 135 | response_ph, response_len, y_pred): 136 | each_test_run = len(actions) // 3 137 | acc1 = [0.0] * 10 138 | rank1 = 0.0 139 | cnt = 0 140 | print('evaluating') 141 | 142 | with open(test_file, encoding="utf8") as f: 143 | lines = f.readlines() 144 | low = 0 145 | history, true_utt = build_evaluate_data(lines) 146 | history, history_len = multi_sequences_padding(history, max_sentence_len) 147 | true_utt_len = np.array(get_sequences_length(true_utt, maxlen=max_sentence_len)) 148 | true_utt = np.array(pad_sequences(true_utt,padding='post', maxlen=max_sentence_len)) 149 | history, history_len = np.array(history), np.array(history_len) 150 | feed_dict = {utterance_ph: history, 151 | all_utterance_len_ph: history_len, 152 | response_ph: true_utt, 153 | response_len: true_utt_len 154 | } 155 | true_scores = sess.run(y_pred, feed_dict=feed_dict) 156 | true_scores = true_scores[:, 1] 157 | for i in range(true_scores.shape[0]): 158 | all_candidate_scores = [] 159 | for j in range(3): 160 | feed_dict = {utterance_ph: np.concatenate([history[low:low + 1]] * each_test_run, axis=0), 161 | all_utterance_len_ph: np.concatenate([history_len[low:low + 1]] * each_test_run, axis=0), 162 | response_ph: actions[each_test_run * j:each_test_run * (j + 1)], 163 | response_len: actions_len[each_test_run * j:each_test_run * (j + 1)] 164 | } 165 | candidate_scores = sess.run(y_pred, feed_dict=feed_dict) 166 | all_candidate_scores.append(candidate_scores[:, 1]) 167 | all_candidate_scores = np.concatenate(all_candidate_scores, axis=0) 168 | pos1 = np.sum(true_scores[i] + 1e-8 < all_candidate_scores) 169 | if pos1 < 10: 170 | acc1[pos1] += 1 171 | rank1 += pos1 172 | low += 1 173 | cnt += true_scores.shape[0] 174 | print([a / cnt for a in acc1]) # rank top 1 to top 10 acc 175 | print(rank1 / cnt) # average rank 176 | print(np.sum(acc1[:3]) * 1.0 / cnt) # top 3 acc 177 | 178 | 179 | if __name__ == '__main__': 180 | load_data(500000) 181 | -------------------------------------------------------------------------------- /theano_src/CNN.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import scipy.sparse as sp 3 | from collections import defaultdict, OrderedDict 4 | import sys, re, cPickle, random, logging, argparse 5 | import datetime 6 | 7 | import theano 8 | import theano.tensor as T 9 | from theano.tensor.nnet import conv 10 | 11 | def ReLU(x): 12 | y = T.maximum(0.0, x) 13 | return(y) 14 | 15 | def kmaxpooling(input,input_shape,k): 16 | sorted_values = T.argsort(input,axis=3) 17 | topmax_indexes = sorted_values[:,:,:,-k:] 18 | # sort indexes so that we keep the correct order within the sentence 19 | topmax_indexes_sorted = T.sort(topmax_indexes) 20 | 21 | #given that topmax only gives the index of the third dimension, we need to generate the other 3 dimensions 22 | dim0 = T.arange(0,input_shape[0]).repeat(input_shape[1]*input_shape[2]*k) 23 | dim1 = T.arange(0,input_shape[1]).repeat(k*input_shape[2]).reshape((1,-1)).repeat(input_shape[0],axis=0).flatten() 24 | dim2 = T.arange(0,input_shape[2]).repeat(k).reshape((1,-1)).repeat(input_shape[0]*input_shape[1],axis=0).flatten() 25 | dim3 = topmax_indexes_sorted.flatten() 26 | return input[dim0,dim1,dim2,dim3].reshape((input_shape[0], input_shape[1], input_shape[2], k)) 27 | 28 | class QALeNetConvPoolLayer(object): 29 | """ Convolution Layer and Pool Layer for Question and Sentence pair """ 30 | 31 | def __init__(self, rng, linp, rinp, filter_shape, poolsize): 32 | """ 33 | Allocate a LeNetConvPoolLayer with shared variable internal parameters. 34 | 35 | :type rng: numpy.random.RandomState 36 | :param rng: a random number generator used to initialize weights 37 | 38 | :type linp: theano.tensor.TensorType 39 | :param linp: symbolic variable that describes the left input of the 40 | architecture (one minibatch) 41 | 42 | :type rinp: theano.tensor.TensorType 43 | :param rinp: symbolic variable that describes the right input of the 44 | architecture (one minibatch) 45 | 46 | :type filter_shape: tuple or list of length 4 47 | :param filter_shape: (number of filters, 1, 48 | filter height,filter width) 49 | 50 | :type poolsize: tuple or list of length 2 51 | :param poolsize: the downsampling (pooling) factor (#rows,#cols) 52 | """ 53 | 54 | self.linp = linp 55 | self.rinp = rinp 56 | self.filter_shape = filter_shape 57 | self.poolsize = poolsize 58 | 59 | # there are "num input feature maps * filter height * filter width" 60 | # inputs to each hidden unit 61 | fan_in = np.prod(filter_shape[1:]) 62 | # each unit in the lower layer receives a gradient from: 63 | # "num output feature maps * filter height * filter width" / 64 | # pooling size 65 | fan_out = (filter_shape[0] * np.prod(filter_shape[2:]) /np.prod(poolsize)) 66 | # initialize weights with random weights 67 | W_bound = np.sqrt(6. / (fan_in + fan_out)) 68 | self.W = theano.shared(np.asarray(rng.uniform(low=-W_bound,high=W_bound,size=filter_shape), 69 | dtype=theano.config.floatX),borrow=True,name="W_conv") 70 | b_values = np.zeros((filter_shape[0],), dtype=theano.config.floatX) 71 | self.b = theano.shared(value=b_values, borrow=True, name="b_conv") 72 | 73 | # convolve input feature maps with filters 74 | lconv_out = conv.conv2d(input=linp, filters=self.W, filter_shape = filter_shape) 75 | rconv_out = conv.conv2d(input=rinp, filters=self.W, filter_shape = filter_shape) 76 | self.lconv_out_tanh = ReLU(lconv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 77 | self.rconv_out_tanh = ReLU(rconv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 78 | self.loutput = theano.tensor.signal.pool.pool_2d(input=self.lconv_out_tanh, ds=self.poolsize, ignore_border=True, mode="max") 79 | self.routput = theano.tensor.signal.pool.pool_2d(input=self.rconv_out_tanh, ds=self.poolsize, ignore_border=True, mode="max") 80 | self.params = [self.W, self.b] 81 | 82 | def predict(self, lnew_data, rnew_data): 83 | """ 84 | predict for new data 85 | """ 86 | lconv_out = conv.conv2d(input=lnew_data, filters=self.W) 87 | rconv_out = conv.conv2d(input=rnew_data, filters=self.W) 88 | lconv_out_tanh = T.tanh(lconv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 89 | rconv_out_tanh = T.tanh(rconv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 90 | loutput = theano.tensor.signal.pool.pool_2d(input=lconv_out_tanh, ds=self.poolsize, ignore_border=True, mode="max") 91 | routput = theano.tensor.signal.pool.pool_2d(input=rconv_out_tanh, ds=self.poolsize, ignore_border=True, mode="max") 92 | return loutput, routput 93 | 94 | class LeNetConvPoolLayer(object): 95 | """Pool Layer of a convolutional network """ 96 | 97 | def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2), non_linear="tanh"): 98 | """ 99 | Allocate a LeNetConvPoolLayer with shared variable internal parameters. 100 | 101 | :type rng: numpy.random.RandomState 102 | :param rng: a random number generator used to initialize weights 103 | 104 | :type input: theano.tensor.dtensor4 105 | :param input: symbolic image tensor, of shape image_shape 106 | 107 | :type filter_shape: tuple or list of length 4 108 | :param filter_shape: (number of filters, num input feature maps, 109 | filter height,filter width) 110 | 111 | :type image_shape: tuple or list of length 4 112 | :param image_shape: (batch size, num input feature maps, 113 | image height, image width) 114 | 115 | :type poolsize: tuple or list of length 2 116 | :param poolsize: the downsampling (pooling) factor (#rows,#cols) 117 | """ 118 | print 'image shape', image_shape 119 | print 'filter shape', filter_shape 120 | assert image_shape[1] == filter_shape[1] 121 | self.input = input 122 | self.filter_shape = filter_shape 123 | self.image_shape = image_shape 124 | self.poolsize = poolsize 125 | self.non_linear = non_linear 126 | # there are "num input feature maps * filter height * filter width" 127 | # inputs to each hidden unit 128 | fan_in = np.prod(filter_shape[1:]) 129 | # each unit in the lower layer receives a gradient from: 130 | # "num output feature maps * filter height * filter width" / 131 | # pooling size 132 | fan_out = (filter_shape[0] * np.prod(filter_shape[2:]) /np.prod(poolsize)) 133 | # initialize weights with random weights 134 | if self.non_linear=="none" or self.non_linear=="relu": 135 | self.W = theano.shared(np.asarray(rng.uniform(low=-0.01,high=0.01,size=filter_shape), 136 | dtype=theano.config.floatX),borrow=True,name="W_conv") 137 | else: 138 | W_bound = np.sqrt(6. / (fan_in + fan_out)) 139 | self.W = theano.shared(np.asarray(rng.uniform(low=-W_bound, high=W_bound, size=filter_shape), 140 | dtype=theano.config.floatX),borrow=True,name="W_conv") 141 | b_values =np.zeros((filter_shape[0],), dtype=theano.config.floatX) 142 | self.b = theano.shared(value=b_values, borrow=True, name="b_conv") 143 | 144 | # convolve input feature maps with filters 145 | conv_out = conv.conv2d(input=input, filters=self.W,filter_shape=self.filter_shape, image_shape=self.image_shape) 146 | if self.non_linear=="tanh": 147 | conv_out_tanh = T.tanh(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 148 | self.output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True,mode="max") 149 | elif self.non_linear=="relu": 150 | conv_out_tanh = ReLU(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 151 | self.output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True,mode="max") 152 | else: 153 | pooled_out = theano.tensor.signal.pool.pool_2d(input=conv_out, ds=self.poolsize, ignore_border=True,mode="max") 154 | self.output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') 155 | self.params = [self.W, self.b] 156 | 157 | def predict(self, new_data, batch_size): 158 | """ 159 | predict for new data 160 | """ 161 | img_shape = (batch_size, 1, self.image_shape[2], self.image_shape[3]) 162 | conv_out = conv.conv2d(input=new_data, filters=self.W, filter_shape=self.filter_shape, image_shape=img_shape) 163 | if self.non_linear=="tanh": 164 | conv_out_tanh = T.tanh(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 165 | output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True) 166 | if self.non_linear=="relu": 167 | conv_out_tanh = ReLU(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 168 | output =theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True) 169 | else: 170 | pooled_out = theano.tensor.signal.pool.pool_2d(input=conv_out, ds=self.poolsize, ignore_border=True) 171 | output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') 172 | return output 173 | 174 | class LeNetConvPoolLayer2(object): 175 | """Pool Layer of a convolutional network """ 176 | 177 | def __init__(self, rng, filter_shape, image_shape, poolsize=(2, 2), non_linear="tanh"): 178 | """ 179 | Allocate a LeNetConvPoolLayer with shared variable internal parameters. 180 | 181 | :type rng: numpy.random.RandomState 182 | :param rng: a random number generator used to initialize weights 183 | 184 | :type input: theano.tensor.dtensor4 185 | :param input: symbolic image tensor, of shape image_shape 186 | 187 | :type filter_shape: tuple or list of length 4 188 | :param filter_shape: (number of filters, num input feature maps, 189 | filter height,filter width) 190 | 191 | :type image_shape: tuple or list of length 4 192 | :param image_shape: (batch size, num input feature maps, 193 | image height, image width) 194 | 195 | :type poolsize: tuple or list of length 2 196 | :param poolsize: the downsampling (pooling) factor (#rows,#cols) 197 | """ 198 | print 'image shape', image_shape 199 | print 'filter shape', filter_shape 200 | assert image_shape[1] == filter_shape[1] 201 | self.filter_shape = filter_shape 202 | self.image_shape = image_shape 203 | self.poolsize = poolsize 204 | self.non_linear = non_linear 205 | # there are "num input feature maps * filter height * filter width" 206 | # inputs to each hidden unit 207 | fan_in = np.prod(filter_shape[1:]) 208 | # each unit in the lower layer receives a gradient from: 209 | # "num output feature maps * filter height * filter width" / 210 | # pooling size 211 | fan_out = (filter_shape[0] * np.prod(filter_shape[2:]) /np.prod(poolsize)) 212 | # initialize weights with random weights 213 | if self.non_linear=="none" or self.non_linear=="relu": 214 | self.W = theano.shared(np.asarray(rng.uniform(low=-0.01,high=0.01,size=filter_shape), 215 | dtype=theano.config.floatX),borrow=True,name="W_conv") 216 | else: 217 | W_bound = np.sqrt(6. / (fan_in + fan_out)) 218 | self.W = theano.shared(np.asarray(rng.uniform(low=-W_bound, high=W_bound, size=filter_shape), 219 | dtype=theano.config.floatX),borrow=True,name="W_conv") 220 | b_values =np.zeros((filter_shape[0],), dtype=theano.config.floatX) 221 | self.b = theano.shared(value=b_values, borrow=True, name="b_conv") 222 | self.params = [self.W, self.b] 223 | # convolve input feature maps with filters 224 | 225 | 226 | def __call__(self, input): 227 | conv_out = conv.conv2d(input=input, filters=self.W,filter_shape=self.filter_shape, image_shape=self.image_shape) 228 | if self.non_linear=="tanh": 229 | conv_out_tanh = T.tanh(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 230 | self.output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True,mode="max") 231 | elif self.non_linear=="relu": 232 | conv_out_tanh = ReLU(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 233 | self.output =theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True,mode="max") 234 | else: 235 | pooled_out = theano.tensor.signal.pool.pool_2d(input=conv_out, ds=self.poolsize, ignore_border=True,mode="max") 236 | self.output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') 237 | return self.output 238 | 239 | 240 | def predict(self, new_data, batch_size): 241 | """ 242 | predict for new data 243 | """ 244 | img_shape = (batch_size, 1, self.image_shape[2], self.image_shape[3]) 245 | conv_out = conv.conv2d(input=new_data, filters=self.W, filter_shape=self.filter_shape, image_shape=img_shape) 246 | if self.non_linear=="tanh": 247 | conv_out_tanh = T.tanh(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 248 | output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True) 249 | if self.non_linear=="relu": 250 | conv_out_tanh = ReLU(conv_out + self.b.dimshuffle('x', 0, 'x', 'x')) 251 | output = theano.tensor.signal.pool.pool_2d(input=conv_out_tanh, ds=self.poolsize, ignore_border=True) 252 | else: 253 | pooled_out = theano.tensor.signal.pool.pool_2d(input=conv_out, ds=self.poolsize, ignore_border=True) 254 | output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') 255 | return output -------------------------------------------------------------------------------- /theano_src/Classifier.py: -------------------------------------------------------------------------------- 1 | """ 2 | This tutorial introduces the multilayer perceptron using Theano. 3 | 4 | A multilayer perceptron is a logistic regressor where 5 | instead of feeding the input to the logistic regression you insert a 6 | intermediate layer, called the hidden layer, that has a nonlinear 7 | activation function (usually tanh or sigmoid) . One can use many such 8 | hidden layers making the architecture deep. The tutorial will also tackle 9 | the problem of MNIST digit classification. 10 | 11 | .. math:: 12 | 13 | f(x) = G( b^{(2)} + W^{(2)}( s( b^{(1)} + W^{(1)} x))), 14 | 15 | References: 16 | 17 | - textbooks: "Pattern Recognition and Machine Learning" - 18 | Christopher M. Bishop, section 5 19 | 20 | """ 21 | 22 | from __future__ import print_function 23 | 24 | __docformat__ = 'restructedtext en' 25 | 26 | 27 | import os 28 | import sys 29 | import timeit 30 | 31 | import numpy 32 | 33 | import theano 34 | import theano.tensor as T 35 | 36 | 37 | from logistic_sgd import LogisticRegression, load_data 38 | 39 | 40 | 41 | 42 | def _dropout_from_layer(rng, layer, p): 43 | """p is the probablity of dropping a unit 44 | """ 45 | srng = theano.tensor.shared_randomstreams.RandomStreams( 46 | rng.randint(999999)) 47 | # p=1-p because 1's indicate keep and p is prob of dropping 48 | mask = srng.binomial(n=1, p=1-p, size=layer.shape) 49 | # The cast is important because 50 | # int * float32 = float64 which pulls things off the gpu 51 | output = layer * T.cast(mask, theano.config.floatX) 52 | return output 53 | # start-snippet-1 54 | class HiddenLayer(object): 55 | def __init__(self, rng, input, n_in, n_out, W=None, b=None, 56 | activation=T.tanh): 57 | """ 58 | Typical hidden layer of a MLP: units are fully-connected and have 59 | sigmoidal activation function. Weight matrix W is of shape (n_in,n_out) 60 | and the bias vector b is of shape (n_out,). 61 | 62 | NOTE : The nonlinearity used here is tanh 63 | 64 | Hidden unit activation is given by: tanh(dot(input,W) + b) 65 | 66 | :type rng: numpy.random.RandomState 67 | :param rng: a random number generator used to initialize weights 68 | 69 | :type input: theano.tensor.dmatrix 70 | :param input: a symbolic tensor of shape (n_examples, n_in) 71 | 72 | :type n_in: int 73 | :param n_in: dimensionality of input 74 | 75 | :type n_out: int 76 | :param n_out: number of hidden units 77 | 78 | :type activation: theano.Op or function 79 | :param activation: Non linearity to be applied in the hidden 80 | layer 81 | """ 82 | self.input = input 83 | # end-snippet-1 84 | 85 | # `W` is initialized with `W_values` which is uniformely sampled 86 | # from sqrt(-6./(n_in+n_hidden)) and sqrt(6./(n_in+n_hidden)) 87 | # for tanh activation function 88 | # the output of uniform if converted using asarray to dtype 89 | # theano.config.floatX so that the code is runable on GPU 90 | # Note : optimal initialization of weights is dependent on the 91 | # activation function used (among other things). 92 | # For example, results presented in [Xavier10] suggest that you 93 | # should use 4 times larger initial weights for sigmoid 94 | # compared to tanh 95 | # We have no info for other function, so we use the same as 96 | # tanh. 97 | if W is None: 98 | W_values = numpy.asarray( 99 | rng.uniform( 100 | low=-numpy.sqrt(6. / (n_in + n_out)), 101 | high=numpy.sqrt(6. / (n_in + n_out)), 102 | size=(n_in, n_out) 103 | ), 104 | dtype=theano.config.floatX 105 | ) 106 | if activation == theano.tensor.nnet.sigmoid: 107 | W_values *= 4 108 | 109 | W = theano.shared(value=W_values, name='W', borrow=True) 110 | 111 | if b is None: 112 | b_values = numpy.zeros((n_out,), dtype=theano.config.floatX) 113 | b = theano.shared(value=b_values, name='b', borrow=True) 114 | 115 | self.W = W 116 | self.b = b 117 | 118 | lin_output = T.dot(input, self.W) + self.b 119 | self.output = ( 120 | lin_output if activation is None 121 | else activation(lin_output) 122 | ) 123 | #self.output = _dropout_from_layer(rng,self.output,0.3) 124 | 125 | # parameters of the model 126 | self.params = [self.W, self.b] 127 | class HiddenLayer2(object): 128 | def __init__(self, rng, n_in, n_out, W=None, b=None, 129 | activation=T.tanh): 130 | """ 131 | Typical hidden layer of a MLP: units are fully-connected and have 132 | sigmoidal activation function. Weight matrix W is of shape (n_in,n_out) 133 | and the bias vector b is of shape (n_out,). 134 | 135 | NOTE : The nonlinearity used here is tanh 136 | 137 | Hidden unit activation is given by: tanh(dot(input,W) + b) 138 | 139 | :type rng: numpy.random.RandomState 140 | :param rng: a random number generator used to initialize weights 141 | 142 | :type input: theano.tensor.dmatrix 143 | :param input: a symbolic tensor of shape (n_examples, n_in) 144 | 145 | :type n_in: int 146 | :param n_in: dimensionality of input 147 | 148 | :type n_out: int 149 | :param n_out: number of hidden units 150 | 151 | :type activation: theano.Op or function 152 | :param activation: Non linearity to be applied in the hidden 153 | layer 154 | """ 155 | # end-snippet-1 156 | 157 | # `W` is initialized with `W_values` which is uniformely sampled 158 | # from sqrt(-6./(n_in+n_hidden)) and sqrt(6./(n_in+n_hidden)) 159 | # for tanh activation function 160 | # the output of uniform if converted using asarray to dtype 161 | # theano.config.floatX so that the code is runable on GPU 162 | # Note : optimal initialization of weights is dependent on the 163 | # activation function used (among other things). 164 | # For example, results presented in [Xavier10] suggest that you 165 | # should use 4 times larger initial weights for sigmoid 166 | # compared to tanh 167 | # We have no info for other function, so we use the same as 168 | # tanh. 169 | if W is None: 170 | W_values = numpy.asarray( 171 | rng.uniform( 172 | low=-numpy.sqrt(6. / (n_in + n_out)), 173 | high=numpy.sqrt(6. / (n_in + n_out)), 174 | size=(n_in, n_out) 175 | ), 176 | dtype=theano.config.floatX 177 | ) 178 | if activation == theano.tensor.nnet.sigmoid: 179 | W_values *= 4 180 | 181 | W = theano.shared(value=W_values, name='W', borrow=True) 182 | 183 | if b is None: 184 | b_values = numpy.zeros((n_out,), dtype=theano.config.floatX) 185 | b = theano.shared(value=b_values, name='b', borrow=True) 186 | 187 | self.W = W 188 | self.b = b 189 | self.activation = activation 190 | 191 | self.params = [self.W, self.b] 192 | 193 | def __call__(self, input): 194 | lin_output = T.dot(input, self.W) + self.b 195 | return self.activation(lin_output) 196 | class TensorClassifier(object): 197 | """Multi-Layer Perceptron Class 198 | 199 | A multilayer perceptron is a feedforward artificial neural network model 200 | that has one layer or more of hidden units and nonlinear activations. 201 | Intermediate layers usually have as activation function tanh or the 202 | sigmoid function (defined here by a ``HiddenLayer`` class) while the 203 | top layer is a softmax layer (defined here by a ``LogisticRegression`` 204 | class). 205 | """ 206 | 207 | def __init__(self, rng, n_left,n_right,dim_tensor=1,activate_func = 'tanh'): 208 | self.dim_tensor = dim_tensor 209 | self.activation = activate_func 210 | 211 | W_values = numpy.asarray( 212 | numpy.random.randn(n_left,self.dim_tensor,n_right) * 0.05, 213 | # rng.uniform( 214 | # low=-numpy.sqrt(6. / (n_left+n_right)), 215 | # high=numpy.sqrt(6. / (n_left+n_right)), 216 | # size=(n_left, self.dim_tensor, n_right) 217 | # ), 218 | dtype=theano.config.floatX 219 | ) 220 | 221 | self.W = theano.shared(value=W_values, name='W', borrow=True) 222 | self.W2 = theano.shared(value=numpy.asarray( 223 | rng.uniform( 224 | low=-numpy.sqrt(6. / (n_left+n_right)), 225 | high=numpy.sqrt(6. / (n_left+n_right)), 226 | size=(n_left + n_right, self.dim_tensor) 227 | ), 228 | dtype=theano.config.floatX 229 | ), borrow=True) 230 | self.params = [self.W,self.W2] 231 | 232 | def __call__(self,left,right,batch_size, *args, **kwargs): 233 | tmp1 = T.dot(T.concatenate([left,right],1),self.W2) 234 | tmp2 = T.batched_dot(T.tensordot(left,self.W,[1,0]),right) 235 | tmp2 = theano.tensor.reshape(tmp2,(batch_size,self.dim_tensor)) 236 | if self.activation == 'tanh': 237 | return theano.tensor.tanh(tmp2 + tmp1) 238 | if self.activation == 'relu': 239 | return T.maximum(0.0, tmp2) 240 | # start-snippet-2 241 | class MLP(object): 242 | """Multi-Layer Perceptron Class 243 | 244 | A multilayer perceptron is a feedforward artificial neural network model 245 | that has one layer or more of hidden units and nonlinear activations. 246 | Intermediate layers usually have as activation function tanh or the 247 | sigmoid function (defined here by a ``HiddenLayer`` class) while the 248 | top layer is a softmax layer (defined here by a ``LogisticRegression`` 249 | class). 250 | """ 251 | 252 | def __init__(self, rng, input, n_in, n_hidden, n_out): 253 | """Initialize the parameters for the multilayer perceptron 254 | 255 | :type rng: numpy.random.RandomState 256 | :param rng: a random number generator used to initialize weights 257 | 258 | :type input: theano.tensor.TensorType 259 | :param input: symbolic variable that describes the input of the 260 | architecture (one minibatch) 261 | 262 | :type n_in: int 263 | :param n_in: number of input units, the dimension of the space in 264 | which the datapoints lie 265 | 266 | :type n_hidden: int 267 | :param n_hidden: number of hidden units 268 | 269 | :type n_out: int 270 | :param n_out: number of output units, the dimension of the space in 271 | which the labels lie 272 | 273 | """ 274 | 275 | # Since we are dealing with a one hidden layer MLP, this will translate 276 | # into a HiddenLayer with a tanh activation function connected to the 277 | # LogisticRegression layer; the activation function can be replaced by 278 | # sigmoid or any other nonlinear function 279 | self.hiddenLayer = HiddenLayer( 280 | rng=rng, 281 | input=input, 282 | n_in=n_in, 283 | n_out=n_hidden, 284 | activation=T.tanh 285 | ) 286 | 287 | # The logistic regression layer gets as input the hidden units 288 | # of the hidden layer 289 | self.logRegressionLayer = LogisticRegression( 290 | input=self.hiddenLayer.output, 291 | n_in=n_hidden, 292 | n_out=n_out, 293 | rng = rng 294 | ) 295 | # end-snippet-2 start-snippet-3 296 | # L1 norm ; one regularization option is to enforce L1 norm to 297 | # be small 298 | self.L1 = ( 299 | abs(self.hiddenLayer.W).sum() 300 | + abs(self.logRegressionLayer.W).sum() 301 | ) 302 | 303 | # square of L2 norm ; one regularization option is to enforce 304 | # square of L2 norm to be small 305 | self.L2_sqr = ( 306 | (self.hiddenLayer.W ** 2).sum() 307 | + (self.logRegressionLayer.W ** 2).sum() 308 | ) 309 | 310 | # negative log likelihood of the MLP is given by the negative 311 | # log likelihood of the output of the model, computed in the 312 | # logistic regression layer 313 | self.negative_log_likelihood = ( 314 | self.logRegressionLayer.negative_log_likelihood 315 | ) 316 | # same holds for the function computing the number of errors 317 | self.errors = self.logRegressionLayer.errors 318 | 319 | # the parameters of the model are the parameters of the two layer it is 320 | # made out of 321 | self.params = self.hiddenLayer.params + self.logRegressionLayer.params 322 | # end-snippet-3 323 | 324 | # keep track of model input 325 | self.input = input 326 | def ortho_weight(ndim): 327 | W = numpy.random.randn(ndim, ndim) 328 | u, s, v = numpy.linalg.svd(W) 329 | return u.astype('float32') 330 | class BilinearLR(object): 331 | """ 332 | Bilinear Formed Logistic Regression Class 333 | """ 334 | 335 | def __init__(self, rng, linp, rinp, n_in, n_out, W=None, b=None): 336 | """ Initialize the parameters of the logistic regression 337 | 338 | :type linp: theano.tensor.TensorType 339 | :param linp: symbolic variable that describes the left input of the 340 | architecture (one minibatch) 341 | 342 | :type rinp: theano.tensor.TensorType 343 | :param rinp: symbolic variable that describes the right input of the 344 | architecture (one minibatch) 345 | 346 | :type n_in: int 347 | :param n_in: number of left input units 348 | 349 | :type n_out: int 350 | :param n_out: number of right input units 351 | 352 | """ 353 | 354 | # initialize with 0 the weights W as a matrix of shape (n_in, n_out) 355 | if W is None: 356 | if n_in == n_out: 357 | self.W = theano.shared(ortho_weight(n_in),borrow=True) 358 | else: 359 | W_bound = numpy.sqrt(6. / (n_in+n_out)) 360 | self.W = theano.shared(numpy.asarray(rng.uniform(low=-W_bound,high=W_bound,size=(n_in,n_out 361 | )), 362 | dtype=theano.config.floatX),borrow=True) 363 | else: 364 | self.W = W 365 | 366 | if b is None: 367 | self.b = theano.shared(value=0., name='b') 368 | self.b = theano.tensor.addbroadcast(self.b) 369 | #self.b = theano.tensor.set_subtensor(self.b,0.) 370 | else: 371 | self.b = b 372 | 373 | # compute vector of class-membership probabilities in symbolic form 374 | self.p_y_given_x = T.nnet.sigmoid(T.batched_dot(T.dot(linp, self.W), rinp)+ self.b) 375 | self.predict_y = T.round(self.p_y_given_x) 376 | 377 | # parameters of the model 378 | self.params = [self.W, self.b] 379 | 380 | def errors(self,y): 381 | if y.dtype.startswith('int'): 382 | return T.mean(T.neq(self.predict_y,y)) 383 | else: 384 | raise NotImplementedError 385 | 386 | def predict(self, ldata, rdata): 387 | p_y_given_x = T.nnet.sigmoid(T.dot(T.dot(ldata, self.W), rdata.T).diagonal() + self.b) 388 | return p_y_given_x 389 | 390 | def get_cost(self, y): 391 | # cross-entropy loss 392 | L = - T.mean(y * T.log(self.p_y_given_x) + (1 - y) * T.log(1 - self.p_y_given_x)) 393 | return L 394 | 395 | 396 | def test_mlp(learning_rate=0.01, L1_reg=0.00, L2_reg=0.0001, n_epochs=1000, 397 | dataset='mnist.pkl.gz', batch_size=20, n_hidden=500): 398 | """ 399 | Demonstrate stochastic gradient descent optimization for a multilayer 400 | perceptron 401 | 402 | This is demonstrated on MNIST. 403 | 404 | :type learning_rate: float 405 | :param learning_rate: learning rate used (factor for the stochastic 406 | gradient 407 | 408 | :type L1_reg: float 409 | :param L1_reg: L1-norm's weight when added to the cost (see 410 | regularization) 411 | 412 | :type L2_reg: float 413 | :param L2_reg: L2-norm's weight when added to the cost (see 414 | regularization) 415 | 416 | :type n_epochs: int 417 | :param n_epochs: maximal number of epochs to run the optimizer 418 | 419 | :type dataset: string 420 | :param dataset: the path of the MNIST dataset file from 421 | http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz 422 | 423 | 424 | """ 425 | datasets = load_data(dataset) 426 | 427 | train_set_x, train_set_y = datasets[0] 428 | valid_set_x, valid_set_y = datasets[1] 429 | test_set_x, test_set_y = datasets[2] 430 | 431 | # compute number of minibatches for training, validation and testing 432 | n_train_batches = train_set_x.get_value(borrow=True).shape[0] // batch_size 433 | n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] // batch_size 434 | n_test_batches = test_set_x.get_value(borrow=True).shape[0] // batch_size 435 | 436 | ###################### 437 | # BUILD ACTUAL MODEL # 438 | ###################### 439 | print('... building the model') 440 | 441 | # allocate symbolic variables for the data 442 | index = T.lscalar() # index to a [mini]batch 443 | x = T.matrix('x') # the data is presented as rasterized images 444 | y = T.ivector('y') # the labels are presented as 1D vector of 445 | # [int] labels 446 | 447 | rng = numpy.random.RandomState(1234) 448 | 449 | # construct the MLP class 450 | classifier = MLP( 451 | rng=rng, 452 | input=x, 453 | n_in=28 * 28, 454 | n_hidden=n_hidden, 455 | n_out=10 456 | ) 457 | 458 | # start-snippet-4 459 | # the cost we minimize during training is the negative log likelihood of 460 | # the model plus the regularization terms (L1 and L2); cost is expressed 461 | # here symbolically 462 | cost = ( 463 | classifier.negative_log_likelihood(y) 464 | + L1_reg * classifier.L1 465 | + L2_reg * classifier.L2_sqr 466 | ) 467 | # end-snippet-4 468 | 469 | # compiling a Theano function that computes the mistakes that are made 470 | # by the model on a minibatch 471 | test_model = theano.function( 472 | inputs=[index], 473 | outputs=classifier.errors(y), 474 | givens={ 475 | x: test_set_x[index * batch_size:(index + 1) * batch_size], 476 | y: test_set_y[index * batch_size:(index + 1) * batch_size] 477 | } 478 | ) 479 | 480 | validate_model = theano.function( 481 | inputs=[index], 482 | outputs=classifier.errors(y), 483 | givens={ 484 | x: valid_set_x[index * batch_size:(index + 1) * batch_size], 485 | y: valid_set_y[index * batch_size:(index + 1) * batch_size] 486 | } 487 | ) 488 | 489 | # start-snippet-5 490 | # compute the gradient of cost with respect to theta (sotred in params) 491 | # the resulting gradients will be stored in a list gparams 492 | gparams = [T.grad(cost, param) for param in classifier.params] 493 | 494 | # specify how to update the parameters of the model as a list of 495 | # (variable, update expression) pairs 496 | 497 | # given two lists of the same length, A = [a1, a2, a3, a4] and 498 | # B = [b1, b2, b3, b4], zip generates a list C of same size, where each 499 | # element is a pair formed from the two lists : 500 | # C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)] 501 | updates = [ 502 | (param, param - learning_rate * gparam) 503 | for param, gparam in zip(classifier.params, gparams) 504 | ] 505 | 506 | # compiling a Theano function `train_model` that returns the cost, but 507 | # in the same time updates the parameter of the model based on the rules 508 | # defined in `updates` 509 | train_model = theano.function( 510 | inputs=[index], 511 | outputs=cost, 512 | updates=updates, 513 | givens={ 514 | x: train_set_x[index * batch_size: (index + 1) * batch_size], 515 | y: train_set_y[index * batch_size: (index + 1) * batch_size] 516 | } 517 | ) 518 | # end-snippet-5 519 | 520 | ############### 521 | # TRAIN MODEL # 522 | ############### 523 | print('... training') 524 | 525 | # early-stopping parameters 526 | patience = 10000 # look as this many examples regardless 527 | patience_increase = 2 # wait this much longer when a new best is 528 | # found 529 | improvement_threshold = 0.995 # a relative improvement of this much is 530 | # considered significant 531 | validation_frequency = min(n_train_batches, patience // 2) 532 | # go through this many 533 | # minibatche before checking the network 534 | # on the validation set; in this case we 535 | # check every epoch 536 | 537 | best_validation_loss = numpy.inf 538 | best_iter = 0 539 | test_score = 0. 540 | start_time = timeit.default_timer() 541 | 542 | epoch = 0 543 | done_looping = False 544 | 545 | while (epoch < n_epochs) and (not done_looping): 546 | epoch = epoch + 1 547 | for minibatch_index in range(n_train_batches): 548 | 549 | minibatch_avg_cost = train_model(minibatch_index) 550 | # iteration number 551 | iter = (epoch - 1) * n_train_batches + minibatch_index 552 | 553 | if (iter + 1) % validation_frequency == 0: 554 | # compute zero-one loss on validation set 555 | validation_losses = [validate_model(i) for i 556 | in range(n_valid_batches)] 557 | this_validation_loss = numpy.mean(validation_losses) 558 | 559 | print( 560 | 'epoch %i, minibatch %i/%i, validation error %f %%' % 561 | ( 562 | epoch, 563 | minibatch_index + 1, 564 | n_train_batches, 565 | this_validation_loss * 100. 566 | ) 567 | ) 568 | 569 | # if we got the best validation score until now 570 | if this_validation_loss < best_validation_loss: 571 | #improve patience if loss improvement is good enough 572 | if ( 573 | this_validation_loss < best_validation_loss * 574 | improvement_threshold 575 | ): 576 | patience = max(patience, iter * patience_increase) 577 | 578 | best_validation_loss = this_validation_loss 579 | best_iter = iter 580 | 581 | # test it on the test set 582 | test_losses = [test_model(i) for i 583 | in range(n_test_batches)] 584 | test_score = numpy.mean(test_losses) 585 | 586 | print((' epoch %i, minibatch %i/%i, test error of ' 587 | 'best model %f %%') % 588 | (epoch, minibatch_index + 1, n_train_batches, 589 | test_score * 100.)) 590 | 591 | if patience <= iter: 592 | done_looping = True 593 | break 594 | 595 | end_time = timeit.default_timer() 596 | print(('Optimization complete. Best validation score of %f %% ' 597 | 'obtained at iteration %i, with test performance %f %%') % 598 | (best_validation_loss * 100., best_iter + 1, test_score * 100.)) 599 | print(('The code for file ' + 600 | os.path.split(__file__)[1] + 601 | ' ran for %.2fm' % ((end_time - start_time) / 60.)), file=sys.stderr) 602 | 603 | 604 | if __name__ == '__main__': 605 | test_mlp() -------------------------------------------------------------------------------- /theano_src/Optimization.py: -------------------------------------------------------------------------------- 1 | import theano 2 | import theano.tensor as T 3 | from collections import defaultdict, OrderedDict 4 | import numpy as np 5 | 6 | def as_floatX(variable): 7 | if isinstance(variable, float): 8 | return np.cast[theano.config.floatX](variable) 9 | 10 | if isinstance(variable, np.ndarray): 11 | return np.cast[theano.config.floatX](variable) 12 | return theano.tensor.cast(variable, theano.config.floatX) 13 | 14 | 15 | 16 | class RMSprop(object): 17 | def RMSprop(self,cost, params, lr=0.001, rho=0.9, epsilon=1e-6): 18 | grads = T.grad(cost=cost, wrt=params) 19 | updates = [] 20 | for p, g in zip(params, grads): 21 | acc = theano.shared(p.get_value() * 0.) 22 | acc_new = rho * acc + (1 - rho) * g ** 2 23 | gradient_scaling = T.sqrt(acc_new + epsilon) 24 | g = g / gradient_scaling 25 | updates.append((acc, acc_new)) 26 | updates.append((p, p - lr * g)) 27 | return updates 28 | 29 | 30 | class Adam(object): 31 | def Adam(self,cost, params, lr=0.0002, b1=0.1, b2=0.001, e=1e-8): 32 | updates = [] 33 | grads = T.grad(cost, params) 34 | i = theano.shared(as_floatX(0.)) 35 | i_t = i + 1. 36 | fix1 = 1. - (1. - b1)**i_t 37 | fix2 = 1. - (1. - b2)**i_t 38 | lr_t = lr * (T.sqrt(fix2) / fix1) 39 | for p, g in zip(params, grads): 40 | m = theano.shared(p.get_value() * 0.) 41 | v = theano.shared(p.get_value() * 0.) 42 | m_t = (b1 * g) + ((1. - b1) * m) 43 | v_t = (b2 * T.sqr(g)) + ((1. - b2) * v) 44 | g_t = m_t / (T.sqrt(v_t) + e) 45 | p_t = p - (lr_t * g_t) 46 | updates.append((m, m_t)) 47 | updates.append((v, v_t)) 48 | updates.append((p, p_t)) 49 | updates.append((i, i_t)) 50 | return updates 51 | 52 | class Adadelta(object): 53 | def sgd_updates_adadelta(self,params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'): 54 | """ 55 | adadelta update rule, mostly from 56 | https://groups.google.com/forum/#!topic/pylearn-dev/3QbKtCumAW4 (for Adadelta) 57 | """ 58 | updates = OrderedDict({}) 59 | exp_sqr_grads = OrderedDict({}) 60 | exp_sqr_ups = OrderedDict({}) 61 | gparams = [] 62 | for param in params: 63 | empty = np.zeros_like(param.get_value()) 64 | exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name="exp_grad_%s" % param.name) 65 | gp = T.grad(cost, param) 66 | exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name="exp_grad_%s" % param.name) 67 | gparams.append(gp) 68 | for param, gp in zip(params, gparams): 69 | exp_sg = exp_sqr_grads[param] 70 | exp_su = exp_sqr_ups[param] 71 | up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp) 72 | updates[exp_sg] = up_exp_sg 73 | step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp 74 | updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step) 75 | stepped_param = param + step 76 | if (param.get_value(borrow=True).ndim == 2) and (param.name!='Words'): 77 | col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0)) 78 | desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim)) 79 | scale = desired_norms / (1e-7 + col_norms) 80 | updates[param] = stepped_param * scale 81 | else: 82 | updates[param] = stepped_param 83 | return updates 84 | -------------------------------------------------------------------------------- /theano_src/PreProcess.py: -------------------------------------------------------------------------------- 1 | import cPickle 2 | from collections import defaultdict 3 | import logging 4 | import theano 5 | import gensim 6 | import numpy as np 7 | from random import shuffle 8 | from gensim.models.word2vec import Word2Vec 9 | import codecs 10 | logger = logging.getLogger('relevance_logger') 11 | 12 | 13 | def build_multiturn_data(trainfile, max_len = 100,isshuffle=False): 14 | revs = [] 15 | vocab = defaultdict(float) 16 | total = 1 17 | with codecs.open(trainfile,'r','utf-8') as f: 18 | for line in f: 19 | line = line.replace("_","") 20 | parts = line.strip().split("\t") 21 | 22 | lable = parts[0] 23 | message = "" 24 | words = set() 25 | for i in range(1,len(parts)-1,1): 26 | message += "_t_" 27 | message += parts[i] 28 | words.update(set(parts[i].split())) 29 | 30 | response = parts[-1] 31 | 32 | data = {"y" : lable, "m":message,"r": response} 33 | revs.append(data) 34 | total += 1 35 | if total % 10000 == 0: 36 | print total 37 | #words = set(message.split()) 38 | words.update(set(response.split())) 39 | 40 | for word in words: 41 | vocab[word] += 1 42 | logger.info("processed dataset with %d question-answer pairs " %(len(revs))) 43 | logger.info("vocab size: %d" %(len(vocab))) 44 | if isshuffle == True: 45 | shuffle(revs) 46 | return revs, vocab, max_len 47 | 48 | 49 | def build_data(trainfile, max_len = 20,isshuffle=False): 50 | revs = [] 51 | vocab = defaultdict(float) 52 | total = 1 53 | with codecs.open(trainfile,'r','utf-8') as f: 54 | for line in f: 55 | line = line.replace("_","") 56 | parts = line.strip().split("\t") 57 | 58 | topic = parts[0] 59 | topic_r = parts[1] 60 | lable = parts[2] 61 | message = parts[-2] 62 | response = parts[-1] 63 | 64 | data = {"y" : lable, "m":message,"r": response,"t":topic,"t2":topic_r} 65 | revs.append(data) 66 | total += 1 67 | 68 | words = set(message.split()) 69 | words.update(set(response.split())) 70 | for word in words: 71 | vocab[word] += 1 72 | logger.info("processed dataset with %d question-answer pairs " %(len(revs))) 73 | logger.info("vocab size: %d" %(len(vocab))) 74 | if isshuffle == True: 75 | shuffle(revs) 76 | return revs, vocab, max_len 77 | 78 | class WordVecs(object): 79 | def __init__(self, fname, vocab, binary, gensim): 80 | if gensim: 81 | word_vecs = self.load_gensim(fname,vocab) 82 | self.k = len(word_vecs.values()[0]) 83 | self.W, self.word_idx_map = self.get_W(word_vecs, k=self.k) 84 | 85 | def get_W(self, word_vecs, k=300): 86 | """ 87 | Get word matrix. W[i] is the vector for word indexed by i 88 | """ 89 | vocab_size = len(word_vecs) 90 | word_idx_map = dict() 91 | W = np.zeros(shape=(vocab_size+1, k)) 92 | W[0] = np.zeros(k) 93 | i = 1 94 | for word in word_vecs: 95 | W[i] = word_vecs[word] 96 | word_idx_map[word] = i 97 | i += 1 98 | return W, word_idx_map 99 | 100 | def load_gensim(self, fname, vocab): 101 | model = Word2Vec.load(fname) 102 | weights = [[0.] * model.vector_size] 103 | word_vecs = {} 104 | total_inside_new_embed = 0 105 | miss= 0 106 | for pair in vocab: 107 | word = gensim.utils.to_unicode(pair) 108 | if word in model: 109 | total_inside_new_embed += 1 110 | word_vecs[pair] = np.array([w for w in model[word]]) 111 | #weights.append([w for w in model[word]]) 112 | else: 113 | miss = miss + 1 114 | word_vecs[pair] = np.array([0.] * model.vector_size) 115 | #weights.append([0.] * model.vector_size) 116 | print 'transfer', total_inside_new_embed, 'words from the embedding file, total', len(vocab), 'candidate' 117 | print 'miss word2vec', miss 118 | return word_vecs 119 | 120 | def createtopicvec(): 121 | max_topicword = 50 122 | model = Word2Vec.load_word2vec_format(r"\\msra-sandvm-001\v-wuyu\Models\W2V\Ubuntu\word2vec.model") 123 | topicmatrix = np.zeros(shape=(100,max_topicword,100),dtype=theano.config.floatX) 124 | file = open(r"\\msra-sandvm-001\v-wuyu\project\pythonproject\ACL2016\mergedic2.txt") 125 | i = 0 126 | miss = 0 127 | for line in file: 128 | tmp = line.strip().split(' ') 129 | for j in range(min(len(tmp),max_topicword)): 130 | if gensim.utils.to_unicode(tmp[j]) in model.vocab: 131 | topicmatrix[i,j,:] = model[gensim.utils.to_unicode(tmp[j])] 132 | else: 133 | miss = miss+1 134 | 135 | i= i+1 136 | print "miss word2vec", miss 137 | return topicmatrix 138 | 139 | def ParseSingleTurn(): 140 | logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO) 141 | revs, vocab, max_len = build_data(r"\\msra-sandvm-001\v-wuyu\Data\ubuntu_data\ubuntu_data\train.topic",isshuffle=True) 142 | word2vec = WordVecs(r"\\msra-sandvm-001\v-wuyu\Models\W2V\Ubuntu\word2vec.model", vocab, True, True) 143 | cPickle.dump([revs, word2vec, max_len,createtopicvec()], open("ubuntu_data.test",'wb')) 144 | logger.info("dataset created!") 145 | 146 | def ParseMultiTurn(): 147 | logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO) 148 | revs, vocab, max_len = build_multiturn_data(r"\\msra-sandvm-001\v-wuyu\Data\ubuntu_data\ubuntu_data\test.txt",isshuffle=False) 149 | word2vec = WordVecs(r"\\msra-sandvm-001\v-wuyu\Models\W2V\Ubuntu\word2vec.model", vocab, True, True) 150 | cPickle.dump([revs, word2vec, max_len], open("ubuntu_data.mul.test",'wb')) 151 | logger.info("dataset created!") 152 | 153 | if __name__=="__main__": 154 | ParseMultiTurn() -------------------------------------------------------------------------------- /theano_src/RNN.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import theano 3 | import theano.tensor as T 4 | from sklearn.base import BaseEstimator 5 | import logging 6 | import time 7 | import os 8 | import datetime 9 | import cPickle as pickle 10 | 11 | def ortho_weight(ndim): 12 | W = np.random.randn(ndim, ndim) 13 | u, s, v = np.linalg.svd(W) 14 | return u.astype('float32') 15 | 16 | 17 | # weight initializer, normal by default 18 | def norm_weight(nin, nout=None, scale=0.01, ortho=False): 19 | if nout is None: 20 | nout = nin 21 | if nout == nin and ortho: 22 | W = ortho_weight(nin) 23 | else: 24 | W = scale * np.random.randn(nin, nout) 25 | return W.astype('float32') 26 | def uniform_weight(size,scale=0.1): 27 | return np.random.uniform(size=size,low=-scale, high=scale).astype(theano.config.floatX) 28 | 29 | 30 | def glorot_uniform(size): 31 | fan_in, fan_out = size 32 | s = np.sqrt(6. / (fan_in + fan_out)) 33 | return np.random.uniform(size=size,low=-s, high=s).astype(theano.config.floatX) 34 | 35 | 36 | class BiGRU(object): 37 | def __init__(self, n_in, n_hidden, n_out, activation=T.tanh,inner_activation=T.nnet.sigmoid, 38 | output_type='real',batch_size=200): 39 | 40 | self.gru_1 = GRU(n_in,n_hidden,n_out,batch_size=batch_size) 41 | self.gru_2 = GRU(n_in,n_hidden,n_out,batch_size=batch_size) 42 | 43 | self.params = self.gru_1.params 44 | self.params += self.gru_2.params 45 | 46 | def __call__(self, input, input_lm=None, return_list = False): 47 | reverse_input = input[:,::-1,:] 48 | reverse_mask = input_lm[:,::-1] 49 | 50 | res1 = self.gru_1(input,input_lm,return_list) 51 | if return_list == True: 52 | res2 = self.gru_2(reverse_input,reverse_mask,return_list)[:,::-1,:] 53 | return T.concatenate([res1,res2],2) 54 | else: 55 | res2 = self.gru_2(reverse_input,reverse_mask,return_list) 56 | return T.concatenate([res1,res2],1) 57 | 58 | 59 | class GRU(object): 60 | def __init__(self, n_in, n_hidden, n_out, activation=T.tanh,inner_activation=T.nnet.sigmoid, 61 | output_type='real',batch_size=200): 62 | 63 | self.activation = activation 64 | self.inner_activation = inner_activation 65 | self.output_type = output_type 66 | 67 | self.batch_size = batch_size 68 | self.n_hidden = n_hidden 69 | 70 | # recurrent weights as a shared variable 71 | self.U_z = theano.shared(ortho_weight(n_hidden),borrow=True) 72 | self.W_z = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 73 | self.b_z = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 74 | 75 | self.U_r = theano.shared(ortho_weight(n_hidden),borrow=True) 76 | self.W_r = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 77 | self.b_r = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 78 | 79 | self.U_h = theano.shared(ortho_weight(n_hidden),borrow=True) 80 | self.W_h = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 81 | self.b_h = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 82 | 83 | 84 | self.params = [self.W_z,self.W_h,self.W_r, 85 | self.U_h,self.U_r,self.U_z, 86 | self.b_h,self.b_r,self.b_z] 87 | 88 | def __call__(self, input,input_lm=None, return_list = False, Init_input =None,check_gate = False): 89 | # activation function 90 | if Init_input == None: 91 | init = theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 92 | dtype=theano.config.floatX),borrow=True) 93 | else: 94 | init = Init_input 95 | 96 | if check_gate: 97 | self.h_l, _ = theano.scan(self.step3, 98 | sequences=[input.dimshuffle(1,0,2),T.addbroadcast(input_lm.dimshuffle(1,0,'x'), -1)], 99 | outputs_info=[init, theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 100 | dtype=theano.config.floatX),borrow=True)]) 101 | return [self.h_l[0][:,-1,:], self.h_l[1]] 102 | 103 | 104 | 105 | if input_lm == None: 106 | self.h_l, _ = theano.scan(self.step2, 107 | sequences=input.dimshuffle(1,0,2), 108 | outputs_info=init) 109 | else: 110 | self.h_l, _ = theano.scan(self.step, 111 | sequences=[input.dimshuffle(1,0,2),T.addbroadcast(input_lm.dimshuffle(1,0,'x'), -1)], 112 | outputs_info=init) 113 | self.h_l = self.h_l.dimshuffle(1,0,2) 114 | if return_list == True: 115 | return self.h_l 116 | return self.h_l[:,-1,:] 117 | 118 | def step2(self,x_t, h_tm1): 119 | x_z = T.dot(x_t, self.W_z) + self.b_z 120 | x_r = T.dot(x_t, self.W_r) + self.b_r 121 | x_h = T.dot(x_t, self.W_h) + self.b_h 122 | z = self.inner_activation(x_z + T.dot(h_tm1, self.U_z)) 123 | r = self.inner_activation(x_r + T.dot(h_tm1, self.U_r)) 124 | 125 | hh = self.activation(x_h + T.dot(r * h_tm1, self.U_h)) 126 | h = z * h_tm1 + (1 - z) * hh 127 | return h 128 | def step3(self,x_t,mask, h_tm1, gate_tm1): 129 | #h_tm1 = mask * h_tm1 130 | x_z = T.dot(x_t, self.W_z) + self.b_z 131 | x_r = T.dot(x_t, self.W_r) + self.b_r 132 | x_h = T.dot(x_t, self.W_h) + self.b_h 133 | z = self.inner_activation(x_z + T.dot(h_tm1, self.U_z)) 134 | r = self.inner_activation(x_r + T.dot(h_tm1, self.U_r)) 135 | 136 | hh = self.activation(x_h + T.dot(r * h_tm1, self.U_h)) 137 | h = z * h_tm1 + (1 - z) * hh 138 | h = mask * h + (1-mask) * h_tm1 139 | 140 | return [h,r] 141 | 142 | def step(self,x_t,mask, h_tm1): 143 | #h_tm1 = mask * h_tm1 144 | x_z = T.dot(x_t, self.W_z) + self.b_z 145 | x_r = T.dot(x_t, self.W_r) + self.b_r 146 | x_h = T.dot(x_t, self.W_h) + self.b_h 147 | z = self.inner_activation(x_z + T.dot(h_tm1, self.U_z)) 148 | r = self.inner_activation(x_r + T.dot(h_tm1, self.U_r)) 149 | 150 | hh = self.activation(x_h + T.dot(r * h_tm1, self.U_h)) 151 | h = z * h_tm1 + (1 - z) * hh 152 | h = mask * h + (1-mask) * h_tm1 153 | 154 | return h 155 | 156 | 157 | class LSTM(object): 158 | def __init__(self,n_in, n_hidden, n_out, activation=T.tanh,inner_activation=T.nnet.sigmoid, 159 | output_type='real',batch_size=200): 160 | self.activation = activation 161 | self.inner_activation = inner_activation 162 | self.output_type = output_type 163 | 164 | self.batch_size = batch_size 165 | self.n_hidden = n_hidden 166 | 167 | self.W_i = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 168 | self.U_i = theano.shared(ortho_weight(n_hidden),borrow=True) 169 | self.b_i = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 170 | 171 | self.W_f = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 172 | self.U_f = theano.shared(ortho_weight(n_hidden),borrow=True) 173 | self.b_f = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 174 | 175 | self.W_c = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 176 | self.U_c = theano.shared(ortho_weight(n_hidden),borrow=True) 177 | self.b_c = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 178 | 179 | self.W_o = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True) 180 | self.U_o = theano.shared(ortho_weight(n_hidden),borrow=True) 181 | self.b_o = theano.shared(value=np.zeros((n_hidden,),dtype=theano.config.floatX),borrow=True) 182 | 183 | self.params = [self.W_i, self.U_i, self.b_i, 184 | self.W_c, self.U_c, self.b_c, 185 | self.W_f, self.U_f, self.b_f, 186 | self.W_o, self.U_o, self.b_o] 187 | def __call__(self, input,input_lm=None, return_list = False): 188 | # activation function 189 | if input_lm == None: 190 | self.h_l, _ = theano.scan(self.step2, 191 | sequences=input.dimshuffle(1,0,2), 192 | outputs_info=[theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 193 | dtype=theano.config.floatX),borrow=True), 194 | theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 195 | dtype=theano.config.floatX),borrow=True)]) 196 | else: 197 | self.h_l, _ = theano.scan(self.step, 198 | sequences=[input.dimshuffle(1,0,2),T.addbroadcast(input_lm.dimshuffle(1,0,'x'), -1)], 199 | outputs_info=[theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 200 | dtype=theano.config.floatX),borrow=True), 201 | theano.shared(value=np.zeros((self.batch_size,self.n_hidden), 202 | dtype=theano.config.floatX),borrow=True)]) 203 | self.h_l = self.h_l[0].dimshuffle(1,0,2) 204 | if return_list == True: 205 | return self.h_l 206 | return self.h_l[:,-1,:] 207 | 208 | def step(self,x_t,mask, h_tm1,c_tm1): 209 | #h_tm1 = mask * h_tm1 210 | #c_tm1 = mask * c_tm1 211 | x_i =T.dot(x_t, self.W_i) + self.b_i 212 | x_f =T.dot(x_t, self.W_f) + self.b_f 213 | x_c =T.dot(x_t, self.W_c) + self.b_c 214 | x_o =T.dot(x_t, self.W_o) + self.b_o 215 | 216 | i = self.inner_activation(x_i + T.dot(h_tm1, self.U_i)) 217 | f = self.inner_activation(x_f + T.dot(h_tm1, self.U_f)) 218 | c = f * c_tm1 + i * self.activation(x_c + T.dot(h_tm1, self.U_c)) 219 | o = self.inner_activation(x_o + T.dot(h_tm1, self.U_o)) 220 | h = o * self.activation(c) 221 | 222 | h = mask * h + (1-mask) * h_tm1 223 | c = mask * c + (1-mask) * c_tm1 224 | 225 | return [h, c] 226 | 227 | def step2(self,x_t, h_tm1,c_tm1): 228 | #h_tm1 = mask * h_tm1 229 | x_i =T.dot(x_t, self.W_i) + self.b_i 230 | x_f =T.dot(x_t, self.W_f) + self.b_f 231 | x_c =T.dot(x_t, self.W_c) + self.b_c 232 | x_o =T.dot(x_t, self.W_o) + self.b_o 233 | 234 | i = self.inner_activation(x_i + T.dot(h_tm1, self.U_i)) 235 | f = self.inner_activation(x_f + T.dot(h_tm1, self.U_f)) 236 | c = f * c_tm1 + i * self.activation(x_c + T.dot(h_tm1, self.U_c)) 237 | o = self.inner_activation(x_o + T.dot(h_tm1, self.U_o)) 238 | h = o * self.activation(c) 239 | return [h, c] 240 | 241 | class RNN(object): 242 | def __init__(self, input_l, input_r, n_in, n_hidden, n_out, activation=T.tanh, 243 | output_type='real',batch_size=200,input_lm=None,input_rm=None): 244 | if input_lm == None: 245 | input_lm = theano.shared(value=np.ones((batch_size,20), dtype=theano.config.floatX),borrow=True) 246 | if input_rm == None: 247 | input_rm = theano.shared(value=np.ones((batch_size,20), dtype=theano.config.floatX),borrow=True) 248 | self.activation = activation 249 | self.output_type = output_type 250 | # Parameters are reshaped views of theta 251 | param_idx = 0 # pointer to somewhere along parameter vector 252 | 253 | # recurrent weights as a shared variable 254 | self.W = theano.shared(ortho_weight(n_hidden),borrow=True,name='W') 255 | # input to hidden layer weights 256 | self.W_in = theano.shared(glorot_uniform((n_in,n_hidden)),borrow=True,name='W_in') 257 | 258 | self.h0 = theano.shared(value=np.zeros((batch_size,n_hidden), dtype=theano.config.floatX),borrow=True,name='h0') 259 | self.bh = theano.shared(value=np.zeros((batch_size,n_hidden), dtype=theano.config.floatX),borrow=True,name='bh') 260 | #self.by = theano.shared(value=np.zeros((n_out,), dtype=theano.config.floatX),borrow=True,name='by') 261 | # for convenience 262 | self.params = [self.W, self.W_in, self.bh] 263 | 264 | # activation function 265 | def step(x_t, mask, h_tm1): 266 | h_tm1 = mask * h_tm1 267 | #h_t = h_tm1 + self.bh 268 | h_t = T.tanh(T.dot(x_t, self.W_in) + \ 269 | T.dot(h_tm1, self.W) + self.bh) 270 | #y_t = T.dot(h_t, self.W_out) + self.by 271 | return h_t 272 | #a = T.addbroadcast(input_lm.dimshuffle(1,0), -1) 273 | self.h_l, _ = theano.scan(step, 274 | sequences=[input_l.dimshuffle(1,0,2),T.addbroadcast(input_lm.dimshuffle(1,0,'x'), -1)], 275 | outputs_info=theano.shared(value=np.zeros((batch_size,n_hidden), dtype=theano.config.floatX),borrow=True)) 276 | self.h_r, _ = theano.scan(step, 277 | sequences=[input_r.dimshuffle(1,0,2),T.addbroadcast(input_rm.dimshuffle(1,0,'x'), -1)], 278 | outputs_info=theano.shared(value=np.zeros((batch_size,n_hidden), dtype=theano.config.floatX),borrow=True)) 279 | self.h_l = self.h_l.dimshuffle(1,0,2) 280 | self.h_r = self.h_r.dimshuffle(1,0,2) 281 | 282 | 283 | if __name__=="__main__": 284 | input = T.tensor3() 285 | input2 = T.matrix() 286 | rnn = GRU(100,100,100,batch_size=47) 287 | res = rnn(input,input2,check_gate=True) 288 | output = theano.function([input,input2],[res[1]]) 289 | 290 | 291 | print output(np.random.rand(47,20,100).astype('float32'), 292 | np.ones((47,20)).astype('float32'))[0].shape -------------------------------------------------------------------------------- /theano_src/SMN_Dynamic.py: -------------------------------------------------------------------------------- 1 | import cPickle 2 | from RNN import GRU 3 | import numpy as np 4 | import theano 5 | from gensim.models.word2vec import Word2Vec 6 | from PreProcess import WordVecs 7 | from Classifier import LogisticRegression 8 | from Optimization import Adam 9 | import theano.tensor as T 10 | from SimAsImage import ConvSim 11 | 12 | max_turn = 10 13 | def get_idx_from_sent_msg(sents, word_idx_map, max_l=50,mask = False): 14 | """ 15 | Transforms sentence into a list of indices. Pad with zeroes. 16 | """ 17 | turns = [] 18 | for sent in sents.split('_t_'): 19 | x = [0] * max_l 20 | x_mask = [0.] * max_l 21 | words = sent.split() 22 | length = len(words) 23 | for i, word in enumerate(words): 24 | if max_l - length + i < 0: continue 25 | if word in word_idx_map: 26 | x[max_l - length + i] = word_idx_map[word] 27 | #if x[max_l - length + i] != 0: 28 | x_mask[max_l - length + i] = 1 29 | if mask: 30 | x += x_mask 31 | turns.append(x) 32 | 33 | final = [0.] * (max_l * 2 * max_turn) 34 | for i in range(max_turn): 35 | if max_turn - i <= len(turns): 36 | for j in range(max_l * 2): 37 | final[i*(max_l*2) + j] = turns[-(max_turn-i)][j] 38 | #print final 39 | #print sents 40 | return final 41 | 42 | def get_idx_from_sent(sent, word_idx_map, max_l=50,mask = False): 43 | """ 44 | Transforms sentence into a list of indices. Pad with zeroes. 45 | """ 46 | x = [0] * max_l 47 | x_mask = [0.] * max_l 48 | words = sent.split() 49 | length = len(words) 50 | for i, word in enumerate(words): 51 | if max_l - length + i < 0: continue 52 | if word in word_idx_map: 53 | x[max_l - length + i] = word_idx_map[word] 54 | #if x[max_l - length + i] != 0: 55 | x_mask[max_l - length + i] = 1 56 | if mask: 57 | x += x_mask 58 | return x 59 | 60 | def _dropout_from_layer(rng, layer, p): 61 | """p is the probablity of dropping a unit 62 | """ 63 | srng = theano.tensor.shared_randomstreams.RandomStreams( 64 | rng.randint(999999)) 65 | # p=1-p because 1's indicate keep and p is prob of dropping 66 | mask = srng.binomial(n=1, p=1-p, size=layer.shape) 67 | # The cast is important because 68 | # int * float32 = float64 which pulls things off the gpu 69 | output = layer * T.cast(mask, theano.config.floatX) 70 | return output 71 | 72 | 73 | def predict(datasets, 74 | U, # pre-trained word embeddings 75 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 76 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): # for optimization 77 | """ 78 | return: a list of dicts of lists, each list contains (ansId, groundTruth, prediction) for a question 79 | """ 80 | hiddensize = hidden_size 81 | U = U.astype(dtype=theano.config.floatX) 82 | rng = np.random.RandomState(3435) 83 | lsize, rsize = max_l,max_l 84 | sessionmask = T.matrix() 85 | lx = [] 86 | lxmask = [] 87 | for i in range(max_turn): 88 | lx.append(T.matrix()) 89 | lxmask.append(T.matrix()) 90 | 91 | index = T.lscalar() 92 | rx = T.matrix('rx') 93 | rxmask = T.matrix() 94 | y = T.ivector('y') 95 | Words = theano.shared(value = U, name = "Words") 96 | llayer0_input = [] 97 | for i in range(max_turn): 98 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 99 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 100 | 101 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 102 | 103 | 104 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 105 | 106 | train_set_lx = [] 107 | train_set_lx_mask = [] 108 | q_embedding = [] 109 | offset = 2 * lsize 110 | for i in range(max_turn): 111 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 112 | ,dtype=theano.config.floatX),borrow=True)) 113 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 114 | ,dtype=theano.config.floatX),borrow=True)) 115 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 116 | ,dtype=theano.config.floatX),borrow=True) 117 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 118 | ,dtype=theano.config.floatX),borrow=True) 119 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 120 | ,dtype=theano.config.floatX),borrow=True) 121 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 122 | 123 | val_set_lx = [] 124 | val_set_lx_mask = [] 125 | for i in range(max_turn): 126 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 127 | ,dtype=theano.config.floatX),borrow=True)) 128 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 129 | ,dtype=theano.config.floatX),borrow=True)) 130 | 131 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 132 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 133 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 134 | ,dtype=theano.config.floatX),borrow=True) 135 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 136 | 137 | dic = {} 138 | for i in range(max_turn): 139 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 140 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 141 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 142 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 143 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 144 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 145 | 146 | val_dic = {} 147 | for i in range(max_turn): 148 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 149 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 150 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 151 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 152 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 153 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 154 | 155 | 156 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 157 | 158 | for i in range(max_turn): 159 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 160 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 161 | 162 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 163 | 164 | poolingoutput = [] 165 | 166 | 167 | for i in range(max_turn): 168 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 169 | q_embedding[i],r_embedding)) 170 | 171 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 172 | res = session2vec(T.stack(poolingoutput,1),sessionmask,True) 173 | 174 | W = theano.shared(ortho_weight(50),borrow = True) 175 | W2 = theano.shared(glorot_uniform((100,50)),borrow=True) 176 | b = theano.shared(value=np.zeros((50,),dtype='float32'),borrow=True) 177 | U_s = theano.shared(glorot_uniform((50,1)),borrow = True) 178 | 179 | final = T.dot(T.tanh(T.dot(res,W) + T.dot(T.stack(q_embedding,1)[:,:,-1,:],W2) + b),U_s) 180 | 181 | weight = T.exp(T.max(final,2)) * sessionmask 182 | weight2 = weight / T.sum(weight,1)[:,None] 183 | 184 | final2 = T.sum(res *weight2[:,:,None],1) 185 | 186 | classifier = LogisticRegression(final2, session_hidden_size, 2, rng) 187 | 188 | 189 | test = theano.function([index], final2 190 | ,givens=val_dic,on_unused_input='ignore') 191 | print test(0).shape 192 | print test(0) 193 | 194 | cost = classifier.negative_log_likelihood(y) 195 | error = classifier.errors(y) 196 | opt = Adam() 197 | params = classifier.params 198 | params += sentence2vec.params 199 | params += session2vec.params 200 | params += pooling_layer.params 201 | params += [Words,W,b,W2,U_s] 202 | 203 | load_params(params,model_name) 204 | 205 | predict = classifier.predict_prob 206 | 207 | val_model = theano.function([index], [y,predict,cost,error], givens=val_dic 208 | ,on_unused_input='ignore') 209 | f = open('result.txt','w') 210 | loss = 0. 211 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 212 | a,b,c,d = val_model(minibatch_index) 213 | print c 214 | loss += c 215 | #print b.shape 216 | for i in range(batch_size): 217 | f.write(str(b[i][1])) 218 | f.write('\t') 219 | f.write(str(a[i])) 220 | f.write('\n') 221 | #print b[i] 222 | print loss/(datasets[1].shape[0]/batch_size) 223 | 224 | def ortho_weight(ndim): 225 | W = np.random.randn(ndim, ndim) 226 | u, s, v = np.linalg.svd(W) 227 | return u.astype('float32') 228 | def load_params(params,filename): 229 | f = open(filename) 230 | num_params = cPickle.load(f) 231 | for p,w in zip(params,num_params): 232 | p.set_value(w.astype('float32'),borrow=True) 233 | print "load successfully" 234 | def glorot_uniform(size): 235 | fan_in, fan_out = size 236 | s = np.sqrt(6. / (fan_in + fan_out)) 237 | print s 238 | return np.random.uniform(size=size,low=-s, high=s).astype(theano.config.floatX) 239 | def train(datasets, 240 | U, # pre-trained word embeddings 241 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 242 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): 243 | hiddensize = hidden_size 244 | U = U.astype(dtype=theano.config.floatX) 245 | rng = np.random.RandomState(3435) 246 | lsize, rsize = max_l,max_l 247 | sessionmask = T.matrix() 248 | lx = [] 249 | lxmask = [] 250 | for i in range(max_turn): 251 | lx.append(T.matrix()) 252 | lxmask.append(T.matrix()) 253 | 254 | index = T.lscalar() 255 | rx = T.matrix('rx') 256 | rxmask = T.matrix() 257 | y = T.ivector('y') 258 | Words = theano.shared(value = U, name = "Words") 259 | llayer0_input = [] 260 | for i in range(max_turn): 261 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 262 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 263 | 264 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 265 | 266 | 267 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 268 | 269 | train_set_lx = [] 270 | train_set_lx_mask = [] 271 | q_embedding = [] 272 | offset = 2 * lsize 273 | for i in range(max_turn): 274 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 275 | ,dtype=theano.config.floatX),borrow=True)) 276 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 277 | ,dtype=theano.config.floatX),borrow=True)) 278 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 279 | ,dtype=theano.config.floatX),borrow=True) 280 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 281 | ,dtype=theano.config.floatX),borrow=True) 282 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 283 | ,dtype=theano.config.floatX),borrow=True) 284 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 285 | 286 | val_set_lx = [] 287 | val_set_lx_mask = [] 288 | for i in range(max_turn): 289 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 290 | ,dtype=theano.config.floatX),borrow=True)) 291 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 292 | ,dtype=theano.config.floatX),borrow=True)) 293 | 294 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 295 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 296 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 297 | ,dtype=theano.config.floatX),borrow=True) 298 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 299 | 300 | dic = {} 301 | for i in range(max_turn): 302 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 303 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 304 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 305 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 306 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 307 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 308 | 309 | val_dic = {} 310 | for i in range(max_turn): 311 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 312 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 313 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 314 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 315 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 316 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 317 | 318 | 319 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 320 | 321 | for i in range(max_turn): 322 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 323 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 324 | 325 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 326 | 327 | poolingoutput = [] 328 | 329 | 330 | for i in range(max_turn): 331 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 332 | q_embedding[i],r_embedding)) 333 | 334 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 335 | res = session2vec(T.stack(poolingoutput,1),sessionmask,True) 336 | 337 | W = theano.shared(ortho_weight(50),borrow = True) 338 | W2 = theano.shared(glorot_uniform((100,50)),borrow=True) 339 | b = theano.shared(value=np.zeros((50,),dtype='float32'),borrow=True) 340 | U_s = theano.shared(glorot_uniform((50,1)),borrow = True) 341 | 342 | final = T.dot(T.tanh(T.dot(res,W) + T.dot(T.stack(q_embedding,1)[:,:,-1,:],W2) + b),U_s) 343 | 344 | weight = T.exp(T.max(final,2)) * sessionmask 345 | weight2 = weight / T.sum(weight,1)[:,None] 346 | 347 | final2 = T.sum(res *weight2[:,:,None],1) 348 | 349 | classifier = LogisticRegression(final2, session_hidden_size, 2, rng) 350 | 351 | 352 | test = theano.function([index], final2 353 | ,givens=val_dic,on_unused_input='ignore') 354 | print test(0).shape 355 | print test(0) 356 | 357 | cost = classifier.negative_log_likelihood(y) 358 | error = classifier.errors(y) 359 | opt = Adam() 360 | params = classifier.params 361 | params += sentence2vec.params 362 | params += session2vec.params 363 | params += pooling_layer.params 364 | params += [Words,W,b,W2,U_s] 365 | 366 | grad_updates = opt.Adam(cost=cost,params=params,lr = 0.001) #opt.sgd_updates_adadelta(params, cost, lr_decay, 1e-8, sqr_norm_lim) 367 | 368 | train_model = theano.function([index], cost,updates=grad_updates, givens=dic,on_unused_input='ignore') 369 | val_model = theano.function([index], [cost,error], givens=val_dic,on_unused_input='ignore') 370 | best_dev = 1. 371 | n_train_batches = datasets[0].shape[0]/batch_size 372 | for i in xrange(n_epochs): 373 | cost = 0 374 | total = 0. 375 | for minibatch_index in np.random.permutation(range(n_train_batches)): 376 | batch_cost = train_model(minibatch_index) 377 | total = total + 1 378 | cost = cost + batch_cost 379 | if total % 50 == 0: 380 | print total, cost/total 381 | cost = cost / n_train_batches 382 | print "echo %d loss %f" % (i,cost) 383 | 384 | cost=0 385 | errors = 0 386 | j = 0 387 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 388 | tcost, terr = val_model(minibatch_index) 389 | cost += tcost 390 | errors += terr 391 | j = j+1 392 | cost = cost / j 393 | errors = errors / j 394 | if cost < best_dev: 395 | best_dev = cost 396 | save_params(params,model_name) 397 | print "echo %d dev_loss %f" % (i,cost) 398 | print "echo %d dev_accuracy %f" % (i,1 - errors) 399 | 400 | def save_params(params,filename): 401 | num_params = [p.get_value() for p in params] 402 | f = open(filename,'wb') 403 | cPickle.dump(num_params,f) 404 | 405 | def get_session_mask(sents): 406 | session_mask = [0.] * max_turn 407 | turns = [] 408 | for sent in sents.split('_t_'): 409 | words = sent.split() 410 | if len(words) > 0: 411 | turns.append(len(words)) 412 | 413 | for i in range(max_turn): 414 | if max_turn - i <= len(turns): 415 | session_mask[-(max_turn-i)] = 1. 416 | #print session_mask 417 | return session_mask 418 | #print final 419 | 420 | 421 | def make_data(revs, word_idx_map, max_l=50, filter_h=3, val_test_splits=[2,3],validation_num = 50000): 422 | """ 423 | Transforms sentences into a 2-d matrix. 424 | """ 425 | train, val, test = [], [], [] 426 | for rev in revs: 427 | sent = get_idx_from_sent_msg(rev["m"], word_idx_map, max_l, True) 428 | sent += get_idx_from_sent(rev["r"], word_idx_map, max_l, True) 429 | sent += get_session_mask(rev["m"]) 430 | sent.append(int(rev["y"])) 431 | if len(val) > validation_num: 432 | train.append(sent) 433 | else: 434 | val.append(sent) 435 | 436 | train = np.array(train,dtype="int") 437 | val = np.array(val,dtype="int") 438 | test = np.array(test,dtype="int") 439 | print 'trainning data', len(train),'val data', len(val) 440 | return [train, val, test] 441 | 442 | if __name__=="__main__": 443 | train_flag = True 444 | max_word_per_utterence = 50 445 | dataset = r"../ubuntu_data.mul.100d.fullw2v.train" 446 | x = cPickle.load(open(dataset,"rb")) 447 | revs, wordvecs, max_l = x[0], x[1], x[2] 448 | 449 | if train_flag == False: 450 | x = cPickle.load(open(r"../ubuntu_data.mul.test","rb")) 451 | revs, wordvecs2, max_l2 = x[0], x[1], x[2] 452 | datasets = make_data(revs,wordvecs.word_idx_map,max_l=max_word_per_utterence) 453 | 454 | if train_flag == True: 455 | train(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 456 | ,hidden_size=100,word_embedding_size=100,model_name='SMN_Dynamic.bin') 457 | else: 458 | predict(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 459 | ,hidden_size=100,word_embedding_size=100,model_name='SMN_Dynamic.bin') -------------------------------------------------------------------------------- /theano_src/SMN_Last.py: -------------------------------------------------------------------------------- 1 | import cPickle 2 | from RNN import GRU 3 | import numpy as np 4 | import theano 5 | from gensim.models.word2vec import Word2Vec 6 | from PreProcess import WordVecs 7 | from Classifier import LogisticRegression 8 | from Optimization import Adam 9 | import theano.tensor as T 10 | from SimAsImage import ConvSim 11 | 12 | max_turn = 10 13 | def get_idx_from_sent_msg(sents, word_idx_map, max_l=50,mask = False): 14 | """ 15 | Transforms sentence into a list of indices. Pad with zeroes. 16 | """ 17 | turns = [] 18 | for sent in sents.split('_t_'): 19 | x = [0] * max_l 20 | x_mask = [0.] * max_l 21 | words = sent.split() 22 | length = len(words) 23 | for i, word in enumerate(words): 24 | if max_l - length + i < 0: continue 25 | if word in word_idx_map: 26 | x[max_l - length + i] = word_idx_map[word] 27 | #if x[max_l - length + i] != 0: 28 | x_mask[max_l - length + i] = 1 29 | if mask: 30 | x += x_mask 31 | turns.append(x) 32 | 33 | final = [0.] * (max_l * 2 * max_turn) 34 | for i in range(max_turn): 35 | if max_turn - i <= len(turns): 36 | for j in range(max_l * 2): 37 | final[i*(max_l*2) + j] = turns[-(max_turn-i)][j] 38 | #print final 39 | #print sents 40 | return final 41 | 42 | def get_idx_from_sent(sent, word_idx_map, max_l=50,mask = False): 43 | """ 44 | Transforms sentence into a list of indices. Pad with zeroes. 45 | """ 46 | x = [0] * max_l 47 | x_mask = [0.] * max_l 48 | words = sent.split() 49 | length = len(words) 50 | for i, word in enumerate(words): 51 | if max_l - length + i < 0: continue 52 | if word in word_idx_map: 53 | x[max_l - length + i] = word_idx_map[word] 54 | #if x[max_l - length + i] != 0: 55 | x_mask[max_l - length + i] = 1 56 | if mask: 57 | x += x_mask 58 | return x 59 | 60 | def _dropout_from_layer(rng, layer, p): 61 | """p is the probablity of dropping a unit 62 | """ 63 | srng = theano.tensor.shared_randomstreams.RandomStreams( 64 | rng.randint(999999)) 65 | # p=1-p because 1's indicate keep and p is prob of dropping 66 | mask = srng.binomial(n=1, p=1-p, size=layer.shape) 67 | # The cast is important because 68 | # int * float32 = float64 which pulls things off the gpu 69 | output = layer * T.cast(mask, theano.config.floatX) 70 | return output 71 | 72 | 73 | def predict(datasets, 74 | U, # pre-trained word embeddings 75 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 76 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): # for optimization 77 | """ 78 | return: a list of dicts of lists, each list contains (ansId, groundTruth, prediction) for a question 79 | """ 80 | hiddensize = hidden_size 81 | U = U.astype(dtype=theano.config.floatX) 82 | rng = np.random.RandomState(3435) 83 | lsize, rsize = max_l,max_l 84 | 85 | sessionmask = T.matrix() 86 | lx = [] 87 | lxmask = [] 88 | for i in range(max_turn): 89 | lx.append(T.matrix()) 90 | lxmask.append(T.matrix()) 91 | 92 | index = T.lscalar() 93 | rx = T.matrix('rx') 94 | rxmask = T.matrix() 95 | y = T.ivector('y') 96 | Words = theano.shared(value = U, name = "Words") 97 | llayer0_input = [] 98 | for i in range(max_turn): 99 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 100 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 101 | 102 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 103 | 104 | 105 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 106 | 107 | train_set_lx = [] 108 | train_set_lx_mask = [] 109 | q_embedding = [] 110 | offset = 2 * lsize 111 | for i in range(max_turn): 112 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 113 | ,dtype=theano.config.floatX),borrow=True)) 114 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 115 | ,dtype=theano.config.floatX),borrow=True)) 116 | #print train_set_lx.shape 117 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 118 | ,dtype=theano.config.floatX),borrow=True) 119 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 120 | ,dtype=theano.config.floatX),borrow=True) 121 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 122 | ,dtype=theano.config.floatX),borrow=True) 123 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 124 | 125 | val_set_lx = [] 126 | val_set_lx_mask = [] 127 | for i in range(max_turn): 128 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 129 | ,dtype=theano.config.floatX),borrow=True)) 130 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 131 | ,dtype=theano.config.floatX),borrow=True)) 132 | 133 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 134 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 135 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 136 | ,dtype=theano.config.floatX),borrow=True) 137 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 138 | 139 | dic = {} 140 | for i in range(max_turn): 141 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 142 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 143 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 144 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 145 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 146 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 147 | 148 | val_dic = {} 149 | for i in range(max_turn): 150 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 151 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 152 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 153 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 154 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 155 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 156 | 157 | 158 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 159 | 160 | for i in range(max_turn): 161 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 162 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 163 | 164 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 165 | 166 | poolingoutput = [] 167 | test = theano.function([index],pooling_layer(llayer0_input[-4],rlayer0_input, 168 | q_embedding[i],r_embedding) 169 | ,givens=val_dic,on_unused_input='ignore') 170 | print test(0).shape 171 | print test(0) 172 | 173 | for i in range(max_turn): 174 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 175 | q_embedding[i],r_embedding)) 176 | 177 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 178 | res = session2vec(T.stack(poolingoutput,1),sessionmask) 179 | classifier = LogisticRegression(res, session_hidden_size ,2,rng) 180 | 181 | cost = classifier.negative_log_likelihood(y) 182 | error = classifier.errors(y) 183 | opt = Adam() 184 | params = classifier.params 185 | params += sentence2vec.params 186 | params += session2vec.params 187 | params += pooling_layer.params 188 | params += [Words] 189 | 190 | 191 | load_params(params,model_name) 192 | 193 | predict = classifier.predict_prob 194 | 195 | val_model = theano.function([index], [y,predict,cost,error], givens=val_dic 196 | ,on_unused_input='ignore') 197 | f = open('result.txt','w') 198 | loss = 0. 199 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 200 | a,b,c,d = val_model(minibatch_index) 201 | print c 202 | loss += c 203 | #print b.shape 204 | for i in range(batch_size): 205 | f.write(str(b[i][1])) 206 | f.write('\t') 207 | f.write(str(a[i])) 208 | f.write('\n') 209 | #print b[i] 210 | print loss/(datasets[1].shape[0]/batch_size) 211 | 212 | 213 | def load_params(params,filename): 214 | f = open(filename) 215 | num_params = cPickle.load(f) 216 | for p,w in zip(params,num_params): 217 | p.set_value(w.astype('float32'),borrow=True) 218 | print "load successfully" 219 | 220 | def train(datasets, 221 | U, # pre-trained word embeddings 222 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 223 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): 224 | hiddensize = hidden_size 225 | U = U.astype(dtype=theano.config.floatX) 226 | rng = np.random.RandomState(3435) 227 | lsize, rsize = max_l,max_l 228 | sessionmask = T.matrix() 229 | lx = [] 230 | lxmask = [] 231 | for i in range(max_turn): 232 | lx.append(T.matrix()) 233 | lxmask.append(T.matrix()) 234 | 235 | index = T.lscalar() 236 | rx = T.matrix('rx') 237 | rxmask = T.matrix() 238 | y = T.ivector('y') 239 | Words = theano.shared(value = U, name = "Words") 240 | llayer0_input = [] 241 | for i in range(max_turn): 242 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 243 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 244 | 245 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 246 | 247 | 248 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 249 | 250 | train_set_lx = [] 251 | train_set_lx_mask = [] 252 | q_embedding = [] 253 | offset = 2 * lsize 254 | for i in range(max_turn): 255 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 256 | ,dtype=theano.config.floatX),borrow=True)) 257 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 258 | ,dtype=theano.config.floatX),borrow=True)) 259 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 260 | ,dtype=theano.config.floatX),borrow=True) 261 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 262 | ,dtype=theano.config.floatX),borrow=True) 263 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 264 | ,dtype=theano.config.floatX),borrow=True) 265 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 266 | 267 | val_set_lx = [] 268 | val_set_lx_mask = [] 269 | for i in range(max_turn): 270 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 271 | ,dtype=theano.config.floatX),borrow=True)) 272 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 273 | ,dtype=theano.config.floatX),borrow=True)) 274 | 275 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 276 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 277 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 278 | ,dtype=theano.config.floatX),borrow=True) 279 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 280 | 281 | dic = {} 282 | for i in range(max_turn): 283 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 284 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 285 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 286 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 287 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 288 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 289 | 290 | val_dic = {} 291 | for i in range(max_turn): 292 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 293 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 294 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 295 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 296 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 297 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 298 | 299 | 300 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 301 | 302 | for i in range(max_turn): 303 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 304 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 305 | 306 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 307 | 308 | poolingoutput = [] 309 | test = theano.function([index],pooling_layer(llayer0_input[-4],rlayer0_input, 310 | q_embedding[i],r_embedding) 311 | ,givens=val_dic,on_unused_input='ignore') 312 | print test(0).shape 313 | print test(0) 314 | 315 | for i in range(max_turn): 316 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 317 | q_embedding[i],r_embedding)) 318 | 319 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 320 | res = session2vec(T.stack(poolingoutput,1),sessionmask) 321 | classifier = LogisticRegression(res, session_hidden_size ,2,rng) 322 | 323 | cost = classifier.negative_log_likelihood(y) 324 | error = classifier.errors(y) 325 | opt = Adam() 326 | params = classifier.params 327 | params += sentence2vec.params 328 | params += session2vec.params 329 | params += pooling_layer.params 330 | params += [Words] 331 | 332 | grad_updates = opt.Adam(cost=cost,params=params,lr = 0.001) #opt.sgd_updates_adadelta(params, cost, lr_decay, 1e-8, sqr_norm_lim) 333 | 334 | train_model = theano.function([index], cost,updates=grad_updates, givens=dic,on_unused_input='ignore') 335 | val_model = theano.function([index], [cost,error], givens=val_dic,on_unused_input='ignore') 336 | best_dev = 1. 337 | n_train_batches = datasets[0].shape[0]/batch_size 338 | for i in xrange(n_epochs): 339 | cost = 0 340 | total = 0. 341 | for minibatch_index in np.random.permutation(range(n_train_batches)): 342 | batch_cost = train_model(minibatch_index) 343 | total = total + 1 344 | cost = cost + batch_cost 345 | if total % 50 == 0: 346 | print total, cost/total 347 | cost = cost / n_train_batches 348 | print "echo %d loss %f" % (i,cost) 349 | 350 | cost=0 351 | errors = 0 352 | j = 0 353 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 354 | tcost, terr = val_model(minibatch_index) 355 | cost += tcost 356 | errors += terr 357 | j = j+1 358 | cost = cost / j 359 | errors = errors / j 360 | if cost < best_dev: 361 | best_dev = cost 362 | save_params(params,model_name) 363 | print "echo %d dev_loss %f" % (i,cost) 364 | print "echo %d dev_accuracy %f" % (i,1 - errors) 365 | 366 | def save_params(params,filename): 367 | num_params = [p.get_value() for p in params] 368 | f = open(filename,'wb') 369 | cPickle.dump(num_params,f) 370 | 371 | def get_session_mask(sents): 372 | session_mask = [0.] * max_turn 373 | turns = [] 374 | for sent in sents.split('_t_'): 375 | words = sent.split() 376 | if len(words) > 0: 377 | turns.append(len(words)) 378 | 379 | for i in range(max_turn): 380 | if max_turn - i <= len(turns): 381 | session_mask[-(max_turn-i)] = 1. 382 | #print session_mask 383 | return session_mask 384 | #print final 385 | 386 | 387 | def make_data(revs, word_idx_map, max_l=50, filter_h=3, val_test_splits=[2,3],validation_num = 50000): 388 | """ 389 | Transforms sentences into a 2-d matrix. 390 | """ 391 | train, val, test = [], [], [] 392 | for rev in revs: 393 | sent = get_idx_from_sent_msg(rev["m"], word_idx_map, max_l, True) 394 | sent += get_idx_from_sent(rev["r"], word_idx_map, max_l, True) 395 | sent += get_session_mask(rev["m"]) 396 | sent.append(int(rev["y"])) 397 | if len(val) > validation_num: 398 | train.append(sent) 399 | else: 400 | val.append(sent) 401 | 402 | train = np.array(train,dtype="int") 403 | val = np.array(val,dtype="int") 404 | test = np.array(test,dtype="int") 405 | print 'trainning data', len(train),'val data', len(val) 406 | return [train, val, test] 407 | 408 | if __name__=="__main__": 409 | train_flag = True 410 | max_word_per_utterence = 50 411 | dataset = r"../ubuntu_data.mul.100d.fullw2v.train" 412 | x = cPickle.load(open(dataset,"rb")) 413 | revs, wordvecs, max_l = x[0], x[1], x[2] 414 | 415 | if train_flag == False: 416 | x = cPickle.load(open(r"../ubuntu_data.mul.test","rb")) 417 | revs, wordvecs2, max_l2 = x[0], x[1], x[2] 418 | datasets = make_data(revs,wordvecs.word_idx_map,max_l=max_word_per_utterence) 419 | 420 | if train_flag == True: 421 | train(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 422 | ,hidden_size=100,word_embedding_size=100) 423 | else: 424 | predict(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 425 | ,hidden_size=100,word_embedding_size=100) -------------------------------------------------------------------------------- /theano_src/SMN_Static.py: -------------------------------------------------------------------------------- 1 | import cPickle 2 | from RNN import GRU 3 | import numpy as np 4 | import theano 5 | from gensim.models.word2vec import Word2Vec 6 | from PreProcess import WordVecs 7 | from Classifier import LogisticRegression 8 | from Optimization import Adam 9 | import theano.tensor as T 10 | from SimAsImage import ConvSim 11 | 12 | max_turn = 10 13 | def get_idx_from_sent_msg(sents, word_idx_map, max_l=50,mask = False): 14 | """ 15 | Transforms sentence into a list of indices. Pad with zeroes. 16 | """ 17 | turns = [] 18 | for sent in sents.split('_t_'): 19 | x = [0] * max_l 20 | x_mask = [0.] * max_l 21 | words = sent.split() 22 | length = len(words) 23 | for i, word in enumerate(words): 24 | if max_l - length + i < 0: continue 25 | if word in word_idx_map: 26 | x[max_l - length + i] = word_idx_map[word] 27 | #if x[max_l - length + i] != 0: 28 | x_mask[max_l - length + i] = 1 29 | if mask: 30 | x += x_mask 31 | turns.append(x) 32 | 33 | final = [0.] * (max_l * 2 * max_turn) 34 | for i in range(max_turn): 35 | if max_turn - i <= len(turns): 36 | for j in range(max_l * 2): 37 | final[i*(max_l*2) + j] = turns[-(max_turn-i)][j] 38 | #print final 39 | #print sents 40 | return final 41 | 42 | def get_idx_from_sent(sent, word_idx_map, max_l=50,mask = False): 43 | """ 44 | Transforms sentence into a list of indices. Pad with zeroes. 45 | """ 46 | x = [0] * max_l 47 | x_mask = [0.] * max_l 48 | words = sent.split() 49 | length = len(words) 50 | for i, word in enumerate(words): 51 | if max_l - length + i < 0: continue 52 | if word in word_idx_map: 53 | x[max_l - length + i] = word_idx_map[word] 54 | #if x[max_l - length + i] != 0: 55 | x_mask[max_l - length + i] = 1 56 | if mask: 57 | x += x_mask 58 | return x 59 | 60 | def _dropout_from_layer(rng, layer, p): 61 | """p is the probablity of dropping a unit 62 | """ 63 | srng = theano.tensor.shared_randomstreams.RandomStreams( 64 | rng.randint(999999)) 65 | # p=1-p because 1's indicate keep and p is prob of dropping 66 | mask = srng.binomial(n=1, p=1-p, size=layer.shape) 67 | # The cast is important because 68 | # int * float32 = float64 which pulls things off the gpu 69 | output = layer * T.cast(mask, theano.config.floatX) 70 | return output 71 | 72 | 73 | def predict(datasets, 74 | U, # pre-trained word embeddings 75 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 76 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): # for optimization 77 | """ 78 | return: a list of dicts of lists, each list contains (ansId, groundTruth, prediction) for a question 79 | """ 80 | hiddensize = hidden_size 81 | U = U.astype(dtype=theano.config.floatX) 82 | rng = np.random.RandomState(3435) 83 | lsize, rsize = max_l,max_l 84 | sessionmask = T.matrix() 85 | lx = [] 86 | lxmask = [] 87 | for i in range(max_turn): 88 | lx.append(T.matrix()) 89 | lxmask.append(T.matrix()) 90 | 91 | index = T.lscalar() 92 | rx = T.matrix('rx') 93 | rxmask = T.matrix() 94 | y = T.ivector('y') 95 | Words = theano.shared(value = U, name = "Words") 96 | llayer0_input = [] 97 | for i in range(max_turn): 98 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 99 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 100 | 101 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 102 | 103 | 104 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 105 | 106 | train_set_lx = [] 107 | train_set_lx_mask = [] 108 | q_embedding = [] 109 | offset = 2 * lsize 110 | for i in range(max_turn): 111 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 112 | ,dtype=theano.config.floatX),borrow=True)) 113 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 114 | ,dtype=theano.config.floatX),borrow=True)) 115 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 116 | ,dtype=theano.config.floatX),borrow=True) 117 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 118 | ,dtype=theano.config.floatX),borrow=True) 119 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 120 | ,dtype=theano.config.floatX),borrow=True) 121 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 122 | 123 | val_set_lx = [] 124 | val_set_lx_mask = [] 125 | for i in range(max_turn): 126 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 127 | ,dtype=theano.config.floatX),borrow=True)) 128 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 129 | ,dtype=theano.config.floatX),borrow=True)) 130 | 131 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 132 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 133 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 134 | ,dtype=theano.config.floatX),borrow=True) 135 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 136 | 137 | dic = {} 138 | for i in range(max_turn): 139 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 140 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 141 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 142 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 143 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 144 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 145 | 146 | val_dic = {} 147 | for i in range(max_turn): 148 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 149 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 150 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 151 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 152 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 153 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 154 | 155 | 156 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 157 | 158 | for i in range(max_turn): 159 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 160 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 161 | 162 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 163 | 164 | poolingoutput = [] 165 | 166 | 167 | for i in range(max_turn): 168 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 169 | q_embedding[i],r_embedding)) 170 | 171 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 172 | res = session2vec(T.stack(poolingoutput,1),sessionmask,True) 173 | w = theano.shared(value=np.ones((max_turn,),dtype=theano.config.floatX),borrow=True) 174 | 175 | 176 | test = theano.function([index],T.sum(res * w[None,:,None],1) 177 | ,givens=val_dic,on_unused_input='ignore') 178 | print test(0).shape 179 | print test(0) 180 | classifier = LogisticRegression(T.sum(res * w[None,:,None],1), session_hidden_size,2,rng) 181 | 182 | cost = classifier.negative_log_likelihood(y) 183 | error = classifier.errors(y) 184 | opt = Adam() 185 | params = classifier.params 186 | params += sentence2vec.params 187 | params += session2vec.params 188 | params += pooling_layer.params 189 | params += [Words,w] 190 | 191 | 192 | load_params(params,model_name) 193 | 194 | predict = classifier.predict_prob 195 | 196 | val_model = theano.function([index], [y,predict,cost,error], givens=val_dic 197 | ,on_unused_input='ignore') 198 | f = open('result.txt','w') 199 | loss = 0. 200 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 201 | a,b,c,d = val_model(minibatch_index) 202 | print c 203 | loss += c 204 | #print b.shape 205 | for i in range(batch_size): 206 | f.write(str(b[i][1])) 207 | f.write('\t') 208 | f.write(str(a[i])) 209 | f.write('\n') 210 | #print b[i] 211 | print loss/(datasets[1].shape[0]/batch_size) 212 | 213 | 214 | def load_params(params,filename): 215 | f = open(filename) 216 | num_params = cPickle.load(f) 217 | for p,w in zip(params,num_params): 218 | p.set_value(w.astype('float32'),borrow=True) 219 | print "load successfully" 220 | 221 | def train(datasets, 222 | U, # pre-trained word embeddings 223 | n_epochs=5,batch_size=20,max_l = 100,hidden_size=100,word_embedding_size=100, 224 | session_hidden_size=50,session_input_size =50, model_name = 'SMN_last.bin'): 225 | hiddensize = hidden_size 226 | U = U.astype(dtype=theano.config.floatX) 227 | rng = np.random.RandomState(3435) 228 | lsize, rsize = max_l,max_l 229 | sessionmask = T.matrix() 230 | lx = [] 231 | lxmask = [] 232 | for i in range(max_turn): 233 | lx.append(T.matrix()) 234 | lxmask.append(T.matrix()) 235 | 236 | index = T.lscalar() 237 | rx = T.matrix('rx') 238 | rxmask = T.matrix() 239 | y = T.ivector('y') 240 | Words = theano.shared(value = U, name = "Words") 241 | llayer0_input = [] 242 | for i in range(max_turn): 243 | llayer0_input.append(Words[T.cast(lx[i].flatten(),dtype="int32")]\ 244 | .reshape((lx[i].shape[0],lx[i].shape[1],Words.shape[1]))) 245 | 246 | rlayer0_input = Words[T.cast(rx.flatten(),dtype="int32")].reshape((rx.shape[0],rx.shape[1],Words.shape[1])) # input: word embeddings of the mini batch 247 | 248 | 249 | train_set, dev_set, test_set = datasets[0], datasets[1], datasets[2] 250 | 251 | train_set_lx = [] 252 | train_set_lx_mask = [] 253 | q_embedding = [] 254 | offset = 2 * lsize 255 | for i in range(max_turn): 256 | train_set_lx.append(theano.shared(np.asarray(train_set[:,offset*i:offset*i + lsize] 257 | ,dtype=theano.config.floatX),borrow=True)) 258 | train_set_lx_mask.append(theano.shared(np.asarray(train_set[:,offset*i + lsize:offset*i + 2*lsize] 259 | ,dtype=theano.config.floatX),borrow=True)) 260 | train_set_rx = theano.shared(np.asarray(train_set[:,offset*max_turn:offset*max_turn + lsize] 261 | ,dtype=theano.config.floatX),borrow=True) 262 | train_set_rx_mask= theano.shared(np.asarray(train_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize] 263 | ,dtype=theano.config.floatX),borrow=True) 264 | train_set_session_mask= theano.shared(np.asarray(train_set[:,-max_turn-1:-1] 265 | ,dtype=theano.config.floatX),borrow=True) 266 | train_set_y =theano.shared(np.asarray(train_set[:,-1],dtype="int32"),borrow=True) 267 | 268 | val_set_lx = [] 269 | val_set_lx_mask = [] 270 | for i in range(max_turn): 271 | val_set_lx.append(theano.shared(np.asarray(dev_set[:,offset*i:offset*i + lsize] 272 | ,dtype=theano.config.floatX),borrow=True)) 273 | val_set_lx_mask.append(theano.shared(np.asarray(dev_set[:,offset*i + lsize:offset*i + 2*lsize] 274 | ,dtype=theano.config.floatX),borrow=True)) 275 | 276 | val_set_rx = theano.shared(np.asarray(dev_set[:,offset*max_turn:offset*max_turn + lsize],dtype=theano.config.floatX),borrow=True) 277 | val_set_rx_mask = theano.shared(np.asarray(dev_set[:,offset*max_turn +lsize:offset*max_turn +2 *lsize],dtype=theano.config.floatX),borrow=True) 278 | val_set_session_mask = theano.shared(np.asarray(dev_set[:,-max_turn-1:-1] 279 | ,dtype=theano.config.floatX),borrow=True) 280 | val_set_y =theano.shared(np.asarray(dev_set[:,-1],dtype="int32"),borrow=True) 281 | 282 | dic = {} 283 | for i in range(max_turn): 284 | dic[lx[i]] = train_set_lx[i][index*batch_size:(index+1)*batch_size] 285 | dic[lxmask[i]] = train_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 286 | dic[rx] = train_set_rx[index*batch_size:(index+1)*batch_size] 287 | dic[sessionmask] = train_set_session_mask[index*batch_size:(index+1)*batch_size] 288 | dic[rxmask] = train_set_rx_mask[index*batch_size:(index+1)*batch_size] 289 | dic[y] = train_set_y[index*batch_size:(index+1)*batch_size] 290 | 291 | val_dic = {} 292 | for i in range(max_turn): 293 | val_dic[lx[i]] = val_set_lx[i][index*batch_size:(index+1)*batch_size] 294 | val_dic[lxmask[i]] = val_set_lx_mask[i][index*batch_size:(index+1)*batch_size] 295 | val_dic[rx] = val_set_rx[index*batch_size:(index+1)*batch_size] 296 | val_dic[sessionmask] = val_set_session_mask[index*batch_size:(index+1)*batch_size] 297 | val_dic[rxmask] = val_set_rx_mask[index*batch_size:(index+1)*batch_size] 298 | val_dic[y] = val_set_y[index*batch_size:(index+1)*batch_size] 299 | 300 | 301 | sentence2vec = GRU(n_in=word_embedding_size,n_hidden=hiddensize,n_out=hiddensize) 302 | 303 | for i in range(max_turn): 304 | q_embedding.append(sentence2vec(llayer0_input[i],lxmask[i],True)) 305 | r_embedding = sentence2vec(rlayer0_input,rxmask,True) 306 | 307 | pooling_layer = ConvSim(rng,max_l,session_input_size,hidden_size=hiddensize) 308 | 309 | poolingoutput = [] 310 | 311 | 312 | for i in range(max_turn): 313 | poolingoutput.append(pooling_layer(llayer0_input[i],rlayer0_input, 314 | q_embedding[i],r_embedding)) 315 | 316 | session2vec = GRU(n_in=session_input_size,n_hidden=session_hidden_size,n_out=session_hidden_size) 317 | res = session2vec(T.stack(poolingoutput,1),sessionmask,True) 318 | w = theano.shared(value=np.ones((max_turn,),dtype=theano.config.floatX),borrow=True) 319 | 320 | 321 | test = theano.function([index],T.sum(res * w[None,:,None],1) 322 | ,givens=val_dic,on_unused_input='ignore') 323 | print test(0).shape 324 | print test(0) 325 | classifier = LogisticRegression(T.sum(res * w[None,:,None],1), session_hidden_size,2,rng) 326 | 327 | cost = classifier.negative_log_likelihood(y) 328 | error = classifier.errors(y) 329 | opt = Adam() 330 | params = classifier.params 331 | params += sentence2vec.params 332 | params += session2vec.params 333 | params += pooling_layer.params 334 | params += [Words,w] 335 | 336 | grad_updates = opt.Adam(cost=cost,params=params,lr = 0.001) #opt.sgd_updates_adadelta(params, cost, lr_decay, 1e-8, sqr_norm_lim) 337 | 338 | train_model = theano.function([index], cost,updates=grad_updates, givens=dic,on_unused_input='ignore') 339 | val_model = theano.function([index], [cost,error], givens=val_dic,on_unused_input='ignore') 340 | best_dev = 1. 341 | n_train_batches = datasets[0].shape[0]/batch_size 342 | for i in xrange(n_epochs): 343 | cost = 0 344 | total = 0. 345 | for minibatch_index in np.random.permutation(range(n_train_batches)): 346 | batch_cost = train_model(minibatch_index) 347 | total = total + 1 348 | cost = cost + batch_cost 349 | if total % 50 == 0: 350 | print total, cost/total 351 | cost = cost / n_train_batches 352 | print "echo %d loss %f" % (i,cost) 353 | 354 | cost=0 355 | errors = 0 356 | j = 0 357 | for minibatch_index in xrange(datasets[1].shape[0]/batch_size): 358 | tcost, terr = val_model(minibatch_index) 359 | cost += tcost 360 | errors += terr 361 | j = j+1 362 | cost = cost / j 363 | errors = errors / j 364 | if cost < best_dev: 365 | best_dev = cost 366 | save_params(params,model_name) 367 | print "echo %d dev_loss %f" % (i,cost) 368 | print "echo %d dev_accuracy %f" % (i,1 - errors) 369 | 370 | def save_params(params,filename): 371 | num_params = [p.get_value() for p in params] 372 | f = open(filename,'wb') 373 | cPickle.dump(num_params,f) 374 | 375 | def get_session_mask(sents): 376 | session_mask = [0.] * max_turn 377 | turns = [] 378 | for sent in sents.split('_t_'): 379 | words = sent.split() 380 | if len(words) > 0: 381 | turns.append(len(words)) 382 | 383 | for i in range(max_turn): 384 | if max_turn - i <= len(turns): 385 | session_mask[-(max_turn-i)] = 1. 386 | #print session_mask 387 | return session_mask 388 | #print final 389 | 390 | 391 | def make_data(revs, word_idx_map, max_l=50, filter_h=3, val_test_splits=[2,3],validation_num = 50000): 392 | """ 393 | Transforms sentences into a 2-d matrix. 394 | """ 395 | train, val, test = [], [], [] 396 | for rev in revs: 397 | sent = get_idx_from_sent_msg(rev["m"], word_idx_map, max_l, True) 398 | sent += get_idx_from_sent(rev["r"], word_idx_map, max_l, True) 399 | sent += get_session_mask(rev["m"]) 400 | sent.append(int(rev["y"])) 401 | if len(val) > validation_num: 402 | train.append(sent) 403 | else: 404 | val.append(sent) 405 | 406 | train = np.array(train,dtype="int") 407 | val = np.array(val,dtype="int") 408 | test = np.array(test,dtype="int") 409 | print 'trainning data', len(train),'val data', len(val) 410 | return [train, val, test] 411 | 412 | if __name__=="__main__": 413 | train_flag = True 414 | max_word_per_utterence = 50 415 | dataset = r"../ubuntu_data.mul.100d.fullw2v.train" 416 | x = cPickle.load(open(dataset,"rb")) 417 | revs, wordvecs, max_l = x[0], x[1], x[2] 418 | 419 | if train_flag == False: 420 | x = cPickle.load(open(r"../ubuntu_data.mul.test","rb")) 421 | revs, wordvecs2, max_l2 = x[0], x[1], x[2] 422 | datasets = make_data(revs,wordvecs.word_idx_map,max_l=max_word_per_utterence) 423 | 424 | if train_flag == True: 425 | train(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 426 | ,hidden_size=100,word_embedding_size=100) 427 | else: 428 | predict(datasets,wordvecs.W,batch_size=200,max_l=max_word_per_utterence 429 | ,hidden_size=100,word_embedding_size=100) -------------------------------------------------------------------------------- /theano_src/SimAsImage.py: -------------------------------------------------------------------------------- 1 | 2 | import os 3 | import sys 4 | import timeit 5 | 6 | import numpy 7 | from CNN import QALeNetConvPoolLayer,LeNetConvPoolLayer2 8 | from Classifier import HiddenLayer2 9 | import theano 10 | import theano.tensor as T 11 | import numpy as np 12 | def ortho_weight(ndim): 13 | W = np.random.randn(ndim, ndim) 14 | u, s, v = np.linalg.svd(W) 15 | return u.astype('float32') 16 | def kmaxpooling(input,input_shape,k): 17 | sorted_values = T.argsort(input,axis=3) 18 | topmax_indexes = sorted_values[:,:,:,-k:] 19 | # sort indexes so that we keep the correct order within the sentence 20 | topmax_indexes_sorted = T.sort(topmax_indexes) 21 | 22 | #given that topmax only gives the index of the third dimension, we need to generate the other 3 dimensions 23 | dim0 = T.arange(0,input_shape[0]).repeat(input_shape[1]*input_shape[2]*k) 24 | dim1 = T.arange(0,input_shape[1]).repeat(k*input_shape[2]).reshape((1,-1)).repeat(input_shape[0],axis=0).flatten() 25 | dim2 = T.arange(0,input_shape[2]).repeat(k).reshape((1,-1)).repeat(input_shape[0]*input_shape[1],axis=0).flatten() 26 | dim3 = topmax_indexes_sorted.flatten() 27 | return input[dim0,dim1,dim2,dim3].reshape((input_shape[0], input_shape[1], input_shape[2], k)) 28 | 29 | class PoolingSim(object): 30 | def __init__(self, rng, n_in, n_out, W=None, b=None, 31 | activation=T.tanh): 32 | self.W = theano.shared(value=ortho_weight(100), name='W', borrow=True) 33 | self.activation = activation 34 | self.hidden_layer = HiddenLayer2(rng,2*5*n_in,n_out) 35 | 36 | self.params = [self.W] + self.hidden_layer.params 37 | 38 | def __call__(self, input_l,input_r,batch_size,max_l): 39 | channel_1 = T.batched_dot(input_l,input_r.dimshuffle(0,2,1)) 40 | channel_2 = T.batched_dot(T.dot(input_l,self.W),input_r.dimshuffle(0,2,1)) 41 | input = T.stack([channel_1,channel_2],axis=1) 42 | poolingoutput = kmaxpooling(input,[batch_size,2,max_l,max_l],5) 43 | mlp_in = T.flatten(poolingoutput,2) 44 | return self.hidden_layer(mlp_in) 45 | 46 | class PoolingSim3(object): 47 | def __init__(self, rng, n_in, n_out, W=None, b=None, 48 | activation=T.tanh,hidden_size=100): 49 | self.W = theano.shared(value=ortho_weight(hidden_size), name='W', borrow=True) 50 | self.activation = activation 51 | self.hidden_layer = HiddenLayer2(rng,2*5*n_in,n_out) 52 | 53 | self.params = [self.W] + self.hidden_layer.params 54 | 55 | def __call__(self,origin_l,origin_r,input_l,input_r,batch_size,max_l): 56 | channel_1 = T.batched_dot(origin_l,origin_r.dimshuffle(0,2,1)) 57 | channel_2 = T.batched_dot(T.dot(input_l,self.W),input_r.dimshuffle(0,2,1)) 58 | input = T.stack([channel_1,channel_2],axis=1) 59 | poolingoutput = kmaxpooling(input,[batch_size,2,max_l,max_l],5) 60 | mlp_in = T.flatten(poolingoutput,2) 61 | return self.hidden_layer(mlp_in) 62 | 63 | class PoolingSim2(object): 64 | def __init__(self, rng, n_in, n_out,tensor_num = 3, 65 | activation=T.tanh): 66 | self.tensor_num = tensor_num 67 | self.W = [] 68 | for i in range(tensor_num): 69 | self.W.append(theano.shared(value=ortho_weight(100), borrow=True)) 70 | self.activation = activation 71 | self.hidden_layer = HiddenLayer2(rng,tensor_num*5*n_in,n_out) 72 | 73 | self.params = self.W + self.hidden_layer.params 74 | 75 | def __call__(self, input_l,input_r,batch_size,max_l): 76 | channels = [] 77 | for i in range(self.tensor_num): 78 | channels.append(T.batched_dot(T.dot(input_l,self.W[i]),input_r.dimshuffle(0,2,1))) 79 | 80 | input = T.stack(channels,axis=1) 81 | poolingoutput = kmaxpooling(input,[batch_size,self.tensor_num,max_l,max_l],5) 82 | mlp_in = T.flatten(poolingoutput,2) 83 | return self.hidden_layer(mlp_in) 84 | 85 | class ConvSim(object): 86 | def __init__(self, rng, n_in, n_out, W=None, b=None, 87 | activation=T.tanh,hidden_size=100): 88 | self.W = theano.shared(value=ortho_weight(hidden_size), borrow=True) 89 | self.activation = activation 90 | 91 | self.conv_layer = LeNetConvPoolLayer2(rng,filter_shape=(8,2,3,3), 92 | image_shape=(200,2,50,50) 93 | ,poolsize=(3,3),non_linear='relu') 94 | 95 | self.hidden_layer = HiddenLayer2(rng,2048,n_out) 96 | self.params = [self.W,] + self.conv_layer.params + self.hidden_layer.params 97 | def Get_M2(self,input_l,input_r): 98 | return T.batched_dot(T.dot(input_l,self.W),input_r.dimshuffle(0,2,1)) 99 | 100 | def __call__(self, origin_l,origin_r,input_l,input_r): 101 | channel_1 = T.batched_dot(origin_l,origin_r.dimshuffle(0,2,1)) 102 | channel_2 = T.batched_dot(T.dot(input_l,self.W),input_r.dimshuffle(0,2,1)) 103 | input = T.stack([channel_1,channel_2],axis=1) 104 | mlp_in = T.flatten(self.conv_layer(input),2) 105 | 106 | return self.hidden_layer(mlp_in) 107 | 108 | class ConvSim2(object): 109 | def __init__(self, rng, n_in, n_out, W=None, b=None, 110 | activation=T.tanh,hidden_size=100): 111 | self.W = theano.shared(value=ortho_weight(hidden_size), borrow=True) 112 | self.activation = activation 113 | 114 | self.conv_layer = LeNetConvPoolLayer2(rng,filter_shape=(8,1,3,3), 115 | image_shape=(200,1,50,50) 116 | ,poolsize=(3,3),non_linear='relu') 117 | 118 | self.hidden_layer = HiddenLayer2(rng,2048,n_out) 119 | self.params = self.conv_layer.params + self.hidden_layer.params 120 | 121 | def __call__(self, origin_l,origin_r): 122 | channel_1 = T.batched_dot(origin_l,origin_r.dimshuffle(0,2,1)) 123 | input =channel_1.dimshuffle(0,'x',1,2) 124 | mlp_in = T.flatten(self.conv_layer(input),2) 125 | 126 | return self.hidden_layer(mlp_in) -------------------------------------------------------------------------------- /theano_src/logistic_sgd.py: -------------------------------------------------------------------------------- 1 | import cPickle, gzip, numpy 2 | import theano 3 | import theano.tensor as T 4 | 5 | class SumRegression(object): 6 | def __init__(self,input,n_in,n_out,rng): 7 | self.W = theano.shared(value=numpy.ones((n_in,n_out),dtype=theano.config.floatX) 8 | ,borrow=True,name='W') 9 | self.predict_prob = T.nnet.softmax(T.dot(input,self.W)) 10 | self.predict_y = T.argmax(self.predict_prob,axis=1) 11 | self.params=[] 12 | 13 | def negative_log_likelihood(self, y): 14 | #return - T.mean(y * T.log(self.predict_prob) + (1 - y) * T.log(1 - self.predict_prob)) 15 | return -T.mean(T.log(self.predict_prob)[T.arange(y.shape[0]), y]) 16 | 17 | def errors(self,y): 18 | if y.dtype.startswith('int'): 19 | return T.mean(T.neq(self.predict_y,y)) 20 | else: 21 | raise NotImplementedError 22 | 23 | class LogisticRegression(object): 24 | def __init__(self,input,n_in,n_out,rng): 25 | self.W = theano.shared( numpy.asarray( 26 | rng.uniform( 27 | low=-numpy.sqrt(6. / (n_in + n_out)), 28 | high=numpy.sqrt(6. / (n_in + n_out)), 29 | size=(n_in, n_out) 30 | ), 31 | dtype=theano.config.floatX 32 | )) 33 | self.b = theano.shared(value=numpy.zeros(n_out,dtype=theano.config.floatX),borrow=True,name='b') 34 | self.predict_prob = T.nnet.softmax(T.dot(input,self.W)+self.b) 35 | self.predict_y = T.argmax(self.predict_prob,axis=1) 36 | self.params=[self.W,self.b] 37 | 38 | def negative_log_likelihood(self, y): 39 | #return - T.mean(y * T.log(self.predict_prob) + (1 - y) * T.log(1 - self.predict_prob)) 40 | return -T.mean(T.log(self.predict_prob)[T.arange(y.shape[0]), y]) 41 | 42 | def errors(self,y): 43 | if y.dtype.startswith('int'): 44 | return T.mean(T.neq(self.predict_y,y)) 45 | else: 46 | raise NotImplementedError 47 | 48 | def load_data(dataset): 49 | def shared_data(data_xy): 50 | data_x,data_y = data_xy 51 | shared_x = theano.shared(data_x) 52 | shared_y = theano.shared(data_y) 53 | return shared_x, T.cast(shared_y,'int32') 54 | 55 | f = gzip.open(dataset) 56 | train_set, dev_set, test_set = cPickle.load(f) 57 | f.close() 58 | 59 | train_set_x, train_set_y = shared_data(train_set) 60 | dev_set_x, dev_set_y = shared_data(dev_set) 61 | test_set_x, test_set_y = shared_data(test_set) 62 | 63 | rval = [(train_set_x,train_set_y),(dev_set_x, dev_set_y ), 64 | (test_set_x,test_set_y)] 65 | return rval 66 | 67 | 68 | def sgd_optimization_mnist(learning_rate=0.13, n_epochs=1000, 69 | dataset='mnist.pkl.gz', 70 | batch_size=600): 71 | data = load_data('mnist.pkl.gz') 72 | train_x, train_y = data[0] 73 | dev_x, dev_y = data[1] 74 | test_x, test_y = data[2] 75 | 76 | n_train_batches = train_x.get_value(borrow=True).shape[0]//batch_size 77 | n_dev_batches = dev_x.get_value(borrow=True).shape[0]//batch_size 78 | n_test_batches = test_x.get_value(borrow=True).shape[0]//batch_size 79 | 80 | print n_dev_batches 81 | 82 | x = T.matrix('x') 83 | y = T.ivector('y') 84 | classifier = LogisticRegression(input=x,n_in=28*28,n_out=10) 85 | cost = classifier.negative_log_likelihood(y) 86 | print 'building model...' 87 | index = T.lscalar() 88 | 89 | g_w = T.grad(cost=cost, wrt= classifier.W) 90 | g_b = T.grad(cost = cost,wrt = classifier.b) 91 | updates = [(classifier.W,classifier.W-learning_rate*g_w), 92 | (classifier.b,classifier.b-learning_rate*g_b)] 93 | train_model = theano.function(inputs=[index],outputs = cost,updates=updates, 94 | givens={ 95 | x: train_x[index*batch_size:(index+1)*batch_size], 96 | y: train_y[index*batch_size:(index+1)*batch_size] 97 | }) 98 | 99 | validate_model = theano.function(inputs=[index],outputs = classifier.error(y), 100 | givens={ 101 | x: test_x[index*batch_size:(index+1)*batch_size], 102 | y: test_y[index*batch_size:(index+1)*batch_size] 103 | }) 104 | epoch = 0 105 | while epoch < n_epochs: 106 | epoch = epoch +1 107 | train_error = 0 108 | for minibatch_index in range(n_train_batches): 109 | minibatch_avg_cost = train_model(minibatch_index) 110 | #print minibatch_avg_cost 111 | train_error = train_error+ minibatch_avg_cost 112 | if minibatch_index == n_train_batches-1: 113 | validation_losses = [validate_model(i) for i in range(n_dev_batches)] 114 | this_validation_losses = numpy.mean(validation_losses) 115 | #print validation_losses 116 | print('epoch %i, minibatch %i, valiadation error %f'%(epoch,minibatch_index+1,this_validation_losses)) 117 | 118 | if __name__ == '__main__': 119 | sgd_optimization_mnist() -------------------------------------------------------------------------------- /train.sample: -------------------------------------------------------------------------------- 1 | 1 my hometown 的 中文 歌词 很 感动 英文 版 是 小田 亲自 翻译 的 更加 感动 求 v _url_ thanks 3 2 | 0 my hometown 的 中文 歌词 很 感动 英文 版 是 小田 亲自 翻译 的 更加 感动 求 v _url_ 是 我 眼拙 心 盲 3 | 1 昆明 那里 配 眼镜 比较 便宜 云大 附近 很多 店 应该 有 竞争 价格 会 下来 一点 的 吧 给 推荐 个 云大 附近 的 吧 谢谢 去 了 就能 看到 比如 云光 什么 的 4 | 0 昆明 那里 配 眼镜 比较 便宜 云大 附近 很多 店 应该 有 竞争 价格 会 下来 一点 的 吧 给 推荐 个 云大 附近 的 吧 谢谢 你 的 他 毕竟 还是 说 了 我 的 完全 没有 任何 消息 我 伤害 了 他 于是 15 天 没 消息 5 | 1 看 原版 英文 电影 学 纯正 英语 大 爱 老友 记 反复 看 了 好多 次 了 一样 光盘 都 快 被 我 看 花 了 那 你 现在 的 英语 应该 不错 了 6 | 0 看 原版 英文 电影 学 纯正 英语 大 爱 老友 记 反复 看 了 好多 次 了 一样 光盘 都 快 被 我 看 花 了 我 也 想 知道 啊 感觉 暧昧 的 时候 很 大胆 真正 在一起 后 怎么 小心翼翼 的 了 是不是 闷葫芦 了 我 月鱼 金 秤 我 不懂 啊 7 | 1 视频 资源 综合 帖 开头 的 我 只 知道 这 两个 请教 一下 怎么 我 打开 这 两个 网站 之后 没有 看到 播放 的 字样 呢 是不是 还 需要 另外 下载 播放器 求解 gracias 下载 了 ftv 播放器 后 还是 不能 看 怎么办 好像 真的 不能 看 啊 8 | 0 视频 资源 综合 帖 开头 的 我 只 知道 这 两个 请教 一下 怎么 我 打开 这 两个 网站 之后 没有 看到 播放 的 字样 呢 是不是 还 需要 另外 下载 播放器 求解 gracias 本来 就是 要 坚持 做 你 想 永久 那 是 不 可能 的 都是 要 做 很 多次 才 可以 9 | 1 杀人 者 海明威 翻译者 是 上海人 把 客 字 看 出来 的 有 阿拉 上海 宁才 会 翻 得出 的 词语 啊 哈哈 哈 哈哈 哈 当初 读 的 时候 注意 到了 10 | 0 杀人 者 海明威 翻译者 是 上海人 把 客 字 看 出来 的 有 阿拉 上海 宁才 会 翻 得出 的 词语 啊 哈哈 哈 主要 女孩子 的 皮肤 这个 东西 尤其 脸上 的 皮肤 要是 出 了 什么 大 问题 那 真的 一辈子 都 完了 女人 这 方面 真的 很 被动 小心 点 总是 好 的 11 | 1 小 广告 专 贴 有 料 的 小 广告 还 挺 多 最近 想 买 瑜伽铺巾 有 推荐 的 产品 没 搬 个 小 板凳 坐等 另外 问候 迷糊 蕊 麒 和 朋友 们 de 纯 天然橡胶 瑜伽垫 防滑 性 超 棒 舒适 耐用 瑜伽 习练 的 必备 品 哦 还有 漂亮 的 王燕 老师 极力 推荐 你 心水 了 吗 url z0dszsi 你 是 优胜 美 地 的 啊 哈哈 我 去 过 你们 那 环境 很好 12 | 0 小 广告 专 贴 有 料 的 小 广告 还 挺 多 最近 想 买 瑜伽铺巾 有 推荐 的 产品 没 搬 个 小 板凳 坐等 另外 问候 迷糊 蕊 麒 和 朋友 们 de 纯 天然橡胶 瑜伽垫 防滑 性 超 棒 舒适 耐用 瑜伽 习练 的 必备 品 哦 还有 漂亮 的 王燕 老师 极力 推荐 你 心水 了 吗 url z0dszsi 走 着 13 | 1 际 恒 公关公司 怎么样 我 特别 想 去 际 恒 实习 不 知 可否 · · · · · · grace 现在 想来 吗 简历 发给 我 看 下 吧 是 hr 大人 么 我 也 想 去 你 家 试 一 试 求 介绍 我 不是 hr 不过 可以 和 你 聊聊 无 意中 发现 恒 际 的 贴 请问 您 现在 还 在 恒 际 吗 是的 还 在 同行 吗 是啊 同行 啊 那 请问 贵 公司 还 招人 吗 现在 招 啊 我们 公司 招 14 | 0 际 恒 公关公司 怎么样 我 特别 想 去 际 恒 实习 不 知 可否 · · · · · · grace 现在 想来 吗 简历 发给 我 看 下 吧 是 hr 大人 么 我 也 想 去 你 家 试 一 试 求 介绍 我 不是 hr 不过 可以 和 你 聊聊 无 意中 发现 恒 际 的 贴 请问 您 现在 还 在 恒 际 吗 是的 还 在 同行 吗 是啊 同行 啊 那 请问 贵 公司 还 招人 吗 现在 招 啊 我 刚 跟 他 发 短信 了 他 说 你 实在 要 的 话 就 法院 诉讼 去吧 你 说 难道 他 已经 有 办法 还是 之前 有人 告 过 他 但是 没 成功 15 | 1 私房菜 删 帖 及 封 禁 相关 细则 传 很久 很多 菜 的 一个 帖子 被 删 了 阿土 伯 你 给 我 捞 出来 了 我 刚 回 了 个人 问 的 问题 结果 又 进去 了 我 才刚 释放 啊 你 再 给 我 捞 出来 吧 我 就 放 那 自己 看不 回帖 了 还是 有 违禁 词 与 wangshang gouwu 有关 的 一切 词 都是 违禁 词 帖子 里 确实 有 违禁 词 你 给 我 捞 出来 了 我 可以 进 到 帖子 里 把 这个 词 删 了 吗 不会 进去 修改 还没有 删掉 就 又 进 回收站 了 吧 能 删 你 给 我 删 可以 吗 16 | 0 私房菜 删 帖 及 封 禁 相关 细则 传 很久 很多 菜 的 一个 帖子 被 删 了 阿土 伯 你 给 我 捞 出来 了 我 刚 回 了 个人 问 的 问题 结果 又 进去 了 我 才刚 释放 啊 你 再 给 我 捞 出来 吧 我 就 放 那 自己 看不 回帖 了 还是 有 违禁 词 与 wangshang gouwu 有关 的 一切 词 都是 违禁 词 嗯 哼 17 | 1 殷琪 卸妆 我 怎么 找不到 真的 很 夸张 眼睛 也 差 太多 了 吧 哪里 能 看到 我 就是 上面 给 的 地址 看 的 不过 现在 看不 了了 18 | 0 殷琪 卸妆 我 怎么 找不到 真的 很 夸张 眼睛 也 差 太多 了 吧 哪里 能 看到 s 吧 粉色 是 s 的 hm 的 都会 偏 大 相当 于 m 19 | 1 日本 早稻田大学 图书 馆 网站 有 大量 中国 古籍 的 扫描 版 直接 点 开 pdf 右上 角 有 下载 选项 另外 虽然 是 多年 前 的 帖子 但 现在 仍然 能 用 非常 感谢 请教 是 一 张 一 张 下 还是 全部 整个 pdf 一起 下 不 可能 一次 下 一 张 的 恩 谢谢 20 | 0 日本 早稻田大学 图书 馆 网站 有 大量 中国 古籍 的 扫描 版 直接 点 开 pdf 右上 角 有 下载 选项 另外 虽然 是 多年 前 的 帖子 但 现在 仍然 能 用 非常 感谢 请教 是 一 张 一 张 下 还是 全部 整个 pdf 一起 下 不 可能 一次 下 一 张 的 我 觉得 他 已经 不 光 是 荧幕 形象 小气 巴 拉 的 问题 了 感觉 现实 生活 中 也是 个 精 巴 到 不行 的 抠门 鬼 21 | 1 刮痧 与 拍 痧 拍 痧 拍 出来 的 是 湿气 毒气 浊 气 放心 吧 我们 的 身体 很 聪明 的 好 的 东西 跑 不 出来 拍 完 喝 些 温开水 使 这些 代谢 的 废物 尽快 排出 体外 是不是 要 等 痧 退 了 才能 继续 拍 或者 洗澡 据说 继续 拍 可以 拍 散 的 我 没 试 过 一般 等 他 自然 消退 再 继续 我 的 气血 水平 较 低 不敢 每天 都 拍 几个 小时 后 可以 洗澡 话说 我 拍 完 都 三四 天 了 还没 退 完 我 出痧 多 的 时候 一 周 才 退 下去 别 急 病毒 不是 一 天 积累 起来 的 也 不 可能 短 时间 内 排 完 养生 可是 一生 的 事业 哈哈 是 滴 不过 目前 只有 一些 隐隐约约 的 红 点 了 22 | 0 刮痧 与 拍 痧 拍 痧 拍 出来 的 是 湿气 毒气 浊 气 放心 吧 我们 的 身体 很 聪明 的 好 的 东西 跑 不 出来 拍 完 喝 些 温开水 使 这些 代谢 的 废物 尽快 排出 体外 是不是 要 等 痧 退 了 才能 继续 拍 或者 洗澡 据说 继续 拍 可以 拍 散 的 我 没 试 过 一般 等 他 自然 消退 再 继续 我 的 气血 水平 较 低 不敢 每天 都 拍 几个 小时 后 可以 洗澡 话说 我 拍 完 都 三四 天 了 还没 退 完 我 出痧 多 的 时候 一 周 才 退 下去 别 急 病毒 不是 一 天 积累 起来 的 也 不 可能 短 时间 内 排 完 养生 可是 一生 的 事业 哼 你 才 不是 呢 23 | 1 刮痧 与 拍 痧 拍 痧 拍 出来 的 是 湿气 毒气 浊 气 放心 吧 我们 的 身体 很 聪明 的 好 的 东西 跑 不 出来 拍 完 喝 些 温开水 使 这些 代谢 的 废物 尽快 排出 体外 是不是 要 等 痧 退 了 才能 继续 拍 或者 洗澡 据说 继续 拍 可以 拍 散 的 我 没 试 过 一般 等 他 自然 消退 再 继续 我 的 气血 水平 较 低 不敢 每天 都 拍 几个 小时 后 可以 洗澡 话说 我 拍 完 都 三四 天 了 还没 退 完 我 出痧 多 的 时候 一 周 才 退 下去 别 急 病毒 不是 一 天 积累 起来 的 也 不 可能 短 时间 内 排 完 养生 可是 一生 的 事业 哈哈 是 滴 不过 目前 只有 一些 隐隐约约 的 红 点 了 24 | 0 刮痧 与 拍 痧 拍 痧 拍 出来 的 是 湿气 毒气 浊 气 放心 吧 我们 的 身体 很 聪明 的 好 的 东西 跑 不 出来 拍 完 喝 些 温开水 使 这些 代谢 的 废物 尽快 排出 体外 是不是 要 等 痧 退 了 才能 继续 拍 或者 洗澡 据说 继续 拍 可以 拍 散 的 我 没 试 过 一般 等 他 自然 消退 再 继续 我 的 气血 水平 较 低 不敢 每天 都 拍 几个 小时 后 可以 洗澡 话说 我 拍 完 都 三四 天 了 还没 退 完 我 出痧 多 的 时候 一 周 才 退 下去 别 急 病毒 不是 一 天 积累 起来 的 也 不 可能 短 时间 内 排 完 养生 可是 一生 的 事业 要 有 信心 啦 25 | 1 东莞 哪里 有 做 diy 蛋糕 的 地方 环境 很 温馨 服务 非常 好 女朋友 说 蛋糕 很 好吃 从来 没 吃 过 这么 好吃 的 蛋糕 下次 要 带 女朋友 一起 去 请问 后面 四 个 问号 啥 意思 我 发 的 是 表情 啊 怎么 变成 问号 了 26 | 0 东莞 哪里 有 做 diy 蛋糕 的 地方 环境 很 温馨 服务 非常 好 女朋友 说 蛋糕 很 好吃 从来 没 吃 过 这么 好吃 的 蛋糕 下次 要 带 女朋友 一起 去 请问 后面 四 个 问号 啥 意思 我 问 了 呢 15 天 内 超过 15 天 就不 能 无 条件 换 机 有 任何 问题 都 算 保修 27 | 1 想 听听 大家 对 论 摄影 看法 大家 觉得 那个 版本 的 论 摄影 翻译 的 更好 一些 呢 黄灿然 译 的 第 二 版 好些 貌似 是 2010年 再版 的 之前 湖南 美术 出 的 错误 奇多 黄灿然 的 版本 从 字面 上 的 错误 少 一点 从 翻译 的 角度 没 好 多少 基本 无法 达意 还是 看 原著 吧 28 | 0 想 听听 大家 对 论 摄影 看法 大家 觉得 那个 版本 的 论 摄影 翻译 的 更好 一些 呢 黄灿然 译 的 第 二 版 好些 貌似 是 2010年 再版 的 之前 湖南 美术 出 的 错误 奇多 不然 怎么办 29 | 1 身高 167cm 女生 172 爱 穿 高跟 么 微 跟 五 公分 左右 嗯 我 喜欢 的 高度 看来 你 182 你好 聪明 30 | 0 身高 167cm 女生 172 爱 穿 高跟 么 微 跟 五 公分 左右 嗯 我 喜欢 的 高度 看来 你 182 是的 几天 不见 就 特别 想 31 | 1 征 同 游 集中 贴 性别 女 时间 2012年 6月 17 到 23 方式 自由行 目前 一人 求 被 捡 预算 不 清楚 还没 概念 机票 已 买 上海 广州 暹粒 广州 上海 住宿 标准 无 所谓 联系 豆油 性格 和善 为什么 要 先 去 广州 东航 出 的 特价机票 必须 得 转 一下 后来 才 发现 真 傻 价钱 也 没 咋 便宜 诶 时间 搭 不上 我 要 等 七月 份 高温假 出来 以后 再 定 嘿嘿 · 我 也 准备 七月 去 等到 放假 可能 七月 十号 左右 目前 还有 一 同学 到时 联系 下 吧 看看 时间 能 不能 对 上 可以 同 游 吼吼 32 | 0 征 同 游 集中 贴 性别 女 时间 2012年 6月 17 到 23 方式 自由行 目前 一人 求 被 捡 预算 不 清楚 还没 概念 机票 已 买 上海 广州 暹粒 广州 上海 住宿 标准 无 所谓 联系 豆油 性格 和善 为什么 要 先 去 广州 东航 出 的 特价机票 必须 得 转 一下 后来 才 发现 真 傻 价钱 也 没 咋 便宜 诶 时间 搭 不上 我 要 等 七月 份 高温假 出来 以后 再 定 嘿嘿 · 我 也 准备 七月 去 等到 放假 可能 七月 十号 左右 目前 还有 一 同学 抢 到 沙发 好 开心 33 | 1 济南 哪里 买 明信片 今儿 去 中山公园 了 啥 也 没 淘 到 我 还有 这个 想法 幸好 你 去 了 要不 跑 冤枉 路 了 那 是 2年 前 的 事 了 从 上 看 下来 有 去 中山公园 的 冲动 了 34 | 0 济南 哪里 买 明信片 今儿 去 中山公园 了 啥 也 没 淘 到 我 还有 这个 想法 幸好 你 去 了 要不 跑 冤枉 路 了 那 是 2年 前 的 事 了 我 睡 到 现在 才 起来 所以 是 早安 35 | 1 有 一 天 我 一定 要 买 齐 所有 幾 米 的 本本 我 在 当当 网上 模拟 买 几米 好几 次 了 喜欢 装帧 精美 的 看着 精装 的 就 舒服 可是 好 贵 啊 舍不得 要是 有人 送 我 一套 我 就 娶 她 哈哈 做梦 了 有人 送 我 我 就 嫁 他 我 送 了 本 星空 给 她 我 没有 错过 她 愿 你 幸福 啊 36 | 0 有 一 天 我 一定 要 买 齐 所有 幾 米 的 本本 我 在 当当 网上 模拟 买 几米 好几 次 了 喜欢 装帧 精美 的 看着 精装 的 就 舒服 可是 好 贵 啊 舍不得 要是 有人 送 我 一套 我 就 娶 她 哈哈 做梦 了 有人 送 我 我 就 嫁 他 我 送 了 本 星空 给 她 我 没有 错过 她 因为 不 在家 所以 没 拍照 过年 咯 37 | 1 家里 这么 潮湿 有 啥 好 办法 啊 我 家 的 天花 残 了 水滴 下来 了 也 掉 皮 了 装 好 了 三 年 的 房子 就 这么 废 了不 住 还好 才 住 不到 一个 月 啊 洗手间 的 天花 在 滴水 厨房 的 地 满地 的 水 不能 拖 的 家里 又 潮 又 水 又 脏 看得 我 想 吐 唯一 不 怎么 潮 的 是 我 的 睡 房 我 天天 空调 抽 潮门 都 不敢 打开 所以 我 现在 天天 在 床 上 呆 着 这种 天气 再 这样 下去 会 疯 的 挺 悲催 的 噢 貌似 潮湿 的 天气 还 会 持续 一段 时间 但 中途 会 有 太阳 出来 的 你 家 会 像 十五二十一 样 整个 天花板 塌 掉 么 很 壮观 诶 你 心态 真好 还 欣赏 壮 不 壮观 我 家 要是 这样 我 得 郁闷 死 38 | 0 家里 这么 潮湿 有 啥 好 办法 啊 我 家 的 天花 残 了 水滴 下来 了 也 掉 皮 了 装 好 了 三 年 的 房子 就 这么 废 了不 住 还好 才 住 不到 一个 月 啊 洗手间 的 天花 在 滴水 厨房 的 地 满地 的 水 不能 拖 的 家里 又 潮 又 水 又 脏 看得 我 想 吐 唯一 不 怎么 潮 的 是 我 的 睡 房 我 天天 空调 抽 潮门 都 不敢 打开 所以 我 现在 天天 在 床 上 呆 着 这种 天气 再 这样 下去 会 疯 的 挺 悲催 的 噢 貌似 潮湿 的 天气 还 会 持续 一段 时间 但 中途 会 有 太阳 出来 的 你 家 会 像 十五二十一 样 整个 天花板 塌 掉 么 很 壮观 诶 哈哈 没 事儿 39 | 1 致 所有 和 双 男 纠结 中的 女人 我 是 射手 女 跟 双子 男 认识 一年 多 了 关系 平淡 属于 相敬如宾 的 那种 昨晚 心血来潮 发 了 条 信息 过去 hi baby 你 睡 了 么 他 竟然 回 你 不能 这样 喊 次奥 他 这 是 拒绝 暧昧 么 是 因为 有 女朋友 了 还是 他 只是 把 我 当 普通 朋友 求解 lz 都 注销 了 求解 个 p 啊 晕 呃 好 吧 我 发帖 了 但 没人 回应 肥仔 不是 回 了 吗 问题 是 你 不 接受 人家 说 的 啊 你 问 这里 的 人 双子 男 怎么 想 的 谁 都 不是 他 肚 里 的 蛔虫 谁 知道 他 怎么 想 的 啊 而且 看 你 的 文字 总 觉得 是 很 抽风 的 那种 女生 内心 淡定 的 人才 搞 的 掂 双子 男 我 承认 我 很 抽风 本 以为 射手 和 双子 很 合拍 呢 哎 这 是 我 和 他 的 故事 您 给 个 话吧 url zj93ips 没 加 这个 组 永远 也 不会 加 脑子 进水 了 吗 好好 的 日子 不过 干嘛 非 折腾 男朋友 对方 不是人 吗 也是 爸妈 生养 的 不 怕 折腾 跑 了 吗 然后 再 低三下四 的 求 人家 回头 无语 给 你 的 建议 是 他 找 你 你 就 回应 不 找 你 别 犯贱 该 干嘛 干嘛 好 永远 别 打 这个 号码 40 | 0 致 所有 和 双 男 纠结 中的 女人 我 是 射手 女 跟 双子 男 认识 一年 多 了 关系 平淡 属于 相敬如宾 的 那种 昨晚 心血来潮 发 了 条 信息 过去 hi baby 你 睡 了 么 他 竟然 回 你 不能 这样 喊 次奥 他 这 是 拒绝 暧昧 么 是 因为 有 女朋友 了 还是 他 只是 把 我 当 普通 朋友 求解 lz 都 注销 了 求解 个 p 啊 晕 呃 好 吧 我 发帖 了 但 没人 回应 肥仔 不是 回 了 吗 问题 是 你 不 接受 人家 说 的 啊 你 问 这里 的 人 双子 男 怎么 想 的 谁 都 不是 他 肚 里 的 蛔虫 谁 知道 他 怎么 想 的 啊 而且 看 你 的 文字 总 觉得 是 很 抽风 的 那种 女生 内心 淡定 的 人才 搞 的 掂 双子 男 我 承认 我 很 抽风 本 以为 射手 和 双子 很 合拍 呢 哎 这 是 我 和 他 的 故事 您 给 个 话吧 url zj93ips 没 加 这个 组 永远 也 不会 加 脑子 进水 了 吗 好好 的 日子 不过 干嘛 非 折腾 男朋友 对方 不是人 吗 也是 爸妈 生养 的 不 怕 折腾 跑 了 吗 然后 再 低三下四 的 求 人家 回头 无语 给 你 的 建议 是 他 找 你 你 就 回应 不 找 你 别 犯贱 该 干嘛 干嘛 闪电侠 你 也 看 完了 41 | 1 咱们 学校 那个 驾校 怎么样 看到 这个 2010年 的 帖子 真 亲切 我 现在 已经 不 再 师大 了 话说 我 已经 2010年 6 月份 就 发 证 了 挺好的 据说 现在 人 很多 的 我 那时 2600 你 是 师大 毕业 的 吗 什么 专业 的 啊 校友 啊 不过 我 还 在 我 07 级 历史 的 哈哈 我 是 10 出版 的 我 认识 你 一 07 的 学姐 呵呵 啊 我们 这 最大 的 是 08 的 啊 嗯 嗯嗯 是 08 的 我 记 错了 哈哈 额 嘿嘿 嘿嘿 是 男 是 女 啊 女 的 呵呵 42 | 0 咱们 学校 那个 驾校 怎么样 看到 这个 2010年 的 帖子 真 亲切 我 现在 已经 不 再 师大 了 话说 我 已经 2010年 6 月份 就 发 证 了 挺好的 据说 现在 人 很多 的 我 那时 2600 你 是 师大 毕业 的 吗 什么 专业 的 啊 校友 啊 不过 我 还 在 我 07 级 历史 的 哈哈 我 是 10 出版 的 我 认识 你 一 07 的 学姐 呵呵 啊 我们 这 最大 的 是 08 的 啊 嗯 嗯嗯 是 08 的 我 记 错了 哈哈 额 嘿嘿 嘿嘿 是 男 是 女 啊 好 的 发 简历 吧 43 | 1 左手 摁 计算器 右手 记 数 d excel 所谓 软件 就是 预算 软件 直接 上 完毕 我 一直 都是 手写 计算 excel 这个 方法 好像 很 厉害 学习 了 可以 举 个 例子 么 我 邮箱 url 谢谢 我 干 安装 的 一样 么 44 | 0 左手 摁 计算器 右手 记 数 d excel 所谓 软件 就是 预算 软件 直接 上 完毕 我 一直 都是 手写 计算 excel 这个 方法 好像 很 厉害 学习 了 可以 举 个 例子 么 我 邮箱 url 谢谢 熊抱 45 | 1 无 争 围棋 的 棋友 们 大家 互相 认识 一下 吧 我 先 介绍 一下 自己 软件工程师 现 居 深圳 无 争 围棋 的 发起人 和 主要 维护 者 爱 下 围棋 有 近 二十 年 棋 龄 但 水平 不 高 url 打 不 开 无 争 网 了 郁闷 已经 恢复 正常 服务器 偶 有 不 稳定 情况 惭愧 见谅 46 | 0 无 争 围棋 的 棋友 们 大家 互相 认识 一下 吧 我 先 介绍 一下 自己 软件工程师 现 居 深圳 无 争 围棋 的 发起人 和 主要 维护 者 爱 下 围棋 有 近 二十 年 棋 龄 但 水平 不 高 url 打 不 开 无 争 网 了 郁闷 把 他 当成 你 了 47 | 1 每日 好习惯 随时 更新 lz 啊 有没有 男女 不一样 的 地方 啊 肯定 有 啦 私 以为 男人 只要 不 吸烟 少 喝酒 吃 早餐 午饭 不 凑合 晚上 不 暴饮暴食 少 淫欲 多 运动 就是 最好 的 养生 啦 那 我 都 做到 啊 岂不 是 完美 了 那个 吃 豆浆 的 男生 好像 不好 吧 虽然 对 女人 特别 好 但 对 男人 也 没有 不好 啦 别 太 纠结 这些 细节 了 太 纠结 本身 也是 问题 对 吧 你 已经 做 的 挺 不错 了 就 继续 保持 好习惯 吧 有 空 的 时候 把 这些 观念 传达 给 更多 的 人 会 更加 快乐 我 一直 本着 养生 原则 48 | 0 每日 好习惯 随时 更新 lz 啊 有没有 男女 不一样 的 地方 啊 肯定 有 啦 私 以为 男人 只要 不 吸烟 少 喝酒 吃 早餐 午饭 不 凑合 晚上 不 暴饮暴食 少 淫欲 多 运动 就是 最好 的 养生 啦 那 我 都 做到 啊 岂不 是 完美 了 那个 吃 豆浆 的 男生 好像 不好 吧 虽然 对 女人 特别 好 但 对 男人 也 没有 不好 啦 别 太 纠结 这些 细节 了 太 纠结 本身 也是 问题 对 吧 你 已经 做 的 挺 不错 了 就 继续 保持 好习惯 吧 有 空 的 时候 把 这些 观念 传达 给 更多 的 人 会 更加 快乐 天蝎 的 美女 啊 哈哈 周围 有 天蝎 的 确实 感觉 神秘 啊 你 的 头像 就 很 神秘 我 见到 别的 女生 也 会 打 招呼 聊天 但是 不会 像 女朋友 那样 对付 一个 女朋友 就 已经 很 累 了 我 是 不会 去 找 麻烦 脚 踩 2 只 船 太 麻烦 了 有 那 功夫 我 去 干点 自己 喜欢 的 事情 朋友 在 我 眼里 不分 男女 但是 还是 哥们 多 些 不会 有什么 这个 颜 那个 颜 的对 女生 仅 限 偶尔 聊天 打 招呼 什么 的 不会 短信 电话 不断 如果 这样 就 有 问题 了 我 的 立场 还是 讲 清楚 他 不 妥协 不 改 那 就 散 自己 去 想 吧 想 清楚 也 没 机会 了 2 个人 的 生活 其实 就是 妥协 找到 平衡 点 偶尔 冷 他 天天 对 他 好 对 你 没 好处 估计 你 男朋友 还 不 成熟 需要 经历 痛苦 49 | 1 珠海 哪 间 医院 看 皮肤科 比较 有名 皮 防 所 看 痘痘 在 紫荆园 附近 是不是 招牌 是 绿色 的 字体 大大 间 系 转角 位 咩 色 唔 记得 招牌 好 大 个 好似 系 皮肤 防疫 中心 对面 是 个 运动场 对 吧 一直 以为 那 家 是 美容 院 治 痘痘 很 出名 到 七八 点 还是 会 很多 人 但是 查 地图 好像 是 在 紫荆 豪庭 对面 马路 那边 了 50 | 0 珠海 哪 间 医院 看 皮肤科 比较 有名 皮 防 所 看 痘痘 在 紫荆园 附近 是不是 招牌 是 绿色 的 字体 大大 间 系 转角 位 咩 色 唔 记得 招牌 好 大 个 好似 系 皮肤 防疫 中心 对面 是 个 运动场 对 吧 一直 以为 那 家 是 美容 院 治 痘痘 很 出名 到 七八 点 还是 会 很多 人 换 成 注明 来自 豆瓣 注明 应聘 职位 51 | 1 客观分析 天蝎 男 纯 原创 2010 08 30 15 49 53 joy 天蝎 男 是 很 贱 根据 我 跟 蝎 男 交往 1年 零 3 个 月 的 经验 看 对付 蝎 男 要 做到 以下 几 点 1 不能 太 懂事 他 犯浑 的 时候 你 要 比 他 还 浑 2 不能 总 给 他 好脸 他 乖 的 时候 就 对 他 温柔 他 犯 sb 的 时候 就 甭 搭理 他 绝对 不能 依 着 他 3 记住 他 说 的 话 他 做 的 事 再 吵架 的 时候 用 他 自己 的 话 回 他 那 强盗逻辑 让 他 哑口无言 用 他 对待 你 的 方式 对待 他 等 他 质问 你 的 时候 告诉 他 我 为什么 不能 这么 对待 你 4 表面 上 顺从 他 但 别 心理 真 顺从 不要 被 他 同化 了 5 适时 撒泼 耍赖 记住 他们 贱 的 很 6 爱 自己 多 一点 真心 赞 很 赞同 · · · · 现在 刚 和 蝎子 开始 唉 · · · · 日后 还 长 着 蝎子 说 过 我 很 要强 他 很 喜欢 这 是 有 征服 欲 吗 必须的 征服 欲 啊 之后 就 会 对 你 这种 个性 挑三拣四 再 后来 就是 大 加 讽刺 再 再 后来 就是 攻击 人格 达到 虐 人 的 快感 慢慢 来 吧 不 着急 被 蝎子 爱着 的 时候 还是 很 美好 的 他 可以 给 你 所有 的 少女 幻想 我 觉得 我 完蛋 了 · · · · · 52 | 0 客观分析 天蝎 男 纯 原创 2010 08 30 15 49 53 joy 天蝎 男 是 很 贱 根据 我 跟 蝎 男 交往 1年 零 3 个 月 的 经验 看 对付 蝎 男 要 做到 以下 几 点 1 不能 太 懂事 他 犯浑 的 时候 你 要 比 他 还 浑 2 不能 总 给 他 好脸 他 乖 的 时候 就 对 他 温柔 他 犯 sb 的 时候 就 甭 搭理 他 绝对 不能 依 着 他 3 记住 他 说 的 话 他 做 的 事 再 吵架 的 时候 用 他 自己 的 话 回 他 那 强盗逻辑 让 他 哑口无言 用 他 对待 你 的 方式 对待 他 等 他 质问 你 的 时候 告诉 他 我 为什么 不能 这么 对待 你 4 表面 上 顺从 他 但 别 心理 真 顺从 不要 被 他 同化 了 5 适时 撒泼 耍赖 记住 他们 贱 的 很 6 爱 自己 多 一点 真心 赞 很 赞同 · · · · 现在 刚 和 蝎子 开始 唉 · · · · 日后 还 长 着 蝎子 说 过 我 很 要强 他 很 喜欢 这 是 有 征服 欲 吗 必须的 征服 欲 啊 之后 就 会 对 你 这种 个性 挑三拣四 再 后来 就是 大 加 讽刺 再 再 后来 就是 攻击 人格 达到 虐 人 的 快感 慢慢 来 吧 不 着急 被 蝎子 爱着 的 时候 还是 很 美好 的 他 可以 给 你 所有 的 少女 幻想 人生 中 总 有 过客 嘛 痛 过 就 好 了 53 | 1 如何 学好 古代汉语 在下 的 个人 体会 学 古文 最 快 的 方法 就是 背书 时间 紧张 起码 要 背 四书 因为 在 过去 所有 读书 的 人 都是 背 了 四书 的 包括 亲手 革 掉 古文 命 的 五四 新文学 领袖 们 以及 大 部分 老一辈 无产阶级革命家 背书 的 具体 方法 首先 明确 每个 字 的 读音 再 把 它 大声 地念 若干 遍 你 会 立刻 发现 汉语 的 音乐 性 很快 就 会 喜欢 老祖宗 编曲 的 古老 歌谣 了 有 一点 像 疯狂英语 但 其实 疯狂英语 是 借鉴 老 办法 的 你好 啊 我 想 问 下 初 接触 古文 古籍 里面 那些 不认识 的 字 的 读音 怎样 读 呀 去 哪 查 呢 十分 感谢 有 很多 办法 给 你 个 最 快 的 url 54 | 0 如何 学好 古代汉语 在下 的 个人 体会 学 古文 最 快 的 方法 就是 背书 时间 紧张 起码 要 背 四书 因为 在 过去 所有 读书 的 人 都是 背 了 四书 的 包括 亲手 革 掉 古文 命 的 五四 新文学 领袖 们 以及 大 部分 老一辈 无产阶级革命家 背书 的 具体 方法 首先 明确 每个 字 的 读音 再 把 它 大声 地念 若干 遍 你 会 立刻 发现 汉语 的 音乐 性 很快 就 会 喜欢 老祖宗 编曲 的 古老 歌谣 了 有 一点 像 疯狂英语 但 其实 疯狂英语 是 借鉴 老 办法 的 你好 啊 我 想 问 下 初 接触 古文 古籍 里面 那些 不认识 的 字 的 读音 怎样 读 呀 去 哪 查 呢 十分 感谢 啊 啊 啊 啊 啊 那 都是 刷 到 眼 瞎 才 挑 出来 的 精品 啊 55 | 1 业余 建筑 工作室 或者 王澍 老师 的 联系方式 13957176938 但是 可惜 他 不 接 电话 不 回 短信 不如 找 他 夫人 陆文 宇 好说 话 这个 是 他 的 号码 么 没人 接 56 | 0 业余 建筑 工作室 或者 王澍 老师 的 联系方式 13957176938 但是 可惜 他 不 接 电话 不 回 短信 不如 找 他 夫人 陆文 宇 好说 话 这个 是 他 的 号码 么 ca113105 只有 80f 和 85f 拼 价 470 57 | 1 找人 一起 合作 写 推理 小说 我 还 想 问 下 帅 楼主 是 同志 吗 我 总 觉得 你 不是 同志 会 很 可惜 eautiful girls q 58 | 0 找人 一起 合作 写 推理 小说 我 还 想 问 下 帅 楼主 是 同志 吗 我 总 觉得 你 不是 同志 会 很 可惜 eautiful girls 那 我 还是 找 下 一家 59 | 1 月亮 摩羯 的 使命 是 征服 日 狮 月 摩 日 狮 月 摩 1 日 狮 月 摩 上升 天蝎 哎 外表 冷 脸 没有 表情 内心 火热 冲动 但 大脑 又 控制 自己 要 冷静 征服 好生 纠结 60 | 0 月亮 摩羯 的 使命 是 征服 日 狮 月 摩 日 狮 月 摩 1 日 狮 月 摩 上升 天蝎 哎 外表 冷 脸 没有 表情 内心 火热 冲动 但 大脑 又 控制 自己 要 冷静 征服 没 胆量 了 吧 61 | 1 假如 晓霞 活 着 少 平 会不会 跟 她 结婚 别说 了 我 八年 前 看 的 现在 想想 看到 晓霞 死 那 一段 的 时候 哭 坏 了 好 巧 啊 我 也是 8年 前 看 的这 本 书 好 巧 有缘 62 | 0 假如 晓霞 活 着 少 平 会不会 跟 她 结婚 别说 了 我 八年 前 看 的 现在 想想 看到 晓霞 死 那 一段 的 时候 哭 坏 了 好 巧 啊 我 也是 8年 前 看 的这 本 书 我 会 拼命 哒 失 兄 我 年底 来 给 你 汇报 好消息 63 | 1 测测 自己 生命的颜色 宁佳 心 是 蓝色 张小伟 是 黑色 呵 呵呵 呵呵 呵呵 呵呵 你 也 看 了 阳光姐姐 的 单翼天使不孤单 啊 我 也 看 了 我 有 本 好好 看 啊 我 也 有 好看 点 一百个 赞 好好 看 啊 64 | 0 测测 自己 生命的颜色 宁佳 心 是 蓝色 张小伟 是 黑色 呵 呵呵 呵呵 呵呵 呵呵 你 也 看 了 阳光姐姐 的 单翼天使不孤单 啊 我 也 看 了 我 有 本 好好 看 啊 我 也 有 好看 点 一百个 赞 不过 只是 时间 上 不 顺 的 话 还好 说 oo 65 | 1 我 在 北京 我 要 学 意大利语 请 大家 指点 好 的 学校 我 刚 学 的 意大利语 在 新东方 学 的 还 不错 的 就是 课程 排 的 有些 紧 口语 听力 得 自己 练 语法 讲 的 非常 详细 意大利语 也 只有 在 北京 的 新东方 有 吧 都是 中教 我 不知道 别的 新东方 有 米 有 我 是 在 北京 学 的 我们 这个 班 是 一个 中教 一个 外教 中教 主要 负责 语法 外教 主要 负责 语音 感觉 怎么样 啊 课程 安排 的 非常 紧 新东方 的 学费 比较 低 课时 少 口语 和 听力 需要 课 下 自己 苦练 没有 上课 时间 练习 但是 语法 讲 的 非常 好 最好 不要 上 集中 的 课程 周末 班 比较 好 每周 2 天课 每天 6 小时 这 就 差不多 是 这 一 周 该 消化 的 了 老师 讲 的 挺好的 每个 班 20 个人 左右 上课 都 顾及 的 到 只要 用心 学 把 每周 讲 的 复习 好 跟上 没 问题 我 初级 学 完 以后 还 打算 在 新东方 报 中级 班 66 | 0 我 在 北京 我 要 学 意大利语 请 大家 指点 好 的 学校 我 刚 学 的 意大利语 在 新东方 学 的 还 不错 的 就是 课程 排 的 有些 紧 口语 听力 得 自己 练 语法 讲 的 非常 详细 意大利语 也 只有 在 北京 的 新东方 有 吧 都是 中教 我 不知道 别的 新东方 有 米 有 我 是 在 北京 学 的 我们 这个 班 是 一个 中教 一个 外教 中教 主要 负责 语法 外教 主要 负责 语音 感觉 怎么样 啊 蕾丝 少 了 像 泳衣 67 | 1 征集 征集 不和 婆婆 住 的 十大 理由 我 跟 我 老公 外加 我 婆婆 和 大姑子 去 给 我 老公 买 裤子 我 婆婆 就 当 我 不 存在 给 她 亲 儿子 选 裤子 还 亲自 给 拽拽 裤腿 提提 裆 真的 是 托 着 啦 还 问 他 裆部 紧 不 紧 我 简直 是 目瞪口呆 旁边 碰 过来 碰 过去 超级 呕 腥 哎 还有 现在 不是 夏天 吗 他 妈 在家 穿 睡衣 睡衣 蛮 透 的 也 不知道 穿 胸罩 估计 是 觉得 没 胸 穿 不 穿 无 所谓 吧 就 看 两 颗 大 粒 的 黑葡萄 在 我 面前 晃 来 晃 去 我 就不 相信 他 儿子 看不 到 后来 有 一次 在 饭桌 上 我 看 了 他 妈 的 胸 又 看看 我 老公 我 老公 看 我 眼神 异常 才 发现 叫 他 妈 去 换 衣服 去 他 妈 可 听 他 儿子 话 了 就 去 换 了 衣服 不过 这次 换 了 下次 还 照 就 然后 还有 他 妈 上午 睡 回笼觉 的 时候 房间 门 也 不 关 两个 房间 门 是 门对 门 我 一 开门 就 看 他 妈 穿 个 透 透 的 破 大 裤 头 翘 个 屁股 在 睡觉 我 好几 次 都 悄悄 的 关上 她 的 门 了 那 我 老公 先 起 不 也 看到 了 他 儿子 也 不 小 了 也 不知道 注意 点 都 说 儿 大 防 母女 大 防 f 父 父母 就 没 点 自觉 吗 而且 你 老公 不会 觉得 不自在 估计 也 都 习惯 了不 过 我 看到 你 这么 说 都 恶心 想起 月子 里 老公 晚上 洗 完 澡 穿着 内裤 和 婆婆 说话 我 都 觉得 别扭 68 | 0 征集 征集 不和 婆婆 住 的 十大 理由 我 跟 我 老公 外加 我 婆婆 和 大姑子 去 给 我 老公 买 裤子 我 婆婆 就 当 我 不 存在 给 她 亲 儿子 选 裤子 还 亲自 给 拽拽 裤腿 提提 裆 真的 是 托 着 啦 还 问 他 裆部 紧 不 紧 我 简直 是 目瞪口呆 旁边 碰 过来 碰 过去 超级 呕 腥 哎 还有 现在 不是 夏天 吗 他 妈 在家 穿 睡衣 睡衣 蛮 透 的 也 不知道 穿 胸罩 估计 是 觉得 没 胸 穿 不 穿 无 所谓 吧 就 看 两 颗 大 粒 的 黑葡萄 在 我 面前 晃 来 晃 去 我 就不 相信 他 儿子 看不 到 后来 有 一次 在 饭桌 上 我 看 了 他 妈 的 胸 又 看看 我 老公 我 老公 看 我 眼神 异常 才 发现 叫 他 妈 去 换 衣服 去 他 妈 可 听 他 儿子 话 了 就 去 换 了 衣服 不过 这次 换 了 下次 还 照 就 然后 还有 他 妈 上午 睡 回笼觉 的 时候 房间 门 也 不 关 两个 房间 门 是 门对 门 我 一 开门 就 看 他 妈 穿 个 透 透 的 破 大 裤 头 翘 个 屁股 在 睡觉 我 好几 次 都 悄悄 的 关上 她 的 门 了 那 我 老公 先 起 不 也 看到 了 他 儿子 也 不 小 了 也 不知道 注意 点 我 的 最爱 69 | 1 福州 宠物 医院 哪 家 好 呢 我 的 喵 在 善化 坊 那边 的 精灵 仁爱 医院 包括 绝育 驱虫 咳嗽 之类 的 东西 挖坟 帖 你 还 回 已经 有人 挖坟 了 我 也 跟着 挖 呗 70 | 0 福州 宠物 医院 哪 家 好 呢 我 的 喵 在 善化 坊 那边 的 精灵 仁爱 医院 包括 绝育 驱虫 咳嗽 之类 的 东西 挖坟 帖 你 还 回 哦哦 这样 那 只能 祝 你 好运 咯 71 | 1 日本 建筑师 事务所 官网 收集 天津 银河广场 的 图书 馆 是 日本 设计师 设计 的 吗 是 山本 理 显 我 说 呢 谢 啦 72 | 0 日本 建筑师 事务所 官网 收集 天津 银河广场 的 图书 馆 是 日本 设计师 设计 的 吗 是 山本 理 显 我 和 我 ex 不是 是 高中同学 后来 异地 了 73 | 1 在 景区 做 过 两年 导游 解答 各类 关于 乌镇 的 问题 到了 桐乡站 怎么 到 乌镇 乘坐 k282 5 元 人 终点 站 就是 乌镇 汽车站 时刻表 url 公交 么 嗯 公交 车 好 的 谢谢 啦 不客气 哈 我 在 乌镇 住 两天 会不会 有点 多余 住 一 天 两天 都 可以 啊 你 大概 的 时候 行程 安排 有 吗 改 时间 了 住 21 22 号 两天 一 天 西 栅 一 天 东 栅 那 ok 你 慢慢 逛 好 了 74 | 0 在 景区 做 过 两年 导游 解答 各类 关于 乌镇 的 问题 到了 桐乡站 怎么 到 乌镇 乘坐 k282 5 元 人 终点 站 就是 乌镇 汽车站 时刻表 url 公交 么 嗯 公交 车 好 的 谢谢 啦 不客气 哈 我 在 乌镇 住 两天 会不会 有点 多余 住 一 天 两天 都 可以 啊 你 大概 的 时候 行程 安排 有 吗 改 时间 了 住 21 22 号 两天 一 天 西 栅 一 天 东 栅 0 0 好 吧 语文 没 学好 改 之 75 | 1 原创 tal ben shahar 三本 英文 著作 下载 地址 _url_ 以上 是 他 三本 重要 著作 的 pdf 下载 方式 希望 对 大家 有 帮助 这个 网站 支持 免费 下载 大家 可以 自主 查询 更多 积极心理学 相关 的 文献 钓鱼链接 不要 在 這 裡 瞎 留言 危言 聳 聽 76 | 0 原创 tal ben shahar 三本 英文 著作 下载 地址 _url_ 以上 是 他 三本 重要 著作 的 pdf 下载 方式 希望 对 大家 有 帮助 这个 网站 支持 免费 下载 大家 可以 自主 查询 更多 积极心理学 相关 的 文献 钓鱼链接 现在 就 去 暖 会不会 太 早 77 | 1 性 与 福气 2 一个 曾经 很 阳光 的 香港 男星 由于 其 糜烂 的 私生活 而 导致 前程 尽 毁 陈冠希 他 还有 很多 福报 过去 世 修 的 福报 很 大 你 如何 得知 啊 貌似 他 是 基督徒 78 | 0 性 与 福气 2 一个 曾经 很 阳光 的 香港 男星 由于 其 糜烂 的 私生活 而 导致 前程 尽 毁 陈冠希 他 还有 很多 福报 过去 世 修 的 福报 很 大 呵呵 谢谢 你 晓 同学 因为 现在 陈晓红 了 总 有些 人 到处 黑 他 找不到 黑 料 就 黑 他 长相 没 辨识 度 神马 的 真心 看 了 无语 你 也是 学 表演 的 吧 祝福 你 的 星 路 一 路 顺利 79 | 1 每个 人 进 来说 一个 西海岸 的 元素 好 么 雪茄 算 么 黑暗 交易 黑暗 交易 就是 那种 匪帮 盗卖 军火 那种 的 神马 玩意儿 哦哦 了解 80 | 0 每个 人 进 来说 一个 西海岸 的 元素 好 么 雪茄 算 么 黑暗 交易 黑暗 交易 就是 那种 匪帮 盗卖 军火 那种 的 神马 玩意儿 我 上升 天蝎 81 | 1 我 喜欢 犯贱 怎么办 典型 的 犯贱 你 就 想 找 虐 就 冲 你 那 句 不 缺 女人 我 就 对 你 咬牙切齿 像 你 这种 不 负 责任 的 男人 祝 你 将来 被 伤 的 很 深 顺带 一句 感觉 楼主 是 实在 人 说话 句句 中肯 确实 很 贱 的说 幸好 你 还有 自知之明 我 讨厌 把 女人 不 当 一 回事 的 男人 我 妈 是 女人 我 将来 孩 他 娘 也是 女人 单 凭 这点 不说 高尚 的 男女平等 的 社会 论调 不 谈 高端 的 人性 哲学 尊重 女性 朋友 没 啥 话说 咱俩 有点 跑题 了 露珠 应该 表达 的 是 现在 不 在乎 找到 找不到 女朋友 用 词 不 当 语境 使然 配合 露珠 本 篇 帖子 的 本意 是 你 我 在此 自作多情 罢了 82 | 0 我 喜欢 犯贱 怎么办 典型 的 犯贱 你 就 想 找 虐 就 冲 你 那 句 不 缺 女人 我 就 对 你 咬牙切齿 像 你 这种 不 负 责任 的 男人 祝 你 将来 被 伤 的 很 深 顺带 一句 感觉 楼主 是 实在 人 说话 句句 中肯 确实 很 贱 的说 幸好 你 还有 自知之明 我 讨厌 把 女人 不 当 一 回事 的 男人 因为 认识 一 女 的 也是 这 配置 比 凤姐 和 丽娟 还 流弊 没 想到 一 猜 你 就是 这 配置 忒 落 俗套 了 饭 去 恁 继续 高傲 ps 你 的 腻 秤 很 有 趣 83 | 1 同学 们 我们 来 总结 一下 高中 的 教 过 你 的 老师 吧 高一 高二 高三 ing 语文 唐远 霞 数学 马静 英语 袁 秦 物理 邓 战 军 化学 梁 光 斐 生物 廖慧 历史 杨秋萍 政治 杨耘 地理 冷 咏 松 哈哈 哈哈 我们 生物 历史 政治 都 一样 诶 好 喜欢 啦 们 哦 廖慧 就是 太 瘦 哦 身体 不好 有点 造孽 最 喜欢 上 秋 萍 姐 诶 课 每次 就 像 时装表演 一样 杨耘 是 我 高一 高二 班主任 蛮好 诶 是 勒 不晓得 廖慧 现在 生 崽 没 得 杨 姨妈 肯定 好 么 你 是 11 届 勒 嗯嗯 我 13 班 诶 你 哪 班 诶 嘛 26 勒 你 叫 乃 名字 嘛 我 认 到 你们 班 王 y 84 | 0 同学 们 我们 来 总结 一下 高中 的 教 过 你 的 老师 吧 高一 高二 高三 ing 语文 唐远 霞 数学 马静 英语 袁 秦 物理 邓 战 军 化学 梁 光 斐 生物 廖慧 历史 杨秋萍 政治 杨耘 地理 冷 咏 松 哈哈 哈哈 我们 生物 历史 政治 都 一样 诶 好 喜欢 啦 们 哦 廖慧 就是 太 瘦 哦 身体 不好 有点 造孽 最 喜欢 上 秋 萍 姐 诶 课 每次 就 像 时装表演 一样 杨耘 是 我 高一 高二 班主任 蛮好 诶 是 勒 不晓得 廖慧 现在 生 崽 没 得 杨 姨妈 肯定 好 么 你 是 11 届 勒 嗯嗯 我 13 班 诶 你 哪 班 诶 嘛 嗯嗯 其实 对于 我 来说 无 所谓 但 我 征求 了 目前 住 的 几 位 gg 的 意见 他们 不 太 愿意 哟 真的 很 抱歉 希望 你们 能 找到 合适 的 房子 85 | 1 3 16 更新 wow 小白 经典 事件 直播 贴 这 是 谁 的 一 铲子 这 帖子 时不时 就 有人 挖 上来 的 多大 仇 系列 我 一直 以为 你 是 从 2x 版本 开始 玩 的 我 不 觉得 有什么 诶 挖坟 人 的 动机 我 都 没 所谓 了 因为 谁 都是 从 小白 过来 的 啊 看看 这个 我 反而 觉得 自己 魔兽 没 白 玩 我 是 3 13 后期 的 玩家 了 遇到 了 比较 好 的 基友 和 团队 所以 现在 能 打打 还 看得 过去 的 进度 fk 驾鹤西去 删 号 自焚 的 只能 在 网吧 里 摆摆 老资格 嘲讽 下 90后 小 朋友 了 哈哈 哈哈 哈 真是 妥 艳 你 知道 战士 盾 反 要 切 姿态 吗 我们 那 时候 惩戒 打架 要 用 一 级 命令 生存 射击 猎 远程 射 死 布衣 近战 砍 死 战士 贼 的 年代 你 不知道 吧 真正 高端 贼 能 用 剥皮 小刀 戳 死 r14 战士 真是 尽 现 骨灰 级 玩家 的 丑恶 嘴脸 啊 哈哈 哈哈 哈哈 哈 小 朋友 们 那 崇拜 的 小 眼神 〜 那种 对 老 玩家 发自 灵魂 深处 很 不 得 当场 脱 裤 献 菊 的 向往 啊 〜 86 | 0 3 16 更新 wow 小白 经典 事件 直播 贴 这 是 谁 的 一 铲子 这 帖子 时不时 就 有人 挖 上来 的 多大 仇 系列 我 一直 以为 你 是 从 2x 版本 开始 玩 的 我 不 觉得 有什么 诶 挖坟 人 的 动机 我 都 没 所谓 了 因为 谁 都是 从 小白 过来 的 啊 看看 这个 我 反而 觉得 自己 魔兽 没 白 玩 我 是 3 13 后期 的 玩家 了 遇到 了 比较 好 的 基友 和 团队 所以 现在 能 打打 还 看得 过去 的 进度 fk 驾鹤西去 删 号 自焚 的 只能 在 网吧 里 摆摆 老资格 嘲讽 下 90后 小 朋友 了 哈哈 哈哈 哈 真是 妥 艳 晚安 晚安 87 | 1 dele 中级 考试 心得 2 考 来 真 没什么 用 怎么 讲 2 拿 了 90 左右 后来 去 准备 selectividad 还是 要 没日没夜 地学 要 真心 想 学好 一门 语言 c 等级 以上 才 算是 敲门砖 吧 累 感 不 爱 不过 谢谢 是 这样 的 除非 十分 喜欢 学 的这 门 语言 不然 学 起来 真的 很 累 不用 客气 88 | 0 dele 中级 考试 心得 2 考 来 真 没什么 用 怎么 讲 2 拿 了 90 左右 后来 去 准备 selectividad 还是 要 没日没夜 地学 要 真心 想 学好 一门 语言 c 等级 以上 才 算是 敲门砖 吧 累 感 不 爱 不过 谢谢 逐年 递增 销售额 为什么 就不 能 是 别人 不知道 的 来 买 为什么 非 要是 回头客 你 这 什么 逻辑 89 | 1 认知疗法 重建 你 的 睡眠 想法 必 看 组长 你 有 句 话说 到 我 心里 去了 我 白天 的 糟糕 感觉 并不 仅 是 因为 我 的 失眠 很 大 程度 上 源 自我 糟糕 的 负面 想法 以前 我 是 因为 为 不会 如何 睡觉 现在 我 越来越 清楚 应该 如何 睡了 睡眠 质量 也 越来 好 可以 很快 入睡 即使 醒 了 也 很快 再次 睡着 可以 睡 到 早上 但是 就 在 我 这 两天 觉得 我 可以 和 失眠 再见 可以 正常 生活 的 时候 我 又 莫名 的 出现 很多 对 睡觉 怪异 的 想法 比如 我 怎么 就 睡着 了 闭眼 睁眼 这么 长 时间 就 过去了 之类 这种 无 里头 的 想法 以至于 这 想 问题 晚上 又 整夜 无法 入睡 不知道 是 因为 想 弄 明白 这些 无聊 的 问题 还是 因为 以后 都 纠结 在 这些 问题 上 放 不 下 而 睡不着 或 有 这种 想法 而 不敢 入睡 我 对 自己 真的 很 无语 国庆 在家 的 时候 和 妈妈 一起 睡 特别 好像 是 有 种 动力 感觉 像 是 她睡了 我 也 要 快点 睡 有点 像 是 较劲 我 要 睡 的 好 所以 那 7 天 每天 都是 晚上 9 10 点 睡 可以 立马 睡着 中途 醒 了 也 不 再 意 可以 再 睡 可以 睡 到 早上 6 7 点 可是 现在 一个人睡 就 会 胡思乱想 我 到底 是 怎么 了 真的 很 烦 不 推荐 这 篇 文章 组长 我 只是 希望 你 帮 我 解惑 下 一边 期待 睡觉 一边 对 睡觉 又 带有 恐惧 这 是不是 就是 害怕 失眠 的 一种 表现 害怕 失眠 本身 就是 一种 表现 我们 讨论 的 问题 如果 不 脱离 表现 和 各种 表象 就不 会 对 你 有 任何 帮助 90 | 0 认知疗法 重建 你 的 睡眠 想法 必 看 组长 你 有 句 话说 到 我 心里 去了 我 白天 的 糟糕 感觉 并不 仅 是 因为 我 的 失眠 很 大 程度 上 源 自我 糟糕 的 负面 想法 以前 我 是 因为 为 不会 如何 睡觉 现在 我 越来越 清楚 应该 如何 睡了 睡眠 质量 也 越来 好 可以 很快 入睡 即使 醒 了 也 很快 再次 睡着 可以 睡 到 早上 但是 就 在 我 这 两天 觉得 我 可以 和 失眠 再见 可以 正常 生活 的 时候 我 又 莫名 的 出现 很多 对 睡觉 怪异 的 想法 比如 我 怎么 就 睡着 了 闭眼 睁眼 这么 长 时间 就 过去了 之类 这种 无 里头 的 想法 以至于 这 想 问题 晚上 又 整夜 无法 入睡 不知道 是 因为 想 弄 明白 这些 无聊 的 问题 还是 因为 以后 都 纠结 在 这些 问题 上 放 不 下 而 睡不着 或 有 这种 想法 而 不敢 入睡 我 对 自己 真的 很 无语 国庆 在家 的 时候 和 妈妈 一起 睡 特别 好像 是 有 种 动力 感觉 像 是 她睡了 我 也 要 快点 睡 有点 像 是 较劲 我 要 睡 的 好 所以 那 7 天 每天 都是 晚上 9 10 点 睡 可以 立马 睡着 中途 醒 了 也 不 再 意 可以 再 睡 可以 睡 到 早上 6 7 点 可是 现在 一个人睡 就 会 胡思乱想 我 到底 是 怎么 了 真的 很 烦 不 推荐 这 篇 文章 组长 我 只是 希望 你 帮 我 解惑 下 一边 期待 睡觉 一边 对 睡觉 又 带有 恐惧 这 是不是 就是 害怕 失眠 的 一种 表现 他 最近 的 表现 的确 反常 很多 时候 感觉 心思 都 不在 节目 里 91 | 1 求助 tactical planning 面试 前 需要 准备 什么 战术 策划 数字 敏感 些 高数 最好 好 点 excel 好 两年 前 入 行 前 得 帖子 结果 没 去 做 tp 去 做 了 策划 p 到 变成 planning 我 当初 面试 的 时候 那 人 认为 我 更 适合 做 策划 就 推荐 我 去 了 策划 组 前后 面 了 三 次 请问 前辈 在哪 家 公司 高就 能够 如此 甄选 人才 92 | 0 求助 tactical planning 面试 前 需要 准备 什么 战术 策划 数字 敏感 些 高数 最好 好 点 excel 好 两年 前 入 行 前 得 帖子 结果 没 去 做 tp 去 做 了 策划 p 到 变成 planning 我 当初 面试 的 时候 那 人 认为 我 更 适合 做 策划 就 推荐 我 去 了 策划 组 前后 面 了 三 次 慢慢 学 吧 93 | 1 大家 觉得 海贼 里头 哪些 歌 好听 路飞 神曲 在 空岛 我 也 喜欢 他 那个 小调 可爱 瞎 了 我 会 唱 94 | 0 大家 觉得 海贼 里头 哪些 歌 好听 路飞 神曲 在 空岛 我 也 喜欢 他 那个 小调 可爱 瞎 了 任何 的 爱好 不 良 嗜好 都 有 独特 的 乐趣 我 安慰 我 自己 95 | 1 邯郸 有 哪 几个 不错 的 书店 2005年 8月29日 lz 发 了 这个 贴 今天 是 2011年 8月10日 如果 他 发帖 那天 和 某个 姑娘 上 了 床 没 做好 保护 那 今天 他们 的 小孩 儿 都 要 上 小学 了 他 妈 的 幸 不 辱命 组长 难 的 现身 啊 96 | 0 邯郸 有 哪 几个 不错 的 书店 2005年 8月29日 lz 发 了 这个 贴 今天 是 2011年 8月10日 如果 他 发帖 那天 和 某个 姑娘 上 了 床 没 做好 保护 那 今天 他们 的 小孩 儿 都 要 上 小学 了 他 妈 的 幸 不 辱命 哦 thx anyway 97 | 1 个人 关于 直觉 型 人 学 外语 的 感想 我 觉得 一切 都 应该 是 我 执行力 不够 影响 的 英语 背 单词 什么 的 是 这样 我 也 觉得 很 痛苦 但是 难受 的 读 完 一篇 生僻 文章 再 把 每个 单词 查 出来 什么意思 效果 很好 虽然 耗时 久 · · · 但是 一个个 背 我 根本 不 可能 坚持 · · · 同感 强 n 型 的 人 拿 着 单词 本 背 单词 是 种 折磨 我 更 喜欢 阅读 先 不 查 生 单词 全部 读 下来 再 把 所有 的 生 单词 查 出来 然后 把 文章 再 看 一两 遍 理解 意思 仍然 不 记 单词 然后 再 读 另 一篇 文章 每天 这样 坚持 会 发现 很多 生 单词 是 重复 出现 的 即 高频词汇 或者 说 是 你 以前 查 出来 过 有 印象 但是 不 记得 意思 的 单词 反复 出现 的 单词 重点 记忆 这时候 就是 记忆 强化 和 重复 的 过程 坚持 每天 阅读 下去 甚至 不用 刻意 记 单词 会 发现 需要 查 出来 的 生 单词 越来越 少 词汇 自然 就 积累 了 阅读 文章 实际 上 是 生 单词 在 语境 中的 应用 理解 性 记忆 远 好 于 死记硬背 我 最近 逼 自己 用 拓词 机械 重复 但是 效果 还 不错 双管齐下 吧 其实 如果 我 现在 小学 不 着急 的 话 应该 会 好好 疼爱 我 的 英英 词典 柯林斯 很 不错 恩 顺便 打 个 广告 自从 有道词典 添加 了 柯林斯 词典 后 基本 告别 其他 所有 词典 用 有道 柯林斯 词典 很 方便 例句 和 解释 都 非常 实用 且 易于 理解 长期 用 有道词典 手机 版 的 路过 98 | 0 个人 关于 直觉 型 人 学 外语 的 感想 我 觉得 一切 都 应该 是 我 执行力 不够 影响 的 英语 背 单词 什么 的 是 这样 我 也 觉得 很 痛苦 但是 难受 的 读 完 一篇 生僻 文章 再 把 每个 单词 查 出来 什么意思 效果 很好 虽然 耗时 久 · · · 但是 一个个 背 我 根本 不 可能 坚持 · · · 同感 强 n 型 的 人 拿 着 单词 本 背 单词 是 种 折磨 我 更 喜欢 阅读 先 不 查 生 单词 全部 读 下来 再 把 所有 的 生 单词 查 出来 然后 把 文章 再 看 一两 遍 理解 意思 仍然 不 记 单词 然后 再 读 另 一篇 文章 每天 这样 坚持 会 发现 很多 生 单词 是 重复 出现 的 即 高频词汇 或者 说 是 你 以前 查 出来 过 有 印象 但是 不 记得 意思 的 单词 反复 出现 的 单词 重点 记忆 这时候 就是 记忆 强化 和 重复 的 过程 坚持 每天 阅读 下去 甚至 不用 刻意 记 单词 会 发现 需要 查 出来 的 生 单词 越来越 少 词汇 自然 就 积累 了 阅读 文章 实际 上 是 生 单词 在 语境 中的 应用 理解 性 记忆 远 好 于 死记硬背 我 最近 逼 自己 用 拓词 机械 重复 但是 效果 还 不错 双管齐下 吧 其实 如果 我 现在 小学 不 着急 的 话 应该 会 好好 疼爱 我 的 英英 词典 柯林斯 很 不错 对 滴 转租合同 99 | 1 羊 男 蝎 女修 成 正果 了 可怜 的 我 正在 分手 期 不过 我 觉得 他 是 想 冷静 冷静 还有 回转 的 余地 他 说 他 很 忙 但是 分手 6 天 了 好像 还是 每晚 都 有 通话 态度 也 很 客气 然后 有 一 天 我 忍不住 想 复合 他 说 现在 答应 复合 怕 以后 又 反复 不 答应 又 觉得 没 给 两个 人 机会 想 51 放假 的 时候 想想 我 最近 极度 痛苦 挣扎 中 在 找回 自己 的 生活 一个 人 在 异国他乡 好 崩溃 啊 沾 lz 的 喜气 多多 多多 传 给 我 点 吧 谢谢 楼主 好 希望 我们 能 复合 然后 修 成 正果 啊 我 今天 早晨 给 他 发 了 条 信息 说 早晨 好 心情 愉快 然后 他 说 妹子 嘴 很 甜 嘛 好好 加油 哦 昨晚 还说 今晚 打 电话 分手 那天 很 奇怪 就是 他 没 回 我 电话 我 生气 了 猛打 他 电话 结果 他 说 做 朋友 吧 有人 给 分析 不 现在 发展 如何 了 愿 一切 都 好 爱 嘛 并不 是 要 分出 个 输赢 的 坚持 坦诚 和 包容 才能 让 爱 得以 延续 和好 了不 过 长 路 漫漫 继续 坚持 为了 爱 坚持 也是 值得 的 但 要 有 自己 的 原则 祝 好运 100 | 0 羊 男 蝎 女修 成 正果 了 可怜 的 我 正在 分手 期 不过 我 觉得 他 是 想 冷静 冷静 还有 回转 的 余地 他 说 他 很 忙 但是 分手 6 天 了 好像 还是 每晚 都 有 通话 态度 也 很 客气 然后 有 一 天 我 忍不住 想 复合 他 说 现在 答应 复合 怕 以后 又 反复 不 答应 又 觉得 没 给 两个 人 机会 想 51 放假 的 时候 想想 我 最近 极度 痛苦 挣扎 中 在 找回 自己 的 生活 一个 人 在 异国他乡 好 崩溃 啊 沾 lz 的 喜气 多多 多多 传 给 我 点 吧 谢谢 楼主 好 希望 我们 能 复合 然后 修 成 正果 啊 我 今天 早晨 给 他 发 了 条 信息 说 早晨 好 心情 愉快 然后 他 说 妹子 嘴 很 甜 嘛 好好 加油 哦 昨晚 还说 今晚 打 电话 分手 那天 很 奇怪 就是 他 没 回 我 电话 我 生气 了 猛打 他 电话 结果 他 说 做 朋友 吧 有人 给 分析 不 现在 发展 如何 了 愿 一切 都 好 爱 嘛 并不 是 要 分出 个 输赢 的 坚持 坦诚 和 包容 才能 让 爱 得以 延续 和好 了不 过 长 路 漫漫 继续 坚持 好 谢谢 101 | 1 羊 男 蝎 女修 成 正果 了 我 现在 也 这么 想 前 段 时间 该 折腾 的 挽回 失望 拉黑 断 联 可是 我 还是 放 不 下 现在 准备 继续 努力 如果 特别 喜欢 就 别 放手 退回 朋友 的 位置 重新 开始 对 他 好 不要 给 他 压力 不要 对 他 提出 要求 去 温暖 他 羊 羊 很 心软 的 你 对 他 好 他 会 记得 的 ps 我们 准备 结婚 了 希望 带 给 你 点 喜气 恭喜 102 | 0 羊 男 蝎 女修 成 正果 了 我 现在 也 这么 想 前 段 时间 该 折腾 的 挽回 失望 拉黑 断 联 可是 我 还是 放 不 下 现在 准备 继续 努力 如果 特别 喜欢 就 别 放手 退回 朋友 的 位置 重新 开始 对 他 好 不要 给 他 压力 不要 对 他 提出 要求 去 温暖 他 羊 羊 很 心软 的 你 对 他 好 他 会 记得 的 ps 我们 准备 结婚 了 希望 带 给 你 点 喜气 周末 睡觉 觉得 就是 浪费 时间 啊 103 | 1 有 养 秋田 的 嘛 萨摩耶 金毛 拉布拉 多 松狮 敢 在 俗气 点 吗 我 养 秋田 我 爱 秋田 我 觉得 最 俗 的 是 泰迪 人人 养 就 像 那 最 炫 民族 风 一样 一 大众 就 俗 还有 泰迪 那 疯 闹 的 小 性格 烦 没 错 泰迪 巨 爱 叫 跟 吉娃娃 有 一 拼 了 是啊 小狗 都 凶 可 家里 没 条件 养 大 个 的 秋田 太 大 啦 忠犬 八公 人家 在 院子 有 自己 的 房子 的 我 就 整天 看 画 的 饼 解 解馋 你 可以 养 一 只 小 柴 啊 大小 跟 雪纳瑞 差不多 我 觉得 柴犬 像 是 小版 的 秋 田田 是的 我 也 发现 了 打算 养 个 小 柴犬 不过 我 真的 不喜欢 凶 闹 的 狗狗 我 喜欢 不言不语 的 不 知 这个 柴犬 个头 小 了 是不是 也 比 秋田 要 闹 呢 秋田 不 闹 跟 人 特别 友好 而且 也 不 爱 叫 很 聪明 但是 特别 好斗 我 家 秋田 是 小 男孩 爱 跟 别的 公 狗 打架 母 狗 怎么 欺负 他 都 没事 不知道 柴犬 是不是 也 如此 104 | 0 有 养 秋田 的 嘛 萨摩耶 金毛 拉布拉 多 松狮 敢 在 俗气 点 吗 我 养 秋田 我 爱 秋田 我 觉得 最 俗 的 是 泰迪 人人 养 就 像 那 最 炫 民族 风 一样 一 大众 就 俗 还有 泰迪 那 疯 闹 的 小 性格 烦 没 错 泰迪 巨 爱 叫 跟 吉娃娃 有 一 拼 了 是啊 小狗 都 凶 可 家里 没 条件 养 大 个 的 秋田 太 大 啦 忠犬 八公 人家 在 院子 有 自己 的 房子 的 我 就 整天 看 画 的 饼 解 解馋 你 可以 养 一 只 小 柴 啊 大小 跟 雪纳瑞 差不多 我 觉得 柴犬 像 是 小版 的 秋 田田 是的 我 也 发现 了 打算 养 个 小 柴犬 不过 我 真的 不喜欢 凶 闹 的 狗狗 我 喜欢 不言不语 的 不 知 这个 柴犬 个头 小 了 是不是 也 比 秋田 要 闹 呢 嘿嘿 多 交流 105 | 1 下巴 长 痘 的 同志 们 来 这里 集合 了 原因 经验 方法 西医 终于 暂时 压制 住 了 痘 子 但是 起 痘 的 原因 没有 消除 lz 的 痘 子 还是 此起彼伏 包括 下巴 lz 决定 调整 生活 习惯 来 慢慢 的 调理 身体 不在 操之过急 1 早 睡 每天 10 点 半 之前 雷打不动 必须 躺 在 床 上 早 睡 自然 能 早起 上班 迟到 次数 锐减 哈哈 哈 2 健康 饮食 饮 不 喝 灌装 饮料 冰激凌 咖啡 上火 酒精 多 喝 开水 花草茶 红 绿茶 食 营养 均衡 三餐 合理 搭配 经常 吃 应 季 水果 少 吃 甚至 不吃 垃圾 零食 辛辣 油腻 等 重 口味 食品 根据 体质 尽量 搭配 一些 调理 食物 3 运动 不用多说 了 4 冬季 注意 保暖 减少 寒性体质 的 诱因 泡脚 5 合理 护肤 针对 皮肤 的 状态 选择 合适 的 护肤品 不 盲目 相信 网络 推荐 产品 坚持 一段 时间 后 身体 一定 会 有 变化 lz 你 现在 脸上 已经 不 长 了 麼 我 也是 体寒 怕 冷 的 很 连 夏天 都 很少 出汗 也是 抗 痘 很久 很久 吃 了 半年 的 中药 脸上 其他 地方 的 痘痘 都 不 长 了 唯独 下巴 啊 下巴 啊 我 看 别人 吃 了 月见草 胶囊 管用 我 吃 不 管用 啊 我 ms 特别 容易 推迟 有 时候 甚至 推迟 2 礼拜 你 现在 下巴 还有 痘痘 吗 106 | 0 下巴 长 痘 的 同志 们 来 这里 集合 了 原因 经验 方法 西医 终于 暂时 压制 住 了 痘 子 但是 起 痘 的 原因 没有 消除 lz 的 痘 子 还是 此起彼伏 包括 下巴 lz 决定 调整 生活 习惯 来 慢慢 的 调理 身体 不在 操之过急 1 早 睡 每天 10 点 半 之前 雷打不动 必须 躺 在 床 上 早 睡 自然 能 早起 上班 迟到 次数 锐减 哈哈 哈 2 健康 饮食 饮 不 喝 灌装 饮料 冰激凌 咖啡 上火 酒精 多 喝 开水 花草茶 红 绿茶 食 营养 均衡 三餐 合理 搭配 经常 吃 应 季 水果 少 吃 甚至 不吃 垃圾 零食 辛辣 油腻 等 重 口味 食品 根据 体质 尽量 搭配 一些 调理 食物 3 运动 不用多说 了 4 冬季 注意 保暖 减少 寒性体质 的 诱因 泡脚 5 合理 护肤 针对 皮肤 的 状态 选择 合适 的 护肤品 不 盲目 相信 网络 推荐 产品 坚持 一段 时间 后 身体 一定 会 有 变化 lz 你 现在 脸上 已经 不 长 了 麼 我 也是 体寒 怕 冷 的 很 连 夏天 都 很少 出汗 也是 抗 痘 很久 很久 吃 了 半年 的 中药 脸上 其他 地方 的 痘痘 都 不 长 了 唯独 下巴 啊 下巴 啊 我 看 别人 吃 了 月见草 胶囊 管用 我 吃 不 管用 啊 我 ms 特别 容易 推迟 有 时候 甚至 推迟 2 礼拜 同学 logo 哪 能 用 ps 做 啊 要 用 矢量 的 好 么 好 吧 就算 你 用 ps 做 那个 不是 等高线 做 出来 的 107 | 1 十月 份 适合 到 哪里 去 旅游 九寨 九寨 我 是 打算 坐飞机 去 的 但是 一 看 机票 钱 好多 好多 银子 我 也是 算 了 路费 一再 犹豫 坐 大巴 我 实在 是 受不了 那个 罪 我 可以 但 时间 不 允许 我 身 在 武汉 啊 要 先 到 成都 再 转车 折腾 都 得 12 天 我 在 郑州 可以 坐 动车 到 西安 然后 直飞 黄龙 所以 我 这次 就不 去 九寨 了 我 回 郑州 囧 108 | 0 十月 份 适合 到 哪里 去 旅游 九寨 九寨 我 是 打算 坐飞机 去 的 但是 一 看 机票 钱 好多 好多 银子 我 也是 算 了 路费 一再 犹豫 坐 大巴 我 实在 是 受不了 那个 罪 我 可以 但 时间 不 允许 我 身 在 武汉 啊 要 先 到 成都 再 转车 折腾 都 得 12 天 我 在 郑州 可以 坐 动车 到 西安 然后 直飞 黄龙 那 不是 我 负责 的 事情 了 109 | 1 寻找 无名 指 上 有 痣 的 girl 我 有 痣 的 位置 说 出来 好 低俗 好想 知道 在哪里 你 是 故意 的 吗 那个 谁 我 不是 故意 的 我 是 有 意 的 我 就是 问问 · · · · 怎么 地 · · · · 这 位 朋友 请到 拐角 来 我 展示 给 你 看 110 | 0 寻找 无名 指 上 有 痣 的 girl 我 有 痣 的 位置 说 出来 好 低俗 好想 知道 在哪里 你 是 故意 的 吗 那个 谁 我 不是 故意 的 我 是 有 意 的 我 就是 问问 · · · · 怎么 地 · · · · 可以 阿 亲 你 豆油 我 要 的 东西 我 给 亲 算 优惠价 111 | 1 愤怒 把 一个 男人 捣碎 成 很多 男孩 巴列霍 作者 的 意思 是 一般 人 的 愤怒 是 负 情绪 对于 穷人 来讲 是 一种 正面 力量 他 是 想说 愤怒 的 无力 吧 百度 了 一下 说 他 一生 穷困潦倒 又 思想 激进 大概 有 很多 无力 的 时候 原来 如此 112 | 0 愤怒 把 一个 男人 捣碎 成 很多 男孩 巴列霍 作者 的 意思 是 一般 人 的 愤怒 是 负 情绪 对于 穷人 来讲 是 一种 正面 力量 他 是 想说 愤怒 的 无力 吧 百度 了 一下 说 他 一生 穷困潦倒 又 思想 激进 大概 有 很多 无力 的 时候 呵 呵呵 113 | 1 最近 买 的 几 支 试管 跟 哪 家 买 的 试管 装 1 有 地址 吗 豆油 下 thx 微笑 家 豆豆 家 博物馆 的 猫咪 家 啥 的 114 | 0 最近 买 的 几 支 试管 跟 哪 家 买 的 试管 装 1 有 地址 吗 豆油 下 thx 这个 真心 不 愿意 啊 不是 很 喜欢 锻炼 但是 身体 还 可以 紫金山 一口气 爬上 去 摸 问题 虽然 也 不 高 --------------------------------------------------------------------------------