> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Data Types in AI Models
> Overview of AI data types, preprocessing techniques, model selection, and AWS tooling for handling numerical, categorical, text, image, audio, and time series data
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.
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
```python theme={null}
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
pipeline = Pipeline([
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
X_transformed = pipeline.fit_transform(X_numeric)
```
Numerical datasets commonly live in Amazon S3, Redshift, or managed databases and are integrated into SageMaker training workflows for forecasting or sensor analytics.
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
```python theme={null}
import pandas as pd
X_onehot = pd.get_dummies(df[['product_type','region']], drop_first=False)
```
SageMaker Data Wrangler and preprocessing utilities simplify encoding pipelines and integration into model training.
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
```python theme={null}
from sklearn.feature_extraction.text import TfidfVectorizer
tfidf = TfidfVectorizer(max_features=10000, ngram_range=(1,2))
X_text = tfidf.fit_transform(corpus)
```
AWS tools: Amazon Comprehend for managed NLU tasks; SageMaker for custom NLP training and deployment.
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
```python theme={null}
from torchvision import transforms
transform = transforms.Compose([
transforms.Resize((224,224)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
])
```
AWS Rekognition supports common image and video analysis; SageMaker enables custom vision model training and deployment.
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)
```python theme={null}
import librosa
y, sr = librosa.load('audio.wav', sr=16000)
mel_spec = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=64)
```
Challenges: background noise, accents, and variable volume — apply noise reduction and normalization before training.
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).
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).
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).
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
```python theme={null}
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(class_weight='balanced')
```
Frameworks like SageMaker support sampling, weighting, and distributed preprocessing to handle imbalance at scale.
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.
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.
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
* Amazon SageMaker: [https://aws.amazon.com/sagemaker/](https://aws.amazon.com/sagemaker/)
* AWS Glue: [https://aws.amazon.com/glue/](https://aws.amazon.com/glue/)
* Amazon EMR: [https://aws.amazon.com/emr/](https://aws.amazon.com/emr/)
* Amazon Rekognition: [https://aws.amazon.com/rekognition/](https://aws.amazon.com/rekognition/)
* Amazon Transcribe: [https://aws.amazon.com/transcribe/](https://aws.amazon.com/transcribe/)
* Amazon Comprehend: [https://aws.amazon.com/comprehend/](https://aws.amazon.com/comprehend/)
Table — Quick reference: data types, preprocessing, and AWS tools
| Data type | Typical preprocessing | Common models | AWS services |
| - | - | - | - |
| Numerical | Scaling, imputation, outlier handling | Linear models, GBDT, neural nets | S3, SageMaker |
| Categorical | One-hot, label encode, embeddings | Trees, neural nets | SageMaker Data Wrangler |
| Text | Tokenization, TF-IDF/embeddings, cleaning | Transformers, RNNs, classifiers | Amazon Comprehend, SageMaker |
| Image | Resize, normalize, augment | CNNs, transfer learning | Amazon Rekognition, SageMaker |
| Audio | MFCC/spectrogram, denoise | CNN/RNN/transformers | Amazon Transcribe, SageMaker |
| Time-series | Resampling, detrend, windowing | ARIMA, LSTM, transformers | SageMaker, Prophet (external) |
Good luck — focus on practicing each pipeline end-to-end and validating preprocessing decisions with experiments.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.