IT Training and Innovator Mentoring

Transform Your Business with Groundbreaking Innovation

Empowering future innovators with expert guidance, advanced IT training, and hands-on mentoring. We help founders turn bold ideas into real-world solutions through personalised support, next-generation technology education, and a clear pathway from concept to successful launch.

Our IT Courses

Comprehensive programs designed by industry experts to give you the skills needed in today's competitive tech landscape.

Web Development

Master modern web technologies including HTML5, CSS3, JavaScript, React, Node.js, and databases to build responsive, dynamic websites and applications. You will learn to create accessible, performant user interfaces with semantic HTML and CSS frameworks (Tailwind, Bootstrap), manage state and side effects with React hooks, develop scalable backend APIs using Express.js, integrate both SQL (PostgreSQL) and NoSQL (MongoDB) databases, and deploy full‑stack applications on cloud platforms (Vercel, Render, AWS). By the end, you will be able to design, build, and ship production‑ready web apps from scratch — handling authentication, real‑time features, and RESTful architecture.

🎯 What you'll build

  • Responsive websites with modern CSS (Grid, Flexbox, animations)
  • Interactive frontend apps with React (state, hooks, routing)
  • RESTful APIs with Node.js + Express
  • Database integration (SQL and NoSQL)
  • Full‑stack capstone: a complete web app deployed live

📌 Prerequisites

  • No prior coding experience? Basic computer literacy
  • Familiarity with file systems and using a text editor
  • Laptop (Windows/Mac/Linux) with internet connection
  • Curiosity and commitment (6 Saturdays, 9am–4pm)

🛠️ Core stack

  • Frontend: HTML5, CSS3, Tailwind CSS, JavaScript (ES6), React
  • Backend: Node.js, Express.js, REST APIs
  • Databases: PostgreSQL, MongoDB, Mongoose
  • Tools: VS Code, Git, GitHub, Postman, Vercel/Render
📅 6 Saturdays — from zero to full‑stack developer
Saturday 1 HTML5 · CSS3 · Responsive design

📄 Topics

  • HTML5 semantics, forms, accessibility, multimedia (audio/video)
  • CSS3: selectors, box model, Flexbox, Grid, animations
  • Responsive design: media queries, mobile‑first approach
  • Intro to Git: version control basics, GitHub
✍️ Hands-on: Build a fully responsive portfolio landing page (mobile, tablet, desktop).

🛠️ Tools

  • VS Code, Live Server
  • Chrome DevTools
  • GitHub Pages deployment
Saturday 2 JavaScript (ES6+) · DOM manipulation

📜 Topics

  • Variables, functions, arrays, objects, loops
  • ES6+: arrow functions, destructuring, spread/rest, modules
  • DOM manipulation, events, forms, async JS (Promises, async/await)
  • Fetch API, consuming REST APIs, local storage
✍️ Hands-on: Build an interactive weather dashboard that fetches live API data and updates the DOM dynamically.

🛠️ Tools

  • Browser dev tools (debugger)
  • ESLint, Prettier
  • Postman (API testing)
Saturday 3 React · Components, state & hooks

⚛️ Topics

  • React concepts: JSX, components (functional & class)
  • Props, state, event handling, conditional rendering
  • Hooks: useState, useEffect, custom hooks
  • React Router (navigation), forms in React
✍️ Hands-on: Create a task manager SPA with add/delete/edit tasks, using localStorage or API mocking.

🛠️ Tools

  • Create React App / Vite
  • React DevTools
  • Axios (HTTP client)
Saturday 4 Backend · Node.js + Express + REST APIs

🟢 Topics

  • Node.js runtime, npm, package.json, event loop
  • Express.js: routes, middleware, error handling
  • Building RESTful APIs (GET, POST, PUT, DELETE)
  • Environment variables, Postman testing, CORS
✍️ Hands-on: Build a REST API for a blog or product catalog with in‑memory storage, then connect React frontend.

🛠️ Tools

  • Node.js, Express
  • Nodemon, dotenv
  • Postman / Insomnia
Saturday 5 Databases · SQL (PostgreSQL) & MongoDB

🗄️ Topics

  • Relational databases: PostgreSQL, SQL queries (JOINs, aggregations)
  • Integrating PostgreSQL with Node.js (pg, Prisma, or Sequelize)
  • NoSQL: MongoDB, Mongoose ODM, document modeling
  • Authentication basics: JWT, bcrypt, user sessions
✍️ Hands-on: Extend the REST API with persistent database (choose SQL or MongoDB) and implement user registration/login with JWT.

🛠️ Tools

  • PostgreSQL (ElephantSQL), MongoDB Atlas
  • Prisma / Mongoose
  • JWT, bcryptjs
Saturday 6 Full‑stack integration · Deployment · Capstone

