Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ 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
+variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text

FoodVision_CV.py

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Feb  8 15:27:13 2024
+
+@author: Dhrumit Patel
+"""
+
+"""
+Get helper functions
+"""
+# Import series of helper functions
+from helper_functions import create_tensorboard_callback, plot_loss_curves, compare_historys
+
+"""
+Use TensorFlow Datasets(TFDS) to download data
+"""
+# Get TensorFlow Datasets
+import tensorflow_datasets as tfds
+
+# List all the available datasets
+datasets_list = tfds.list_builders() # Get all available datasets in TFDS
+print("food101" in datasets_list) # Is our target dataset in the list of TFDS datasets?
+
+# Load in the data
+(train_data, test_data), ds_info = tfds.load(name="food101", 
+                                             split=["train", "validation"], 
+                                             shuffle_files=True, # Data gets returned in tuple format (data, label)
+                                             with_info=True)
+# Features of Food101 from TFDS
+ds_info.features
+
+# Get the class names
+class_names = ds_info.features["label"].names
+class_names[:10]
+
+# Take one sample of the train data
+train_one_sample = train_data.take(1) # samples are in format (image_tensor, label)
+# What does one sample of our training data look like?
+train_one_sample
+
+# Output info about our training samples
+for sample in train_one_sample:
+    image, label = sample["image"], sample["label"]
+    print(f"""
+    Image shape: {image.shape}
+    Image datatype: {image.dtype}
+    Target class from Food101 (tensor form): {label}
+    Class name (str form): {class_names[label.numpy()]}
+    """)
+
+# What does our image tensor from TFDS's Food101 look like?
+import tensorflow as tf
+image
+tf.reduce_min(image), tf.reduce_max(image)
+
+"""
+Plot an image from TensorFlow Datasets
+"""
+# Plot an image tensor
+import matplotlib.pyplot as plt
+plt.imshow(image)
+plt.title(class_names[label.numpy()]) # Add title to verify the label is associated to right image
+plt.axis(False)
+
+(image, label)
+
+# Make a function for preprocessing images
+def preprocess_img(image, label, img_shape=224):
+    """
+    Converts image datatype from uint8 -> float32 and reshapes
+    image to [img_shape, img_shape, color_channels]
+    """
+    image = tf.image.resize(image, [img_shape, img_shape]) # reshape target image
+    # image = image/255. # scale image values (not required for EfficientNet models from tf.keras.applications)
+    return tf.cast(image, dtype=tf.float32), label # return a tuple of float32 image and a label tuple
+
+# Preprocess a single sample image and check the outputs
+preprocessed_img = preprocess_img(image, label)[0]
+print(f"Image before preprocessing:\n {image[:2]}..., \n Shape: {image.shape},\nDatatype: {image.dtype}\n")
+print(f"Image after preprocessing:]n {preprocessed_img[:2]}..., \n Shape: {preprocessed_img.shape}, \nDatatype: {preprocessed_img.dtype}")
+
+"""
+Batch and preprare datasets
+
+We are now going to make our data input pipeline run really fast.
+"""
+# Map preprocessing function to training data (and parallelize)
+train_data = train_data.map(map_func=lambda sample: preprocess_img(sample['image'], sample['label']), num_parallel_calls=tf.data.AUTOTUNE)
+# Shuffle train_data and turned it into batches and prefetch it (load it faster)
+train_data = train_data.shuffle(buffer_size=1000).batch(batch_size=32).prefetch(buffer_size=tf.data.AUTOTUNE)
+
+# Map preprocessing function to test data
+test_data = test_data.map(map_func=lambda sample: preprocess_img(sample['image'], sample['label']), num_parallel_calls=tf.data.AUTOTUNE)
+# Turn the test data into batches (don't need to shuffle the test data)
+test_data = test_data.batch(batch_size=32).prefetch(tf.data.AUTOTUNE)
+
+train_data, test_data
+
+"""
+Create modelling callbacks
+
+We are going to create a couple of callbacks to help us while our model trains:
+1. TensorBoard callback to log training results (so we can visualize them later if need be)
+2. ModelCheckpoint callback to save our model's progress after feature extraction.
+"""
+# Create tensorboard callback (import from helper_functions.py)
+from helper_functions import create_tensorboard_callback
+
+# Create a ModelCheckpoint callback to save a model's progress during training
+checkpoint_path = "model_checkpoints/cp.ckpt"
+model_checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
+                                                      monitor="val_acc",
+                                                      save_best_only=True,
+                                                      save_weights_only=True,
+                                                      verbose=1)
+
+# Turn on mixed precision training
+from tensorflow.keras import mixed_precision
+mixed_precision.set_global_policy("mixed_float16") # Set global data policy to mixed precision
+mixed_precision.global_policy()
+
+"""
+Build feature extraction 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.efficientnet_v2.EfficientNetV2B0(include_top=False)
+base_model.trainable = False
+
+# Create functional model
+inputs = layers.Input(shape=input_shape, name="input_layer")
+# Note: EfficientNetV2B0 models have rescaling built-in but if your model doesn't you can have a layer like below
+# x = preprocessing.Rescaling(1./255)(x) 
+x = base_model(inputs, training=False) # make sure layers which should be in inference mode only
+x = layers.GlobalAveragePooling2D(name="global_pooling_layer")(x)
+outputs = layers.Dense(len(class_names), activation="softmax", dtype=tf.float32, name="softmax_float32")(x) # This will be converted to float32
+
+model = tf.keras.Model(inputs, outputs)
+
+# Compile the model
+model.compile(loss="sparse_categorical_crossentropy", # The labels are in integer form
+              optimizer=tf.keras.optimizers.Adam(),
+              metrics=["accuracy"])
+
+model.summary()
+
+# Check the dtype_policy attributes of layers in our model
+for layer in model.layers:
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+
+# Check the dtype_policy attributes for the base_model layer
+for layer in model.layers[1].layers:
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+# OR
+
+for layer in base_model.layers:
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+# Fit the feature extraction model with callbacks
+history_101_food_classes_feature_extract = model.fit(train_data,
+                    epochs=10,
+                    steps_per_epoch=len(train_data),
+                    validation_data=test_data,
+                    validation_steps=int(0.15 * len(test_data)),
+                    callbacks=[create_tensorboard_callback(dir_name="training_logs", experiment_name="efficientnetb0_101_classes_all_data_feature_extract"), model_checkpoint])
+
+
+# Evaluate the model on the whole test data
+results_feature_extract_model = model.evaluate(test_data)
+results_feature_extract_model
+
+
+# 1. Create a function to recreate the original model
+def create_model():
+  # Create base model
+  input_shape = (224, 224, 3)
+  base_model = tf.keras.applications.efficientnet.EfficientNetB0(include_top=False)
+  base_model.trainable = False # freeze base model layers
+
+  # Create Functional model 
+  inputs = layers.Input(shape=input_shape, name="input_layer")
+  # Note: EfficientNetBX models have rescaling built-in but if your model didn't you could have a layer like below
+  # x = layers.Rescaling(1./255)(x)
+  x = base_model(inputs, training=False) # set base_model to inference mode only
+  x = layers.GlobalAveragePooling2D(name="pooling_layer")(x)
+  x = layers.Dense(len(class_names))(x) # want one output neuron per class 
+  # Separate activation of output layer so we can output float32 activations
+  outputs = layers.Activation("softmax", dtype=tf.float32, name="softmax_float32")(x) 
+  model = tf.keras.Model(inputs, outputs)
+  
+  return model
+
+# 2. Create and compile a new version of the original model (new weights)
+created_model = create_model()
+created_model.compile(loss="sparse_categorical_crossentropy",
+                      optimizer=tf.keras.optimizers.Adam(),
+                      metrics=["accuracy"])
+
+# 3. Load the saved weights
+created_model.load_weights(checkpoint_path)
+
+# 4. Evaluate the model with loaded weights
+results_created_model_with_loaded_weights = created_model.evaluate(test_data)
+
+# 5. Loaded checkpoint weights should return very similar results to checkpoint weights prior to saving
+import numpy as np
+assert np.isclose(results_feature_extract_model, results_created_model_with_loaded_weights).all(), "Loaded weights results are not close to original model."  # check if all elements in array are close
+
+# Check the layers in the base model and see what dtype policy they're using
+for layer in created_model.layers[1].layers[:20]: # check only the first 20 layers to save printing space
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+# Save model locally (if you're using Google Colab, your saved model will Colab instance terminates)
+save_dir = "07_efficientnetb0_feature_extract_model_mixed_precision"
+model.save(save_dir)
+
+# Load model previously saved above
+loaded_saved_model = tf.keras.models.load_model(save_dir)
+
+# Load model previously saved above
+loaded_saved_model = tf.keras.models.load_model(save_dir)
+
+
+# Check the layers in the base model and see what dtype policy they're using
+for layer in loaded_saved_model.layers[1].layers[:20]: # check only the first 20 layers to save output space
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+results_loaded_saved_model = loaded_saved_model.evaluate(test_data)
+results_loaded_saved_model
+
+# The loaded model's results should equal (or at least be very close) to the model's results prior to saving
+import numpy as np
+assert np.isclose(results_feature_extract_model, results_loaded_saved_model).all()
+
+
+"""
+Optional
+"""
+# Download and unzip the saved model from Google Storage - https://drive.google.com/file/d/1-4BsHQyo3NIBGzlgqZgJNC5_3eIGcbVb/view?usp=sharing
+
+# Unzip the SavedModel downloaded from Google Storage
+# !mkdir downloaded_gs_model # create new dir to store downloaded feature extraction model
+# !unzip 07_efficientnetb0_feature_extract_model_mixed_precision.zip -d downloaded_gs_model
+
+# Load and evaluate downloaded GS model
+loaded_gs_model = tf.keras.models.load_model("downloaded_gs_model/07_efficientnetb0_feature_extract_model_mixed_precision")
+
+# Get a summary of our downloaded model
+loaded_gs_model.summary()
+
+# How does the loaded model perform?
+results_loaded_gs_model = loaded_gs_model.evaluate(test_data)
+results_loaded_gs_model
+
+# Are any of the layers in our model frozen?
+for layer in loaded_gs_model.layers:
+    layer.trainable = True # set all layers to trainable
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy) # make sure loaded model is using mixed precision dtype_policy ("mixed_float16")
+
+
+# Check the layers in the base model and see what dtype policy they're using
+for layer in loaded_gs_model.layers[1].layers[:20]:
+    print(layer.name, layer.trainable, layer.dtype, layer.dtype_policy)
+
+# Setup EarlyStopping callback to stop training if model's val_loss doesn't improve for 3 epochs
+early_stopping = tf.keras.callbacks.EarlyStopping(monitor="val_loss", # watch the val loss metric
+                                                  patience=3) # if val loss decreases for 3 epochs in a row, stop training
+
+# Create ModelCheckpoint callback to save best model during fine-tuning
+checkpoint_path = "fine_tune_checkpoints/"
+model_checkpoint = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
+                                                      save_best_only=True,
+                                                      monitor="val_loss")
+# Creating learning rate reduction callback
+reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor="val_loss",  
+                                                 factor=0.2, # multiply the learning rate by 0.2 (reduce by 5x)
+                                                 patience=2,
+                                                 verbose=1, # print out when learning rate goes down 
+                                                 min_lr=1e-7)
+
+# Compile the model
+loaded_gs_model.compile(loss="sparse_categorical_crossentropy", # sparse_categorical_crossentropy for labels that are *not* one-hot
+                        optimizer=tf.keras.optimizers.Adam(0.0001), # 10x lower learning rate than the default
+                        metrics=["accuracy"])
+
+
+# Start to fine-tune (all layers)
+history_101_food_classes_all_data_fine_tune = loaded_gs_model.fit(train_data,
+                                                        epochs=100, # fine-tune for a maximum of 100 epochs
+                                                        steps_per_epoch=len(train_data),
+                                                        validation_data=test_data,
+                                                        validation_steps=int(0.15 * len(test_data)), # validation during training on 15% of test data
+                                                        callbacks=[create_tensorboard_callback("training_logs", "efficientb0_101_classes_all_data_fine_tuning"), # track the model training logs
+                                                                   model_checkpoint, # save only the best model during training
+                                                                   early_stopping, # stop model after X epochs of no improvements
+                                                                   reduce_lr]) # reduce the learning rate after X epochs of no improvements
+
+# Save model locally (note: if you're using Google Colab and you save your model locally, it will be deleted when your Google Colab session ends)
+loaded_gs_model.save("07_efficientnetb0_fine_tuned_101_classes_mixed_precision")
+
+
+"""
+Optional
+"""
+# Download and evaluate fine-tuned model from Google Storage - https://drive.google.com/file/d/1owx3maxBae1P2I2yQHd-ru_4M7RyoGpB/view?usp=sharing
+
+# Unzip fine-tuned model
+# !mkdir downloaded_fine_tuned_gs_model # create separate directory for fine-tuned model downloaded from Google Storage
+# !unzip 07_efficientnetb0_fine_tuned_101_classes_mixed_precision -d downloaded_fine_tuned_gs_model
+
+# Load in fine-tuned model and evaluate
+loaded_fine_tuned_gs_model = tf.keras.models.load_model("downloaded_fine_tuned_gs_model/07_efficientnetb0_fine_tuned_101_classes_mixed_precision")
+
+# Get a model summary 
+loaded_fine_tuned_gs_model.summary()
+
+# Note: Even if you're loading in the model from Google Storage, you will still need to load the test_data variable for this cell to work
+results_downloaded_fine_tuned_gs_model = loaded_fine_tuned_gs_model.evaluate(test_data)
+results_downloaded_fine_tuned_gs_model
+
+"""
+# Upload experiment results to TensorBoard (uncomment to run)
+# !tensorboard dev upload --logdir ./training_logs \
+#   --name "Fine-tuning EfficientNetB0 on all Food101 Data" \
+#   --description "Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001" \
+#   --one_shot
+
+# View past TensorBoard experiments
+# !tensorboard dev list
+
+
+# Delete past TensorBoard experiments
+# !tensorboard dev delete --experiment_id YOUR_EXPERIMENT_ID
+
+# Example
+# !tensorboard dev delete --experiment_id OAE6KXizQZKQxDiqI3cnUQ
+"""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

helper_functions.py

@@ -0,0 +1,302 @@
+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 instance 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()
+  
+  
+# Download and unzip file
+import zipfile
+import requests
+import os
+
+def download_and_unzip(url, target_folder):
+    # Download the file from url and save it
+    filename = os.path.join(target_folder, os.path.basename(url))
+    with open(filename, 'wb') as f:
+        r = requests.get(url)
+        f.write(r.content)
+
+    # Unzip the downloaded file
+    with zipfile.ZipFile(filename, 'r') as zip_ref:
+        zip_ref.extractall(target_folder)
+
+# 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

saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03f2eab4db7e3bda054c33266e097bb52a70b45ae545ef050b8ce5c0c64a3d84
+size 7614129

variables.data-00000-of-00001

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