我们从Python开源项目中，提取了以下5个代码示例，用于说明如何使用ops.fc()。
def inception_v3_parameters(weight_decay=0.00004, stddev=0.1, batch_norm_decay=0.9997, batch_norm_epsilon=0.001): """Yields the scope with the default parameters for inception_v3. Args: weight_decay: the weight decay for weights variables. stddev: standard deviation of the truncated guassian weight distribution. batch_norm_decay: decay for the moving average of batch_norm momentums. batch_norm_epsilon: small float added to variance to avoid dividing by zero. Yields: a arg_scope with the parameters needed for inception_v3. """ # Set weight_decay for weights in Conv and FC layers. with scopes.arg_scope([ops.conv2d, ops.fc], weight_decay=weight_decay): # Set stddev, activation and parameters for batch_norm. with scopes.arg_scope([ops.conv2d], stddev=stddev, activation=tf.nn.relu, batch_norm_params={ 'decay': batch_norm_decay, 'epsilon': batch_norm_epsilon}) as arg_scope: yield arg_scope
def __call__(self, z, y): """ :param z: 2D [batch_size, z_dim] :param y: 2D [batch_size, y_dim] :return: """ batch_size, y_dim = y.get_shape().as_list() batch_size_, z_dim = z.get_shape().as_list() assert batch_size == batch_size_ h1_size = int(self._output_size / 4) h2_size = int(self._output_size / 2) with tf.variable_scope(self._name): yb = tf.reshape(y, shape=[-1, 1, 1, y_dim]) # (100, 1, 1, 10) z = tf.concat([z, y], axis=1) # (batch_size=100, y_dim+z_dim=110) h0 = tf.nn.relu( ops.batch_norm( ops.fc(z, self._fc_dim, reuse=self._reuse, name='g_fc0'), is_training=self._is_training, reuse=self._reuse, name_scope='g_bn0' ) ) h0 = tf.concat([h0, y], axis=1) # (batch_size=100, fc_dim+y_dim=794) h1 = tf.nn.relu( ops.batch_norm( ops.fc(h0, self._ngf*h1_size*h1_size, reuse=self._reuse, name='g_fc1'), is_training=self._is_training, reuse=self._reuse, name_scope='g_bn1' ) ) h1 = tf.reshape(h1, shape=[-1, h1_size, h1_size, self._ngf]) h1 = tf.concat([h1, yb*tf.ones([batch_size, h1_size, h1_size, y_dim])], axis=3) # (100, 7, 7, 522) h2 = tf.nn.relu( ops.batch_norm( ops.deconv2d(h1, self._ngf, reuse=self._reuse, name='g_conv2'), is_training=self._is_training, reuse=self._reuse, name_scope='g_bn2' ) ) h2 = tf.concat([h2, yb*tf.ones([batch_size, h2_size, h2_size, y_dim])], axis=3) # (100, 14, 14, 522) h3 = tf.nn.sigmoid( ops.deconv2d(h2, self._channel_dim, reuse=self._reuse, name='g_conv3') ) # TODO DIMENSION??? SHRINK self._reuse = True return h3 # (100, 28, 28, 1)
def __call__(self, input_, y): batch_size, y_dim = y.get_shape().as_list() batch_size_, height, width, c_dim = input_.get_shape().as_list() assert batch_size == batch_size_ assert (self._input_size == width) and (self._input_size == height) h0_size = int(self._input_size / 2) h1_size = int(self._input_size / 4) with tf.variable_scope(self._name): yb = tf.reshape(y, shape=[-1, 1, 1, y_dim]) # dim(x) = (100, 28, 28, 11) x = tf.concat([input_, yb*tf.ones([batch_size, self._input_size, self._input_size, y_dim])], axis=3) h0 = ops.leaky_relu( ops.conv2d(x, c_dim + y_dim, reuse=self._reuse, name='d_conv0'), slope=0.2 ) h0 = tf.concat([h0, yb*tf.ones([batch_size, h0_size, h0_size, y_dim])], axis=3) # (100, 14, 14, 21) h1 = ops.leaky_relu( ops.batch_norm( ops.conv2d(h0, c_dim + self._ndf, reuse=self._reuse, name='d_conv1'), is_training=self._is_training, reuse=self._reuse, name_scope='d_bn1' ), slope=0.2 ) h1 = tf.reshape(h1, [batch_size, h1_size*h1_size*(c_dim+self._ndf)]) h1 = tf.concat([h1, y], axis=1) # (100, 28*28*(1+64)+10) h2 = ops.leaky_relu( ops.batch_norm( ops.fc(h1, self._fc_dim, reuse=self._reuse, name='d_fc2'), is_training=self._is_training, reuse=self._reuse, name_scope='d_bn2' ), slope=0.2 ) h2 = tf.concat([h2, y], axis=1) # (100, 794) # h3 = tf.nn.sigmoid( h3 = ops.fc(h2, 1, reuse=self._reuse, name='d_fc3') # ) self._reuse = True return h3 # (100, 1)
def discriminator(images, labels, reuse=False): with tf.variable_scope("discriminator") as scope: if reuse: scope.reuse_variables() # conv1 conv1 = ops.conv_2d(images, 64, scope="conv1") # leakly ReLu h1 = ops.leaky_relu(conv1) # conv2 conv2 = ops.conv_2d(h1, 128, scope="conv2") # batch norm norm2 = ops.batch_norm(conv2, scope="batch_norm2", is_training=True) # leaky ReLU h2 = ops.leaky_relu(norm2) # conv3 conv3 = ops.conv_2d(h2, 256, scope="conv3") # batch norm norm3 = ops.batch_norm(conv3, scope="batch_norm3", is_training=True) # leaky ReLU h3 = ops.leaky_relu(norm3) # conv4 conv4 = ops.conv_2d(h3, 512, scope="conv4") # batch norm norm4 = ops.batch_norm(conv4, scope="batch_norm4", is_training=True) # leaky ReLU h4 = ops.leaky_relu(norm4) # reshape h4_reshape = tf.reshape(h4, [FLAGS.batch_size, -1]) # source logits source_logits = ops.fc(h4_reshape, 1, scope="source_logits") # class logits class_logits = ops.fc( h4_reshape, FLAGS.n_classes, scope="class_logits") return source_logits, class_logits
def build(self, is_train=True): n = self.a_dim conv_info = self.conv_info # build loss and accuracy {{{ def build_loss(logits, labels): # Cross-entropy loss loss = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels) # Classification accuracy correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) return tf.reduce_mean(loss), accuracy # }}} # Classifier: takes images as input and outputs class label [B, m] def C(img, q, scope='Classifier'): with tf.variable_scope(scope) as scope: log.warn(scope.name) conv_1 = conv2d(img, conv_info[0], is_train, s_h=3, s_w=3, name='conv_1') conv_2 = conv2d(conv_1, conv_info[1], is_train, s_h=3, s_w=3, name='conv_2') conv_3 = conv2d(conv_2, conv_info[2], is_train, name='conv_3') conv_4 = conv2d(conv_3, conv_info[3], is_train, name='conv_4') conv_q = tf.concat([tf.reshape(conv_4, [self.batch_size, -1]), q], axis=1) fc_1 = fc(conv_q, 256, name='fc_1') fc_2 = fc(fc_1, 256, name='fc_2') fc_2 = slim.dropout(fc_2, keep_prob=0.5, is_training=is_train, scope='fc_3/') fc_3 = fc(fc_2, n, activation_fn=None, name='fc_3') return fc_3 logits = C(self.img, self.q, scope='Classifier') self.all_preds = tf.nn.softmax(logits) self.loss, self.accuracy = build_loss(logits, self.a) # Add summaries def draw_iqa(img, q, target_a, pred_a): fig, ax = tfplot.subplots(figsize=(6, 6)) ax.imshow(img) ax.set_title(question2str(q)) ax.set_xlabel(answer2str(target_a)+answer2str(pred_a, 'Predicted')) return fig try: tfplot.summary.plot_many('IQA/', draw_iqa, [self.img, self.q, self.a, self.all_preds], max_outputs=3, collections=["plot_summaries"]) except: pass tf.summary.scalar("loss/accuracy", self.accuracy) tf.summary.scalar("loss/cross_entropy", self.loss) log.warn('Successfully loaded the model.')