🚀 Topics

  • Connecting React frontend with Node backend (proxy, CORS, env)
  • Deployment strategies: Vercel (frontend) + Render / Railway (backend + DB)
  • Environment variables, build scripts, monitoring
  • Capstone project presentations & code review
✍️ Capstone: Build a full‑stack application (e.g., e‑commerce, social media dashboard, blog CMS, task manager with users) and deploy live.

🛠️ Tools

  • GitHub Actions (CI basics)
  • Vercel, Render, Netlify
  • MongoDB Atlas cloud
🎓 Capstone project & assessment

📊 Grading breakdown

  • Weekly lab assignments (5) – 25%
  • Responsive website project (Week 2) – 15%
  • React frontend challenge (Week 3) – 15%
  • Backend + Database integration task (Week 5) – 20%
  • Final capstone (full‑stack app + live deployment + 5‑min demo) – 25%

✔️ Certificate of completion + portfolio‑ready GitHub repository.

🌟 Example capstone projects

Option A: E‑commerce store (product listing, cart, checkout, user auth)

Option B: Social media dashboard with posts, likes, comments (MERN stack)

Option C: Personal finance tracker with charts and transaction history

Deliverables: GitHub repo, live URL, 5‑min video walkthrough, code review session.

📚 Resources included:

Official documentation (MDN, React, Node.js), Figma design files, Postman collections, and a private Discord community for 24/7 support.














6 Saturdays | Beginner to Advanced
Learn More

AI & Machine Learning

Dive into artificial intelligence, neural networks, deep learning frameworks, and data science applications for building intelligent systems and predictive models.

🎯 What you'll learn

  • End‑to‑end ML pipeline: data prep, training, evaluation, deployment
  • Supervised & unsupervised learning (regression, classification, clustering)
  • Neural networks: from perceptrons to deep architectures
  • Convolutional networks (CNN) for image analysis
  • Recurrent networks & Transformers for text/time series
  • Model deployment with Gradio / FastAPI

📌 Prerequisites

  • Basic Python (loops, functions, libraries)
  • High‑school level math (algebra, basic calculus)
  • Laptop with 8GB+ RAM (Google Colab provided for GPU)
  • Curiosity about AI – no prior ML experience required

🛠️ Core stack

  • Python: pandas, NumPy, matplotlib, seaborn, scikit‑learn
  • Deep learning: TensorFlow 2.x, Keras, PyTorch
  • NLP: NLTK, spaCy, Hugging Face Transformers
  • MLOps: MLflow, Gradio, Hugging Face Spaces
📅 6 Saturdays — from fundamentals to deep learning
Saturday 1 Python for Data Science · ML Foundations

📊 Topics

  • Python review: NumPy, pandas, data visualization (matplotlib, seaborn)
  • Train/test split, cross‑validation, evaluation metrics (accuracy, precision, recall, F1, RMSE)
  • Linear regression, logistic regression, decision trees, random forest
  • Feature engineering, scaling, one‑hot encoding
✍️ Hands-on: Build a predictive model for house prices (regression) and customer churn (classification) with scikit‑learn.

🛠️ Tools

  • Jupyter / Colab
  • pandas, scikit‑learn
  • matplotlib, seaborn
Saturday 2 Neural Networks · Intro to Deep Learning

🧠 Topics

  • Perceptron, activation functions (ReLU, sigmoid, tanh), backpropagation
  • Building a neural network from scratch with NumPy
  • TensorFlow & Keras: sequential API, dense layers, optimizers, loss functions
  • Overfitting: regularization, dropout, early stopping
✍️ Hands-on: Implement a multi‑layer perceptron (MLP) for MNIST digit classification using Keras; compare with classical ML.

🛠️ Tools

  • TensorFlow, Keras
  • Google Colab (GPU)
  • TensorBoard basics
Saturday 3 Computer Vision · Convolutional Neural Networks (CNN)

🖼️ Topics

  • Convolution, pooling, stride, padding, feature maps
  • Classic CNN architectures: LeNet, AlexNet, ResNet (concepts)
  • Data augmentation, transfer learning (VGG16, ResNet50, EfficientNet)
  • Object detection & segmentation overview (YOLO, U‑Net)
✍️ Hands-on: Train a CNN to classify cats vs. dogs; fine‑tune a pre‑trained ResNet on a custom dataset (e.g., flower species).

🛠️ Tools

  • TensorFlow / PyTorch
  • Keras Applications
  • OpenCV basics
Saturday 4 Natural Language Processing (NLP)

📝 Topics

  • Text preprocessing: tokenization, stemming, lemmatization, stopwords
  • Vectorization: Bag‑of‑Words, TF‑IDF, word embeddings (Word2Vec, GloVe)
  • Recurrent Neural Networks (RNN, LSTM, GRU) for sequence data
  • Transformers & attention: BERT, GPT basics (Hugging Face)
