PCEI-30-01 Cheat Sheet

Last revised: September 16, 2026

Cheat sheet: AI, ML, Python, data, and model evaluation reference for Python Institute PCEI-30-01 candidates.

Use the tables for a quick pre-exam check. Expand a topic’s notes for explanations, examples, and additional distinctions.

Scope and study context

Item	Reference
Vendor/provider	Python Institute
Official exam title	Python Institute PCEI - Certified Entry-Level AI Specialist with Python (PCEI-30-01)
Exam code	PCEI-30-01
Page purpose	Independent quick review for AI concepts, Python patterns, data workflows, model selection, and evaluation basics
Best use	Review terms, choose algorithms from scenarios, read short Python snippets, and identify common AI/ML mistakes

Focus on practical distinctions: classification vs regression, training vs inference, parameter vs hyperparameter, feature vs label, accuracy vs precision/recall, and model performance vs responsible AI risk.

For the PCEI-30-01 exam, use original practice questions to test recognition and reasoning, not memorization alone.

A strong practice sequence is:

Start with short topic drills on AI terminology, Python basics, data handling, and evaluation metrics.
Review detailed explanations for every missed or guessed question.
Create a mistake log grouped by topic: Python, data, workflow, models, metrics, ethics.
Re-drill weak areas until you can explain why each wrong option is wrong.
Move to mixed question bank sessions to practice switching topics.
Finish with mock exams under timed conditions.
Use the final review to target only the areas still causing errors.

Practice is most useful when explanations force you to compare close choices: classification vs regression, precision vs recall, validation vs test, overfitting vs underfitting, and AI vs ML vs deep learning.

AI and machine learning concept map

Term	Compact meaning	Exam-use distinction
Artificial intelligence, AI	Systems that perform tasks associated with human intelligence	Broad umbrella: may include rules, search, ML, robotics, NLP, vision
Machine learning, ML	Models learn patterns from data instead of being explicitly programmed for every rule	ML is a subset of AI
Deep learning, DL	ML using multi-layer neural networks	Strong for images, speech, text, and large unstructured data
Data science	Extracting insights from data using statistics, programming, and domain knowledge	May include analytics without predictive AI
Model	Learned or designed function that maps inputs to outputs	Trained model is used for inference
Training	Process of fitting model parameters using data	Uses training data and a loss/objective
Inference	Using a trained model to make predictions	Should not update learned parameters unless online learning is intended
Feature	Input variable used by the model	Example: age, pixel values, token counts
Label / target	Output the model should learn to predict	Present in supervised learning
Parameter	Learned internal value	Weights in linear models or neural networks
Hyperparameter	Chosen before or during training control	Learning rate, tree depth, number of clusters
Loss function	Quantity minimized during training	Cross-entropy for classification; MSE often for regression
Generalization	Performance on unseen data	Better exam answer than “memorizes training set”
Overfitting	Model fits training data too closely and performs poorly on new data	Often high train score, low validation/test score
Underfitting	Model is too simple or poorly trained to capture patterns	Low train and validation performance
Bias	In ML error: simplifying assumptions; in responsible AI: unfair systematic harm	Read the scenario carefully; the word has two contexts
Variance	Sensitivity to training data changes	High variance often means overfitting

Notes and examples

Machine learning workflow

A typical ML workflow is iterative. The first model is rarely the final model.

    flowchart TD
	    A[Define problem] --> B[Collect data]
	    B --> C[Explore and clean data]
	    C --> D[Split data]
	    D --> E[Preprocess features]
	    E --> F[Train model]
	    F --> G[Evaluate model]
	    G --> H{Good enough?}
	    H -- No --> C
	    H -- Yes --> I[Deploy or use model]
	    I --> J[Monitor performance]
	    J --> C

Workflow decision points

Step	Key question	Trap to avoid
Define problem	What exactly should be predicted or automated?	Building a model before defining success
Collect data	Is the data relevant and representative?	Using convenient but biased data
Explore data	What patterns, gaps, and anomalies exist?	Skipping visualization and summary statistics
Split data	How will generalization be measured?	Testing on data used in training
Preprocess	What transformations are needed?	Fitting preprocessing on all data before splitting
Train	Which model is appropriate?	Choosing complexity without a reason
Evaluate	Which metric matches the goal?	Using accuracy for imbalanced problems
Monitor	Does performance remain stable?	Assuming deployment ends the project

Learning paradigms and task selection

Paradigm	Data available	Output	Common examples	Choose when	Common trap
Supervised classification	Features plus class labels	Category/class	Spam/not spam, disease/no disease, image class	Target is discrete	Predicting a number does not automatically mean regression if the number is a class code
Supervised regression	Features plus numeric target	Continuous value	Price, temperature, demand	Target is numeric and ordered/continuous	Do not use accuracy for regression
Unsupervised clustering	Features without labels	Groups/segments	Customer segments, document groups	Need structure discovery	Clusters are not automatically “correct labels”
Unsupervised dimensionality reduction	Features without labels	Fewer transformed features	PCA, visualization, compression	Need simplify high-dimensional data	Transformed components may be hard to interpret
Reinforcement learning	Agent, environment, rewards	Policy/actions	Game agent, robotics control	Sequential decisions with feedback	Reward design is critical; not the default for normal labeled datasets
Semi-supervised learning	Few labels plus many unlabeled samples	Improved supervised model	Label-scarce image/text tasks	Labels are expensive	Unlabeled data must be relevant to the same problem
Self-supervised learning	Labels generated from data itself	Representations/pretraining	Masked words, contrastive learning	Large unlabeled text/image data	Not the same as manually labeled supervised learning

End-to-end AI/ML workflow

    flowchart LR
	    A[Define problem] --> B[Collect data]
	    B --> C[Explore and clean]
	    C --> D[Split data]
	    D --> E[Preprocess and engineer features]
	    E --> F[Train model]
	    F --> G[Validate and tune]
	    G --> H[Test once]
	    H --> I[Deploy or report]
	    I --> J[Monitor drift, errors, bias]

