Skip to main content
Welcome — this is Michael Forrester. In this lesson we cover a foundational topic for AI practitioners: the data types used in AI models and how those types determine preprocessing, feature extraction, and model selection. These concepts can be technical. If you’re unfamiliar with math or data science basics, take notes and review the examples. Key distinctions—such as structured vs. unstructured data and labeled vs. unlabeled data—are important for practical projects and for certification exams. A “data type” here refers to the representation and structure of input data fed to AI systems. Common categories include numerical, categorical, text, image, audio, and time-series data. Each requires different preprocessing and modeling strategies; handling them correctly is crucial for accurate results and reliable production systems.
A dark-blue presentation slide titled "Data Types in AI Models – Introduction" showing four colorful icons and labels on the left for Numerical, Categorical, Text, and Images. The rest of the slide is mostly empty space.
Callouts: data preprocessing matters
Preprocessing choices directly influence how models learn. Use the right scaling, encoding, and augmentation strategies for each data type — and validate changes with cross-validation and holdout sets.
Practical note on AWS tooling AWS provides services that streamline preprocessing and data management at scale:
  • AWS Glue and Amazon EMR for large-scale ETL and data processing.
  • Amazon SageMaker (Data Wrangler, Processing Jobs, Ground Truth) for data preparation, labeling, and model training.
  • Domain-specific services like Amazon Rekognition (vision), Amazon Transcribe (speech-to-text), and Amazon Comprehend (NLP).
Numerical data Numerical data are quantitative measurements (integers, floats) used in regression, forecasting, and many ML algorithms. They can also encode binary conditions (0/1 flags). Common preprocessing steps:
  • Scaling: standardization (zero mean, unit variance) or min-max normalization.
  • Outlier handling: clipping or transformations (log, Box–Cox).
  • Imputation: fill missing numbers with mean/median or model-based predictions.
Example: scale and impute with scikit-learn
Numerical datasets commonly live in Amazon S3, Redshift, or managed databases and are integrated into SageMaker training workflows for forecasting or sensor analytics.
A dark-themed slide titled "Numerical Data" showing a small table of time, price and sensor temperature values on the left, an AI model brain icon in the center, and icons labeled "Financial forecasting" and "Sensor data analysis" on the right.
Categorical data Categorical variables group observations into discrete buckets (e.g., product type, region, status). Most ML algorithms expect numeric inputs, so categorical data must be encoded. Common encoding techniques:
  • One-hot encoding: binary indicator columns for each category (suitable for nominal features).
  • Label encoding: integer mapping (useful for ordinal features or some tree-based models).
  • Target encoding or embeddings: handle high-cardinality categories or capture target-related information.
Example: one-hot encoding with pandas
SageMaker Data Wrangler and preprocessing utilities simplify encoding pipelines and integration into model training.
A diagram titled "Categorical Data" showing a table of product types (A, B) and regions (North, South) being transformed via a central "One-Hot Encoding" box into binary columns A, B, North, and South. Arrows illustrate the input-to-output encoding process.
Text data and natural language processing (NLP) Text is unstructured and requires tokenization and transformation into numeric representations before modeling. Typical steps include tokenization, normalization, stop-word removal, stemming/lemmatization, and vectorization. Common representations:
  • Bag-of-words / TF-IDF for simple classification tasks.
  • Word embeddings (Word2Vec, GloVe) for semantic information.
  • Subword tokenizers and transformer token IDs for modern language models.
NLP workflow checklist:
  • Tokenize and manage vocabulary.
  • Clean or normalize text (lowercase, punctuation handling).
  • Convert tokens to embeddings or indices.
  • Apply modeling: classification, entity extraction, summarization, etc.
