AI theory, architecture, models

Perform vector and matrix operations relevant to neural network computations

Calculate eigenvalues and eigenvectors and understand their significance in machine learning

Apply matrix decomposition techniques such as SVD and eigendecomposition

Compute partial derivatives and gradients of multivariate functions

Apply the chain rule for differentiating composite functions in the context of backpropagation

Calculate Jacobians and Hessians for advanced optimization

Apply Bayes' theorem to solve problems involving conditional probability

Describe common probability distributions (Gaussian, Bernoulli, Categorical) and their applications

Compute expectations and variances of random variables

Apply the law of large numbers and the central limit theorem to justify statistical methods

Perform maximum likelihood estimation (MLE) and maximum a posteriori (MAP) estimation

Implement gradient descent, stochastic gradient descent (SGD), and mini-batch gradient descent

Apply adaptive learning rate methods including AdaGrad, RMSprop, and Adam

Properly split data into training, validation, and test sets

Implement K-fold cross-validation to assess model generalization

Diagnose and mitigate overfitting and underfitting

Analyze the bias-variance tradeoff in model complexity

Evaluate classification models using metrics such as accuracy, precision, recall, F1-score, and AUC-ROC

Evaluate regression models using metrics like MSE, MAE, and R-squared

Implement linear regression and apply L1/L2 regularization to prevent overfitting

Implement logistic regression for binary classification tasks

Implement Naive Bayes classifiers for probabilistic classification

Apply support vector machines (SVMs) with different kernel methods

Build decision trees using entropy and information gain criteria

Implement the K-nearest neighbors (KNN) algorithm

Explain the principles of ensemble learning, including bagging and boosting

Implement a random forest classifier using bagging

Implement AdaBoost and Gradient Boosting Machines (GBMs) from first principles

Apply high-performance boosting libraries: XGBoost, LightGBM, and CatBoost

Implement K-means clustering and evaluate its performance using the silhouette score

Apply hierarchical clustering with different linkage methods

Implement Principal Component Analysis (PCA) from scratch for dimensionality reduction

Apply t-SNE for high-dimensional data visualization

Implement Gaussian Mixture Models (GMMs) using the Expectation-Maximization (EM) algorithm

Build a multi-layer perceptron (MLP) with forward propagation

Derive and implement the backpropagation algorithm from scratch

Compare properties and use cases of common activation functions (Sigmoid, Tanh, ReLU, Leaky ReLU)

Implement Xavier and He weight initialization strategies to improve convergence

Diagnose and mitigate vanishing and exploding gradients using techniques like gradient clipping

Implement batch normalization and explain its effect on training stability

Apply dropout as a regularization technique to prevent overfitting

Implement early stopping and learning rate scheduling strategies

Implement 2D convolution and pooling operations from scratch

Analyze the concept of receptive fields in CNNs

Build a foundational CNN for an image classification task

Analyze and implement classic CNN architectures: LeNet, VGG, and ResNet (with residual connections)

Implement advanced architectural patterns like Inception modules

Implement efficient convolutions (depthwise separable) and design MobileNet-style architectures

Apply dilated convolutions and squeeze-and-excitation networks for advanced feature extraction

Implement region-based CNNs (R-CNN, Fast R-CNN, Faster R-CNN) for object detection

Implement single-shot detectors (YOLO, SSD) for real-time object detection

Apply non-maximum suppression to refine detection bounding boxes

Implement fully convolutional networks (FCNs) and U-Net for semantic segmentation

Implement Mask R-CNN for instance segmentation

Evaluate object detection and segmentation models using appropriate metrics (mAP, IoU)

Implement a Variational Autoencoder (VAE) using the reparameterization trick

Derive the Evidence Lower Bound (ELBO) objective for VAEs

Build a basic Generative Adversarial Network (GAN) and diagnose common training issues like mode collapse

Implement a Deep Convolutional GAN (DCGAN)

Implement Wasserstein GANs (WGANs) for improved training stability

Implement advanced GAN architectures for controlled and high-fidelity generation (Conditional GANs, StyleGAN)

Implement the forward and reverse processes of Denoising Diffusion Probabilistic Models (DDPM)

Implement a Latent Diffusion Model (LDM) like the one used in Stable Diffusion

Apply classifier-free guidance for conditional image generation

Prepare a custom dataset for fine-tuning a diffusion model

Implement Parameter-Efficient Fine-Tuning (PEFT) for diffusion models using LoRA

Implement DreamBooth for personalizing models with specific subjects or styles

Apply textual inversion to teach new concepts to a model without changing its weights

Use training frameworks like Kohya_ss to fine-tune Stable Diffusion models

Configure hyperparameters and use negative prompts for targeted content generation (SFW and NSFW)

Evaluate the quality of fine-tuned diffusion models and iterate on the training process

Understand content filtering in diffusion models and the methods used to bypass them

Implement a basic Recurrent Neural Network (RNN) cell and apply backpropagation through time (BPTT)

Implement Long Short-Term Memory (LSTM) and Gated Recurrent Unit (GRU) networks to overcome vanishing gradients

Build bidirectional RNNs to process sequence information from both directions

