How to migrate from TensorFlow 1.x to TensorFlow 2.x

The introduction of TensorFlow 2. x marks a significant advance in the strong open-source machine learning toolkit TensorFlow. TensorFlow 2.0 introduces significant API changes, making manual code upgrades tedious and error prone. TensorFlow 2. x places an emphasis on user-friendliness and optimizes the development process, whereas TensorFlow 1. x provided a versatile, low-level API.

Upgrading your current TensorFlow 1.x code to TensorFlow 2.x can provide you access to additional capabilities, faster processing, and a more user-friendly programming environment. The main ideas and procedures needed to successfully transition your TensorFlow 1.x code to TensorFlow 2.x will be covered in this post.

• TensorFlow 2.0 introduces significant API changes, making manual code upgrades tedious and error prone.
• The tf_upgrade_v2 utility simplifies the transition by automating most conversions.
• With manual adjustments:
  • Proofreading tf.compat.v1 usages and migrating them to the new tf.* namespace.
  • Handling deprecated modules like tf.flags by using alternatives like absl.flags or packages in tensorflow/addons.

Why convert a TensorFlow 1.x code to TensorFlow 2.x?

The benefits of migrating to TensorFlow 2.x are undeniable:

• Simplified API: The API is streamlined, making it easier to learn and use.
• Eager Execution: Enjoy the flexibility of debugging and inspecting code line-by-line with eager execution.
• Improved Performance: Leverage automatic differentiation and other optimizations for faster training and inference.
• Keras as the Core: Keras is now the foundation for building and training models, offering a unified and user-friendly experience.

How to Convert a TensorFlow 1.x Code to TensorFlow 2.x

Ready to leverage the power and simplicity of TensorFlow 2.x but stuck with your existing 1.x code? Don’t worry upgrading is easier than you think! Here’s a step-by-step guide to get you started.

1. Install TensorFlow 2.x

First things first, equip your toolbox with the latest edition. Use pip or conda to install TensorFlow 2.x. For example , with pip :

pip install tensorflow

2. Run the Upgrade Script

Time to wave the magic wand! TensorFlow provides a handy script to automate much of the conversion.

Find it on the TensorFlow GitHub repository or use the command line :

tf_upgrade_v2 --infile tf1_code.py --outfile tf2_code.py

This script uses TensorFlow 2.x’s updated APIs and syntax to convert your tf1_code.py file to tf2_code.py. It also produces a report that highlights changes and areas that require your attention. You can also use the flag –reportfile report.txt to save the report to a file.

3. Fix the errors and warnings

Not all of the faults and warnings in your code may be resolved by the TensorFlow 2.x upgrade procedure. Some difficulties may need manual code editing, such as changing outdated APIs , eliminating sessions and placeholders, adding tf.function decorators, and so on.

4. Test your code

Once your code has been changed to TensorFlow 2.x , you should test it to ensure that it functions as intended. The same measurements and data as before may be used to compare the outcomes. Additionally , you may use tf.debugging , the TensorFlow 2.x debugger , to examine your code for faults and abnormalities.

Migrating Linear Regression model from TensorFlow 1.x to TensorFlow 2.x

In TensorFlow 1.x, you might have written something like this:

Python3

# TensorFlow 1.x code
import tensorflow as tf
# Define the model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Define the input and output placeholders
x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)
# Define the linear model
linear_model = W * x + b
# Define the loss function
squared_delta = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_delta)
# Define the optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# Create a session and initialize the variables
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
# Train the model
for i in range(1000):
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
# Evaluate the model
print(sess.run([W, b]))
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

In the above code snippet,

• the code defines variable, placeholders, model, loss, optimizer and session manually.
• the code also defines the linear model explicitly with variables for weights and biases.
• the code explicitly runs the training loop, feeding data into the placeholders and calling the ‘train’ operation in a session.
• the code evaluates the model by running the session with the input data and printing the weighs and the loss value.

Manually Converting the Code to TensorFlow 2.x

In TensorFlow 2.x, you can use the high-level Keras API to simplify the code and enable eager execution:

Python3

# TensorFlow 2.x code
import tensorflow as tf
# Define the model using the Keras Sequential API
model = tf.keras.Sequential([
  tf.keras.layers.Dense(units=1, input_shape=[1])
])
# Compile the model with the loss function and optimizer
model.compile(loss='mean_squared_error',
              optimizer=tf.keras.optimizers.SGD(0.01))
# Train the model with the input and output data
model.fit(x=[1,2,3,4], y=[0,-1,-2,-3], epochs=1000)
# Evaluate the model
print(model.get_weights())
print(model.evaluate(x=[1,2,3,4], y=[0,-1,-2,-3]))

