Artificial Intelligence (AI) is the broad field of creating machines/systems that can simulate human intelligence — reasoning, problem-solving, understanding language, recognizing patterns. Machine Learning (ML) is a subset of AI where systems learn from data to improve performance without being explicitly programmed. Deep Learning (DL) is a subset of ML that uses multi-layered neural networks. Hierarchy: AI ⊃ ML ⊃ Deep Learning. AI includes rule-based systems; ML relies entirely on learning from data.

Machine Learning is broadly categorized into three types:

• Supervised Learning: Trains on labeled data (input-output pairs). Goal: predict output for new inputs. Examples: regression, classification (linear regression, decision trees, SVM, neural networks).
• Unsupervised Learning: Trains on unlabeled data. Goal: find hidden patterns or groupings. Examples: clustering (K-Means), dimensionality reduction (PCA), autoencoders.
• Reinforcement Learning: An agent learns by interacting with an environment, receiving rewards/penalties. Examples: game AI (AlphaGo), robotics, recommendation systems.

Regression predicts a continuous numerical value. Example: predicting house prices, temperature, stock prices. Algorithms: Linear Regression, Ridge, Lasso, SVR. Metrics: MSE, RMSE, MAE, R². Classification predicts a discrete category/class label. Example: spam/not spam, cat/dog, disease diagnosis. Algorithms: Logistic Regression, SVM, Random Forest, Neural Networks. Metrics: Accuracy, Precision, Recall, F1-Score, ROC-AUC.

Overfitting: The model learns training data too well, including noise — performs great on training set but poorly on test/new data (high variance). Fix: more data, regularization (L1/L2), dropout, cross-validation, pruning, early stopping. Underfitting: The model is too simple to capture patterns — poor on both training and test data (high bias). Fix: use a more complex model, more features, reduce regularization, train longer. Goal: balance bias-variance tradeoff.

Bias is the error from incorrect assumptions in the model (underfitting — model too simple). Variance is the error from sensitivity to fluctuations in training data (overfitting — model too complex). Total Error = Bias² + Variance + Irreducible Error. As model complexity increases, bias decreases but variance increases. The goal is to find the "sweet spot" — a model complex enough to capture patterns but not so complex it memorizes noise. Cross-validation helps identify the optimal complexity.

Cross-validation is a technique for evaluating model performance on unseen data by splitting the dataset into multiple folds. The most common is k-fold cross-validation: data is split into k equal parts; the model trains on k-1 parts and validates on the remaining 1 part, repeated k times, and results are averaged. Importance: gives a more reliable performance estimate than a single train-test split, helps detect overfitting, and is used for hyperparameter tuning. LOOCV (Leave-One-Out CV) is an extreme case where k = n.

A confusion matrix is a table showing TP (True Positive), FP (False Positive), TN (True Negative), FN (False Negative) predictions.

• Precision = TP / (TP + FP) — Of all predicted positives, how many were actually positive? (Minimizes false positives)
• Recall (Sensitivity) = TP / (TP + FN) — Of all actual positives, how many did we correctly identify? (Minimizes false negatives)
• F1-Score = 2 × (Precision × Recall) / (Precision + Recall) — Harmonic mean; balances both metrics
• Accuracy = (TP + TN) / Total — Misleading for imbalanced datasets

A decision tree is a tree-shaped model that makes decisions by splitting data at each node based on a feature threshold. It recursively partitions data until reaching leaf nodes (predictions). Splits are chosen to maximize information gain (using Information Gain / Entropy for classification) or minimize impurity (using Gini impurity). Advantages: interpretable, handles non-linear relationships, requires little data preprocessing. Disadvantage: prone to overfitting (mitigated by pruning or using ensemble methods like Random Forest).

Random Forest is an ensemble method that builds multiple decision trees on random subsets of data (bagging) and random subsets of features, then aggregates predictions (majority vote for classification, average for regression). Advantages over a single tree: significantly reduces overfitting, handles high-dimensional data, more robust to noise and outliers, provides feature importance. Trade-off: less interpretable (black-box compared to a single tree), computationally more expensive.

