Create README.md

README.md

@@ -0,0 +1,192 @@
+---
+license: mit
+language:
+- en
+metrics:
+- accuracy
+base_model:
+- google/efficientnet-b0
+pipeline_tag: image-classification
+---
+
+# Model Card for Food Vision Model
+
+This model is an image classification model trained to identify different types of food from images. It was developed as part of a Food Vision project, likely utilizing transfer learning on a pre-trained convolutional neural network.
+
+## Model Details
+
+### Model Description
+
+This model is a deep learning model for classifying food images into one of 101 categories from the Food101 dataset. It was trained using TensorFlow and likely employs a transfer learning approach, leveraging the features learned by a model pre-trained on a large dataset like ImageNet. The training process included the use of mixed precision for potentially faster training and reduced memory usage.
+
+* **Developed by:** Based on the notebook, this seems to be a personal project or tutorial. You should replace this with the actual developer's name or organization.
+
+* **Model type:** Image Classification (likely Transfer Learning with a CNN backbone)
+
+* **Language(s) (NLP):** N/A (Image Classification)
+
+* **License:** MIT
+
+* **Finetuned from model:** \[More Information Needed - Specify the base model used for transfer learning, e.g., EfficientNet, ResNet]
+
+### Uses
+
+This model is intended for classifying images of food into 101 distinct categories. Potential use cases include:
+
+* Food recognition in mobile applications.
+
+* Organizing food images in databases.
+
+* Assisting in dietary tracking or recipe suggestions based on images.
+
+## Limitations
+
+* **Dataset Bias:** The model is trained on the Food101 dataset. Its performance may degrade on food images that are significantly different in style, presentation, or origin from those in the training data.
+
+* **Image Quality:** Performance can be affected by image quality, lighting conditions, occlusions, and variations in food presentation.
+
+* **Specificity:** While it classifies into 101 categories, it may not distinguish between very similar dishes or variations within a category.
+
+## Evaluation
+
+The model's performance was evaluated using standard classification metrics on a validation set from the Food101 dataset.
+
+#### Testing Data
+
+The model was evaluated on the validation split of the Food101 dataset.
+
+* **Food101 Dataset:** A dataset of 101 food categories, with 101,000 images. 750 training images and 250 testing images per class.
+
+* **Source:** [TensorFlow Datasets](https://www.tensorflow.org/datasets/catalog/food101)
+
+#### Factors
+
+Evaluation was performed on the overall validation dataset. Further analysis could involve disaggregating performance by individual food categories to identify classes where the model performs better or worse.
+
+#### Metrics
+
+The primary evaluation metric used is Accuracy. A confusion matrix was also generated to visualize per-class performance.
+
+* **Accuracy:** The proportion of correctly classified images out of the total number of images evaluated.
+    $\text{Accuracy} = \frac{\text{Number of correct predictions}}{\text{Total number of predictions}}$
+
+* **Confusion Matrix:** A table that visualizes the performance of a classification model. Each row represents the instances in an actual class, while each column represents the instances in a predicted class.
+
+### Results
+
+70-80% Fluctualting accuracy on validation data
+
+#### Summary
+
+Transfer learning helped the model achieve greater accuracy, though the model struggled with food closely related to each other indicating more data was needed. The Dataset used alot but more data is still needed to differentiate between closely looking food.
+
+## Environmental Impact
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+* **Hardware Type:** Tesla T4
+
+* **Hours used:** 1 hour estimate(max)
+
+* **Cloud Provider:** Google Cloud
+
+* **Compute Region:** us-central
+
+* **Carbon Emitted:** 80 grams of CO2eq (estimated)
+
+## Technical Specifications
+
+### Model Architecture and Objective
+
+The model is likely a fine-tuned convolutional neural network (CNN) classifier. The notebook mentions using mixed precision training, which suggests a modern CNN architecture compatible with `float16` data types. The objective is to minimize the classification loss (e.g., categorical cross-entropy) to accurately predict the food category given an image.
+
+### Compute Infrastructure
+
+The model was trained using a Tesla T4 GPU on Google Cloud in the us-central region. The estimated carbon emissions for 1 hour of training time on this setup are 80 grams of CO2eq. The environment was intended to support mixed precision training.
+
+### Software
+
+* TensorFlow
+
+* TensorFlow Datasets
+
+* NumPy
+
+* Matplotlib
+
+* Scikit-learn
+
+* Helper functions from `helper_functions.py` (likely for plotting, data handling)
+
+## Usage
+
+Here's an example of how to use the model for inference on a new image. This assumes the model has been saved in a TensorFlow SavedModel format.
+
+First, make sure you have TensorFlow installed:
+
+```bash
+pip install tensorflow
+```
+
+Then, you can load the model and make a prediction:
+```python
+import tensorflow as tf
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Assume the model is saved in a directory named 'food_vision_model'
+loaded_model = tf.keras.models.load_model('food_vision_model')
+
+# Define the class names (replace with the actual class names from your training)
+class_names = ['apple_pie', 'baby_back_ribs', 'baklava', 'beef_carpaccio', 'beef_tartare', 'beet_salad', 'beignets', 'bibimbap', 'bread_pudding', 'breakfast_burrito', 'bruschetta', 'buffalo_wings', 'caesar_salad', 'cannoli', 'caprese_salad', 'carrot_cake', '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_chicken', 'frozen_yogurt', 'garlic_bread', 'gnocchi', 'greek_salad', 'grilled_cheese_sandwich', 'grilled_salmon', 'guacamole', 'gyros', 'hamburger', 'hot_dog', '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', 'samosas', 'sashimi', 'scallops', 'shrimp_scampi', 'smores', 'spaghetti_bolognese', 'spaghetti_carbonara', 'spring_rolls', 'steak', 'strawberry_shortcake', 'sushi', 'tacos', 'takoyaki', 'tiramisu', 'tuna_tartare', 'waffles'] # Example class names
+
+# Create a function to load and prepare images (from your notebook)
+def load_prep_image(filepath, img_shape=224, scale=True):
+    """
+        Reads in an image and preprocesses it for model prediction
+
+        Args:
+            filepath (str): path to target image
+            img_shape (int): shape to resize image to. Default = 224
+            scale (bool): Condition to scale image. Default = True
+
+        Returns:
+            Image Tensor of shape (img_shape, img_shape, 3)
+    """
+    image = tf.io.read_file(filepath)
+    image_tensor = tf.io.decode_image(image, channels=3)
+    image_tensor = tf.image.resize(image_tensor, [img_shape, img_shape])
+    if scale:
+        # Scale image tensor to be between 0 and 1
+        scaled_image_tensor = image_tensor / 255.
+        return scaled_image_tensor
+    else:
+        return image_tensor
+
+# Load and preprocess a sample image
+# Replace 'path/to/your/image.jpg' with the actual path to your image
+sample_image_path = 'path/to/your/image.jpg'
+prepared_image = load_prep_image(sample_image_path)
+
+# Add a batch dimension to the image
+prepared_image = tf.expand_dims(prepared_image, axis=0)
+
+# Make a prediction
+predictions = loaded_model.predict(prepared_image)
+
+# Get the predicted class index
+predicted_class_index = np.argmax(predictions)
+
+# Get the predicted class name
+predicted_class_name = class_names[predicted_class_index]
+
+# Print the prediction
+print(f"The predicted food item is: {predicted_class_name}")
+
+# Optional: Display the image
+# img = plt.imread(sample_image_path)
+# plt.imshow(img)
+# plt.title(f"Prediction: {predicted_class_name}")
+# plt.axis('off')
+# plt.show()
+```