Notes and examples

Step	Key questions	Artifacts	High-yield trap
Define problem	Classification, regression, clustering, generation, ranking?	Objective, success metric, constraints	Picking an algorithm before defining the target
Collect data	Is data representative, legal to use, and relevant?	Raw datasets, metadata	More data is not useful if it is biased or mislabeled
Explore data	Missing values, outliers, class balance, correlations?	Summary stats, plots	Assuming correlation proves causation
Split data	Train/validation/test or cross-validation?	Reproducible split	Letting test data influence preprocessing or tuning
Preprocess	Scale, encode, tokenize, impute, normalize?	Pipeline or transformation code	Fitting preprocessors on all data causes leakage
Train	Which model family and hyperparameters?	Fitted model	High training score alone is not evidence of success
Validate/tune	Which hyperparameters improve validation metric?	Scores, selected model	Repeatedly tuning on test data invalidates test result
Test	Final unbiased performance estimate?	Test metrics	Testing before final model selection
Deploy/monitor	Is performance stable in production?	Model service, logs, dashboards	Data drift can degrade a once-good model

Data types, features, and preprocessing choices

Data / issue	Common handling	Choose / remember	Trap
Numeric continuous	Scaling, normalization, outlier checks	Important for kNN, SVM, logistic regression, neural networks	Trees usually need less scaling
Categorical nominal	One-hot encoding, embeddings for high-cardinality data	No inherent order	Label encoding may imply false order
Categorical ordinal	Ordered integer mapping or ordinal encoding	Keep meaningful order	Treating ordinal values as purely nominal can lose signal
Text	Tokenization, vectorization, embeddings	Convert words/tokens to numbers	Raw strings cannot be directly used by most numeric models
Images	Pixel arrays, normalization, augmentation, CNNs	Preserve spatial patterns	Flattening may discard useful locality for vision tasks
Time series	Time-aware split, lag features, rolling stats	Future data must not leak into past	Random split can leak future information
Missing values	Imputation, missingness indicators, row removal	Strategy depends on why data is missing	Dropping rows can bias the dataset
Outliers	Investigate, cap, transform, robust models	Some outliers are valid signals	Blind removal can discard rare but important cases
Imbalanced classes	Stratified split, class weights, resampling, precision/recall/F1	Use metrics beyond accuracy	A model predicting only majority class can look accurate
Duplicate records	Deduplicate before split where appropriate	Prevent same entity in train and test	Duplicates inflate test performance
Data leakage	Keep target/future/test information out of training	Use pipelines fitted on training only	Leakage often creates unrealistically high metrics

Python essentials for AI code questions

Python feature	Remember	Common mistake
Indentation	Defines code blocks	Misreading nested `if`, `for`, `def`, or `class` blocks
Lists	Ordered, mutable sequences	Assignment copies references, not deep copies
Tuples	Ordered, immutable sequences	Tuple can contain mutable objects
Dictionaries	Key-value mappings	Keys must be hashable
Sets	Unordered unique elements	No index-based access
Slicing	`seq[start:stop:step]`, stop is excluded	Off-by-one errors
Negative index	`seq[-1]` is last item	`seq[-0]` equals `seq[0]`
List comprehension	Compact transformation/filter	Side effects are less readable
Functions	`return` sends value back	Printing is not returning
Lambda	Small anonymous function	Best for simple expressions only
Exceptions	`try` / `except` handles runtime errors	Catching broad exceptions can hide bugs
Modules	Imported with `import` or `from ... import ...`	Namespace changes depending on import style
Randomness	Use seeds for reproducibility	Seed does not make a poor split representative
Boolean logic	`and`, `or`, `not`; truthy/falsy values	Confusing bitwise `&` with logical `and` outside array contexts

Notes and examples

Core Python patterns

values = [3, 1, 4, 1, 5]

squares = [x * x for x in values if x > 1]
unique_values = set(values)
counts = {x: values.count(x) for x in unique_values}

def normalize_minmax(x, min_x, max_x):
    return (x - min_x) / (max_x - min_x)

Read snippets for data flow: what is created, transformed, fitted, predicted, or measured.

NumPy and pandas quick reference

Library	Used for	High-yield objects / methods
NumPy	Numeric arrays, vectorized operations, linear algebra basics	`array`, `shape`, `reshape`, `mean`, `sum`, `argmax`, `dot`, broadcasting
pandas	Tabular data loading, cleaning, exploration	`DataFrame`, `Series`, `read_csv`, `head`, `info`, `describe`, `isna`, `value_counts`, `groupby`, `loc`, `iloc`
matplotlib / plotting tools	Basic visualization	Histograms, scatter plots, line plots, confusion matrix display
scikit-learn-style APIs	Classical ML workflows	`fit`, `transform`, `predict`, `score`, train/test split, metrics, pipelines

Notes and examples

import numpy as np

x = np.array([[1, 2, 3],
              [4, 5, 6]])

x.shape          # (2, 3)
x.mean(axis=0)   # column means
x.mean(axis=1)   # row means

import pandas as pd

df = pd.read_csv("data.csv")
df.head()
df.info()
df["target"].value_counts()
df.isna().sum()

pandas selector	Meaning
`df["col"]`	Select one column as a Series
`df[["a", "b"]]`	Select multiple columns as a DataFrame
`df.loc[row_label, col_label]`	Label-based selection
`df.iloc[row_index, col_index]`	Position-based selection
`df.drop(columns=["x"])`	Remove column `x`
`df.groupby("class").mean()`	Aggregate by group

Model selection matrix

