FROM AI CONCEPTS TO PRACTICAL COMPUTING My Learnings from the Accelerated Intelligence Lab.

AVI DUBEY — Tue, 27 Oct 2026 09:40:26 +0000

Event: Accelerated Intelligence Lab — TFUG Workshop
Date: 24 October 2026 | Venue: United College
Author: AVI DUBEY

1. Introduction:

Moving Beyond Theoretical AI
Artificial intelligence is evolving rapidly, but building effective machine learning applications requires more than understanding algorithms. Developers must also understand computational resources, development environments, model-training workflows, and the tools that make experimentation efficient.
On 24 October 2026, I attended the Accelerated Intelligence Lab workshop associated with the TensorFlow User Group (TFUG) at United College. The experience encouraged me to explore the technical infrastructure behind machine learning and understand how developers can use modern computing platforms to experiment with AI applications.
One of my key areas of practical exploration was Google Colab, a cloud-based notebook environment that allows developers to write and execute Python code without setting up a complete local development environment.
My work in Google Colab provided a practical starting point for understanding notebook-based development, while the workshop's focus on accelerated intelligence motivated me to explore how specialised hardware, machine learning frameworks, and cloud computing fit into the broader AI development workflow.
My practical notebook: https://colab.research.google.com/drive/1tldf4-o0ohMXzjivoprXTXBQFKWbdvkP
In this article, I discuss the technical concepts behind AI acceleration, the role of Google Colab, the differences between CPUs, GPUs, and TPUs, and how these technologies can support future machine learning projects.

2. Understanding AI Acceleration
Machine learning models perform computations to identify patterns in data, learn relationships between features, and generate predictions.
For example, an image-classification model may process thousands of images to learn how to distinguish between different objects or categories. During training, the model repeatedly performs mathematical operations, calculates prediction errors, and updates its internal parameters.
As the dataset and model grow, these computations can become expensive in terms of processing time and memory. AI acceleration uses specialised hardware and software optimisation techniques to execute machine learning workloads more efficiently.

CPU (Central Processing Unit): A general-purpose processor suited to operating-system tasks, program control, data preparation, and a wide variety of computations.
GPU (Graphics Processing Unit): A processor capable of executing many operations in parallel, making it useful for matrix-heavy computations in deep learning.
TPU (Tensor Processing Unit): A specialised processor developed by Google to accelerate machine learning operations, particularly the large matrix computations common in neural networks.
The appropriate choice depends on the model architecture, workload, dataset size, available software, and performance requirements. Selecting the right computing environment can influence development time, training efficiency, and computational cost.

TPUs: Specialised Hardware for Machine Learning
Tensor Processing Units are application-specific integrated circuits designed by Google to accelerate machine learning workloads. Unlike general-purpose CPUs, TPUs are designed around the mathematical operations that dominate many neural networks.
How does a TPU work?
Deep learning models frequently perform matrix multiplication and related tensor operations. These computations appear in neural-network layers, attention mechanisms, and many other machine learning components. TPUs use specialised matrix-processing hardware to perform these operations efficiently.
A simplified execution workflow is:
Input data → Machine learning framework → Computation optimisation → TPU execution → Model output
Input preparation: The dataset is loaded, cleaned, and transformed into a format suitable for the model.
Model definition: A developer defines the neural network using a compatible framework, such as TensorFlow with Keras.
Computation optimisation: For supported TPU workflows, the XLA compiler optimises suitable computations for execution on the accelerator.
Parallel computation: The TPU executes supported tensor and matrix operations using its specialised hardware.
Model training: The model calculates its loss, computes gradients, and updates its parameters. The process repeats across batches of training data.
Why are TPUs useful?
TPUs can be particularly useful for workloads involving large amounts of tensor computation, including deep learning, large neural networks, and distributed model training. However, using a TPU does not automatically make every program faster. Performance depends on how well the workload maps to the hardware, how data is supplied, batch size, and compilation or transfer overhead.
The important lesson is that AI acceleration depends on both the hardware and the way the software uses it.
TPU vs GPU vs CPU: Understanding the Differences
CPUs, GPUs, and TPUs serve different purposes. They should not be treated as interchangeable technologies with identical performance characteristics.
Feature
CPU / GPU
TPU
Primary design
CPU: general-purpose; GPU: highly parallel computing
Specialised machine learning acceleration
Typical strengths
CPU: control and preprocessing; GPU: many deep-learning workloads
Supported tensor- and matrix-heavy workloads
Flexibility
CPU: very high; GPU: high
More specialised
Software considerations
Broad CPU support; GPU support depends on framework and hardware
Requires compatible operations and TPU configuration
Best-use scenario
General development, preprocessing, and many deep-learning workloads
Workloads that map efficiently to TPU execution

