Build a Food Classification Pipeline with Python and TensorFlow

IntroductionTensorFlow food image classification is a practical way to recognize what’s inside an image and turn pixels into a label your app can use.
In this tutorial, you’ll build a 36-class fruits and vegetables classifier in Python using TensorFlow / Keras, while using OpenCV for consistent preprocessing.
You’ll load a dataset, standardize image sizes, create NumPy arrays for fast training, train the model, evaluate accuracy, and run predictions on unseen images.If you’re learning computer vision, this workflow is a solid baseline you can reuse for other image classification projects.

Code for Food Classification :Want the exact dataset so your results match mine?If you want to reproduce the same training flow and compare your results to mine, I can share the dataset structure and what I used in this tutorial. Send me an email and mention the name of the tutorial / dataset , so I know what you’re requesting.🖥️ Email: feitgemel@gmail.com

Master Computer Vision

Follow my latest tutorials and AI insights on my Personal Blog.

Beginner

Complete CV Bootcamp

Foundation using PyTorch & TensorFlow.

Get Started →

Interactive

Deep Learning with PyTorch

Hands-on practice in an interactive environment.

Start Learning →

Advanced

Modern CV: GPT & OpenCV4

Vision GPT and production-ready models.

Go Advanced →

Project Setup and Labels
We set up the project environment, define food labels, and initialize containers for image data and targets.You will import essential Python libraries that handle files, images, and arrays.
OpenCV reads and resizes images so your dataset is uniform for modeling.
NumPy stores the pixel data efficiently and allows vectorized operations.
Dedicated lists will hold images and labels before they are converted into NumPy arrays for training.The labels list describes which food item appears in each image.
This list is created once and reused for both training and testing data.
Consistent labels guarantee that your food classification model learns the right mapping.
They also simplify evaluation when you classify food on unseen images.We also print progress information to the console.
Progress messages help you debug early and confirm that files are discovered.
They also validate that class names are resolved correctly from directory paths.
Small checks like these save time when datasets are large.

### In this tutorial we will build a reproducible pipeline for food classification using Python. # In this tutorial we will make a fruit and vegtables classificaion model using TensorFlow and Keras  ### Import os to work with files and directories during data collection for food classification. import os ### Import OpenCV to load and resize images before we classify food with a model. import cv2 ### Import NumPy to manage arrays that will store image pixels for food classification. import numpy as np ### Import save helper to write NumPy arrays to disk for later training runs. from numpy import save  ### Define the canonical list of class names for food classification. # Array of all the classes  class_names = ["banana", "apple", "pear", "grapes", "orange", "kiwi", "watermelon", "pomegranate", "pineapple", "mango", "cucumber", "carrot", "capsicum", "onion", "potato", "lemon", "tomato", "raddish", "beetroot", "cabbage", "lettuce", "spinach", "soy beans", "cauliflower", "bell pepper", "chilli pepper", "turnip", "corn", "sweetcorn", "sweetpotato", "paprika", "jalepeno", "ginger", "garlic", "peas", "eggplant"]  ### Initialize a list to store all training images as arrays to support food classification. train_data_array = [] ### Initialize a list to store numeric labels that correspond to each training image. train_data_labels_array = []  ### Print a status message to confirm the training load process has started. print ("Loading the train data ")

Link for the full code : https://ko-fi.com/s/bba2540d4fLoad and Preprocess Training ImagesWe load images from the training folders, resize them to a fixed shape, and attach the correct label for food classification.Consistent image size is crucial for food classification models.
Neural networks expect uniform dimensions to process batches efficiently.
Resizing standardizes the input and allows fair comparison across images.
It also reduces memory usage and speeds up training when you classify food.
You iterate through the training directory tree to discover images.
Each file path is combined with its folder to get a full location.
Images that fail to load are skipped to keep the dataset clean.
This prevents corrupt files from degrading the food classification pipeline.Resizing to 28×28 creates compact inputs for rapid experimentation.
This size is useful for demonstrating the pipeline and debugging.
You can increase the size later to capture more detail when you classify food.
The key is to keep width and height consistent for every image.Labels are derived from folder names that mirror the class list.
A stable mapping from name to index ensures reproducibility.
Appending both image arrays and their labels keeps data aligned.
This alignment is essential for supervised training in food classification tasks.Finally, arrays are converted to NumPy ndarrays for efficient storage.
Shape prints confirm correct counts and dimensions.
You can quickly spot anomalies before moving to modeling.
Early validation increases confidence when you classify food at scale.

