Scikit-learn, covered in our Python for Machine Learning tutorial, handles classical algorithms well: decision trees, logistic regression, random forests. But once a problem involves images, audio, or genuinely large, unstructured datasets, those classical approaches start hitting a ceiling that deep learning is built to push past. This TensorFlow tutorial for beginners covers exactly that gap: what tensors actually are, how to build and train a neural network with Keras, and when reaching for TensorFlow makes more sense than sticking with scikit-learn.

TensorFlow, originally built by Google’s Brain team, remains one of the two dominant deep learning frameworks in production use today, alongside PyTorch. As of 2026, TensorFlow sits at version 2.21, built around Keras 3 as its primary high-level API, and it requires Python 3.10 through 3.13.

Setting Up Your Environment

# CPU-only installation
pip install tensorflow

# GPU-enabled installation (requires compatible NVIDIA hardware and CUDA)
pip install tensorflow[and-cuda]

Verify the installation and check whether TensorFlow detects a GPU

import tensorflow as tf

print(tf.__version__)
print("GPU available:", tf.config.list_physical_devices('GPU'))

A GPU dramatically speeds up training for anything beyond small models, but everything in this tutorial runs perfectly well on a CPU too, just more slowly for the larger examples.

Understanding Tensors

A tensor is TensorFlow’s core data structure, conceptually similar to a NumPy array but with two important additions: tensors can run on a GPU for massively parallel computation, and TensorFlow automatically tracks the operations performed on them to compute gradients during training, a process called automatic differentiation.

import tensorflow as tf

# A scalar (0-dimensional tensor)
scalar = tf.constant(7)

# A vector (1-dimensional tensor)
vector = tf.constant([1, 2, 3])

# A matrix (2-dimensional tensor)
matrix = tf.constant([[1, 2], [3, 4]])

print(scalar.shape, vector.shape, matrix.shape)
print(matrix.numpy())  # convert back to a NumPy array

If you’ve worked through our NumPy tutorial, tensor indexing, reshaping, and arithmetic will feel immediately familiar, since TensorFlow deliberately mirrors NumPy’s syntax and behavior wherever possible.

a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])

print(tf.add(a, b))       # element-wise addition
print(a + b)              # same result, operator overloading works too
print(tf.matmul(a, b))    # matrix multiplication

How TensorFlow and Keras Fit Together

Keras is TensorFlow’s high-level API for building and training neural networks, and as of Keras 3, it’s designed to work across multiple backends, TensorFlow, PyTorch, and JAX, though this tutorial uses it through TensorFlow, its original and most common pairing. Nearly nobody builds a neural network using TensorFlow’s lower-level operations directly anymore; Keras handles the layer definitions, training loop, and optimization details, letting you focus on architecture and data rather than reimplementing gradient descent by hand.

Building Your First Neural Network

The most common way to build a simple network is Keras’s Sequential API, stacking layers in order from input to output.

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

model.summary()

Each Dense layer is fully connected, meaning every neuron in that layer connects to every neuron in the previous one. The first layer’s input_shape=(10,) tells the model to expect input data with 10 features. The final layer has a single neuron with a sigmoid activation, appropriate for binary classification, since sigmoid squashes its output into a range between 0 and 1, interpretable as a probability.

The Functional API for More Complex Models

Sequential works well for straightforward, single-path architectures, but many real models need multiple inputs, multiple outputs, or layers that branch and merge, structures a simple stack can’t express. Keras’s Functional API handles this by treating layers as callable functions applied to tensors directly.

inputs = keras.Input(shape=(10,))
x = layers.Dense(64, activation='relu')(inputs)
x = layers.Dense(32, activation='relu')(x)
outputs = layers.Dense(1, activation='sigmoid')(x)

functional_model = keras.Model(inputs=inputs, outputs=outputs)
functional_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

This produces functionally the same model as the Sequential example above, but the Functional API’s real value shows up once you need something more complex, for instance a model with two separate input branches that merge partway through:

input_a = keras.Input(shape=(10,))
input_b = keras.Input(shape=(5,))

branch_a = layers.Dense(32, activation='relu')(input_a)
branch_b = layers.Dense(16, activation='relu')(input_b)

merged = layers.concatenate([branch_a, branch_b])
output = layers.Dense(1, activation='sigmoid')(merged)

multi_input_model = keras.Model(inputs=[input_a, input_b], outputs=output)

This pattern comes up often in practice, combining structured tabular features with image or text data in a single model, something Sequential‘s strictly linear stack simply can’t represent.

Layers, Activation Functions, and Loss Functions

Activation functions introduce non-linearity between layers, which is what actually lets a neural network learn complex patterns rather than just a linear combination of inputs. ReLU (Rectified Linear Unit) is the standard choice for hidden layers, returning the input directly if positive and zero otherwise, since it’s computationally cheap and works well in practice across most problems. Sigmoid suits binary classification output layers, squashing output to a 0-1 probability range. Softmax suits multi-class classification output layers, producing a probability distribution across all classes that sums to 1.

