Skip to content

Ehsan Ahmadi's Personal Docs

Naive RAG {RAG}

Initializing search

🚀 Cheatsheet
🧪 Data Science
🧠 AI
👨‍💻 Software
⚾ Soft Skill
🧮 Mathematics

Ehsan Ahmadi's Personal Docs

🚀 Cheatsheet
🚀 Cheatsheet
- AI
- CI/CD
- Docker
- .Net
- Elasticsearch
- Git
- Go
- Linux
- MongoDB
- Mysql
- Nginx
- Postgresql
- Python
- Rabbitmq
- Wordpress
🧪 Data Science
🧪 Data Science
- Overview
  Overview
  - 9 Laws
  - Projects Flow
- 🗃️ Data
  🗃️ Data
  - Cleaning
    Cleaning
    
    Cheatsheet
    
    Duplicates
    
    Imbalanced Data
    
    Missing Values
    
    Noisy Data
    
    Outliers
  - Creation
    Creation
    
    Augmentation
  - Distribution types
    Distribution types
    
    Binomial
    
    Long Tail
    
    Normal {Gaussian} {Bell Curve}
    
    Poisson
    
    Uniform
  - Reduction
    Reduction
    
    Overview
    
    Aggregation
    
    Clustering
    
    Compression
    
    Generalization
    
    Importance Sampling {Sampling}
    
    Reservoir Sampling {Sampling}
    
    Simple Random Sampling {Sampling}
    
    Stratified Sampling {Sampling}
    
    Weighted Sampling {Sampling}
- 🔍 Feature
  🔍 Feature
- 📈 Charts
  📈 Charts
- ⚖️ Metrics & Evaluation
  ⚖️ Metrics & Evaluation
🧠 AI
🧠 AI
- 🦾 Machine Learning
  🦾 Machine Learning
  - Overview
  - Classification
    Classification
    
    Decision Trees {Tree}
    
    K-Nearest Neighbors (KNN)
    
    Logistic Regression
    
    Multinomial Logistic Regression
    
    Naive Bayes
    
    Random Forest {Tree}
    
    Support Vector Machine (SVM)
    
    XGBoost (eXtreme Gradient Boosting) {Tree}
    
    Share (Information Gain Technique) {Tree}
    
    Vs (SVM & Logistic Regression)
  - Clustering
    Clustering
    
    Overview
    
    Anomaly
    
    HDBSCAN
    
    K-Means
    
    VADER {Sentiment Analysis}
  - Feature extraction
    Feature extraction
    
    FastText
    
    Word2Vec
  - Recommender
    Recommender
    
    Collaborative Filtering {Unsup}
    
    Content-Based Filtering {Unsup}
    
    Simple Recommendation {Unsup}
  - Regression
    Regression
    
    Linear Regression (Least Squares) {Sup}
    
    Polynomial Regression {Sup}
  - Reinforcement
    Reinforcement
    
    Reinforcement Learning {Unsup}
  - Topic modeling
    Topic modeling
    
    Overview
    
    BERTopic
    
    LDA
    
    NMF
- 🤖 Neural Network
  🤖 Neural Network
  - Activation functions
    Activation functions
    
    Linear {\(-\infty\) to \(+\infty\)}
    
    ReLU {\(0\) to \(+\infty\)}
    
    Sigmoid {0 to 1}
    
    Softmax {0 to 1}
    
    Softplus {\(0\) to \(+\infty\)}
    
    TanH {-1 to 1}
    
    Threshold {0 or 1}
  - Architectures
    Architectures
    
    Auto-Encoders (AE) {Dimensionality Reduction}
    
    Convolutional (CNN) {Image}
    
    Embedding [Dense] [Sparse] {NLP}
    
    Feed Forward (FFNN)
    
    Generative Adversarial (GAN) {Data Augmentation}
    
    Mamba {NLP}
    
    Mixture of Experts (MoE) {NLP}
    
    Mixture of Recursion (MoR) {NLP}
    
    Parameter-Efficient Ensembling {Tabular}
    
    Recurrent (RNN) {Sequential Data}
    
    RWKV {NLP}
    
    Time Series Models {Correlated Data}
    
    Transformers {NLP}
  - Cost functions
    Cost functions
    
    Overview
    
    Cosine Similarity {Embedding}
    
    Cross-Entropy Loss {Multi-Class Classification}
    
    Distortion {Signal Processing}
    
    Log Loss {Binary Classification}
    
    Multiple Negative Ranking (MNR) (InfoNCE7) (NTXentLoss) {Embedding}
    
    Squared Error Loss {Regression}
  - Fine tuning
    Fine tuning
    
    Overview
    
    Adapters {PEFT}
    
    Contrastive Learning
    
    DPO (Direct Preference Optimization)
    
    Freezing Layers
    
    LoRA [QLoRA] {PEFT}
    
    Masked Language Modeling (MLM)
    
    Online RL [PPO] [GRPO]
    
    Parameter-Efficient Fine-Tuning (PEFT)
    
    RLHF (Reinforcement Learning from Human Feedback)
    
    SetFit
    
    Supervised Fine-Tuning (SFT)
    
    Vs (SFT & DPO & RLHF & Online RL)
  - Learning rate techniques
    Learning rate techniques
    
    Adam Algorithm
    
    ADOPT Algorithm
    
    Batch & Mini-batch
    
    Gradient Descent With Momentum
    
    Hyperparameters Tuning
    
    Learning Rate Decay (lrDecay)
    
    Weight Initialization
  - Optimization
    Optimization
    
    Knowledge Distillation
    
    Pruning
    
    Quantization
  - Tasks
    Tasks
    
    Bi-Encoders (Dense Retrieval)
    
    Cross-Encoders (Reranking)
    
    Fill-Mask
    
    Named Entity Recognition (NER)
    
    Neural Machine Translation
    
    Part of Speech Tagging (POS)
    
    Question Answering
    
    Sentiment Analysis
    
    Text Generation
    
    Text Summarization
    
    Zero-Shot Classification
