Path & PassCertification practice
AIF-C01

AWS Certified AI Practitioner (AIF-C01)

Study another certification
Progress0%
Recent accuracy0%
Review due0questions
Answered0 / 550questions

Practice by topic

1 AI and ML fundamentalsAI, machine learning, deep learning, use cases, and development lifecycles.102questionsHigh
2 Generative AI fundamentalsGenerative AI, foundation models, RAG, prompting, and AWS generative AI services.103questionsHigh
3 Foundation model applicationsFoundation model design, prompting, adaptation, and evaluation.147questionsHigh
4 Responsible AIFairness, transparency, explainability, and safety.82questionsHigh
5 Security, compliance, and governance for AI systemsProtecting, auditing, governing, and assessing AI systems.116questionsHigh
5 areas / 14 objectives selected550questionseligible

Learning modes

Mock examPractice with exam-style timing and length

Browse questions by objective

Choose a topic to read an individual question, its hints, and explanations. No session setup is required.

1.1 Explain basic AI concepts and terminology21 questions
  1. Distinguishing AI and machine learning
  2. Distinguishing supervised and unsupervised learning
  3. Distinguishing training and inference
  4. Distinguishing classification and regression
  5. Understanding reinforcement learning
  6. Organizing AI and machine-learning terms
  7. Matching learning methods to goals
  8. Choosing predictive and generative models
  9. Separate request intent from named entities
  10. Distinguish image labels from object locations
  11. Use output meaning to distinguish classification, regression and generation
  12. Separate known intent classes from discovery of unknown groups
  13. Distinguish transcription from speaker diarization
  14. Separate OCR text locations from invoice validation
  15. Separate model training from inference with a fixed model
  16. Check transfer-learning reuse and target-task evaluation
  17. Separating regression and classification
  18. Separating supervised and unsupervised learning
  19. Understanding reinforcement learning
  20. Understanding ensembles
  21. Building an anomaly baseline
1.2 Identify practical use cases for AI32 questions
  1. Choosing classification or regression
  2. Selecting a generative AI business use case
  3. Identifying an anomaly-detection use case
  4. Selecting a recommendation use case
  5. Selecting a demand-forecasting use case
  6. Using NLP to route and analyze call transcripts
  7. Selecting a computer-vision use case
  8. Selecting anomaly detection
  9. Communicating forecast uncertainty
  10. Choose fixed-rule automation or machine learning for the requirement
  11. Separating drift from data quality
  12. Preventing evaluation leakage
  13. Evaluating imbalanced classes
  14. Keeping feature scaling consistent
  15. Setting a drift baseline
  16. Managing missing values
  17. Aligning label definitions
  18. Detecting feature drift
  19. Separating train and test data
  20. Finding target leakage
  21. Reducing overfitting
  22. Choosing metrics for imbalanced data
  23. Managing cross-validation splits
  24. Scaling features
  25. Using dimensionality reduction
  26. Tuning a classification threshold
  27. Validating synthetic data
  28. Auditing label quality
  29. Handling missing values
  30. Using stratified sampling
  31. Recognizing concept drift
  32. Handling out-of-distribution inputs
1.3 Describe the AI/ML development lifecycle49 questions
  1. Organizing the machine learning lifecycle
  2. Selecting production model-monitoring signals
  3. Assessing the impact of missing labels
  4. Separating evaluation data from training
  5. Detecting model drift
  6. Recognizing overfitting
  7. Keeping feature preprocessing consistent
  8. Choosing metrics for the business objective
  9. Preventing data leakage
  10. Splitting time-series data
  11. Detecting data drift
  12. Separating features and labels
  13. Separating evaluation data
  14. Preventing cross-validation leakage
  15. Evaluating class imbalance
  16. Choosing a missing-value policy
  17. Calibrating prediction probabilities
  18. Responding to concept drift
  19. Using stratified splits
  20. Handling outliers
  21. Evaluating hyperparameter search
  22. Choosing a learning method
  23. Preventing data leakage
  24. Separating dataset roles
  25. Recognizing reinforcement learning
  26. Using embedding similarity
  27. Managing a model lifecycle
  28. Handling missing values
  29. Evaluating data augmentation
  30. Scheduling retraining
  31. Creating features
  32. Matching metrics to business cost
  33. Managing model approval
  34. Gating model CI/CD
  35. Using a shadow deployment
  36. Designing a canary deployment
  37. Reproducing a model build
  38. Tracking experiments
  39. Defining rollback triggers
  40. Using active learning
  41. Handling experiment variation
  42. Tracking data lineage
  43. Choosing transfer learning
  44. Choosing batch or online inference
  45. Comparing throughput and latency
  46. Recording dataset provenance
  47. Making inference retries idempotent
  48. Checkpointing long AI jobs
  49. Excluding expired training data