A CPU is often sufficient for learning Python, preparing datasets, testing simple algorithms, and running smaller models. A GPU can be useful when training deep-learning models that benefit from parallel processing. A TPU may be attractive for compatible TensorFlow, JAX, or PyTorch workloads that can take advantage of its specialised architecture.
The correct choice should be based on actual measurements rather than assumptions. Developers should run the same model with comparable data, evaluate the results, and measure training time while accounting for initialisation, compilation, data-loading overhead, and accelerator utilisation.
A faster accelerator is valuable only when it improves the performance of the workload being executed.

5. Google Colab:

My Practical Development Environment
Google Colab is a hosted Jupyter Notebook environment that allows users to write Python code, execute individual code cells, document their work, and share notebooks. It offers access to computing resources such as GPUs and TPUs, subject to availability and usage restrictions.
Why use Google Colab?
Browser-based development: Python code can be written and executed directly in a browser.
Notebook-based workflow: Code, explanations, and outputs can be organised into separate cells.
Machine learning support: Common Python libraries can be installed and used for data analysis and model development.
Accelerator access: Compatible notebooks can use available GPU or TPU runtimes.
Google Drive integration: Notebooks and supporting files can be stored and accessed through Google Drive.
Easy collaboration: Notebooks can be shared with other developers for review and experimentation.
My practical experience.

I used Google Colab as part of my practical work associated with the workshop. My notebook is available here:
https://colab.research.google.com/drive/1tldf4-o0ohMXzjivoprXTXBQFKWbdvkP

This provided me with a starting point for working in a cloud-hosted coding environment rather than relying entirely on a locally configured development setup.
An important part of using Colab effectively is understanding the difference between the notebook and its runtime. The notebook contains the code, text, and saved outputs. The runtime is the computing environment in which the code executes. Runtime packages, temporary files, and execution state may not persist when a runtime is reset or terminated.
A reliable workflow should document the necessary dependencies, data sources, configuration, and execution steps so that another developer can reproduce the work.

6. Understanding the Machine Learning Development Workflow
A typical machine learning experiment involves several connected stages.
Define the problem: Identify the task to be solved, such as classification, regression, object detection, or forecasting.
Prepare the data: Collect the dataset, check its quality, handle missing or invalid values, and transform it into the required format.
Select a model: Choose a suitable algorithm or neural-network architecture according to the task and available data.
Configure the environment: Select the required libraries and dependencies. If acceleration is needed, configure an appropriate supported runtime.
Train the model: Pass the training data through the model and update its parameters using a suitable optimisation algorithm.
Evaluate the results: Measure performance using appropriate metrics and test the model on data that was not used for training.
Document and share: Save the notebook, explain the implementation, document dependencies, and share the code and results.
Problem Definition → Dataset Preparation → Model Development → Training → Evaluation → Documentation

*7. A Technical Example: *

Running a Machine Learning Experiment in Colab
To understand how an accelerated machine-learning workflow can be structured, consider a simple image-classification experiment using TensorFlow and Keras. The following is an illustrative example for further experimentation, not a claim that this exact code was executed in my workshop notebook.
Step 1: Import the required libraries

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

print("TensorFlow version:", tf.version)
This imports TensorFlow and Keras, which provide tools for building and training machine learning models.
Step 2: Check the available devices
devices = tf.config.list_physical_devices()

for device in devices:
print(device)
This displays the physical devices visible to TensorFlow. Listing devices alone does not prove that a particular accelerator is being used by a model. A TPU experiment requires additional TPU-specific initialisation and compatible model configuration.
Step 3: Build a simple neural network
model = keras.Sequential([
layers.Input(shape=(28, 28)),
layers.Flatten(),
layers.Dense(128, activation="relu"),
layers.Dense(10)
])

model.summary()
This example defines a simple neural network for inputs with dimensions of 28 × 28 and ten output scores. It contains an input layer, a flattening operation, a dense hidden layer with 128 units, and an output layer with ten scores.
The example illustrates model construction, but it does not train the model or demonstrate TPU acceleration. A complete experiment would load a dataset, preprocess its images and labels, configure a loss function and optimiser, and execute training.
To establish whether an accelerator improves performance, the experiment would need to be executed under comparable CPU, GPU, and TPU configurations where supported hardware is available.

8. GitHub and Version Control:

Making Experiments Reproducible
Machine learning development involves experimentation. Developers frequently modify model architectures, change parameters, update preprocessing logic, and compare different approaches. Without version control, it becomes difficult to determine which changes produced a particular result.
Git is a distributed version-control system, while GitHub provides a platform for hosting Git repositories and collaborating on software projects.
A useful repository for a Colab-based machine-learning experiment might contain:
ai-acceleration-project/
├── README.md
├── notebooks/
│ └── experiment.ipynb
├── src/
│ └── model.py
├── requirements.txt
├── data/
│ └── README.md
└── results/
└── README.md
The README explains the project and setup; notebooks store experiments; src contains reusable code; requirements.txt documents dependencies; and data/results documentation explains where datasets and outputs can be found.
A basic Git workflow is:
git init
git add .
git commit -m "Add initial ML experiment"
After creating an appropriate remote repository on GitHub, the developer can connect the local repository and push committed code. The remote URL and branch should be configured according to the repository's actual setup.
These commands illustrate the standard workflow; they should not be interpreted as evidence that I created or pushed a GitHub repository for this workshop. A well-documented repository makes it easier for teammates, mentors, and recruiters to understand the implementation and reproduce the experiment.

9. Connecting AI Acceleration to Real-World Projects
The concepts explored through AI acceleration have applications beyond isolated notebook experiments. For example, an image-classification system may require a model to process thousands of images during training. An appropriate accelerator can help reduce training time when the model and workload benefit from that hardware.
One potential application is crop-disease and pest-infestation detection, an area I have explored through my AI/ML project preparation. A system of this kind could use images of crop leaves to identify possible disease symptoms.
Collect and label crop images.
Clean the dataset and apply suitable preprocessing.
Select an image-classification architecture.
Train the model using TensorFlow or another compatible framework.
Evaluate performance on held-out images.
Investigate whether GPU or TPU acceleration improves training efficiency.
Integrate the validated model into an application.
For a fair performance comparison, use the same dataset, model configuration, and evaluation procedure wherever possible. Record training time, inference latency, memory usage, and predictive performance separately.
Faster training does not automatically produce a more accurate model. Accuracy depends on data quality, model architecture, training methodology, and evaluation. In agricultural applications, predictions should be validated before being used to recommend treatment. Expert review and reliable agricultural guidance remain important.
This is a potential application of the concepts, rather than a claim that the workshop notebook already implements a crop-disease detection system.

10. Technical Challenges and Lessons for Future Experiments
Hardware availability
Accelerators are not always available in every runtime. Access to GPUs and TPUs can depend on current resource availability and usage limits. A project should avoid assuming that a particular accelerator will always be available.
Data-loading overhead
An accelerator may spend time waiting for data instead of performing computations. Efficient data pipelines, batching, caching where appropriate, and suitable data formats can help reduce this bottleneck.
Software compatibility
Not every library operation or model architecture is equally suitable for every accelerator. Developers should check framework support and resolve compatibility issues before interpreting performance results.
Reproducibility
A notebook that works in one runtime may behave differently after a runtime reset or dependency update. Documenting library versions, data sources, configuration, and execution instructions makes experiments easier to reproduce.
Measuring performance correctly
A valid performance comparison should account for initialisation, compilation, data loading, and actual workload execution time. For a small model, setup overhead may outweigh the benefits of acceleration; larger workloads may benefit more substantially.
These considerations highlight an important engineering principle: selecting hardware is only one part of building an efficient machine-learning system.
11. What I Want to Explore Next
The workshop has encouraged me to continue developing my practical understanding of machine-learning infrastructure.
Build a complete TensorFlow model in Google Colab.
Experiment with a suitable dataset and evaluate the model using appropriate metrics.
Configure and test GPU or TPU execution on a compatible workload.
Compare performance across available computing environments.
Record training time, evaluation results, and resource requirements.
Publish the implementation in a well-documented GitHub repository.
Investigate how the workflow could support a real-world AI/ML project.
These steps would help me move from exploring a cloud-based development environment towards conducting reproducible machine-learning experiments.
12. Conclusion
The Accelerated Intelligence Lab workshop at United College on 24 October 2026 was an opportunity to explore the technologies and workflows that support modern AI development.
My practical work in Google Colab provided a starting point for experimenting with code in a cloud-hosted environment. The broader concepts of AI acceleration also highlighted why understanding CPUs, GPUs, TPUs, machine-learning frameworks, and reproducible development practices is important for aspiring AI/ML engineers.
One of my main takeaways is that building effective AI systems requires more than choosing a model. It also requires understanding the computational environment, managing data efficiently, evaluating results carefully, and documenting the development process.
I look forward to extending my practical experiments, exploring accelerator-backed model training, and applying these concepts to meaningful AI/ML projects.
The goal is not simply to run machine-learning code, but to understand how it works, measure its performance, and build systems that can be reproduced and improved.
References and Further Reading
Google Colab — Official documentation: https://developers.google.com/colab
TensorFlow — Using TPUs with TensorFlow: https://www.tensorflow.org/guide/tpu
Google Cloud TPU: https://cloud.google.com/tpu
Google Colab FAQ: https://research.google.com/colaboratory/faq.html

DEV Community: AVI DUBEY

FROM AI CONCEPTS TO PRACTICAL COMPUTING My Learnings from the Accelerated Intelligence Lab.