### Define the root directory that contains training images organized by food class. rootdir = "C:/Python-cannot-upload-to-GitHub/Fruit-and-Vegetable/train"  ### Walk through the directory tree to discover class folders and image files. for subdir , dirs , files in os.walk(rootdir):     ### Iterate over files found in the current class folder.     for file in files:         ### Read the image from disk using OpenCV so we can classify food later.         frame = cv2.imread(os.path.join(subdir, file))          ### Skip invalid files to keep the training data for food classification clean.         if frame is None:             ### Log that this item is not a valid image file.             print("not an image")         else:             ### Print the folder and file name for progress visibility.             print(subdir,file)              ### Many images have different sizes, so we standardize to a fixed 28x28 shape.             ### Resizing ensures uniform inputs for food classification models.             resized = cv2.resize(frame,(28,28), interpolation=cv2.INTER_AREA)             ### Confirm that resizing succeeded by checking the height dimension.             checkSize = resized.shape[0] #checking that the resize was done successfuly             ### Append the resized image and its numeric label if the size is correct.             if checkSize ==28 :                 ### Store the resized image in the training data list.                 train_data_array.append(resized)                 ### Derive the class index from the folder name for label alignment.                 index = class_names.index(os.path.basename(subdir))                 ### Store the numeric label for supervised learning in food classification.                 train_data_labels_array.append(index)  ### Convert the list of images into a NumPy array for efficient tensor operations. # converts the lists to numpy arrays train_data = np.array(train_data_array) ### Convert the list of numeric labels into a NumPy array for modeling. train_data_lables = np.array(train_data_labels_array)  ### Print completion message to signal that the training data is ready. print ("Finished loading the train data") ### Print the number of training samples loaded for food classification. print ("Number of train records : ", train_data.shape[0] )  ### Print shapes to verify dimensions of the training images and labels. print(train_data.shape) print(train_data_lables.shape)  ### The following demo code can visualize a couple of training images if needed. # while running , lets add more code :  ### Display two sample images to sanity-check labels during food classification development. # lets see 2 examples of the images :  ### Select a sample image by index for quick inspection. # demoImage = train_data[4] # lets look at image number 4 ### Show the image in a window. # cv2.imshow("Demo image", demoImage) ### Retrieve and print the human-readable class name for the sample. # index = train_data_lables[4] # print (class_names[index])  ### Repeat the process for a second sample image if desired. # #lets add another sample image  # demoImage2 = train_data[5] # lets look at image number 4 # cv2.imshow("Demo image2", demoImage2) # index = train_data_lables[5] # print (class_names[index])  ### Wait for a key press before closing the display windows. # cv2.waitKey(0)  ### Persist the training arrays to disk so you can reload them quickly when you classify food. # lets save the data to the disk in numpy binary format: save('c:/temp/train_data.npy', train_data) ### Save the label array alongside the images for training. save('c:/temp/train_data_labels.npy', train_data_lables)

Link for the full code : https://ko-fi.com/s/bba2540d4fPrepare Test Set and Persist DatasetsWe load the test set, create both small and large resized images, validate shapes, and save all arrays for future food classification experiments.A separate test set helps you estimate how well your model will classify food on unseen images.
Preparing it with the same preprocessing ensures fair evaluation.
Creating a larger preview size is useful for visualization and reporting.
Saving everything to disk accelerates iteration across experiments.You define the root directory of the test split and repeat the traversal.
Each image is resized to 28×28 for modeling.
A second 280×280 version is created for inspection and result presentation.
This dual size approach serves both modeling and communication needs.Invalid images are again filtered out to maintain data quality.
Labels are mapped identically from folder names to numeric indices.
This keeps the test set aligned with the training set in your food classification pipeline.
Consistent labeling is critical when you classify food across splits.After processing, arrays for images, large previews, and labels are created.
Printing shapes confirms counts and dimensions before saving.
Finally, arrays are written to disk using NumPy’s binary format.
This makes reloads instant and keeps preprocessing deterministic.

