└── README.md /README.md: -------------------------------------------------------------------------------- 1 | # 63 Must-Know LLMs Interview Questions in 2025 2 | 3 |
4 |

5 | 6 | machine-learning-and-data-science 7 | 8 |

9 | 10 | #### You can also find all 63 answers here 👉 [Devinterview.io - LLMs](https://devinterview.io/questions/machine-learning-and-data-science/llms-interview-questions) 11 | 12 |
13 | 14 | ## 1. What are _Large Language Models (LLMs)_ and how do they work? 15 | 16 | **Large Language Models (LLMs)** are advanced artificial intelligence systems designed to understand, process, and generate human-like text. Examples include **GPT** (Generative Pre-trained Transformer), **BERT** (Bidirectional Encoder Representations from Transformers), **Claude**, and **Llama**. 17 | 18 | These models have revolutionized natural language processing tasks such as translation, summarization, and question-answering. 19 | 20 | ### Core Components and Operation 21 | 22 | #### Transformer Architecture 23 | LLMs are built on the **Transformer architecture**, which uses a network of transformer blocks with **multi-headed self-attention mechanisms**. This allows the model to understand the context of words within a broader text. 24 | 25 | ```python 26 | class TransformerBlock(nn.Module): 27 | def __init__(self, embed_dim, num_heads): 28 | super().__init__() 29 | self.attention = nn.MultiheadAttention(embed_dim, num_heads) 30 | self.feed_forward = nn.Sequential( 31 | nn.Linear(embed_dim, 4 * embed_dim), 32 | nn.ReLU(), 33 | nn.Linear(4 * embed_dim, embed_dim) 34 | ) 35 | self.layer_norm1 = nn.LayerNorm(embed_dim) 36 | self.layer_norm2 = nn.LayerNorm(embed_dim) 37 | 38 | def forward(self, x): 39 | attn_output, _ = self.attention(x, x, x) 40 | x = self.layer_norm1(x + attn_output) 41 | ff_output = self.feed_forward(x) 42 | return self.layer_norm2(x + ff_output) 43 | ``` 44 | 45 | #### Tokenization and Embeddings 46 | LLMs process text by breaking it into **tokens** and converting them into **embeddings** - high-dimensional numerical representations that capture semantic meaning. 47 | 48 | ```python 49 | from transformers import AutoTokenizer, AutoModel 50 | 51 | tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") 52 | model = AutoModel.from_pretrained("bert-base-uncased") 53 | 54 | text = "Hello, how are you?" 55 | inputs = tokenizer(text, return_tensors="pt") 56 | outputs = model(**inputs) 57 | embeddings = outputs.last_hidden_state 58 | ``` 59 | 60 | #### Self-Attention Mechanism 61 | This mechanism allows the model to focus on different parts of the input when processing each token, enabling it to capture complex relationships within the text. 62 | 63 | ### Training Process 64 | 65 | 1. **Unsupervised Pretraining**: The model learns language patterns from vast amounts of unlabeled text data. 66 | 67 | 2. **Fine-Tuning**: The pretrained model is further trained on specific tasks or domains to improve performance. 68 | 69 | 3. **Prompt-Based Learning**: The model learns to generate responses based on specific prompts or instructions. 70 | 71 | 4. **Continual Learning**: Ongoing training to keep the model updated with new information and language trends. 72 | 73 | ### Encoder-Decoder Framework 74 | 75 | Different LLMs use various configurations of the encoder-decoder framework: 76 | 77 | - **GPT** models use a decoder-only architecture for unidirectional processing. 78 | - **BERT** uses an encoder-only architecture for bidirectional understanding. 79 | - **T5** (Text-to-Text Transfer Transformer) uses both encoder and decoder for versatile text processing tasks. 80 |
81 | 82 | ## 2. Describe the architecture of a _transformer model_ that is commonly used in LLMs. 83 | 84 | The **Transformer model** architecture has revolutionized Natural Language Processing (NLP) due to its ability to capture long-range dependencies and outperform previous methods. Its foundation is built on **attention mechanisms**. 85 | 86 | ### Core Components 87 | 88 | 1. **Encoder-Decoder Structure**: The original Transformer featured separate encoders for processing input sequences and decoders for generating outputs. However, variants like GPT (Generative Pre-trained Transformer) use **only the encoder** for tasks such as language modeling. 89 | 90 | 2. **Self-Attention Mechanism**: This allows the model to weigh different parts of the input sequence when processing each element, forming the core of both encoder and decoder. 91 | 92 | ### Model Architecture 93 | 94 | #### Encoder 95 | 96 | The encoder consists of multiple identical layers, each containing: 97 | 98 | 1. **Multi-Head Self-Attention Module** 99 | 2. **Feed-Forward Neural Network** 100 | 101 | ```python 102 | class EncoderLayer(nn.Module): 103 | def __init__(self, d_model, num_heads, d_ff): 104 | super().__init__() 105 | self.self_attn = MultiHeadAttention(d_model, num_heads) 106 | self.feed_forward = FeedForward(d_model, d_ff) 107 | self.norm1 = nn.LayerNorm(d_model) 108 | self.norm2 = nn.LayerNorm(d_model) 109 | 110 | def forward(self, x): 111 | x = x + self.self_attn(self.norm1(x)) 112 | x = x + self.feed_forward(self.norm2(x)) 113 | return x 114 | ``` 115 | 116 | #### Decoder 117 | 118 | The decoder also consists of multiple identical layers, each containing: 119 | 120 | 1. **Masked Multi-Head Self-Attention Module** 121 | 2. **Multi-Head Encoder-Decoder Attention Module** 122 | 3. **Feed-Forward Neural Network** 123 | 124 | #### Positional Encoding 125 | 126 | To incorporate sequence order information, positional encodings are added to the input embeddings: 127 | 128 | ```python 129 | def positional_encoding(max_seq_len, d_model): 130 | pos = np.arange(max_seq_len)[:, np.newaxis] 131 | i = np.arange(d_model)[np.newaxis, :] 132 | angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model)) 133 | angle_rads = pos * angle_rates 134 | 135 | sines = np.sin(angle_rads[:, 0::2]) 136 | cosines = np.cos(angle_rads[:, 1::2]) 137 | 138 | pos_encoding = np.concatenate([sines, cosines], axis=-1) 139 | return torch.FloatTensor(pos_encoding) 140 | ``` 141 | 142 | #### Multi-Head Attention 143 | 144 | The multi-head attention mechanism allows the model to jointly attend to information from different representation subspaces: 145 | 146 | ```python 147 | class MultiHeadAttention(nn.Module): 148 | def __init__(self, d_model, num_heads): 149 | super().__init__() 150 | self.num_heads = num_heads 151 | self.d_model = d_model 152 | assert d_model % num_heads == 0 153 | 154 | self.depth = d_model // num_heads 155 | self.wq = nn.Linear(d_model, d_model) 156 | self.wk = nn.Linear(d_model, d_model) 157 | self.wv = nn.Linear(d_model, d_model) 158 | self.dense = nn.Linear(d_model, d_model) 159 | 160 | def split_heads(self, x, batch_size): 161 | x = x.view(batch_size, -1, self.num_heads, self.depth) 162 | return x.permute(0, 2, 1, 3) 163 | 164 | def forward(self, q, k, v, mask=None): 165 | batch_size = q.size(0) 166 | 167 | q = self.split_heads(self.wq(q), batch_size) 168 | k = self.split_heads(self.wk(k), batch_size) 169 | v = self.split_heads(self.wv(v), batch_size) 170 | 171 | scaled_attention = scaled_dot_product_attention(q, k, v, mask) 172 | concat_attention = scaled_attention.permute(0, 2, 1, 3).contiguous() 173 | concat_attention = concat_attention.view(batch_size, -1, self.d_model) 174 | 175 | return self.dense(concat_attention) 176 | ``` 177 | 178 | #### Feed-Forward Network 179 | 180 | Each encoder and decoder layer includes a fully connected feed-forward network: 181 | 182 | ```python 183 | class FeedForward(nn.Module): 184 | def __init__(self, d_model, d_ff): 185 | super().__init__() 186 | self.linear1 = nn.Linear(d_model, d_ff) 187 | self.linear2 = nn.Linear(d_ff, d_model) 188 | 189 | def forward(self, x): 190 | return self.linear2(F.relu(self.linear1(x))) 191 | ``` 192 | 193 | ### Training Procedure 194 | 195 | - **Encoder-Decoder Models**: Use teacher forcing during training. 196 | - **GPT-style Models**: Employ self-learning schedules with the encoder only. 197 | 198 | ### Advantages 199 | 200 | - **Scalability**: Transformer models can be scaled up to handle word-level or subword-level tokens. 201 | - **Adaptability**: The architecture can accommodate diverse input modalities, including text, images, and audio. 202 | 203 |
204 | 205 | ## 3. What are the main differences between _LLMs_ and traditional _statistical language models_? 206 | 207 | ### Architecture 208 | 209 | - **LLMs**: Based on **transformer** architectures with **self-attention** mechanisms. They can process and understand long-range dependencies in text across vast contexts. 210 | - **Traditional models**: Often use simpler architectures like **N-grams** or **Hidden Markov Models**. They rely on fixed-length contexts and struggle with long-range dependencies. 211 | 212 | ### Scale and Capacity 213 | 214 | - **LLMs**: Typically have **billions of parameters** and are trained on massive datasets, allowing them to capture complex language patterns and generalize to various tasks. 215 | - **Traditional models**: Usually have **fewer parameters** and are trained on smaller, task-specific datasets, limiting their generalization capabilities. 216 | 217 | ### Training Approach 218 | 219 | - **LLMs**: Often use **unsupervised pre-training** on large corpora, followed by fine-tuning for specific tasks. They employ techniques like **masked language modeling** and **next sentence prediction**. 220 | - **Traditional models**: Typically trained in a **supervised manner** on specific tasks, requiring labeled data for each application. 221 | 222 | ### Input Processing 223 | 224 | - **LLMs**: Can handle **variable-length inputs** and process text as sequences of tokens, often using subword tokenization methods like **Byte-Pair Encoding** (BPE) or **SentencePiece**. 225 | - **Traditional models**: Often require **fixed-length inputs** or use simpler tokenization methods like word-level or character-level splitting. 226 | 227 | ### Contextual Understanding 228 | 229 | - **LLMs**: Generate **contextual embeddings** for words, capturing their meaning based on surrounding context. This allows for better handling of polysemy and homonymy. 230 | - **Traditional models**: Often use **static word embeddings** or simpler representations, which may not capture context-dependent meanings effectively. 231 | 232 | ### Multi-task Capabilities 233 | 234 | - **LLMs**: Can be applied to a wide range of **natural language processing tasks** with minimal task-specific fine-tuning, exhibiting strong few-shot and zero-shot learning capabilities. 235 | - **Traditional models**: Usually designed and trained for **specific tasks**, requiring separate models for different applications. 236 | 237 | ### Computational Requirements 238 | 239 | - **LLMs**: Require significant **computational resources** for training and inference, often necessitating specialized hardware like GPUs or TPUs. 240 | - **Traditional models**: Generally have **lower computational demands**, making them more suitable for resource-constrained environments. 241 |
242 | 243 | ## 4. Can you explain the concept of _attention mechanisms_ in transformer models? 244 | 245 | The **Attention Mechanism** is a crucial innovation in transformer models, allowing them to process entire sequences simultaneously. Unlike sequential models like RNNs or LSTMs, transformers can parallelize operations, making them efficient for long sequences. 246 | 247 | ### Core Components of Attention Mechanism 248 | 249 | #### Query, Key, and Value Vectors 250 | - For each word or position, the transformer generates three vectors: **Query**, **Key**, and **Value**. 251 | - These vectors are used in a weighted sum to focus on specific parts of the input sequence. 252 | 253 | #### Attention Scores 254 | - Calculated using the **Dot-Product Method**: multiplying Query and Key vectors, then normalizing through a softmax function. 255 | - The **Scaled Dot-Product Method** adjusts key vectors for better numerical stability: 256 | 257 | $\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$ 258 | 259 | where $d_k$ is the dimension of the key vectors. 260 | 261 | #### Multi-Head Attention 262 | - Allows the model to learn multiple representation subspaces: 263 | - Divides vector spaces into independent subspaces. 264 | - Conducts attention separately over these subspaces. 265 | - Each head provides a weighted sum of word representations, which are then combined. 266 | - Enables the model to focus on different aspects of the input sequence simultaneously. 267 | 268 | #### Positional Encoding 269 | - Adds positional information to the input, as attention mechanisms don't inherently consider sequence order. 270 | - Usually implemented as sinusoidal functions or learned embeddings: 271 | 272 | $$ 273 | PE_{(pos,2i)} = \sin\left(\frac{pos}{10000^{\frac{2i}{d_{\text{model}}}}}\right) 274 | $$ 275 | 276 | $$ 277 | PE_{(pos,2i+1)} = \cos\left(\frac{pos}{10000^{\frac{2i}{d_{\text{model}}}}}\right) 278 | $$ 279 | 280 | ### Transformer Architecture Highlights 281 | 282 | - **Encoder-Decoder Architecture**: Consists of an encoder that processes the input sequence and a decoder that generates the output sequence. 283 | - **Stacked Layers**: Multiple layers of attention and feed-forward networks, allowing for incremental refinement of representations. 284 | 285 | ### Code Example: Multi-Head Attention 286 | 287 | ```python 288 | import tensorflow as tf 289 | 290 | # Input sequence: 10 words, each represented by a 3-dimensional vector 291 | sequence_length, dimension, batch_size = 10, 3, 2 292 | input_sequence = tf.random.normal((batch_size, sequence_length, dimension)) 293 | 294 | # Multi-head attention layer with 2 attention heads 295 | num_attention_heads = 2 296 | multi_head_layer = tf.keras.layers.MultiHeadAttention(num_heads=num_attention_heads, key_dim=dimension) 297 | 298 | # Self-attention: query, key, and value are all derived from the input sequence 299 | output_sequence = multi_head_layer(query=input_sequence, value=input_sequence, key=input_sequence) 300 | 301 | print(output_sequence.shape) # Output: (2, 10, 3) 302 | ``` 303 |
304 | 305 | ## 5. What are _positional encodings_ in the context of LLMs? 306 | 307 | **Positional encodings** are a crucial component in Large Language Models (LLMs) that address the inherent limitation of transformer architectures in capturing sequence information. 308 | 309 | #### Purpose 310 | 311 | Transformer-based models process all tokens simultaneously through self-attention mechanisms, making them position-agnostic. Positional encodings inject position information into the model, enabling it to understand the order of words in a sequence. 312 | 313 | #### Mechanism 314 | 315 | 1. **Additive Approach**: Positional encodings are added to the input word embeddings, combining static word representations with positional information. 316 | 317 | 2. **Sinusoidal Function**: Many LLMs, including the GPT series, use trigonometric functions to generate positional encodings. 318 | 319 | #### Mathematical Formulation 320 | 321 | The positional encoding (PE) for a given position `pos` and dimension `i` is calculated as: 322 | 323 | $$ 324 | PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) 325 | $$ 326 | $$ 327 | PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{\text{model}}}}\right) 328 | $$ 329 | 330 | Where: 331 | - `pos` is the position in the sequence 332 | - `i` is the dimension index (0 ≤ i < d_model/2) 333 | - `d_model` is the dimensionality of the model 334 | 335 | #### Rationale 336 | 337 | - The use of sine and cosine functions allows the model to learn relative positions. 338 | - Different frequency components capture relationships at various scales. 339 | - The constant `10000` prevents function saturation. 340 | 341 | #### Implementation Example 342 | 343 | Here's a Python implementation of positional encoding: 344 | 345 | ```python 346 | import numpy as np 347 | 348 | def positional_encoding(seq_length, d_model): 349 | position = np.arange(seq_length)[:, np.newaxis] 350 | div_term = np.exp(np.arange(0, d_model, 2) * -(np.log(10000.0) / d_model)) 351 | 352 | pe = np.zeros((seq_length, d_model)) 353 | pe[:, 0::2] = np.sin(position * div_term) 354 | pe[:, 1::2] = np.cos(position * div_term) 355 | 356 | return pe 357 | 358 | # Example usage 359 | seq_length, d_model = 100, 512 360 | positional_encodings = positional_encoding(seq_length, d_model) 361 | ``` 362 |
363 | 364 | ## 6. Discuss the significance of _pre-training_ and _fine-tuning_ in the context of LLMs. 365 | 366 | **Pre-training** and **fine-tuning** are important concepts in the development and application of Large Language Models (LLMs). These processes enable LLMs to achieve impressive performance across various Natural Language Processing (NLP) tasks. 367 | 368 | ### Pre-training 369 | 370 | Pre-training is the initial phase of LLM development, characterized by: 371 | 372 | - **Massive Data Ingestion**: LLMs are exposed to enormous amounts of text data, typically hundreds of gigabytes or even terabytes. 373 | 374 | - **Self-supervised Learning**: Models learn from unlabeled data using techniques like: 375 | - Masked Language Modeling (MLM) 376 | - Next Sentence Prediction (NSP) 377 | - Causal Language Modeling (CLM) 378 | 379 | - **General Language Understanding**: Pre-training results in models with broad knowledge of language patterns, semantics, and world knowledge. 380 | 381 | #### Example: GPT-style Pre-training 382 | 383 | ```python 384 | import torch 385 | from transformers import GPT2LMHeadModel, GPT2Tokenizer 386 | 387 | # Load pre-trained GPT-2 model and tokenizer 388 | model = GPT2LMHeadModel.from_pretrained('gpt2') 389 | tokenizer = GPT2Tokenizer.from_pretrained('gpt2') 390 | 391 | # Generate text 392 | prompt = "The future of artificial intelligence is" 393 | input_ids = tokenizer.encode(prompt, return_tensors='pt') 394 | output = model.generate(input_ids, max_length=50, num_return_sequences=1) 395 | 396 | print(tokenizer.decode(output[0], skip_special_tokens=True)) 397 | ``` 398 | 399 | ### Fine-tuning 400 | 401 | Fine-tuning adapts pre-trained models to specific tasks or domains: 402 | 403 | - **Task-specific Adaptation**: Adjusts the model for particular NLP tasks such as: 404 | - Text Classification 405 | - Named Entity Recognition (NER) 406 | - Question Answering 407 | - Summarization 408 | 409 | - **Transfer Learning**: Leverages general knowledge from pre-training to perform well on specific tasks, often with limited labeled data. 410 | 411 | - **Efficiency**: Requires significantly less time and computational resources compared to training from scratch. 412 | 413 | #### Example: Fine-tuning BERT for Text Classification 414 | 415 | ```python 416 | from transformers import BertForSequenceClassification, BertTokenizer, AdamW 417 | from torch.utils.data import DataLoader 418 | 419 | # Load pre-trained BERT model and tokenizer 420 | model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2) 421 | tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') 422 | 423 | # Prepare dataset and dataloader (assuming 'texts' and 'labels' are defined) 424 | dataset = [(tokenizer(text, padding='max_length', truncation=True, max_length=128), label) for text, label in zip(texts, labels)] 425 | dataloader = DataLoader(dataset, batch_size=16, shuffle=True) 426 | 427 | # Fine-tuning loop 428 | optimizer = AdamW(model.parameters(), lr=2e-5) 429 | 430 | for epoch in range(3): 431 | for batch in dataloader: 432 | inputs = {k: v.to(model.device) for k, v in batch[0].items()} 433 | labels = batch[1].to(model.device) 434 | 435 | outputs = model(**inputs, labels=labels) 436 | loss = outputs.loss 437 | 438 | loss.backward() 439 | optimizer.step() 440 | optimizer.zero_grad() 441 | 442 | # Save fine-tuned model 443 | model.save_pretrained('./fine_tuned_bert_classifier') 444 | ``` 445 | 446 | ### Advanced Techniques 447 | 448 | - **Few-shot Learning**: Fine-tuning with a small number of examples, leveraging the model's pre-trained knowledge. 449 | 450 | - **Prompt Engineering**: Crafting effective prompts to guide the model's behavior without extensive fine-tuning. 451 | 452 | - **Continual Learning**: Updating models with new knowledge while retaining previously learned information. 453 |
454 | 455 | ## 7. How do LLMs handle _context_ and _long-term dependencies_ in text? 456 | 457 | The cornerstone of modern LLMs is the **attention mechanism**, which allows the model to focus on different parts of the input when processing each word. This approach significantly improves the handling of **context** and **long-range dependencies**. 458 | 459 | #### Self-Attention 460 | 461 | **Self-attention**, a key component of the Transformer architecture, enables each word in a sequence to attend to all other words, capturing complex relationships: 462 | 463 | ```python 464 | def self_attention(query, key, value): 465 | scores = torch.matmul(query, key.transpose(-2, -1)) 466 | attention_weights = torch.softmax(scores, dim=-1) 467 | return torch.matmul(attention_weights, value) 468 | ``` 469 | 470 | ### Positional Encoding 471 | 472 | To incorporate sequence order information, LLMs use **positional encoding**. This technique adds position-dependent signals to word embeddings: 473 | 474 | ```python 475 | def positional_encoding(seq_len, d_model): 476 | position = torch.arange(seq_len).unsqueeze(1) 477 | div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)) 478 | pos_encoding = torch.zeros(seq_len, d_model) 479 | pos_encoding[:, 0::2] = torch.sin(position * div_term) 480 | pos_encoding[:, 1::2] = torch.cos(position * div_term) 481 | return pos_encoding 482 | ``` 483 | 484 | ### Multi-head Attention 485 | 486 | **Multi-head attention** allows the model to focus on different aspects of the input simultaneously, enhancing its ability to capture diverse contextual information: 487 | 488 | ```python 489 | class MultiHeadAttention(nn.Module): 490 | def __init__(self, d_model, num_heads): 491 | super().__init__() 492 | self.num_heads = num_heads 493 | self.attention = nn.MultiheadAttention(d_model, num_heads) 494 | 495 | def forward(self, query, key, value): 496 | return self.attention(query, key, value) 497 | ``` 498 | 499 | ### Transformer Architecture 500 | 501 | The **Transformer** architecture, which forms the basis of many modern LLMs, effectively processes sequences in parallel, capturing both local and global dependencies: 502 | 503 | #### Encoder-Decoder Structure 504 | 505 | - **Encoder**: Processes the input sequence, capturing contextual information. 506 | - **Decoder**: Generates output based on the encoded information and previously generated tokens. 507 | 508 | ### Advanced LLM Architectures 509 | 510 | #### BERT (Bidirectional Encoder Representations from Transformers) 511 | 512 | BERT uses a bidirectional approach, considering both preceding and succeeding context: 513 | 514 | ```python 515 | class BERT(nn.Module): 516 | def __init__(self, vocab_size, hidden_size, num_layers): 517 | super().__init__() 518 | self.embedding = nn.Embedding(vocab_size, hidden_size) 519 | self.transformer = nn.TransformerEncoder( 520 | nn.TransformerEncoderLayer(hidden_size, nhead=8), 521 | num_layers=num_layers 522 | ) 523 | 524 | def forward(self, x): 525 | x = self.embedding(x) 526 | return self.transformer(x) 527 | ``` 528 | 529 | #### GPT (Generative Pre-trained Transformer) 530 | 531 | GPT models use a unidirectional approach, predicting the next token based on previous tokens: 532 | 533 | ```python 534 | class GPT(nn.Module): 535 | def __init__(self, vocab_size, hidden_size, num_layers): 536 | super().__init__() 537 | self.embedding = nn.Embedding(vocab_size, hidden_size) 538 | self.transformer = nn.TransformerDecoder( 539 | nn.TransformerDecoderLayer(hidden_size, nhead=8), 540 | num_layers=num_layers 541 | ) 542 | 543 | def forward(self, x): 544 | x = self.embedding(x) 545 | return self.transformer(x, x) 546 | ``` 547 | 548 | ### Long-range Dependency Handling 549 | 550 | To handle extremely long sequences, some models employ techniques like: 551 | 552 | - **Sparse Attention**: Focusing on a subset of tokens to reduce computational complexity. 553 | - **Sliding Window Attention**: Attending to a fixed-size window of surrounding tokens. 554 | - **Hierarchical Attention**: Processing text at multiple levels of granularity. 555 |
556 | 557 | ## 8. What is the role of _transformers_ in achieving parallelization in LLMs? 558 | 559 | Transformers play a crucial role in achieving **parallelization** for both inference and training in **Large Language Models** (LLMs). Their architecture enables efficient parallel processing of input sequences, significantly improving computational speed. 560 | 561 | ### Key Components of Transformers 562 | 563 | The Transformer architecture consists of three main components: 564 | 565 | 1. **Input Embeddings** 566 | 2. **Self-Attention Mechanism** 567 | 3. **Feed-Forward Neural Networks** 568 | 569 | The **self-attention mechanism** is particularly important for parallelization, as it allows each token in a sequence to attend to all other tokens simultaneously. 570 | 571 | ### Parallelization through Self-Attention 572 | 573 | The self-attention process involves two main steps: 574 | 575 | 1. **QKV (Query, Key, Value) Computation** 576 | 2. **Weighted Sum Calculation** 577 | 578 | Without parallelization, these steps can become computational bottlenecks. However, Transformers enable efficient parallel processing through matrix operations. 579 | 580 | #### Example of Parallelized Attention Computation: 581 | 582 | ```python 583 | import torch 584 | 585 | def parallel_self_attention(Q, K, V): 586 | # Compute attention scores 587 | attention_scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(K.size(-1))) 588 | 589 | # Apply softmax 590 | attention_weights = torch.softmax(attention_scores, dim=-1) 591 | 592 | # Compute output 593 | output = torch.matmul(attention_weights, V) 594 | 595 | return output 596 | 597 | # Assume batch_size=32, num_heads=8, seq_length=512, d_k=64 598 | Q = torch.randn(32, 8, 512, 64) 599 | K = torch.randn(32, 8, 512, 64) 600 | V = torch.randn(32, 8, 512, 64) 601 | 602 | parallel_output = parallel_self_attention(Q, K, V) 603 | ``` 604 | 605 | This example demonstrates how self-attention can be computed in parallel across multiple dimensions (batch, heads, and sequence length) using matrix operations. 606 | 607 | ### Accelerating Computations 608 | 609 | To further speed up computations, LLMs leverage: 610 | 611 | - **Matrix Operations**: Expressing multiple operations in matrix notation for concurrent execution. 612 | - **Optimized Libraries**: Utilizing high-performance libraries like **cuBLAS**, **cuDNN**, and **TensorRT** for maximum parallelism on GPUs. 613 | 614 | ### Balancing Parallelism and Dependencies 615 | 616 | While parallelism offers significant speed improvements, it also introduces challenges related to **learning dependencies** and **resource allocation**. To address these issues, LLMs employ several techniques: 617 | 618 | 1. **Bucketing**: Grouping inputs of similar sizes for efficient parallel processing. 619 | 2. **Attention Masking**: Controlling which tokens attend to each other, enabling selective parallelism. 620 | 3. **Layer Normalization**: Bridging computational steps to mitigate the impact of parallelism on learned representations. 621 | 622 | #### Example of Attention Masking: 623 | 624 | ```python 625 | import torch 626 | 627 | def masked_self_attention(Q, K, V, mask): 628 | attention_scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(K.size(-1))) 629 | 630 | # Apply mask 631 | attention_scores = attention_scores.masked_fill(mask == 0, float('-inf')) 632 | 633 | attention_weights = torch.softmax(attention_scores, dim=-1) 634 | output = torch.matmul(attention_weights, V) 635 | 636 | return output 637 | 638 | # Create a simple causal mask for a sequence of length 4 639 | mask = torch.tril(torch.ones(4, 4)) 640 | 641 | Q = torch.randn(1, 1, 4, 64) 642 | K = torch.randn(1, 1, 4, 64) 643 | V = torch.randn(1, 1, 4, 64) 644 | 645 | masked_output = masked_self_attention(Q, K, V, mask) 646 | ``` 647 |
648 | 649 | ## 9. What are some prominent _applications_ of LLMs today? 650 | 651 | Large Language Models (LLMs) have revolutionized various industries with their versatile capabilities. Here are some of the most notable applications: 652 | 653 | 1. **Natural Language Processing (NLP) Tasks** 654 | - **Text Generation**: LLMs excel at producing human-like text, powering applications like: 655 | - **Sentiment Analysis**: Determining the emotional tone of text. 656 | - **Named Entity Recognition (NER)**: Identifying and classifying entities in text. 657 | 658 | 2. **Content Creation and Manipulation** 659 | - **Text Summarization**: Condensing long documents into concise summaries. 660 | - **Content Expansion**: Elaborating on brief ideas or outlines. 661 | - **Style Transfer**: Rewriting text in different styles or tones. 662 | 663 | 3. **Language Translation** 664 | - Translating text between multiple languages with high accuracy. 665 | - Supporting real-time translation in communication apps. 666 | 667 | 4. **Conversational AI** 668 | - **Chatbots**: Powering customer service bots and virtual assistants. 669 | - **Question-Answering Systems**: Providing accurate responses to user queries. 670 | 671 | 5. **Code Generation and Analysis** 672 | - Generating code snippets based on natural language descriptions. 673 | - Assisting in code review and bug detection. 674 | 675 | 6. **Educational Tools** 676 | - **Personalized Learning**: Adapting content to individual student needs. 677 | - **Automated Grading**: Assessing written responses and providing feedback. 678 | 679 | 7. **Healthcare Applications** 680 | - **Medical Record Analysis**: Extracting insights from patient records. 681 | - **Drug Discovery**: Assisting in the identification of potential drug candidates. 682 | 683 | 8. **Financial Services** 684 | - **Market Analysis**: Generating reports and insights from financial data. 685 | - **Fraud Detection**: Identifying unusual patterns in transactions. 686 | 687 | 9. **Creative Writing Assistance** 688 | - **Story Generation**: Creating plot outlines or entire narratives. 689 | - **Poetry Composition**: Generating verses in various styles. 690 | 691 | 10. **Research and Data Analysis** 692 | - **Literature Review**: Summarizing and synthesizing academic papers. 693 | - **Trend Analysis**: Identifying patterns in large datasets. 694 | 695 | 11. **Accessibility Tools** 696 | - **Text-to-Speech**: Converting written text to natural-sounding speech. 697 | - **Speech Recognition**: Transcribing spoken words to text. 698 | 699 | 12. **Legal and Compliance** 700 | - **Contract Analysis**: Reviewing and summarizing legal documents. 701 | - **Regulatory Compliance**: Ensuring adherence to legal standards. 702 |
703 | 704 | ## 10. How is _GPT-4_ different from its predecessors like _GPT-3_ in terms of capabilities and applications? 705 | 706 | ### Key Distinctions between GPT-4 and Its Predecessors 707 | 708 | #### Scale and Architecture 709 | 710 | - **GPT-3**: Released in 2020, it had 175 billion parameters, setting a new standard for large language models. 711 | 712 | - **GPT-4**: While the exact parameter count is undisclosed, it's believed to be significantly larger than GPT-3, potentially in the trillions. It also utilizes a more advanced neural network architecture. 713 | 714 | #### Training Methodology 715 | 716 | - **GPT-3**: Trained primarily on text data using unsupervised learning. 717 | 718 | - **GPT-4**: Incorporates multimodal training, including text and images, allowing it to understand and generate content based on visual inputs. 719 | 720 | #### Performance and Capabilities 721 | 722 | - **GPT-3**: Demonstrated impressive natural language understanding and generation capabilities. 723 | 724 | - **GPT-4**: Shows substantial improvements in: 725 | - **Reasoning**: Better at complex problem-solving and logical deduction. 726 | - **Consistency**: Maintains coherence over longer conversations and tasks. 727 | - **Factual Accuracy**: Reduced hallucinations and improved factual reliability. 728 | - **Multilingual Proficiency**: Enhanced performance across various languages. 729 | 730 | #### Practical Applications 731 | 732 | - **GPT-3**: Widely used in chatbots, content generation, and code assistance. 733 | 734 | - **GPT-4**: Expands applications to include: 735 | - **Advanced Analytics**: Better at interpreting complex data and providing insights. 736 | - **Creative Tasks**: Improved ability in tasks like story writing and poetry composition. 737 | - **Visual Understanding**: Can analyze and describe images, useful for accessibility tools. 738 | - **Ethical Decision Making**: Improved understanding of nuanced ethical scenarios. 739 | 740 | #### Ethical Considerations and Safety 741 | 742 | - **GPT-3**: Raised concerns about bias and potential misuse. 743 | 744 | - **GPT-4**: Incorporates more advanced safety measures: 745 | - **Improved Content Filtering**: Better at avoiding inappropriate or harmful outputs. 746 | - **Enhanced Bias Mitigation**: Efforts to reduce various forms of bias in responses. 747 | 748 | #### Code Generation and Understanding 749 | 750 | - **GPT-3**: Capable of generating simple code snippets and explanations. 751 | 752 | - **GPT-4**: Significantly improved code generation and understanding: 753 | 754 | #### Contextual Understanding 755 | 756 | - **GPT-3**: Good at maintaining context within a single prompt. 757 | 758 | - **GPT-4**: Demonstrates superior ability to maintain context over longer conversations and across multiple turns of dialogue. 759 |
760 | 761 | ## 11. Can you mention any domain-specific adaptations of LLMs? 762 | 763 | **LLMs** have demonstrated remarkable adaptability across various domains, leading to the development of specialized models tailored for specific industries and tasks. Here are some notable domain-specific adaptations of LLMs: 764 | 765 | ### Healthcare and Biomedical 766 | 767 | - **Medical Diagnosis**: LLMs trained on vast medical literature can assist in diagnosing complex conditions. 768 | - **Drug Discovery**: Models like **MolFormer** use natural language processing techniques to predict molecular properties and accelerate drug development. 769 | - **Biomedical Literature Analysis**: LLMs can summarize research papers and extract key findings from vast biomedical databases. 770 | 771 | ### Legal 772 | 773 | - **Contract Analysis**: Specialized models can review legal documents, identify potential issues, and suggest modifications. 774 | - **Case Law Research**: LLMs trained on legal precedents can assist lawyers in finding relevant cases and statutes. 775 | 776 | ### Finance 777 | 778 | - **Market Analysis**: Models like **FinBERT** are fine-tuned on financial texts to perform sentiment analysis on market reports and news. 779 | - **Fraud Detection**: LLMs can analyze transaction patterns and identify potential fraudulent activities. 780 | 781 | ### Education 782 | 783 | - **Personalized Learning**: LLMs can adapt educational content based on a student's learning style and progress. 784 | - **Automated Grading**: Models can assess essays and provide detailed feedback on writing style and content. 785 | 786 | ### Environmental Science 787 | 788 | - **Climate Modeling**: LLMs can process and analyze vast amounts of climate data to improve predictions and understand long-term trends. 789 | - **Biodiversity Research**: Specialized models can assist in species identification and ecosystem analysis from textual descriptions and images. 790 | 791 | ### Manufacturing and Engineering 792 | 793 | - **Design Optimization**: LLMs can suggest improvements to product designs based on specifications and historical data. 794 | - **Predictive Maintenance**: Models can analyze sensor data and maintenance logs to predict equipment failures. 795 | 796 | ### Linguistics and Translation 797 | 798 | - **Low-Resource Language Translation**: Adaptations like **mT5** focus on improving translation quality for languages with limited training data. 799 | - **Code Translation**: Models like **CodeT5** specialize in translating between different programming languages. 800 | 801 | ### Cybersecurity 802 | 803 | - **Threat Detection**: LLMs can analyze network logs and identify potential security breaches or unusual patterns. 804 | - **Vulnerability Analysis**: Specialized models can review code and identify potential security vulnerabilities. 805 |
806 | 807 | ## 12. How do LLMs contribute to the field of _sentiment analysis_? 808 | 809 | **Large Language Models (LLMs)** have significantly advanced the field of sentiment analysis, offering powerful capabilities for understanding and classifying emotions in text. 810 | 811 | ### Key Contributions 812 | 813 | LLMs contribute to sentiment analysis in several important ways: 814 | 815 | 1. **Contextual Understanding**: LLMs excel at capturing long-range dependencies and context, enabling more accurate interpretation of complex sentiments. 816 | 817 | 2. **Transfer Learning**: Pre-trained LLMs can be fine-tuned for sentiment analysis tasks, leveraging their broad language understanding for specific domains. 818 | 819 | 3. **Handling Nuance**: LLMs can better grasp subtle emotional cues, sarcasm, and implicit sentiments that traditional methods might miss. 820 | 821 | 4. **Multilingual Capability**: Many LLMs are trained on diverse languages, facilitating sentiment analysis across different linguistic contexts. 822 | 823 | ### Advantages in Sentiment Analysis 824 | 825 | #### Nuanced Comprehension 826 | LLMs consider bidirectional context, allowing for more accurate interpretation of: 827 | - Complex emotions 828 | - Idiomatic expressions 829 | - Figurative language 830 | 831 | #### Disambiguation and Negation 832 | LLMs effectively handle: 833 | - Negation (e.g., "not bad" as positive) 834 | - Ambiguous terms (e.g., "sick" as good or ill) 835 | 836 | #### Contextual Relevance 837 | LLMs excel in: 838 | - Cross-sentence sentiment analysis 839 | - Document-level sentiment understanding 840 | 841 | ### Code Example: BERT for Sentiment Analysis 842 | 843 | ```python 844 | from transformers import AutoTokenizer, AutoModelForSequenceClassification 845 | import torch 846 | 847 | # Load pre-trained BERT model and tokenizer 848 | model_name = "nlptown/bert-base-multilingual-uncased-sentiment" 849 | tokenizer = AutoTokenizer.from_pretrained(model_name) 850 | model = AutoModelForSequenceClassification.from_pretrained(model_name) 851 | 852 | # Prepare input text 853 | text = "The movie was not as good as I expected, quite disappointing." 854 | inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True) 855 | 856 | # Perform sentiment analysis 857 | with torch.no_grad(): 858 | outputs = model(**inputs) 859 | predicted_class = torch.argmax(outputs.logits, dim=1) 860 | 861 | # Map class to sentiment 862 | sentiment_map = {0: "Very Negative", 1: "Negative", 2: "Neutral", 3: "Positive", 4: "Very Positive"} 863 | predicted_sentiment = sentiment_map[predicted_class.item()] 864 | 865 | print(f"Predicted Sentiment: {predicted_sentiment}") 866 | ``` 867 |
868 | 869 | ## 13. Describe how LLMs can be used in the _generation of synthetic text_. 870 | 871 | **Large Language Models** (LLMs) are powerful tools for generating **coherent, context-aware synthetic text**. Their applications span from chatbots and virtual assistants to content creation and automated writing systems. 872 | 873 | Modern Transformer-based LLMs have revolutionized text generation techniques, enabling **dynamic text synthesis** with high fidelity and contextual understanding. 874 | 875 | ### Techniques for Text Generation 876 | 877 | #### Beam Search 878 | 879 | - **Method**: Selects the most probable word at each step, maintaining a pool of top-scoring sequences. 880 | - **Advantages**: Simple implementation, robust against local optima. 881 | - **Drawbacks**: Can produce repetitive or generic text. 882 | 883 | ```python 884 | def beam_search(model, start_token, beam_width=3, max_length=50): 885 | sequences = [[start_token]] 886 | for _ in range(max_length): 887 | candidates = [] 888 | for seq in sequences: 889 | next_token_probs = model.predict_next_token(seq) 890 | top_k = next_token_probs.argsort()[-beam_width:] 891 | for token in top_k: 892 | candidates.append(seq + [token]) 893 | sequences = sorted(candidates, key=lambda x: model.sequence_probability(x))[-beam_width:] 894 | return sequences[0] 895 | ``` 896 | 897 | #### Diverse Beam Search 898 | 899 | - **Method**: Extends beam search by incorporating diversity metrics to favor unique words. 900 | - **Advantages**: Reduces repetition in generated text. 901 | - **Drawbacks**: Increased complexity and potential for longer execution times. 902 | 903 | #### Top-k and Nucleus (Top-p) Sampling 904 | 905 | - **Method**: Randomly samples from the top k words or the nucleus (cumulative probability distribution). 906 | - **Advantages**: Enhances novelty and diversity in generated text. 907 | - **Drawbacks**: May occasionally produce incoherent text. 908 | 909 | ```python 910 | def top_k_sampling(model, start_token, k=10, max_length=50): 911 | sequence = [start_token] 912 | for _ in range(max_length): 913 | next_token_probs = model.predict_next_token(sequence) 914 | top_k_probs = np.partition(next_token_probs, -k)[-k:] 915 | top_k_indices = np.argpartition(next_token_probs, -k)[-k:] 916 | next_token = np.random.choice(top_k_indices, p=top_k_probs/sum(top_k_probs)) 917 | sequence.append(next_token) 918 | return sequence 919 | ``` 920 | 921 | #### Stochastic Beam Search 922 | 923 | - **Method**: Incorporates randomness into the beam search process at each step. 924 | - **Advantages**: Balances structure preservation with randomness. 925 | - **Drawbacks**: May occasionally generate less coherent text. 926 | 927 | #### Text Length Control 928 | 929 | - **Method**: Utilizes a score-based approach to regulate the length of generated text. 930 | - **Advantages**: Useful for tasks requiring specific text lengths. 931 | - **Drawbacks**: May not always achieve the exact desired length. 932 | 933 | #### Noisy Channel Modeling 934 | 935 | - **Method**: Introduces noise in input sequences and leverages the model's language understanding to reconstruct the original sequence. 936 | - **Advantages**: Enhances privacy for input sequences without compromising output quality. 937 | - **Drawbacks**: Requires a large, clean dataset for effective training. 938 | 939 | ```python 940 | def noisy_channel_generation(model, input_sequence, noise_level=0.1): 941 | noisy_input = add_noise(input_sequence, noise_level) 942 | return model.generate(noisy_input) 943 | 944 | def add_noise(sequence, noise_level): 945 | return [token if random.random() > noise_level else random_token() for token in sequence] 946 | ``` 947 |
948 | 949 | ## 14. In what ways can LLMs be utilized for _language translation_? 950 | 951 | Here are key ways **LLMs** can be utilized for translation tasks: 952 | 953 | #### 1. Zero-shot Translation 954 | 955 | LLMs can perform translations without specific training on translation pairs, utilizing their broad language understanding. 956 | 957 | ```python 958 | # Example using a hypothetical LLM API 959 | def zero_shot_translate(text, target_language): 960 | prompt = f"Translate the following text to {target_language}: '{text}'" 961 | return llm.generate(prompt) 962 | ``` 963 | 964 | #### 2. Few-shot Learning 965 | 966 | By providing a few examples, LLMs can quickly adapt to specific translation styles or domains. 967 | 968 | ```python 969 | few_shot_prompt = """ 970 | English: Hello, how are you? 971 | French: Bonjour, comment allez-vous ? 972 | 973 | English: The weather is nice today. 974 | French: Le temps est beau aujourd'hui. 975 | 976 | English: {input_text} 977 | French:""" 978 | 979 | translated_text = llm.generate(few_shot_prompt.format(input_text=user_input)) 980 | ``` 981 | 982 | #### 3. Multilingual Translation 983 | 984 | LLMs can translate between multiple language pairs without the need for separate models for each pair. 985 | 986 | #### 4. Context-aware Translation 987 | 988 | LLMs consider broader context, improving translation quality for ambiguous terms or idiomatic expressions. 989 | 990 | ```python 991 | context_prompt = f""" 992 | Context: In a business meeting discussing quarterly results. 993 | Translate: "Our figures are in the black this quarter." 994 | Target Language: Spanish 995 | """ 996 | contextual_translation = llm.generate(context_prompt) 997 | ``` 998 | 999 | #### 5. Style-preserving Translation 1000 | 1001 | LLMs can maintain the tone, formality, and style of the original text in the translated version. 1002 | 1003 | #### 6. Handling Low-resource Languages 1004 | 1005 | LLMs can leverage cross-lingual transfer to translate to and from languages with limited training data. 1006 | 1007 | #### 7. Real-time Translation 1008 | 1009 | With optimized inference, LLMs can be used for near real-time translation in applications like chat or subtitling. 1010 | 1011 | #### 8. Translation Explanation 1012 | 1013 | LLMs can provide explanations for their translations, helping users understand nuances and choices made during the translation process. 1014 | 1015 | ```python 1016 | explanation_prompt = """ 1017 | Translate the following English idiom to French and explain your translation: 1018 | "It's raining cats and dogs." 1019 | """ 1020 | translation_with_explanation = llm.generate(explanation_prompt) 1021 | ``` 1022 | 1023 | #### 9. Specialized Domain Translation 1024 | 1025 | LLMs can be fine-tuned on domain-specific corpora to excel in translating technical, medical, or legal texts. 1026 | 1027 | #### 10. Translation Quality Assessment 1028 | 1029 | LLMs can be used to evaluate and score translations, providing feedback on fluency and adequacy. 1030 |
1031 | 1032 | ## 15. Discuss the _application_ of LLMs in _conversation AI_ and _chatbots_. 1033 | 1034 | **Large Language Models** (LLMs) have revolutionized the field of conversation AI, making chatbots more sophisticated and responsive. These models incorporate context, intent recognition, and semantic understanding, leading to more engaging and accurate interactions. 1035 | 1036 | ### Key Components for LLM-powered Chatbots 1037 | 1038 | 1. **Intent Recognition**: LLMs analyze user queries to identify the underlying intent or purpose. This enables chatbots to provide more relevant and accurate responses. Models like BERT or RoBERTa can be fine-tuned for intent classification tasks. 1039 | 1040 | 2. **Named Entity Recognition (NER)**: LLMs excel at identifying specific entities (e.g., names, locations, dates) in user input, allowing for more tailored responses. Custom models built on top of LLMs can be particularly effective for domain-specific NER tasks. 1041 | 1042 | 3. **Coreference Resolution**: LLMs can recognize and resolve pronoun antecedents, enhancing the chatbot's ability to maintain consistent context throughout a conversation. 1043 | 1044 | 4. **Natural Language Generation (NLG)**: LLMs generate human-like text, enabling chatbots to provide coherent and contextually appropriate responses, making interactions feel more natural. 1045 | 1046 | ### Fine-Tuning LLMs for Chatbots 1047 | 1048 | To optimize LLMs for specific chatbot applications, they typically undergo: 1049 | 1050 | #### Transfer Learning 1051 | - A pre-trained LLM (e.g., GPT-3, GPT-4, or BERT) serves as a base model, leveraging its knowledge gained from vast amounts of general textual data. 1052 | 1053 | #### Fine-Tuning 1054 | - The base model is then fine-tuned on a more focused dataset related to the specific chatbot function or industry (e.g., customer support, healthcare). 1055 | 1056 | ### Code Example: Intent Classification with BERT 1057 | 1058 | Here's a Python example using the `transformers` library to perform intent classification: 1059 | 1060 | ```python 1061 | from transformers import AutoModelForSequenceClassification, AutoTokenizer 1062 | import torch 1063 | 1064 | # Load pre-trained model and tokenizer 1065 | model_name = "bert-base-uncased" 1066 | model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2) 1067 | tokenizer = AutoTokenizer.from_pretrained(model_name) 1068 | 1069 | def classify_intent(user_input): 1070 | # Tokenize the input 1071 | inputs = tokenizer(user_input, return_tensors="pt", truncation=True, padding=True) 1072 | 1073 | # Predict the intent 1074 | with torch.no_grad(): 1075 | outputs = model(**inputs) 1076 | 1077 | logits = outputs.logits 1078 | intent_id = torch.argmax(logits, dim=1).item() 1079 | 1080 | # Map the intent ID to a human-readable label 1081 | intent_label = ['Negative', 'Positive'][intent_id] 1082 | return intent_label 1083 | 1084 | # Test the function 1085 | user_input = "I love this product!" 1086 | print(classify_intent(user_input)) # Output: "Positive" 1087 | ``` 1088 | 1089 | ### Recent Advancements 1090 | 1091 | 1. **Few-shot Learning**: Modern LLMs like GPT-4 can perform tasks with minimal examples, reducing the need for extensive fine-tuning. 1092 | 1093 | 2. **Multilingual Models**: LLMs like XLM-RoBERTa enable chatbots to operate across multiple languages without separate models for each language. 1094 | 1095 | 3. **Retrieval-Augmented Generation (RAG)**: This technique combines LLMs with external knowledge bases, allowing chatbots to access and utilize up-to-date information beyond their training data. 1096 | 1097 | 4. **Prompt Engineering**: Sophisticated prompt design techniques help guide LLMs to produce more accurate and contextually appropriate responses in chatbot applications. 1098 |
1099 | 1100 | 1101 | 1102 | #### Explore all 63 answers here 👉 [Devinterview.io - LLMs](https://devinterview.io/questions/machine-learning-and-data-science/llms-interview-questions) 1103 | 1104 |
1105 | 1106 | 1107 | machine-learning-and-data-science 1108 | 1109 |

1110 | 1111 | --------------------------------------------------------------------------------