Program Fullstack Artificial Intelligence Road MAP

1. Foundations of Programming (Python) Training Course 
2. Data Fundamentals (SQL and Basic Data Manipulation) Training Course 
3. Core Machine Learning Concepts Training Course 
4. Intro to Deep Learning (Light Touch) Training Course 
5. Model Deployment Basics Training Course 
6. Full-Stack Integration and Project Work Training Course

Training timeline will be 30 days (5 days for each training course). 

Phase 1: Foundations of Object-Oriented Programming (OOP) in Python

Prerequisite: None

Timeline: 5 Days

 

Day 1: OOP Fundamentals & Python Essentials

1. Environment Setup & Python Basics
   • Install Python and set up virtual environments (venv or conda).
   • Learn basic syntax: variables, data types, printing, and running scripts.
2. Control Flow & Functions
   • Understand if-else, for/while loops.
   • Define functions with parameters, return values, and discuss variable scope.
3. Introduction to OOP Concepts
   • Overview of objects, classes, attributes, and methods with real-world analogies.
4. Basic Python Data Structures (Optional Review)
   • Explore lists, dictionaries, sets, and tuples.

Proposed Assessment (Day 1):

• Quiz: Short multiple-choice/true-false questions on Python basics and OOP definitions.
• Coding Exercise: Write a function that processes user input (e.g., filters even numbers) and prints the results.

Day 2: Classes & Objects in Python

1. Creating Classes & Instances
   • Define classes using the class keyword and instantiate objects.
2. Instance Attributes & the __init__ Method
   • Use the __init__ method to initialize instance data and distinguish between class and instance attributes.
3. Instance Methods
   • Create methods that use self to access/modify instance attributes.
4. Hands-On Example:
   • Develop a simple BankAccount or Car class that demonstrates unique object states.

Proposed Assessment (Day 2):

• Exercise: Build a Car class with attributes like make, model, year and a start_engine() method.
• Peer Review: Verify that different instances hold unique values.

Day 3: Core OOP Principles & Inheritance

1. OOP Pillars Overview
   • Introduce encapsulation, abstraction, inheritance, and polymorphism.
2. Class Inheritance
   • Create child classes that inherit from a parent class.
3. Method Overriding & super()
   • Override parent methods and use super() to invoke parent functionality.
4. Hands-On Example:
   • Develop a Person class with a child class Student that overrides an introduce() method.

Proposed Assessment (Day 3):

• Coding Task: Create a Person → Student hierarchy demonstrating inheritance and method overriding.
• Mini Quiz: Short questions on OOP principles.

Day 4: Advanced OOP Features & Best Practices

1. Special (Dunder) Methods
   • Implement __str__, __repr__, __len__, __eq__ to enhance object behavior.
2. Modules & Packages
   • Organize classes into separate .py files and packages.
3. Error Handling with Exceptions
   • Use try-except blocks and create custom exceptions.
4. Basic Testing & Documentation
   • Write unit tests (with unittest or pytest) and proper docstrings.

Proposed Assessment (Day 4):

• Refactoring Challenge: Split previous code into modules, add a custom exception, and write a unit test.
• Documentation Review: Ensure each class/method has clear docstrings.

Day 5: OOP Mini Project & Review

1. Mini Project:
   • Build an “Inventory Management System” using multiple classes (e.g., Item as a base class with specialized children like FoodItem).
2. Refactoring & Code Organization
   • Organize code into separate files and ensure consistency.
3. Documentation & Simple Testing
   • Write a README, include unit tests, and document your code.
4. Final Review & Next Steps
   • Summarize key takeaways and prepare for data integration in Phase 2.

Project Output (End of Phase 1):

• A fully functional mini application demonstrating OOP principles with multiple classes, inheritance, error handling, and basic tests.

Phase 2: Data Fundamentals (SQL & Basic Data Manipulation)

Prerequisite: OOP Python

Timeline: 5 Days

 

Day 1: Relational Database Basics

1. Database Concepts:
   • Understand tables, rows, columns, and primary keys.
2. Basic SQL Commands:
   • Learn CREATE TABLE, INSERT, SELECT and simple schema design.
3. SQL Tools & Environments:
   • Use a command-line client or GUI (like DBeaver).

Proposed Assessment (Day 1):

• Quiz: Key SQL command definitions.
• Hands-On: Create a test table in SQLite/PostgreSQL and insert sample data.