### Announce the start of test data loading to mirror the training process. #lets continue to the test data  print("Start loading the test data ") ### Define the root directory containing test images by food class. rootdir = "C:/Python-cannot-upload-to-GitHub/Fruit-and-Vegetable/test"  ### Prepare lists to hold resized test images and their labels. test_data_array = [] ### Prepare a list for numeric labels corresponding to test images. test_data_labels_array = []  ### Keep a separate list for larger 280x280 images for visualization. # lets build another arrray for the bigger images , so we can see it after building the Tensorflow model test_data_big_array = []  ### Walk through the test directory structure to find images for food classification evaluation. for subdir , dirs , files in os.walk(rootdir):     ### Iterate through each file discovered in the current class directory.     for file in files:         ### Load the image from disk using OpenCV.         frame = cv2.imread(os.path.join(subdir, file))          ### Skip any entries that are not valid images to keep the test set clean.         # check the validity of the image          if frame is None:             ### Log invalid entries to the console.             print("not an image")         else:             ### Print path and filename for progress tracking.             print(subdir,file)             ### Create a larger 280x280 version for visualization and reporting.             # just to have the ability to see a "normal" size image             resizedBig = resized = cv2.resize(frame,(280,280), interpolation=cv2.INTER_AREA)             ### Create a compact 28x28 version for model input during food classification.             resized = cv2.resize(frame,(28,28), interpolation=cv2.INTER_AREA)             ### Verify that the resized image has the expected dimension.             checkSize = resized.shape[0] #checking that the resize was done successfuly             ### Append the processed image and label if size is correct.             if checkSize ==28 :                 ### Store the 28x28 image for modeling.                 test_data_array.append(resized)                 ### Store the 280x280 image for visualization.                 test_data_big_array.append(resizedBig)                 ### Lookup the label index from the folder name to align with training classes.                 index = class_names.index(os.path.basename(subdir))                 ### Append the label to the test label list.                 test_data_labels_array.append(index)  ### Convert lists into NumPy arrays for efficient evaluation and storage. test_data = np.array(test_data_array) ### Convert the preview images into a NumPy array. test_data_big = np.array(test_data_big_array) ### Convert the test labels into a NumPy array for metrics calculation. test_data_labels = np.array(test_data_labels_array)  ### Print a completion message to confirm that the test set is ready. print("Finished loading the test data ") ### Print how many test records are available for food classification evaluation. print ("Number of test records : ", test_data.shape[0] ) ### Print shapes to confirm array dimensions match expectations. print(test_data.shape) print(test_data_labels.shape)  ### Save the processed test arrays to disk to allow instant reuse across runs. # save the numpy arrays as numpy binary to the disk  save('c:/temp/test_data.npy', test_data) ### Save the large preview images for visualization workflows. save('c:/temp/test_data_big.npy', test_data_big) ### Save the aligned labels for evaluation consistency in food classification. save('c:/temp/test_data_labels.npy', test_data_labels)

Link for the full code : https://ko-fi.com/s/bba2540d4fData Loading and Normalization for Food ClassificationThis section loads previously saved arrays for training and testing to enable fast iteration in food classification workflows.
It confirms dataset shapes, aligns labels, and normalizes pixel ranges to stabilize optimization when you classify food.
It prepares inputs for TensorFlow by scaling values from 0–255 to 0–1, which helps gradients behave predictably.
It completes the foundation required to move directly into model building for food classification.Saved arrays accelerate the workflow by removing repetitive disk scans and per-run decoding.
Using consistent class mappings ensures that each image corresponds to the correct label during training and evaluation.
Printing shapes validates the integrity of the data splits and prevents misalignment between images and labels.
Normalization ensures that features share a comparable scale, improving convergence and classification stability.When you classify food across many categories, clean data handling is essential for reproducible results.
Memory-efficient arrays and clear logging make it easier to manage larger datasets and track progress.
By standardizing the preprocessing, experiments become comparable across epochs and hyperparameters.
This consistency is crucial for measuring real improvements in food classification performance.These steps also prepare the ground for deployment in lightweight environments.
Tensors normalized to [0,1] are easy to feed into different backends or exported models.
A stable input convention reduces bugs when switching from training to inference.
This reliability improves confidence when you classify food in production systems.

