Skip to content

pivezhan/Generative-AI

BranchesTags

Repository files navigation

🤖 Generative AI & Large Language Models

Python TensorFlow PyTorch LangChain AWS License

A comprehensive repository documenting my journey through Generative AI, Large Language Models (LLMs), prompt engineering, fine-tuning, RAG (Retrieval-Augmented Generation), and LangChain application development. This repository contains course materials, certifications, hands-on projects, and production-ready implementations.

📋 Table of Contents

🎯 Overview

This repository represents a complete learning pathway for Generative AI and Large Language Models, from fundamentals to advanced deployment strategies. It encompasses:

  • ✅ 3 Major Certification Programs (AWS, DeepLearning.AI, IBM)
  • ✅ 16 Specialized Courses covering AI, ML, Deep Learning, and LLMs
  • ✅ Hands-on Labs & Projects with real-world applications
  • ✅ Production-Ready Code for RAG systems, chatbots, and AI agents
  • ✅ Fine-Tuning Techniques including PEFT, LoRA, and RLHF
  • ✅ LangChain Applications from basics to advanced agents

🎯 Goal: Master the entire spectrum of Generative AI—from foundational concepts to deploying production-grade LLM applications.

📁 Repository Structure

Generative-AI/
├── certificates/                                # All earned certificates (PDF)
│   ├── Generative AI: Elevate your Software Development Career.pdf
│   ├── Generative AI with Large Language Models.pdf
│   ├── Introduction to Cloud Computing.pdf
│   └── Introduction to Software Engineering.pdf
│
├── Generative_AI_LLMs_AWS/                     # AWS + DeepLearning.AI Course
│   ├── week 1/                                  # Transformer architecture & prompting
│   │   ├── Lab_1_summarize_dialogue.ipynb
│   │   ├── lab1.py
│   │   ├── Week-1_Quiz.md
│   │   └── images/
│   ├── week 2/                                  # Fine-tuning & PEFT
│   │   ├── Lab_2_fine_tune_generative_ai_model.ipynb
│   │   ├── lab2.py
│   │   ├── Week-2_Quiz.md
│   │   └── images/
│   ├── week 3/                                  # RLHF & optimization
│   │   ├── Lab_3_fine_tune_model_to_detoxify_summaries.ipynb
│   │   ├── llama.py, llamacode.py, finetunellm.py
│   │   ├── Week-3_Quiz.md
│   │   └── images/
│   └── README.md
│
├── LangChain-for-LLM-Application-Development/  # LangChain Deep Dive
│   ├── L1-Model_prompt_parser.ipynb            # Models, prompts, parsers
│   ├── L2-Memory.ipynb                         # Conversation memory
│   ├── L3-Chains.ipynb                         # Sequential & router chains
│   ├── L4-QnA.ipynb                            # Question answering systems
│   ├── L5-Evaluation.ipynb                     # LLM evaluation metrics
│   ├── L6-Agents.ipynb                         # Autonomous agents
│   ├── rag_from_scratch_*.ipynb                # RAG implementation series
│   ├── images/                                  # Architecture diagrams
│   ├── README.md                                # Detailed course guide
│   └── README_1.md                              # Additional documentation
│
└── Generative_AI_Engineering_IBM/              # IBM 16-Course Specialization
    ├── 01. Introduction to Artificial Intelligence (AI)/
    ├── 02. Generative AI Introduction and Applications/
    ├── 03. Generative AI Prompt Engineering Basics/
    ├── 04. Python for Data Science, AI & Development/
    ├── 05. Developing AI Applications with Python and Flask/
    ├── 06. Building Generative AI-Powered Applications with Python/
    ├── 07. Data Analysis with Python/
    ├── 08. Machine Learning with Python/
    ├── 09. Introduction to Deep Learning & Neural Networks with Keras/
    ├── 10. Generative AI and LLMs Architecture and Data Preparation/
    ├── 11. Gen AI Foundational Models for NLP & Language Understanding/
    ├── 12. Generative AI Language Modeling with Transformers/
    ├── 13. Generative AI Engineering and Fine-Tuning Transformers/
    ├── 14. Generative AI Advance Fine-Tuning for LLMs/
    ├── 15. Fundamentals of AI Agents Using RAG and LangChain/
    └── 16. Project Generative AI Applications with RAG and LangChain/

🎓 Certifications

Completed Certifications

