Upload 22 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+FoodVision.hdf5 filter=lfs diff=lfs merge=lfs -text
+sample_images/sushi.jpg filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/.name

@@ -0,0 +1 @@
+app.py

.idea/FoodVision.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.11" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/FoodVision.iml" filepath="$PROJECT_DIR$/.idea/FoodVision.iml" />
+    </modules>
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="1e69dd8b-dcce-48e7-b98e-c0f62bebe947" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="MarkdownSettingsMigration">
+    <option name="stateVersion" value="1" />
+  </component>
+  <component name="ProjectId" id="2XIBP0z526oyXyOdRYelkE0iL3Y" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.OpenProjectViewOnStart": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "settings.editor.selected.configurable": "preferences.pluginManager"
+  }
+}]]></component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="1e69dd8b-dcce-48e7-b98e-c0f62bebe947" name="Changes" comment="" />
+      <created>1698306686202</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1698306686202</updated>
+    </task>
+    <servers />
+  </component>
+</project>

FoodVision.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32acc1c81bcc4513a3d399a8d4cf3b42657884899e6ac72669bd7dbe6eb92521
+size 81206904

helper_functions.py

@@ -0,0 +1,288 @@
+### We create a bunch of helpful functions throughout the course.
+### Storing them here so they're easily accessible.
+
+import tensorflow as tf
+
+# Create a function to import an image and resize it to be able to be used with our model
+def load_and_prep_image(filename, img_shape=224, scale=True):
+  """
+  Reads in an image from filename, turns it into a tensor and reshapes into
+  (224, 224, 3).
+
+  Parameters
+  ----------
+  filename (str): string filename of target image
+  img_shape (int): size to resize target image to, default 224
+  scale (bool): whether to scale pixel values to range(0, 1), default True
+  """
+  # Read in the image
+  img = tf.io.read_file(filename)
+  # Decode it into a tensor
+  img = tf.image.decode_jpeg(img)
+  # Resize the image
+  img = tf.image.resize(img, [img_shape, img_shape])
+  if scale:
+    # Rescale the image (get all values between 0 and 1)
+    return img/255.
+  else:
+    return img
+
+# Note: The following confusion matrix code is a remix of Scikit-Learn's 
+# plot_confusion_matrix function - https://scikit-learn.org/stable/modules/generated/sklearn.metrics.plot_confusion_matrix.html
+import itertools
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import confusion_matrix
+
+# Our function needs a different name to sklearn's plot_confusion_matrix
+def make_confusion_matrix(y_true, y_pred, classes=None, figsize=(10, 10), text_size=15, norm=False, savefig=False): 
+  """Makes a labelled confusion matrix comparing predictions and ground truth labels.
+
+  If classes is passed, confusion matrix will be labelled, if not, integer class values
+  will be used.
+
+  Args:
+    y_true: Array of truth labels (must be same shape as y_pred).
+    y_pred: Array of predicted labels (must be same shape as y_true).
+    classes: Array of class labels (e.g. string form). If `None`, integer labels are used.
+    figsize: Size of output figure (default=(10, 10)).
+    text_size: Size of output figure text (default=15).
+    norm: normalize values or not (default=False).
+    savefig: save confusion matrix to file (default=False).
+  
+  Returns:
+    A labelled confusion matrix plot comparing y_true and y_pred.
+
+  Example usage:
+    make_confusion_matrix(y_true=test_labels, # ground truth test labels
+                          y_pred=y_preds, # predicted labels
+                          classes=class_names, # array of class label names
+                          figsize=(15, 15),
+                          text_size=10)
+  """  
+  # Create the confustion matrix
+  cm = confusion_matrix(y_true, y_pred)
+  cm_norm = cm.astype("float") / cm.sum(axis=1)[:, np.newaxis] # normalize it
+  n_classes = cm.shape[0] # find the number of classes we're dealing with
+
+  # Plot the figure and make it pretty
+  fig, ax = plt.subplots(figsize=figsize)
+  cax = ax.matshow(cm, cmap=plt.cm.Blues) # colors will represent how 'correct' a class is, darker == better
+  fig.colorbar(cax)
+
+  # Are there a list of classes?
+  if classes:
+    labels = classes
+  else:
+    labels = np.arange(cm.shape[0])
+  
+  # Label the axes
+  ax.set(title="Confusion Matrix",
+         xlabel="Predicted label",
+         ylabel="True label",
+         xticks=np.arange(n_classes), # create enough axis slots for each class
+         yticks=np.arange(n_classes), 
+         xticklabels=labels, # axes will labeled with class names (if they exist) or ints
+         yticklabels=labels)
+  
+  # Make x-axis labels appear on bottom
+  ax.xaxis.set_label_position("bottom")
+  ax.xaxis.tick_bottom()
+
+  # Set the threshold for different colors
+  threshold = (cm.max() + cm.min()) / 2.
+
+  # Plot the text on each cell
+  for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
+    if norm:
+      plt.text(j, i, f"{cm[i, j]} ({cm_norm[i, j]*100:.1f}%)",
+              horizontalalignment="center",
+              color="white" if cm[i, j] > threshold else "black",
+              size=text_size)
+    else:
+      plt.text(j, i, f"{cm[i, j]}",
+              horizontalalignment="center",
+              color="white" if cm[i, j] > threshold else "black",
+              size=text_size)
+
+  # Save the figure to the current working directory
+  if savefig:
+    fig.savefig("confusion_matrix.png")
+  
+# Make a function to predict on images and plot them (works with multi-class)
+def pred_and_plot(model, filename, class_names):
+  """
+  Imports an image located at filename, makes a prediction on it with
+  a trained model and plots the image with the predicted class as the title.
+  """
+  # Import the target image and preprocess it
+  img = load_and_prep_image(filename)
+
+  # Make a prediction
+  pred = model.predict(tf.expand_dims(img, axis=0))
+
+  # Get the predicted class
+  if len(pred[0]) > 1: # check for multi-class
+    pred_class = class_names[pred.argmax()] # if more than one output, take the max
+  else:
+    pred_class = class_names[int(tf.round(pred)[0][0])] # if only one output, round
+
+  # Plot the image and predicted class
+  plt.imshow(img)
+  plt.title(f"Prediction: {pred_class}")
+  plt.axis(False);
+  
+import datetime
+
+def create_tensorboard_callback(dir_name, experiment_name):
+  """
+  Creates a TensorBoard callback instand to store log files.
+
+  Stores log files with the filepath:
+    "dir_name/experiment_name/current_datetime/"
+
+  Args:
+    dir_name: target directory to store TensorBoard log files
+    experiment_name: name of experiment directory (e.g. efficientnet_model_1)
+  """
+  log_dir = dir_name + "/" + experiment_name + "/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+  tensorboard_callback = tf.keras.callbacks.TensorBoard(
+      log_dir=log_dir
+  )
+  print(f"Saving TensorBoard log files to: {log_dir}")
+  return tensorboard_callback
+
+# Plot the validation and training data separately
+import matplotlib.pyplot as plt
+
+def plot_loss_curves(history):
+  """
+  Returns separate loss curves for training and validation metrics.
+
+  Args:
+    history: TensorFlow model History object (see: https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/History)
+  """ 
+  loss = history.history['loss']
+  val_loss = history.history['val_loss']
+
+  accuracy = history.history['accuracy']
+  val_accuracy = history.history['val_accuracy']
+
+  epochs = range(len(history.history['loss']))
+
+  # Plot loss
+  plt.plot(epochs, loss, label='training_loss')
+  plt.plot(epochs, val_loss, label='val_loss')
+  plt.title('Loss')
+  plt.xlabel('Epochs')
+  plt.legend()
+
+  # Plot accuracy
+  plt.figure()
+  plt.plot(epochs, accuracy, label='training_accuracy')
+  plt.plot(epochs, val_accuracy, label='val_accuracy')
+  plt.title('Accuracy')
+  plt.xlabel('Epochs')
+  plt.legend();
+
+def compare_historys(original_history, new_history, initial_epochs=5):
+    """
+    Compares two TensorFlow model History objects.
+    
+    Args:
+      original_history: History object from original model (before new_history)
+      new_history: History object from continued model training (after original_history)
+      initial_epochs: Number of epochs in original_history (new_history plot starts from here) 
+    """
+    
+    # Get original history measurements
+    acc = original_history.history["accuracy"]
+    loss = original_history.history["loss"]
+
+    val_acc = original_history.history["val_accuracy"]
+    val_loss = original_history.history["val_loss"]
+
+    # Combine original history with new history
+    total_acc = acc + new_history.history["accuracy"]
+    total_loss = loss + new_history.history["loss"]
+
+    total_val_acc = val_acc + new_history.history["val_accuracy"]
+    total_val_loss = val_loss + new_history.history["val_loss"]
+
+    # Make plots
+    plt.figure(figsize=(8, 8))
+    plt.subplot(2, 1, 1)
+    plt.plot(total_acc, label='Training Accuracy')
+    plt.plot(total_val_acc, label='Validation Accuracy')
+    plt.plot([initial_epochs-1, initial_epochs-1],
+              plt.ylim(), label='Start Fine Tuning') # reshift plot around epochs
+    plt.legend(loc='lower right')
+    plt.title('Training and Validation Accuracy')
+
+    plt.subplot(2, 1, 2)
+    plt.plot(total_loss, label='Training Loss')
+    plt.plot(total_val_loss, label='Validation Loss')
+    plt.plot([initial_epochs-1, initial_epochs-1],
+              plt.ylim(), label='Start Fine Tuning') # reshift plot around epochs
+    plt.legend(loc='upper right')
+    plt.title('Training and Validation Loss')
+    plt.xlabel('epoch')
+    plt.show()
+  
+# Create function to unzip a zipfile into current working directory 
+# (since we're going to be downloading and unzipping a few files)
+import zipfile
+
+def unzip_data(filename):
+  """
+  Unzips filename into the current working directory.
+
+  Args:
+    filename (str): a filepath to a target zip folder to be unzipped.
+  """
+  zip_ref = zipfile.ZipFile(filename, "r")
+  zip_ref.extractall()
+  zip_ref.close()
+
+# Walk through an image classification directory and find out how many files (images)
+# are in each subdirectory.
+import os
+
+def walk_through_dir(dir_path):
+  """
+  Walks through dir_path returning its contents.
+
+  Args:
+    dir_path (str): target directory
+  
+  Returns:
+    A print out of:
+      number of subdiretories in dir_path
+      number of images (files) in each subdirectory
+      name of each subdirectory
+  """
+  for dirpath, dirnames, filenames in os.walk(dir_path):
+    print(f"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.")
+    
+# Function to evaluate: accuracy, precision, recall, f1-score
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+def calculate_results(y_true, y_pred):
+  """
+  Calculates model accuracy, precision, recall and f1 score of a binary classification model.
+
+  Args:
+      y_true: true labels in the form of a 1D array
+      y_pred: predicted labels in the form of a 1D array
+
+  Returns a dictionary of accuracy, precision, recall, f1-score.
+  """
+  # Calculate model accuracy
+  model_accuracy = accuracy_score(y_true, y_pred) * 100
+  # Calculate model precision, recall and f1 score using "weighted average
+  model_precision, model_recall, model_f1, _ = precision_recall_fscore_support(y_true, y_pred, average="weighted")
+  model_results = {"accuracy": model_accuracy,
+                  "precision": model_precision,
+                  "recall": model_recall,
+                  "f1": model_f1}
+  return model_results

