Introducing AI With Python

Live: Online

Rs 12,500/- PKR

About Course

This course provides an engaging introduction to programming, data science, and AI through Python and PyTorch. Students will explore fundamental programming concepts, visualize data, work on real-world mini projects, and delve into object detection and chatbot development using industry-standard tools. The hands-on nature of the course encourages creativity, experimentation, and collaboration, preparing students for deeper learning in AI and machine learning.

Class 1: Python Basics & Introduction to PyTorch

Variables, data types, and simple operations
Conditional statements (if, else)
Loops (for, while)
Functions (definition, parameters, return)
Lists and basic data structures
Introduction to PyTorch tensors:
- What are tensors?
- Creating and manipulating tensors
- Playground setup: Google Colab or Jupyter Notebooks

Class 2: Practicing with Loops, Functions + Mini Project Prep

Recap and deeper practice with loops and functions
Using PyTorch to generate random tensors and apply basic operations
Mini Project: Simulate a Dice Rolling Game
- Generate random numbers using PyTorch
- Track stats (e.g., average rolls, frequency)
- Create a modular structure using functions
- Collaborative playground creation + code snippets
- Encourage creative extensions (e.g., multi-dice simulation)

Class 3: Data Visualization Basics

Introduction to Matplotlib and Seaborn
Types of graphs: Line plot, Bar chart, Histogram, Pie chart
Plotting datasets (e.g., temperature, test scores)
Aesthetic customization (titles, labels, legends, colors)

Class 4: Real-World Visualizations + Final Project Discussion

Applications:
- COVID-19 daily cases
- Visualizing students' marks or performance trends
- Simulated data for expenses and budgeting
- Brief intro to interactivity using Plotly
Project: Create a Dashboard of Your Day
- Collect 1-day time usage data (sleep, study, screen time, etc.)
- Visualize it with pie charts, bar graphs
- Display insights like “most productive hour”
- Optional: Compare multiple days, integrate basic PyTorch stats

Class 5: Concept of Object Detection + MMDetection Setup

What is object detection? How is it different from classification?
Introduction to MMDetection framework
Using pretrained models (YOLO, Faster R-CNN)
Installation and setup (Colab/Runtime notes)
Loading an image and detecting objects
Visualizing detection results with bounding boxes

Class 6: Real-World Applications of Object Detection

Applications:
- Object detection in security cameras
- Detecting traffic signs or vehicles
- Custom example: Book detection on a shelf
- Minor tweaking with confidence thresholds and image sources
Project: Object Detector for Everyday Items
- Upload your own room image
- Detect known objects
- Present findings and reflection
- Discuss challenges and limitations (e.g., model size, accuracy)

Class 7: Chatbots & Conversational AI

Introduction to Chatbots
Rule-based vs. AI-powered
Using a simple transformer-based model (e.g., DialoGPT or GPT-2)
Build a chatbot that can respond to basic queries
Exploring model inference using Hugging Face Transformers
Limitations and ethical considerations

Class 8: Project + RAG Discussion

Project: Build Your Own Chatbot
- Create a chatbot that can answer FAQ-style questions (e.g., about a topic like space, animals, school subjects)
- Train/infer using predefined context
Intro to RAG (Conceptual)
- Why large models struggle with specific info
- How RAG uses external data sources to improve responses
- Real-world examples (chatbots with document support)

What Will You Learn?

Writing Python programs using variables, conditionals, loops, and functions.
Creating and manipulating tensors with PyTorch for simulations and experiments.
Building simulations like dice games using randomness and modular code.
Visualizing data with Matplotlib and Seaborn, including pie charts and bar graphs.
Understanding object detection and applying pretrained models on real-world images.

Exploring use cases of AI in everyday life—like detecting books or traffic signs.
Building and customizing your own chatbot with transformer models like GPT-2.
Gaining insights into Retrieval-Augmented Generation (RAG) and how AI can access external knowledge to improve responses.
Developing a solid foundation in programming, data visualization, AI applications, and ethical tech usage.

Certifications

“Introducing AI With Python”

September’2025-November’2025

Certified Students 🌟

Here you can view and download your certificates

Recorded Lectures

With lifetime access to our lecture content,
you can revisit and refresh your concepts at your convenience.

Lecture 01: Python Fundamentalss

Introduced Python data types including integers, floats, strings, booleans, and characters.
Explained string operations: slicing, concatenation, repetition, and immutability.
Demonstrated built-in string functions, formatted strings, and multiline strings.
Showed type conversions between int, float, and string with examples.
Covered lists: creation, indexing, traversal, appending, deleting, and nested lists.
Explained tuple operations, immutability, traversal, and copying lists vs tuples.
Introduced problem-solving with loops: separating even/odd numbers from a list.
Demonstrated set operations: remove duplicates, sorting, union, intersection, subtraction, and cross product.

Homework 1

Lecture 02: Problem Solving(Tutorial)

