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'''