✍️ Hands-on: Sentiment analysis on movie reviews using LSTM; fine‑tune a BERT model for text classification with Hugging Face.

🛠️ Tools

  • NLTK, spaCy
  • TensorFlow / PyTorch
  • Hugging Face Transformers
Saturday 5 Unsupervised Learning · Generative AI & Advanced Topics

🎨 Topics

  • Clustering: K‑Means, DBSCAN, hierarchical, PCA / t‑SNE
  • Autoencoders for anomaly detection & dimensionality reduction
  • Generative models: GANs (Generative Adversarial Networks) & VAEs
  • Introduction to Reinforcement Learning (Q‑learning, DQN)
✍️ Hands-on: Build an autoencoder for fraud detection on credit card data; generate synthetic images with a simple GAN (MNIST).

🛠️ Tools

  • scikit‑learn (clustering, PCA)
  • TensorFlow / PyTorch
  • OpenAI Gym (RL basics)
Saturday 6 MLOps, Deployment & Capstone Projects

🚀 Topics

  • Model serialization (pickle, joblib, ONNX)
  • Deploying models with Gradio, Streamlit, FastAPI
  • Introduction to MLflow for experiment tracking
  • Hugging Face Spaces & cloud deployment (AWS/GCP basics)
  • Capstone project showcase (end‑to‑end AI solution)
✍️ Capstone: Choose a domain (vision, NLP, tabular) – build, evaluate, and deploy an interactive web demo (e.g., image classifier, chatbot, price predictor).

🛠️ Tools

  • Gradio / Streamlit
  • Docker (basic)
  • Hugging Face Spaces
🎓 Capstone Project & Assessment

📊 Grading breakdown

  • Weekly coding labs (5) – 25%
  • Classical ML project (Week 1) – 15%
  • Deep learning challenge (Week 2‑3) – 20%
  • NLP / Computer Vision task (Week 4‑5) – 20%
  • Final capstone + live demo – 20%

✔️ Certificate of completion + portfolio of 5+ AI projects on GitHub.

🌟 Example capstone ideas

Computer Vision: Face mask detector, plant disease classifier, real‑time object detector.

NLP: Twitter sentiment bot, text summarizer, question‑answering system.

Tabular: Customer churn predictor with deployment dashboard, sales forecasting.

🛠️ Deploy on Hugging Face Spaces or Streamlit Cloud – shareable link included.

📚 Resources provided:

Interactive Colab notebooks, curated datasets (MNIST, CIFAR‑10, IMDB, Kaggle competitions), weekly office hours, and private Slack community.














6 Saturdays | Intermediate to Advanced
Learn More

Artificial General Intelligence

Explore the frontiers of AGI research, cognitive architectures, and the future of human-level machine intelligence. Understand the theoretical foundations and practical approaches to creating general AI systems.

🎯 What you will learn

  • Key differences between narrow AI and AGI
  • Classical & modern cognitive architectures (ACT‑R, Soar, CLARION)
  • Neural‑symbolic methods: integrating deep learning with logic
  • Meta‑learning, few‑shot learning, and open‑world adaptation
  • Reward modeling, intrinsic motivation, and curiosity‑driven agents
  • Ethical frameworks, value alignment, and AGI safety research

📌 Prerequisites

  • Solid understanding of machine learning (neural networks, RL)
  • Proficiency in Python (PyTorch/TensorFlow)
  • Basic knowledge of logic, probability, and cognitive science
  • Curiosity about consciousness and intelligence

🛠️ Frameworks & tools

  • Soar / ACT‑R cognitive architecture shells
  • Neural‑symbolic libraries: DeepProbLog, NSNet, TorchLogic
  • Meta‑learning: MAML, Reptile (learn2learn)
  • OpenAI Gym / MiniGrid (curiosity‑driven agents)
  • Hugging Face (large language models as reasoning tools)
📅 6 Saturdays — From narrow AI to general intelligence
Saturday 1 Foundations of AGI · Cognitive Architectures

🧠 Topics

  • Defining AGI: benchmarks, capabilities, and missing pieces
  • History: from Turing's universal intelligence to modern deep RL
  • Cognitive architectures: ACT‑R (adaptive control of thought), Soar, CLARION
  • Symbolic vs. subsymbolic representations – why both matter
✍️ Hands-on: Implement a simple production‑system agent in Soar (or pySoar) that solves block‑world problems.

🛠️ Tools

  • Soar Suite / ACT‑R environment
  • Jupyter notebooks with symbolic logic
  • Python bindings for cognitive architectures
Saturday 2 Neural‑Symbolic Integration & Reasoning