Model / method	Best fit	Preprocessing needs	Strengths	Watch for
Linear regression	Numeric regression with roughly linear relationships	Encoding, often scaling	Simple, interpretable baseline	Poor fit for strong nonlinearity unless features are engineered
Logistic regression	Binary or multiclass classification	Encoding, often scaling	Strong baseline, probabilistic outputs	Despite name, used for classification
k-nearest neighbors, kNN	Classification/regression based on similar examples	Scaling is very important	Simple concept; no complex training	Slow on large data; sensitive to irrelevant features
Naive Bayes	Text classification, simple probabilistic classification	Text vectorization for NLP	Fast, works well for bag-of-words text	“Naive” independence assumption may be unrealistic
Decision tree	Classification/regression with nonlinear rules	Little scaling needed	Interpretable if small	Easily overfits if unconstrained
Random forest	Ensemble of decision trees	Little scaling needed	Reduces variance, strong general-purpose model	Less interpretable than one tree
Gradient boosting	Sequential ensemble improving errors	Depends on implementation/data	High predictive performance	Sensitive to tuning; can overfit
Support vector machine, SVM	Classification with clear margins; can use kernels	Scaling usually important	Effective in many medium-size problems	Kernel choice and tuning matter
k-means	Unsupervised clustering into k groups	Scaling important	Simple clustering baseline	Must choose k; assumes roughly spherical clusters
PCA	Dimensionality reduction	Scaling often important	Compresses features, removes correlation	Components may not map to human-readable features
Neural network	Complex nonlinear patterns, unstructured data	Scaling/normalization; more data often needed	Flexible, supports deep learning	More parameters, less interpretability, compute needs

Neural networks and deep learning

Concept	Meaning	Exam cue
Neuron/unit	Computes weighted input plus bias, then activation	Basic building block
Weight	Learned coefficient	Parameter, not hyperparameter
Bias term	Learned offset	Lets activation shift
Activation function	Adds nonlinearity	Without nonlinear activations, stacked layers act like a linear model
Forward pass	Inputs flow through network to output	Prediction computation
Loss	Difference between prediction and desired output	Training minimizes loss
Backpropagation	Computes gradients through network	Used to update weights
Gradient descent	Optimization method moving parameters to reduce loss	Learning rate controls step size
Epoch	One pass over training data	More epochs can overfit
Batch / mini-batch	Subset used for one update	Common in neural network training
CNN	Convolutional neural network	Strong for images and spatial patterns
RNN	Recurrent neural network	Designed for sequences; less central than transformers in modern NLP
Transformer	Attention-based architecture	Common in modern language models
Embedding	Dense vector representation	Used for words, documents, images, users/items

Notes and examples

Common activations:

Activation	Typical use	Key behavior
ReLU	Hidden layers	Outputs zero for negative input and linear positive values
Sigmoid	Binary probability output or gating	Outputs between 0 and 1
Softmax	Multiclass output	Converts class scores into probabilities that sum to 1
Tanh	Hidden layers in some networks	Outputs between -1 and 1

Metrics and evaluation

Confusion matrix terms

Term	Meaning
True positive, TP	Predicted positive and actually positive
True negative, TN	Predicted negative and actually negative
False positive, FP	Predicted positive but actually negative
False negative, FN	Predicted negative but actually positive

Notes and examples

\[ \begin{aligned} \text{Accuracy} &= \frac{TP + TN}{TP + TN + FP + FN} \\ \text{Precision} &= \frac{TP}{TP + FP} \\ \text{Recall} &= \frac{TP}{TP + FN} \\ \text{F1} &= 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}} \end{aligned} \]

Metric	Use when	Trap
Accuracy	Classes are reasonably balanced and error costs are similar	Misleading with class imbalance
Precision	False positives are costly	High precision can still miss many positives
Recall / sensitivity	False negatives are costly	High recall can create many false positives
Specificity	True-negative performance matters	Often paired with sensitivity
F1 score	Need balance between precision and recall	Hides trade-off between the two
ROC AUC	Ranking ability across thresholds	Can look good even when precision is poor in rare-positive tasks
PR AUC	Positive class is rare	More informative than ROC in many imbalanced cases
Confusion matrix	Need error type breakdown	Must know which class is “positive”

Regression metrics:

\[ \begin{aligned} \text{MAE} &= \frac{1}{n}\sum_{i=1}^{n}|y_i - \hat{y}_i| \\ \text{MSE} &= \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2 \\ \text{RMSE} &= \sqrt{\text{MSE}} \end{aligned} \]

Metric	Use when	Trap
MAE	Need average absolute error in target units	Less sensitive to large errors
MSE	Penalize larger errors more	Units are squared
RMSE	Penalize large errors while keeping target units	Sensitive to outliers
R-squared	Explain variance relative to baseline	High value does not prove causation or fairness

Train, validation, test, and cross-validation

Dataset part	Purpose	Should be used for
Training set	Fit model parameters	Training model and preprocessing fitted within training workflow
Validation set	Tune hyperparameters and compare models	Model selection
Test set	Final estimate of generalization	One-time final evaluation
Cross-validation	Repeated train/validation splits	More stable model comparison on limited data

from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, stratify=y, random_state=42
)

model = make_pipeline(
    StandardScaler(),
    LogisticRegression()
)

model.fit(X_train, y_train)
pred = model.predict(X_test)

print(classification_report(y_test, pred))

Key point: the scaler inside the pipeline is fitted on X_train, not the full dataset. That helps avoid data leakage.

Overfitting, underfitting, and fixes

Symptom	Likely issue	Practical fixes
High training score, low validation score	Overfitting / high variance	More data, regularization, simpler model, pruning, dropout, early stopping, cross-validation
Low training and validation score	Underfitting / high bias	More expressive model, better features, train longer, reduce excessive regularization
Validation score unstable across splits	High variance or small dataset	Cross-validation, more data, simpler model
Great test score during development but poor production performance	Leakage, distribution shift, or over-tuning	Recheck split, monitor drift, use realistic validation
Model performs well overall but fails subgroup	Bias/fairness issue or unrepresentative data	Subgroup evaluation, better data coverage, fairness review

