Tensorflow Python Tutorial – Complete Guide

Welcome to our tutorial on Tensorflow in Python. In this tutorial, we will be diving into a fascinating data science tool known as Tensorflow, and we’ll do so using the Python programming language. This tutorial is your roadmap to understanding what Tensorflow is, why it’s a valuable skill to learn, and how to get started with Tensorflow using the Python language. Prepare to be engaged as we head into the wonderful world of data analysis and machine learning.

What is Tensorflow?

Tensorflow is a free, open-source library created by Google. It’s designed for creating and training machine learning models, and it’s largely responsible for making machine learning accessible to the common developer.

Tensorflow is primarily used to develop artificial intelligence and machine learning applications. Ranging from image recognition to natural language processing and beyond, Tensorflow has a myriad of applications across various sectors, including health, finance, and gaming. For example, game developers might use Tensorflow to create a learning AI opponent, teaching it to play better over time.

Learning Tensorflow in Python is advantageous for several reasons. Firstly, Tensorflow provides abstraction to complex mathematical concepts, simplifying the process of creating machine learning models. Secondly, Python is a flexible and user-friendly language, making it a great choice for beginners and experienced coders alike.

But most importantly, mastering Tensorflow in Python equips you with skills that are in high demand in today’s tech-driven world. With these skills, you can analyze large data sets, make predictions, create intelligent systems, and more. The possibilities are endless and exciting!

CTA Small Image

Getting Started With Tensorflow in Python

To start using Tensorflow in Python, the first thing we need to do is install the tensorflow library. We do this with pip, python’s package installer.

pip install tensorflow

Once installed, we can then import Tensorflow into our Python script as follows:

import tensorflow as tf

Creating Tensors

Tensors are multi-dimensional arrays with an identical type (i.e., int32, float32, etc.). We can create tensors in Tensorflow like this:

# Create a constant tensor
constant_tensor = tf.constant([1, 2, 3, 4])

Above, we created a constant, 1-dimensional tensor. Tensorflow also provides methods for creating 2D tensors or matrices:

# Create a 2x2 constant tensor
matrix_tensor = tf.constant([[1, 2], [3, 4]])

There are several other tensor types you can create, such as variable tensors, which can change their value over time.

Manipulating Tensors

Tensorflow provides several operations we can use to manipulate our tensors, like addition, subtraction, and multiplication:

A = tf.constant([10, 20, 30, 40])
B = tf.constant([1, 2, 3, 4])

C = tf.add(A, B)


Building a Simple Neural Network

Now, let’s construct a simple neural network model. We’ll make a Sequential model with two Dense layers. A Sequential model is appropriate for a plain stack of layers where each layer has exactly one input tensor and one output tensor. A Dense layer is the regular deeply connected neural network layer. It’s most common and frequently used.

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

# define the model
model = Sequential()
model.add(Dense(10, activation='relu', input_shape=(8,)))
model.add(Dense(1, activation='sigmoid'))

# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# summary of the model

In the above code block, we built a basic neural network with 2 layers using Tensorflow. The first layer has 10 neurons and uses the ReLU activation function. The second layer has 1 neuron and uses the Sigmoid activation function. The network uses Adam as the optimization algorithm and binary cross-entropy as the loss function.

And there we have it! You’ve made your first steps into the realm of Tensorflow in Python. Remember – the journey of a thousand miles begins with one step. Happy coding!

Training and Evaluating the Model

After building a model, the next step is to train it with dataset and then evaluate its performance. For the purpose of this tutorial, let’s use a dummy dataset. Remember, for real applications, it’s crucial to use a legitimate dataset related to the problem at hand.

import numpy as np

# Dummy dataset
X_train = np.random.random((1000, 8))
y_train = np.random.randint(2, size=(1000, 1))
X_test = np.random.random((200, 8))
y_test = np.random.randint(2, size=(200, 1))

# Train the model
model.fit(X_train, y_train, epochs=5, batch_size=32, verbose=1)

# Evaluate the model
score = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Here, we’ve trained our model on the training dataset, and evaluated it on the testing dataset. We’ve recorded the model’s performance metrics – loss and accuracy – on the test dataset.

Loading and Predicting Images

Tensorflow is commonly used in applications involving image data. Let’s load an image and make a prediction about it using a pre-trained Tensorflow model. We’ll use the Keras API which is included in Tensorflow.

from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions

# Load model
model = VGG16(weights='imagenet', include_top=True)

# Load an example image
img_path = 'example_image.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

# Make a prediction
predictions = model.predict(x)
print('Predicted:', decode_predictions(predictions, top=3)[0])

In the code block, we’re using the VGG16 model, a pre-trained model available in the Keras API. This model has been trained on the ImageNet dataset, and hence is capable of identifying 1000 different types of objects in images.

Saving and Loading Models

After training a model, we may need to save it, to use it later or deploy it in a different system. We can do this in Tensorflow with the following commands:

# Save the model

# Load the model
new_model = tf.keras.models.load_model('my_model.h5')

In just two steps, we’ve saved the model into a file and then loaded it back into a new model object.

And that’s the crux of Tensorflow in Python! From installing the Tensorflow library to saving and loading models, you’ve taken a significant leap in your data science journey with Python. Are you excited to dive deeper? We’re excited to accompany you on your learning journey!

Where to Go Next? Keep Learning!

Embarking on the journey of learning programming and data science is an investment of time that pays exponential dividends in the form of skills, opportunities, and career growth. But to gain these benefits, one must never stop learning. So where do you go next on your Python and Tensorflow journey?

The Python Programming Mini-Degree offered by Zenva is an excellent stepping stone for those looking to deepen their Python expertise. This comprehensive collection of courses covers multiple aspects of Python programming, ranging from the basics to more advanced topics like algorithms, object-oriented programming, game development, and app development. By undertaking this program, you can:

  • Create engaging games and applications
  • Work on real-world projects
  • Gain a solid foundation in Python and expand your skills
  • Forge a path towards a career in various industries
  • Add an impressive portfolio of Python projects to your resume

Our accomplished instructors bring rich industry experience to the table and deliver interactive lessons, quizzes, and coding challenges to reinforce learning. The courses are self-paced and accessible on any device, hence adding no constraints to your learning journey.

We also recommend exploring our broad collection of Python courses to find subjects and specializations that particularly interest you. With diligence and earnest effort, you’re only steps away from being a Python expert!


With this tutorial, we trust you’ve gotten an exciting taste of what Python and Tensorflow can offer in the field of machine learning and AI. It’s an often said that data is the new oil, and Python in combination with Tensorflow equips you with the skills needed to navigate this new world order.

If you’re eager to dive further and explore the depths of Python coding while riding the wave of AI and machine learning, don’t hesitate to join our Python Programming Mini-Degree. Zenva is here to help you explore your potential, create opportunities, and carve a thriving career pathway. Let’s shape the future together, one code line at a time!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.