Deep Learning Tools

  from third_party.tensorflow.contrib.layers.python import layers

  arg_scope = tf.contrib.framework.arg_scope

  with arg_scope([layers.conv2d], padding='SAME',
                 initializer=layers.variance_scaling_initializer(),
                 regularizer=layers.l2_regularizer(0.05)):
    net = layers.conv2d(inputs, 64, [11, 11], 4, padding='VALID', scope='conv1')
    net = layers.conv2d(net, 256, [5, 5], scope='conv2')

  layers.conv2d(inputs, 64, [11, 11], 4, padding='VALID',
                initializer=layers.variance_scaling_initializer(),
                regularizer=layers.l2_regularizer(0.05), scope='conv1')

  layers.conv2d(inputs, 256, [5, 5], padding='SAME',
                initializer=layers.variance_scaling_initializer(),
                regularizer=layers.l2_regularizer(0.05), scope='conv2')

  with arg_scope([layers.conv2d], padding='SAME',
                 initializer=layers.variance_scaling_initializer(),
                 regularizer=layers.l2_regularizer(0.05)) as sc:
      net = layers.conv2d(net, 256, [5, 5], scope='conv1')
      # ...

  with arg_scope(sc):
      net = layers.conv2d(net, 256, [5, 5], scope='conv2')

  @tf.contrib.framework.add_arg_scope
  def conv2d(*args, **kwargs)

  # class_ids will be the model prediction for the class (Iris flower type)
  # The output node with the highest value is our prediction
  predictions = { 'class_ids': tf.argmax(input=logits, axis=1) }

  # Return our prediction
  if mode == tf.estimator.ModeKeys.PREDICT:
     return tf.estimator.EstimatorSpec(mode, predictions=predictions)

  # To calculate the loss, we need to convert our labels
  # Our input labels have shape: [batch_size, 1]
  labels = tf.squeeze(labels, 1)          # Convert to shape [batch_size]
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Calculate the accuracy between the true labels, and our predictions
  accuracy = tf.metrics.accuracy(labels, predictions['class_ids'])

  if mode == tf.estimator.ModeKeys.EVAL:
     return tf.estimator.EstimatorSpec(
         mode,
         loss=loss,
         eval_metric_ops={'my_accuracy': accuracy})

  optimizer = tf.train.AdagradOptimizer(0.05)
  train_op = optimizer.minimize(
     loss,
     global_step=tf.train.get_global_step())

  # Set the TensorBoard scalar my_accuracy to the accuracy
  tf.summary.scalar('my_accuracy', accuracy[1])

  return tf.estimator.EstimatorSpec(
     mode,
     loss=loss,
     train_op=train_op)

  numeric_feature_column = tf.feature_column.numeric_column(key="SepalLength",
                                                            dtype=tf.float64)

  vector_feature_column = tf.feature_column.numeric_column(key="Bowling",
                                                           shape=10)

  matrix_feature_column = tf.feature_column.numeric_column(key="MyMatrix",
                                                           shape=[10,5])

  # A numeric column for the raw input.
  numeric_feature_column = tf.feature_column.numeric_column("Year")

  # Bucketize the numeric column on the years 1960, 1980, and 2000
  bucketized_feature_column = tf.feature_column.bucketized_column(
      source_column = numeric_feature_column,
      boundaries = [1960, 1980, 2000])

  # Create a categorical output for input "feature_name_from_input_fn",
  # which must be of integer type. Value is expected to be >= 0 and < num_buckets
  identity_feature_column = tf.feature_column.categorical_column_with_identity(
      key='feature_name_from_input_fn',
      num_buckets=4) # Values [0, 4)

  # The 'feature_name_from_input_fn' above needs to match an integer key that is
  # returned from input_fn (see below). So for this case, 'Integer_1' or
  # 'Integer_2' would be valid strings instead of 'feature_name_from_input_fn'.
  # For more information, please check out Part 1 of this blog series.
  def input_fn():
      ...<code>...
      return ({ 'Integer_1':[values], ..<etc>.., 'Integer_2':[values] },
              [Label_values])

  # Given input "feature_name_from_input_fn" which is a string,
  # create a categorical feature to our model by mapping the input to one of
  # the elements in the vocabulary list.
  vocabulary_feature_column =
      tf.feature_column.categorical_column_with_vocabulary_list(
          key="feature_name_from_input_fn",
          vocabulary_list=["kitchenware", "electronics", "sports"])

  # Given input "feature_name_from_input_fn" which is a string,
  # create a categorical feature to our model by mapping the input to one of
  # the elements in the vocabulary list.
  vocabulary_feature_column =
      tf.feature_column.categorical_column_with_vocabulary_list(
          key="feature_name_from_input_fn",
          vocabulary_list=["kitchenware", "electronics", "sports"])

  # Create categorical output for input "feature_name_from_input_fn".
  # Category becomes: hash_value("feature_name_from_input_fn") % hash_bucket_size
  hashed_feature_column =
      tf.feature_column.categorical_column_with_hash_bucket(
          key = "feature_name_from_input_fn",
          hash_buckets_size = 100) # The number of categories

  # In our input_fn, we convert input longitude and latitude to integer values
  # in the range [0, 100)
  def input_fn():
      # Using Datasets, read the input values for longitude and latitude
      latitude = ...   # A tf.float32 value
      longitude = ...  # A tf.float32 value

      # In our example we just return our lat_int, long_int features.
      # The dictionary of a complete program would probably have more keys.
      return { "latitude": latitude, "longitude": longitude, ...}, labels

  # As can be see from the map, we want to split the latitude range
  # [33.641336, 33.887157] into 100 buckets. To do this we use np.linspace
  # to get a list of 99 numbers between min and max of this range.
  # Using this list we can bucketize latitude into 100 buckets.
  latitude_buckets = list(np.linspace(33.641336, 33.887157, 99))
  latitude_fc = tf.feature_column.bucketized_column(
      tf.feature_column.numeric_column('latitude'),
      latitude_buckets)

  # Do the same bucketization for longitude as done for latitude.
  longitude_buckets = list(np.linspace(-84.558798, -84.287259, 99))
  longitude_fc = tf.feature_column.bucketized_column(
      tf.feature_column.numeric_column('longitude'), longitude_buckets)

  # Create a feature cross of fc_longitude x fc_latitude.
  fc_san_francisco_boxed = tf.feature_column.crossed_column(
      keys=[latitude_fc, longitude_fc],
      hash_bucket_size=1000) # No precise rule, maybe 1000 buckets will be good?

  indicator_column = tf.feature_column.indicator_column(categorical_column)

  categorical_column = ... # Create any categorical column

  # Represent the categorical column as an embedding column.
  # This means creating a one-hot vector with one element for each category.
  embedding_column = tf.feature_column.embedding_column(
      categorical_column=categorical_column,
      dimension=dimension_of_embedding_vector)

  class TimeBasedStopHook(tf.train.SessionRunHook):
      def begin(self):
          self.started_at = time.time()

      def after_run(self, run_context, run_values):
          if time.time() - self.started_at >= TRAIN_TIME:
              run_context.request_stop()

  a = array_ops.placeholder(dtypes.float32, shape=[])
  b = array_ops.placeholder(dtypes.float32, shape=[])
  c = array_ops.placeholder(dtypes.float32, shape=[])
  r1 = math_ops.add(a, b)
  r2 = math_ops.multiply(r1, c)

  h = sess.partial_run_setup([r1, r2], [a, b, c])
  res = sess.partial_run(h, r1, feed_dict={a: 1, b: 2})
  res = sess.partial_run(h, r2, feed_dict={c: res})

  from keras.models import Sequential
  from keras.layers import Dense

  model = Sequential()
  model.add(Dense(units=64, activation='relu', input_dim=100))
  model.add(Dense(units=10, activation='softmax'))

  model.compile(loss='categorical_crossentropy',
                optimizer='sgd',
                metrics=['accuracy'])


  # x_train and y_train are Numpy arrays --just like in the Scikit-Learn API.
  model.fit(x_train, y_train, epochs=5, batch_size=32)

  # Evaluate performance:
  loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

  # Generate predictions on new data:
  classes = model.predict(x_test, batch_size=128)