Notes and examples

Technique	What it does	Common use
Regularization	Penalizes model complexity	Reduce overfitting
Dropout	Randomly disables neural units during training	Neural network regularization
Early stopping	Stops training when validation stops improving	Avoid overtraining
Pruning	Limits decision tree complexity	Reduce tree overfitting
Data augmentation	Creates modified training examples	Images, text, audio robustness
Cross-validation	Tests performance across multiple splits	Model selection on limited data

Generative AI, NLP, and embeddings

Concept	Meaning	Exam-use distinction
Tokenization	Splits text into tokens	Tokens may be words, subwords, or characters
Vocabulary	Set of tokens known to a model/vectorizer	Unknown or rare words need handling
Bag of words	Counts token occurrences	Ignores word order
TF-IDF	Weights words by frequency and rarity	Useful classical text representation
Embedding	Dense numeric vector representing meaning/features	Similar items should be close in vector space
Language model	Predicts or generates text	Can be used for completion, classification, summarization
Generative model	Produces new content	Text, image, audio, code, or synthetic data
Prompt	Input instruction/context for a generative model	Prompt wording affects output
Hallucination	Plausible but incorrect generated output	Requires verification and guardrails
RAG	Retrieval-augmented generation	Retrieves external context before generation
Fine-tuning	Further training a model on task-specific data	Changes model behavior more deeply than prompting
Temperature	Sampling randomness control	Higher generally means more varied output; lower more deterministic
Guardrails	Controls to reduce unsafe or invalid outputs	Can include filtering, validation, human review

Notes and examples

Cosine similarity is commonly used to compare embeddings:

\[ \text{cosine similarity} = \frac{A \cdot B}{\lVert A \rVert \lVert B \rVert} \]

import numpy as np

def cosine_similarity(a, b):
    a = np.array(a)
    b = np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Responsible AI, ethics, and risk controls

Risk	Example	Mitigation idea
Bias / unfairness	Lower performance for a demographic subgroup	Representative data, subgroup metrics, fairness review
Privacy exposure	Sensitive data included in training or prompts	Data minimization, anonymization, access control
Lack of explainability	User cannot understand why a decision was made	Simpler model, feature importance, documentation
Hallucination	Generated answer invents facts	Retrieval, validation, citations, human review
Data poisoning	Malicious or corrupted training data	Data provenance, validation, monitoring
Adversarial inputs	Small input changes cause wrong predictions	Robust testing, input validation, monitoring
Automation bias	Users overtrust AI output	Human-in-the-loop review and clear uncertainty
Model drift	Production data changes over time	Monitoring, retraining triggers, performance checks
Security leakage	Model or API reveals sensitive information	Authentication, authorization, logging, rate controls
Misuse	Model used outside intended scope	Clear documentation, constraints, governance

Notes and examples

High-yield distinction: model accuracy is not the same as model acceptability. A model can score well and still be unsafe, unfair, nontransparent, or inappropriate for deployment.

Responsible AI and ethics

For the Python Institute PCEI - Certified Entry-Level AI Specialist with Python (PCEI-30-01) exam, responsible AI concepts are important because entry-level AI specialists must understand that technical work has human impact.

Topic	Practical meaning
Fairness	Avoid unjust performance differences across groups
Bias	Data, labels, or design choices can disadvantage groups
Transparency	Users and stakeholders should understand system behavior at an appropriate level
Explainability	Ability to describe why a model made a prediction
Privacy	Protect personal or sensitive data
Security	Prevent misuse, tampering, or data exposure
Accountability	Humans remain responsible for system design and use
Safety	Reduce harmful outputs or decisions
Human oversight	Critical systems should not rely blindly on automation

Responsible AI decision rules

Do not deploy a model just because it has a good metric.
Check who benefits and who may be harmed.
Consider whether the data was collected with appropriate consent and safeguards.
Evaluate performance across meaningful subgroups when relevant.
Use human review for high-impact decisions.
Document assumptions, limitations, and intended use.
Monitor for drift, misuse, and unexpected failures.

Scenario decision rules

If the question says…	Think…
“Predict whether” / “classify as” / “which category”	Classification
“Predict price/amount/temperature”	Regression
“Find natural groups without labels”	Clustering
“Reduce many features while preserving information”	Dimensionality reduction
“Agent learns by reward and penalty”	Reinforcement learning
“Images with spatial patterns”	CNN or image-focused preprocessing
“Text meaning or semantic search”	Embeddings, language models, NLP
“Rare positive class”	Precision, recall, F1, PR AUC; not accuracy alone
“False negative is dangerous”	Prioritize recall/sensitivity
“False positive is expensive”	Prioritize precision
“Very high training score, weak validation score”	Overfitting
“Preprocessing used before split”	Data leakage risk
“New data no longer matches training data”	Drift / distribution shift
“Need human-understandable rules”	Simpler interpretable model or explanation method

Common traps to eliminate

Logistic regression is for classification, not ordinary numeric regression.
Accuracy can be a poor metric when classes are imbalanced.
Test data is not for tuning. Use validation or cross-validation for model selection.
Fit preprocessing only on training data; transform validation/test using training-fitted steps.
Correlation does not prove causation.
Hyperparameters are chosen, while parameters are learned.
Scaling matters for distance-based and gradient-based methods; it is usually less critical for tree-based models.
Unsupervised learning has no labels during training.
A larger model is not automatically better; it can overfit and be harder to explain.
A seed improves reproducibility, not necessarily model quality.
Good average performance can hide subgroup failure.
Generative AI output must be verified when correctness matters.

Last-pass checklist for PCEI-30-01 review

Use this checklist before practice questions for the Python Institute PCEI - Certified Entry-Level AI Specialist with Python (PCEI-30-01):

