Ai for Beginners Guide: A step by step guide on how to use Ai

Overview: This guide gives you a clear, step-by-step path to learn and apply Ai, explaining core concepts, selecting tools, preparing data, and deploying simple models so you can build practical projects with confidence. You’ll find hands-on examples, best practices, and troubleshooting tips to accelerate your skills and help you make informed decisions about Ai adoption.

Key Takeaways:

• Understand core concepts: what Ai is, common models, capabilities and limitations.
• Use a practical workflow: define the goal, gather data, choose tools/models, craft and test prompts iteratively.
• Prioritize evaluation, safety, and data privacy while refining outputs and measuring performance.

Key Takeaways:

• Learn core concepts and common tools: what AI is, model types, and basic workflows for training and inference.
• Practice with step-by-step projects: follow tutorials, build small experiments, and iterate on prompts and inputs to improve results.
• Follow safety and quality practices: handle data responsibly, mitigate bias, validate outputs, and use trusted documentation and community resources.

Understanding AI

You’ll encounter AI as a toolkit of algorithms, data pipelines, and models that automate tasks like language understanding, image analysis, and forecasting; companies deploy these systems to cut manual work, personalize experiences, and surface insights from millions of records, so your hands-on experiments with pre-trained models and small datasets will quickly demonstrate core concepts and trade-offs.

What is Artificial Intelligence?

You should view AI as software systems that perform tasks once reserved for humans: NLP powers chatbots (e.g., GPT-family), computer vision enables medical image analysis, and recommendation engines tailor content; transformers (introduced 2017) unlocked large-scale language models that scale to billions of parameters and much richer behavior.

Types of AI

Your practical focus will be on narrow (specialized) AI, while general AI (AGI) remains theoretical; additionally, distinguish methods like supervised, unsupervised, and reinforcement learning, and architectures such as CNNs for images and transformers for text when choosing models for a project.

Narrow AI	Chatbots, image classifiers, recommender systems
General AI (AGI)	Hypothetical systems matching broad human abilities
Superintelligent AI	Theoretical systems surpassing human intelligence
Machine Learning	Supervised, unsupervised, reinforcement learning
Deep Learning	CNNs, RNNs, Transformers (e.g., ResNet, BERT, GPT)

• Decide whether your problem needs prediction, classification, or control.
• Pick architectures based on modality: CNNs for images, transformers for text.
• After you prototype, measure latency, throughput, and accuracy trade-offs.

You can deepen your approach by studying cases: AlphaGo beat Lee Sedol in 2016 using reinforcement learning and Monte Carlo tree search; GPT-3 (175 billion parameters, 2020) demonstrated few-shot language generation; such examples show that task framing, data volume, and compute budget (from hundreds to millions of dollars) determine feasibility for your project.

Task Specialization	Higher accuracy on narrow tasks
Data Needs	Tens of thousands to millions of labeled examples for large models
Compute	Training can range from GPU-hours to multi-million-dollar clusters
Transfer Learning	Fine-tuning pre-trained models reduces data and compute
Evaluation	Use held-out tests and real-world A/B experiments

• Define a clear metric (accuracy, F1, latency) to judge models.
• Start with pre-trained models to cut development time and cost.
• After you validate on held-out data, deploy incrementally and monitor drift.

Understanding Artificial Intelligence

What is AI?

You work with systems that automate tasks needing human-like intelligence: perception, language, planning, and decision-making. For example, supervised models trained on ImageNet’s 1.2M images power image classifiers, GPT-3 (175 billion parameters) generates coherent text, and reinforcement agents like AlphaGo beat Lee Sedol 4–1 in 2016. When you design solutions, match the algorithm class, dataset size, and evaluation metric to the specific task to get predictable results.

• You can prototype quickly using pre-trained models and transfer learning.
• You should track datasets, labels, and evaluation metrics to avoid bias.
• Any time you deploy your model, monitor for drift and unintended behavior.

Types of AI

You should separate AI into practical categories: narrow (task-specific) systems like chatbots and vision models, broader research goals such as artificial general intelligence (AGI), and enabling families like supervised learning, unsupervised learning, and reinforcement learning. For instance, deep CNNs transformed vision after AlexNet (2012), and transformer architectures enabled large-scale language models; choose narrow approaches first to deliver measurable value.