Removeing duplicates from list and sorts it
Finding union of two lists (unique + sorted)
Finding elements in H not in D (H − D)
Generating all ordered pairs (Cartesian product)
Checking if a number is prime
Checking if a number is composite
Returning absolute value of a number
Separateing negatives and positives
Converting a number into its binary representation

Lecture 03: Lists And Comprehension

Filter fruits containing “a”, sort, reverse
List comprehension with length filter
Prime check with list comprehension (non-primes)
Measure execution time with loops vs comprehension
Sorting lists (original vs sorted copy)
Sort words alphabetically, reverse, or by length
Sort words with custom keys (like first 2 letters)
Functions: define, call, pass params, default values
Functions with return values (single & multiple)
Type hints, assertions for type safety
Segregate uppercase and lowercase letters
Process numbers, skip negatives (pass)
Yield vs return (generators vs normal functions)
Row-wise maximum in 2D array

Homework 2

Lecture 04: NumPy

Mixed types in lists, single type in NumPy arrays.
Array creation using np.array(), np.zeros(), np.ones(), np.arange().
Shape with .shape, reshape arrays using .reshape().
Indexing and slicing with [ ] and : operators.
Math operations + - * / ** work elementwise on arrays.
Broadcasting auto-expands smaller arrays to match larger ones.
Discount calculation using vectorized array operations.
Random numbers with np.random.randint(low, high, size).
Statistics with np.sum(), np.mean(), np.max(), np.min().
Boolean masking with conditions and np.where() for filtering/replacing.

Homework 3

Help Session 01: Numpy - Assignment 03(Tutorial)

Task 1: Created a sequence with np.arange, transformed values, reshaped into a 10×10 matrix, and flattened back into 1D.
Task 2: Generated random sensor readings (5×4), subtracted sensor offsets (1D broadcasting), applied scalar subtraction for maintenance cost, and obtained final calibrated readings.
Task 3: Performed statistical analysis with max, mean, row-wise averages, column-wise sums, and accessed a specific reading using indexing.
Task 4: Applied discounts on item prices, converted percentages to decimals, calculated final prices as floats, then cast them into integers using np.int64.
Task 5: Simulated 500 die rolls, counted sixes, reshaped results into blocks, and computed block-wise averages with np.mean.

Lecture 05: Boolean Masking

Boolean masking uses conditions (arr % 2 == 0, arr % 5 == 0) and np.where() to replace values.
Row-wise and column-wise counts with .sum(axis=0/1).
Sorting arrays with np.sort(), reverse using [::-1].
Slicing arrays with [::-1] (reverse), [:3] (first 3), ::2 (even index), 1::2 (odd index).
Views share data with the original array, copies (.copy()) are independent.
Iteration through arrays with nested loops to extract values.
Boolean indexing like arr[arr > 3] filters directly, np.where() gives indexes.
Concatenation with np.concatenate, np.hstack, np.vstack, np.dstack for combining arrays.
Practical example: combining student scores using stacking.
enumerate() modifies arrays/lists in place while looping.
Splitting arrays with np.array_split(arr, n, axis) for horizontal or vertical slicing.

Homework 4

Lecture 06: Dictionaries

Created dictionary with items and prices.
Accessed dictionary values using keys.Checked if key exists in dictionary.
Updated values and added new keys.
Created tuple and unpacked variables.
Looped dictionary and updated values.
Counted keys using len().
Built new dict with comprehension.
Defined function with **kwargs.
Mixed parameters with *args and **kwargs.
Created lambda for cube, add, subtract.
Checked odd and prime with lambda.
Squared numbers using map().
Combined map and filter together.Sorted list by closeness to 10.
Applied lambda on NumPy array.
Created closure multiplier function.
Built doubler and tripler functions.

Homework 5

Lecture 07: Candy Shop Project

Simulated a candy shop with lists, sorting, filtering, counting, and a guessing game.
Created candies and prices lists.
Filtered candies containing letter “a”.
Sorted candies by closeness to price 4.
Separated even and odd prices.
Created candy multiplier using lambda.
Made 2D candy basket and zigzag traverse.
Made “Guess the Candy Price” game.

Lecture 08: Object Oriented Programming

Created Student class with name, age, and grade.
Printed student info using __str__().
Made MyClass with class and instance attributes.
Changed and printed class attribute from instance.
Created Person class that prints all attributes dynamically.
Added extra attributes like dob, grade, address.
Built ShoppingCart with add_item() and show_cart().
Added fruits and displayed full cart.
Defined Point class storing coordinates as tuple.
Displayed point location using display().
Created Car class with color, model, and state flag.
Added subject marks using add_mark().
Calculated total and percentage in show_percentage().
Imported Path, NumPy, and PIL for image handling.
Built DataLoader to load images from folder.
Used matplotlib to show all loaded images.
Loaded and displayed all cat and dog pictures.
Extracted and showed Red, Green, and Blue channels separately using NumPy slicing.

Homework 6

Help Session 02: Image Manipulation (Tutorial)