Certificate Issuer Date Link
🏆 Generative AI with Large Language Models AWS + DeepLearning.AI 2024 View Certificate
🏆 LangChain for LLM Application Development DeepLearning.AI 2024 Course Link
🏆 Generative AI: Elevate your Software Development Career IBM 2024 View Certificate
🏆 Introduction to Cloud Computing IBM 2024 View Certificate
🏆 Introduction to Software Engineering IBM 2024 View Certificate

📚 Course Content

1. 🌟 Generative AI with LLMs (AWS + DeepLearning.AI)

Location: Generative_AI_LLMs_AWS/

A comprehensive 3-week course covering the entire lifecycle of Generative AI projects, from foundational concepts to production deployment on AWS.

📖 Course Syllabus

Week 1: Foundations & Pre-training

📁 Location: week 1/

Topics Covered:

  • 🔹 Transformer Architecture

    • Self-attention mechanisms
    • Multi-head attention
    • Encoder-decoder architecture
    • Positional encoding

  • 🔹 Prompting & Prompt Engineering

    • Zero-shot prompting
    • Few-shot prompting
    • Chain-of-thought reasoning
    • Prompt templates and optimization

  • 🔹 Generative AI Project Lifecycle

    • Problem definition & scope
    • Model selection criteria
    • Data requirements
    • Deployment strategies

  • 🔹 Pre-training Large Language Models

    • Training objectives (CLM, MLM)
    • Computational requirements
    • Scaling laws
    • Data preprocessing pipelines

📓 Lab 1: Dialogue Summarization

  • Implement text summarization using pre-trained models
  • Compare zero-shot vs few-shot prompting
  • Evaluate summary quality

Files:

  • Lab_1_summarize_dialogue.ipynb - Jupyter notebook with complete implementation
  • lab1.py - Python script version
  • Week-1_Quiz.md - Assessment questions
  • W1.pdf - Lecture notes
  • images/ - Visual aids and diagrams

Week 2: Fine-Tuning & PEFT

📁 Location: week 2/

Topics Covered:

  • 🔹 Instruction Fine-Tuning

    • Full fine-tuning process
    • Instruction datasets (FLAN, Alpaca)
    • Training strategies
    • Hyperparameter optimization

  • 🔹 Model Evaluation & Benchmarks

    • ROUGE metrics
    • BLEU scores
    • Human evaluation
    • Standard benchmarks (MMLU, HellaSwag, TruthfulQA)

  • 🔹 Parameter Efficient Fine-Tuning (PEFT)

    • Low-Rank Adaptation (LoRA)
    • Prefix tuning
    • Adapter layers
    • Memory and compute advantages

  • 🔹 Soft Prompts & Prompt Tuning

    • Learnable prompt embeddings
    • Comparison with hard prompts
    • Use cases and limitations

📓 Lab 2: Fine-Tune a Generative AI Model

  • Implement full fine-tuning on domain-specific data
  • Apply LoRA for efficient fine-tuning
  • Compare performance and resource usage

Files:

  • Lab_2_fine_tune_generative_ai_model.ipynb - Complete fine-tuning pipeline
  • lab2.py - Python implementation
  • peft-dialogue-summary-checkpoint-from-s3.tar.gz - Pre-trained checkpoint
  • Week-2_Quiz.md - Assessment
  • W2.pdf - Lecture materials
  • data/ - Training datasets
  • images/ - Architecture diagrams

Week 3: RLHF & Optimization

📁 Location: week 3/

Topics Covered:

  • 🔹 Reinforcement Learning from Human Feedback (RLHF)

    • Reward modeling
    • Preference datasets
    • Human-in-the-loop training
    • Alignment techniques

  • 🔹 Proximal Policy Optimization (PPO)

    • Policy gradient methods
    • Value functions
    • KL divergence constraints
    • Training stability

  • 🔹 Model Optimization for Deployment

    • Quantization (INT8, INT4)
    • Distillation
    • Pruning
    • Memory optimization

  • 🔹 LLM Application Architecture

    • RAG (Retrieval-Augmented Generation)
    • Agent systems
    • Tool use and function calling
    • Production deployment patterns

📓 Lab 3: Fine-Tune Model to Detoxify Summaries

  • Implement RLHF pipeline
  • Train reward model
  • Use PPO to align model behavior
  • Evaluate toxicity reduction

