Introduction
Python has become the go-to language for aspiring programmers and data enthusiasts worldwide. Whether you’re looking to enter the exciting world of data science, machine learning, or artificial intelligence, TensorFlow 2.0 can be your best friend on this journey. In this guide, we will embark on an adventure to explore the amazing world of TensorFlow 2.0, using Python 3. Our mission is to equip you with the knowledge and skills to become a Python pro, while harnessing the immense power of TensorFlow 2.0.
Chapter 1: The TensorFlow 2.0 Foundation
Before diving into the world of TensorFlow, it’s crucial to understand the basics. TensorFlow is an open-source machine learning framework developed by Google. TensorFlow 2.0 is the second major version, bringing with it exciting improvements. It offers a flexible and user-friendly platform to build, train, and deploy machine learning models.
Let’s get started with the installation of TensorFlow 2.0 in your Python environment. Open your terminal and type:
pip install tensorflowOnce TensorFlow is installed, we can start exploring its capabilities.
Chapter 2: Building Your First Model
In the quest to become a Python pro, it’s important to get hands-on experience. Let’s begin by creating a simple model using TensorFlow 2.0. In this example, we’ll build a basic neural network to classify images of handwritten digits.
import tensorflow as tf
from tensorflow import keras
# Load the MNIST dataset
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# Normalize the data
train_images, test_images = train_images / 255.0, test_images / 255.0
# Build the model
model = keras.models.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])To enable the following instructions: SSE SSE2 SSE3 SSE4.1 SSE4.2 AVX AVX2 AVX_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.2959 - accuracy: 0.9140
Epoch 2/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.1428 - accuracy: 0.9575
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1073 - accuracy: 0.9670
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.0889 - accuracy: 0.9727
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0747 - accuracy: 0.9764
313/313 - 0s - loss: 0.0753 - accuracy: 0.9767 - 346ms/epoch - 1ms/stepThis code defines a neural network model using TensorFlow’s high-level Keras API. It’s a simple example, but it forms the foundation for more complex models.
Chapter 3: Training Your Model
Building a model is only the beginning. To become proficient in Python and TensorFlow, you must know how to train your model. Training involves feeding your model data and adjusting its internal parameters so it can make accurate predictions.
Here’s an example of how to train the model we defined earlier:
# Train the model
model.fit(train_images, train_labels, epochs=5)
# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)Test accuracy: 0.9767000079154968In this code, we use the fit method to train the model on our training data. The number of epochs (5 in this case) determines how many times the model will see the entire dataset. After training, we evaluate the model’s performance on the test data.
Chapter 4: Visualizing Your Model’s Progress
As a Python pro in the making, it’s essential to visualize the results of your model. Visualizations provide insights into how well your model is performing.
We can plot the training and validation accuracy to assess the model’s learning progress:
import matplotlib.pyplot as plt
history = model.fit(train_images, train_labels, epochs=5, validation_data=(test_images, test_labels))
# Plot training & validation accuracy values
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()Epoch 1/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0666 - accuracy: 0.9789 - val_loss: 0.0764 - val_accuracy: 0.9773
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0594 - accuracy: 0.9813 - val_loss: 0.0766 - val_accuracy: 0.9756
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0531 - accuracy: 0.9827 - val_loss: 0.0683 - val_accuracy: 0.9790
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0479 - accuracy: 0.9843 - val_loss: 0.0725 - val_accuracy: 0.9794
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0445 - accuracy: 0.9851 - val_loss: 0.0736 - val_accuracy: 0.9803
This code uses Matplotlib to create a plot that displays the training and validation accuracy over epochs. It’s a vital tool to understand your model’s performance.
Chapter 5: Customizing Your Model
To truly become a pro in Python and TensorFlow, you need to customize your models. TensorFlow offers the flexibility to create complex architectures and add custom layers. Let’s dive into creating a custom layer for our model.
# Create a custom layer
class CustomLayer(tf.keras.layers.Layer):
def __init__(self, units=32):
super(CustomLayer, self).__init__()
self.units = units
def build(self, input_shape):
self.w = self.add_weight(
shape=(input_shape[-1], self.units),
initializer='random_normal',
trainable=True,
)
self.b = self.add_weight(
shape=(self.units,),
initializer='zeros',
trainable=True,
)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
# Add the custom layer to the model
model.add(CustomLayer(64))This code demonstrates how to create a custom layer by subclassing tf.keras.layers.Layer. It gives you full control over the layer’s behavior, including its weights and calculations.
Chapter 6: Saving and Loading Models
Being proficient in Python also involves managing your work efficiently. You can save and load your models in TensorFlow for future use. Here’s how to do it:
# Save the model
model.save('custom_model.h5')
# Load the model
loaded_model = tf.keras.models.load_model('custom_model.h5')
You can save your model’s architecture, weights, and optimizer state in a single file using the .save() method. Later, you can load it using .load_model().
Chapter 7: Exploring Real-World Datasets
Becoming a Python pro means working with real-world datasets. Let’s explore a popular dataset – the Iris dataset. It contains features of different iris flowers, and we’ll use it for classification.
import seaborn as sns
import pandas as pd
# Load the Iris dataset
iris = sns.load_dataset('iris')
# Prepare the data
X = iris.drop('species', axis=1)
y = pd.get_dummies(iris['species'])
# Build and train a model
model = keras.Sequential([
keras.layers.Input(shape=(4,)),
keras.layers.Dense(10, activation='relu'),
keras.layers.Dense(3, activation='softmax')
])
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(X, y, epochs=50)Epoch 1/50
5/5 [==============================] - 0s 0s/step - loss: 3.3960 - accuracy: 0.3333
Epoch 2/50
5/5 [==============================] - 0s 4ms/step - loss: 3.2018 - accuracy: 0.3333
Epoch 3/50
5/5 [==============================] - 0s 0s/step - loss: 3.0066 - accuracy: 0.3333
Epoch 4/50
5/5 [==============================] - 0s 2ms/step - loss: 2.8100 - accuracy: 0.3333
Epoch 5/50
5/5 [==============================] - 0s 2ms/step - loss: 2.6333 - accuracy: 0.3333
Epoch 6/50
5/5 [==============================] - 0s 0s/step - loss: 2.4501 - accuracy: 0.3333
Epoch 7/50
5/5 [==============================] - 0s 4ms/step - loss: 2.2689 - accuracy: 0.3333
Epoch 8/50
5/5 [==============================] - 0s 0s/step - loss: 2.1077 - accuracy: 0.3333
Epoch 9/50
5/5 [==============================] - 0s 0s/step - loss: 1.9537 - accuracy: 0.3333
Epoch 10/50
5/5 [==============================] - 0s 4ms/step - loss: 1.8142 - accuracy: 0.3333
Epoch 11/50
5/5 [==============================] - 0s 0s/step - loss: 1.6913 - accuracy: 0.3333
Epoch 12/50
5/5 [==============================] - 0s 4ms/step - loss: 1.5861 - accuracy: 0.3333
Epoch 13/50
5/5 [==============================] - 0s 0s/step - loss: 1.4996 - accuracy: 0.3333
Epoch 14/50
5/5 [==============================] - 0s 0s/step - loss: 1.4388 - accuracy: 0.3333
Epoch 15/50
5/5 [==============================] - 0s 4ms/step - loss: 1.3785 - accuracy: 0.3333
Epoch 16/50
5/5 [==============================] - 0s 0s/step - loss: 1.3345 - accuracy: 0.3333
Epoch 17/50
5/5 [==============================] - 0s 4ms/step - loss: 1.3008 - accuracy: 0.3267
Epoch 18/50
5/5 [==============================] - 0s 0s/step - loss: 1.2768 - accuracy: 0.2867
Epoch 19/50
5/5 [==============================] - 0s 0s/step - loss: 1.2539 - accuracy: 0.2600
Epoch 20/50
5/5 [==============================] - 0s 0s/step - loss: 1.2355 - accuracy: 0.2333
Epoch 21/50
5/5 [==============================] - 0s 0s/step - loss: 1.2187 - accuracy: 0.1933
Epoch 22/50
5/5 [==============================] - 0s 4ms/step - loss: 1.2025 - accuracy: 0.1667
Epoch 23/50
5/5 [==============================] - 0s 0s/step - loss: 1.1867 - accuracy: 0.1467
Epoch 24/50
5/5 [==============================] - 0s 0s/step - loss: 1.1718 - accuracy: 0.1467
Epoch 25/50
5/5 [==============================] - 0s 0s/step - loss: 1.1570 - accuracy: 0.1467
Epoch 26/50
5/5 [==============================] - 0s 0s/step - loss: 1.1422 - accuracy: 0.1467
Epoch 27/50
5/5 [==============================] - 0s 0s/step - loss: 1.1274 - accuracy: 0.1467
Epoch 28/50
5/5 [==============================] - 0s 0s/step - loss: 1.1131 - accuracy: 0.1467
Epoch 29/50
5/5 [==============================] - 0s 4ms/step - loss: 1.0996 - accuracy: 0.1533
Epoch 30/50
5/5 [==============================] - 0s 0s/step - loss: 1.0853 - accuracy: 0.1600
Epoch 31/50
5/5 [==============================] - 0s 0s/step - loss: 1.0722 - accuracy: 0.1600
Epoch 32/50
5/5 [==============================] - 0s 0s/step - loss: 1.0591 - accuracy: 0.1600
Epoch 33/50
5/5 [==============================] - 0s 0s/step - loss: 1.0458 - accuracy: 0.1600
Epoch 34/50
5/5 [==============================] - 0s 4ms/step - loss: 1.0335 - accuracy: 0.2200
Epoch 35/50
5/5 [==============================] - 0s 1ms/step - loss: 1.0213 - accuracy: 0.2867
Epoch 36/50
5/5 [==============================] - 0s 0s/step - loss: 1.0084 - accuracy: 0.3800
Epoch 37/50
5/5 [==============================] - 0s 0s/step - loss: 0.9964 - accuracy: 0.4333
Epoch 38/50
5/5 [==============================] - 0s 0s/step - loss: 0.9847 - accuracy: 0.4667
Epoch 39/50
5/5 [==============================] - 0s 4ms/step - loss: 0.9731 - accuracy: 0.5000
Epoch 40/50
5/5 [==============================] - 0s 0s/step - loss: 0.9621 - accuracy: 0.5133
Epoch 41/50
5/5 [==============================] - 0s 0s/step - loss: 0.9507 - accuracy: 0.5400
Epoch 42/50
5/5 [==============================] - 0s 0s/step - loss: 0.9401 - accuracy: 0.5467
Epoch 43/50
5/5 [==============================] - 0s 0s/step - loss: 0.9292 - accuracy: 0.5533
Epoch 44/50
5/5 [==============================] - 0s 4ms/step - loss: 0.9186 - accuracy: 0.5600
Epoch 45/50
5/5 [==============================] - 0s 0s/step - loss: 0.9086 - accuracy: 0.5667
Epoch 46/50
5/5 [==============================] - 0s 0s/step - loss: 0.8988 - accuracy: 0.5667
Epoch 47/50
5/5 [==============================] - 0s 0s/step - loss: 0.8884 - accuracy: 0.5667
Epoch 48/50
5/5 [==============================] - 0s 0s/step - loss: 0.8788 - accuracy: 0.5733
Epoch 49/50
5/5 [==============================] - 0s 4ms/step - loss: 0.8700 - accuracy: 0.5667
Epoch 50/50
5/5 [==============================] - 0s 0s/step - loss: 0.8602 - accuracy: 0.5733In this example, we load the Iris dataset using Seaborn and prepare it for training. The model is adapted for multiclass classification using one-hot encoding.
Chapter 8: Your Path to Python Mastery
As we conclude this journey into TensorFlow 2.0 with Python 3, remember that becoming a Python pro is an ongoing process. The world of Python and machine learning is ever-evolving. Continue to explore, learn, and build on what you’ve gained here.
In your quest for Python mastery, you’ll encounter numerous resources and challenges. TensorFlow is your trusty companion, ready to assist you in realizing your goals. Be sure to experiment with different datasets, model architectures, and advanced techniques.
To maintain your progress and explore further, consider reading
books, enrolling in courses, and participating in coding communities. Share your knowledge, collaborate with peers, and never stop coding!
Conclusion
In this comprehensive guide, we’ve delved into the world of TensorFlow 2.0 with Python 3, guiding you from the basics to more advanced concepts. We’ve built and trained models, visualized their progress, created custom layers, saved and loaded models, and explored real-world datasets.
As you continue your journey to become a Python pro, always remember that practice and exploration are key. With the power of TensorFlow 2.0 at your fingertips, you’re well on your way to mastering Python and conquering the world of machine learning and data science.
Also, check out our other playlist Rasa Chatbot, Internet of things, Docker, Python Programming, MQTT, Tech News, ESP-IDF etc.
Become a member of our social family on youtube here.
Stay tuned and Happy Learning. ✌🏻😃
Happy coding! ❤️🔥