Difference Between the TensorFlow 1.x code and TensorFlow 2.x code:

The provided code snippets demonstrate linear regression models implemented using TensorFlow 1.x and TensorFlow 2.x. Here’s a breakdown of the key differences between the two versions:

1. Syntax and Structure:
   • TensorFlow 1.x code involves defining variables, placeholders, model, loss, optimizer, and session manually.
   • TensorFlow 2.x code uses the Keras Sequential API, which offers a higher-level abstraction, simplifying the model creation and training process.
2. Model Definition:
   • TensorFlow 1.x code defines the linear model explicitly with variables for weights (W) and biases (b).
   • TensorFlow 2.x code uses the tf.keras.Sequential API, specifying a single dense layer with one unit and one input shape.
3. Loss and Optimization:
   • In TensorFlow 1.x, the loss function (mean squared error) and optimizer (GradientDescentOptimizer) are defined separately.
   • In TensorFlow 2.x, the loss function and optimizer are defined during model compilation using the compile() method.
4. Training:
   • TensorFlow 1.x code explicitly runs the training loop, feeding data into the placeholders and calling the train operation in a session.
   • TensorFlow 2.x code uses the fit() method directly on the model, providing input data (x and y) and specifying the number of epochs for training.
5. Evaluation:
   • TensorFlow 1.x code evaluates the model by running the session with the input data and printing the weights (W and b) and the loss value.
   • TensorFlow 2.x code uses the get_weights() method to print the model’s weights and calls evaluate() to compute the loss on the provided input data.

In summary, TensorFlow 2.x provides a more concise and intuitive way to define, train, and evaluate machine learning models compared to TensorFlow 1.x, especially with the integration of the Keras API.

Converting the code using tf_upgrade_v2 command-line script

In this example , I will demonstrate the tf_upgrade_v2 command-line script for the same code files (simple linear regression) used in example 1. Before running the script I will save the simple linear regression code files named liner.py. Then to directly access the terminal for command-line execution you need to add an exclamation mark (!) before the command in your notebook cell or if you want to run the command through the terminal just write the command as a text string below.

tf_upgrade_v2 --infile tf1_code.py --outfile tf2_code.py

Output file contains the following code:

Python3

# TensorFlow 1.x code
import tensorflow as tf
# Define the model parameters
W = tf.Variable([.3], dtype=tf.float32)
b = tf.Variable([-.3], dtype=tf.float32)
# Define the input and output placeholders
x = tf.compat.v1.placeholder(tf.float32)
y = tf.compat.v1.placeholder(tf.float32)
# Define the linear model
linear_model = W * x + b
# Define the loss function
squared_delta = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_delta)
# Define the optimizer
optimizer = tf.compat.v1.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# Create a session and initialize the variables
sess = tf.compat.v1.Session()
init = tf.compat.v1.global_variables_initializer()
sess.run(init)
# Train the model
for i in range(1000):
  sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
# Evaluate the model
print(sess.run([W, b]))
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

As you can see, the converted code still uses the tf.compat.v1 module, which means it is not fully migrated to TF2. You can run this code in TF2, but you will not be able to use eager execution, gradient tape, or other TF2 features.

You can also refer to “report.txt” file to learn the changes made by the command.

The report.txt file included:

TensorFlow 2.0 Upgrade Script
-----------------------------
Converted 1 files
Detected 0 issues that require attention
--------------------------------------------------------------------------------
================================================================================
Detailed log follows:

================================================================================
--------------------------------------------------------------------------------
Processing file '/content/tf1_code.py'
 outputting to 'tf2_code.py'
--------------------------------------------------------------------------------

7:4: INFO: Renamed 'tf.placeholder' to 'tf.compat.v1.placeholder'
8:4: INFO: Renamed 'tf.placeholder' to 'tf.compat.v1.placeholder'
15:12: INFO: Renamed 'tf.train.GradientDescentOptimizer' to 'tf.compat.v1.train.GradientDescentOptimizer'
18:7: INFO: Renamed 'tf.Session' to 'tf.compat.v1.Session'
19:7: INFO: Renamed 'tf.global_variables_initializer' to 'tf.compat.v1.global_variables_initializer'

Conclusion

Voila! Your model is up to date, enjoying the benefits of TensorFlow 2.x! Remember, the script might not handle everything automatically, so keep an eye out for any remaining 1.x remnants and address them manually. This example is just a taste of the conversion process. With practice and these basic concepts, you’ll be confidently navigating the TensorFlow 2.x world in no time!