In practice, most production systems are narrow: recommendation engines drive a large share of engagement on platforms, virtual assistants handle intent routing, and industrial controllers optimize throughput. For example, reinforcement learning powered AlphaGo’s 2016 milestone, while transformers scaled language tasks to billions of parameters; use these case studies to select architectures and datasets for your project.

• You can combine supervised models with human-in-the-loop labeling to improve quality.
• You will often use transfer learning to reduce training time and data needs.
• Any evaluation plan should include fairness, robustness, and performance metrics.

Narrow AI	Virtual assistants, chatbots, and recommendation systems
Machine Learning	Supervised/unsupervised methods; ImageNet (1.2M images) for vision
Deep Learning	CNNs for vision, Transformers for NLP (e.g., GPT-3, 175B parameters)
Reinforcement Learning	AlphaGo (beat Lee Sedol 4–1 in 2016), robotics control
Artificial General Intelligence	Hypothetical research goal: broad, human-level cognitive abilities

Getting Started with AI

You can jump into a hands-on project right away: train a digit classifier on MNIST (60,000 training images) using Python with TensorFlow or PyTorch, run 10–20 epochs and track accuracy changes. Use Google Colab’s free GPU for quick iterations or create a local conda env (python=3.10) for offline work. Log experiments with Weights & Biases or TensorBoard, tweak learning rate and batch size, and compare results to learn what adjustments actually improve performance.

Tools and Software for Beginners

You should use Anaconda or venv to isolate projects, JupyterLab or VS Code for development, and Google Colab for free GPU access (sessions often up to ~12 hours). Install TensorFlow 2.x or PyTorch (1.12+), plus NumPy, pandas, and scikit-learn. Explore the Hugging Face Model Hub for pretrained models and datasets, and add Weights & Biases for experiment tracking to make results reproducible and easy to compare.

Setting Up Your AI Environment

You can create a reproducible environment with conda: conda create -n ai python=3.10 && conda activate ai, then pip install -r requirements.txt. For GPU training choose an NVIDIA card (for example, an RTX 3060 with 12GB VRAM) and install the matching CUDA/cuDNN versions; otherwise use Colab or a cloud VM. Also set up Git, a sensible .gitignore for data, and a Dockerfile if you need consistent deployments.

If you rely on a GPU, verify driver and CUDA compatibility up front—mismatches often cause import or runtime errors; consult tensorflow.org or pytorch.org for exact pairings. For testing pipelines start with small datasets like MNIST (60k samples) or CIFAR-10 (60k 32×32 images) before scaling to larger corpora. Also enable Git LFS for checkpoints and large files, automate periodic backups of model weights, and script environment creation with environment.yml or Dockerfile so you and collaborators can reproduce runs reliably.

Getting Started with AI Tools

You’ll pick tools based on immediate goals: rapid prototyping on Google Colab (free GPUs like T4/P100, sessions often up to ~12 hours), local development in JupyterLab, training with PyTorch or TensorFlow, and using Hugging Face or OpenAI APIs for pretrained models. Balance cost and scale — a single GPU with 8–16 GB VRAM handles many experiments, while production training often requires cloud instances (AWS p3/p4, GCP A2) and careful data management.

Popular AI Tools for Beginners

Start with Google Colab for zero-setup notebooks and JupyterLab for local control. Install PyTorch for research-style workflows and TensorFlow for production pipelines; use scikit-learn for classical ML tasks. Leverage Hugging Face’s model hub and inference API for transformers, OpenAI’s API for LLMs, and Runway ML or Lobe for visual no-code workflows. Many beginners fine-tune small transformer models on Colab + Hugging Face within a day to learn the full loop.

Setting Up Your AI Environment

Create isolated Python environments (python3 -m venv venv && source venv/bin/activate) and pip install -r requirements.txt, then verify GPU with nvidia-smi. Match your CUDA toolkit and driver when installing GPU-enabled PyTorch/TensorFlow, store API keys in environment variables (export OPENAI_API_KEY=…), and use Docker for reproducible containers. Pin package versions and use a requirements lockfile to avoid drifting dependencies during experiments.