Example: TF-IDF with scikit-learn
AWS tools: Amazon Comprehend for managed NLU tasks; SageMaker for custom NLP training and deployment.
A dark-themed diagram of an NLP pipeline: raw text data is preprocessed (tokenization, stop-word removal), fed into an NLP model, and yields outputs like sentiment analysis and text classification.
Image data Images are unstructured arrays of pixels. Preprocessing includes decoding, resizing, normalization, and augmentation to improve model robustness. Convolutional neural networks (CNNs) and transfer learning are widely used for vision tasks. Typical image pipeline:
  • Load and decode images.
  • Resize and normalize pixel values (e.g., scale to [0, 1] or standardize).
  • Apply augmentation (rotation, flips, color jitter).
  • Use CNNs or pretrained backbones for feature extraction and classification.
Example: simple torchvision transforms
AWS Rekognition supports common image and video analysis; SageMaker enables custom vision model training and deployment.
A schematic pipeline showing an image classification workflow: a raw image goes through preprocessing steps (resizing, normalization, augmentation), is fed into an AI model, and outputs labels like “Cat” or “Dog.”
Audio data and speech Audio is time-series-style data and typically requires feature extraction (MFCCs, spectrograms) before modeling. Preprocessing often involves denoising, resampling, and normalization. Common approaches:
  • Extract spectrograms or MFCC features for classification.
  • Use waveform-based neural networks or transformer-based audio models for end-to-end tasks.
  • For speech-to-text, use services like Amazon Transcribe or build custom ASR models.
Example: compute a Mel spectrogram (high-level)
Challenges: background noise, accents, and variable volume — apply noise reduction and normalization before training.
A simple flow diagram showing audio data fed into Amazon Transcribe (with Mel-Frequency Cepstral Coefficients) that outputs the text "Hello Everyone!".
Structured vs. unstructured data The structured vs. unstructured distinction guides algorithm choice and preprocessing complexity:
  • Structured: tabular data with fixed schema (rows/columns). Easier to clean, encode, and feed into tree-based models or linear models.
  • Unstructured: free-form text, images, audio, or video. Requires feature extraction, embeddings, or deep learning models.
Choosing algorithms:
  • Structured: decision trees, gradient-boosted trees, and linear models.
  • Unstructured: neural networks (CNNs for vision, transformers for language, and hybrid models for multimodal tasks).
An infographic titled "Structured vs Unstructured Data" showing a neat grid of document and square icons labeled Structured Data on the left and a jumbled cluster of document shapes labeled Unstructured Data on the right. A stylized AI brain icon sits centered between the two.
Data quality and preprocessing best practices High-quality inputs are essential for high-quality models. Core preprocessing tasks include:
  • Cleaning: remove duplicates and correct obvious errors.
  • Encoding: convert categories to numeric representations.
  • Scaling: normalize numeric ranges.
  • Imputation: handle missing values robustly.
  • Balancing and augmentation: address class imbalance or increase dataset diversity.
Practical checklist:
  • Visualize distributions and correlations.
  • Log-transform skewed variables when appropriate.
  • Use cross-validation to measure preprocessing effects.
  • Track preprocessing steps in reproducible pipelines (SageMaker Processing Jobs, Data Wrangler).
Labeled vs. unlabeled data
  • Labeled data: inputs paired with target labels (used for supervised learning — classification, regression).
  • Unlabeled data: no explicit targets; used in unsupervised learning (clustering, anomaly detection) or self-supervised methods.
Exam tip: Labeled vs. unlabeled is often tested. Labeled data ⇒ supervised learning. Unlabeled data ⇒ unsupervised or self-supervised approaches (clustering, anomaly detection, representation learning).
A comparison diagram titled "Labeled vs Unlabeled Data" showing a left panel with cat and dog icons labeled as "Labeled Data" for supervised learning, and a right panel with the same icons unlabeled as "Unlabeled Data" for unsupervised learning.
Time-series data Time-series data are sequences indexed by time; order matters. Forecasting and sequential prediction use historical patterns (trend, seasonality, cyclic behavior). Common methods:
  • Statistical: ARIMA, exponential smoothing.
  • ML/DL: LSTM, GRU, temporal CNNs, transformer-based time-series models.
  • Tools: Facebook Prophet for trend/seasonality, or SageMaker for custom deep learning models.