- 🗣️ LLM
  🗣️ LLM
  - Chain types
    Chain types
    
    Adaptive RAG {RAG}
    
    Agentic RAG {RAG}
    
    Corrective RAG {RAG}
    
    Graph RAG {RAG}
    
    Hybrid RAG {RAG}
    
    HyDE {RAG}
    
    Map-Reduce
    
    Map-Rerank
    
    Multimodal RAG {RAG}
    
    Naive RAG {RAG} Naive RAG {RAG}
    Table of contents
    
    Description
    
    ReAct
    
    Refine
    
    Search Type
    
    Stuffing
  - Hyperparameters
    Hyperparameters
    
    max_token
    
    Presence Penalty
    
    Repetition Penalty
    
    temperature
    
    top_k
    
    top_p
    
    Vs (top_p & temperature)
  - Jailbreaking
    Jailbreaking
    
    Overview
    
    Encoding
    
    Many-Shot
    
    Prompt Injection
  - Prompting
    Prompting
    
    Chain-of-Thought (CoT)
    
    Few-Shot
    
    Generated Knowledge
    
    Meta
    
    Prompt Chaining
    
    Retrieval Augmented Generation (RAG)
    
    Self-Consistency
    
    Step-Back
    
    Structured
    
    Tree-of-Thoughts (ToT)
    
    Zero-Shot
    
    Zero-Shot Chain-of-Thought
    
    Vs (Generated Knowledge & RAG)
    
    Vs (Meta & Few-Shot)
  - Tokenization
    Tokenization
    
    Byte Pair Encoding (BPE) {Strategy}
    
    Byte Tokens {Output}
    
    Character Tokens {Output}
    
    SentencePiece {Strategy}
    
    Subword Tokens {Output}
    
    Word Tokens {Output}
    
    WordPiece {Strategy}
- Evaluation
  Evaluation
  - Data Distribution
  - Orthogonalization
- Fitting problems
  Fitting problems
  - Overview
  - Ensemble methods
    Ensemble methods
    
    Overview
    
    Bagging (Bootstrap Aggregating)
    
    Boosting
    
    Gradient Boosting
    
    Stacking
  - For neural networks
    For neural networks
    
    Bigger Neural Network
    
    Dropout Regularization
    
    Early Stopping Regularization
  - Hyperparameter tuning
    Hyperparameter tuning
    
    Training CV
  - Imbalanced data
    Imbalanced data
    
    Cost-Sensitive Learning
  - Regularization
    Regularization
    
    Overview
    
    LASSO (L1)
    
    Ridge (L2)
    
    Vs (LASSO & Ridge)
  - Splitting data
    Splitting data
    
    Holdout Method (Train/Test Split)
    
    K-Fold
    
    Leave-P-Out
    
    Stratified K-Fold
    
    Time Series Cross-Validation
- Learning types
  Learning types