Identify the ML task from the target: category, number, cluster, sequence action, or generated content.
Name the correct data split and what each split is allowed to influence.
Match metric to business error: false positive, false negative, continuous error, ranking, or imbalance.
Recognize leakage in preprocessing, feature creation, duplicates, and time-based data.
Distinguish AI, ML, deep learning, NLP, computer vision, and generative AI.
Read Python code for mutability, slicing, function return values, array shape, and fit/predict flow.
Know when scaling, encoding, imputation, tokenization, and embeddings are needed.
Recognize overfitting and underfitting from train/validation patterns.
Include responsible AI risks when a scenario mentions privacy, fairness, safety, transparency, or misuse.

High-yield exam mindset

The PCEI-30-01 exam is entry-level, so expect emphasis on whether you understand the role of AI and Python in practical workflows, not whether you can derive advanced research-level models from scratch.

Focus your final review on four skills:

Vocabulary precision — AI, machine learning, deep learning, model, feature, label, training, inference, bias, variance.
Workflow reasoning — how data moves from collection to preprocessing, training, evaluation, deployment, and monitoring.
Python fluency for AI tasks — variables, data structures, functions, modules, arrays, tabular data, plotting, and library usage patterns.
Model evaluation judgment — choosing the right metric, spotting overfitting, avoiding data leakage, and interpreting results cautiously.

Big-picture map

Area	Know this quickly	Common exam trap
Artificial intelligence	Broad field of systems that perform tasks associated with human intelligence	Thinking AI always means machine learning
Machine learning	Models learn patterns from data rather than being explicitly programmed for every rule	Assuming more data or a more complex model always improves results
Deep learning	Neural-network-based ML, often useful for images, audio, language, and large datasets	Treating deep learning as the best choice for every problem
Data preparation	Cleaning, encoding, scaling, splitting, and checking data quality	Preprocessing test data using information from training data incorrectly
Supervised learning	Uses labeled examples: features plus target labels	Confusing classification and regression
Unsupervised learning	Finds structure without target labels	Expecting unsupervised learning to “know” the correct answer
Evaluation	Measures whether the model generalizes to unseen data	Reporting training accuracy as proof of real-world performance
Responsible AI	Fairness, transparency, privacy, safety, and accountability	Treating technical accuracy as the only success criterion

AI, ML, and deep learning

Core distinctions

Term	Meaning	Example
AI	Any system designed to perform intelligent behavior	A planning system, chatbot, recommendation engine
Machine learning	AI approach where patterns are learned from data	Predicting house prices from past sales
Deep learning	ML using neural networks with many layers	Image classification using a convolutional neural network
Generative AI	Models that create new content such as text, images, code, or audio	Text generation, image generation
Expert system	Rule-based system using human-coded knowledge	If-then diagnostic rules

Notes and examples

A useful decision rule:

If the system follows fixed rules written by humans, it may be AI but not necessarily ML.
If the system improves by learning patterns from data, it is ML.
If the learning system uses multilayer neural networks, it is deep learning.
If the system creates new outputs resembling learned examples, it may be generative AI.

Common misconceptions

AI does not “understand” in the human sense just because it produces fluent output.
A model can be accurate on one dataset and fail on another.
Correlation in data does not prove causation.
Automation does not remove the need for human oversight.
Training a model is different from using a trained model for inference.

Neural network vocabulary

Term	Meaning
Neuron/node/unit	Computes a weighted combination of inputs and applies an activation
Layer	Group of neurons
Input layer	Receives features
Hidden layer	Intermediate transformation layer
Output layer	Produces final prediction
Weight	Learned parameter controlling connection strength
Bias term	Learned offset parameter
Activation function	Nonlinear function that helps networks learn complex patterns
Loss function	Measures prediction error during training
Backpropagation	Computes how weights should change to reduce loss
Epoch	One pass through the training data
Batch	Subset of training examples processed together

Where deep learning is commonly useful

Domain	Why deep learning is common
Computer vision	Learns patterns from pixels and spatial structure
Natural language processing	Learns patterns in sequences and meaning-related representations
Speech/audio	Learns time-based signal patterns
Generative AI	Learns data distributions to generate new content
Large-scale prediction	Can model complex nonlinear relationships with enough data

Deep learning traps

More layers do not automatically mean better performance.
Neural networks can overfit.
Deep learning often needs more data and compute than simpler models.
Interpretability can be harder than with simple models.
A neural network prediction is not a guarantee of truth.

Python foundations for AI

Python concepts to review

Concept	What to remember	AI-related use
Variables	Names bound to objects	Store data, parameters, model outputs
Numeric types	Integers and floats behave differently in some operations	Calculations, metrics, feature values
Strings	Text sequences with indexing and methods	Labels, text data, file paths
Lists	Ordered, mutable collections	Small datasets, batches, feature lists
Tuples	Ordered, immutable collections	Fixed coordinate-like values, shape pairs
Dictionaries	Key-value mappings	Configuration, label mappings, JSON-like data
Sets	Unordered unique values	Unique labels, duplicate checks
Conditionals	Branching with if/elif/else	Data validation, decision logic
Loops	Repetition over items or ranges	Preprocessing records, iterating samples
Functions	Reusable blocks with parameters and return values	Clean training, evaluation, preprocessing code
Modules/packages	Reusable libraries imported into programs	NumPy, pandas, scikit-learn, visualization tools

Notes and examples

Python mistakes that often appear in AI code

Mistake	Why it matters
Confusing assignment and comparison	Assignment stores a value; comparison tests a condition
Mutating a list unexpectedly	Shared references can alter data unintentionally
Off-by-one indexing	Python indexing starts at 0
Ignoring indentation	Indentation defines blocks in Python
Reusing variable names carelessly	Can overwrite data, models, or metrics
Treating missing values as normal numbers	Can distort statistics and training
Mixing strings and numbers	Causes type errors or incorrect comparisons
Forgetting reproducibility	Random splits and initialization can change results