### Move to the modeling stage of the food classification pipeline. # Now we will move to next step of building a model using Tensor Flow and Keras  ### Import OS utilities for path handling used by the food classification workflow. import os ### Import OpenCV for optional visualization during food classification. import cv2 ### Import NumPy for array operations with image tensors in food classification. import numpy as np ### Import the load helper to read saved NumPy arrays that back the classify food steps. from numpy import load  ### Import TensorFlow to build and train the neural network for food classification. import tensorflow as tf  ### Import Keras high-level APIs to define layers and models that classify food. from tensorflow import keras ### Reduce TensorFlow log verbosity so food classification logs are concise. os.environ["TF_CPP_MIN_LOG_LEVEL"]="2" # Reduce the information messages  ### Define the canonical set of class names for multiclass food classification. # Array of all the classes  class_names = ["banana", "apple", "pear", "grapes", "orange", "kiwi", "watermelon", "pomegranate", "pineapple", "mango", "cucumber", "carrot", "capsicum", "onion", "potato", "lemon", "tomato", "raddish", "beetroot", "cabbage", "lettuce", "spinach", "soy beans", "cauliflower", "bell pepper", "chilli pepper", "turnip", "corn", "sweetcorn", "sweetpotato", "paprika", "jalepeno", "ginger", "garlic", "peas", "eggplant"]  ### Load the training image tensors for food classification directly from disk. #load the saved train and test data train_data = load('c:/temp/train_data.npy') ### Load the aligned training labels that map images to food classes. train_data_lables = load('c:/temp/train_data_labels.npy') ### Load the test image tensors used to evaluate how well we classify food. test_data = load('c:/temp/test_data.npy') ### Load the larger test images for visualization of classify food predictions. test_data_big = load('c:/temp/test_data_big.npy') ### Load the test labels for objective accuracy measurement in food classification. test_data_labels = load('c:/temp/test_data_labels.npy')  ### Confirm that arrays are loaded and ready to classify food. print("Finish loading the data ")  ### Optionally preview a training sample to verify content before you classify food. #show a sample data - image number 116 in the train data # demoImage = train_data[116] # cv2.imshow('demoImage',demoImage) # index = train_data_lables[116] # print(class_names[index]) # cv2.waitKey(0)  ### Print data shapes to validate dimensions for the food classification model. # data shape : print("train shape : ", train_data.shape) ### Print label shape to confirm one label per training image in food classification. print("train lables shape : ", train_data_lables.shape) ### Print test image shape for the evaluation split when you classify food. print("test data shape:", test_data.shape) ### Print test label shape to ensure alignment for accuracy computation. print("test data labels shape:", test_data_labels.shape)  ### Normalize training images from [0,255] to [0,1] for stable food classification training. # the values of each pixel is 0 to 255 . We would like ot change it between 0 to 1 train_data = train_data / 255.0 ### Normalize test images using the same scale so we can classify food consistently. test_data = test_data / 255.0

Link for the full code : https://ko-fi.com/s/bba2540d4fBuild and Train the Neural Network to Classify FoodThis section defines a simple yet effective neural network to perform food classification.
It flattens 28×28×3 inputs, uses a dense hidden layer with ReLU activation, and outputs 36 softmax probabilities.
It compiles the model with Adam and sparse categorical cross-entropy to handle integer labels efficiently.
It trains the network for multiple epochs to learn discriminative patterns that classify food correctly.Dense architectures can perform strongly when inputs are compact and classes are well defined.
ReLU mitigates vanishing gradients and encourages sparse activations for efficient learning.
Softmax converts logits into a probability distribution across all food classes.
These choices create a balanced baseline for food classification before exploring deeper architectures.Compilation defines how the model learns and how performance is measured.
Adam provides adaptive learning rates that converge quickly on normalized inputs.
Sparse categorical cross-entropy matches integer labels, keeping memory usage low.
Accuracy reporting offers an intuitive metric for how well the model can classify food.Training schedules influence the final accuracy of food classification.
More epochs allow the network to refine boundaries between visually similar items.
Batch progression and gradient updates adjust weights to reduce loss steadily.
Careful monitoring prevents overfitting and enables targeted improvements to classify food robustly.