For hardware and workflow hygiene, target 8–16 GB GPU memory for prototyping and reserve 50–100 GB disk for datasets and checkpoints. Use DVC or Git LFS for dataset versioning when files exceed ~100 MB, set random seeds (numpy, torch, tf) for reproducibility, and track runs with Weights & Biases or TensorBoard. When you need scale, provision cloud GPUs (AWS p3, GCP A2) and automate environment setup with simple scripts or Terraform.

Data Preparation

Importance of Data

You’ll spend roughly 60–80% of a typical AI project on data preparation, because model performance ties directly to data quality. High-quality labels and consistent features let models learn real patterns; noisy or biased inputs produce misleading results. For example, ImageNet’s 14 million labeled images enabled large-scale advances in vision; similarly, well-curated domain data accelerates your model’s accuracy and reduces costly retraining cycles.

Collecting and Cleaning Data

Start by inventorying sources (databases, APIs, CSVs) and sampling 10–20% for manual inspection to spot format issues or label drift. Then remove duplicates, standardize units, impute or flag missing values, and convert categories with one-hot or ordinal encoding. If classes are imbalanced (e.g., 95/5), apply stratified sampling, resampling, or class weighting to avoid biased models.

Use automated scripts (Pandas, SQL, Spark) for repeatable cleaning and keep a separate validation sample untouched. For imputation choose mean/median for numeric, mode or model-based methods for complex gaps, and K-fold cross-validation to test impacts. Detect outliers with IQR or z-score thresholds and decide case-by-case whether to cap, transform, or drop them. Finally, version datasets (DVC, Git LFS), log cleaning steps, and store a data dictionary so you can audit changes and reproduce experiments.

Basic AI Concepts

A model maps inputs to outputs using patterns learned from data, and you balance dataset size, model size, and compute to hit goals; models range from tiny classifiers with a few thousand parameters to large transformers like GPT‑3 (175 billion parameters). Training optimizes a loss across epochs (full passes through data) while inference applies the trained model in real time, so latency, batch size and evaluation metrics (accuracy, F1, AUC) determine deployment choices.

Machine Learning vs. Deep Learning

Classical machine learning uses algorithms like logistic regression, SVMs or random forests that perform well with engineered features and thousands of samples, whereas deep learning uses multi-layer neural networks (ResNet‑50 ≈25M params, BERT‑base ≈110M) and shines on vision/NLP when you have tens of thousands to millions of labeled examples (ImageNet ≈1.28M). You’ll prefer ML for interpretability and small data, and deep learning when raw data scale and GPUs are available.

Key Terminology

Supervised learning trains on labeled pairs (e.g., MNIST digits), unsupervised finds structure without labels (K‑means clustering), and reinforcement learning learns via rewards (DQN on Atari). Loss quantifies error, gradients drive updates, epochs are full dataset passes, batch size controls samples per update, and overfitting happens when your model fits noise instead of general patterns.

When tuning, you’ll experiment with hyperparameters: learning rates often span 1e‑3 to 1e‑5, batch sizes 16–512, and epochs 10–200 depending on dataset; regularization like dropout (0.1–0.5), weight decay (~1e‑4), augmentation (random crops/rotations) and early stopping (patience 5–10) reduce overfitting. Use validation metrics (precision/recall/F1, AUC) and methods like random search or Bayesian optimization to find robust settings across folds.

Building Your First AI Model

When building your first model, pick a clear metric (accuracy, F1, AUC) and an experimental plan: split data 80/20 and use 5-fold cross-validation. For images, start with a pretrained ResNet-50 on ImageNet; for tabular data try XGBoost or Random Forest; for text, fine-tune a small Transformer or LSTM. Aim for at least 1,000 labeled examples, scale numeric features, and log experiments with MLflow or Weights & Biases to track hyperparameters and results.

Choosing the Right Algorithm

When choosing an algorithm, match your data type and constraints. Start with logistic regression or decision trees for quick baselines, use XGBoost or LightGBM for tabular datasets under 100,000 rows, and pick CNNs like ResNet-50 or MobileNet for images (MobileNet saves memory for edge devices). For text, fine-tune a 6–12 layer Transformer or use DistilBERT to cut latency. Also balance interpretability, expected GPU hours, and target inference latency.

Training Your Model

When training your model, set realistic hyperparameters: start with batch size 32, learning rate 1e-3 using Adam, and 10–50 epochs while monitoring validation loss. Augment images (flip, crop, color jitter) and apply dropout (0.2–0.5) or weight decay (1e-4) to prevent overfitting. Use 16-bit mixed precision on GPUs to cut training time by ~2x and adopt a scheduler like ReduceLROnPlateau or cosine decay. Log metrics and use early stopping after 5–10 non-improving epochs.