Gradient Descent is an optimization algorithm that minimizes a loss function by iteratively updating parameters in the direction of the negative gradient. Variants: Batch Gradient Descent — uses all training data per update (accurate but slow). Stochastic Gradient Descent (SGD) — uses one sample per update (fast, noisy). Mini-batch Gradient Descent — uses a small batch (balance between batch and SGD, most common in deep learning). Advanced optimizers: Adam (adaptive learning rates + momentum), RMSprop, Adagrad.

Regularization adds a penalty term to the loss function to reduce overfitting by discouraging large model weights. L1 (Lasso): adds |w| penalty — produces sparse models (drives some weights to exactly zero), useful for feature selection. L2 (Ridge): adds w² penalty — distributes weight reductions across all features, tends to produce smaller weights overall. ElasticNet: combines both L1 and L2. The hyperparameter λ (alpha) controls regularization strength — higher λ = more regularization = simpler model.

An Artificial Neural Network (ANN) is a computational model inspired by the human brain. It consists of interconnected layers of nodes (neurons): Input layer (receives features), Hidden layers (transform data via weighted connections and activation functions), Output layer (produces predictions). Training: forward pass (compute predictions), calculate loss, backpropagation (compute gradients), update weights via gradient descent. Activation functions (ReLU, Sigmoid, Tanh, Softmax) introduce non-linearity.

Backpropagation is the algorithm used to train neural networks by computing gradients of the loss function with respect to each weight. Process: (1) Forward pass — compute predictions, (2) Compute loss (e.g., cross-entropy, MSE), (3) Backward pass — propagate error gradients from output back through layers using the chain rule of calculus, (4) Update weights using gradient descent: w = w - α * ∂L/∂w where α is the learning rate. This is repeated over many epochs until the model converges.

Activation functions introduce non-linearity into neural networks, enabling them to learn complex patterns. Common ones:

• ReLU (Rectified Linear Unit): f(x) = max(0, x). Most popular for hidden layers; fast, avoids vanishing gradient. Issue: dying ReLU problem.
• Sigmoid: f(x) = 1/(1+e^-x). Output 0–1. Used in binary classification output layer. Suffers from vanishing gradient.
• Tanh: Output -1 to 1. Better than sigmoid for hidden layers in practice.
• Softmax: Multi-class classification output — converts logits to probability distribution summing to 1.
• Leaky ReLU / ELU: Fixes dying ReLU problem.

A CNN is a deep learning architecture designed for processing grid-structured data like images. Key layers: Convolutional layer — applies filters (kernels) to detect features (edges, textures); Pooling layer — reduces spatial dimensions (max pooling, average pooling) to decrease computation and provide translation invariance; Fully Connected (Dense) layer — final classification. CNNs share weights (parameters), making them efficient. Applications: image classification, object detection, face recognition. Famous architectures: VGG, ResNet, Inception.

A Recurrent Neural Network (RNN) processes sequential data by maintaining a hidden state that captures information from previous time steps — it has loops that pass information forward. Useful for: time series, text, speech, video. Problem: vanishing/exploding gradient in long sequences — gradients shrink or blow up during backpropagation through time. Solutions: LSTM (Long Short-Term Memory — uses gates: forget, input, output to control information flow) and GRU (Gated Recurrent Unit — simplified LSTM).

The Transformer (introduced in "Attention Is All You Need", 2017) replaced RNNs for NLP tasks. Key innovation: self-attention mechanism — allows each word to attend to all other words in a sequence simultaneously, capturing long-range dependencies without sequential processing. Architecture: Encoder stack + Decoder stack, each with multi-head self-attention layers and feed-forward networks. Positional encodings are added since transformers have no inherent order. Transformers are the foundation of BERT, GPT, T5, and all modern LLMs.

The attention mechanism allows a model to focus on the most relevant parts of the input when producing an output. In self-attention: for each word (query), compute similarity scores with all other words (keys), apply softmax to get attention weights, then compute a weighted sum of value vectors. Multi-head attention runs multiple attention operations in parallel to capture different types of relationships. Attention enables Transformers to handle long-range dependencies that RNNs struggle with.

