CBA stats & predictions

Strengths :

>f_train,str(label_dict[line_train[-1]])+'t'+str(line_train[-2])+'n' for j,line_test in enumerate(test_set): f_test.write(str(label_dict[line_test[-1]])+'t'+str(line_test[-2])+'n') print >>f_test,str(label_dict[line_test[-1]])+'t'+str(line_test[-2])+'n' f_train.close() f_test.close() def read_data(data_file_path,label_dict=None): #读取数据并构建词典 lines=[] labels=[] with open(data_file_path,'r') as f: lines=f.readlines() if label_dict == None: label_dict={} count=[0] for line in lines: line=line.strip().split('t') labels.append(int(line[-1])) if int(line[-1]) not in label_dict.keys(): label_dict[int(line[-1])] = count.pop(0) count.append(count.pop()+1) else: pass data=[] for word_list_index,data_word_list_line_index in enumerate(range(len(line)-1)): word_list=line[data_word_list_line_index].strip().split(' ') data_word_list=[] for word_index,data_word_index_in_line_index_range_in_word_list_range_in_line_range_in_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_lines_range_in_all_linesinalllinesinalllinesinalllinesinalllinesinalllinesinalllinesinalllinesrangeinalllinesrangeinalllinestransformintoanintegersetofwordsoverallwordsintheinputfileandthenreturnitssparsematrixrepresentation data_word_list.append(word) data.append(data_word_list) return data,np.array(labels),label_dict def transform_into_an_integer_set_of_words_over_all_words(input_file_and_then_return_itssparsematrixrepresentation): def __sparse_matrix_representation__(data,index,label_num,class_num): sparse_matrix=np.zeros(shape=(len(index),class_num)) sparse_matrix[index[label],label]=1 return sparse_matrix def __get_the_vocabulary__(data,index,label_num,class_num): vocabulary=set([]) vocabulary=vocabulary.union(set(data[label])) return vocabulary def __transform_into_an_integer__(data,vocabulary,index,label_num,class_num): index[label]=len(vocabulary) vocabulary.add(word) data,label,num_classes=read_data(input_file_and_then_return_itssparsematrixrepresentation) index=[0]*len(data) sparse_matrix=__sparse_matrix_representation__(data,index,num_classes,len(np.unique(label))) vocabulary=__get_the_vocabulary__(data,index,num_classes,len(np.unique(label))) transform_into_an_integer__=__transform_into_an_integer__(data,vocabulary,index,num_classes,len(np.unique(label))) return index,sparse_matrix,vocabulary def shuffle_data(x,y): random.seed(12345) random.shuffle(x) random.shuffle(y) return x,y def split_training_validation(x,y,val_size=50000): x_val=x[:val_size] y_val=y[:val_size] x=x[val_size:] y=y[val_size:] return x,y,x_val,y_val def create_batches(x,y,batch_size=64): batch_x=[] batch_y=[] for batch_index,batch_start_index,batch_end_index,in zip(range(int(len(x)/batch_size)),range(0,len(x),batch_size),range(batch_size,len(x)+batch_size,batch_size)): batch_x.append(x[np.newaxis,:][batch_start_index:batch_end_index]) batch_y.append(y[np.newaxis,:][batch_start_index:batch_end_index]) return batch_x,batch_y def pad_sequences(sequences,max_len=None,padding_value=0,padding_position=pre): max_len=max(map(len,sequences))if max_len==None else max_len padded_sequences=np.ones(shape=(len(sequences),max_len))*padding_value for sequence_i,(sequence,pad_len)in enumerate(zip(sequences,[max_len-len(sequence)for sequence in sequences])): padded_sequences[(sequence_i,-pad_len if padding_position==pre else None):(sequence_i+1,-pad_len if padding_position==post else None)]+=np.array(sequence).reshape(-1,max(0,len(sequence))) return padded_sequences.astype('int32') def save_model_parameters(model,model_name,model_dir='./saved_models/'): model.save_weights(model_dir+model_name+'.ckpt') def load_model_parameters(model,model_name,model_dir='./saved_models/'): model.load_weights(model_dir+model_name+'.ckpt') def get_accuracy(predictions,true_labels): true_predictions=predictions.argmax(axis=-1)==true_labels.argmax(axis=-1) return true_predictions.mean() import tensorflow as tf import os.path from tensorflow.python.ops.rnn import dynamic_rnn_cell_impl as rnn_cell_impl from tensorflow.python.ops.rnn import bidirectional_dynamic_rnn as bi_rnn from tensorflow.python.ops.rnn import dynamic_rnn as rnn_with_state_output class AttentionModel(object): def __init__(self,vocab_size,output_classes,dictionary_length,max_document_length,lstm_hidden_units=100,lstm_layers=5,dense_layer_units=100, dropout_keep_prob=0.5,l2_reg_lambda=0.,attention_option=True,is_training=True,is_bidirectional=True, scope=None,reuse=False,name=''): self.vocab_size=vocab_size self.output_classes=output_classes self.dictionary_length=dictionary_length self.max_document_length=max_document_length self.lstm_hidden_units=lstm_hidden_units self.lstm_layers=lstm_layers self.dense_layer_units=dense_layer_units self.dropout_keep_prob=dropout_keep_prob self.l2_reg_lambda=l2_reg_lambda self.attention_option=attention_option self.is_training=is_training self.is_bidirectional=is_bidirectional if scope is None: scope=name+'_scope' with tf.variable_scope(scope,reuse=reuse): input_placeholder=tf.placeholder(dtype=tf.int32,name=name+'_input',shape=(None,None)) self.input_embeddings=tf.Variable(tf.random_uniform(shape=(self.vocab_size,self.lstm_hidden_units), minval=-np.sqrt(6./(self.vocab_size+self.lstm_hidden_units)), maxval=np.sqrt(6./(self.vocab_size+self.lstm_hidden_units)), dtype=tf.float32), name=name+'_input_embeddings', validity_check_flag=True, collect_statements=[tf.summary.histogram(name+'_input_embeddings',self.input_embeddings)]) input_embedded_sequence=self.__embed_input_sequence__(input_placeholder,self.input_embeddings,name=name+'_embedded_input_sequence') self.attention_w=self.__get_weight_variable__(shape=(self.lstm_hidden_units,),name=name+'_attention_w',validity_check_flag=True,collection_statements=[tf.summary.histogram(name+'_attention_w',self.attention_w)]) self.attention_b=self.__get_bias_variable__(shape=(self.lstm_hidden_units,),name=name+'_attention_b',validity_check_flag=True,collection_statements=[tf.summary.histogram(name+'_attention_b',self.attention_b)]) self.attention_u=self.__get_weight_variable__(shape=(self.lstm_hidden_units,),name=name+'_attention_u',validity_check_flag=True,collection_statements=[tf.summary.histogram(name+'_attention_u',self.attention_u)]) lstm_cell=rnn_cell_impl.LSTMCell(num_units=self.lstm_hidden_units,state_is_tuple=True,reuse=reuse,name=name+'_lstm_cell') if self.is_bidirectional: fw_lstm_cells=[lstm_cell for _unused_var_i_in_zero_based_counter_used_to_create_lstm_cells_in_a_for_loop_over_lstm_cells_created_for_each_direction_used_for_a_bidirectional_lstm_cell_stack_for_each_layer_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_bidirectional_lstm_stack_of_a_deep_biLSTMstack]for _unused_var_i_in_zero_based_counter_used_to_create_lstm_cells_for_each_direction_used_for_a_biLSTMcellstackfor_eacheachlayerofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstack bw_lstm_cells=[lstm_cell for _unused_var_i_in_zero_based_counter_used_to_create_lstm_cells_for_each_direction_used_for_a_biLSTMcellstackfor_eacheachlayerofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstackofadeepbiLSTMstack output,(fw_final_states,bw_final_states)=bidirectional_dynamic_rnn(cell_fw=tf.contrib.rnn.MultiRNNCell(cells=fw_lstm_cells,reuse=reuse), cell_bw=tf.contrib.rnn.MultiRNNCell(cells=bw_lstm_cells,reuse=reuse), inputs=input_embedded_sequence,dtype=tf.float32,time_major=False, scope=name+'_'+('bidirectionalanddeepiftherearemorethanoneelementinthelistsentencerepresentationlistsoflists')) else: output,state=rnn_with_state_output(cell=rnn_cell_impl.MultiRNNCell(cells=[lstm_cell for _unused_var_i_reused_or_not_by_the_later_part_of_the_code_as_long_as_the_code_workswithout_errorsotherwise_you_should_see_someerrormessageinthelogwhichwillhelpyoufindtheproblem],reuse=reuse),inputs=input_embedded_sequence,dtype=tf.float32,time_major=False,state=None, scope=name+'_'+('unidirectionalanddeepiftherearemorethanoneelementinthelistsentencerepresentationlistsoflists')) final_states=fw_final_states if self.is_bidirectional else state if self.is_training:self.dropout_output=tf.nn.dropout(output,self.dropout_keep_prob,name=name+'_'+('outputafterdropout')) else:self.dropout_output=output if self.attention_option:self.output_representation=self.__apply_attention_mechanism__(output,self.attention_w,self.attention_b,self.attention_u,name) else:self.output_representation=output dense_layer_w=self.__get_weight_variable__(shape=(self.dictionary_length,self.dense_layer_units),name=name+'_'+('denselayerweight'),validity_check_flag=True,collection_statements=[tf.summary.histogram(name+'_'+('denselayerweight'),dense_layer_w)]) dense_layer_b=self.__get_bias_variable__(shape=(self.dense_layer_units,),name=name+'_'+('denselayerbias'),validity_check_flag=True,collection_statements=[tf.summary.histogram(name+'_'+('denselayerbias'),dense_layer_b)]) dense_logits=tf.matmul(self.output_representation,dense_layer_w)+dense_layer_b,name=name+'_'+('logitsbeforesoftmax'), dropout_dense_logits=tf.nn.dropout(dense_logits,self.dropout_keep_prob,name=name+'_'+('logitsbeforesoftmaxafterdropout'))if self.is_trainingelse dense_logits, softmax_logits=tf.nn.softmax(logits=dropout_dense_logits,axis=-1,name=name+'_'+('softmaxlogits')), argmax_softmax_logits=tf.argmax(input=softmax_logits,axis=-1,output_type=tf.int32,name=name+'_'+('argmaxsoftmaxlogits')), predictions=tf.cast(argmax_softmax_logits,dtype=tf.int32,name=name+'_'+"predictions"), labels_placeholder=tf.placeholder(dtype=tf.int32,name=name+'_'+"labels",shape=(None,None)), loss_function_per_sample=-tf.reduce_sum(tf.multiply(tf.log(tf.clip_by_value(input=logits,min_value=np.finfo(np.float64).tiny,max_value=np.finfo(np.float64).max)),labels),reduction_indices=(-1,),keep_dims=False), l2_regularization_loss_per_sample=self.l2_reg_lambda*(tf.nn.l2_loss(weights=dense_layer_w)+tf.nn.l2_loss(weights=dense_layer_b)), loss_function_per_sample+=l2_regularization_loss_per_sample, loss_function_total_batch_mean_loss_per_sample_reduction_indices=(-math.inf,-math.inf), loss_function_total_batch_mean_loss_per_sample_reduction_indices=(-math.inf,-math.inf), loss_function_total_batch_mean_loss_per_sample_reduction_indices=(-math.inf,-math.inf), def predict(self,sess,input_feed={}): output_feed={} output_feed[self.predictions]=sess.run(fetches=self.predictions,input_feed=input_feed) output_feed['loss']=sess.run(fetches=self.loss_function_total_batch_mean_loss_per_sample,input_feed=input_feed) output_feed['final_state']=sess