### Create a sequential Keras model to perform food classification on 36 classes. # build the model model = keras.Sequential([     ### Flatten 28x28x3 images into a 1D vector suitable for dense layers in food classification.     # first we will flatten the images . We will take the 28X28X3 and flatten the shape as the input to the model     keras.layers.Flatten(input_shape=(28,28,3)), # this is the input layer      ### Add a hidden dense layer with ReLU activation to learn non-linear patterns that classify food.     # lets define the hidden layer.     # we dont know what is the exact number , so will try with 512 neurons     keras.layers.Dense(512,activation='relu'), # relu has no negative values.      ### Add the final softmax layer with 36 outputs, one per food class, to support food classification.     # this is the last layer - the classifation for the classes      # we have 36 classes (Apple , banana , orange .........)     keras.layers.Dense(36,activation='softmax') # softmax has return values between 0 to 1  ])  ### Log completion of the model architecture for food classification. print('Finish build the model skeleton')  ### Compile the model with an optimizer, loss, and metric appropriate for classify food tasks. # compile the model model.compile(     ### Use Adam optimizer to accelerate convergence for normalized inputs in food classification.     # optimizer -> calulate the gradient descent of the network     optimizer='adam',     ### Use sparse cross-entropy since labels are integer-encoded for classify food training.     # loss function     loss = 'sparse_categorical_crossentropy',     ### Track accuracy to monitor how well we classify food over epochs.     metrics=['accuracy'] # metrics measurment )  ### Log completion of the compile step. print('Finish compile the model')  ### Train the model for multiple epochs to learn how to classify food accurately. # train the model # we start with a 10 epochs , but probebly will update the number to a bigger one during the sessions model.fit(train_data,train_data_lables,epochs=120)

Link for the full code : https://ko-fi.com/s/bba2540d4fEvaluate, Predict, Visualize, and Compare Food Classification ResultsThis section evaluates generalization on a held-out test set to measure how well we classify food on unseen data.
It prints accuracy, generates probability predictions, and extracts the top class with argmax.
It overlays the predicted label on a large preview image for human-readable validation.
It compares predicted and ground-truth labels across the test set to assess consistency.Objective metrics guide improvements to food classification pipelines.
A strong test accuracy indicates effective feature learning and class separation.
Per-image predictions help discover hard cases and visually similar foods.
This visibility supports targeted data augmentation and model refinements that classify food better.Interactive visualization bridges the gap between numbers and intuition.
Annotating images with predicted labels makes errors obvious and actionable.
Inspecting successes and failures reveals dataset biases and class overlaps.
These insights inform the next iteration of food classification experiments.Batch comparisons provide quick scans for systemic issues.
Repeated confusions can suggest merging classes, collecting more samples, or tuning architecture.
Clear logging helps document progress across experiments.
This discipline improves reliability when you classify food at scale.