model_training.py

@@ -0,0 +1,408 @@
+# -*- coding: utf-8 -*-
+"""model_training.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1LgqvdLV1teCsAi6qjR_BBVt4TwX7vx9J
+
+<a href="https://colab.research.google.com/github/gauravreddy08/food-vision/blob/main/model_training.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
+
+# **Food Vision** 🍔
+
+As an introductory project to myself, I built an **end-to-end CNN Image Classification Model** which identifies the food in your image.
+
+I worked out with a pretrained Image Classification Model that comes with Keras and then retrained it on the infamous **Food101 Dataset**.
+
+
+**Fun Fact :**
+
+The Model actually beats the DeepFood Paper's model which also trained on the same dataset.
+
+The Accuracy of [**DeepFood**](https://arxiv.org/abs/1606.05675) was **77.4%** and our model's is **85%**. Difference of **8%** ain't much but the interesting thing is, DeepFood's model took 2-3 days to train while our's was around 60min.
+
+> **Dataset :** `Food101`
+
+> **Model :** `EfficientNetB1`
+
+## **Setting up the Workspace**
+
+* Checking the GPU
+* Mounting Google Drive
+* Importing Tensorflow
+* Importing other required Packages
+
+### **Checking the GPU**
+
+For this Project we will working with **Mixed Precision**. And mixed precision works best with a with a GPU with compatibility capacity **7.0+**.
+
+At the time of writing, colab offers the following GPU's :
+* Nvidia K80
+* **Nvidia T4**
+* Nvidia P100
+
+Colab allocates a random GPU everytime we factory reset runtime. So you can reset the runtime till you get a **Tesla T4 GPU** as T4 GPU has a rating 7.5.
+
+> In case using local hardware, use a GPU with rating 7.0+ for better results.
+
+Run the below cell to see which GPU is allocated to you.
+"""
+
+!nvidia-smi -L
+
+"""
+### **Mounting Google Drive**
+
+
+"""
+
+from google.colab import drive
+drive.mount('/content/drive')
+
+"""### **Importing Tensorflow**
+
+At the time of writing, `tesnorflow 2.5.0` has a bug with EfficientNet Models. [Click Here](https://github.com/tensorflow/tensorflow/issues/49725) to get more info about the bug. Hopefully tensorflow fixes it soon.
+
+So the below code is used to downgrade the version to `tensorflow 2.4.1`, it will take a moment to uninstall the previous version and install our required version.
+
+> You need to restart the **Runtime** after required version of tensorflow is installed.
+
+**Note :** Restarting runtime won't assign you a new GPU.
+"""
+
+#!pip install tensorflow==2.4.1
+import tensorflow as tf
+print(tf.__version__)
+
+"""### **Importing other required Packages**"""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import datetime
+import os
+import tensorflow_datasets as tfds
+import seaborn as sn
+
+"""#### **Importing `helper_fuctions`**
+
+The `helper_functions.py` is a python script created by me. Which has some important functions I use frequently while building Deep Learning Models.
+"""
+
+!wget https://raw.githubusercontent.com/sg-sparsh-goyal/extras/main/helper_function.py
+
+from helper_function import plot_loss_curves, load_and_prep_image
+
+"""## **Getting the Data Ready**
+
+The Dataset used is **Food101**, which is available on both Kaggle and Tensorflow.
+
+In the below cells we will be importing Datasets from `Tensorflow Datasets` Module.
+
+"""
+
+# Prints list of Datasets avaible in Tensorflow Datasets Module
+
+dataset_list = tfds.list_builders()
+dataset_list[:10]
+
+"""### **Importing Food101 Dataset**
+
+**Disclaimer :**
+The below cell will take time to run, as it will be downloading
+**4.65GB data** from **Tensorflow Datasets Module**.
+
+So do check if you have enough **Disk Space** and **Bandwidth Cap** to run the below cell.
+"""
+
+(train_data, test_data), ds_info = tfds.load(name='food101',
+                                             split=['train', 'validation'],
+                                             shuffle_files=False,
+                                             as_supervised=True,
+                                             with_info=True)
+
+"""## **Becoming One with the Data**
+
+One of the most important steps in building any ML or DL Model is to **become one with the data**.
+
+Once you get the gist of what type of data your dealing with and how it is structured, everything else will fall in place.
+"""
+
+ds_info.features
+
+class_names = ds_info.features['label'].names
+class_names[:10]
+
+train_one_sample = train_data.take(1)
+
+train_one_sample
+
+for image, label in train_one_sample:
+  print(f"""
+  Image Shape : {image.shape}
+  Image Datatype : {image.dtype}
+  Class : {class_names[label.numpy()]}
+  """)
+
+image[:2]
+
+tf.reduce_min(image), tf.reduce_max(image)
+
+plt.imshow(image)
+plt.title(class_names[label.numpy()])
+plt.axis(False);
+
+"""## **Preprocessing the Data**
+
+Since we've downloaded the data from TensorFlow Datasets, there are a couple of preprocessing steps we have to take before it's ready to model.
+
+More specifically, our data is currently:
+
+* In `uint8` data type
+* Comprised of all differnet sized tensors (different sized images)
+* Not scaled (the pixel values are between 0 & 255)
+
+Whereas, models like data to be:
+
+* In `float32` data type
+* Have all of the same size tensors (batches require all tensors have the same shape, e.g. `(224, 224, 3)`)
+* Scaled (values between 0 & 1), also called normalized
+
+To take care of these, we'll create a `preprocess_img()` function which:
+
+* Resizes an input image tensor to a specified size using [`tf.image.resize()`](https://www.tensorflow.org/api_docs/python/tf/image/resize)
+* Converts an input image tensor's current datatype to `tf.float32` using [`tf.cast()`](https://www.tensorflow.org/api_docs/python/tf/cast)
+"""
+
+def preprocess_img(image, label, img_size=224):
+  image = tf.image.resize(image, [img_size, img_size])
+  image = tf.cast(image, tf.float16)
+  return image, label
+
+# Trying the preprocess function on a single image
+
+preprocessed_img = preprocess_img(image, label)[0]
+preprocessed_img
+
+train_data = train_data.map(preprocess_img, tf.data.AUTOTUNE)
+train_data = train_data.shuffle(buffer_size=1000).batch(32).prefetch(tf.data.AUTOTUNE)
+
+test_data = test_data.map(preprocess_img, tf.data.AUTOTUNE)
+test_data = test_data.batch(32)
+
+train_data
+
+test_data
+
+"""## **Building the Model : EfficientNetB1**
+
+
+### **Getting the Callbacks ready**
+As we are dealing with a complex Neural Network (EfficientNetB0) its a good practice to have few call backs set up. Few callbacks I will be using throughtout this Notebook are :
+ * **TensorBoard Callback :** TensorBoard provides the visualization and tooling needed for machine learning experimentation
+
+ * **EarlyStoppingCallback :** Used to stop training when a monitored metric has stopped improving.
+
+ * **ReduceLROnPlateau :** Reduce learning rate when a metric has stopped improving.
+
+
+ We already have **TensorBoardCallBack** function setup in out helper function, all we have to do is get other callbacks ready.
+"""
+
+from helper_function import create_tensorboard_callback
+
+# EarlyStopping Callback
+
+early_stopping_callback = tf.keras.callbacks.EarlyStopping(restore_best_weights=True, patience=3, verbose=1, monitor="val_accuracy")
+
+# ReduceLROnPlateau Callback
+
+lower_lr = tf.keras.callbacks.ReduceLROnPlateau(factor=0.2,
+                                                monitor='val_accuracy',
+                                                min_lr=1e-7,
+                                                patience=0,
+                                                verbose=1)
+
+"""
+
+### **Mixed Precision Training**
+Mixed precision is used for training neural networks, reducing training time and memory requirements without affecting the model performance.
+
+More Specifically, in **Mixed Precision** we will setting global dtype as `mixed_float16`. Because modern accelerators can run operations faster in the 16-bit dtypes, as they have specialized hardware to run 16-bit computations and 16-bit dtypes can be read from memory faster.
+
+To know more about Mixed Precision, [**click here**](https://www.tensorflow.org/guide/mixed_precision)"""
+
+from tensorflow.keras import mixed_precision
+mixed_precision.set_global_policy(policy='mixed_float16')
+
+mixed_precision.global_policy()
+
+"""
+
+### **Building the Model**"""
+
+from tensorflow.keras import layers
+from tensorflow.keras.layers.experimental import preprocessing
+
+# Create base model
+input_shape = (224, 224, 3)
+base_model = tf.keras.applications.EfficientNetB1(include_top=False)
+
+# Input and Data Augmentation
+inputs = layers.Input(shape=input_shape, name="input_layer")
+x = base_model(inputs)
+
+x = layers.GlobalAveragePooling2D(name="pooling_layer")(x)
+x = layers.Dropout(.3)(x)
+
+x = layers.Dense(len(class_names))(x)
+outputs = layers.Activation("softmax")(x)
+model = tf.keras.Model(inputs, outputs)
+
+# Compiling the model
+model.compile(loss="sparse_categorical_crossentropy",
+              optimizer=tf.keras.optimizers.Adam(0.001),
+              metrics=["accuracy"])
+
+model.summary()
+
+history = model.fit(train_data,
+                    epochs=50,
+                    steps_per_epoch=len(train_data),
+                    validation_data=test_data,
+                    validation_steps=int(0.15 * len(test_data)),
+                    callbacks=[create_tensorboard_callback("training-logs", "EfficientNetB1-"),
+                               early_stopping_callback,
+                               lower_lr])
+
+# Saving the model
+model.save("/content/drive/My Drive/FinalModel.hdf5")
+
+# Saving the model
+model.save("FoodVision.hdf5")
+
+plot_loss_curves(history)
+
+model.evaluate(test_data)
+
+"""## **Evaluating our Model**"""
+
+# Commented out IPython magic to ensure Python compatibility.
+# %load_ext tensorboard
+# %tensorboard --logdir training-logs
+
+pred_probs = model.predict(test_data, verbose=1)
+len(pred_probs), pred_probs.shape
+
+pred_classes = pred_probs.argmax(axis=1)
+pred_classes[:10], len(pred_classes), pred_classes.shape
+
+# Getting true labels for the test_data
+
+y_labels = []
+test_images = []
+for images, labels in test_data.unbatch():
+  y_labels.append(labels.numpy())
+y_labels[:10]
+
+# Predicted Labels vs. True Labels
+pred_classes==y_labels
+
+"""### **Sklearn's Accuracy Score**"""
+
+from sklearn.metrics import accuracy_score
+
+sklearn_acc = accuracy_score(y_labels, pred_classes)
+sklearn_acc
+
+"""### **Confusion Matrix**
+A confusion matrix is a table that is often used to describe the performance of a classification model (or "classifier") on a set of test data for which the true values are known
+"""
+
+cm = tf.math.confusion_matrix(y_labels, pred_classes)
+
+plt.figure(figsize = (100, 100));
+sn.heatmap(cm, annot=True,
+           fmt='',
+           cmap='Purples');
+
+"""### **Model's Class-wise Accuracy Score**"""
+
+from sklearn.metrics import classification_report
+report = (classification_report(y_labels, pred_classes, output_dict=True))
+
+# Create empty dictionary
+class_f1_scores = {}
+# Loop through classification report items
+for k, v in report.items():
+  if k == "accuracy": # stop once we get to accuracy key
+    break
+  else:
+    # Append class names and f1-scores to new dictionary
+    class_f1_scores[class_names[int(k)]] = v["f1-score"]
+class_f1_scores
+
+report_df = pd.DataFrame(class_f1_scores, index = ['f1-scores']).T
+
+report_df = report_df.sort_values("f1-scores", ascending=True)
+
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(figsize=(12, 25))
+scores = ax.barh(range(len(report_df)), report_df["f1-scores"].values)
+ax.set_yticks(range(len(report_df)))
+plt.axvline(x=0.85, linestyle='--', color='r')
+ax.set_yticklabels(class_names)
+ax.set_xlabel("f1-score")
+ax.set_title("F1-Scores for 10 Different Classes")
+ax.invert_yaxis(); # reverse the order
+
+"""### **Predicting on our own Custom images**
+
+Once we have our model ready, its cruicial to evaluate it on our custom data : the data our model has never seen.
+
+Training and evaluating a model on train and test data is cool, but making predictions on our own realtime images is another level.
+
+
+"""
+
+import os
+
+directory_path = "/content/drive/MyDrive/FoodVisionModels/Custom Images"
+os.makedirs(directory_path, exist_ok=True)
+
+custom_food_images = [directory_path + img_path for img_path in os.listdir(directory_path)]
+custom_food_images
+
+import os
+import matplotlib.pyplot as plt
+
+def pred_plot_custom(folder_path):
+    custom_food_images = [folder_path + img_path for img_path in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, img_path))]
+
+    for img in custom_food_images:
+        img = load_and_prep_image(img, scale=False)
+        pred_prob = model.predict(tf.expand_dims(img, axis=0))
+        pred_class = class_names[pred_prob.argmax()]
+        top_5_i = (pred_prob.argsort())[0][-5:][::-1]
+        values = pred_prob[0][top_5_i]
+        labels = []
+
+        for x in range(5):
+            labels.append(class_names[top_5_i[x]])
+
+        fig, ax = plt.subplots(1, 2, figsize=(15, 5))
+
+        # Plotting Image
+        ax[0].imshow(img/255.)
+        ax[0].set_title(f"Prediction: {pred_class}   Probability: {pred_prob.max():.2f}")
+        ax[0].axis('off')
+
+        # Plotting Models Top 5 Predictions
+        ax[1].bar(labels, values, color='orange')
+        ax[1].set_title('Top 5 Predictions')
+
+        plt.show()
+
+pred_plot_custom("/content/drive/MyDrive/FoodVisionModels/Custom Images/")
+