⚙️ Topics

  • Bridging deep learning and symbolic reasoning
  • Neuro‑symbolic programming: DeepProbLog, Logic Tensor Networks
  • Differentiable reasoning, theorem proving with neural guidance
  • Commonsense reasoning benchmarks (ConceptNet, Winograd schemas)
✍️ Hands-on: Build a neural‑symbolic model for visual question answering that reasons about object relationships.

🛠️ Tools

  • DeepProbLog, PyTorch
  • CLUTRR dataset
  • Neural theorem provers (TacticToe)
Saturday 3 Meta‑Learning · Learning to Learn

🔄 Topics

  • Few‑shot, zero‑shot, and open‑world learning
  • Meta‑learning algorithms: MAML, Reptile, Prototypical Networks
  • Hypernetworks, learned optimizers, and self‑modifying architectures
  • Continual learning and catastrophic forgetting (EWC, progressive nets)
✍️ Hands-on: Implement MAML to learn a new classification task from only 5 examples; extend to a continual learning scenario.

🛠️ Tools

  • learn2learn, higher
  • Omniglot / miniImageNet
  • Avalanche (continual learning)
Saturday 4 Intrinsic Motivation · Curiosity · Open‑ended Learning

🎮 Topics

  • Reinforcement learning for AGI: beyond reward maximization
  • Intrinsic motivation: curiosity, empowerment, novelty seeking
  • World models, imagination, and planning (Dreamer, MuZero)
  • Open‑ended evolution, autotelic agents, and skill discovery
✍️ Hands-on: Train a curiosity‑driven agent in MiniGrid or Montezuma's Revenge using Random Network Distillation (RND).

🛠️ Tools

  • Stable‑Baselines3, MiniGrid
  • Dreamer (world model)
  • PyTorch / JAX
Saturday 5 Alignment, Safety & Value Loading

🛡️ Topics

  • The alignment problem: why AGI goals may misalign with human values
  • Value loading: inverse reinforcement learning, cooperative IRL, reward modeling
  • Scalable oversight, debate, and amplification (IDeA, recursive reward modeling)
  • AI safety benchmarks (MACHIAVELLI, Safety Gym)
  • Constitutional AI and norm learning
✍️ Hands-on: Implement an inverse RL algorithm to infer human preferences from demonstrations, then detect reward misspecification.

🛠️ Tools

  • OpenAI Gym‑Safety, SafeRL
  • Human preference datasets (Comparison)
  • PyTorch, RLLib
Saturday 6 Capstone Symposium · Future of AGI

🌌 Topics

  • Review: integrated AGI architectures (CogPrime, NARS, ANNA)
  • Large language models as cognitive pillars (GPT, Gemini, Claude)
  • Consciousness, embodiment, and the hard problem
  • Roadmaps, timelines, and governance of AGI
  • Student capstone presentations (research paper or prototype)
🎓 Capstone: Either (1) design a cognitive architecture component (e.g., memory system, reasoning module) or (2) write a research‑style position paper on an AGI challenge and present to peers.

🛠️ Tools

  • OpenCog / SingularityNET (optional)
  • LangChain (LLM composition)
  • Notion / Overleaf for papers
🎓 Capstone Project & Assessment

📊 Grading breakdown

  • Weekly labs / code notebooks (5) – 30%
  • Neural‑symbolic or meta‑learning implementation – 20%
  • Alignment/safety experiment write‑up – 20%
  • Final capstone (presentation + report/prototype) – 30%

✔️ Certificate in AGI Foundations · Portfolio of advanced AI research artifacts.

🧩 Example capstone projects

Research track: Survey on intrinsic motivation for open‑ended learning, or a critique of current benchmarks for AGI.

Engineering track: Implement a hybrid memory system (differentiable neural dictionary) + symbolic query interface; or extend a meta‑learning algorithm for continual task adaptation.

Alignment track: Build a reward modeling environment where a simulated agent learns from human preferences; analyze failure modes.

6 Saturdays| Advanced Level
Learn More

Quantum Computing

Learn quantum algorithms, quantum information theory, and practical quantum programming for the next computing revolution. Gain hands-on experience with quantum simulators and understand quantum supremacy.

Module 1: Quantum Foundations & Qiskit Basics
This module introduces the fundamental concepts of quantum computing and how to express them using Qiskit's basic operations.

Theory:
- From Bits to Qubits: Superposition, measurement, and the Bloch sphere.
- Introduction to Quantum Gates: Pauli (X, Y, Z), Hadamard (H), and Phase (S, T) gates.
- Multi-Qubit Systems: The tensor product, entanglement, and the Bell state.

Practical (Hands-on with Qiskit):
Lab 1.1: Your First Quantum Circuit. Create a circuit with a single qubit, apply a Hadamard gate, and measure the result on the qasm_simulator.
Lab 1.2: Creating Entanglement. Build a circuit to create a Bell state using a Hadamard and a CNOT gate. Visualize the resulting statevector.