Focus on systematic tuning: run 50–200 random or Bayesian trials with Optuna, and use stratified 5-fold cross-validation for imbalanced classes to stabilize AUC estimates. Transfer learning cuts required labeled data—fine-tuning ResNet-50 on 5,000 images often beats training from scratch. Warm up the learning rate for 1–5 epochs, use batch normalization, and measure both precision and recall if class weights differ. Track GPU hours and cost; constrain experiments to 8–12 GPU hours per round to stay efficient.

Step-by-Step Guide to Using AI

Pinpoint a measurable objective (accuracy, AUC, CTR), then run a quick baseline—logistic regression or XGBoost—to set expectations. Split data (commonly 80/20) and validate with 5-fold CV, iterate on features, and only then scale to deep models like ResNet50 or BERT when baseline gains stall. Track experiments, log metrics, and optimize for both performance and inference cost (latency, memory).

Step Breakdown

Step	What you do
Define objective	Set metric (AUC, F1, CTR); target improvement (e.g., +0.05 AUC).
Data Preparation	Clean, impute (median or KNN k=5), drop cols >50% missing, split 80/20, augment images (rotation, flip).
Feature engineering	Encode categorical (one-hot or embeddings), scale numeric, create interaction terms, PCA if >1000 dims.
Modeling	Start with logistic/XGBoost; move to CNNs or transformers; use transfer learning (ResNet50, BERT).
Training & tuning	Use Adam lr 1e-3, batch 32, early stopping (patience 5), 5-fold CV, grid/Bayesian search.
Evaluation & deploy	Assess AUC, F1, latency; compress (8-bit quantization ≈4× size reduction) and monitor post-deploy.

Data Preparation

Start by auditing data quality: remove duplicates, drop features with >50% missing, and impute numeric gaps with median or KNN (k=5). Tokenize text with WordPiece or BPE, apply TF‑IDF or contextual embeddings for NLP, and augment image sets via rotations and flips to expand small datasets from 1k–10k images into larger effective training pools.

Building and Training Models

Choose a model family based on data size: XGBoost for tabular, ResNet variants for images, BERT for text. Use transfer learning—fine-tune ResNet50 or BERT by unfreezing the last 2–4 layers. Train with Adam (lr 1e-3 baseline), batch 32 (or 16 for transformers), and run 3–50 epochs with early stopping (patience 5) while validating via 5‑fold CV.

For deeper tuning, run hyperparameter searches: test learning rates [1e-4,1e-3,1e-2], batch sizes [16,32,64], and regularization (dropout 0.1–0.5). Address class imbalance with class weights or SMOTE, log experiments (MLflow/TensorBoard), and prioritize reproducibility by fixing seeds. In practice, fine-tuning BERT on 10k labeled examples for 2–4 epochs often yields a 5–10 point F1 uplift versus training from scratch.

Evaluating AI Performance

Assess models on a held-out 20% test set and with 5-fold cross-validation, then benchmark against your baseline (logistic regression or XGBoost). Focus on both offline metrics and online results: ROC AUC, F1, and calibration on test data, plus A/B test lifts (for example, a 2–3% CTR uplift with p < 0.05). Monitor latency and throughput in staging—target under 200 ms and >100 req/s for user-facing systems—and track drift metrics to detect degradation after deployment.

Metrics for Success

Use task-specific metrics: classification needs precision, recall, F1 and ROC AUC (aim for AUC > 0.8 if feasible), ranking relies on NDCG or precision@k, and regression uses RMSE or MAE. Add calibration (Brier score) for probability outputs and business KPIs like revenue per user or churn reduction (e.g., 5% decrease). Define SLOs: latency <200 ms, 99th percentile latency <500 ms, and statistical significance thresholds (p < 0.05) for A/B tests.

Common Pitfalls to Avoid

Avoid overfitting, data leakage, and metric mismatch: a model can show 98% accuracy on a 1% positive class yet only 5% recall. Watch class imbalance, uncalibrated probabilities, and ignoring fairness metrics (disparate impact <0.8 signals bias). Also prevent silent production drift—population stability index (PSI) >0.25 often indicates distribution shift—and don’t deploy without monitoring for performance and business impact.

