def generate_critic(self, state_shape, action_size, optimizer, LEARNING_RATE):
assert(len(state_shape)==3),"shape mismatch"
nr_day, nr_feature, nr_seller = state_shape
assert(action_size == nr_seller)
inp = Input(shape=(nr_day, nr_feature, nr_seller))
print("inp shape=",inp.shape)
action = Input(shape=(nr_seller,))
#Similarly, first background part, ASSUME seller data ordered
dsf_inp = Permute((1,3,2))(inp)
reshape_inp = Reshape((nr_day,nr_seller * nr_feature))(dsf_inp)
background_feat = Bidirectional(GRU(self.bh))(reshape_inp) # (batch, bh)
repeated_background_feat = RepeatVector(nr_seller)(background_feat) #(batch, nr_seller, bh)
#individual part
sdf_inp = Permute((3,1,2))(inp)
ind_model = self.generate_individual_model(nr_day, nr_feature)
individual_feat = TimeDistributed(ind_model)(sdf_inp) #(batch, nr_seller, ih)
eval_model = self.generate_eval_model(2*(self.ih+self.bh)+1)
concat_feat = Concatenate(axis=-1)([repeated_background_feat, individual_feat, Reshape((-1,1))(action)]) #(batch, nr_seller, ih+bh)
print("concat_feat shape = ",concat_feat.get_shape())
values = TimeDistributed(eval_model)(concat_feat) #(batch, nr_seller ,1)
print("values shape = ",values.get_shape())
flat_values = Reshape((-1,))(values)
#then reduce to one value by addition
value = ReduceSum(axis = 1)(flat_values) #(batch,)
#value = Dense(1, activation="linear")(flat_values)
print("value shape = ",value.get_shape())
model = Model(inputs=[inp,action], outputs=[value])
opt = optimizer(LEARNING_RATE)
model.compile(loss="mse", optimizer=opt)
return model, action, inp
def build_model(self):
inputs = Input(shape=(3, self.sequence_size, self.img_size,
self.img_size))
x = TimeDistributed(
Convolution2D(16, 3, 3, activation=Relu,
border_mode="same"))(inputs)
x = TimeDistributed(
Convolution2D(32, 3, 3, activation=Relu, border_mode="same"))(x)
x = TimeDistributed(MaxPooling2D((2, 2)))(x)
x = TimeDistributed(
Convolution2D(64, 3, 3, activation=Relu, border_mode="same"))(x)
x = TimeDistributed(
Convolution2D(32, 3, 3, activation=Relu, border_mode="same"))(x)
x = TimeDistributed(MaxPooling2D((2, 2)))(x)
x = TimeDistributed(
Convolution2D(8, 3, 3, activation=Relu, border_mode="same"))(x)
x = TimeDistributed(Flatten())(x)
x = LSTM(256)(x)
x = Reshape([1, 16, 16])(x)
x = Convolution2D(32, 3, 3, activation=Relu, border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(64, 3, 3, activation=Relu, border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(32, 3, 3, activation=Relu, border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
x = Convolution2D(1, 3, 3, activation=Relu, border_mode='same')(x)
x = UpSampling2D((2, 2))(x)
print(x.get_shape())
model = Model(input=inputs, output=x)
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
return model
def build_sleepnet_lstm_model(num_features,
num_classes,
num_channels,
timestep=3,
fs=20):
input = Input(shape=(timestep, num_features, num_channels))
# two conv-nets in parallel for feature learning,
# one with fine resolution another with coarse resolution
# network to learn fine features
# fine
convFine = TimeDistributed(
Conv1D(filters=64,
kernel_size=int(fs / 2),
strides=int(fs / 6),
padding='same',
activation='relu',
name='fConv1'))(input)
convFine = TimeDistributed(BatchNormalization(name='fNorm1'))(convFine)
convFine = TimeDistributed(
Conv1D(filters=64,
kernel_size=8,
padding='same',
activation='relu',
name='fConv2'))(convFine)
convFine = TimeDistributed(
Conv1D(filters=64,
kernel_size=8,
padding='same',
activation='relu',
name='fConv3'))(convFine)
convFine = TimeDistributed(
Conv1D(filters=64,
kernel_size=8,
padding='same',
activation='relu',
name='fConv4'))(convFine)
convFine = TimeDistributed(BatchNormalization(name='fNorm2'))(convFine)
fineShape = convFine.get_shape()
convFine = TimeDistributed(Flatten(name='fFlat1'))(convFine)
# coarse
convCoarse = TimeDistributed(
Conv1D(filters=32,
kernel_size=fs * 2,
strides=int(fs / 2),
padding='same',
activation='relu',
name='cConv1'))(input)
convCoarse = TimeDistributed(BatchNormalization(name='cNorm1'))(convCoarse)
convCoarse = TimeDistributed(
Conv1D(filters=64,
kernel_size=6,
padding='same',
activation='relu',
name='cConv2'))(convCoarse)
convCoarse = TimeDistributed(
Conv1D(filters=64,
kernel_size=6,
padding='same',
activation='relu',
name='cConv3'))(convCoarse)
convCoarse = TimeDistributed(
Conv1D(filters=64,
kernel_size=6,
padding='same',
activation='relu',
name='cConv4'))(convCoarse)
convCoarse = TimeDistributed(BatchNormalization(name='cNorm2'))(convCoarse)
coarseShape = convCoarse.get_shape()
convCoarse = TimeDistributed(Flatten(name='cFlat1'))(convCoarse)
x = concatenate([convFine, convCoarse], name='merge')
x = TimeDistributed(Flatten())(x)
# x = Flatten()(x)
x = LSTM(32, activation='relu', name='bLstm2')(x)
output = Dense(num_classes, activation='softmax', name='outLayer')(x)
# adam = optimizer.Adam(lr=0.00001, beta_1=0.9, beta_2=0.999, epsilon=1e-8, clipnorm=1.)
model = Model(input=input, output=output, name='sleep_lstm_1D')
model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=[metrics.sparse_categorical_accuracy])
return model
x = Embedding(lx, embed_size, weights=[embedding_matrix])(inp)
x = Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')(x)
x = MaxPooling1D(pool_size=2)(x)
x = LSTM(300, return_sequences=True)(x)
#x = AttentionDecoder(300,maxlen)(x)
#x = GlobalMaxPool1D()(x)
#x = Dense(300, activation="relu")(x)
#x = Dense(100, activation="relu")(x)
#x = Dropout(0.1)(x)
#ylayer=numpy.asarray(ylayer)
print(x.get_shape())
xa = TimeDistributed(Dense(3, activation="tanh"))(x)
xa = Flatten()(xa)
xa = Activation('softmax')(xa)
xa = RepeatVector(300)(xa)
print(xa.get_shape())
xa = Permute([2, 1])(xa)
print(xa.get_shape())
ot = Multiply()([x, xa])
ot = Lambda(lambda xin: K.sum(xin, axis=-1))(ot)
ol = TimeDistributed(Dense(3, activation="sigmoid"))(ot)
model = Model(inputs=inp, outputs=ol)
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
X_t[X_t == lx] = lx - 1
X_te[X_te == lx] = lx - 1
model.fit(X_t, ytrain, batch_size=200, epochs=1, validation_split=0.1)
def block_warp(block_name,input_layer,filters,kernal_size=3, dilation_rate=1,depthfilter=4,stride=1):
def conv_block(input_layer,filters,k=3):
y = Conv3D(filters=filters, kernel_size=k, padding='same')(input_layer)
y = BatchNormalization()(y)
y = Activation('relu')(y)
return y
if block_name == 'conv':
y = conv_block(input_layer,filters)
y = conv_block(y,filters)
elif block_name == 'dialtion':
y = Conv3D(filters=filters, kernel_size=kernal_size, padding='same', dilation_rate=dilation_rate)(input_layer)
y = BatchNormalization()(y)
y = Activation('relu')(y)
elif block_name == 'deconv':
y = Conv3DTranspose(filters=filters,kernel_size=3,strides=2,padding='same')(input_layer)
y = BatchNormalization()(y)
y = Activation('relu')(y)
elif block_name == 'time_conv':
y = TimeDistributed(Conv2D(filters=filters,kernel_size=3,padding='same'))(input_layer)
y = TimeDistributed(BatchNormalization())(y)
y = TimeDistributed(Activation('relu'))(y)
elif block_name == 'time_deconv':
y = TimeDistributed(Conv2DTranspose(filters=filters,kernel_size=3,padding='same',strides=2))(input_layer)
y = TimeDistributed(BatchNormalization())(y)
y = TimeDistributed(Activation('relu'))(y)
elif block_name == 'inception':
filters = filters//4
c1 = conv_block(input_layer,filters,1)
c3 = conv_block(input_layer,filters,1)
c3 = conv_block(c3,filters,3)
c5 = MaxPool3D(pool_size=3,padding='same',strides=1)(input_layer)
c5 = conv_block(c5,filters,3)
c7 = conv_block(input_layer,filters,1)
c7 = conv_block(c7, filters, 3)
c7 = conv_block(c7, filters, 3)
y = concatenate([c1,c3,c5,c7])
# c_all = BatchNormalization()(c_all)
# y = Activation('relu')(c_all)
elif block_name == 'sep':
input_layer = Permute((4,1,2,3))(input_layer)
sz = input_layer.get_shape()
shape = tuple(int(sz[i]) for i in range(1, 5))
input_layer = Reshape(shape+(1,))(input_layer)
conv1 = TimeDistributed(Conv3D(filters=depthfilter,kernel_size=kernal_size,padding='same',strides=stride))(input_layer)
conv1 = Permute((2,3,4,1,5))(conv1)
sz = conv1.get_shape()
shape = tuple(int(sz[i]) for i in range(1, 4))
conv1 = Reshape(shape+(-1,))(conv1)
conv1 = Conv3D(filters=filters,kernel_size=1,padding='same')(conv1)
conv1 = BatchNormalization()(conv1)
y = Activation('relu')(conv1)
else:
raise ValueError("layer error")
return y
# WORD-LEVEL
sentence_input = Input(shape=(maxlen,), dtype='int32')
embedded_sequences = embedding_layer(sentence_input)
print('embedded_sequences SHAPE')
print(embedded_sequences.get_shape())
# Bidirectional GRU
l_gru = MultiplicativeLSTM(gru_output_size, return_sequences=True)(embedded_sequences)
l_dense = TimeDistributed(Dense(units=gru_output_size))(l_gru)
print('l_gru SHAPE')
print(l_gru.get_shape())
print('l_dense SHAPE')
print(l_dense.get_shape())
# Word-Level Attention Layer
l_att = AttLayer()(l_dense)
print('l_att SHAPE')
print(l_att.get_shape())
sentEncoder = Model(sentence_input, l_att)
sentEncoder.compile(
optimizer=Adam(0.0001),
loss='mse',
metrics={},
)
