Hands-on AI Development Workshop
Audience: AI Development Workshop is a hands-on curriculum for full stack software engineers who have no background of AI/ML tools but are well versed in software development. The curriculum includes basic theory needed for each module followed by graded coding examples in each module starting with the simplest to intermediate level. Use Python as the language of expression and VSCode as the AI powered IDE.
- More than two thirds of time will be spent on development work and assignments.
- All assignments will be done under the mentorship & guidance of the instructor and the teaching assistants.
- This is a 10 week course that would meet 2 hours each for four times a week.
- The teaching assistants will be assigned for each student to ensure sufficient guidance is available.
Course Schedule:
The instructor led sessions will be conducted two evenings per week and at least one session will be for hands-on office hours with the teaching assistants.
Tuesdays and Thursdays: This is a 10 week course that would meet 2 hours each for four times a week.
Mondays and Wednesdays: The teaching assistants will be assigned for each student to ensure sufficient guidance is available.
General Teaching Approach:
- Interactive Sessions: Encourage questions and discussions.
- Hands-on Focus: Theory should be just enough to understand the "why" before diving into the "how."
- Relate to Full-Stack: Continuously draw parallels to concepts they already know (APIs, data formats, microservices for agent communication, etc.).
- Manage Expectations: AI/ML is vast. This is an introduction to get you started and comfortable with key tools and concepts.
- Troubleshooting: Be prepared for environment setup issues, API key problems, model download times.
- Further Learning: Provide resources for deeper dives into each topic.
This curriculum should provide a solid foundation and help the students to explore further and become confident AI Developers.
Prerequisites: Intermediate Python skills, familiarity with APIs, data handling (JSON, basic data structures).
Tools & Environment:
- Python 3.8+
- VS Code with Python extension (Cascade)
- Jupyter Notebooks
- Standard libraries: requests, numpy, pandas, scikit-learn
- AI-specific libraries: openai, anthropic, google-generativeai, ollama, langchain, llama-index, sentence-transformers, faiss-cpu (or chromadb), transformers, datasets, peft, bitsandbytes (for finetuning)
- Access to cloud LLM APIs (OpenAI, Anthropic, Google Gemini - provide API keys or guide setup)
- Ollama installed locally.
Course content:
- What is AI? What is Machine Learning (ML)? What is Deep Learning (DL)?
- Types of ML: Supervised (Classification, Regression), Unsupervised (Clustering, Dimensionality Reduction), Reinforcement Learning (brief overview).
- Key Terminology: Features, Labels, Training Data, Test Data, Validation Data, Model, Algorithm, Inference, Overfitting, Underfitting.
- Basic Evaluation Metrics: Accuracy, Precision, Recall, F1-score (for classification), MSE/MAE (for regression).
- The ML Workflow: Data Collection -> Data Preprocessing -> Model Training -> Model Evaluation -> Deployment -> Monitoring.
- Predictive AI Recap: Focus on practical applications – what business problems can it solve? (e.g., fraud detection, customer churn, sales forecasting). Mention common model types at a high level (Decision Trees, Random Forests, Gradient Boosting, Neural Networks - no deep dive).
- Generative AI (GenAI): What is it? How does it differ from predictive AI?
- Types of GenAI: Text (LLMs), Images (GANs, Diffusion Models), Audio, Code.
- Common Use Cases: Content creation, chatbots, code generation, summarization, translation, synthetic data generation.
- Key Tools/Platforms: Hugging Face (as a hub for models & datasets), specific model providers (OpenAI, Anthropic, Google).
- What are Large Language Models (LLMs)? Transformer architecture (high-level overview: attention mechanism).
- Key Concepts: Prompts, Context Window, Tokens, Temperature, Top-p, Top-k.
- Pre-training vs. Fine-tuning (brief introduction, more in Module 5).
- Cloud-hosted LLMs:
- Providers: OpenAI (GPT series), Anthropic (Claude series), Google (Gemini).
- Access via APIs, benefits (scale, latest models), considerations (cost, data privacy).
- Locally-hosted LLMs with Ollama:
- What is Ollama? Benefits (privacy, offline, cost control, experimentation).
- Running models like Llama, Mistral, etc.
- Hardware considerations (RAM, VRAM).
- Limitations of LLMs: Knowledge cut-offs, hallucinations, lack of access to private/real-time data.
- What is RAG? How does it address LLM limitations?
- Key Components of a RAG Pipeline:
- Data Loading & Chunking: Strategies for breaking down documents.
- Embedding Models: Converting text to dense vector representations (e.g., Sentence-Transformers).
- Vector Stores/Databases: Storing and efficiently querying embeddings (e.g., FAISS, ChromaDB, Pinecone, Weaviate).
- Retriever: Finding relevant chunks based on user query.
- LLM for Synthesis: Combining retrieved context with the query to generate an answer.
- CAG (Context Augmented Generation) as a broader term.
- Theory:
- Why finetune? (Domain adaptation, style adaptation, improving performance on specific tasks when RAG isn't enough or for specific behaviors).
- Difference from pre-training. Difference from prompting/RAG.
- Data Preparation for Finetuning: Instruction-following datasets (e.g., prompt-completion pairs). JSONL format.
- Full Finetuning vs. Parameter-Efficient Fine-Tuning (PEFT):
- LoRA (Low-Rank Adaptation) & QLoRA: Concept and benefits (reduced computational cost, smaller adapter weights).
- Platforms/Tools for Finetuning: Hugging Face transformers (Trainer API), cloud provider APIs (OpenAI, Google Vertex AI), specialized services.
- What is an AI Agent? Beyond simple input-output.
- Core Components of an Agent:
- LLM as the "brain" or reasoning engine.
- Tools/Functions: Allowing the LLM to interact with the external world (APIs, databases, code execution).
- Planning: Breaking down complex tasks into steps (e.g., ReAct - Reason + Act, Chain of Thought).
- Memory: Short-term (context window), Long-term (often using RAG or vector stores).
- Single-Agent vs. Multi-Agent Systems (MAS).
- Frameworks: LangChain Agents, LlamaIndex Agents, AutoGen, CrewAI (briefly introduce).