Loss functions measure how wrong a model’s predictions are, and the training process works to minimize this value. Common choices: binary_crossentropy for two-class classification, categorical_crossentropy for multi-class classification with one-hot encoded labels, sparse_categorical_crossentropy for multi-class classification with integer labels instead, and mean_squared_error for regression problems predicting a continuous value.

Picking the wrong loss function for your problem type is one of the most common beginner mistakes, and it usually produces a model that trains without erroring out but never actually learns anything useful.

Compiling and Training a Model

Before training, a model needs to be compiled with an optimizer, loss function, and the metrics you want tracked during training.

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

import numpy as np

# Example synthetic data: 1000 samples, 10 features each
X_train = np.random.random((1000, 10))
y_train = np.random.randint(0, 2, (1000, 1))

history = model.fit(
    X_train, y_train,
    epochs=20,
    batch_size=32,
    validation_split=0.2
)

adam is the most commonly used optimizer, adapting the learning rate automatically during training and performing reliably well across a wide range of problems without heavy manual tuning. An epoch is one complete pass through the entire training dataset; batch size controls how many samples the model processes before updating its weights once, with smaller batches training more slowly but sometimes generalizing better, and larger batches training faster but requiring more memory. validation_split=0.2 holds out 20% of the training data to monitor performance on data the model isn’t directly training on, which is essential for catching overfitting as it happens rather than only after training finishes.

Evaluating and Making Predictions

X_test = np.random.random((200, 10))
y_test = np.random.randint(0, 2, (200, 1))

test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_accuracy:.2%}")

predictions = model.predict(X_test[:5])
print(predictions)  # probabilities, not final class labels

predicted_classes = (predictions > 0.5).astype(int)
print(predicted_classes)

model.predict() returns raw probabilities for classification problems, not final class labels directly, so converting a sigmoid output above 0.5 into a class label, as shown above, is a step you handle explicitly rather than something the model does automatically.

Building a Regression Model

Predicting a continuous value rather than a class follows the same overall workflow, with a few specific adjustments to the output layer and loss function.

regression_model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),
    layers.Dense(32, activation='relu'),
    layers.Dense(1)  # no activation function on the output layer
])

regression_model.compile(
    optimizer='adam',
    loss='mean_squared_error',
    metrics=['mae']  # mean absolute error, easier to interpret than MSE
)

y_train_continuous = np.random.random((1000, 1)) * 100

regression_model.fit(
    X_train, y_train_continuous,
    epochs=20,
    validation_split=0.2
)

The output layer for regression has no activation function at all, since applying sigmoid or softmax would artificially constrain the output to a fixed range, which makes no sense when predicting an unrestricted continuous value like a price or a temperature. Tracking mae (mean absolute error) alongside the loss is common practice, since it’s expressed in the same units as the target variable, making it more directly interpretable than the squared error the model is actually optimizing against internally.

Preventing Overfitting

Neural networks, with their large number of parameters, are particularly prone to overfitting, memorizing training data rather than learning patterns that generalize. A few standard techniques address this directly.

model_with_dropout = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(10,)),
    layers.Dropout(0.3),
    layers.Dense(32, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(1, activation='sigmoid')
])

Dropout(0.3) randomly disables 30% of neurons in that layer during each training step, forcing the network to avoid depending too heavily on any single neuron and generally improving how well it generalizes to new data.

Early stopping halts training automatically once validation performance stops improving, avoiding wasted computation and further overfitting from training too long:

early_stop = keras.callbacks.EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True
)

model.fit(
    X_train, y_train,
    epochs=100,
    validation_split=0.2,
    callbacks=[early_stop]
)

patience=5 waits five epochs without improvement before stopping, since validation loss can fluctuate slightly from epoch to epoch even when the overall trend is still improving. restore_best_weights=True ensures the final model reflects its best-performing state, not just whatever weights existed when training stopped.

Convolutional Neural Networks for Image Data

Standard Dense layers treat input as a flat list of numbers, which discards the spatial structure that makes images images, which pixels are near which other pixels. Convolutional Neural Networks (CNNs) are built specifically to preserve and exploit that spatial structure.

cnn_model = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

cnn_model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

Conv2D layers slide small filters across an image, learning to detect increasingly complex visual features, edges and simple shapes in early layers, more abstract patterns in deeper ones. MaxPooling2D reduces the spatial dimensions between convolutional layers, cutting computation while retaining the most important detected features. Flatten converts the resulting multi-dimensional feature maps into a single flat vector, which the final Dense layers then use to make an actual classification decision. This architecture, or close variations of it, remains the standard starting point for image classification tasks that don’t require the very largest, most cutting-edge model architectures.