NLP is a branch of AI that enables computers to understand, interpret, and generate human language. Key tasks: Text classification (spam detection, sentiment analysis), Named Entity Recognition (NER), Machine Translation, Question Answering, Text Summarization, Chatbots. Pipeline: Tokenization → Text cleaning → Feature extraction (TF-IDF, word embeddings) → Model. Modern NLP uses pre-trained transformers (BERT, GPT) fine-tuned on specific tasks.

Word embeddings represent words as dense numerical vectors that capture semantic meaning — similar words have similar vectors. Word2Vec (Google, 2013): trains using CBOW (predict word from context) or Skip-gram (predict context from word); captures semantic relationships. GloVe (Stanford): trains on global word co-occurrence statistics. FastText (Facebook): represents words as bags of character n-grams, handles rare/misspelled words and morphologically rich languages better. Modern embeddings: contextual embeddings from BERT/GPT that change based on sentence context.

BERT (Bidirectional Encoder Representations from Transformers, Google 2018) is a pre-trained NLP model based on the Transformer encoder. Key features: (1) Bidirectional — reads text in both directions simultaneously (unlike GPT which is left-to-right), capturing full context; (2) Pre-trained on two tasks: Masked Language Modeling (predict masked words) and Next Sentence Prediction; (3) Fine-tuning: BERT is fine-tuned on specific downstream tasks (classification, QA, NER) with minimal additional layers. Revolutionary for NLP benchmarks.

GPT (Generative Pre-trained Transformer, OpenAI) is a decoder-only Transformer trained autoregressively — predicts the next token given all previous tokens (left-to-right). GPT excels at text generation. BERT uses the encoder, is bidirectional, and excels at text understanding tasks. GPT-3 (175B parameters) and GPT-4 demonstrate remarkable few-shot learning — can perform tasks with just a few examples in the prompt. GPT powers ChatGPT. Key difference: BERT = understanding (classification, QA); GPT = generation (text, code, conversation).

Transfer learning reuses a model trained on one task (typically with large data) as the starting point for a new, related task. This dramatically reduces training time, data requirements, and computational cost. Approaches: (1) Feature extraction — freeze pre-trained layers, only train new layers added on top; (2) Fine-tuning — unfreeze some/all pre-trained layers and train further on new data with a lower learning rate. Examples: VGG/ResNet for computer vision tasks, BERT/GPT for NLP tasks. Foundation of modern AI.

Large Language Models (LLMs) are transformer-based models trained on massive text datasets (hundreds of billions of tokens) with billions of parameters. They learn to predict the next token, and in doing so, develop rich world knowledge, reasoning, and language capabilities. Examples: GPT-4, Claude, LLaMA, Gemini, Mistral. Capabilities: text generation, summarization, translation, code generation, question answering, reasoning. They exhibit emergent behaviors — abilities not explicitly trained for that appear at sufficient scale.

Prompt Engineering is the practice of designing and optimizing input prompts to get the best output from LLMs without changing model weights. Techniques: Zero-shot (just the task description), Few-shot (provide examples in the prompt), Chain-of-Thought (CoT) (ask the model to reason step-by-step: "Let's think step by step"), Role prompting ("Act as an expert..."), Output formatting (specify JSON, bullet points, etc.). Good prompts are clear, specific, and include context, task, format, and constraints.

RAG combines LLMs with external knowledge retrieval to overcome the LLM's knowledge cutoff and hallucination problems. Process: (1) Indexing: documents are chunked and stored as embeddings in a vector database (Pinecone, Chroma, FAISS); (2) Retrieval: user query is embedded and similar chunks are retrieved from the vector DB; (3) Generation: the retrieved context + query is passed to the LLM to generate a grounded answer. RAG improves accuracy for domain-specific applications (internal docs, FAQs) without expensive fine-tuning.

