如何用TensorFlow训练后的MLP模型预测单条文本标签？

Hey there! Let’s walk through exactly how to use your trained TensorFlow model to predict a label for a single string input—this is straightforward once you align your prediction pipeline with what you did during training.

Step 1: Reuse Your Training Preprocessing Pipeline #

First, your model expects input in the exact same format as the data you trained it on. If you used tools like Tokenizer to turn strings into numeric sequences, or padded/truncated sequences to a fixed length, you need to repeat those steps for your single input.

For example, if your training code looked something like this:

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Training setup
tokenizer = Tokenizer(num_words=10000)
tokenizer.fit_on_texts(your_train_texts)
max_seq_length = 100  # Fixed length for all sequences

You’ll need to reuse this exact tokenizer (and max length) for prediction. Pro tip: Save your tokenizer after training so you don’t have to refit it later—use tokenizer.to_json() to save it to a file.

Step 2: Load Your Trained Model & Tokenizer #

First, load the model you saved after training, then load the tokenizer you saved:

import tensorflow as tf
from tensorflow.keras.preprocessing.text import tokenizer_from_json

# Load the trained model
model = tf.keras.models.load_model('your_saved_model.h5')  # Replace with your model path

# Load the saved tokenizer
with open('tokenizer.json', 'r') as f:
    tokenizer_json = f.read()
tokenizer = tokenizer_from_json(tokenizer_json)

max_seq_length = 100  # Must match the value you used during training

Step 3: Preprocess the Single String Input #

Turn your single string into a format the model can understand:

def preprocess_input(input_str):
    # Convert string to numeric sequence
    sequence = tokenizer.texts_to_sequences([input_str])
    # Pad the sequence to the fixed length used in training
    padded_sequence = pad_sequences(sequence, maxlen=max_seq_length)
    return padded_sequence

# Your single input string
test_string = "Put your single string input here!"
processed_input = preprocess_input(test_string)

Note: If you did any other preprocessing during training (like lowercasing text, removing punctuation), make sure to apply those to your test string too!

Step 4: Run Prediction & Interpret the Result #

Now feed the processed input to your model and decode the output:

# Run prediction
predictions = model.predict(processed_input)

# Interpret the result based on your task:
# 1. For multi-class classification (e.g., 3 labels)
labels = ['label_a', 'label_b', 'label_c']  # Replace with your actual label list
predicted_label_index = tf.argmax(predictions[0]).numpy()  # Get index of highest confidence
predicted_label = labels[predicted_label_index]

# 2. For binary classification (e.g., positive/negative)
# predicted_prob = predictions[0][0]
# predicted_label = "positive" if predicted_prob > 0.5 else "negative"

print(f"Predicted label: {predicted_label}")
print(f"Confidence scores: {predictions[0]}")

Key Things to Double-Check #

• Make sure every preprocessing step (tokenization, padding, text cleaning) matches exactly what you did during training—small differences will break your predictions.
• If you didn’t save your tokenizer earlier, you’ll need to refit it using your original training text before you can process new inputs.
• If your model uses any custom layers or metrics, you’ll need to include those when loading the model (use custom_objects in load_model() if needed).

内容的提问来源于stack exchange，提问作者tim_xyz