def __call__(self, inputs): self.deconv_filter = normal_initializer((self.kernel_size, self.kernel_size, self.output_filters, self.input_filters), name="deconv_filter" ) self.deconv_bias = zero_initializer ((self.output_filters), name="deconv_bias") # input height and width input_height = inputs.get_shape().as_list()[1] input_width = inputs.get_shape().as_list()[2] if self.kernel_padding == 'SAME': output_height = input_height * self.kernel_stride output_width = input_width * self.kernel_stride elif self.kernel_padding == 'VALID': output_height = (input_height - 1) * self.kernel_stride + self.kernel_size output_width = (input_width - 1) * self.kernel_stride + self.kernel_size else: raise Exception('No such padding') self.deconv_output = tf.nn.conv2d_transpose(inputs, self.deconv_filter, [tf.shape(inputs)[0], output_height, output_width, self.output_filters], [1, self.kernel_stride, self.kernel_stride, 1], self.kernel_padding) # Add bias and apply activation if self.act is None: self.total_output = self.deconv_output else: self.total_output = self.act(self.deconv_output + self.deconv_bias) return self.total_output
def decoder(self, inputs, last_conv_dims): # apply fully connected layer weights_decoder = normal_initializer((FLAGS.code_size, tf.cast(last_conv_dims[0]*last_conv_dims[1]*last_conv_dims[2], tf.int32))) bias_decoder = zero_initializer((tf.cast(last_conv_dims[0]*last_conv_dims[1]*last_conv_dims[2], tf.int32))) decode_layer = tf.nn.relu(tf.matmul(inputs, weights_decoder) + bias_decoder) print(decode_layer.shape) # reshape to send as input to transposed convolutional layer deconv_input = tf.reshape(decode_layer, (-1,last_conv_dims[0],last_conv_dims[1],last_conv_dims[2])) print(deconv_input.shape) # transpose convolutional layer deconv1 = DeconvLayer (input_filters=tf.cast(deconv_input.shape[3], tf.int32), output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=2, kernel_padding="SAME") deconv1_act = deconv1.__call__(deconv_input) print(deconv1_act.shape) # transpose convolutional layer deconv2 = DeconvLayer (input_filters=16, output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=2, kernel_padding="SAME") deconv2_act = deconv2.__call__(deconv1_act) print(deconv2_act.shape) # transpose convolutional layer deconv3 = DeconvLayer (input_filters=8, output_filters=1, act=None, kernel_size=3, kernel_stride=2, kernel_padding="SAME") deconv3_act = deconv3.__call__(deconv2_act) print(deconv3_act.shape) return deconv3_act
def forward(self, inputs, ema=None): hps = self.hps bsmm = hps.bsmm xgroup = hps.x_group_size xgroups = len(inputs) // xgroup sproj = hps.sproj_out self.inputs = inputs if sproj is not None: inputs = [sproj.gather(h) for h in inputs] with tf.variable_scope(self.scope): w = hps.get_variable("w", bsmm["y"].w_shape, normal_initializer()) g = hps.get_variable("g", [hps.nvocab], ones_initializer()) b = hps.get_variable("b", [hps.nvocab], zeros_initializer()) self.params = [w, g, b] if ema is not None: w = ema.average(w) g = ema.average(g) b = ema.average(b) #w = ew.float_cast(w, dtype=hps.dtype) w = bsmm["y"].l2_normalize(w, dtype=hps.dtype) # compute the fc matmul in groups for better memory efficiency. ygroups = [] for i in range(xgroups): x = tf.concat(inputs[i * xgroup:(i + 1) * xgroup], 1 - hps.axis) # (nsteps x nbatch, nvocab) = (nsteps x nbatch, hidden) . (nhidden, nvocab) ygroups.append(bsmm["y"](x, w, dw_dtype=hps.dw_dtype)) y = tf.concat(ygroups, 1 - hps.axis) # cast to float32 before entering cost function y = ew.float_cast(y, dtype=tf.float32, dx_dtype=hps.dx_dtype) if hps.axis == 0: y = tf.transpose(y) if (hps.nvocab % 32) != 0: y = tf.slice(y, [0, 0], [-1, hps.nvocab]) self.outputs = y * g + b outputs = tf.stop_gradient(self.outputs) return outputs
def __call__(self, inputs): self.conv_filter = normal_initializer((self.kernel_size, self.kernel_size, self.input_filters, self.output_filters), name="conv_filter" ) self.conv_bias = zero_initializer ((self.output_filters), name="conv_bias") self.conv_output = tf.nn.conv2d(inputs, self.conv_filter, [1, self.kernel_stride, self.kernel_stride, 1] , self.kernel_padding) # Add bias and apply activation self.total_output = self.act(self.conv_output + self.conv_bias) return self._call(self.total_output)
def encoder(self, inputs): # convolutional layer conv1 = ConvLayer(input_filters=tf.cast(inputs.shape[3], tf.int32), output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME") conv1_act = conv1.__call__(inputs) print(conv1_act.shape) # convolutional and pooling layer conv_pool1 = ConvPoolLayer(input_filters=8, output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME", pool_size=3, pool_stride=2, pool_padding="SAME") conv_pool1_act = conv_pool1.__call__(conv1_act) print(conv_pool1_act.shape) # convolutional layer conv2 = ConvLayer(input_filters=8, output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME") conv2_act = conv2.__call__(conv_pool1_act) print(conv2_act.shape) # convolutional and pooling layer conv_pool2 = ConvPoolLayer(input_filters=16, output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME", pool_size=3, pool_stride=2, pool_padding="SAME") conv_pool2_act = conv_pool2.__call__(conv2_act) print(conv_pool2_act.shape) conv3 = ConvLayer(input_filters=16, output_filters=32, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME") conv3_act = conv3.__call__(conv_pool2_act) print(conv3_act.shape) conv_pool3 = ConvPoolLayer(input_filters=32, output_filters=32, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding="SAME", pool_size=3, pool_stride=2, pool_padding="SAME") conv_pool3_act = conv_pool3.__call__(conv3_act) print(conv_pool3_act.shape) last_conv_dims = conv_pool3_act.shape[1:] # make output of pooling flatten flatten = tf.reshape(conv_pool3_act, [-1,last_conv_dims[0]*last_conv_dims[1]*last_conv_dims[2]]) print(flatten.shape) weights_encoder = normal_initializer((tf.cast(flatten.shape[1], tf.int32), FLAGS.code_size)) bias_encoder = zero_initializer((FLAGS.code_size)) # apply fully connected layer dense = tf.matmul(flatten, weights_encoder) + bias_encoder print(dense.shape) return dense, last_conv_dims
def __call__(self, inputs): ##################################################################### # TODO: Define Filters and Bias # # Filter kernel size is self.kernel_size # # Number of input channels is self.input_filters # # Number of desired output filters is self.output_filters # # Define filter tensor with proper size using normal initializer # # Define bias tensor as well using zero initializer # ##################################################################### self.conv_filter = normal_initializer( shape=(self.kernel_size, self.kernel_size, self.input_filters, self.output_filters), name='conv_w') self.conv_bias = zero_initializer(shape=(self.output_filters, ), name='conv_b') ##################################################################### # END OF YOUR CODE # ##################################################################### ####################################################################### # TODO: Apply Convolution, Bias and Activation Function # # Use tf.nn.conv2d and give it following inputs # # 1. Input tensor # # 2. Filter you have defined in above empty part # # 3. Stride tensor showing stride size for each dimension # # 4. Padding type based on self.kernel_padding # # Add bias after filtering by convolutions # # Finally apply activation function and store it as self.total_output # ####################################################################### self.conv_output = tf.nn.conv2d( input=inputs, filter=self.conv_filter, strides=[1, self.kernel_stride, self.kernel_stride, 1], padding=self.kernel_padding) self.total_output = self.act(self.conv_output + self.conv_bias) ####################################################################### # END OF YOUR CODE # ####################################################################### return self._call(self.total_output)
def __call__(self, inputs): # Define Filters and Bias # Note that tensor shape of this filter is different from that of the filter in ConvLayer self.deconv_filter = normal_initializer(shape=[self.kernel_size, self.kernel_size, self.output_filters, self.input_filters]) self.deconv_bias = zero_initializer(shape=[self.output_filters]) # input height and width input_height = inputs.get_shape().as_list()[1] input_width = inputs.get_shape().as_list()[2] # Calculate Output Shape # The formula to calculate output shapes depends on type of padding if self.kernel_padding == 'SAME': output_height = self.kernel_stride*input_height output_width = self.kernel_stride*input_width elif self.kernel_padding == 'VALID': output_height = self.kernel_stride*(input_height-1)+self.kernel_size output_width = self.kernel_stride*(input_width-1)+self.kernel_size else: raise Exception('No such padding') # Apply Transposed Convolution, Bias and Activation Function # Use tf.nn.conv2d_transpose and give it following inputs # 1. Input tensor # 2. Filter you have defined above # 3. Output shape you have calculated above # 4. Stride tensor showing stride size for each dimension # 5. Padding type based on self.kernel_padding batch_size = tf.shape(inputs)[0] Depth = inputs.get_shape().as_list()[3] deconv_shape = tf.stack([batch_size, output_height, output_width, self.output_filters]) self.deconv_output = tf.nn.conv2d_transpose(inputs, self.deconv_filter, output_shape=deconv_shape, strides=[1, self.kernel_stride, self.kernel_stride, 1], padding=self.kernel_padding) # Add bias and apply activation self.total_output = self.act(tf.add(self.deconv_output, self.deconv_bias)) return self.total_output
def __call__(self, inputs): # Define Filters and Bias # Define filter tensor with proper size using normal initializer # Define bias tensor as well using zero initializer self.conv_filter = normal_initializer(shape=[self.kernel_size, self.kernel_size, self.input_filters, self.output_filters]) self.conv_bias = zero_initializer(shape=[self.output_filters]) # Apply Convolution, Bias and Activation Function # Use tf.nn.conv2d and give it following inputs # 1. Input tensor # 2. Filter you have defined in above empty part # 3. Stride tensor showing stride size for each dimension # 4. Padding type based on self.kernel_padding self.conv_output = tf.nn.conv2d(inputs, self.conv_filter, strides=[1, self.kernel_stride, self.kernel_stride, 1], padding=self.kernel_padding) # Add bias and apply activation self.total_output = self.act(tf.add(self.conv_output, self.conv_bias)) return self._call(self.total_output)
def encoder(self, inputs): # Build Convolutional Part of Encoder # Put sequential layers: # ConvLayer1 ==> ConvPoolLayer1 ==> ConvLayer2 ==> ConvPoolLayer2 ==> ConvLayer3 ==> ConvPoolLayer3 # Settings of layers: # For all ConvLayers: filter size = 3, filter stride = 1, padding type = SAME # For all ConvPoolLayers: # Conv : filter size = 3, filter stride = 1, padding type = SAME # Pooling : pool size = 3, pool stride = 2, padding type = SAME # Number of Filters: # num_channel defined in FLAGS (input) ==> 8 ==> 8 ==> 16 ==> 16 ==> 32 ==> 32 # convolutional layer conv1_class = ConvLayer(input_filters=FLAGS.num_channel, output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME') conv1 = conv1_class(inputs=inputs) print(conv1.shape) # convolutional and pooling layer conv_pool1_class = ConvPoolLayer(input_filters=8, output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME') conv_pool1 = conv_pool1_class(inputs=conv1) print(conv_pool1.shape) # convolutional layer conv2_class = ConvLayer(input_filters=8, output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME') conv2 = conv2_class(inputs=conv_pool1) print(conv2.shape) # convolutional and pooling layer conv_pool2_class = ConvPoolLayer(input_filters=16, output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME') conv_pool2 = conv_pool2_class(inputs=conv2) print(conv_pool2.shape) conv3_class = ConvLayer(input_filters=16, output_filters=32, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME') conv3 = conv3_class(inputs=conv_pool2) print(conv3.shape) conv_pool3_class = ConvPoolLayer(input_filters=32, output_filters=32, act=tf.nn.relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME') conv_pool3 = conv_pool3_class(inputs=conv3) print(conv_pool3.shape) # Make Output Flatten and Apply Transformation # Num of features for dense is defined by code_size in FLAG # make output of pooling flatten WholeShape = tf.shape(conv_pool3) NumSamples = WholeShape[0] last_conv_dims = tf.constant(value=(4, 4, 32), dtype=tf.int32, shape=(3, )) #WholeShape[1:] FlattedShape = tf.reduce_prod(last_conv_dims) flatten = tf.reshape(conv_pool3, shape=[NumSamples, FlattedShape]) print(flatten.shape) # apply fully connected layer W_Trans = normal_initializer(shape=[FlattedShape, FLAGS.code_size]) B_Trans = zero_initializer(shape=[FLAGS.code_size]) dense = tf.nn.xw_plus_b(flatten, W_Trans, B_Trans) print(dense.shape) return dense, last_conv_dims
def decoder(self, inputs, last_conv_dims): # Apply Transformation and Reshape to Original # Num of output features in this transformation can be calculated using last_conv_dims # Please note that number of input features is code_size stored in FLAGS # apply fully connected layer FlattedShape = tf.reduce_prod(last_conv_dims) W_InvTrans = normal_initializer(shape=[FLAGS.code_size, FlattedShape]) B_InvTrans = zero_initializer(shape=[FlattedShape]) decode_layer = tf.nn.relu( tf.nn.xw_plus_b(inputs, W_InvTrans, B_InvTrans)) print(decode_layer.shape) # reshape to send as input to transposed convolutional layer deconv_input = tf.reshape(decode_layer, shape=[ -1, last_conv_dims[0], last_conv_dims[1], last_conv_dims[2] ]) print(deconv_input.shape) # Apply 3 Transposed Convolution Sequentially # Put sequential layers: # DeconvLayer ==> Deconv Layer ==> Deconv Layer # For all layers use: # filter size = 3, filter stride = 2, padding type = SAME # Apply tf.nn.relu as activation function for first two layers # Multiply all the numbers in last_conv_dims to find num of output features # Number of filters: # num_channel defined in FLAGS (input of first deconv) ==> 16 ==> 8 ==> 1 # transpose convolutional layer deconv1_class = DeconvLayer(input_filters=last_conv_dims[2], output_filters=16, act=tf.nn.relu, kernel_size=3, kernel_stride=2, kernel_padding='SAME') deconv1 = deconv1_class(inputs=deconv_input) print(deconv1.shape) # transpose convolutional layer deconv2_class = DeconvLayer(input_filters=16, output_filters=8, act=tf.nn.relu, kernel_size=3, kernel_stride=2, kernel_padding='SAME') deconv2 = deconv2_class(inputs=deconv1) print(deconv2.shape) # transpose convolutional layer deconv3_class = DeconvLayer(input_filters=8, output_filters=1, act=tf.identity, kernel_size=3, kernel_stride=2, kernel_padding='SAME') deconv3 = deconv3_class(inputs=deconv2) print(deconv3.shape) return deconv3
def encoder(self, inputs): ############################################################################################################# # TODO: Build Convolutional Part of Encoder # # Put sequential layers: # # ConvLayer1 ==> ConvPoolLayer1 ==> ConvLayer2 ==> ConvPoolLayer2 ==> ConvLayer3 ==> ConvPoolLayer3 # # Settings of layers: # # For all ConvLayers: filter size = 3, filter stride = 1, padding type = SAME # # For all ConvPoolLayers: # # Conv : filter size = 3, filter stride = 1, padding type = SAME # # Pooling : pool size = 3, pool stride = 2, padding type = SAME # # Number of Filters: # # num_channel defined in FLAGS (input) ==> 8 ==> 8 ==> 16 ==> 16 ==> 32 ==> 32 # ############################################################################################################# relu = tf.nn.relu # convolutional layer cl1 = ConvLayer(FLAGS.num_channel, 8, relu, 3, 1, 'SAME') conv1 = cl1(inputs) print(conv1.shape) # convolutional and pooling layer cl2 = ConvPoolLayer(8, 8, relu, 3, 1, 'SAME', 3, 2, 'SAME') conv_pool1 = cl2(conv1) print(conv_pool1.shape) # convolutional layer cl3 = ConvLayer(8, 16, relu, 3, 1, 'SAME') conv2 = cl3(conv_pool1) print(conv2.shape) # convolutional and pooling layer cl4 = ConvPoolLayer(16, 16, relu, 3, 1, 'SAME', 3, 2, 'SAME') conv_pool2 = cl4(conv2) print(conv_pool2.shape) cl5 = ConvLayer(16, 32, relu, 3, 1, 'SAME') conv3 = cl5(conv_pool2) print(conv3.shape) cl6 = ConvPoolLayer(32, 32, tf.nn.relu, 3, 1, 'SAME', 3, 2, 'SAME') conv_pool3 = cl6(conv3) print(conv_pool3.shape) ########################################################################## # END OF YOUR CODE # ########################################################################## ########################################################################## # TODO: Make Output Flatten and Apply Transformation # # Please save the last three dimensions of output of the above code # # Save these numbers in a variable called last_conv_dims # # Multiply all these dimensions to find num of features if flatten # # Use tf.reshape to make a tensor flat # # Define some weights and bias and apply linear transformation # # Use normal and zero initializer for weights and bias respectively # # Please store output of transformation in a variable called dense # # Num of features for dense is defined by code_size in FLAG # # Note that there is no need apply any kind of activation function # ########################################################################## # make output of pooling flatten dim = np.prod(conv_pool3.shape[1:]) flatten = tf.reshape(conv_pool3, [-1, dim]) print(flatten.shape) # apply fully connected layer W_fc = normal_initializer(shape=(dim.__int__(), FLAGS.code_size)) B_fc = zero_initializer(shape=FLAGS.code_size) dense = tf.matmul(flatten, W_fc) + B_fc print(dense.shape) ########################################################################## # END OF YOUR CODE # ########################################################################## last_conv_dims = conv_pool3.shape[1:] return dense, last_conv_dims
def decoder(self, inputs, last_conv_dims): ######################################################################################### # TODO: Apply Transformation and Reshape to Original # # Define some weights and biases and apply linear transformation # # Num of output features in this transformation can be calculated using last_conv_dims # # Multiply all the numbers in last_conv_dims to find num of output features # # Please note that number of input features is code_size stored in FLAGS # # Use normal and zero initializer for weights and biases respectively # # Apply tf.nn.relu activation function # # Finally use last_conv_dims to reshape output of transformation # ######################################################################################### # apply fully connected layer dim = last_conv_dims[0] * last_conv_dims[1] * last_conv_dims[2] # dim = np.prod(last_conv_dims) W_fc = normal_initializer(shape=(FLAGS.code_size, dim.__int__())) B_fc = zero_initializer(shape=dim) wxb = tf.matmul(inputs, W_fc) + B_fc decode_layer = tf.nn.relu(wxb) print(decode_layer.shape) # reshape to send as input to transposed convolutional layer deconv_input = tf.reshape(decode_layer, [-1, last_conv_dims[0], last_conv_dims[1], last_conv_dims[2]]) print(deconv_input.shape) ######################################################################################### # END OF YOUR CODE # ######################################################################################### ################################################################################### # TODO: Apply 3 Transposed Convolution Sequentially # # Put sequential layers: # # DeconvLayer ==> Deconv Layer ==> Deconv Layer # # For all layers use: # # filter size = 3, filter stride = 2, padding type = SAME # # Apply tf.nn.relu as activation function for first two layers # # Note that use linear activation function for last layer # # Multiply all the numbers in last_conv_dims to find num of output features # # Number of filters: # # num_channel defined in FLAGS (input of first deconv) ==> 16 ==> 8 ==> 1 # # Save final output in deconv3 # ################################################################################### relu = tf.nn.relu # transpose convolutional layer dc1 = DeconvLayer(32, 16, relu, 3, 2, 'SAME') deconv1 = dc1(deconv_input) print(deconv1.shape) # transpose convolutional layer dc2 = DeconvLayer(16, 8, relu, 3, 2, 'SAME') deconv2 = dc2(deconv1) print(deconv2.shape) # transpose convolutional layer dc3 = DeconvLayer(8, 1, lambda x: x, 3, 2, 'SAME') deconv3 = dc3(deconv2) print(deconv3.shape) ################################################################################### # END OF YOUR CODE # ################################################################################### return deconv3
def encoder(self, inputs): ############################################################################################################# # TODO: Build Convolutional Part of Encoder # # Put sequential layers: # # ConvLayer1 ==> ConvPoolLayer1 ==> ConvLayer2 ==> ConvPoolLayer2 ==> ConvLayer3 ==> ConvPoolLayer3 # # Settings of layers: # # For all ConvLayers: filter size = 3, filter stride = 1, padding type = SAME # # For all ConvPoolLayers: # # Conv : filter size = 3, filter stride = 1, padding type = SAME # # Pooling : pool size = 3, pool stride = 2, padding type = SAME # # Number of Filters: # # num_channel defined in FLAGS (input) ==> 8 ==> 8 ==> 16 ==> 16 ==> 32 ==> 32 # ############################################################################################################# # convolutional layer relu = tf.nn.relu conv1 = ConvLayer(input_filters=FLAGS.num_channel, output_filters=8, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME')(inputs) print(conv1.shape) # convolutional and pooling layer conv_pool1 = ConvPoolLayer(input_filters=8, output_filters=8, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME')(conv1) print(conv_pool1.shape) # convolutional layer conv2 = ConvLayer(input_filters=8, output_filters=16, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME')(conv_pool1) print(conv2.shape) # convolutional and pooling layer conv_pool2 = ConvPoolLayer(input_filters=16, output_filters=16, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME')(conv2) print(conv_pool2.shape) conv3 = ConvLayer(input_filters=16, output_filters=32, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME')(conv_pool2) print(conv3.shape) conv_pool3 = ConvPoolLayer(input_filters=32, output_filters=32, act=relu, kernel_size=3, kernel_stride=1, kernel_padding='SAME', pool_size=3, pool_stride=2, pool_padding='SAME')(conv3) print(conv_pool3.shape) ########################################################################## # END OF YOUR CODE # ########################################################################## ########################################################################## # TODO: Make Output Flatten and Apply Transformation # # Please save the last three dimensions of output of the above code # # Save these numbers in a variable called last_conv_dims # # Multiply all these dimensions to find num of features if flatten # # Use tf.reshape to make a tensor flat # # Define some weights and bias and apply linear transformation # # Use normal and zero initializer for weights and bias respectively # # Please store output of transformation in a variable called dense # # Num of features for dense is defined by code_size in FLAG # # Note that there is no need apply any kind of activation function # ########################################################################## # make output of pooling flatten last_conv_dims = conv_pool3.shape[1:] flatten_dim = np.prod(last_conv_dims) flatten = tf.reshape(conv_pool3, [tf.shape(conv_pool3)[0], flatten_dim]) print(flatten.shape) # apply fully connected layer dense = tf.matmul(flatten, normal_initializer([ flatten_dim, FLAGS.code_size ])) + zero_initializer([FLAGS.code_size]) print(dense.shape) ########################################################################## # END OF YOUR CODE # ########################################################################## return dense, last_conv_dims
def decoder(self, inputs, last_conv_dims): ######################################################################################### # TODO: Apply Transformation and Reshape to Original # # Define some weights and biases and apply linear transformation # # Num of output features in this transformation can be calculated using last_conv_dims # # Multiply all the numbers in last_conv_dims to find num of output features # # Please note that number of input features is code_size stored in FLAGS # # Use normal and zero initializer for weights and biases respectively # # Apply tf.nn.relu activation function # # Finally use last_conv_dims to reshape output of transformation # ######################################################################################### # apply fully connected layer decode_layer = tf.matmul( inputs, normal_initializer([FLAGS.code_size, np.prod(last_conv_dims)])) + zero_initializer( [np.prod(last_conv_dims)]) print(decode_layer.shape) # reshape to send as input to transposed convolutional layer deconv_input = tf.reshape(decode_layer, [ tf.shape(inputs)[0], last_conv_dims[0], last_conv_dims[1], last_conv_dims[2] ]) print(deconv_input.shape) ######################################################################################### # END OF YOUR CODE # ######################################################################################### ################################################################################### # TODO: Apply 3 Transposed Convolution Sequentially # # Put sequential layers: # # DeconvLayer ==> Deconv Layer ==> Deconv Layer # # For all layers use: # # filter size = 3, filter stride = 2, padding type = SAME # # Apply tf.nn.relu as activation function for first two layers # # Note that use linear activation function for last layer # # Multiply all the numbers in last_conv_dims to find num of output features # # Number of filters: # # num_channel defined in FLAGS (input of first deconv) ==> 16 ==> 8 ==> 1 # # Save final output in deconv3 # ################################################################################### relu = tf.nn.relu # transpose convolutional layer print(last_conv_dims) deconv1 = DeconvLayer(input_filters=last_conv_dims[2], output_filters=16, act=relu, kernel_size=3, kernel_stride=2, kernel_padding='SAME')(deconv_input) print(deconv1.shape) # transpose convolutional layer deconv2 = DeconvLayer(input_filters=16, output_filters=8, act=relu, kernel_size=3, kernel_stride=2, kernel_padding='SAME')(deconv1) print(deconv2.shape) # transpose convolutional layer deconv3 = DeconvLayer(input_filters=8, output_filters=1, act=tf.keras.activations.linear, kernel_size=3, kernel_stride=2, kernel_padding='SAME')(deconv2) print(deconv3.shape) ################################################################################### # END OF YOUR CODE # ################################################################################### return deconv3
def __call__(self, inputs): ############################################################################################ # TODO: Define Filters and Bias # # Filter kernel size is self.kernel_size # # Number of input channels is self.input_filters # # Number of desired output filters is self.output_filters # # Define filter tensor with proper size using normal initializer # # Note that tensor shape of this filter is different from that of the filter in ConvLayer # # Define bias tensor as well using zero initializer # ############################################################################################ self.deconv_filter = normal_initializer(shape=(self.kernel_size, self.kernel_size, self.output_filters, self.input_filters)) self.deconv_bias = zero_initializer(shape=(self.output_filters)) ############################################################################################ # END OF YOUR CODE # ############################################################################################ # input height and width input_height = inputs.get_shape().as_list()[1] input_width = inputs.get_shape().as_list()[2] ############################################################################ # TODO: Calculate Output Shape # # Use input height and width to set output height and width respectively # # The formula to calculate output shapes depends on type of padding # ############################################################################ if self.kernel_padding == 'VALID': output_height = self.kernel_stride * (input_height - 1) + self.kernel_size output_width = self.kernel_stride * (input_width - 1) + self.kernel_size elif self.kernel_padding == 'SAME': output_height = self.kernel_stride * (input_height) output_width = self.kernel_stride * (input_width) else: raise Exception('No such padding') ############################################################################ # END OF YOUR CODE # ############################################################################ ######################################################################### # TODO: Apply Transposed Convolution, Bias and Activation Function # # Use tf.nn.conv2d_transpose and give it following inputs # # 1. Input tensor # # 2. Filter you have defined above # # 3. Output shape you have calculated above # # 4. Stride tensor showing stride size for each dimension # # 5. Padding type based on self.kernel_padding # # Add bias after filtering by transposed convolutions # # Finally apply activation function and store it as self.total_output # ######################################################################### self.deconv_output = tf.nn.conv2d_transpose( value=inputs, filter=self.deconv_filter, output_shape=[ tf.shape(inputs)[0], output_height, output_width, self.output_filters ], strides=[1, self.kernel_stride, self.kernel_stride, 1], padding=self.kernel_padding) # Add bias and apply activation self.total_output = self.act(self.deconv_output + self.deconv_bias) ######################################################################### # END OF YOUR CODE # ######################################################################### return self.total_output