commit

FetchRecipe.py

@@ -0,0 +1,16 @@
+import requests
+import json
+
+url = "https://rapidapi.com/spoonacular/api/recipe-food-nutrition"
+
+querystring = {"q":"chicken soup"}
+
+headers = {
+    'x-rapidapi-host': "rapidapi.com/spoonacular/api/",
+    'x-rapidapi-key': "1f9b61c859214d3ab6a00a6d82ec5a85"
+    }
+
+response = requests.request("GET", url, headers=headers, params=querystring)
+json_data = json.loads(response.text)
+
+print(json_data)

Procfile.txt

@@ -0,0 +1 @@
+web: sh setup.sh && streamlit run app.py

README.md

@@ -1,12 +1,38 @@
 ---
-title: Seefood Know Your Receipe
-emoji: 😻
-colorFrom: green
+title: SeeFood
+emoji: 🐨
+colorFrom: yellow
 colorTo: pink
 sdk: streamlit
-sdk_version: 1.15.2
+sdk_version: 1.10.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Configuration
+
+`title`: _string_  
+Display title for the Space
+
+`emoji`: _string_  
+Space emoji (emoji-only character allowed)
+
+`colorFrom`: _string_  
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`colorTo`: _string_  
+Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
+
+`sdk`: _string_  
+Can be either `gradio` or `streamlit`
+
+`sdk_version` : _string_  
+Only applicable for `streamlit` SDK.  
+See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
+
+`app_file`: _string_  
+Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
+Path is relative to the root of the repository.
+
+`pinned`: _boolean_  
+Whether the Space stays on top of your list.

RecipeData.py

@@ -0,0 +1,69 @@
+import requests
+import json
+import random
+
+API_KEY = '1f9b61c859214d3ab6a00a6d82ec5a85'
+
+def fetchRecipeData(foodName, apiKey = API_KEY):
+    recipe = {}
+    
+    # Fetching recipe Details from food name
+    url = f"https://api.spoonacular.com/recipes/search?query={foodName}&apiKey={apiKey}"
+    response = requests.get(url)
+    json_data = response.json()
+    
+    # saving responce code 
+    response_status_code = response.status_code
+    
+    # selecting random recipe from fetched recipes
+    recipe_list = json_data['results']
+    foodRecipe = random.choice(recipe_list)
+    
+    recipe_ID = foodRecipe['id']
+    
+    # getting recipe details from api using recipe id
+    url = f"https://api.spoonacular.com/recipes/{recipe_ID}/information?apiKey={apiKey}&includeNutrition=true"
+    recipe_response = requests.get(url)
+    all_recipe_json_data = recipe_response.json()
+    
+    # recipe instructions
+    recipe_instructions = preprocessing_instructions(all_recipe_json_data['instructions'])
+    
+    # recipe summary
+    recipe_summary = all_recipe_json_data['summary']
+    
+    # recipe ingredients
+    recipe_Ingredients = all_recipe_json_data['extendedIngredients']
+    for i, dict in enumerate(recipe_Ingredients):
+        recipe_Ingredients[i] = dict['originalName']
+    Ingredients = ', '.join(recipe_Ingredients)
+
+    # caloric Breakdow of recipe
+    recipe_caloric_breakdown = all_recipe_json_data['nutrition']['caloricBreakdown']
+    
+    # storing all values in recipe dict
+    recipe['id'] = recipe_ID
+    recipe['title'] = foodRecipe['title']
+    recipe['readyTime'] = foodRecipe['readyInMinutes']
+    recipe['soureUrl'] = foodRecipe['sourceUrl']
+
+    recipe['instructions'] = recipe_instructions
+    
+    recipe['ingridents'] = recipe_Ingredients
+
+    recipe_summary = recipe_summary.replace('<b>', '')
+    recipe_summary = recipe_summary.replace('</b>', '')
+    recipe['summary'] = recipe_summary
+
+    recipe['percentProtein'] = recipe_caloric_breakdown['percentProtein']
+    recipe['percentFat'] = recipe_caloric_breakdown['percentFat']
+    recipe['percentCarbs'] = recipe_caloric_breakdown['percentCarbs']
+    
+    return response_status_code, recipe
+
+
+def preprocessing_instructions(text):
+    word_to_remove = ['<ol>', '</ol>', '<li>', '</li>']
+    for word in word_to_remove:
+        text = text.replace(word, '')
+    return text

app.py

