关于TensorFlow中tf.keras.Sequential工作原理及activation、input_shape参数的疑问

Hey there! Let's break down exactly what's going on with tf.keras.Sequential and those parameters like activation and input_shape—no overly technical jargon, just clear, practical explanations that make sense for beginners.

First, let's start with the big picture: tf.keras.Sequential is just a "linear stack" of layers. Think of it like stacking Lego bricks one on top of the next—data goes into the first layer, gets processed, then passes directly to the second layer, and so on until it comes out the last layer. It's perfect for simple models where each layer only connects to the one before and after it (no fancy skip connections or branching, which would need a different model type like the Functional API).

Let's walk through your code line by line to unpack every part:

import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

1. The Sequential Container #

All you're doing here is telling TensorFlow: "I want a model where layer 1 feeds into layer 2, end of story." It handles all the behind-the-scenes work of passing data between layers so you don't have to manually wire them up.

2. First Dense Layer: tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)) #

Let's break each parameter:

• Dense: This is a "fully connected" layer—every neuron in this layer is connected to every neuron from the previous layer (or the input data, for the first layer). It's the most basic building block for learning patterns in data.
• 64: This is the number of neurons in the layer. Each neuron learns a small pattern in the data, so 64 means the layer will output a 64-dimensional set of features from your input.
• activation='relu': The activation function is what gives your model nonlinearity. Without it, even a stack of 100 Dense layers would just be a fancy linear equation—and linear equations can't learn complex patterns like handwritten digits. ReLU (Rectified Linear Unit) is super simple: it takes any input value, keeps it if it's positive, and sets it to 0 if it's negative. This "gatekeeping" helps the model focus on meaningful features and ignore noise.
• input_shape=(784,): This is only needed for the first layer—it tells TensorFlow what shape your input data is. In your case, (784,) means each input sample is a 1D vector of 784 numbers (like flattening a 28x28 MNIST image into a single list of pixels). All subsequent layers automatically figure out their input shape from the previous layer's output, so you never need to set this again after the first layer.

3. Second Dense Layer: tf.keras.layers.Dense(10, activation='softmax') #

• 10: 10 neurons because you're doing 10-class classification (like recognizing digits 0-9). Each neuron corresponds to one class.
• activation='softmax': This activation function turns the layer's raw outputs into probabilities. Each output value will be between 0 and 1, and all 10 values add up to 1. So if the 3rd neuron outputs 0.9, that means the model is 90% sure the input is the digit 3. Perfect for multi-class classification tasks.

4. The model.compile() Step #

This is where you set up the "training rules" for your model:

• optimizer='adam': The optimizer is the algorithm that adjusts your model's internal weights to make predictions more accurate. Adam is a great default—it automatically tweaks the learning rate (how big of a "step" the model takes to fix its mistakes) so you don't have to mess with it manually.
• loss='categorical_crossentropy': This is the "error metric" the model uses to measure how wrong its predictions are. For multi-class tasks where your labels are one-hot encoded (e.g., digit 3 is represented as [0,0,0,1,0,0,0,0,0,0]), this loss function penalizes the model when its predicted probabilities are far from the true label.
• metrics=['accuracy']: This is just a human-readable metric to track during training—accuracy tells you what percentage of samples the model predicts correctly. It doesn't affect training, but it's super useful to see how well your model is doing.

Why Sequential Makes Sense Here #

Your model is a straight line: input → 64-node hidden layer (with ReLU) → 10-node output layer (with Softmax). Sequential is the simplest way to build this because it handles all the data passing between layers automatically. You don't have to write code to connect layer 1's output to layer 2's input—it just works.

To make this even more concrete, here's a quick extension of your code to train it on the MNIST dataset (so you can see it in action):

# Load the MNIST handwritten digit dataset
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Preprocess the data: flatten images to 784-length vectors, normalize pixel values to 0-1
x_train = x_train.reshape(-1, 784) / 255.0
x_test = x_test.reshape(-1, 784) / 255.0

# Convert labels to one-hot encoding (required for categorical_crossentropy)
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Train the model for 5 epochs (full passes over the training data)
model.fit(x_train, y_train, epochs=5, batch_size=32, validation_split=0.1)

# Evaluate how well the model does on unseen test data
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")

When you run this, you'll see the accuracy metric go up each epoch—this means the model is learning to connect the 784 pixel values to the correct digit class, using the Sequential stack you built.

Quick Recap to Clear Up Confusion #

• Sequential is for simple, linear layer stacks (no complex connections)
• input_shape only needs to be set on the first layer—it defines the shape of your raw input data
• activation functions add nonlinearity so your model can learn complex patterns (ReLU for hidden layers, Softmax for multi-class outputs)
• Each Dense layer's neuron count depends on your task (more neurons = more capacity to learn, but don't overdo it—too many can lead to overfitting)

内容来源于stack exchange