title: How to upgrade TensorFlow script to TensorFlow 2.0
body: <p>I am trying to convert and run a kind of hello world script from a TensorFlow Tutorial in Version 2.0 but cannot get this to work no matter what I try :-(</p>
  <p>I tried using the tf_upgrade_v2 script but it also leaves the python code with an error because it does not seem to be able to replace the usage of the tf.keras.Input() statements (which are tf.placeholder statements in the original code). So, I tried converting to 2.0 manually but that does not seem to work either as I am stuck for while finding no solution to the error shown below.</p>
  <p>I am currently looking at the below code but it generates the below error message. Does someone see a way to fix this?</p>
  <h1>Error Message</h1>
  <hr />
  <pre><code>ValueError                                Traceback (most recent call last)
  &lt;ipython-input-25-27dc7c3cea56&gt; in &lt;module&gt;()
        1 # 4. define a Gradient descent optimizer that will minimize the loss defined in the operation 'cost'
  ----&gt; 2 optimizer = tf.optimizers.SGD(learning_rate=learning_rate, name='SGD').minimize(loss=tf_cost,var_list=[tf_size_factor, tf_price_offset])
  
  2 frames
  /usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/optimizer_v2/optimizer_v2.py in _filter_grads(grads_and_vars)
     1269   if not filtered:
     1270     raise ValueError(&quot;No gradients provided for any variable: %s.&quot; %
  -&gt; 1271                      ([v.name for _, v in grads_and_vars],))
     1272   if vars_with_empty_grads:
     1273     logging.warning(
  
  ValueError: No gradients provided for any variable: ['size_factor:0', 'price_offset:0']. 
  </code></pre>
  <h1>Python Code</h1>
  <pre><code># This is a very simple prediction of house prices based on house size, implemented in TensorFlow.
  #
  
  import tensorflow as tf
  import numpy as np
  import math
  import matplotlib.pyplot as plt
  import matplotlib.animation as animation  # import animation support
  
  # Generating house sizes between 1000 and 3500 (typical sq feet of house)
  num_house = 160
  np.random.seed(42)
  house_size = np.random.randint(low=1000, high=3500, size=num_house)
  
  # Generate house prizes from house size with a random noise added
  np.random.seed(42)
  house_price = house_size * 100.0 + np.random.randint(low=20000, high=70000, size=num_house)
  
  print ('house_size type:', type(house_size))
  print ('house_prize type:', type(house_price))
  
  # Plot generated house and size
  plt.plot(house_size, house_price, &quot;bx&quot;)  # bx = blue x
  plt.ylabel(&quot;Price&quot;)
  plt.xlabel(&quot;Size&quot;)
  plt.show()
  
  # We need to normalize values to prevent under/overflow
  def normalize(array):
      return (array - array.mean()) / array.std()
  
  # define number of training samples, 0.7 = 70%. We can take the first 70% since the values are randomized
  num_train_samples = math.floor(num_house * 0.7)
  
  # defining training data
  train_house_size = np.asarray(house_size[:num_train_samples])
  train_price = np.asarray(house_price[:num_train_samples:])
  
  train_house_size_norm = normalize(train_house_size)
  train_price_norm = normalize(train_price)
  
  # define test data
  test_house_size = np.array(house_size[num_train_samples:])
  test_house_price = np.array(house_price[num_train_samples:])
  
  test_house_size_norm = normalize(test_house_size)
  test_house_price_norm = normalize(test_house_price)
  
  # Set up the TensorFlow placeholders that get updated as we descend down the gradient
  # Replacing tf.placeholder() in TF 1.x with tf.keras.Input() -&gt; https://stackoverflow.com/questions/58986126/replacing-placeholder-for-tensorflow-v2
  tf_house_size = tf.keras.Input(name=&quot;house_size&quot;, shape=(), dtype=tf.dtypes.float32)
  tf_price = tf.keras.Input(name=&quot;price&quot;, shape=(), dtype=tf.dtypes.float32)
  
  print('tf_house_size:', type(tf_house_size))
  print('tf_price:', type(tf_price))
  
  # Define the variables holding the size_factor and price we set during training.
  # We define them to some random values based on the normal destribution.
  tf_size_factor = tf.Variable(np.random.randn(), name=&quot;size_factor&quot;)
  tf_price_offset = tf.Variable(np.random.randn(), name=&quot;price_offset&quot;)
  
  # 2. Define the operations for the predicting values - predicted price = (size_factor * house_size) + price_offset
  # Notice, the use of the tensorflow add and multiply functions. These add the operations to the computation graph,
  # AND the tensorflow methods understand how to deal with Tensors. Therefore, do not try to use numpy or other library methods.
  tf_price_pred = tf.add(tf.multiply(tf_size_factor, tf_house_size), tf_price_offset)
  
  # 3. Define the loss Function (how much error) - Mean squared error
  tf_cost = lambda: tf.reduce_sum(tf.pow(tf_price_pred - tf_price, 2)) / (2 * num_train_samples)
  
  # Optimizer learning rate. The size of the stops down the gradient.
  learning_rate = 0.1
  
  # 4. define a Gradient descent optimizer that will minimize the loss defined in the operation 'cost'
  optimizer = tf.optimizers.SGD(learning_rate=learning_rate, name='SGD').minimize(loss=tf_cost,var_list=[tf_size_factor, tf_price_offset])
  </code></pre>