Day 2: SQL Queries (Filtering & Aggregation)

1. Filtering Data:
   • Use WHERE, LIKE, BETWEEN, and logical operators.
2. Aggregation & Grouping:
   • Practice GROUP BY, ORDER BY, and aggregate functions (COUNT, SUM).
3. Join Fundamentals:
   • Introduce INNER JOIN and foreign key relationships.

Proposed Assessment (Day 2):

• SQL Exercise: Write queries that filter and aggregate data (e.g., total sales per category).

Day 3: Python Data Handling with Pandas

1. Pandas Setup & Installation:
   • Install Pandas and set up Jupyter Notebooks.
2. Reading & Writing Data:
   • Learn read_csv, read_excel and basic transformations.
3. Data Cleaning:
   • Handle missing values and data type conversions.
4. Filtering & Aggregation in Pandas:
   • Practice boolean indexing and groupby operations.

Proposed Assessment (Day 3):

• Coding Task: Load a CSV file, clean the data, and perform aggregation.
• Mini Quiz: On key Pandas functions and data cleaning steps.

Day 4: SQL & Python Integration

1. Connecting Python to a Database:
   • Use sqlite3 or psycopg2 to execute SQL from Python.
2. Introduction to SQLAlchemy (Optional):
   • Basic ORM concepts and simple queries.
3. Reading Query Results into Pandas:
   • Use pd.read_sql_query() for data manipulation.

Proposed Assessment (Day 4):

• Integration Exercise: Write a script that queries a database, loads results into Pandas, and performs a brief analysis.

Day 5: Data Mini Project & Review

1. Mini Data Pipeline Project:
   • Connect to a sample database, run multiple queries, clean/transform data in Pandas, and export the final dataset.
2. Documentation & Testing:
   • Create a README and document your data pipeline.
3. Review & Next Steps:
   • Recap SQL fundamentals and data cleaning concepts.

Project Output (End of Phase 2):

• An end-to-end data pipeline that pulls data from a database, cleans it with Pandas, and outputs a final dataset ready for analysis or ML.

Phase 3: Core Machine Learning Concepts

Prerequisite: OOP Python, Data Fundamentals

Timeline: 5 Days

 

Day 1: Introduction to Machine Learning

1. ML Overview:
   • Understand supervised vs. unsupervised learning and the ML workflow.
2. Scikit-Learn Setup:
   • Install scikit-learn along with NumPy, Pandas, and Matplotlib.
3. Data Preparation:
   • Practice train-test splits and feature scaling.

Proposed Assessment (Day 1):

• Quiz: ML terminology and data splitting concepts.
• Coding Exercise: Load a dataset, split it, and scale features.

Day 2: Regression & Classification Basics

1. Linear Regression:
   • Learn how to fit a line and interpret regression metrics.
2. Logistic Regression:
   • Understand binary classification and probability predictions.
3. Evaluation Metrics:
   • Explore metrics: MSE, RMSE, R² for regression; accuracy, precision, recall, F1 for classification.

Proposed Assessment (Day 2):

• Coding Task: Train a linear regression model on a small dataset and interpret the R² score.
• Mini Quiz: Differences between regression and classification metrics.

Day 3: Tree-Based Models & Model Tuning

1. Decision Trees & Random Forests:
   • Understand tree structures, feature importance, and ensemble methods.
2. Hyperparameter Tuning:
   • Learn basics of GridSearchCV or RandomizedSearchCV.
3. Cross-Validation:
   • Practice k-fold cross-validation to assess model performance.

Proposed Assessment (Day 3):

• Coding Exercise: Train a Random Forest classifier and perform a simple grid search for hyperparameters.
• Quiz: Key concepts of ensemble methods and model tuning.

Day 4: Unsupervised Learning (Optional Light Touch)

1. Clustering Basics:
   • Learn K-means clustering and the elbow method.
2. Dimensionality Reduction:
   • Introduction to PCA for data visualization.
3. Practical Example:
   • Apply clustering on a small dataset and visualize clusters.

Proposed Assessment (Day 4):

• Coding Task: Execute K-means clustering on a dataset and plot an elbow curve.
• Short Quiz: Define key clustering and PCA concepts.

Day 5: End-to-End ML Pipeline & Review