2.1 Explain basic AI concepts and terminology44 questions
  1. Understanding foundation models
  2. Choosing the purpose of RAG
  3. Improving a prompt with specificity
  4. Distinguishing generation from classification
  5. Selecting benefits of foundation models
  6. Choosing a purpose for chunking
  7. Understanding multimodal models
  8. Recognizing generative-AI limitations
  9. Understanding Transformer attention
  10. Using embeddings for similarity
  11. Understanding foundation-model pretraining
  12. Understanding temperature
  13. Understanding diffusion models
  14. Distinguishing parameters and context
  15. Understanding encoder-decoder models
  16. Balancing embedding dimensions
  17. Understanding transfer learning
  18. Distinguishing token and document embeddings
  19. Choosing a multimodal model
  20. Separate characters, input tokens and output budgets
  21. Understanding attention
  22. Explaining diffusion generation
  23. Connecting generative AI applications to external tools
  24. Distinguishing pretraining and inference
  25. Using human preference feedback
  26. Managing a context limit
  27. Handling a knowledge cutoff
  28. Selecting a model by modality
  29. Evaluating quantization trade-offs
  30. Choosing adaptation methods
  31. Evaluating tokenization
  32. Choosing generation parameters
  33. Separate short-term memory, long-term memory and business knowledge
  34. Choosing a context window
  35. Selecting few-shot examples
  36. Handling multimodal limits
  37. Choosing coordination and result flow for multiple agents
  38. Managing model quotas
  39. Selecting a foundation model
  40. Handle the delay before long-term memory becomes available
  41. Aligning multimodal inputs
  42. Managing a token budget
  43. Checking provider data use
  44. Building a model selection matrix
2.3 Describe AWS infrastructure and technologies for building GenAI applications31 questions
  1. Choosing between Bedrock and SageMaker AI
  2. Understanding Knowledge Bases
  3. Understanding agent tool use
  4. Using prompt chaining
  5. Separating user input from trusted instructions
  6. Specifying an output schema
  7. Using few-shot examples
  8. Separating system instructions and user input
  9. Evaluating a prompt change
  10. Handling reasoning information safely
  11. Using message roles
  12. Validating prompt input
  13. Handling template variables safely
  14. Minimizing conversation memory
  15. Splitting a prompt workflow
  16. Reducing hallucinations
  17. Choosing generation parameters
  18. Approving tool execution
  19. Preventing output injection
  20. Validating tool arguments
  21. Ordering prompt constraints
  22. Tuning content-filter thresholds
  23. Budgeting prompt length
  24. Designing a safe refusal
  25. Separating instruction trust
  26. Understanding temperature
  27. Managing the context window
  28. Making generation reproducible
  29. Designing few-shot examples
  30. Using top-k and top-p
  31. Designing stop conditions
3.2 Choose effective prompt engineering techniques29 questions
  1. Requesting constrained structured output
  2. Adding role and constraints to a prompt
  3. Designing grounded RAG answers
  4. Filtering vector search by metadata
  5. Updating a RAG index
  6. Designing RAG chunk boundaries
  7. Combining keyword and vector search
  8. Measuring RAG retrieval quality
  9. Maintaining RAG permission boundaries
  10. Managing RAG freshness
  11. Improving a search query
  12. Pin a prompt version for production
  13. Considering RAG reranking
  14. Compressing retrieved context
  15. Evaluating hybrid retrieval
  16. Preserving document layout
  17. Applying authorization to RAG search
  18. Tuning chunk overlap
  19. Organizing duplicate documents
  20. Evaluating evidence ranking
  21. Clarify an ambiguous retrieval target
  22. Prioritizing exact identifiers
  23. Evaluating a reranker
  24. Versioning metadata filters
  25. Grounding answers with citations
  26. Updating a vector index
  27. Securing answer caches
  28. Calibrating confidence
  29. Compare prompt configuration changes and output quality
