Quantum Edge 2025

Quantum Edge: AI ML in the Quantum Era

Week 1: Fundamentals of Python

1. (20 min): Getting Started with Python.

Introduction to the course and Python's role in Data Science.

Setting up the development environment (e.g., Google Colab).

Core Concepts: Variables, data types (int, float, string, boolean), and basic arithmetic operations.

2.  (20 min): Python's Building Blocks.

Control Flow: Conditional statements (if, elif, else).

Repetitive tasks: Looping constructs (for, while).

Practical Exercise: A simple script to check a number's properties.

3.  (20 min): Functions and Data Structures.

Why use functions? Defining and calling functions.

Introduction to Python's fundamental data structures: Lists and Tuples.

List operations: indexing, slicing, and methods.

4.  (20 min): Advanced Data Structures and Libraries.

Exploring Dictionaries and Sets.

Introduction to key Python libraries for data: NumPy for numerical operations and Pandas for data manipulation.

Mini-Project: Load a small CSV file using Pandas and perform a basic data inspection.

Week 2: Introduction to Machine Learning

1.  (20 min): The World of Machine Learning.

What is Machine Learning? From data to predictions.

Types of ML: Supervised vs. Unsupervised Learning.

Key concepts: Training data, testing data, and the role of features and labels.

2.  (20 min): Classical Supervised Learning - Regression.

Introduction to Linear Regression: The goal of fitting a line to data.

Understanding the hypothesis function and cost function.

Practical Exercise: A conceptual walkthrough of a simple regression problem.

3.  (20 min): Classical Supervised Learning - Classification.

Introduction to Classification and its applications.

Focus on Logistic Regression as a fundamental classification algorithm.

The concept of a decision boundary.

4.  (20 min): Evaluating Your Models.

Why model evaluation is crucial.

Key metrics for classification: Accuracy, Precision, and Recall.

Key metrics for regression: Mean Squared Error (MSE).

5.  (20 min): Introduction to Artificial Intelligence (AI)

What is AI? Definition and history.

Difference between AI, Machine Learning (ML), and Deep Learning (DL).

Types of AI: Narrow AI, General AI, Super AI.

Everyday applications of AI (voice assistants, recommendations, self-driving cars).

6.  (20 min): Machine Learning in AI

What is Deep Learning and how it relates to AI.
Basics of Artificial Neural Networks (neurons, layers, weights).
Introduction to Convolutional Neural Networks (CNNs) for image tasks.
Introduction to Recurrent Neural Networks (RNNs) for sequential data.
Applications: image recognition, NLP, speech processing.

Week 3: Machine Learning with Python

1.  (20 min): Data Preprocessing with Scikit-learn.

The machine learning workflow.

Data cleaning and feature scaling.

Splitting data into training and testing sets using train_test_split.

2.  (20 min): Regression Model.

Implementing Linear Regression using Scikit-learn

Training the model and making predictions.

Multiple Linear Regression: Introduction to Multiple Linear Regression as an extension of simple linear regression.

Understanding the regression equation and assumptions (linearity, independence, constant variance and no multicollinearity).

Interpreting regression coefficients in the presence of multiple predictors.

Evaluating the model's performance on the test set.

3.  (20 min): Classification Model.

Implementing Logistic Regression using Scikit-learn.

Training and evaluating the model.

Interpreting the classification report.

4.  (20 min): The K-Nearest Neighbors Algorithm.

Introduction to a simple, intuitive algorithm for both regression and classification.

The concept of "neighbor" and distance metrics.

Hands-on example using Scikit-learn.

5. (20 min): Unsupervised Learning- K-Means Clustering

Week 4: Machine Learning algorithms

1.  (20 min): Ridge Regression (L2 Regularization)

Overfitting in regression models.

Introduction to Ridge Regression and the L2 penalty.

Effect of Ridge: coefficient shrinkage, reduced variance, but no zero coefficients.

Comparison of Ridge vs standard linear regression.

2.  (20 min): Lasso Regression (L1 Regularization)

Introduction to Lasso Regression and the L1 penalty.

Feature selection effect: coefficients shrink to zero.

Strengths and weaknesses of Lasso compared to Ridge.

When to use Ridge, Lasso, or a combination (Elastic Net).

3. (20 min): Decision Trees

Introduction to Decision Trees for classification and regression.

Splitting criteria: Gini Index, Entropy, and Mean Squared Error.

Advantages: simple, interpretable, visual representation.

Limitations: overfitting and sensitivity to data.

4. (20 min): Random Forests

Introduction to ensemble learning and bagging.

Random Forest: building multiple trees and averaging predictions.

Benefits: higher accuracy, robustness, reduced overfitting.

Feature importance in Random Forests.

5. (20 min): Boosting and XGBoost

Concept of Boosting: sequential learning where each new model improves on the previous.

Gradient Boosting basics: error correction and gradient descent.

XGBoost: efficiency, regularization, and why it outperforms standard boosting.

Applications in real-world problems and competitions.

6. (20 min): Support Vector Regression (SVR)

Introduction to Support Vector Regression.

Concept of ε-insensitive margin (the “tube” around predictions).

Role of kernels (linear, polynomial, RBF) in handling non-linear relationships.

Strengths of SVR: effective in high-dimensional, complex data scenarios.

Week 5: Quantum Information - The Basics

1. (20 min): Classical vs. Quantum Computing.

The limitations of classical bits.

Introduction to the quantum bit or "qubit."

The concepts of superposition and entanglement.

2. (20 min): Representing Quantum States.

Vector representation of qubits.

Introduction to the Bloch Sphere as a visual tool for understanding a single qubit state.

3.  (20 min): Introduction to Quantum Gates.

Analogy: Quantum gates are the "logic gates" of quantum computing.

Focus on key single-qubit gates: Pauli-X, Y, and Z gates.

The powerful Hadamard gate for creating superposition.

4.  (20 min): Multiple Qubits and Entanglement.

Introduction to multi-qubit systems.

The power of controlled gates (e.g., CNOT).

Understanding entanglement as a non-classical correlation between qubits.

5.  (20 min): Grover's Search Algorithm.

The concept of unstructured search problems.

How Grover's algorithm provides a quadratic speedup over classical search.

Real-world analogy to find a specific entry in a phonebook.

6.  (20 min): What is Quantum Machine Learning (QML)?

A fusion of quantum computing and machine learning.

Potential advantages of QML: faster processing, new types of models.

Introduction to the different types of QML approaches.

A final exam to recap the course and collection of  feedback for next steps.