Working With Real Image Datasets

Real image datasets typically live as folders of image files rather than a conveniently preloaded array, and Keras provides a utility to load them directly from a directory structure where each subfolder represents a class.

train_dataset = keras.utils.image_dataset_from_directory(
    'data/train',
    image_size=(180, 180),
    batch_size=32
)

val_dataset = keras.utils.image_dataset_from_directory(
    'data/validation',
    image_size=(180, 180),
    batch_size=32
)

Real-world image datasets also benefit heavily from data augmentation, artificially expanding a training set by applying random transformations, which helps a model generalize better and reduces overfitting, particularly when the amount of available training data is limited.

data_augmentation = keras.Sequential([
    layers.RandomFlip('horizontal'),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
])

augmented_model = keras.Sequential([
    data_augmentation,
    layers.Rescaling(1./255),
    layers.Conv2D(32, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(10, activation='softmax')
])

Rescaling(1./255) normalizes pixel values from their original 0-255 range down to 0-1, which, as covered in the common mistakes section below, matters considerably for how well and how quickly a network trains. Augmentation layers only apply their random transformations during training, automatically switching off during evaluation and prediction, so validation and test performance still reflects the model’s behavior on genuinely unmodified images.

Transfer Learning: Building on Pretrained Models

Training a strong image classification model from scratch typically requires a large dataset and substantial compute time. Transfer learning sidesteps both problems by starting with a model already trained on a massive dataset, then adapting it to your specific, usually much smaller, problem.

base_model = keras.applications.MobileNetV2(
    input_shape=(180, 180, 3),
    include_top=False,
    weights='imagenet'
)
base_model.trainable = False  # freeze the pretrained weights

transfer_model = keras.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

transfer_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

MobileNetV2, pretrained on the large, diverse ImageNet dataset, has already learned to recognize a broad range of general visual features, edges, textures, shapes, that transfer well to many other image tasks. Setting base_model.trainable = False freezes those pretrained weights, so training only adjusts the new layers added on top, which trains dramatically faster and requires far less data than training a comparable model entirely from scratch. Once the new layers have converged, unfreezing some of the later base model layers for a final round of fine-tuning at a low learning rate often improves performance further, a common two-stage pattern in practical transfer learning workflows.

Monitoring Training With TensorBoard

Watching raw numbers scroll by during training makes it hard to spot trends. TensorBoard provides an interactive dashboard for visualizing training and validation metrics as they happen.

tensorboard_callback = keras.callbacks.TensorBoard(log_dir='./logs')

model.fit(
    X_train, y_train,
    epochs=20,
    validation_split=0.2,
    callbacks=[tensorboard_callback]
)

Launch the dashboard from a terminal with tensorboard --logdir=./logs, then open the URL it provides in a browser. Watching loss and accuracy curves visually makes patterns like overfitting, where training and validation curves start diverging, considerably easier to spot early than scanning through printed epoch-by-epoch numbers in a terminal.

Saving and Loading Models

Training can take anywhere from seconds to hours or days, so saving a trained model for later use without retraining is essential.

model.save('my_model.keras')

loaded_model = keras.models.load_model('my_model.keras')
predictions = loaded_model.predict(X_test[:5])

The .keras format, the current standard, saves the model’s architecture, trained weights, and training configuration together in a single file, making it straightforward to reload and immediately use for prediction or continue training later without needing to redefine the model’s structure from scratch.

TensorFlow vs. PyTorch vs. Scikit-learn

Scikit-learn remains the right default for structured, tabular data, classical problems like customer churn prediction or fraud detection, where classical algorithms often match or outperform deep learning anyway while training faster and staying easier to interpret. Our Python for Machine Learning tutorial covers this territory in depth.

TensorFlow suits deep learning problems, particularly where production deployment across servers, mobile, and edge devices matters, given its mature deployment tooling (TensorFlow Serving, TensorFlow Lite) built up over years of real-world enterprise use.

PyTorch has become the more common choice in research and increasingly in new production systems too, generally considered to have a more intuitive debugging experience and more flexible model-building approach, though the practical gap between the two frameworks has narrowed considerably in recent years.

For a beginner, the honest answer is that either TensorFlow or PyTorch is a reasonable starting point for deep learning specifically, and the core concepts, tensors, layers, loss functions, backpropagation, transfer directly between them once you understand one framework well.

Common Beginner Mistakes

Not normalizing input data. Neural networks train considerably better when input features are scaled to a similar range, typically 0 to 1 or standardized to mean 0 and standard deviation 1, rather than left in wildly different original scales.

Choosing the wrong loss function for the problem type. Using mean_squared_error for a classification problem, or binary_crossentropy for a multi-class problem, produces a model that technically trains without erroring but never learns anything meaningful.

Ignoring the validation loss curve. A model whose training loss keeps improving while validation loss gets worse is overfitting in real time, and catching this early through validation_split and early stopping saves considerable wasted training time.

Training for too many or too few epochs. Too few epochs leaves a model underfit, never given enough opportunity to learn the underlying pattern. Too many, without early stopping or dropout in place, invites overfitting, and neither extreme actually helps final performance.

Shape mismatches between layers. A Dense layer’s input_shape needs to match your actual data’s shape exactly, and a Conv2D layer expects image data in a specific dimensional format; getting this wrong produces an error immediately, but tracing exactly which layer caused it can be confusing at first without a systematic approach to checking shapes at each step.

Practice Project

A solid way to apply this TensorFlow tutorial’s concepts end to end: load the built-in MNIST dataset of handwritten digit images (tf.keras.datasets.mnist.load_data()), normalize the pixel values to a 0-1 range, build a CNN using the architecture pattern shown above, train it with early stopping, and evaluate its accuracy on the held-out test set. MNIST is small and clean enough to train quickly even on a CPU, while still giving you hands-on experience with the full image classification workflow: data preprocessing, CNN architecture, training with callbacks, and evaluation.

Frequently Asked Questions

Do I need a GPU to learn TensorFlow? No, not for learning the fundamentals. Small models and datasets like MNIST train reasonably quickly even on a CPU. A GPU becomes genuinely important once you’re working with larger images, bigger datasets, or more complex architectures, where training time on a CPU alone would stretch from minutes into hours or days.

Should I learn TensorFlow or PyTorch first? Either is a reasonable choice, and the underlying deep learning concepts transfer directly between them. TensorFlow’s Keras API is often considered slightly more beginner-friendly for a first introduction, while PyTorch is currently more dominant in research and academic settings. Many working deep learning practitioners end up comfortable with both over time.

Do I need to understand backpropagation and calculus to use TensorFlow effectively? Not to get started productively, no. TensorFlow’s automatic differentiation handles the gradient calculations behind training entirely automatically. Understanding the concept at a high level, that the model adjusts its weights based on how much each one contributed to the error, is genuinely useful, but you don’t need to derive the math by hand to build and train working models.

What’s the difference between Keras and TensorFlow? Keras is the high-level API for building and training models; TensorFlow is the underlying computational engine that actually executes the operations, handles automatic differentiation, and manages hardware acceleration. As of Keras 3, Keras can also run on top of PyTorch or JAX instead of TensorFlow, though the TensorFlow pairing remains the most common and the one this tutorial uses throughout.

How much data do I need before deep learning outperforms classical machine learning? There’s no universal threshold, but as a rough guideline, classical algorithms in scikit-learn often match or beat deep learning on datasets with a few thousand rows or fewer, particularly for structured, tabular data. Deep learning’s advantages tend to show up more clearly with larger datasets and unstructured data, images, audio, and text, where classical feature engineering approaches struggle to compete.

Is TensorFlow only useful for images? No. While CNNs for image data are a common starting point for learning, TensorFlow and Keras handle a wide range of problems, including tabular data with Dense layers, sequential data like time series or text with recurrent or transformer-based architectures, and increasingly the large language and generative models that have driven much of the recent attention in AI.

What is transfer learning, and why is it so commonly recommended for beginners? Transfer learning starts with a model already trained on a large, general dataset and adapts it to a new, more specific problem, rather than training an architecture entirely from scratch. It’s recommended for beginners because it typically requires far less data and training time to get strong results, and it sidesteps the need for the massive compute resources training a competitive model from zero would otherwise demand.

Do I need to know the exact math behind gradient descent to use TensorFlow well? Not to build and train working models, no. TensorFlow’s automatic differentiation handles the actual gradient calculations without requiring you to derive them manually. A solid conceptual understanding, that training nudges weights in the direction that reduces error, matters more day to day than being able to write out the underlying calculus by hand.

Where to Go From Here

This TensorFlow tutorial for beginners covered tensors, building neural networks with Keras’s Sequential API, activation and loss functions, training with proper validation monitoring, preventing overfitting through dropout and early stopping, CNNs for image data, and saving models for reuse. From here, the fastest way to build real depth is working through the MNIST practice project above end to end, then experimenting with a slightly larger, messier image dataset to see how the same fundamentals hold up outside a clean, well-prepared example.

If you’re still building the foundation this tutorial assumes, our Python tutorial and NumPy tutorial with examples cover the fundamentals TensorFlow builds directly on, and our Python for Machine Learning tutorial covers the classical algorithms worth knowing before deciding deep learning is genuinely the right tool for a given problem. For complete reference on every layer, function, and API mentioned here, the official TensorFlow tutorials and Keras documentation are both worth bookmarking as your primary ongoing resources.