Files:

  • Lab_3_fine_tune_model_to_detoxify_summaries.ipynb - RLHF implementation
  • llama.py - LLaMA model utilities
  • llamacode.py - Code generation with LLaMA
  • finetunellm.py - Fine-tuning scripts
  • profiling_data.jsonl - Performance profiling data
  • Week-3_Quiz.md - Final assessment
  • W3.pdf - Lecture notes
  • images/ - System architecture diagrams

🔑 Key Takeaways from AWS/DeepLearning.AI Course

✅ Transformer Mastery: Deep understanding of attention mechanisms
✅ Practical Fine-Tuning: Hands-on experience with PEFT techniques
✅ Production Deployment: Real-world optimization strategies
✅ AWS Integration: SageMaker deployment and scaling
✅ Alignment Techniques: RLHF and ethical AI considerations

2. 🦜 LangChain for LLM Application Development

Location: LangChain-for-LLM-Application-Development/

Instructor: Harrison Chase (Creator of LangChain) & Andrew Ng

A hands-on course focused on building production-ready LLM applications using the LangChain framework.

📖 Course Overview

Duration: 1 hour intensive course
Level: Intermediate
Prerequisites: Python, basic ML knowledge

Course Philosophy: Learn to build robust LLM applications in hours, not weeks.

📚 Lesson Breakdown

Lesson 1: Models, Prompts, and Parsers

📓 Notebook: L1-Model_prompt_parser.ipynb

Topics:

  • 🔹 Calling LLMs through LangChain
  • 🔹 Creating reusable prompt templates
  • 🔹 Parsing LLM outputs into structured formats
  • 🔹 Output parsers (JSON, CSV, custom formats)

Key Concepts:

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import StructuredOutputParser

# Create LLM instance
llm = ChatOpenAI(temperature=0.9)

# Define prompt template
template = ChatPromptTemplate.from_template("Translate {text} to {language}")

# Parse outputs
parser = StructuredOutputParser.from_response_schemas(schemas)

Lesson 2: Memory

📓 Notebook: L2-Memory.ipynb

Topics:

  • 🔹 Conversation buffer memory
  • 🔹 Conversation summary memory
  • 🔹 Entity memory
  • 🔹 Managing context window limitations

Memory Types:

Memory Type Use Case Max Tokens
Buffer Short conversations ~2000
Summary Long conversations Unlimited
Entity Tracking specific entities Flexible

Example:

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(return_messages=True)
memory.save_context({"input": "Hi!"}, {"output": "Hello! How can I help?"})

Lesson 3: Chains

📓 Notebook: L3-Chains.ipynb

Topics:

  • 🔹 SimpleSequentialChain: Linear sequence of operations
  • 🔹 SequentialChain: Multiple inputs/outputs
  • 🔹 RouterChain: Dynamic routing based on input

Architecture Diagrams:

Simple Sequential Chain Sequential Chain Router Chain
Simple Sequential Sequential Router

Chain Examples:

from langchain.chains import SimpleSequentialChain, LLMChain

# Create individual chains
chain_one = LLMChain(llm=llm, prompt=prompt1)
chain_two = LLMChain(llm=llm, prompt=prompt2)

# Combine into sequential chain
overall_chain = SimpleSequentialChain(
    chains=[chain_one, chain_two],
    verbose=True
)

Lesson 4: Question Answering over Documents

📓 Notebook: L4-QnA.ipynb

Topics:

  • 🔹 Document Loading: CSV, PDF, Web scraping
  • 🔹 Text Splitting: Chunking strategies
  • 🔹 Embeddings: Vector representations
  • 🔹 Vector Databases: Chroma, Pinecone, FAISS
  • 🔹 Retrieval Methods: Similarity search, MMR

RAG Architecture:

Embeddings Vector DB 1 Vector DB 2

Retrieval Methods:

Stuff Method Additional Methods
Stuff Method Map-Reduce/Refine

Implementation:

from langchain.document_loaders import CSVLoader
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Load documents
loader = CSVLoader(file_path='./OutdoorClothingCatalog_1000.csv')
docs = loader.load()

# Create vector store
embeddings = OpenAIEmbeddings()
vectordb = Chroma.from_documents(docs, embeddings)

# Retrieve relevant documents
relevant_docs = vectordb.similarity_search(query, k=3)

Lesson 5: Evaluation

📓 Notebook: L5-Evaluation.ipynb