Key Qiskit Components: QuantumCircuit, QuantumRegister, ClassicalRegister, Aer.get_backend('qasm_simulator') or AerSimulator().

Module 2: Quantum Information Theory & Communication
This module covers how information is processed in a quantum system and explores protocols for secure communication.

Theory:
- The Density Matrix: Representing mixed states and subsystems.
- Quantum Entanglement: EPR pairs and Bell's inequalities. Testing the non-locality of quantum mechanics.
- No-Cloning Theorem & Quantum Teleportation: Teleporting an unknown quantum state using entanglement.
- Quantum Cryptography: The BB84 protocol for secure key distribution.

Practical (Hands-on with Qiskit):
Lab 2.1: Simulating Quantum Teleportation. Implement the teleportation protocol to transfer a qubit state between two qubits in a simulator.
Lab 2.2: Simulating the BB84 Protocol. Write a Qiskit program to simulate the BB84 quantum key distribution steps.

Key Qiskit Components:
- Teleportation: QuantumCircuit with H, CNOT, and measurement gates preceding conditional X and Z gates.
- BB84: Circuits for preparing and measuring qubits in Z- (computational) and X- (Hadamard) bases.

Module 3: Foundational Quantum Algorithms
You’ll implement algorithms that demonstrate a clear quantum advantage for specific, though simple, problems.

Theory:
- Quantum Parallelism & Oracle Functions.
- Deutsch-Jozsa Algorithm: A constant vs. balanced function in one query.
- Bernstein-Vazirani Algorithm: Finding a hidden bitstring with certainty.

Practical (Hands-on with Qiskit):
Lab 3.1: Implementing Deutsch-Jozsa. Define oracle circuits for constant and balanced functions, then run the Deutsch-Jozsa circuit to see it return '0' for constant.
Lab 3.2: Implementing Bernstein-Vazirani. Create an oracle for a secret bitstring and run the algorithm to retrieve it.

Key Qiskit Components:
Quantum Phase Estimation (QPE) is the core subroutine for many algorithms. QuantumCircuit construction with controlled-U gates and inverse QFT.

Module 4: Advanced Algorithms & Quantum Supremacy
After learning the fundamentals, this module explores more complex algorithms that have the potential to solve real-world problems, and concludes with the history and concept of Quantum Supremacy.

Theory:
- Quantum Fourier Transform (QFT): The quantum analog of the discrete Fourier transform, used in many advanced algorithms.
- Grover’s Search Algorithm: Unstructured search with a quadratic speedup.
- Shor’s Factoring Algorithm: Factoring large integers, a threat to classical cryptography.
- Quantum Machine Learning: Introduction to concepts like Quantum Support Vector Machines.

Practical (Hands-on with Qiskit):
Lab 4.1: Building a QFT Circuit. Construct and simulate the QFT on n qubits.
Lab 4.2: Grover's Search. Implement Grover's algorithm to search for a marked item in an unstructured database.
Seminar & Discussion: Quantum Supremacy. Discuss the Google Sycamore experiment and what it means for the field.

Key Qiskit Components:
- QFT class from qiskit.circuit.library.
- Grover's algorithm from qiskit.algorithms (note: qiskit.algorithms has been deprecated and functionality moved to qiskit_algorithms).

Module 5: Near-Term Applications & Hybrid Algorithms (The VQE)
This module covers algorithms designed to run on today’s quantum computers by combining quantum circuits with classical optimization.

Theory:
- Variational Quantum Eigensolver (VQE): Finding the ground state energy of a molecule.
- QAOA (Quantum Approximate Optimization Algorithm): Solving combinatorial optimization problems.

Practical (Hands-on with Qiskit):
Lab 5.1: VQE for Hydrogen Molecule. Build an ansatz circuit, define an observable, and run a VQE simulation to find the molecule's ground state energy.

Key Qiskit Components:
VQE from qiskit_algorithms, EvolvedOperatorAnsatz, SPSA optimizer.

Module 6: Advanced Topics – Error Handling & Real Devices
This module focuses on the practicalities and challenges of running circuits on real quantum hardware.

Theory:
- Noisy Intermediate-Scale Quantum (NISQ) devices.
- Noise and Errors: Decoherence, gate errors, readout errors.
- Error Mitigation Techniques.
- Quantum Error Correction (QEC): The repetition code and an introduction to the surface code, which is crucial for building fault-tolerant quantum computers.

