def _test_Input(): print '\n------------------------------------------------------------' print 'Test: Input Unit' data1 = U.Input(2, name='Data1') data1.check() data1.build() print P.pprint(data1.get_variable()) data2 = U.Input(2) data2.check() data2.build() print P.pprint(data1.get_variable())
def _test_Output(): print '\n------------------------------------------------------------' print 'Test: Output Unit' x = U.Input(2, name='X') output = U.Output() output.set_input('input', x, 'output') x.build() output.check() output.build() print P.pprint(output.get_results(train=False))
def _test_TimeDistributedDense(): print '\n------------------------------------------------------------' print 'Test: Time Distributed Dense Unit' x = U.Input(3, name='X') tdd = U.TimeDistributedDense(16, 1024, 128) tdd.set_input('input', x, 'output') x.build() tdd.check() tdd.build() print P.debugprint(tdd.get_output('output')(train=False))
def _test_Dense(): print '\n------------------------------------------------------------' print 'Test: Dense Unit' X = U.Input(2, name='X') dense_1 = U.Dense(16, 24, name='Dense1') dense_1.set_input('input', X, 'output') X.build() dense_1.check() dense_1.build() print P.pprint(dense_1.get_output('output')(train=False))
def _test_RepeatVector(): print '\n------------------------------------------------------------' print 'Test: Repeat Vector Unit' x = U.Input(2, name='X') f = U.RepeatVector(10) f.set_input('input', x, 'output') x.build() f.check() f.build() print P.pprint(f.get_output('output')(train=False))
def _test_Dropout(): print '\n------------------------------------------------------------' print 'Test: Dropout Unit' data_1 = U.Input(2, name='X') dropout = U.Dropout(0.2) dropout.set_input('input', data_1, 'output') data_1.build() dropout.check() dropout.build() print P.pprint(dropout.get_output('output')(train=False)) print P.pprint(dropout.get_output('output')(train=True))
def _test_Mask(): print '\n------------------------------------------------------------' print 'Test: Mask Unit' x = U.Input(3, name='X') mask = U.Mask() mask.set_input('input', x, 'output') output = U.Output() output.set_input('input', mask, 'mask') x.build() mask.check() mask.build() output.build() print P.pprint(output.get_results(train=False))
def _test_SimpleLambda(): print '\n------------------------------------------------------------' print 'Test: Simple Lambda Unit' x = U.Input(2, name='X') def fun(x): return x**2 f = U.SimpleLambda(fun) f.set_input('input', x, 'output') x.build() f.check() f.build() print P.pprint(f.get_output('output')(train=False))
def _test_Lambda(): print '\n------------------------------------------------------------' print 'Test: Lambda Unit' x = U.Input(2, name='X') y = U.Input(2, name='Y') def fun(x, y): return x * 2, x + y, y * 2 f = U.Lambda(fun, ['2x', 'x+y', '2y']) f.set_input('input_x', x, 'output') f.set_input('input_y', y, 'output') x.build() y.build() f.check() f.build() print P.pprint(f.get_output('2x')(train=False)) print P.pprint(f.get_output('x+y')(train=False)) print P.pprint(f.get_output('2y')(train=False)) output1 = U.Output() output1.set_input('input', f, '2x') output1.build() print P.pprint(output1.get_results(train=False))
def _test_Activation(): print '\n------------------------------------------------------------' print 'Test: Activation Unit' x = U.Input(2, name='X') relu = U.Activation('relu') relu.set_input('input', x, 'output') softmax = U.Activation('softmax') softmax.set_input('input', x, 'output') x.build() relu.check() relu.build() softmax.check() softmax.build() print P.pprint(relu.get_output('output')(train=False)) print P.pprint(softmax.get_output('output')(train=False))
(D_Y_train, D_Y_val) = (D_Y[:split_at], D_Y[split_at:]) (D_mask_train, D_mask_val) = (D_mask[:split_at], D_mask[split_at:]) print(D_X_train.shape, D_Y_train.shape, D_mask_train.shape) import dlx.unit.core as U import dlx.unit.recurrent as R from dlx.model import Model print('Build model...') input_dim = output_dim = len(engine.get_dictionary()) hidden_dim = HIDDEN_SIZE input_length = MAXLEN output_length = MAXLEN '''Define Units''' #Data unit data = U.Input(3, 'X') #Mask unit mask_in = U.Input(2, 'MASK_IN') #RNN rnn = R.RNN(input_length, input_dim, hidden_dim, name='RNN') #Time Distributed Dense tdd = U.TimeDistributedDense(output_length, hidden_dim, output_dim, 'TDD') #Activation activation = U.Activation('softmax') #Output layer output = U.Output() #Output layer mask_out = U.Output() '''Define Relations''' rnn.set_input('input_sequence', data, 'output') rnn.set_input('input_mask', mask_in, 'output')
print(D_X_train.shape) print(D_y_train.shape) import dlx.unit.core as U import dlx.unit.recurrent as R from dlx.model import Model print('Build model...') input_dim = convertor.get_dim() output_dim = convertor.get_dim() hidden_dim = HIDDEN_SIZE input_length = MAXLEN output_length = DIGITS + 1 '''Define Units''' #Data uayer data = U.Input(3, 'X') #RNN encoder encoder = R.RNN(input_length, input_dim, hidden_dim, name='ENCODER') #encoder = R.LSTM(input_length, input_dim, hidden_dim, name='ENCODER') #RNN decoder decoder = R.RNN(output_length, hidden_dim, hidden_dim, name='DECODER') #decoder = R.LSTM(output_length, hidden_dim, hidden_dim, name='DECODER') #Time Distributed Dense tdd = U.TimeDistributedDense(output_length, hidden_dim, output_dim, 'TDD') #Activation activation = U.Activation('softmax') #Output layer output = U.Output() '''Define Relations''' encoder.set_input('input_sequence', data, 'output') decoder.set_input('input_single', encoder, 'output_last')
print(D_B_train.shape) print(D_y_train.shape) import dlx.unit.core as U import dlx.unit.attention as A from dlx.model import Model print('Build model...') input_dim = convertor.get_dim() + MAXLEN output_dim = convertor.get_dim() hidden_dim = HIDDEN_SIZE output_length = MAXLEN attention_hidden_dim = HIDDEN_SIZE '''Define Units''' #Data unit dataA = U.Input(3, 'A') dataB = U.Input(3, 'B') #Add Remove 1 add1 = U.AddOneAtBegin() remove1 = U.RemoveOneAtBegin() #Attention decoder = A.AttentionLSTM_X(output_length + 1, input_dim, hidden_dim, input_dim, attention_hidden_dim, name='ATT') #One to Many one2many = U.OneToMany(['y', 'alpha']) #Time Distributed Dense tdd = U.TimeDistributedDense(output_length, hidden_dim, output_dim, 'TDD')
# convert class vectors to binary class matrices D_Y_train = np_utils.to_categorical(D_y_train, nb_classes) D_Y_test = np_utils.to_categorical(D_y_test, nb_classes) import dlx.unit.core as U from dlx.model import Model input_size = 784 hidden_size = 512 output_size = nb_classes batch_size = 128 nb_epoch = 20 '''Define Units''' #Data unit data = U.Input(2, 'X') #Dense unit 1 dense_1 = U.Dense(input_size, hidden_size, 'Dense1') #Activation unit 1 activation_1 = U.Activation('relu') #Dense unit 2 dense_2 = U.Dense(hidden_size, hidden_size, 'Dense2') #Activation unit 2 activation_2 = U.Activation('relu') #Dense unit 3 dense_3 = U.Dense(hidden_size, output_size, 'Dense3') #Activation unit 3 activation_3 = U.Activation('softmax') #Output unit output = U.Output() '''Define Relations'''