1. Mini ML Project:
   • Choose a dataset (Iris, Titanic, etc.), clean the data, train a model, and evaluate it.
2. Model Saving:
   • Save your trained model using pickle or joblib.
3. Documentation & Presentation:
   • Write a short README and prepare a brief presentation of your model’s performance.
4. Review & Next Steps:
   • Recap the ML workflow and connect the dots to deep learning.

Project Output (End of Phase 3):

• A complete ML pipeline demonstrating data preparation, model training, evaluation, and model saving.

Phase 4: Intro to Deep Learning

Prerequisite: OOP Python, Data Fundamentals

Timeline: 5 Days

 

Day 1: Neural Network Basics

1. Neural Network Foundations:
   • Learn about neurons, layers, activation functions, and backpropagation.
2. Framework Setup:
   • Choose and install either PyTorch or TensorFlow.
   • Perform simple tensor operations and understand CPU vs. GPU basics.

Proposed Assessment (Day 1):

• Quiz: Definitions of epoch, batch, forward pass, backward pass.
• Hands-On: Perform basic tensor manipulations.

Day 2: Building a Simple Feed-Forward Network

1. Dataset & Data Loading:
   • Use MNIST (or another small dataset) and load data via DataLoader or Keras’ fit method.
2. Defining a Simple Network:
   • Build a basic fully connected network.
3. Training & Validation Loop:
   • Run training loops, calculate loss, and track accuracy.

Proposed Assessment (Day 2):

• Coding Task: Train a feed-forward network on MNIST and log training/validation metrics.
• Mini Quiz: Discuss overfitting versus underfitting and the role of learning rate.

Day 3: Quick CNN Introduction & Hyperparameter Basics

1. CNN Overview:
   • Learn the basics of convolutional layers, pooling, and why CNNs are effective for image tasks.
2. Building a Minimal CNN:
   • Implement a small CNN (1–2 convolution layers) on a dataset.
3. Hyperparameter Tuning:
   • Introduce basic adjustments such as learning rate, batch size, and dropout.

Proposed Assessment (Day 3):

• Coding Task: Build and train a minimal CNN and compare its performance with the feed-forward network.
• Short Quiz: Key terms in CNNs (filters, stride, padding) and hyperparameter trade-offs.

Day 4: Overview of State-of-the-Art (SOTA) Models

1. Generative Adversarial Networks (GANs):
   • Understand the basic idea of a Generator versus Discriminator and their applications.
2. Large Language Models (LLMs):
   • Overview of Transformer architectures (e.g., GPT, BERT) and their real-world uses.
3. Object Detection Models (YOLO):
   • Learn the concept behind real-time object detection.
4. Practical Limitations & Future Learning:
   • Discuss resource needs and avenues for deeper exploration in SOTA models.

Proposed Assessment (Day 4):

• Mini Research Task: Prepare a short note or presentation on one SOTA model (GAN, LLM, or YOLO), focusing on its key idea and application.
• Peer Review: Share insights and discuss limitations.

Day 5: Deep Learning Mini Project & Review

1. Mini Deep Learning Project:
   • Choose a small dataset (image or tabular) and implement either a feed-forward or CNN model.
2. Model Evaluation & Documentation:
   • Summarize performance metrics, save the model, and document improvements.
3. Bridge to Deployment:
   • Prepare your model for integration into an API (to be developed in Phase 5).

Project Output (End of Phase 4):

• A trained deep learning model (feed-forward or CNN) on a chosen dataset, accompanied by documentation and a brief write-up on a state-of-the-art model overview.

Phase 5: Model Deployment Basics

Prerequisite: OOP Python, Data Fundamentals, ML Core (or Deep Learning)

Timeline: 5 Days

 

Day 1: Web Framework Fundamentals

1. REST API Basics:
   • Understand HTTP methods, JSON request/response formats.
2. Python Web Framework Overview:
   • Choose between Flask and FastAPI; set up a minimal “Hello World” endpoint.
3. Local Testing:
   • Test endpoints using Postman or curl.

Proposed Assessment (Day 1):

• Exercise: Create an endpoint /status that returns a JSON message.
• Quiz: Basic HTTP methods and their uses.

Day 2: Serving an ML Model

1. Loading a Saved Model:
   • Load a trained model using pickle, joblib, or framework-specific methods.
2. Creating a /predict Endpoint:
   • Accept JSON input, run model.predict(), and return predictions.