Python libraries in an AI workflow

Library/tool type	Typical purpose	What to know at entry level
NumPy	Arrays, vectorized numeric operations	Arrays are faster and more convenient than many manual loops
pandas	Tables, data frames, cleaning, grouping	Columns are features; rows are observations
Matplotlib or similar	Charts and plots	Visualization helps detect patterns and outliers
scikit-learn style tools	Classical ML models and preprocessing	Fit on training data, evaluate on test data
Jupyter notebooks	Interactive experimentation	Useful for exploration, but results should be reproducible
Python standard library	Files, math, randomization, paths	Many support tasks do not need heavy AI libraries

Data fundamentals

Data terms

Term	Meaning
Observation/sample/instance	One row or example in the dataset
Feature/input/predictor	A variable used to make a prediction
Target/label/output	The value the model is trained to predict
Dataset	Collection of examples
Training set	Data used to fit the model
Validation set	Data used to tune choices during development
Test set	Data held back for final evaluation
Inference	Using a trained model to produce predictions
Ground truth	The correct known answer used for evaluation

Notes and examples

Data types and preprocessing

Data type	Examples	Common preprocessing
Numeric	Age, price, temperature	Scaling, imputation, outlier review
Categorical	Color, country, product type	One-hot encoding, label encoding where appropriate
Text	Reviews, emails, documents	Tokenization, normalization, vectorization
Image	Pixels, channels, dimensions	Resizing, normalization, augmentation
Time series	Sensor readings, prices over time	Ordering, lag features, careful split by time
Boolean	True/false flags	Often usable directly or as 0/1 values

Data quality checklist

Before trusting a model, ask:

Are there missing values?
Are there duplicate rows?
Are labels correct and consistent?
Are units consistent?
Are categories spelled consistently?
Are there impossible values, such as negative ages?
Are outliers real, errors, or rare but valid cases?
Does the training data represent the real use case?
Is sensitive information handled appropriately?
Is there leakage from the target into the features?

Arrays, tables, and shapes

Concept	Meaning	Candidate reminder
Scalar	Single value	Example: one temperature
Vector	One-dimensional array	Example: one row of features or one column
Matrix	Two-dimensional array	Example: rows by columns
Tensor	General multidimensional array	Common in deep learning
Shape	Dimensions of an array	Many errors come from shape mismatch
Broadcasting	Automatic alignment of array operations	Powerful but can create unexpected results

A dot product is a common operation in linear models and neural networks:

\[ \mathbf{x} \cdot \mathbf{w} = \sum_{i=1}^{n} x_i w_i \]

The model combines inputs and weights, often adds a bias term, then applies a function.

Data frame habits

When reviewing pandas-style tabular work, remember:

Rows usually represent observations.
Columns usually represent features or labels.
Missing values must be detected and handled.
Categorical columns often need encoding.
Numeric columns may need scaling depending on the model.
Summary statistics can reveal impossible values.
Grouping can reveal class imbalance or biased representation.
The target column should be separated from input features before training.

Supervised learning

Supervised learning uses examples with known labels.

Classification vs regression

Task	Target type	Example	Typical metric
Classification	Category/class	Spam or not spam	Accuracy, precision, recall, F1
Binary classification	Two classes	Fraud or not fraud	Precision, recall, F1, ROC-AUC
Multiclass classification	More than two classes	Animal species	Accuracy, macro/micro F1
Regression	Continuous number	House price	MAE, MSE, RMSE, R-squared

Notes and examples

Common supervised algorithms

Algorithm family	Basic idea	Good to recognize
Linear regression	Fits a line or hyperplane for numeric prediction	Simple, interpretable baseline
Logistic regression	Estimates class probability for classification	Despite the name, used for classification
Decision tree	Splits data using feature-based rules	Easy to visualize; can overfit
Random forest	Ensemble of decision trees	Often stronger than one tree
k-nearest neighbors	Predicts from nearby examples	Sensitive to scaling and distance choice
Support vector machine	Finds a boundary between classes	Can work well but may need scaling
Naive Bayes	Probabilistic classifier with simplifying independence assumption	Common for text classification
Neural network	Layers transform inputs into predictions	Powerful but requires tuning and data

Supervised learning traps

Logistic regression is a classification method, not a regression method in the usual ML task sense.
High training accuracy with low test accuracy suggests overfitting.
A model trained on biased labels can reproduce bias.
If the target value is accidentally included as a feature, evaluation becomes misleading.
Random train/test split may be inappropriate for time series data.
Class imbalance can make accuracy look better than it is.

Unsupervised learning

Unsupervised learning looks for structure without labeled targets.

Task	Goal	Example
Clustering	Group similar observations	Customer segments
Dimensionality reduction	Reduce feature count while preserving important structure	Visualization or compression
Association discovery	Find items or events that occur together	Market basket patterns
Anomaly detection	Identify unusual observations	Fraud, equipment faults

Clustering review

Concept	Meaning
Cluster	Group of similar data points
Centroid	Center of a cluster in algorithms such as k-means
Distance metric	Rule for measuring similarity or difference
Number of clusters	Often a modeling choice, not known automatically
Scaling	Important because large numeric ranges can dominate distances

Common trap: clustering can create groups even when the groups are not meaningful. Always interpret clusters in context.

Model evaluation essentials

Confusion matrix terms

For binary classification:

Term	Meaning
True positive	Model predicts positive, actual is positive
True negative	Model predicts negative, actual is negative
False positive	Model predicts positive, actual is negative
False negative	Model predicts negative, actual is positive

Notes and examples

Classification metrics

\[ \text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN} \]\[ \text{Precision} = \frac{TP}{TP + FP} \]\[ \text{Recall} = \frac{TP}{TP + FN} \]\[ \text{F1} = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}} \]

Use the metric that matches the cost of mistakes:

Situation	Metric focus	Why
Balanced classes, similar error costs	Accuracy may be acceptable	Correct overall proportion is meaningful
False positives are costly	Precision	Positive predictions must be reliable
False negatives are costly	Recall	Need to catch as many actual positives as possible
Imbalanced classes	Precision, recall, F1, ROC-AUC, PR-AUC	Accuracy may hide poor minority-class performance
Medical screening-style scenario	Often recall-sensitive	Missing a true case can be costly
Spam filtering	Often precision-sensitive	Blocking legitimate messages is harmful

Regression metrics

\[ \text{MAE} = \frac{1}{n}\sum_{i=1}^{n} |y_i - \hat{y}_i| \]\[ \text{MSE} = \frac{1}{n}\sum_{i=1}^{n} (y_i - \hat{y}_i)^2 \]\[ \text{RMSE} = \sqrt{\text{MSE}} \]

Metric	Meaning	Watch out
MAE	Average absolute error	Easy to interpret in target units
MSE	Average squared error	Penalizes large errors more strongly
RMSE	Square root of MSE	Same units as target
R-squared	Proportion of variance explained, in a simplified interpretation	Can be misleading if used alone

Bias, variance, and generalization

Key ideas

Concept	Meaning	Symptom
Underfitting	Model is too simple or poorly trained	Poor training and test performance
Overfitting	Model memorizes training data instead of generalizing	Strong training performance, weak test performance
Bias	Error from overly simple assumptions	Misses important patterns
Variance	Error from being too sensitive to training data	Performance changes greatly across samples
Generalization	Performance on new, unseen data	Measured with validation/test data

Notes and examples

Ways to reduce overfitting

Use more representative training data.
Use a simpler model.
Regularize the model.
Prune a decision tree.
Use cross-validation where appropriate.
Stop training earlier for iterative models.
Remove noisy or leakage-prone features.
Evaluate on data not used for fitting or tuning.

Ways to reduce underfitting

Use more relevant features.
Use a more expressive model.
Train longer if the model is not converged.
Reduce excessive regularization.
Improve preprocessing.
Reconsider whether the chosen model family fits the problem.

Data splitting and leakage

Split types

Split	Purpose
Training set	Fit model parameters
Validation set	Tune model choices and compare candidates
Test set	Estimate final generalization after decisions are made
Cross-validation	Repeatedly train/evaluate across folds to get more stable estimates

Data leakage examples

Leakage pattern	Why it is wrong
Scaling using all data before splitting	Test-set information influences training transformation
Including a future value as a feature	Model uses information unavailable at prediction time
Duplicate records in train and test	Model may effectively see test examples during training
Target-derived feature	Feature directly or indirectly reveals the answer
Tuning repeatedly on the test set	Test set becomes part of model selection

A reliable rule: anything learned from data during preprocessing should be learned only from the training data, then applied to validation/test data.

Natural language processing basics

Concept	Meaning
Tokenization	Splitting text into words, subwords, or tokens
Stop words	Common words sometimes removed, depending on task
Stemming/lemmatization	Reducing words to base-like forms
Bag of words	Represents text by word counts, often ignoring order
TF-IDF	Weights words by frequency and distinctiveness
Embedding	Numeric vector representation of text meaning or usage patterns
Sentiment analysis	Predicting positive, negative, or neutral sentiment
Language model	Model trained to predict or generate language-like sequences

Common NLP traps:

Text must be converted to numeric features before most ML models can use it.
Removing stop words is not always helpful; it depends on the task.
Bag-of-words models often ignore word order.
Generated text can be plausible but false.
Training text may contain social, cultural, or factual bias.

Computer vision basics

Concept	Meaning
Pixel	Smallest image element
Channel	Color or intensity component, such as red, green, blue
Resolution	Image width and height
Convolution	Operation that detects local patterns using filters
Pooling	Reduces spatial size while retaining important information
Data augmentation	Creates transformed versions of images to improve robustness
Classification	Assigns an image-level label
Detection	Locates and classifies objects
Segmentation	Labels image regions or pixels

Common computer vision traps:

Image size and channel order matter.
Normalization can affect model performance.
Training on clean images may not generalize to real-world images.
Augmentation should reflect realistic variation.
A high-performing model can still fail on underrepresented conditions.

Generative AI review

Concept	Meaning
Prompt	Input instruction or context given to a generative model
Completion/output	Generated response
Hallucination	Plausible-sounding but incorrect or unsupported output
Temperature	Setting that can influence randomness in generation
Context window	Amount of input/output context the model can consider
Fine-tuning	Further training a model for a specific task or style
Retrieval-augmented generation	Supplying external retrieved information to support generation
Guardrails	Controls to reduce harmful, unsafe, or off-task outputs

Common traps:

Generative output should be verified, especially for facts, code, legal, medical, or financial content.
A confident tone is not evidence of correctness.
Sensitive data should not be casually entered into AI tools.
Prompting can guide output, but it does not guarantee truth.
Evaluation of generative AI may require human judgment as well as automated metrics.

Statistics and probability essentials

Concepts to recognize

Concept	Meaning
Mean	Average value
Median	Middle value when sorted
Mode	Most frequent value
Range	Difference between maximum and minimum
Variance	Average squared spread from the mean
Standard deviation	Typical spread from the mean
Distribution	Pattern of values
Outlier	Unusually extreme value
Correlation	Degree to which variables move together
Probability	Likelihood of an event
Random variable	Quantity with uncertain outcome

Correlation warning

Correlation is useful for exploring relationships, but it does not prove causation. A model may exploit correlations that are unstable, biased, or not meaningful in the real world.

Fast decision tables

Which task is this?

Scenario	Likely task
Predict tomorrow’s temperature	Regression
Predict whether an email is spam	Binary classification
Sort news articles into topics without labels	Clustering
Reduce 500 features to 2 for visualization	Dimensionality reduction
Detect unusual credit-card transactions	Anomaly detection
Generate a summary of a document	Generative AI or NLP
Identify cats in images	Computer vision classification or detection