Mitigate these pitfalls with concrete steps: use stratified or time-based splits and K-fold CV, apply feature audits and permutation tests to detect leakage, calibrate probabilities with Platt scaling or isotonic regression, and instrument monitoring for PSI, AUC, and business KPIs. Automate retrain triggers (for example PSI > 0.25 or AUC drop > 0.05), run periodic fairness checks, and require A/B test significance (p < 0.05) before rollout.

Practical Applications of AI

You’ll find AI embedded across search, recommendations and automation: Google handles ~3.5 billion searches daily using ranking models, Netflix attributes roughly 75% of viewer activity to its recommender, and Gmail’s Smart Reply suggests millions of responses every day. When you apply models from the previous sections, target measurable gains like CTR lift, false-positive reduction or processing time cut, then run controlled A/B tests to quantify impact.

AI in Everyday Life

You interact with AI daily through voice assistants, search, maps and streaming. For example, search engines process about 3.5 billion queries per day and recommendation systems power platforms where recommendations drive ~75% of engagement. You can use off-the-shelf APIs for NLP, vision and personalization; prototype in hours, then measure uplift with simple A/B tests on a subset of users to validate real-world effect.

Industry-Specific Uses

In finance, models like JPMorgan’s COIN cut document review time—reportedly saving ~360,000 hours annually—while insurers use ML to speed claims triage. Healthcare examples include FDA-cleared AI for diabetic retinopathy (IDx‑DR, 2018). Manufacturing uses predictive maintenance to reduce unplanned downtime by up to 40%, and agriculture applies computer vision for yield estimates and pest detection to boost efficiency.

You should start industry pilots by defining ROI metrics (cost per claim, downtime hours saved) and collecting the right signals: transaction histories and device telemetry, plus thousands of labeled examples for supervised tasks. In practice, teams pair XGBoost or Random Forests for tabular fraud detection (AUC often >0.9 in scoped problems) with CNNs for imaging; time-series models or gradient-boosted trees on sensor features predict failures 7–14 days ahead. Deploy models at the edge for low-latency inference and monitor drift, retraining when performance drops beyond preset thresholds.

Practical Applications of AI

You see AI driving measurable gains across sectors: recommendation engines account for roughly 35% of Amazon’s revenue, UPS’s ORION route-optimizer saves the company up to $400 million annually, and Google’s DeepMind cut data-center cooling energy by about 40% in trials. In healthcare, FDA-approved tools like IDx‑DR speed diabetic retinopathy screening, while factories use predictive maintenance to reduce downtime and boost yield.

Industry Use Cases

In finance, ML detects fraud and automates credit scoring while trading firms run microsecond models for execution. In healthcare, imaging AI and decision-support tools shorten diagnosis times—IDx‑DR is an FDA-cleared example. Manufacturing uses anomaly detection to cut downtime by up to 30%, and retail applies demand forecasting and dynamic pricing to trim inventory and raise margins. You can link these to clear KPIs when building business cases.

AI in Everyday Life

On a daily basis you interact with AI via voice assistants (Siri, Google Assistant), navigation that predicts traffic, and personalized streaming—Netflix attributes up to 80% of viewing to recommendations. Smart thermostats like Nest report about 10–12% heating savings, and email filters plus chatbots take on routine tasks so you can focus on higher-value work.

To make AI practical for your routine, enable built-in features: turn on smart replies in Gmail, use Google Maps’ predictive routing, and opt into personalized suggestions on streaming apps. You can automate home scenes with Nest schedules or IFTTT, set bill reminders, and use calendar summarization to reduce planning time. Small automations like these often free hours each month and lower daily decision friction.

Challenges and Ethical Considerations

You will face technical, operational, and ethical hurdles at once: data quality and label noise eat up 60–80% of your time, scaling models can require thousands of GPU hours and thousands of dollars, and regulatory risk (GDPR, CCPA) can halt deployments if you automate high‑impact decisions. Expect trade‑offs between accuracy, latency, and explainability, and plan for monitoring, rollback, and clear documentation so incidents like biased hiring or flawed recidivism scores don’t blindside you.

Common Challenges in AI Implementation