3.3 Describe the training and fine-tuning process for foundation models48 questions
  1. Choosing between RAG and fine-tuning
  2. Using precision and recall
  3. Combining human evaluation
  4. Evaluating retrieval relevance
  5. Detecting prompt-regression
  6. Combining quality and operational metrics
  7. Evaluating structured extraction
  8. Purpose of red-team evaluation
  9. Choosing precision and recall
  10. Combining automated and human evaluation
  11. Evaluating harmful content
  12. Designing pairwise human evaluation
  13. Understanding text-overlap metrics
  14. Using slice analysis
  15. Displaying answer uncertainty
  16. Measuring quality and latency trade-offs
  17. Checking confidence calibration
  18. Combining automatic and human evaluation
  19. Evaluating harmful output
  20. Separating offline and online metrics
  21. Reading a confusion matrix
  22. Knowing string-metric limits
  23. Sampling production quality
  24. Monitoring AI cost
  25. Setting AI rate limits
  26. Defining an AI SLO
  27. Choosing an incident fallback
  28. Routing drift alerts
  29. Reducing alert fatigue
  30. Monitoring with delayed labels
  31. Canary model release
  32. Detecting AI cost anomalies
  33. Securing response caching
  34. Designing model fallback
  35. Monitoring model versions
  36. Tracing an inference
  37. Staging a prompt rollout
  38. Setting drift alert thresholds
  39. Backing up and restoring AI configuration
  40. Separating provider SLA from measurements
  41. Retiring a model safely
  42. Isolating AI service health
  43. Inventorying AI dependencies
  44. Anonymizing AI usage analytics
  45. Controlling an AI budget
  46. Setting a data-quality SLO
  47. Rolling back a model
  48. Defining retraining triggers
3.4 Describe methods to evaluate foundation-model performance32 questions
  1. Selecting a text-generation evaluation metric
  2. Building a fixed evaluation set
  3. Operating generative-AI safety controls
  4. Validating generated output
  5. Monitoring inference cost
  6. Escalating uncertain answers
  7. Monitoring a generative-AI application
  8. Designing rate-limit fallbacks
  9. Responding to an AI incident
  10. Defining generative-AI SLOs
  11. Detecting quality drift
  12. Monitoring prompt abuse
  13. Building a fixed evaluation set
  14. Retrying inference failures
  15. Monitoring token cost
  16. Detecting input drift
  17. Tracing a generation workflow
  18. Autoscaling inference capacity
  19. Designing an inference health check
  20. Evaluating hallucinations
  21. Evaluating harmful output
  22. Standardizing human evaluation
  23. Maintaining a regression set
  24. Maintaining a golden set
  25. Understanding semantic metrics
  26. Verifying citations
  27. Evaluating RAG end to end
  28. Designing a human-review queue
  29. Comparing multilingual quality
  30. Explaining citation confidence
  31. Using user feedback safely
  32. Building a model benchmark
4.1 Explain the development of responsible AI systems40 questions
  1. Selecting bias-reduction activities
  2. Preparing representative fairness data
  3. Reducing model bias
  4. Considering user impact
  5. Considering group thresholds
  6. Minimizing personal data in AI
  7. Investigating proxy features
  8. Validating a fairness intervention
  9. Designing inclusive AI
  10. Investigating label noise
  11. Triggering human oversight
  12. Evaluating representational harm
  13. Evaluating subgroup fairness
  14. Mitigating data bias
  15. Balancing fairness evaluation and privacy
  16. Checking data representativeness
  17. Detecting disparate impact
  18. Creating labeling guidelines
  19. Comparing fairness thresholds
  20. Handling small subgroup metrics
  21. Measuring intersectional fairness
  22. Reviewing label bias
  23. Checking proxy attributes
  24. Understanding explanations
  25. Minimizing personal data
  26. Measuring group impact
  27. Checking representative data
  28. Threat-modeling privacy
  29. Designing accessible AI output
  30. Setting purpose-based retention
  31. Choosing fairness mitigations
  32. Managing AI consent
  33. Checking AI accessibility
  34. Notifying users about AI
  35. Showing content provenance
  36. Checking go-live readiness
  37. Reviewing copyright risk in generated content
  38. Tiering AI risk
  39. Making safety a release gate
  40. Comparing a new model without impact