Loaded the image and converted it into a NumPy array to get its shape.
Extracted and displayed Red, Green, and Green + Blue channel images.
Flipped the image vertically and horizontally using NumPy slicing.
Created a negative image by subtracting pixel values from 255.
Swapped the color channels (Red, Blue, Green) to form a new color combination.
Displayed all results using Matplotlib subplots for visual comparison.

Lecture 09: Image Creation With PyTorch

Explained what PyTorch is and how tensors are similar to NumPy arrays.
Explained how images are represented using 3D tensors (Height × Width × RGB channels), and how changing values in each channel affects the color of a pixel.
Showed how to import and use PyTorch along with matplotlib.pyplot for displaying images, and how tensor functions like torch.zeros, torch.ones, and torch.full help initialize image backgrounds.
Demonstrated how to draw the Danish flag by dividing a tensor into red and white sections using slicing and pixel manipulation.
Creating a Smiley Face Using Tensors.

Homework 7

Help Session 03: Image Creation - Assignment 07 (Tutorial)

Created any country’s flag using RGB tensor slicing and region masking.
Made horizontal rainbow stripes using RGB channels and indexing.
Designed a smiley face with one eye winking using tensor shapes and colors.
Created red, yellow, and green lights inside a traffic signal using RGB tensors.
Created a cube with different colored faces using tensor blocks.
Made the Facebook logo with a blue background and white “f” using PyTorch tensors.
Displayed your name using pixel-style letters formed with tensors.
Created your own unique logo or abstract design using tensor logic.

Lecture 10: Image Processing in Python-Filters

Understanding how images are stored as NumPy arrays (pixels, channels, shapes).
Loading images from a folder using a custom DataLoader class.
Displaying original and processed images side-by-side using Matplotlib.
Converting RGB images to grayscale using weighted pixel values.
Applying Sobel X and Sobel Y filters for edge detection.
Implementing image sharpening using a convolution kernel.
Smoothing images using an average (blurring) filter.
Performing basic operations like invert, threshold, flip horizontally and vertically.
Using scipy.signal.convolve2d() to build custom image filters.
Visualizing the effects of filters to understand their impact on images.

Homework 8

Lecture 11: Edge Detection

Created a blank image using torch.zeros(100,100) to simulate a computer’s view.
Defined a custom function magic_FilterApplier to apply 3×3 filters manually.
Implemented convolution by sliding the filter across the image and summing element-wise products.
Normalized the output to highlight strong responses (edges/features).
Applied a General Sobel filter ([-1 -1 -1; -1 8 -1; -1 -1 -1]) for overall edge detection..
Applied an Average filter → performs blurring / smoothing.
Applied a Sharpen filter → enhances edges and object outlines.
Demonstrated how different filters highlight different image features — foundation of object detection.

Homework 9

Help Session 04: Filters And Edge Detection

Checked how a DataLoader class loads and convert images to RGB arrays.
Defined a Filter class with functions for inversion, thresholding, flipping, smoothing, sharpening, and edge detection.
Implemented visualization function to display original and processed images side by side.
Loaded an image from the folder and performed pixel-wise operations (invert, threshold).
Applied geometric transformations and smoothing/sharpening filters.
Performed edge detection using Sobel X and Sobel Y filters on the grayscale image.

Lecture 12: Data Loading And Neural Networks

Mounted Google Drive and displayed an introductory GIF explaining types of image classification.
Loaded and displayed an example image titled “Types of Image Classification” using Matplotlib.
Loaded the MNIST dataset using datasets.load_dataset("ylecun/mnist").
Visualized multiple samples from the training and test datasets with their digit labels.
Created a function to display pixel intensity values of individual MNIST images.
Visualized one sample image showing pixel intensity distribution (bright = high intensity).
Analyzed and plotted the distribution of digit labels in the MNIST training set.

Homework 10

Lecture 13: Image Classification With NNs

Visualized how neural networks process images using GIF animations and conceptual diagrams.
Demonstrated pixel intensity visualization to understand grayscale image representation.
Showed how data batching works in PyTorch with sample MNIST images from DataLoader.
Explained model architecture and transfer learning using pretrained ResNet-18.
Compared normalized vs unnormalized images before training for better understanding.
Created DataLoaders for training/testing.
Explained neural network basics with visual examples perceptron, CNNs, and convolution operations.
Loaded a pretrained ResNet-18 model, modified its final layer for 10-class MNIST classification, and trained it using Adam optimizer.
Evaluated the trained model on the test set and displayed accuracy results.

Homework 11

Lecture 14:Object Detection And Hugging Face

Loaded and displayed images using Pillow for processing.
Performed resizing, cropping, rotating, flipping, and grayscale conversion.
Adjusted brightness and applies blur filters to images.
Used OWLv2 for zero-shot object detection based on text prompts.
Draws bounding boxes and labels on detected objects in images.
Runs OWLv2 detection on video frames using OpenCV.
Saved annotated videos with detected objects highlighted.
Used DETR (DEtection TRansformer) for COCO-style object detection.
Generated images from text using Stable Diffusion XL.
Discussed abot Hugging Face and its available datasets.

Homework 12