3. Error Handling:
   • Implement basic try/except blocks to handle input errors.

Proposed Assessment (Day 2):

• Coding Task: Build and test a /predict endpoint locally.
• Peer Review: Validate correct prediction output format.

Day 3: Containerization with Docker

1. Docker Basics:
   • Learn Dockerfile structure and key commands.
2. Dockerizing the API:
   • Write a Dockerfile that packages your web API and model.
3. Local Container Testing:
   • Build, run, and test the container locally.

Proposed Assessment (Day 3):

• Exercise: Write a Dockerfile, build the container, and test using docker run.
• Quiz: Docker commands and basic container concepts.

Day 4: Cloud Deployment

1. Deployment Platforms Overview:
   • Compare options like Heroku, AWS, or Render.
2. Deploying the Dockerized App:
   • Use CLI or UI tools to deploy the container.
3. Live Testing & Monitoring:
   • Verify that your deployed API is accessible and functioning correctly.

Proposed Assessment (Day 4):

• Deployment Task: Successfully deploy your API to a chosen cloud platform.
• Validation: Confirm endpoint accessibility using Postman/cURL.

Day 5: Deployment Mini Project & Review

1. End-to-End Deployment Check:
   • Verify the entire pipeline from data input to prediction output.
2. Optional CI/CD Introduction:
   • Briefly explore automated deployment options (e.g., GitHub Actions).
3. Final Review & Next Steps:
   • Summarize the deployment process and discuss potential improvements.

Project Output (End of Phase 5):

• A publicly accessible API serving an ML/DL model, complete with Dockerfile, deployment instructions, and test scripts/documentation.

Phase 6: Full-Stack Integration & Project Work

Prerequisite: OOP Python, Data Fundamentals

Timeline: 5 Days

 

Day 1: Front-End Basics

1. HTML/CSS/JavaScript Refresher:
   • Learn basic HTML structure, CSS styling, and simple JavaScript.
2. Designing a Simple UI:
   • Create input forms and display areas for prediction outputs.
3. Connecting to the API:
   • Use fetch() or Axios to call the deployed /predict endpoint.

Proposed Assessment (Day 1):

• Front-End Exercise: Build a simple web page that sends requests to your local API.
• Quiz: Basic HTML elements and JavaScript fetch syntax.

Day 2: Rapid Prototyping with Streamlit or Gradio (Optional)

1. Why Use Streamlit/Gradio:
   • Understand rapid prototyping benefits and built-in UI components.
2. Setting Up a Minimal App:
   • Install and configure Streamlit or Gradio.
3. Integrating the ML Model:
   • Load your model and display predictions directly in the app.

Proposed Assessment (Day 2):

• Exercise: Build a minimal app using Streamlit/Gradio that calls the model.
• Feedback: Peer or self-review on UI usability.

Day 3: Security & Basic Authentication

1. API Security Basics:
   • Learn about rate limiting, input validation, and API key usage.
2. Implementing Basic Auth:
   • Add simple token-based or credential checks to your API.
3. Data Privacy Best Practices:
   • Discuss logging, data anonymization, and secure handling.

Proposed Assessment (Day 3):

• Security Task: Enhance your API with a basic authentication check.
• Quiz: HTTP status codes and security best practices.

Day 4: Final Full-Stack Integration

1. Connecting Front-End & Backend:
   • Ensure the front-end calls the deployed API.
2. UI/UX Enhancements:
   • Add form validations, loading spinners, and error messages.
3. Optional Features:
   • Consider adding features like saving past predictions.

Proposed Assessment (Day 4):

• Integration Challenge: Host the front-end (via GitHub Pages or Netlify) and test the full data flow.
• Peer Review: Get feedback on the user experience.

 

Day 5: Final Capstone Project & Presentation

1. Capstone Project:
   • Combine all components into an end-to-end AI application (front-end, API, and ML/DL model).
2. Deployment & Documentation:
   • Prepare a detailed README and usage instructions.
3. Presentation:
   • Present the app architecture, demonstrate its functionality, and discuss possible improvements.

Project Output (End of Phase 6):

• A fully integrated Full-Stack AI Application that:
  • Features a user-friendly front-end (HTML/CSS/JS or Streamlit/Gradio).
  • Serves an AI model via a secured and containerized API.
  • Is deployed on a cloud platform with clear documentation.