code: def build_graph(self, image, label):
      image = image / 256.0
  
      fw, fa, fg = get_dorefa(BITW, BITA, BITG)
  
      def new_get_variable(v):
          name = v.op.name
          # don't binarize first and last layer
          if not name.endswith("W") or "conv1" in name or "fct" in name:
              return v
          else:
              logger.info("Binarizing weight {}".format(v.op.name))
              return fw(v)
  
      def nonlin(x):
          return tf.clip_by_value(x, 0.0, 1.0)
  
      def activate(x):
          return fa(nonlin(x))
  
      def resblock(x, channel, stride):
          def get_stem_full(x):
              return (
                  LinearWrap(x)
                  .Conv2D("c3x3a", channel, 3)
                  .BatchNorm("stembn")
                  .apply(activate)
                  .Conv2D("c3x3b", channel, 3)()
              )
  
          channel_mismatch = channel != x.get_shape().as_list()[3]
          if stride != 1 or channel_mismatch or "pool1" in x.name:
              # handling pool1 is to work around an architecture bug in our model
              if stride != 1 or "pool1" in x.name:
                  x = AvgPooling("pool", x, stride, stride)
              x = BatchNorm("bn", x)
              x = activate(x)
              shortcut = Conv2D("shortcut", x, channel, 1)
              stem = get_stem_full(x)
          else:
              shortcut = x
              x = BatchNorm("bn", x)
              x = activate(x)
              stem = get_stem_full(x)
          return shortcut + stem
  
      def group(x, name, channel, nr_block, stride):
          with tf.variable_scope(name + "blk1"):
              x = resblock(x, channel, stride)
          for i in range(2, nr_block + 1):
              with tf.variable_scope(name + "blk{}".format(i)):
                  x = resblock(x, channel, 1)
          return x
  
      with remap_variables(new_get_variable), argscope(
          BatchNorm, decay=0.9, epsilon=1e-4
      ), argscope(Conv2D, use_bias=False, nl=tf.identity):
          logits = (
              LinearWrap(image)
              # use explicit padding here, because our private training framework has
              # different padding mechanisms from TensorFlow
              .tf.pad([[0, 0], [3, 2], [3, 2], [0, 0]])
              .Conv2D(
                  "conv1",
                  64,
                  7,
                  stride=2,
                  padding="VALID",
                  use_bias=True,
              )
              .tf.pad([[0, 0], [1, 1], [1, 1], [0, 0]], "SYMMETRIC")
              .MaxPooling("pool1", 3, 2, padding="VALID")
              .apply(group, "conv2", 64, 2, 1)
              .apply(group, "conv3", 128, 2, 2)
              .apply(group, "conv4", 256, 2, 2)
              .apply(group, "conv5", 512, 2, 2)
              .BatchNorm("lastbn")
              .apply(nonlin)
              .GlobalAvgPooling("gap")
              .tf.multiply(
                  49
              )  # this is due to a bug in our model design
              .FullyConnected("fct", 1000)()
          )
      tf.nn.softmax(logits, name="output")
      ImageNetModel.compute_loss_and_error(logits, label)
  
file_path: tensorpack/examples/DoReFa-Net/resnet-dorefa.py
imports: import argparse
  import numpy
  import os
  import cv2
  import tensorflow
  from tensorpack import *
  from tensorpack.dataflow import dataset
  from tensorpack.tfutils.varreplace import remap_variables
  from dorefa import get_dorefa
  from imagenet_utils import ImageNetModel, eval_classification, fbresnet_augmentor
label_desc: Use image node_id 2 for calling the Model obj's underlying member method code with example usage: obj.build_graph(image, label) and returns: tf, fa, unknown, x, v, fw, LinearWrap