requirements.txt

@@ -0,0 +1,11 @@
+alt
+streamlit
+pandas
+tensorflow
+altair
+time
+datetime
+numpy
+matplotlib
+seaborn
+tensorflow_datasets

utils.py

@@ -0,0 +1,119 @@
+import datetime
+import tensorflow as tf
+import numpy as np
+
+class_names = ['apple_pie',
+                'baby_back_ribs',
+                'baklava',
+                'beef_carpaccio',
+                'beef_tartare',
+                'beet_salad',
+                'beignets',
+                'bibimbap',
+                'bread_pudding',
+                'breakfast_burrito',
+                'bruschetta',
+                'caesar_salad',
+                'cannoli',
+                'caprese_salad',
+                'carrot_cake',
+                'ceviche',
+                'cheesecake',
+                'cheese_plate',
+                'chicken_curry',
+                'chicken_quesadilla',
+                'chicken_wings',
+                'chocolate_cake',
+                'chocolate_mousse',
+                'churros',
+                'clam_chowder',
+                'club_sandwich',
+                'crab_cakes',
+                'creme_brulee',
+                'croque_madame',
+                'cup_cakes',
+                'deviled_eggs',
+                'donuts',
+                'dumplings',
+                'edamame',
+                'eggs_benedict',
+                'escargots',
+                'falafel',
+                'filet_mignon',
+                'fish_and_chips',
+                'foie_gras',
+                'french_fries',
+                'french_onion_soup',
+                'french_toast',
+                'fried_calamari',
+                'fried_rice',
+                'frozen_yogurt',
+                'garlic_bread',
+                'gnocchi',
+                'greek_salad',
+                'grilled_cheese_sandwich',
+                'grilled_salmon',
+                'guacamole',
+                'gyoza',
+                'hamburger',
+                'hot_and_sour_soup',
+                'hot_dog',
+                'huevos_rancheros',
+                'hummus',
+                'ice_cream',
+                'lasagna',
+                'lobster_bisque',
+                'lobster_roll_sandwich',
+                'macaroni_and_cheese',
+                'macarons',
+                'miso_soup',
+                'mussels',
+                'nachos',
+                'omelette',
+                'onion_rings',
+                'oysters',
+                'pad_thai',
+                'paella',
+                'pancakes',
+                'panna_cotta',
+                'peking_duck',
+                'pho',
+                'pizza',
+                'pork_chop',
+                'poutine',
+                'prime_rib',
+                'pulled_pork_sandwich',
+                'ramen',
+                'ravioli',
+                'red_velvet_cake',
+                'risotto',
+                'samosa',
+                'sashimi',
+                'scallops',
+                'seaweed_salad',
+                'shrimp_and_grits',
+                'spaghetti_bolognese',
+                'spaghetti_carbonara',
+                'spring_rolls',
+                'steak',
+                'strawberry_shortcake',
+                'sushi',
+                'tacos',
+                'takoyaki',
+                'tiramisu',
+                'tuna_tartare',
+                'waffles']
+
+
+def get_classes():
+    return class_names
+
+def load_and_prep(image, shape=224, scale=False):
+    image = tf.image.decode_image(image, channels=3)
+    image = tf.image.resize(image, size=([shape, shape]))
+    if scale:
+        image = image/255.
+    return image
+
+def preprocess_data(data):
+    return np.asarray(data).astype(np.float32)