Implement a sequence-to-sequence (seq2seq) model for tasks like machine translation

Implement Bahdanau and Luong attention mechanisms to enhance seq2seq models

Derive and implement scaled dot-product self-attention

Build a multi-head attention layer, the core component of the Transformer

Implement sinusoidal positional encodings for sequence order information

Build a complete Transformer encoder block, including multi-head attention and a position-wise feed-forward network

Build a Transformer decoder block with masked multi-head self-attention

Apply layer normalization and residual connections within the Transformer architecture

Assemble a full encoder-decoder Transformer model from scratch

Train word embeddings using the Word2Vec (Skip-gram) model with negative sampling

Apply tokenization techniques, including Byte-Pair Encoding (BPE) and WordPiece

Explain the masked language modeling (MLM) objective used by BERT

Explain the causal (autoregressive) language modeling objective used by GPT

Fine-tune a pre-trained language model for a downstream text classification task

Understand the principles and benefits of transfer learning in NLP

Analyze the architecture of BERT and its variants (RoBERTa, ALBERT)

Analyze the architecture of GPT models and the role of causal attention

Analyze scaling laws for large language models and their implications

Implement advanced positional embeddings like Rotary Positional Embeddings (RoPE)

Analyze architectural innovations in modern LLMs like LLaMA (e.g., SwiGLU, Grouped-Query Attention)

Understand the Mixture of Experts (MoE) architecture for scaling model capacity

Formulate a problem as a Markov Decision Process (MDP)

Derive and solve the Bellman equations for value functions

Implement value iteration and policy iteration algorithms

Apply model-free prediction methods: Monte Carlo and Temporal Difference (TD) learning

Implement model-free control algorithms: SARSA and Q-Learning

Explain the difference between on-policy and off-policy learning

Implement a Deep Q-Network (DQN) with experience replay and a target network

Implement Double DQN to reduce overestimation bias

Implement the REINFORCE algorithm (a policy gradient method)

Build an Actor-Critic architecture (e.g., A2C)

Implement Proximal Policy Optimization (PPO) with clipping for stable training

Perform supervised fine-tuning (SFT) on a custom instruction dataset

Implement LoRA for parameter-efficient fine-tuning of LLMs

Apply other PEFT techniques like prefix and prompt tuning

Train a reward model to capture human preferences

Implement Reinforcement Learning from Human Feedback (RLHF) using the PPO algorithm

Apply Direct Preference Optimization (DPO) as an alternative to RLHF

Evaluate model alignment using human preference benchmarks

Apply zero-shot and few-shot prompting for in-context learning

Implement Chain-of-Thought (CoT) prompting to improve reasoning

Apply self-consistency to enhance the robustness of CoT reasoning

Engineer effective prompts for specific task optimization

Apply advanced prompting strategies like Tree of Thoughts for complex problem-solving

Implement a dense retrieval system using sentence embeddings and a vector database

Build a complete RAG pipeline that combines retrieval with generation

Implement a cross-encoder model for reranking retrieved documents

Apply contrastive learning to train high-quality sentence embedding models (bi-encoders)

Evaluate RAG systems using retrieval (e.g., recall) and generation metrics

Design a basic agent using a perception-action loop

Implement function calling (tool use) to allow an LLM to interact with external APIs

Implement the ReAct (Reason + Act) prompting framework for agentic behavior

Design and implement basic memory systems for agents

Apply task decomposition and planning for multi-step agent workflows

Implement agent reflection and self-correction mechanisms for improvement

Implement Vision Transformers (ViT) for image classification

Implement CLIP for joint vision-language representation learning

Build an image captioning model using an encoder-decoder architecture

Implement a Visual Question Answering (VQA) model

Process audio signals into spectrograms for deep learning models

Apply the Whisper architecture for robust automatic speech recognition (ASR)

Build a text-to-speech (TTS) system using a deep learning approach

Fine-tune a language model for NSFW or uncensored text generation

Apply jailbreaking techniques to bypass content filters in closed models

Implement a text-to-video generation model using a diffusion-based approach

Fine-tune a video generation model for specialized or NSFW content

Implement temporal consistency techniques to improve video quality

Analyze the ethical and legal considerations surrounding generated media

Apply model quantization techniques (INT8, 4-bit) to reduce model size and VRAM usage

Implement knowledge distillation to transfer knowledge from a large teacher model to a smaller student model

Convert and deploy models in GGUF format for CPU-based inference using llama.cpp

Set up local inference servers using tools like Ollama and text-generation-webui

Apply mixed-precision training and gradient accumulation for training large models on limited hardware

Implement distributed training strategies like Data Parallelism and Pipeline Parallelism

Analyze the architecture of State Space Models like Mamba as an alternative to Transformers

Apply gradient-based attribution methods (saliency maps, Integrated Gradients) for model interpretability

Apply SHAP for model-agnostic explanations

Generate adversarial examples to test model robustness

Implement Graph Neural Networks (GNNs) for learning on graph-structured data

Understand the principles of meta-learning (learning to learn) and implement MAML

Survey emerging architectural paradigms and active areas of AI research