LangChain is a Python/JavaScript framework for building LLM-powered applications. It provides abstractions and components for: Chains (sequences of LLM calls), Agents (LLM + tools for dynamic decision-making), Memory (maintaining conversation history), Retrieval (RAG pipelines), Document loaders and vector stores. LangChain simplifies building complex AI workflows like chatbots, document Q&A systems, code assistants, and multi-step AI pipelines. Works with OpenAI, Anthropic, Hugging Face, and other model providers.

Fine-tuning adapts a pre-trained LLM to a specific domain or task by continuing training on a curated dataset. Types: Full fine-tuning (update all weights — expensive), PEFT (Parameter Efficient Fine-Tuning) — methods like LoRA (Low-Rank Adaptation — inject small trainable matrices while freezing most weights), QLoRA (quantized LoRA for reduced memory), Prefix Tuning, Prompt Tuning. Fine-tuning is used for: domain-specific language (medical, legal), custom tone/style, instruction following, improving accuracy on specific tasks.

Computer Vision is a field of AI that enables machines to interpret and understand visual information from the world. Main tasks:

• Image Classification: Assign a category label to an image (e.g., cat vs. dog).
• Object Detection: Locate and classify multiple objects in an image (bounding boxes). Models: YOLO, Faster R-CNN.
• Image Segmentation: Label each pixel — semantic (class per pixel) or instance (individual object per pixel).
• Face Recognition: Identify or verify individuals from facial images.
• Optical Character Recognition (OCR): Extract text from images.
• Image Generation: GANs, Stable Diffusion, DALL-E.

YOLO (You Only Look Once) is a real-time object detection algorithm. Unlike two-stage detectors (Faster R-CNN), YOLO performs detection in a single forward pass — it divides the image into an S×S grid, and each cell predicts bounding boxes, confidence scores, and class probabilities simultaneously. This makes YOLO extremely fast (real-time detection at 30-60+ FPS). Versions: YOLOv3, YOLOv5, YOLOv8 (current state-of-the-art). Applications: autonomous driving, surveillance, sports analytics, industrial inspection.

GANs (Goodfellow et al., 2014) consist of two competing neural networks: Generator — learns to create realistic fake data (images, text) from random noise; Discriminator — learns to distinguish real data from generated fake data. They train adversarially: the generator improves to fool the discriminator; the discriminator improves to detect fakes. Convergence: Nash equilibrium where the generator produces indistinguishable fakes. Applications: image synthesis, deepfakes, data augmentation, style transfer, image super-resolution. Variants: DCGAN, CycleGAN, StyleGAN.

Diffusion models are a class of generative models that create data by learning to reverse a gradual noising process. Forward process: progressively add Gaussian noise to data over T time steps until it becomes pure noise. Reverse process: train a neural network (usually a U-Net) to denoise step-by-step, learning the reverse of the noise addition. At inference, start from random noise and apply the learned denoising steps. Diffusion models power Stable Diffusion, DALL-E 2/3, and Midjourney, producing higher quality and more diverse outputs than GANs.

PCA is an unsupervised dimensionality reduction technique. It transforms data into a new coordinate system where the first axis (Principal Component 1) captures the maximum variance, the second captures the next most variance, and so on. Steps: (1) Standardize data; (2) Compute covariance matrix; (3) Compute eigenvectors and eigenvalues; (4) Select top k eigenvectors as principal components; (5) Project data onto new axes. Uses: data visualization (reducing to 2D/3D), noise reduction, speeding up ML algorithms by reducing features.

K-Means is an unsupervised clustering algorithm that partitions n data points into k clusters. Algorithm: (1) Initialize k cluster centroids randomly; (2) Assign each point to the nearest centroid (Euclidean distance); (3) Recompute centroids as mean of assigned points; (4) Repeat steps 2-3 until convergence. Key parameter: k (number of clusters) — chosen using the Elbow Method (plot WCSS vs. k, find "elbow"). Limitations: assumes spherical clusters, sensitive to initialization (use k-means++ for better init), sensitive to outliers.

SVM finds the optimal hyperplane that maximizes the margin between two classes. Support vectors are the closest data points to the hyperplane that define the margin. Key concepts: Kernel trick — transforms non-linearly separable data to higher dimensions where it becomes separable (RBF kernel, polynomial kernel); Soft margin (C parameter) — allows some misclassifications for better generalization. SVMs work well in high-dimensional spaces and are effective when classes are clearly separable. Slower to train on very large datasets compared to neural networks.

Both are ensemble methods combining multiple weak learners. Bagging (Bootstrap Aggregating): trains models independently on random subsets (with replacement) and aggregates predictions (voting/averaging). Reduces variance. Example: Random Forest. Boosting: trains models sequentially — each model focuses on correcting errors of the previous one, assigning higher weights to misclassified samples. Reduces bias and variance. Examples: AdaBoost, Gradient Boosting, XGBoost, LightGBM. Boosting typically achieves higher accuracy but is more prone to overfitting.

XGBoost (eXtreme Gradient Boosting) is an optimized gradient boosting framework known for speed and performance. Why popular: (1) Regularization (L1+L2 to prevent overfitting), (2) Handles missing values automatically, (3) Tree pruning using depth-first approach, (4) Parallel processing for faster training, (5) Built-in cross-validation, (6) Consistently wins Kaggle competitions. LightGBM and CatBoost are alternatives — LightGBM uses leaf-wise tree growth for faster training; CatBoost handles categorical features natively.

The vanishing gradient problem occurs in deep networks during backpropagation when gradients become extremely small as they propagate back through many layers — early layers receive tiny gradient signals and learn very slowly or not at all. Cause: repeated multiplication of small numbers (sigmoid/tanh derivatives are ≤ 0.25). Solutions: ReLU activation (gradient = 1 for positive inputs), Batch Normalization, Residual connections (ResNet — skip connections pass gradients directly), LSTM/GRU for RNNs, Gradient clipping for exploding gradients.

Batch Normalization (BN) normalizes the inputs of each layer to have zero mean and unit variance (computed over the mini-batch), then scales and shifts using learned parameters (γ, β). Benefits: (1) Reduces internal covariate shift, allowing higher learning rates; (2) Acts as regularization, reducing dependence on dropout; (3) Speeds up training; (4) Reduces sensitivity to weight initialization. Applied before or after activation functions. At inference, running statistics (moving averages of mean and variance) are used instead of batch statistics.

Dropout is a regularization technique for neural networks. During training, each neuron is randomly "dropped" (set to zero) with probability p (typically 0.2–0.5). This prevents neurons from co-adapting, forces the network to learn redundant representations, and acts as training an ensemble of many smaller networks. At inference, dropout is disabled (all neurons active) and weights are scaled by (1-p). Dropout is very effective at reducing overfitting in large networks. Applied after activation functions in fully connected layers.

Discriminative models learn the boundary between classes — they model P(Y|X) (probability of label given input). Examples: Logistic Regression, SVM, Neural Networks for classification. Generative models learn the full data distribution — they model P(X|Y) and P(X), enabling them to generate new samples. Examples: GANs, VAEs, Naive Bayes, Hidden Markov Models, LLMs. Generative models can synthesize new data; discriminative models focus only on prediction. Modern LLMs like GPT are generative — they model P(next token | previous tokens).

A vector database stores high-dimensional embedding vectors and enables fast similarity search (nearest neighbor lookup). Critical for AI applications like RAG, semantic search, recommendation systems, and image retrieval. Instead of exact keyword matching, vector DBs find semantically similar content using cosine similarity or dot product. Popular options: Pinecone (managed cloud), Weaviate, Chroma (open-source, local), FAISS (Facebook's library), Qdrant, Milvus. They use approximate nearest neighbor (ANN) algorithms (HNSW, IVF) for efficient large-scale search.

MLOps (Machine Learning Operations) is the set of practices for deploying, monitoring, and maintaining ML models in production reliably and efficiently. Key components: Data versioning (DVC), Experiment tracking (MLflow, Weights & Biases), Model registry, CI/CD for ML (automated training pipelines), Model serving (TensorFlow Serving, TorchServe, FastAPI), Model monitoring (detecting data/concept drift), Feature stores. Addresses the gap between ML research and production — only ~20% of ML effort is model training; 80% is infrastructure and operations.

Supervised learning requires manually labeled data (expensive and time-consuming to create). Self-supervised learning creates labels automatically from the data itself — no human labeling needed. Examples: predicting the next word in a sentence (GPT pretraining), predicting masked words (BERT), predicting image patches (MAE). Self-supervised learning enables training on massive unlabeled datasets, which is key to the success of foundation models. The learned representations can then be fine-tuned with small amounts of labeled data for downstream tasks.

RLHF is the technique used to align LLMs with human preferences. Process: (1) Supervised fine-tuning (SFT): fine-tune the base LLM on high-quality demonstrations; (2) Reward modeling: train a reward model on human preference data (pairs of responses ranked by humans); (3) PPO optimization: further fine-tune the LLM using reinforcement learning (PPO algorithm) to maximize the reward model's score, with KL-divergence penalty to prevent the model from deviating too far from the base model. RLHF is core to ChatGPT, Claude, and other instruction-following models.

Hallucination refers to when an LLM generates plausible-sounding but factually incorrect or fabricated information. Causes: LLMs are trained to generate statistically likely text, not to access a truth database; they may "fill in gaps" with confident-sounding falsehoods. Types: Factual hallucination (wrong facts), Intrinsic hallucination (contradicts input), Extrinsic hallucination (introduces unverifiable content). Mitigation: RAG (ground answers in retrieved documents), fine-tuning on domain data, citations/source attribution, temperature reduction, and human oversight.

Accuracy alone is insufficient — it can be misleading for imbalanced datasets. A model predicting "not fraud" 99% of the time on a dataset with 1% fraud has 99% accuracy but is useless. Key metrics by task: Classification: Precision, Recall, F1-Score, ROC-AUC (measures discrimination across all thresholds). Regression: MAE (Mean Absolute Error), RMSE (penalizes large errors), R² (coefficient of determination). Ranking/Recommendation: NDCG, MRR. Generation (NLP): BLEU, ROUGE, METEOR, BERTScore. Always choose metrics aligned with business objectives.

Azure OpenAI Service provides access to OpenAI's powerful models (GPT-4, GPT-3.5, DALL-E, Embeddings, Whisper) through Microsoft Azure's infrastructure. Key benefits: enterprise security (private networking, VNets), compliance (data doesn't train OpenAI's models), Azure Active Directory integration, content filtering, regional deployment. Accessed via REST APIs or SDKs (Python, .NET). Used for: enterprise chatbots, document processing, code generation, semantic search. Azure AI Studio provides a playground and management interface. Combines OpenAI's model capabilities with Azure's enterprise-grade reliability.

Embeddings are dense numerical vector representations of data (text, images, etc.) where semantically similar items have similar vectors. Generated using neural networks (e.g., OpenAI's text-embedding-ada-002, BERT CLS token, sentence-transformers). Applications: (1) Semantic search — find similar documents, (2) RAG — retrieve relevant context for LLMs, (3) Recommendation systems — find similar items/users, (4) Classification — use embeddings as features, (5) Anomaly detection — outliers are far from cluster centers, (6) Deduplication — find near-duplicate content.

Key ethical considerations in AI development and deployment:

• Bias and Fairness: Models trained on biased data perpetuate discrimination (hiring, lending, criminal justice).
• Explainability (XAI): "Black box" models are hard to interpret — critical in healthcare and legal decisions.
• Privacy: Training data may contain personal information; GDPR compliance requires "right to explanation."
• Job displacement: Automation may displace workers — requires workforce re-skilling.
• Misinformation: LLMs can generate convincing false content at scale (deepfakes, fake news).
• Safety and alignment: Ensuring AI systems behave as intended (RLHF, Constitutional AI).
• Environmental impact: Large model training consumes massive amounts of energy.