Key considerations:
  • Capture seasonality and trend components.
  • Handle temporal cross-validation (e.g., rolling-window validation).
  • Beware of data leakage (do not use future information in training features).
A dark-blue slide titled "Time-Series Data" showing a grid chart with two colored line graphs (red/orange) and markers. The lines fluctuate with peaks and dips and trend upward to a final spike on the right.
Imbalanced data Imbalance occurs when classes are unequally represented, biasing models toward the majority class. Select appropriate techniques and metrics. Strategies:
  • Oversample the minority class (simple duplication, SMOTE).
  • Undersample the majority class.
  • Use class weighting or focal loss to penalize minority errors more.
  • Evaluate with precision/recall, F1-score, ROC-AUC, and PR-AUC rather than accuracy alone.
Example: class weighting in scikit-learn
Frameworks like SageMaker support sampling, weighting, and distributed preprocessing to handle imbalance at scale.
A slide titled "Imbalanced Data." It explains that imbalanced data occurs when one class has many more examples than others, which can lead to models that favor the dominant class.
A slide titled "Handling Imbalanced Data" showing a pie chart with a small highlighted slice and three colored icons labeled "Oversampling," "Undersampling," and "ROC–AUC."
Big data and scalable AI Large, varied datasets improve model generalization but require scalable storage and processing:
  • Storage: Amazon S3.
  • Processing: AWS EMR, AWS Glue.
  • Labeling at scale: SageMaker Ground Truth.
  • Training: distributed training with SageMaker and multi-instance jobs.
Design pipelines that are reproducible, monitor dataset drift, and use sample-based experiments before full-scale training. Missing data and imputation Missing values can bias models. Choose an imputation strategy that matches the data generation process:
  • Simple: mean/median/mode.
  • Model-based: use a predictive model to fill missing values.
  • Indicator flags: add a column indicating missingness (sometimes informative).
Always validate the impact of imputation with experiments and sensitivity analysis.
An infographic titled "Handling Missing Data in AI Models" showing an upper table with missing age and salary entries for four people and a lower table where those missing values have been filled (e.g., ages for Bob/Diana set to 27.5 and some salaries set to 60,000). It illustrates imputing missing dataset values.
Summary: match data type to model and preprocessing Understanding data types drives your preprocessing pipeline and model choice:
  • Structured/tabular data: decision trees, gradient-boosted trees, linear models (after encoding categoricals and scaling numericals).
  • Images: convolutional neural networks and transfer learning.
  • Text: transformer-based models or embeddings + downstream classifiers.
  • Time-series: ARIMA, LSTM, temporal transformers, and specialized forecasting tools.
  • Audio: spectrogram/MFCC extraction + CNN/RNN/transformer models.
Supervised models need labeled data; unsupervised approaches work on unlabeled data. Hybrid approaches (self-supervised, semi-supervised) are increasingly common.
A presentation slide titled "Final Thoughts – Choosing the Right Data Type for AI Models" with three numbered cards. The cards recommend Decision Trees for structured/tabular data, CNNs for unstructured data (e.g., text/images), and RNNs for time-series data.
Wrap-up We covered:
  • Numerical, categorical, text, image, audio, and time-series data.
  • Structured vs. unstructured and labeled vs. unlabeled data.
  • Key preprocessing steps: cleaning, encoding, scaling, imputation, augmentation.
  • Handling imbalance, missing values, and big data at scale.
  • How data type influences algorithm selection and real-world tooling.
For deeper learning, practice building pipelines for each data type, experiment with AWS tooling (SageMaker, Glue, EMR, Rekognition, Transcribe, Comprehend), and focus on supervised vs. unsupervised workflows. Links and references Table — Quick reference: data types, preprocessing, and AWS tools Good luck — focus on practicing each pipeline end-to-end and validating preprocessing decisions with experiments.

Watch Video