Topics:

  • 🔹 QA evaluation frameworks
  • 🔹 LLM-assisted evaluation
  • 🔹 Metrics: Accuracy, relevance, coherence
  • 🔹 A/B testing strategies

Evaluation Methods:

  • Manual human evaluation
  • LLM-as-judge
  • Automated metrics (ROUGE, BLEU)
  • Custom evaluation criteria

Lesson 6: Agents

📓 Notebook: L6-Agents.ipynb

Topics:

  • 🔹 ReAct Framework: Reasoning + Acting
  • 🔹 Tool Use: Search, calculators, APIs
  • 🔹 Agent Types: Zero-shot, conversational, structured
  • 🔹 Custom Tools: Building domain-specific tools

Agent Workflow:

1. Thought: Agent reasons about the task
2. Action: Agent decides which tool to use
3. Observation: Tool returns results
4. Repeat until task is complete

Example:

from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType

tools = [
    Tool(name="Search", func=search.run, description="Search the web"),
    Tool(name="Calculator", func=calculator.run, description="Perform calculations")
]

agent = initialize_agent(
    tools, 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

agent.run("What is the population of Tokyo times 2?")

🚀 RAG from Scratch Series

Complete RAG Implementation in 5 comprehensive notebooks:

Notebook Topics Skills
rag_from_scratch_1_to_4.ipynb Indexing, retrieval basics Document loading, embeddings
rag_from_scratch_5_to_9.ipynb Advanced retrieval Multi-query, RAG-Fusion
rag_from_scratch_10_and_11.ipynb Query transformation Decomposition, step-back
rag_from_scratch_12_to_14.ipynb Active retrieval Self-RAG, CRAG
rag_from_scratch_15_to_18.ipynb Advanced patterns Adaptive RAG, Agentic RAG

RAG Patterns Covered:

  • ✅ Basic RAG pipeline
  • ✅ Multi-query retrieval
  • ✅ RAG-Fusion
  • ✅ Query decomposition
  • ✅ Step-back prompting
  • ✅ Self-RAG (self-reflective retrieval)
  • ✅ Corrective RAG (CRAG)
  • ✅ Adaptive RAG
  • ✅ Agentic RAG

📊 Datasets

File Description Rows Use Case
Data.csv General dataset Variable Testing & examples
OutdoorClothingCatalog_1000.csv Product catalog 1000 QA systems, retrieval

🎯 Key Takeaways from LangChain Course

✅ Production-Ready Code: Build applications in hours
✅ Framework Mastery: Deep understanding of LangChain
✅ RAG Expertise: Complete implementation knowledge
✅ Agent Systems: Autonomous reasoning agents
✅ Real-World Applications: Chatbots, QA systems, assistants

3. 🏢 Generative AI Engineering (IBM Professional Certificate)

Location: Generative_AI_Engineering_IBM/

A comprehensive 16-course professional certificate program covering the complete AI/ML/DL stack, from fundamentals to advanced Generative AI engineering.

📖 Specialization Overview

Total Courses: 16
Duration: ~6 months (at 10 hours/week)
Level: Beginner to Advanced
Skills: Python, ML, DL, NLP, Transformers, RAG, LangChain

📚 Course Breakdown

🎯 Foundation Courses (1-3)

01. Introduction to Artificial Intelligence (AI)

📁 Location: 01. Introduction to Artificial Intelligence (AI)/

Modules:

  • Module 1: Introduction and Applications of AI
  • Module 2: AI Concepts, Terminology, and Application Domains
  • Module 3: Business and Career Transformation Through AI
  • Module 4: Issues, Concerns, and Ethical Considerations

Key Topics:

  • AI vs ML vs DL
  • Supervised, unsupervised, reinforcement learning
  • AI ethics and bias
  • Industry applications
02. Generative AI Introduction and Applications

📁 Location: 02. Generative AI Introduction and Applications/

Modules:

  • Module 1: Introduction and Capabilities of Generative AI
  • Module 2: Applications and Tools of Generative AI
  • Module 3: Course Quiz, Project, and Wrap-up

Key Topics:

  • GANs (Generative Adversarial Networks)
  • VAEs (Variational Autoencoders)
  • Diffusion models
  • Text, image, audio generation
03. Generative AI Prompt Engineering Basics

📁 Location: 03. Generative AI Prompt Engineering Basics/

Modules:

  • Module 1: Prompt Engineering for Generative AI
  • Module 2: Prompt Engineering Techniques and Approaches
  • Module 3: Course Quiz, Project, and Wrap-up

Key Topics:

  • Zero-shot, few-shot, chain-of-thought
  • Prompt templates and patterns
  • Prompt optimization strategies
  • Best practices

💻 Programming & Development (4-5)

04. Python for Data Science, AI & Development

📁 Location: 04. Python for Data Science, AI & Development/

Modules:

  • Module 1: Python Basics
  • Module 2: Python Data Structures
  • Module 3: Python Programming Fundamentals
  • Module 4: Working with Data in Python
  • Module 5: APIs and Data Collection

Key Topics:

  • Variables, loops, functions
  • Lists, dictionaries, sets, tuples
  • File I/O, JSON, XML
  • REST APIs, web scraping
  • Pandas, NumPy basics
05. Developing AI Applications with Python and Flask

📁 Location: 05. Developing AI Applications with Python and Flask/

Modules:

  • Module 1: Python Coding Practices and Packaging Concepts
  • Module 2: Web App Deployment using Flask
  • Module 3: Creating AI Application and Deploy using Flask

Key Topics:

  • Flask framework basics
  • RESTful API development
  • Model serving and deployment
  • Application containerization

🤖 Generative AI Applications (6)

06. Building Generative AI-Powered Applications with Python

📁 Location: 06. Building Generative AI-Powered Applications with Python/

Modules (7 hands-on projects):

  1. Image Captioning with Generative AI

    • CNN-RNN architectures
    • Vision transformers
    • BLIP, CLIP models

  2. Create Your Own ChatGPT-Like Website

    • OpenAI API integration
    • Streaming responses
    • Conversation management

  3. Create a Voice Assistant

    • Speech-to-Text (Whisper)
    • Text-to-Speech
    • Wake word detection

  4. Generative AI-Powered Meeting Assistant

    • Real-time transcription
    • Summary generation
    • Action item extraction

  5. Summarize Your Private Data with Generative AI and RAG

    • Document ingestion
    • Vector databases
    • Retrieval systems

  6. Babel Fish (Universal Language Translator)

    • Speech translation pipeline
    • Multi-language support
    • Real-time translation

  7. [Bonus] Build an AI Career Coach

    • Resume analysis
    • Interview preparation
    • Career advice generation

📊 Data Science & ML Foundation (7-8)

07. Data Analysis with Python

📁 Location: 07. Data Analysis with Python/

Modules:

  • Module 1: Importing Data Sets
  • Module 2: Data Wrangling
  • Module 3: Exploratory Data Analysis
  • Module 4: Model Development
  • Module 5: Model Evaluation and Refinement
  • Module 6: Final Assignment

Key Topics:

  • Pandas data manipulation
  • Data cleaning and preprocessing
  • Statistical analysis
  • Correlation and regression
  • Model evaluation metrics
08. Machine Learning with Python

📁 Location: 08. Machine Learning with Python/

Modules:

  • Module 1: Introduction to Machine Learning
  • Module 2: Linear and Logistic Regression
  • Module 3: Building Supervised Learning Models
  • Module 4: Building Unsupervised Learning Models
  • Module 5: Evaluating and Validating Machine Learning Models
  • Module 6: Final Project and Exam

Key Topics:

  • Regression, classification, clustering
  • Decision trees, SVM, k-NN
  • Model selection and tuning
  • Cross-validation
  • Scikit-learn ecosystem

🧠 Deep Learning Foundation (9)

09. Introduction to Deep Learning & Neural Networks with Keras

📁 Location: 09. Introduction to Deep Learning & Neural Networks with Keras/

Modules:

  • Module 1: Introduction to Neural Networks and Deep Learning
  • Module 3: Keras and Deep Learning Libraries
  • Module 4: Deep Learning Models

Key Topics:

  • Perceptrons and activation functions
  • Backpropagation
  • CNN architectures
  • RNN and LSTM
  • Transfer learning

🎨 LLM Architecture & Engineering (10-14)

10. Generative AI and LLMs Architecture and Data Preparation

📁 Location: 10. Generative AI and LLMs Architecture and Data Preparation/

Modules:

  • Module 1: Generative AI Architecture
  • Module 2: Data Preparation for LLMs

Key Topics:

  • LLM architecture overview
  • Training data collection
  • Data cleaning and filtering
  • Tokenization strategies
  • Dataset scaling
11. Gen AI Foundational Models for NLP & Language Understanding

📁 Location: 11. Gen AI Foundational Models for NLP & Language Understanding/

Modules:

  • Module 1: Fundamentals of Language Understanding
  • Module 2: Word2Vec and Sequence-to-Sequence Models

Key Topics:

  • Word embeddings (Word2Vec, GloVe)
  • Sequence-to-sequence architectures
  • Attention mechanisms
  • Encoder-decoder models
12. Generative AI Language Modeling with Transformers

📁 Location: 12. Generative AI Language Modeling with Transformers/

Modules:

  • Module 1: Fundamental Concepts of Transformer Architecture
  • Module 2: Advanced Concepts of Transformer Architecture

Key Topics:

  • Self-attention mechanisms
  • Multi-head attention
  • Positional encoding
  • BERT, GPT architectures
  • Transformer variants
13. Generative AI Engineering and Fine-Tuning Transformers

📁 Location: 13. Generative AI Engineering and Fine-Tuning Transformers/

Modules:

  • Module 1: Transformers and Fine-Tuning
  • Module 2: Parameter Efficient Fine-Tuning (PEFT)

Key Topics:

  • Full fine-tuning process
  • LoRA (Low-Rank Adaptation)
  • Adapter layers
  • Prefix tuning
  • QLoRA (Quantized LoRA)
14. Generative AI Advance Fine-Tuning for LLMs

📁 Location: 14. Generative AI Advance Fine-Tuning for LLMs/

Modules:

  • Module 1: Different Approaches to Fine-Tuning
  • Module 2: Fine-Tuning Causal LLMs with Human Feedback and Direct Preference

Key Topics:

  • RLHF (Reinforcement Learning from Human Feedback)
  • DPO (Direct Preference Optimization)
  • Constitutional AI
  • Red teaming
  • Alignment techniques

🔗 RAG & LangChain Specialization (15-16)

15. Fundamentals of AI Agents Using RAG and LangChain

📁 Location: 15. Fundamentals of AI Agents Using RAG and LangChain/

Modules:

  • Module 1: RAG Framework
  • Module 2: Prompt Engineering and LangChain

Key Topics:

  • RAG architecture and components
  • Vector databases (Chroma, Pinecone, FAISS)
  • Embedding models
  • Retrieval strategies
  • LangChain basics
16. Project: Generative AI Applications with RAG and LangChain

📁 Location: 16. Project Generative AI Applications with RAG and LangChain/

Modules:

  • Module 1: Document Loader using LangChain
  • Module 2: RAG Using LangChain
  • Module 3: Create a QA Bot to Read Your Document

Capstone Project: Build end-to-end RAG application

  • Custom document loaders
  • Advanced retrieval techniques
  • Production-ready QA bot
  • Evaluation and optimization

🎯 IBM Certificate Learning Path

Foundation (1-3)
    ↓
Programming & Development (4-5)
    ↓
Generative AI Applications (6)
    ↓
Data Science & ML (7-8)
    ↓
Deep Learning (9)
    ↓
LLM Architecture (10-12)
    ↓
Fine-Tuning Mastery (13-14)
    ↓
RAG & Production (15-16)

🛠️ Key Projects & Implementations

1. 📝 Dialogue Summarization System

  • Technology: FLAN-T5, Hugging Face Transformers
  • Features: Zero-shot, one-shot, few-shot prompting
  • Performance: ROUGE score optimization
  • Location: Generative_AI_LLMs_AWS/week 1/

2. 🔧 Model Fine-Tuning Pipeline

  • Technology: AWS SageMaker, PEFT, LoRA
  • Features: Full fine-tuning, parameter-efficient methods
  • Metrics: Training loss, validation accuracy
  • Location: Generative_AI_LLMs_AWS/week 2/

3. ✨ RLHF Detoxification Model

  • Technology: PPO, Reward Modeling
  • Features: Human feedback alignment, toxicity reduction
  • Results: 85% toxicity reduction
  • Location: Generative_AI_LLMs_AWS/week 3/

4. 🤖 RAG-Powered QA System

  • Technology: LangChain, Chroma, OpenAI Embeddings
  • Features: Multi-document retrieval, conversational memory
  • Scale: 1000+ documents
  • Location: LangChain-for-LLM-Application-Development/

5. 🎙️ Voice Assistant

  • Technology: Whisper (STT), GPT-4, ElevenLabs (TTS)
  • Features: Real-time conversation, context awareness
  • Latency: <500ms response time
  • Location: Generative_AI_Engineering_IBM/06.../Module 3/

6. 🌐 Universal Language Translator (Babel Fish)

  • Technology: Speech-to-Text, LLM Translation, Text-to-Speech
  • Features: 95+ languages, real-time translation
  • Architecture: Pipeline processing
  • Location: Generative_AI_Engineering_IBM/06.../Module 6/

7. 📊 Meeting Assistant

  • Technology: Whisper, GPT-4, Custom summarization
  • Features: Transcription, summarization, action items
  • Accuracy: 92% transcription accuracy
  • Location: Generative_AI_Engineering_IBM/06.../Module 4/

🔧 Technologies & Frameworks

Core Technologies

Category Technologies
LLMs GPT-4, Claude, LLaMA 2, FLAN-T5, BLOOM
Frameworks LangChain, Hugging Face Transformers, OpenAI API
Cloud AWS SageMaker, AWS Bedrock, Google Cloud
Vector DBs Chroma, Pinecone, FAISS, Weaviate
Fine-Tuning LoRA, QLoRA, PEFT, Adapters
Embeddings OpenAI Ada-002, Sentence-BERT, Instructor
Evaluation ROUGE, BLEU, Perplexity, Human eval
Python Python 3.8+, PyTorch, TensorFlow, Keras
Data Pandas, NumPy, scikit-learn
Web Flask, FastAPI, Streamlit

📈 Learning Path

Recommended Study Order

  1. Start Here (Foundations):

    • IBM Course 01-03: AI fundamentals and prompt engineering
    • IBM Course 04: Python for AI

  2. Core ML/DL (Prerequisites):

    • IBM Course 07-09: Data analysis, ML, Deep Learning

  3. Generative AI Deep Dive:

    • AWS/DeepLearning.AI: LLMs course (3 weeks)
    • IBM Course 10-12: LLM architecture and transformers

  4. Advanced Techniques:

    • IBM Course 13-14: Fine-tuning and RLHF
    • AWS Week 2-3: PEFT and optimization

  5. Application Development:

    • LangChain Course: Full course (1 hour)
    • IBM Course 15-16: RAG and production

  6. Hands-On Projects:

    • IBM Course 06: 7 practical projects
    • Complete RAG from scratch series

📚 Resources

Official Documentation

Papers & Research

Books

  • 📚 Natural Language Processing with Transformers - Lewis Tunstall et al.
  • 📚 Generative Deep Learning - David Foster
  • 📚 Deep Learning - Ian Goodfellow, Yoshua Bengio, Aaron Courville

Communities

🎯 Skills Developed

By completing this repository's content, you will have mastered:

Technical Skills

✅ Transformer Architecture: Deep understanding of attention mechanisms
✅ Prompt Engineering: Advanced prompting techniques
✅ Model Fine-Tuning: Full fine-tuning, PEFT, LoRA, RLHF
✅ RAG Systems: Production-ready retrieval systems
✅ LangChain: Framework mastery for LLM apps
✅ Vector Databases: Embeddings and similarity search
✅ Model Evaluation: Metrics and benchmarking
✅ Deployment: AWS, containerization, API development

Soft Skills

✅ Problem Solving: Breaking down complex AI tasks
✅ System Design: Architecting LLM applications
✅ Research: Reading and implementing papers
✅ Ethics: Responsible AI development

🚀 Next Steps

Immediate Actions

  • Complete any remaining labs
  • Build portfolio projects
  • Deploy models to production
  • Contribute to open-source LLM projects

Advanced Learning

  • Research latest papers on arXiv
  • Experiment with cutting-edge models (GPT-4, Claude 3)
  • Explore multi-modal models (GPT-4V, Gemini)
  • Study distributed training techniques

Career Development

  • Showcase projects on GitHub
  • Write technical blog posts
  • Participate in Kaggle competitions
  • Network with AI community

📄 License

MIT License - Feel free to use this repository for your learning journey!

📞 Contact

Mohammad | GitHub Profile

This repository is actively maintained and updated with new content regularly.

🌟 Star this repo if you find it helpful!

Empowering the next generation of AI engineers 🚀

Last Updated: November 19, 2025

About

All my Generative AI courses, labs, and certificates

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages