About the course
TensorFlow is an end-to-end open-source platform for machine learning, providing a comprehensive and flexible ecosystem of tools, libraries, and community resources for building and deploying ML-powered applications. This 3-day workshop offers a practical introduction to TensorFlow, focusing on its core components and the essential workflow for building, training, and evaluating neural networks. It is designed for programmers who want to quickly gain hands-on experience with one of the leading deep learning frameworks to begin developing neural network models.
The course begins with a concise overview of machine learning and neural network concepts and their place within the Python ML ecosystem. You will dive into the TensorFlow environment, understanding its key components like Tensors and how to effectively leverage GPUs for accelerated computation. A significant focus is placed on building efficient and scalable data pipelines using the tf.data API to load, preprocess, and prepare data for training from various sources, including common data types like images and text.
A major part of the workshop is dedicated to building and training neural networks using tf.keras, TensorFlow's high-level API. You will learn to construct model architectures by selecting appropriate layers, activation functions, loss functions, and metrics, and master the neural network training process by understanding optimisers, compiling and fitting models, and evaluating their performance. Key practical skills are reinforced through hands-on examples, including building and training neural networks for both image classification (introducing basic CNN concepts) and text classification (using text vectorization).
The course also covers essential aspects of model management, such as saving and loading models, basic techniques for improving prediction quality like regularisation, and an introduction to performance optimization with tf.function and using pretrained models. By the end of this workshop, you will have the fundamental knowledge and practical skills to confidently build, train, and evaluate simple neural networks using TensorFlow.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain the role of TensorFlow in the ML ecosystem and understand its key components (tf.keras, tf.data, tf.function)
- Work with TensorFlow Tensors and effectively use GPUs for accelerated computation.
- Build efficient data pipelines using the tf.data API for various data sources (including images and text basics).
- Build simple neural network architectures using tf.keras.
- Select appropriate layers, activation functions, loss functions, and metrics for neural networks.
- Compile and train neural networks using tf.keras.
- Evaluate trained model performance and make predictions.
- Understand and apply basic techniques to handle overfitting (e.g., regularisation).
- Build simple neural networks for image classification (introducing basic CNNs) and text classification using TensorFlow.
- Save and load trained Keras models.
- Understand basic concepts of model improvement, performance optimization, and transfer learning.
-
This 3-day workshop is designed for anyone who wants to learn the fundamentals of building, training, and evaluating neural networks using the TensorFlow platform. It is ideal for:
Software Developers looking to add deep learning skills to their repertoire.
Data Scientists who are new to the TensorFlow framework.
Engineers and Researchers working on applications involving neural networks.
Anyone with programming experience (preferably Python) interested in a practical, hands-on introduction to deep learning using a leading framework.
-
Participants should have attended our Python Programming course or have equivalent experience, including familiarity with data structures, functions, and ideally basic object-oriented concepts.
In addition:Working knowledge of libraries like NumPy is beneficial.
Prior experience with Machine Learning concepts is helpful but not strictly required, as the course will cover foundational ML and Neural Network overviews concisely.
Basic familiarity with mathematical concepts, including algebra, is helpful.
No prior experience with Deep Learning concepts or TensorFlow is required.
We can customise your training to match your team's experience and needs - with more time and coverage of fundamentals for those new to data science with Python - or a swifter pace for experienced developers and analysts. -
This TensorFlow course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction to ML, Neural Networks, and the TensorFlow Ecosystem
What is Machine Learning? (Concise overview of concepts and applications).
Introduction to Neural Networks: The basic building blocks (neurons, layers, activation functions). Why use neural networks?
Overview of the Python ML Ecosystem: Where TensorFlow fits (brief comparison with libraries like Scikit-learn and frameworks like PyTorch).
What is TensorFlow? Its purpose, key components (tf.keras, tf.data, tf.function, etc.), and how it supports the ML workflow.
Setting up the TensorFlow Environment (Installation process, checking GPU availability and setup).
TensorFlow Basics: Tensors (fundamental data structures, creation, manipulation, data types), Performing basic operations on tensors.
Using TensorFlow with GPUs: Moving tensors and models to the GPU for accelerated computation.
Hands-On Labs: TensorFlow installation verification, creating and manipulating tensors, basic operations, confirming GPU usage.
Data Handling with TensorFlow (tf.data)
Why dedicated data pipelines are important for ML training (especially with large datasets).
Introduction to the tf.data API: Building efficient and scalable input pipelines.
Creating tf.data.Dataset objects from various sources (NumPy arrays, Pandas DataFrames, loading from files like CSVs or images).
Essential tf.data transformations: map (applying functions), filter (selecting elements), batch (creating mini-batches), shuffle (randomising data), cache (caching data), prefetch (optimising performance).
Building robust and performant input pipelines for training.
Loading and preparing data specifically for common tasks: examples for tabular, image, and basic text data.
Hands-On Labs: Building tf.data pipelines from different in-memory sources, applying common transformations like batching and shuffling, creating a pipeline to load data from files.
Building Neural Networks with tf.keras
Introduction to tf.keras: TensorFlow's high-level API for quickly building and prototyping neural networks.
Building Sequential Models (tf.keras.Sequential).
Understanding and using common Layers (tf.keras.layers.Dense for fully connected networks, brief introduction to other layers as building blocks e.g. Conv2D).
Choosing and using Activation Functions (relu, sigmoid, tanh, softmax) and when to use them.
Defining and Understanding Loss Functions (tf.keras.losses): Measuring model error (e.g., CategoricalCrossentropy for multi-class, BinaryCrossentropy for binary classification, MeanSquaredError for regression).
Choosing appropriate Metrics for evaluating model performance (tf.keras.metrics): e.g., accuracy, precision, recall, MeanAbsoluteError.
Hands-On Labs: Building various simple neural network architectures using tf.keras.Sequential and different layers/activations, defining loss functions and metrics.
Training and Evaluating Models with tf.keras
The Neural Network Training Process: Understanding the steps – Forward Pass, Loss Calculation, Backward Pass (brief conceptual mention), Optimiser Step.
Optimisers (tf.keras.optimizers): How optimisers update model weights (Gradient Descent concept). Using common optimisers like Adam, SGD, RMSprop.
Compiling a Keras Model (model.compile): Bringing together the optimizer, loss function, and metrics.
Training a Keras Model (model.fit): Running the training loop, understanding epochs, batch size, and using validation data (validation_data argument).
Evaluating a Keras Model (model.evaluate): Getting performance metrics on test data.
Making Predictions (model.predict): Using the trained model for inference.
Understanding Underfitting and Overfitting in neural networks.
Basic Regularisation techniques to combat overfitting (tf.keras.regularizers.L2, adding tf.keras.layers.Dropout layers - practical application).
Hands-On Labs: Compiling and training simple neural networks, evaluating model performance on test data, making predictions, experimenting with different optimisers and learning rates, adding basic regularisation techniques.
Practical TensorFlow Examples
Putting the pieces together: A guided, end-to-end example demonstrating the full workflow from data loading to prediction using tf.keras and tf.data.
Image Classification Example: Loading and preprocessing a simple image dataset (tf.data for images), building and training a basic Convolutional Neural Network (CNN) for image classification (introducing Conv2D and MaxPool2D layers as common patterns), evaluating, and making predictions.
Text Classification Example: Loading and preprocessing a simple text dataset (tf.data for text), using text vectorization (tf.keras.layers.TextVectorization), building and training a simple network for text classification, evaluating, and making predictions.
(Optional/Alternative) Simple Regression Example: Demonstrating how a single-neuron Keras model with linear activation can perform linear regression, showing the connection between classic ML and simple NNs.
Hands-On Labs: Working through a complete image classification problem in TensorFlow, working through a complete text classification problem in TensorFlow.
Model Management and Improvement
Saving and Loading Keras Models (model.save, tf.keras.models.load_model): Persisting trained models (SavedModel format vs. HDF5).
Hyperparameter Tuning Concepts for Neural Networks: Brief overview of tuning layers, units, learning rates, etc., mentioning Keras Tuner as a tool for automation.
Basic Error Analysis: Briefly looking at examples where the model performs poorly.
Using tf.function for performance optimization: Introduction to graph execution benefits for performance (brief conceptual overview and usage example).
Introduction to Transfer Learning: Using Pretrained Models (conceptually, mentioning tf.keras.applications as a source).
Hands-On Labs: Saving and loading models in different formats, basic manual hyperparameter experimentation, applying tf.function to a simple function.
Wrap-up and Next Steps
Review of key TensorFlow Fundamentals and the ML workflow in TensorFlow.
ML Ethics and Responsible AI (discussion points).
Discussion of next steps: Exploring more advanced architectures (CNNs in depth, RNNs, Transformers), other TensorFlow APIs, and MLOps practices for deployment (referencing the MLOps course).
Q&A
-
Official TensorFlow Website - https://www.tensorflow.org/
TensorFlow API Reference (specific APIs like tf.keras, tf.data, tf.function) - https://www.tensorflow.org/api_docs
Keras Documentation - https://keras.io/ (As tf.keras is the standard high-level API)
NumPy Documentation - https://numpy.org/doc/ (Useful as TensorFlow Tensors are conceptually similar to NumPy arrays).
Trusted by