You’ll encounter messy data, concept drift, and integration gaps when moving from prototype to production. For example, models that perform well in offline tests often degrade within weeks unless you set up monitoring, retraining pipelines, and CI/CD for models; many teams report spending more than half their project time on data prep and validation. Also budget for inference costs, latency SLAs, and governance to align stakeholders and legacy systems.

Ethical Implications of AI

You must address bias, privacy, and accountability before deployment: historical datasets can encode discrimination (see Amazon’s 2018 hiring tool or COMPAS debates), and automated decisions affecting loans, hiring, or policing carry legal and reputational risk. Implement impact assessments, obtain informed consent for sensitive data, and document decision pathways so you can justify outcomes to regulators and users.

To mitigate harms, run fairness tests (demographic parity, equalized odds) across protected groups with at least 100 samples per cohort for statistical stability, use explainability tools like SHAP or LIME to audit individual predictions, and apply technical controls such as DP‑SGD for differential privacy when handling sensitive records. Additionally, maintain model cards and datasheets, log inputs/outputs for audits, and establish an incident response plan tied to legal counsel and ethics review to act fast if issues surface.

Conclusion

The Ai for Beginners Guide gives you clear, step-by-step methods to evaluate tools, craft effective prompts, test outputs, and integrate Ai into your workflows, so you can build practical skills, avoid common pitfalls, and apply Ai confidently to real tasks.

To wrap up

Ultimately, you have a clear, practical path to adopt AI: follow the step-by-step techniques to set objectives, choose tools, craft prompts, test outputs, and evaluate results; iterate on prompts and workflows, monitor biases and privacy, and integrate AI into real tasks to boost productivity while maintaining oversight. With hands-on practice and continual learning, you’ll build reliable skills to apply AI safely and effectively.

FAQ

Q: What is AI and how do I get started with a step-by-step approach?

A: Artificial intelligence (AI) refers to systems that perform tasks that normally require human intelligence, such as language understanding, image recognition, and decision support. Step-by-step to get started: 1) Define a clear, narrow goal (e.g., generate marketing copy, summarize documents, classify images). 2) Learn core concepts: types of models (rule-based vs. machine learning), supervised vs. unsupervised learning, training vs. inference, data basics. 3) Choose accessible tools: web-based assistants, no-code platforms, or beginner-friendly libraries (e.g., Hugging Face, OpenAI, Google Vertex AI). 4) Collect or prepare a small dataset or examples to test with. 5) Prototype quickly using prompts or pretrained models; iterate on prompt wording and example inputs. 6) Validate outputs with real users or sample checks, refine prompts/data, and add constraints for safety and privacy. 7) Once results are reliable, plan deployment (simple scripts, integration with existing apps, or automation) and set up monitoring and update cycles for ongoing improvement.

Q: How do I craft effective prompts for AI tools?

A: Effective prompts are specific, structured, and testable. Steps and tips: 1) State the role and objective (e.g., “You are an editor. Rewrite this paragraph to be concise and professional.”). 2) Provide context and any relevant background data or examples. 3) Specify output format, length, tone, and constraints (bullets, JSON, word limit). 4) Give positive and negative examples if possible (show the desired style and what to avoid). 5) Break complex tasks into smaller steps or use chain-of-thought prompts to guide reasoning. 6) Use system-level instructions or model settings (temperature, max tokens) to control creativity vs. precision. 7) Iterate: test edge cases, compare variations, and keep a prompt library of successful patterns. 8) Add verification steps (ask the model to cite sources or list assumptions) to reduce incorrect or unsupported statements.

Q: How can I evaluate AI outputs and safely integrate AI into my workflow?

A: Evaluate outputs using objective and practical checks: 1) Accuracy and factuality: verify against trusted sources or run automated fact-checks for critical tasks. 2) Relevance and usefulness: score outputs against your goal using examples or human raters. 3) Consistency and robustness: test with varied inputs and edge cases. 4) Bias and safety: audit for harmful language, unfair treatment, or privacy leaks; implement filters and guardrails. Integration steps: start with a human-in-the-loop for review, log inputs/outputs for troubleshooting, and create versioned prompts or datasets for reproducibility. Automate gradually (APIs, scheduled jobs, or integrations) and monitor performance, cost, and user feedback. Maintain data governance: control sensitive data, enforce access policies, and plan for periodic model or prompt updates when behavior degrades or requirements change.