4.2 Recognize the importance of transparent and explainable models42 questions
  1. Improving AI transparency and explainability
  2. Improving explainability
  3. Testing robustness
  4. Documenting model use conditions
  5. Explaining AI to different audiences
  6. Ensuring AI traceability
  7. Communicating explainability limits
  8. Documenting model information
  9. Disclosing AI use to users
  10. Making AI use transparent
  11. Routing cases to human review
  12. Explaining limits of explainability
  13. Recording model accountability
  14. Showing content provenance
  15. Designing an appeal workflow
  16. Disclosing high-impact AI use
  17. Linking explanations to evidence
  18. Assigning accountability
  19. Handling consent for AI use
  20. Providing transparency and appeal
  21. Assigning incident accountability
  22. Operating an AI risk register
  23. Maintaining model documentation
  24. Notifying users about AI
  25. Reviewing with stakeholders
  26. Designing human override
  27. Approving AI changes
  28. Handling appeals
  29. Measuring intersectional fairness
  30. Handling explainability limits
  31. Maintaining a model card
  32. Explaining fairness tradeoffs
  33. Controlling human overrides
  34. Defining human escalation
  35. Updating model documentation
  36. Monitoring fairness continuously
  37. Communicating an AI incident
  38. Reviewing model and data licenses
  39. Defining human-review criteria
  40. Handling an appeal of an AI decision
  41. Reviewing AI accessibility
  42. Recording an AI adoption decision
5.1 Explain methods to secure AI systems60 questions
  1. Protecting generative-AI inputs and outputs
  2. Designing least-privilege IAM for an AI application
  3. Identifying prompt injection
  4. Applying least privilege to an AI application
  5. Protecting personal information in AI inputs
  6. Managing encryption keys for AI data
  7. Protecting AI network paths
  8. Treating retrieved instructions as data
  9. Applying least privilege to an AI app
  10. Protecting AI application secrets
  11. Applying input and output guardrails
  12. Isolating AI service network paths
  13. Managing encryption keys
  14. Restricting endpoint policies
  15. Isolating instructions in retrieved documents
  16. Validating customer-category JSON
  17. Restricting encryption-key access
  18. Controlling sensitive data handling
  19. Using an execution role
  20. Not overtrusting private endpoints
  21. Rotating secrets
  22. Authenticating an inference endpoint
  23. Separating encryption in transit and at rest
  24. Controlling egress
  25. Limiting secret read access
  26. Tokenizing sensitive values
  27. Using IAM conditions
  28. Redacting sensitive logs
  29. Isolating document instructions
  30. Handling output-validation failures
  31. Applying authorization before retrieval
  32. Isolating inference networks
  33. Rotating inference secrets
  34. Restricting resource policies
  35. Separating encryption keys
  36. Protecting prompt logs
  37. Authenticating an inference endpoint
  38. Patching AI dependencies
  39. Using private inference paths
  40. Sanitizing generated output
  41. Providing an AI kill switch
  42. Handling personal data before prompting
  43. Preventing multi-turn injection
  44. Checking data residency
  45. Checking the model supply chain
  46. Checking JSON business rules and permissions
  47. Layering AI guardrails
  48. Red-teaming an AI system
  49. Verifying deletion requests
  50. Managing retention exceptions
  51. Performing a privacy impact assessment
  52. Handling harmful output
  53. Protecting personal data in embeddings
  54. Applying privacy by design
  55. Tracking training-data provenance
  56. Adding a training-data license gate
  57. Listing model dependencies
  58. Making audit evidence reproducible
  59. Testing adversarial input
  60. Stopping a dangerous AI feature