### Evaluate the trained model on the test split to measure food classification accuracy. # we got loss: 0.2574 - accuracy: 0.9329 #lets test it on a new data . A data that the model never seen test_loss , test_acc = model.evaluate(test_data,test_data_labels,verbose=1) # verbose is a paramter of how detailed is the log in the console ### Print the overall test accuracy to summarize how well we classify food. print("*******************         Test accuracy : ", test_acc)  ### Generate probability distributions for each test image to classify food. # we have a result of : Test accuracy :  0.941504180431366  ## very good result - near 1 # predictions predictions = model.predict(test_data) ### Optionally print raw prediction arrays for detailed inspection during classify food analysis. #print(predictions) # we will get predicitions for the whole test data  ### Announce which sample index will be inspected in detail. # lets show the predictions of a specific image , for example : image number 100 print ('The predicted class index :')  ### Extract the top class index for image 100 using argmax to classify food. #first we will show the outcome  # for every test image we will get 36 numbers between 0 to 1 # we got 36 numbers. # the higher number is the predicted class , so we have to extracr the index in the 36 list class_index = np.argmax(predictions[100]) # get the max value ### Print the predicted index to the console for traceability. print(class_index)  ### Map the index to a human-readable class name for food classification reporting. class_name = class_names[class_index] ### Print the predicted class name. print('the class name :', class_name)  ### Retrieve a large preview image and overlay the predicted label to visualize classify food results. # lets show the image number 100 # We saved test data as bigger files 280X280 . We will use it now demoImage = test_data_big[100] ### Draw the predicted class on the image for quick validation in food classification tasks. cv2.putText(demoImage,class_name,(20,20),cv2.FONT_HERSHEY_COMPLEX,1,(255,255,0),1) ### Display the annotated preview image. cv2.imshow('demoImage',demoImage) ### Wait for a key press before closing the image window. cv2.waitKey(0)  ### Iterate over all predictions and compare them with ground truth to audit classify food performance. # lets compare all the results : for predict , test_label in zip(predictions,test_data_labels):     ### Extract the predicted class index via argmax for each item.     class_index = np.argmax(predict)     ### Convert the predicted index into a food class name.     class_name_predict = class_names[class_index]      ### Convert the true label index into its class name for comparison.     class_name_original = class_names[test_label]      ### Print predicted versus original class names to review classify food outcomes.     print('Predicted class :',class_name_predict , '     Original / real class name :', class_name_original )  ### Print a friendly note indicating that predictions appear accurate in this food classification run. # you can see that the preictions are very well !!!! # Thank you , and bye bye

Link for the full code : https://ko-fi.com/s/bba2540d4fResults: TensorFlow Fruit & Vegetable Classification in ActionAfter training the TensorFlow/Keras model on the 36-class fruits and vegetables dataset, the pipeline can take a completely unseen test image, run it through the same preprocessing steps, and output a predicted class label. In practice, this means your model turns a raw photo (for example, an apple) into a clean text label such as “apple”, which is exactly what you want for real-world classification apps.The result image below is meant to demonstrate the exact “moment of truth” in the code: the model produces a probability vector, np.argmax() selects the most confident class index, and that index is mapped back to the readable label from class_names. This is the same logic used in class_index = np.argmax(predictions[100]) and class_name = class_names[class_index], which is why the visual focuses on “Test Image → Predicted Class → True Label”.Finally, the output also reflects the last part of your script where you overlay the predicted class on the larger 280×280 test image using cv2.putText() and display it with cv2.imshow(). That overlay step is important: it makes the model’s prediction instantly readable for humans, and it’s exactly the kind of proof that helps readers (and Google) understand that this tutorial produces a working, verifiable result.

TensorFlow food image classification

Check out our tutorial here

Link for the full code here or here

You can find more tutorials in my blog

FAQ Question: What dataset is used in this TensorFlow food image classification tutorial?
Answer: The tutorial uses the “Fruit and Vegetable Image Recognition” dataset with 36 classes, organized into train/test folders by class name.Question: Why do we resize images before training?
Answer: Resizing standardizes input dimensions so the model can train on consistent tensors and process batches efficiently.Question: What TensorFlow/Keras model is used here?
Answer: A simple baseline dense network is trained on 28×28×3 inputs. It’s a starting point you can later replace with a CNN for higher accuracy.Question: How do I run a prediction on a new image?
Answer: You preprocess the image the same way (resize and normalize), then call model.predict() and map argmax to the class label.Question: My accuracy is low — what should I check first?
Answer: Verify that folder names match the label list exactly, images load correctly, and train/test splits are clean and balanced.Connect :☕ Buy me a coffee — https://ko-fi.com/eranfeit🖥️ Email : feitgemel@gmail.com🌐 https://eranfeit.net🤝 Fiverr : https://www.fiverr.com/s/mB3PbbEnjoy,Eran