Notes and examples

Which metric is most appropriate?

Scenario	Better metric focus
Fraud detection with rare fraud cases	Recall, precision, F1, PR-AUC
Medical screening where missing cases is costly	Recall
Search results where returned positives must be relevant	Precision
Balanced image classification	Accuracy plus per-class metrics
Predicting sale price	MAE, RMSE, R-squared
Comparing models during tuning	Validation performance, not test performance

Which preprocessing step?

Problem	Likely response
Missing numeric values	Impute, remove if justified, or investigate source
Text categories	Encode categories
Very different numeric scales	Scale or normalize for distance/gradient-sensitive models
Duplicated observations	Remove or investigate
High-cardinality categories	Use careful encoding strategy
Text data	Tokenize/vectorize
Image data	Resize/normalize
Time-ordered data	Preserve chronology when splitting

Common candidate mistakes

Concept mistakes

Saying AI, ML, and deep learning are identical.
Calling every automated system “machine learning.”
Forgetting that labels are required for supervised learning.
Confusing validation data with test data.
Treating accuracy as universally best.
Assuming unsupervised clusters are automatically meaningful.
Ignoring class imbalance.
Assuming generated AI content is reliable without verification.

Notes and examples

Python mistakes

Misreading Python indexing and slicing.
Forgetting that many operations return new objects rather than modifying in place, or the reverse.
Confusing a list of lists with a two-dimensional numeric array.
Ignoring data types in columns.
Treating missing values as ordinary strings.
Reusing the same variable for different meanings.
Not separating features from the target.
Applying transformations inconsistently between training and test data.

Workflow mistakes

Building a model before defining the problem.
Training and testing on the same data.
Tuning based on test results repeatedly.
Failing to document preprocessing.
Ignoring deployment conditions.
Not monitoring for data drift.
Choosing the most complex model first.
Forgetting ethical and privacy considerations.

Mini review scenarios

Scenario 1: High accuracy but poor minority detection

A model predicts “not fraud” for nearly every transaction and reports high accuracy because fraud is rare.

What to think:

This is likely class imbalance.
Accuracy is misleading.
Review precision, recall, F1, and minority-class performance.
Consider resampling, class weights, threshold tuning, or better features.

Notes and examples

Scenario 2: Excellent training score, weak test score

A decision tree performs almost perfectly on training data but poorly on unseen data.

This suggests overfitting.
Try pruning, limiting depth, using more data, or using cross-validation.
Compare with simpler baselines.

Scenario 3: Test data used during preprocessing

A dataset is scaled before splitting into train and test sets.

This may leak information.
Split first.
Fit preprocessing on training data only.
Apply the learned transformation to validation/test data.

Scenario 4: Text model produces fluent false answer

A generative AI system writes a confident but incorrect explanation.

This is a hallucination or unsupported generation.
Verify against trusted sources.
Use retrieval, constraints, review, and guardrails where appropriate.

Final-day review checklist

Before you move into practice questions, make sure you can answer these quickly:

What is the difference between AI, ML, and deep learning?
What makes a problem supervised, unsupervised, or reinforcement-based?
How do classification and regression differ?
What are features, labels, training data, validation data, and test data?
Why is data leakage dangerous?
When is accuracy misleading?
How do precision and recall differ?
What does overfitting look like?
Why do many models require numeric feature representations?
What does scaling do, and when can it matter?
What are common uses of NumPy and pandas in AI workflows?
What are tokenization, embeddings, and image channels?
Why is responsible AI part of technical AI practice?
Why must generative AI outputs be checked?
How does Python support reproducible, structured AI work?

Put the review into practice

Study Plan

PCEI-30-01 Cheat Sheet

AI and machine learning concept map

Machine learning workflow

Workflow decision points

Learning paradigms and task selection

End-to-end AI/ML workflow

Data types, features, and preprocessing choices

Python essentials for AI code questions

Core Python patterns

NumPy and pandas quick reference

Model selection matrix

Neural networks and deep learning

Metrics and evaluation

Confusion matrix terms

Train, validation, test, and cross-validation

Overfitting, underfitting, and fixes

Generative AI, NLP, and embeddings

Responsible AI, ethics, and risk controls

Responsible AI and ethics

Responsible AI decision rules

Scenario decision rules

Common traps to eliminate

Last-pass checklist for PCEI-30-01 review

High-yield exam mindset

Big-picture map

AI, ML, and deep learning

Core distinctions

Common misconceptions

Neural network vocabulary

Where deep learning is commonly useful

Deep learning traps

Python foundations for AI

Python concepts to review

Python mistakes that often appear in AI code

Python libraries in an AI workflow

Data fundamentals

Data terms

Data types and preprocessing

Data quality checklist

Arrays, tables, and shapes

Data frame habits

Supervised learning

Classification vs regression

Common supervised algorithms

Supervised learning traps

Unsupervised learning

Clustering review

Model evaluation essentials

Confusion matrix terms

Classification metrics

Regression metrics

Bias, variance, and generalization

Key ideas

Ways to reduce overfitting

Ways to reduce underfitting

Data splitting and leakage

Split types

Data leakage examples

Natural language processing basics

Computer vision basics

Generative AI review

Statistics and probability essentials

Concepts to recognize

Correlation warning

Fast decision tables

Which task is this?

Which metric is most appropriate?

Which preprocessing step?

Common candidate mistakes

Concept mistakes

Python mistakes

Workflow mistakes

Mini review scenarios

Scenario 1: High accuracy but poor minority detection

Scenario 2: Excellent training score, weak test score

Scenario 3: Test data used during preprocessing

Scenario 4: Text model produces fluent false answer

Final-day review checklist

Put the review into practice

Browse Certification Practice Tests