5.2 Recognize governance and compliance for AI systems56 questions
  1. Building an AI audit trail
  2. Defining AI log retention
  3. Reviewing compliance before AI adoption
  4. Adding human oversight to high-impact decisions
  5. Maintaining an AI model inventory
  6. Assigning AI asset ownership
  7. Managing AI-policy exceptions
  8. Designing audit-log retention
  9. Assessing third-party AI risk
  10. Recording AI approval evidence
  11. Checking AI data residency
  12. Managing an AI provider change
  13. Preserving AI incident evidence
  14. Setting retention and deletion policies
  15. Mapping compliance controls
  16. Protecting audit-log integrity
  17. Reviewing an AI service SLA
  18. Verifying deletion evidence
  19. Reviewing cross-border transfer
  20. Checking training-data rights
  21. Correlating audit events
  22. Deciding incident notification
  23. Balancing legal hold and deletion
  24. Reviewing the AI supply chain
  25. Handling deletion requests
  26. Preparing audit evidence
  27. Managing a model card
  28. Checking third-party licenses
  29. Managing retention exceptions
  30. Reviewing audit-log access
  31. Deleting records
  32. Managing regional requirements
  33. Reviewing an AI incident
  34. Securing AI logs
  35. Preventing secrets in prompts
  36. Reviewing AI access
  37. Encrypting data at rest and in transit
  38. Rotating encryption keys
  39. Separating AI governance roles
  40. Defining AI change approval
  41. Assembling audit evidence
  42. Rate limiting AI API abuse
  43. Minimizing key access
  44. Validating AI input
  45. Freezing AI changes during critical periods
  46. Auditing AI data access
  47. Approving policy exceptions
  48. Using a private inference path
  49. Decommissioning an AI service
  50. Bounding agent tool permissions
  51. Reviewing an AI vendor contract
  52. Distributing approved models
  53. Managing AI data residency
  54. Managing a policy exception
  55. Coordinating a third-party AI incident
  56. Assessing model-change impact
2.2 Explain foundation-model capabilities and limitations28 questions
  1. Understanding tokens and context length
  2. Choosing the purpose of embeddings
  3. Distinguishing pre-training and fine-tuning
  4. Reducing hallucinations with grounding
  5. Understanding model parameters
  6. Considering tokenization and input limits
  7. Designing a context window
  8. Reducing hallucination
  9. Designing multimodal input
  10. Comparing sampling parameters
  11. Delimiting input data
  12. Controlling output length
  13. Selecting grounded sources
  14. Summarizing long documents
  15. Improving few-shot examples
  16. Judging zero-shot use
  17. Separating instruction roles
  18. Writing a specific prompt
  19. Using role instructions
  20. Handling intermediate results
  21. Controlling summary source coverage
  22. Choosing chunk overlap
  23. Managing retrieval freshness
  24. Filtering with metadata
  25. Validating OCR ingestion
  26. Using language metadata
  27. Deduplicating documents
  28. Separating RAG and fine-tuning
3.1 Select and adapt foundation models38 questions
  1. Comparing models for latency
  2. Distinguishing zero-shot and few-shot prompting
  3. Choosing RAG instead of frequent retraining
  4. Selecting temperature for structured extraction
  5. Protecting customization data
  6. Matching model capability to requirements
  7. Choosing prompts before fine-tuning
  8. Selecting a model for latency
  9. Governing fine-tuning data
  10. Designing model routing
  11. Managing a model-version update
  12. Choosing prompts, RAG, or fine-tuning
  13. Considering efficient adaptation
  14. Comparing model capacity and latency
  15. Splitting customization data
  16. Comparing model cost and quality
  17. Considering model distillation
  18. Choosing an inference mode
  19. Choosing an adaptation method
  20. Rolling out a model update
  21. Selecting for latency
  22. Governing adaptation data
  23. Choosing a quality-cost frontier
  24. Selecting an embedding model
  25. Choosing vector dimensions
  26. Using hybrid search
  27. Choosing top-k
  28. Evaluating a reranker
  29. Choosing approximate nearest-neighbor search
  30. Using Recall@k
  31. Designing RAG chunks
  32. Explaining embedding search
  33. Choosing hybrid search
  34. Preserving grounding metadata
  35. Applying authorization to retrieval
  36. Managing retrieval freshness
  37. Rebuilding a vector index
  38. Refusing without evidence