def create_inputs(vocab_dim): input_seq_axis = Axis('inputAxis') input_sequence = sequence.input_variable(shape=vocab_dim, sequence_axis=input_seq_axis) label_sequence = sequence.input_variable(shape=vocab_dim, sequence_axis=input_seq_axis) return input_sequence, label_sequence
def create_inputs(hidden_dim, sv_dim, vocab_dim): input_seq_axis = Axis('inputAxis') input_sequence = sequence.input_variable(shape=vocab_dim, sequence_axis=input_seq_axis) # state in model, including sv vector, h vector, c vector sv_pair = C.input_variable(shape=sv_dim) inputH = C.input_variable(shape=hidden_dim) inputC = C.input_variable(shape=hidden_dim) label_sequence = sequence.input_variable(shape=vocab_dim, sequence_axis=input_seq_axis) return input_sequence, sv_pair, label_sequence, inputH, inputC
def load_model(self): if self.__model: raise Exception("Model already loaded") trained_frcnn_model = load_model(self.__model_path) # cache indices of the model arguments args_indices = {} for i, arg in enumerate(trained_frcnn_model.arguments): args_indices[arg.name] = i self.__nr_rois = trained_frcnn_model.arguments[ args_indices["rois"]].shape[0] self.__resize_width = trained_frcnn_model.arguments[ args_indices["features"]].shape[1] self.__resize_height = trained_frcnn_model.arguments[ args_indices["features"]].shape[2] self.labels_count = trained_frcnn_model.arguments[ args_indices["roiLabels"]].shape[1] # next, we adjust the clone the model and create input nodes just for the features (image) and ROIs # This will make sure that only the calculations that are needed for evaluating images are performed # during test time # # find the original features and rois input nodes features_node = find_by_name(trained_frcnn_model, "features") rois_node = find_by_name(trained_frcnn_model, "rois") # find the output "z" node z_node = find_by_name(trained_frcnn_model, 'z') # define new input nodes for the features (image) and rois image_input = input_variable(features_node.shape, name='features') roi_input = input_variable(rois_node.shape, name='rois') # Clone the desired layers with fixed weights and place holder for the new input nodes cloned_nodes = combine([z_node.owner]).clone( CloneMethod.freeze, { features_node: placeholder(name='features'), rois_node: placeholder(name='rois') }) # apply the cloned nodes to the input nodes to obtain the model for evaluation self.__model = cloned_nodes(image_input, roi_input) # cache the indices of the input nodes self.__args_indices = {} for i, arg in enumerate(self.__model.arguments): self.__args_indices[arg.name] = i
def create_model_placeholders(): ''' Create placeholders for getting features and labels into the model :return: returns a feature placeholder and a label placeholder ''' input_sequence = sequence.input_variable(shape=VOCAB_SIZE_VAR, name='input_sequence') label_sequence = input_variable(shape=NUM_OUTPUT_CLASSES, name='label_sequence') return input_sequence, label_sequence
minibatch_size = 100 def get_sample(p): xi = [char_to_ix[ch] for ch in data[p:p + minibatch_size]] yi = [char_to_ix[ch] for ch in data[p + 1:p + minibatch_size + 1]] X = np.eye(vocab_size, dtype=np.float32)[xi] Y = np.eye(vocab_size, dtype=np.float32)[yi] return [X], [Y] get_sample(0) input_sequence = sequence.input_variable(shape=vocab_size) label_sequence = sequence.input_variable(shape=vocab_size) model = Sequential([ For( range(2), lambda: Sequential( [Stabilizer(), Recurrence(LSTM(256), go_backwards=False)])), Dense(vocab_size) ]) z = model(input_sequence) z_sm = cntk.softmax(z) ce = cross_entropy_with_softmax(z, label_sequence) errs = classification_error(z, label_sequence)
minibatch_size=100 def sample(p): xi = [char_to_ix[ch] for ch in data[p:p+minibatch_size]] yi = [char_to_ix[ch] for ch in data[p+1:p+minibatch_size+1]] X = np.eye(vocab_size, dtype=np.float32)[xi] Y = np.eye(vocab_size, dtype=np.float32)[yi] return [X], [Y] sample(0) input_seq_axis = Axis('inputAxis') input_sequence = sequence.input_variable(shape=vocab_size, sequence_axis=input_seq_axis) label_sequence = sequence.input_variable(shape=vocab_size, sequence_axis=input_seq_axis) # model = Sequential([Dense(300),Dense(vocab_size)]) model = Sequential([ For(range(2), lambda: Sequential([Stabilizer(), Recurrence(LSTM(256), go_backwards=False)])), Dense(vocab_size)]) z = model(input_sequence) ce = cross_entropy_with_softmax(z, label_sequence) errs = classification_error(z, label_sequence) lr_per_sample = learning_rate_schedule(0.001, UnitType.sample)
for w,l in zip(words_test,labels_test): if dofill: w_a = to_onehot(fill(list(map(char_to_num,list(w))))) else: w_a = to_onehot(list(map(char_to_num,list(w)))) out = net(w_a)[0] if (out[1]>0.5 and l==-1): correct+=1 if (out[0]>0.5 and l==1): correct+=1 total+=1 print("{} out of {} correct ({}%)".format(correct,total,correct/total*100)) z_sm = C.softmax(z) check(z_sm) # Now implement simple RNN words_arr1 = [to_onehot(list(map(char_to_num,list(w)))) for w in words] input_var = sequence.input_variable(vocab_size) label_var = C.input_variable(2) model = Sequential([Recurrence(C.layers.RNNStep(200,activation=C.relu)),sequence.last,Dense(100,activation=C.relu),Dense(2)]) z = model(input_var) z_sm = C.softmax(z) ce = cross_entropy_with_softmax(z, label_var) errs = classification_error(z, label_var) lr_per_sample = learning_rate_schedule(0.02, UnitType.minibatch) learner = C.learners.sgd(z.parameters, lr_per_sample) progress_printer = ProgressPrinter(freq=100, tag='Training') trainer = Trainer(z, (ce, errs), learner, progress_printer)