Practical (Hands-on with Qiskit):
Lab 6.1: Simulating Real Device Noise. Load a noise model from an IBM device's calibration data and run a circuit on a FakeBackend to see noisy results.
Project: Run an Algorithm on Real Hardware. Implement a simple algorithm (e.g., Grover's search for 2-3 qubits), submit it to an IBM Quantum real backend, and analyze the results against noiseless and noisy simulations.

Key Qiskit Components: FakeBackend from qiskit.providers.fake_provider, NoiseModel.from_backend(), QuantumInstance.

6 Saturdays | Intermediate to Advanced
Learn More

Data Science

Master data analysis, visualization, statistical modeling, and machine learning techniques. Learn to extract insights from complex datasets using Python, R, SQL, and advanced analytics tools.

🎯 Learning objectives

By the end you will be able to: clean & merge data (SQL/pandas), perform EDA & visualization, run A/B tests & regressions, build ML models (classification/regression/clustering), deploy a mini data app, and communicate insights.

📋 Prerequisites

  • Basic programming (any language) OR high-school algebra
  • Laptop with Anaconda / RStudio / Docker (setup guide provided)
  • Curiosity & analytical mindset

🛠️ Core tools

  • Python: pandas, matplotlib, seaborn, scikit‑learn, XGBoost
  • R: dplyr, ggplot2, tidymodels
  • SQL (joins, window functions), Git & GitHub
  • Tableau, Streamlit, Spark (PySpark introduction)
📅 6 Saturdays — Intensive hands‑on syllabus
Saturday 1 Foundations · SQL + Python/R Data Wrangling

🔍 Topics covered

  • Data science lifecycle (OSEMN) & environment setup (Jupyter, RStudio, VS Code)
  • SQL essentials: SELECT, JOINs, GROUP BY, window functions (ROW_NUMBER, RANK)
  • Pandas (Python) & dplyr (R): dataframes, merging, handling missing values
  • Introduction to Git version control & collaborative notebooks
✍️ Hands-on: Join 3 messy datasets (sales/customers) using SQL & pandas; create a clean master table.

🛠️ Tools & focus

  • PostgreSQL / SQLite
  • pandas, dplyr, tidyr
  • GitHub Classroom
Saturday 2 EDA & Visualization · Descriptive Stats

📊 Topics covered

  • Exploratory Data Analysis (EDA) principles: distributions, outliers, correlations
  • Visualization: matplotlib/seaborn (Python) & ggplot2 (R)
  • Descriptive statistics (mean, median, variance, IQR, skewness)
  • Advanced plotting: heatmaps, pairplots, boxen plots, interactive dashboards with Plotly
✍️ Hands-on: Full EDA report on a real‑world dataset (e.g., NYC Airbnb or FIFA players) + dashboard snippet.

🛠️ Tools & focus

  • seaborn, matplotlib
  • ggplot2, plotly
  • Tableau Public intro
Saturday 3 Statistical Inference & Regression Modeling

📐 Topics covered

  • Hypothesis testing: t-tests, chi‑square, ANOVA, p‑values & confidence intervals
  • A/B testing fundamentals (sample size, practical significance)
  • Linear regression (assumptions, R², residual analysis) & Logistic regression (confusion matrix, ROC/AUC)
  • Regularization (Ridge, Lasso) using scikit‑learn & glmnet (R)
✍️ Hands-on: Run A/B test on website conversion; predict house prices (linear) and customer churn (logistic) with Python & R side‑by‑side.

🛠️ Tools & focus

  • statsmodels, scikit‑learn
  • R: lm(), glm(), broom
  • Jupyter / RMarkdown
Saturday 4 Machine Learning I · Trees & Ensembles

🌲 Topics covered

  • Train/test split, cross‑validation, preprocessing pipelines (scaling, encoding)
  • Decision trees (Gini, entropy, pruning) & Random Forest
  • Gradient Boosting (XGBoost, LightGBM) – bagging vs boosting
  • Hyperparameter tuning with GridSearchCV & RandomizedSearch
✍️ Hands-on: Build a credit default risk predictor using XGBoost; compare with Random Forest; tune using Optuna.

🛠️ Tools & focus

  • scikit‑learn, XGBoost
  • caret (R) / tidymodels
  • Feature engineering lab
Saturday 5 Unsupervised Learning · Intro to Deep Learning & Advanced Analytics

🧠 Topics covered

  • Clustering: K‑Means, hierarchical, DBSCAN & silhouette analysis
  • Dimensionality reduction: PCA & t‑SNE
  • Introduction to neural networks (TensorFlow/Keras): dense layers, activation functions
  • NLP basics: TF‑IDF, bag‑of‑words, sentiment analysis
  • Big data intro: PySpark DataFrames & AWS/GCP basics
✍️ Hands-on: Customer segmentation (e‑commerce) + sentiment classifier on IMDB reviews using simple deep learning.

🛠️ Tools & focus

  • scikit‑learn (clustering, PCA)
  • TensorFlow / Keras
  • PySpark, Databricks community
Saturday 6 MLOps · Ethics · Capstone Presentations

🚀 Topics covered

  • Model serialization (pickle, joblib) & API deployment using FastAPI / Streamlit
  • Introduction to Docker & basic MLOps (monitoring, versioning)
  • Fairness & bias in AI (fairlearn, aequitas), GDPR compliance
  • Capstone project: end‑to‑end from business problem to interactive dashboard
  • Peer review & presentation techniques
✍️ Hands-on: Deploy a churn prediction model as a simple web app; present capstone project (fraud detection / sales forecast / recommendation system).

🛠️ Tools & focus

  • FastAPI, Streamlit, Docker
  • GitHub Actions (CI basics)
  • Tableau / Power BI
🎓 Capstone project & assessment

📝 Grading breakdown

  • Weekly Saturday labs (6) – 25%
  • SQL + EDA take‑home – 15%
  • Regression & hypothesis testing report – 20%
  • Capstone project (code + presentation + 2‑page exec summary) – 40%

✔️ Completion certificate & project portfolio ready for job applications

🚀 Capstone project options

Real‑world focus: Fraud detection, sales forecasting, recommender system, customer churn, or your own industry dataset.

Deliverables: GitHub repository, interactive dashboard (Streamlit/Tableau), recorded 7‑min presentation + live Q&A on Saturday 6.

✅ Integration of SQL, Python/R, statistical tests, and at least one ML model.

📚 Recommended resources (included):

“An Introduction to Statistical Learning” (Python/R labs) · “Python for Data Analysis” (Wes McKinney) · “R for Data Science” (Wickham) · Kaggle datasets · free SQL practice platform.























6 Saturdays | Beginner to Advanced
Learn More

Big Data Quantum Analytics

Combine big data technologies with quantum computing principles to solve complex analytical problems. Learn to process massive datasets using quantum-inspired algorithms and distributed computing frameworks.

🎯 Learning outcomes

  • Ingest & process petabyte‑scale data with Spark/Dask
  • Formulate optimization problems as QUBO/Ising models
  • Implement quantum‑inspired algorithms (e.g., simulated annealing, tensor networks)
  • Build hybrid quantum-classical models for clustering/classification
  • Deploy quantum kernels on simulators and real quantum backends

📌 Prerequisites

  • Intermediate Python (NumPy, pandas) and linear algebra
  • Basic probability & statistics
  • No prior quantum knowledge required – we start from fundamentals
  • Laptop with 8GB+ RAM (cloud environment provided for large simulations)

🛠️ Core stack

  • Big data: Apache Spark, Hadoop HDFS, Kafka
  • Quantum: Qiskit, PennyLane, D‑Wave Ocean, Cirq
  • Quantum‑inspired: simulated annealing, QAOA, VQE
  • Cloud: AWS Braket / IBM Quantum / Google Colab (Quantum simulators)
📅 6 Saturdays — Big Data + Quantum Analytics deep dive
Saturday 1 Quantum basics · Big data engineering at scale

🔷 Topics

  • Qubits, superposition, entanglement – no math overload
  • Big data ecosystem: HDFS, YARN, Spark (RDDs, DataFrames)
  • Quantum vs. classical complexity: when quantum wins
  • Environment setup: PySpark, Qiskit, PennyLane with Jupyter
⚡ Hands-on: Load 100M+ row dataset with PySpark, perform aggregations; run first quantum circuit (Bell state) on simulator.

🛠️ Tools

  • Apache Spark (Databricks community)
  • Qiskit Aer simulator
  • Docker + Jupyter stacks
Saturday 2 Quantum‑inspired optimization · QUBO formulation for Big Data

🔷 Topics

  • Quadratic Unconstrained Binary Optimization (QUBO) & Ising model
  • Reducing real-world problems (clustering, portfolio opt., feature selection) to QUBO
  • Classical quantum‑inspired solvers: simulated annealing, parallel tempering
  • Using D‑Wave’s hybrid solver for large‑scale problems
⚡ Hands-on: Solve a large‑scale graph partitioning problem (millions of nodes) using Spark + QUBO formulation; compare simulated annealing vs. exact solver.

🛠️ Tools

  • D‑Wave Ocean SDK, dimod
  • PyQUBO, OpenJij (simulated annealing)
  • Spark for data preprocessing
Saturday 3 Quantum Machine Learning · Hybrid models for massive datasets

🔷 Topics

  • Variational quantum circuits (VQC) & parameterized quantum layers
  • Quantum kernels (QSVM) & embedding classical data into quantum states
  • Scaling QML: distributed feature extraction with Spark, then quantum classification on subsets
  • Hybrid neural networks (PyTorch + PennyLane) for big data
⚡ Hands-on: Build a hybrid quantum-classical classifier for fraud detection on 5M+ transactions; use PCA + quantum kernel estimation.

🛠️ Tools

  • PennyLane, Qiskit Machine Learning
  • PyTorch / TensorFlow Quantum
  • Spark MLlib for preprocessing
Saturday 4 Quantum annealing at scale · D‑Wave & AWS Braket

🔷 Topics

  • Quantum annealing principles: energy landscape, tunneling
  • Solving large optimisation problems: traffic flow, supply chain, feature selection
  • Integrating D‑Wave Leap hybrid solvers with big data pipelines (Kafka + Spark)
  • Benchmarking quantum vs. classical solvers (Gurobi, CP‑SAT)
⚡ Hands-on: Real‑time route optimisation on streaming taxi data (Kafka) using D‑Wave hybrid solver & compare with classical heuristics.

🛠️ Tools

  • D‑Wave Ocean, Leap cloud
  • AWS Braket (Annealing)
  • Apache Kafka, Spark Streaming
Saturday 5 Tensor networks · Quantum-inspired feature maps at scale

🔷 Topics

  • Matrix product states (MPS) & tensor trains for big data compression
  • Quantum‑inspired kernel methods without quantum hardware
  • Dimensionality reduction for extremely high‑dimensional datasets (genomics, images)
  • Distributed tensor operations with Dask / Spark
⚡ Hands-on: Reduce a terabyte‑scale sparse dataset using tensor‑train SVD; apply quantum‑inspired SVM and compare with PCA.

🛠️ Tools

  • TensorNetwork (Google), quimb
  • Dask, Spark MLLib
  • scikit‑learn (benchmarks)
Saturday 6 MLOps for Quantum Analytics · Capstone projects

🔷 Topics

  • Model serving: hybrid quantum-classical pipelines via FastAPI + Docker
  • Monitoring & retraining quantum models on streaming big data
  • Ethical AI & quantum advantage: when is quantum worth the cost?
  • Capstone presentations: end‑to‑end quantum‑inspired big data solution
⚡ Capstone projects examples: quantum‑inspired anomaly detection (network logs, 10B events), portfolio optimization with live market data, or quantum clustering for customer segmentation.

🛠️ Tools

  • Docker, Kubernetes (basics)
  • AWS Braket / IBM Quantum services
  • Streamlit / Grafana for dashboard
🎓 Capstone & evaluation framework

📊 Assessment breakdown

  • Weekly coding labs (6) – 20%
  • Quantum optimization challenge (Week 2‑3) – 20%
  • Hybrid QML project report – 25%
  • Final capstone: big data + quantum solution + 8‑min presentation – 35%

✔️ Participants receive a verifiable certificate + GitHub portfolio of quantum‑big‑data projects.

🧪 Capstone project tracks

Industry focus: fraud analytics at scale (Spark + QSVM), supply chain optimisation (QUBO + annealing), real‑time recommendation using quantum kernels.

Deliverables: fully reproducible pipeline (data ingestion → quantum‑inspired model → dashboard) hosted on GitHub + short demo video.

🤝 Mentorship from quantum computing researchers & big data engineers.

📚 Core resources provided:

“Quantum Computing for Data Scientists” (online) · “Quantum Machine Learning” (Schuld, Petruccione) · Spark + Qiskit documentation · Access to D‑Wave Leap & IBM Quantum simulators.

6 Saturdays | Advanced Level
Learn More

Why Choose WCC?

We're committed to providing exceptional educational experiences that empower our students to succeed.

Industry Experts

Learn from professionals with real-world experience in top tech companies.

Project-Based Learning

Build a portfolio of real projects that demonstrate your skills to employers.

Career Services

Get personalized career coaching, interview prep, and job placement support.

Community Network

Join an active community of learners, mentors, and industry professionals.

Recognized Certification

Earn industry-recognized certificates that validate your expertise.

Flexible Learning

Study at your own pace with our flexible online and part-time options.

Student Success Stories

Hear from our graduates about how WCC transformed their careers.

"The Web Development course at WCC completely changed my career trajectory. Within 3 months of completing the program, I landed a job as a front-end developer."
SJ

Sarah Johnson

Web Developer at TechSolutions

"The Data Science program gave me the practical skills I needed to transition from business analysis to data science. The instructors were incredibly knowledgeable."
MR

Michael Roberts

Data Scientist at DataCorp

"As a physics graduate, the Quantum Computing course helped me bridge the gap between theory and practical application. Now I'm working on cutting-edge quantum algorithms."
EC

Emma Chen

Quantum Researcher at QTech

Contact Us

Get in touch to learn more about our courses and start your tech journey with WCC.

Get In Touch

177 Robin Hood Way, London SW15 3QG, United Kingdom

info@wcc.co.uk

0208 287 9287

What's Up No: +447412374609

Bank Account

Bank Account for Paymemt

Account Name: Westminster College

Sort Code: 20-10-53

Account No:53128369

Reference: <Your Full Name>

Send Us a Message