@@ -0,0 +1,137 @@
+import streamlit as st
+import numpy as np
+import time
+import PIL
+import PIL.Image as Image
+from utils import make_pred_outside_india
+from utils import getmodel_outside_india
+from utils import getmodel_india
+from utils import load_prepare_img
+from utils import food_nofood_pred
+import sys
+from RecipeData import fetchRecipeData
+
+IMG_SIZE = (224, 224)
+model_V2 = 'efficientnet_b0.pt'
+model_V1 = 'indian_efficientnet_b0.pt'
+
+
+@st.cache()
+def model_prediction(model_path, img_file, rescale,selected_location):
+    input_img, device = load_prepare_img(img_file)
+    if(selected_location=='Outside India'):
+        model = getmodel_outside_india(model_path)
+        prediction = make_pred_outside_india(input_img, model, device, selected_location)
+    elif(selected_location=='India'):
+        model = getmodel_india(model_path)
+        
+        prediction = make_pred_outside_india(input_img, model, device, selected_location)
+    print(prediction)
+    sorceCode, recipe_data = fetchRecipeData(prediction)
+    return prediction, sorceCode, recipe_data         
+
+def main():
+    st.set_page_config(
+        page_title="SeeFood",
+        page_icon="🍔 Know Your Receipe",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+
+    st.title('SeeFood🍔')
+    st.write('Upload a food image and get the recipe for that food and other details of that food')
+
+    col1, col2 = st.columns(2)
+
+    with col1: 
+        # image uploading button
+        uploaded_file = st.file_uploader("Choose a file")
+        selected_location = st.selectbox('Select loaction',('India', 'Outside India'), index=1)
+        if uploaded_file is not None:
+            display_img = uploaded_file.read()
+            uploaded_img = Image.open(uploaded_file)
+            col2.image(display_img, width=500)
+            
+            
+        
+
+       
+        predict = st.button('Get Recipe!')
+        
+        
+
+    if predict:
+        if uploaded_file is not None:
+            with st.spinner('getting image type'):
+                img_type=food_nofood_pred(uploaded_img)
+                print(img_type)
+                
+            if(img_type=='food'):
+                
+                with st.spinner('Please Wait 👩‍🍳'):
+
+                    # setting model and rescalling 
+                    if selected_location == 'India':
+                        pred_model = model_V1 
+                        pred_rescale = True
+                    if selected_location == 'Outside India':
+                        pred_model = model_V2
+                        pred_rescale =True
+
+
+                    # makeing prediction and fetching food recipe form api
+                    food, source_code, recipe_data = model_prediction(pred_model, uploaded_img, pred_rescale,selected_location)
+
+                    # asssigning caleoric breakdown data
+                    percent_Protein = recipe_data['percentProtein']
+                    percent_fat = recipe_data['percentFat']
+                    percent_carbs = recipe_data['percentCarbs'] 
+
+                    # food name message
+                    col1.success(f"It's an {food}")
+
+                    if source_code == 200:
+                        # desplay food recipe
+                        st.header(recipe_data['title']+" Recipe")
+
+                        col3, col4 = st.columns(2)
+
+                        with col3:
+                            # Ingridents of recipie
+                            st.subheader('Ingredients')
+                            # st.info(recipe_data['ingridents'])
+                            for i in recipe_data['ingridents']:
+                                st.info(f"{i}")
+                        # Inctuction for recipe
+                        with col4:
+                            st.subheader('Instructions')
+                            st.info(recipe_data['instructions'])
+                            # st.subheader('Caloric Breakdown')
+                            '''
+                            ## Caloric Breakdown
+                            '''
+                            st.success(f'''
+                                        * Protien:  {percent_Protein}%
+                                        * Fat: {percent_fat}%
+                                        * Carbohydrates: {percent_carbs}%
+                                        ''')
+
+
+                    else:
+                        st.error('Something went wrong please try again :(')
+                        
+            elif(img_type=='not food'):
+               
+                            # Ingridents of recipie
+                st.warning('This is not food image Please try again!!')
+                
+
+
+        else:
+            st.warning('Please Upload Image')
+
+                
+
+
+if __name__=='__main__': 
+    main()

efficientnet_b0.pt

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

gitattributes.txt

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

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

requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.0.0
+numpy>=1.9.2
+pandas>=0.19
+tensorflow==2.6.0
+torch>=1.7.0
+matplotlib>=1.4.3
+scikit-learn>=0.18
+timm
+transformers

utils.py

@@ -0,0 +1,140 @@
+import os
+import requests
+import json
+import torch 
+import timm
+import torch.nn as nn
+import torchvision
+from torchvision import transforms, datasets, models
+import torch.nn.functional as F
+import PIL
+import PIL.Image as Image
+import numpy as np
+from transformers import CLIPProcessor, CLIPModel
+
+
+classes_outside_india = ['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', 'cheese plate', 'cheesecake', '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']
+
+classes_india = ['burger','butter_naan', 'chai', 'chapati', 'chole_bhature', 'dal_makhani', 'dhokla', 'fried_rice', 'idli',
+           'jalebi', 'kaathi_rolls', 'kadai_paneer', 'kulfi', 'masala_dosa', 'momos', 'paani_puri', 'pakode', 'pav_bhaji',
+           'pizza', 'samosa']
+
+
+def food_nofood_pred(input_image):
+    # input labels for clip model
+    labels = ['food', 'not food']
+
+        # CLIP Model for classification
+    food_nofood_model = CLIPModel.from_pretrained("flax-community/clip-rsicd-v2")
+    processor = CLIPProcessor.from_pretrained("flax-community/clip-rsicd-v2")
+  
+ #         image = Image.open(requests.get(uploaded_file, stream=True).raw)
+    inputs = processor(text=[f"a photo of a {l}" for l in labels], images=input_image, return_tensors="pt", padding=True)
+    outputs = food_nofood_model(**inputs)
+    logits_per_image = outputs.logits_per_image 
+    probs = logits_per_image.softmax(dim=1)
+    print(probs)
+    pred = probs.detach().cpu().numpy().argmax(axis=1)
+    pred_class = labels[pred[0]]
+    return pred_class
+
+def make_pred_outside_india(input_img, model, device, user_location):
+    input_img = input_img.unsqueeze(0)
+    model.eval()
+    pred = model(input_img)
+#     if torch.cuda.is_available():
+#         pred = F.softmax(pred).detach().cpu().numpy()  
+#         y_prob = pred.argmax(axis=1)[0]   #return index with highest class probability 
+#     else:
+    pred = F.softmax(pred).detach().numpy()
+    y_prob = pred.argmax(axis=1)[0]
+
+    if(user_location=='Outside India'):
+        class_label = classes_outside_india[y_prob]
+    elif(user_location=='India'):
+        class_label = classes_india[y_prob]
+    return class_label
+
+
+def getmodel_outside_india(model_path):
+#     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    effnet_b0 = timm.create_model(pretrained=True, model_name='tf_efficientnet_b0')
+
+    for param in effnet_b0.parameters():
+        param.requires_grad = True
+
+    effnet_b0.classifier = nn.Linear(1280, len(classes_outside_india))
+    effnet_b0 = effnet_b0
+
+    #Model Loading
+    effnet_b0.load_state_dict(torch.load(model_path,map_location='cpu'))
+    return effnet_b0
+
+
+def getmodel_india(model_path):
+    #defining model
+#     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    effnet_b0 = timm.create_model(pretrained=True, model_name='tf_efficientnet_b0')
+
+    for param in effnet_b0.parameters():
+        param.requires_grad = True
+
+    effnet_b0.classifier = nn.Linear(1280, len(classes_india))
+    effnet_b0 = effnet_b0
+
+    #Model Loading
+    effnet_b0.load_state_dict(torch.load(model_path, map_location='cpu'))
+    return effnet_b0
+
+
+def load_prepare_img(image):
+    normalize = transforms.Normalize(
+    [0.485, 0.456, 0.406], 
+    [0.229, 0.224, 0.225]
+    )
+
+    test_transform = transforms.Compose([
+        transforms.Resize((225, 225)),
+        transforms.CenterCrop(224),
+        transforms.ToTensor(),
+        normalize,
+    ])
+    input_img = test_transform(image)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    return input_img,device
+
+def fetch_recipe(food_name):
+    url = "https://recipesapi2.p.rapidapi.com/recipes/"+food_name
+    querystring = {"maxRecipes":"1"}
+
+    headers = {
+        'x-rapidapi-host': "recipesapi2.p.rapidapi.com",
+        'x-rapidapi-key': "f6f6823b91msh9e92fed91d5356ap136f5djsn494d8f582fb3"
+        }
+
+    response = requests.request("GET", url, headers=headers, params=querystring)
+    json_data = json.loads(response.text)
+
+    recipe_data = json_data['data'][0]
+
+    return recipe_data