👨‍💻 Software
👨‍💻 Software
- 📜 Languages
  📜 Languages
  - C#
    C#
    
    Architecture
    Architecture
    
    Architecture
    
    Memory Management
    
    Namespace
    
    Solution & Project
    
    Asp
    Asp
    
    Area
    
    Background Tasks
    
    Controller
    
    Data annotations
    
    DI
    
    Identity
    
    Routing
    
    Structure
    
    View
    
    Class
    Class
    
    Class
    
    Delegate & Event
    
    Enumeration
    
    Field
    
    Interface
    
    Method
    
    Property
    
    Record
    
    Structure
    
    Collections
    Collections
    
    Overview
    
    Array
    
    ArrayList
    
    Dictionary
    
    Hashset
    
    Hashtable
    
    LINQ
    
    List
    
    Queue
    
    SortedList
    
    Stack
    
    Share (Dictionary & SortedList & Hashtable)
    
    Share (List & Hashset & ArrayList & Stack & Queue)
    
    Ef
    Ef
    
    Overview & Installation
    
    CMD
    
    Command & Query
    
    DB Context & DB Set
    
    Model & Fields
    
    Fundamentals
    Fundamentals
    
    Async & Await
    
    Character Encoding
    
    Command Line Arguments
    
    Control Statements
    
    Data Types
    
    DateTime
    
    dotnet CLI
    
    Exception Handling
    
    IO
    
    Keywords
    
    Math
    
    Operators
    
    Serialization
    
    String
  - Go
    Go
    
    Passed by Value/Reference
  - Rust
    Rust
    
    Ownership
    
    String
  - Uml
    Uml
    
    Overview
    
    Aggregation (Constructor List)
    
    Association (Constructor Access)
    
    Composition (Constructor Create)
    
    Dependency (Method Access)
    
    Generalization (Extend)
    
    Realization (Implementation)
- 🧩 OOP
  🧩 OOP
- 📢 Protocols
  📢 Protocols
- 🗃️ Storage {Cache} {DB}
  🗃️ Storage {Cache} {DB}
  - overview
    overview
    
    DB Types
    
    DB Use Cases
    
    Glossary
    
    Storage Estimation
    
    Storage Selection
  - Acid transaction
    Acid transaction
    
    Atomicity
    
    Consistency
    
    Durability
    
    Isolation
  - Cache
    Cache
    
    Cache Types
    
    System Memory Hierarchy
  - Data warehouse
    Data warehouse
    
    Overview
    
    Data Lake
    
    Data Mart
    
    Data Mesh
    
    Data Pipeline
    
    Data Warehouse
    
    Delta Lake
    
    Star Schema
  - Nosql
    Nosql
    
    Data Locality
    
    LSM-Tree Storeage Structure
  - Replication
    Replication
    
    Overview
    
    Approach: Leaderless Replication
    
    Approach: Multi-Leader Replication
    
    Approach: Single-Leader Replication
    
    Replication Lag Problem
    
    Vs (Single-Leader & Multi-Leader)
  - Sql
    Sql
    
    B-Tree Storeage Structure
    
    Concurrency Control
    
    Row-Based vs Column-Based
    
    SQL Commands
    
    Standard/Virtual View
- 🥞 Data Structures
  🥞 Data Structures
- 👷 DevOps
  👷 DevOps
  - AWS Services
  - DNS
  - FASS
  - Github Actions
  - Linux
- Applications
  Applications
  - Kafka
  - Elasticsearch
    Elasticsearch
    
    Glossary
    
    DSL (Query Clauses)
    
    DSL (Query Contexts)
    
    Mapping
- System design
  System design
  - Algorithms and patterns
    Algorithms and patterns
    
    API Gateway
    
    Bulkhead
    
    CAP Theorem
    
    Circuit Breaker
    
    CQRS
    
    Event-Driven
    
    Outbox
    
    Saga
    
    Service Mesh
    
    Service Registry
    
    Sidecar
    
    Strangler
  - Architectures
    Architectures
    
    Overview
    
    Clean Architecture
    
    DDD
    
    Hexagonal Architecture
    
    Micro Services
  - Maintainability
    Maintainability
    
    Overview
    
    Evolvability
    
    Operability
    
    Simplicity
  - Reliability
    Reliability
    
    Overview
    
    Fault-Tolerant (Resilient)
  - Scalability
    Scalability
    
    Overview
    
    Points
- System development
  System development
  - Overview
    Overview
    
    Programming Idioms
  - 🛡️ Security
    🛡️ Security
    
    Bearer Token Authentication
    
    MD5 & SHA
    
    OWASP
    
    PASETO Token
    
    Session Management (Access/Refresh Token)
    
    Symmetric & Asymmetric Encryption
  - Log and metric
    Log and metric
    
    Logging
    
    Metrics
    
    Tracing
    
    Vs (Logging & Tracing & Metrics)
  - Testing
    Testing
    
    API Test
  - Typing
    Typing
    
    Duck Typing
    
    Dynamic & Static Typing
    
    Goose Typing
    
    Static Duck Typing (Structural Subtyping)
  - Version control
    Version control
    
    Code Review Guide
    
    Micro Commit
⚾ Soft Skill
⚾ Soft Skill
🧮 Mathematics
🧮 Mathematics
- Fundamentals
  Fundamentals
  - Functions
  - Logic
  - Math Idioms
  - Sets
- Linear algebra
  Linear algebra
  - Matrix
  - Subset
  - Subspace
  - Transformation
  - Vector
- Probability and statistics
  Probability and statistics

Table of contents

Description

Naive RAG {RAG}

Description

©2020-2025 Ehsan Ahmadi