Fundamentals of Large Language Models practice questions

All tokens have the same embedding size.

Why wrong: While all tokens in a given large language model are mapped to embeddings of the same fixed dimension (e.g., 768 or 1024), the phrasing 'same embedding size' could be misinterpreted. The two correct statements are A and E.

Tokens are only used during training.

Why wrong: Incorrect. Tokens are used during both training and inference. During inference, input text is tokenized and processed by the model.

Tokens are always whole words.

Why wrong: Incorrect. Tokens are not always whole words; subword tokenization splits words into smaller units (e.g., 'un' + 'believe' + 'able') to handle rare words and morphology.

Instruct model (e.g., cohere.command)

Why wrong: Instruct models generate responses, not embeddings.

Image generation model

Why wrong: Image models are unrelated to text embeddings.

Base model (e.g., cohere.base)

Why wrong: Base models are not optimized for embeddings.

The embedding vectors will be less accurate for any language.

Why wrong: Embedding quality may suffer for non-English, but not for all languages equally.

The model will hallucinate facts more frequently.

Why wrong: Hallucination is a general issue, not specifically tied to language imbalance.

The context window size will be effectively reduced.

Why wrong: Context window is fixed, not altered by training data composition.

cohere.embed

Why wrong: Embeddings model, not for generating responses.

A model with embeddings capability

Why wrong: Embeddings do not generate text.

cohere.base

Why wrong: Only supports text-generation, not chat-optimized.

The developer does not have permission to use the generative-ai-model-family.

Why wrong: The policy grants 'use' for model-family.

The policy does not allow any operations in the compartment.

Why wrong: It allows create, read, and use.

The compartment name in the policy is incorrect.

Why wrong: Compartment name is specified correctly.

Increase max_new_tokens to 5000 to get a longer response.

Why wrong: Increasing makes the total even larger, exceeding the limit.

Ignore the error and retry the request.

Why wrong: The error will recur because the constraint is not addressed.

Switch to a model in a different region.

Why wrong: Region does not change model context length.

OCI Audit

Why wrong: Audit logs events but does not restrict access.

OCI Vault

Why wrong: Vault is for managing encryption keys and secrets.

Network security groups

Why wrong: NSGs control network-level access, not user-level.

Exceeded token limit

Why wrong: Exceeding token limit may cause a 400 error but with a different message.

Network timeout

Why wrong: Network timeout causes a connection error, not InvalidParameter.

Missing API key

Why wrong: Missing API key results in authentication failure, not InvalidParameter.

Add dropout

Why wrong: Adding dropout is a regularization technique, but reducing model size is also valid. However, option D is more direct.

Increase batch size

Why wrong: Increasing batch size can help generalization but not directly address overfitting.

Increase learning rate

Why wrong: Increasing learning rate may worsen overfitting.

Fine-tuning

Why wrong: Fine-tuning requires more data and computational resources.

Pre-training

Why wrong: Pre-training trains from scratch on large data, not for few-shot adaptation.

Prompt engineering

Why wrong: Prompt engineering is broader; few-shot is a subset but the question asks for a specific technique.

Statement should be 'use' instead of 'read'

Why wrong: 'read' is appropriate for viewing models; 'use' is typically for invoking resources.

Missing 'inspect' permission

Why wrong: The 'read' verb includes inspect, so that is not the issue.

Policy syntax incorrect (missing quotes)

Why wrong: The syntax shown is valid JSON; the issue is the resource type string.

The model is not fine-tuned

Why wrong: Fine-tuning status does not affect endpoint availability.

The compartment OCID is missing

Why wrong: The error message mentions model not found, not authorization.

The model is in a different region

Why wrong: While possible, the error does not indicate region mismatch; 'does not exist' suggests endpoint issue.

The temperature parameter is out of range.

Why wrong: Temperature 0.7 is within valid range (0-2).

The compartment ID is incorrect.

Why wrong: An incorrect compartment ID would produce an authorization error, not 'modelId not found'.

The presencePenalty parameter is misspelled.

Why wrong: The parameter is spelled correctly; a misspelling would cause a different parsing error.

Whether the compartment has sufficient budget.

Why wrong: Budget issues cause quota errors, not invalid parameter errors.

Whether the model ID supports fine-tuning.

Why wrong: Model compatibility issues would result in a different error, not an invalid URI.

Whether the parameters JSON is correctly formatted.

Why wrong: JSON formatting errors would cause parsing errors, not specifically an invalid URI error.

Use a medium-sized model with high precision.

Why wrong: Incorrect: May still be unnecessarily large.

Use an ensemble of models.

Why wrong: Incorrect: Adds complexity and latency.

Use the largest available model for best quality.

Why wrong: Incorrect: Overkill for simple FAQs and slower.

Increase the max tokens parameter.

Why wrong: Incorrect: More tokens increase latency.

Switch to a fine-tuned version of the same model.

Why wrong: Incorrect: Fine-tuning doesn't significantly affect latency.

Enable batched inference.

Why wrong: Incorrect: Batching improves throughput, not per-request latency.

Lower the temperature to 0 to make responses deterministic.

Why wrong: Incorrect: Deterministic responses may still not follow the desired format.

Increase the max tokens to allow longer responses.

Why wrong: Incorrect: Longer responses may include more irrelevant content.

Switch to a different model with better language understanding.

Why wrong: Incorrect: Model change does not guarantee format compliance.

Use mixed precision training (FP16).

Why wrong: Incorrect. Mixed precision training (FP16) can reduce memory usage and speed up training, but it may not be sufficient to resolve OOM if the batch size and sequence length are already near the limit. It is a helpful technique but not the primary fix.

Reduce the model size by using a 3B parameter version.

Why wrong: Incorrect. Reducing model size (e.g., from 7B to 3B parameters) would lower memory requirements, but it is a significant change that alters the model's capacity and may not be necessary if gradient accumulation can solve the issue.

Decrease the number of training epochs.

Why wrong: Incorrect. Decreasing the number of training epochs does not affect the memory usage per step; it only reduces total training time, so OOM errors would still occur.

Using a third-party model via OCI Marketplace

Why wrong: Marketplace models are often hosted outside your tenancy, risking data exposure.

Accessing models through OCI Console only

Why wrong: The console is a UI tool and does not control where inference runs.

Using the OCI GenAI API with the default endpoint

Why wrong: Default endpoints may operate on shared infrastructure where data could cross tenancy boundaries.

Train separate fine-tuned models for each language and route queries based on detected language.

Why wrong: Training separate models per language would prevent any code-switching capability and increase resource usage, contrary to the constraint of limited compute.

Use language detection to route the query to a specific language model, then translate the response.

Why wrong: Routing a code-switched query to a single-language model via language detection fails because the query itself contains multiple languages; the detection system would either pick one language and discard the rest, or misclassify the query, causing the model to ignore the mixed-language structure entirely. This approach is tempting because language detection is a standard preprocessing step for monolingual routing in multilingual systems, and it would be correct if the user queries were purely monolingual and the team could afford separate fine-tuned models per language—but here the model must handle intra-query mixing, which requires a single multilingual model trained on code-switched data.

Use a multilingual embedding model for retrieval to improve context understanding.

Why wrong: Multilingual embeddings improve retrieval but do not address generation fluency for code-switching; they help with understanding but not with generating mixed-language responses.