Cooking similarity - Exploration des données et NLP (2)

Cette deuxième partie fait suite au notebook (1) et explique comment nous allons traiter et extraire des données écrite par des utilisateurs. C'est ce qu'on appelle le "Natural Language Processing" (NLP) autrement appelé en français “Traitement automatique du langage naturel”.

En effet, ces recettes ont eté écrites par des utilisateurs du site Epicurious qui ont chacun une façon différente d'écrire les recettes.

La problématique ici est donc de "traduire" l'information de l'être humain pour que l'ordinateur puisse l'exploiter. Dans notre cas, nous voudrions montrer des similitudes de recette graphiquement à partir de données collectées automatiquement dans des fichiers Json.

In [1]:
from IPython.display import Image
Image(filename="images/description_roastedalmond.png")
Out[1]:

Le format idéal pour exploiter les données serait de simplement écrire:

ingredient+ quantité+ unité

par exemple: Farine: 2 cups

Cependant il existe plusieurs variantes comme l'exemple ci dessus où il propose plusieurs choix and/or ou précise entre parenthèse ou séparé par des virgules ou autres...

Dans un premier temps, nous allons chercher des informations sur les recettes tel que les ingrédients les plus utilisés.


Les fonctions suivantes du notebook Recipe_1 nous permettent d'avoir un aperçu des catégories existantes.

In [2]:
import sys
import numpy as np
import pandas as pd 
from pandas import read_csv
import operator

%matplotlib inline
from plotly import __version__
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import cufflinks as cf

# For Notebooks
init_notebook_mode(connected=True)

# For offline use
cf.go_offline()


df = pd.read_json("full_format_recipes.json")
df.head()
Out[2]:
calories categories date desc directions fat ingredients protein rating sodium title
0 426.0 [Sandwich, Bean, Fruit, Tomato, turkey, Vegeta... 2006-09-01 04:00:00 None [1. Place the stock, lentils, celery, carrot, ... 7.0 [4 cups low-sodium vegetable or chicken stock,... 30.0 2.500 559.0 Lentil, Apple, and Turkey Wrap
1 403.0 [Food Processor, Onion, Pork, Bake, Bastille D... 2004-08-20 04:00:00 This uses the same ingredients found in boudin... [Combine first 9 ingredients in heavy medium s... 23.0 [1 1/2 cups whipping cream, 2 medium onions, c... 18.0 4.375 1439.0 Boudin Blanc Terrine with Red Onion Confit
2 165.0 [Soup/Stew, Dairy, Potato, Vegetable, Fennel, ... 2004-08-20 04:00:00 None [In a large heavy saucepan cook diced fennel a... 7.0 [1 fennel bulb (sometimes called anise), stalk... 6.0 3.750 165.0 Potato and Fennel Soup Hodge
3 NaN [Fish, Olive, Tomato, Sauté, Low Fat, Low Cal,... 2009-03-27 04:00:00 The Sicilian-style tomato sauce has tons of Me... [Heat oil in heavy large skillet over medium-h... NaN [2 tablespoons extra-virgin olive oil, 1 cup c... NaN 5.000 NaN Mahi-Mahi in Tomato Olive Sauce
4 547.0 [Cheese, Dairy, Pasta, Vegetable, Side, Bake, ... 2004-08-20 04:00:00 None [Preheat oven to 350°F. Lightly grease 8x8x2-i... 32.0 [1 12-ounce package frozen spinach soufflé, th... 20.0 3.125 452.0 Spinach Noodle Casserole
In [3]:
def keepCategorie(df, categorie):
    rowToDelete = []
    for row, categories in enumerate(df.categories):
        if not isinstance(categories, list):
            rowToDelete.append(row)
        elif not categorie in categories:
                rowToDelete.append(row)

    df = df.drop(rowToDelete)
    return df
In [4]:
def getNumbersOfRecipeByCategories(df):
    result = {} 
    for categoriesList in df.categories:
        # check if it is really a list of categories
        if not isinstance(categoriesList, list):
            # if not, skip
            continue
        for categorie in categoriesList:
            if categorie in result:
                result[categorie] += 1
            else:
                result[categorie] = 1
    return result
In [5]:
recipeCategCount = getNumbersOfRecipeByCategories(df)
sorted_recipeCategCount = sorted(recipeCategCount.items(), key=operator.itemgetter(1), reverse=True)
dFrame1 = pd.DataFrame(sorted_recipeCategCount, columns=['Categorie','Frequency'])
dFrame1.head()
Out[5]:
Categorie Frequency
0 Bon Appétit 9355
1 Peanut Free 8390
2 Soy Free 8088
3 Tree Nut Free 7044
4 Vegetarian 6846

Ingrédients les plus utilisés

On veut trouver les ingrédients les plus utilisés.

Pour cela il faudrait lister et compter tous les ingrédients. On peut parcourir toute la liste des ingrédients et tenter de garder seulement le nom de l'ingrédient, c'est à dire ne pas prendre en compte la quantité.

Par exemple si on lit : "2 tablespoons extra-virgin olive oil" on veut garder que "extra-virgin olive oil". Géneralement les items dans la liste des ingrédients se présentent ainsi :

quantité + unité de mesure + ingrédient

On peut trouver des variantes :

quantité + unité de mesure + ingrédient + 'or' + quantité + unité de mesure + ingrédient

Parfois la quantitée n'est pas seulement un nombre, par exemple :

1 1/2 cup of ...

Il faut donc tokeniser tous les strings et essayer de garder seulement les ingrédients.

Il y a beaucoup de variantes dans les formulations, il est difficile d'extraire correctement les ingrédients, sans compter les erreurs dans les données.

In [6]:
def updateDict(ingredientDict, ingredient):
    if not isinstance(ingredient, str):
        return ingredientDict
    
    if ingredient == '' or ingredient == ' ' :
        return ingredientDict

    while ingredient[-1] == ')' or ingredient[-1] == '*' or ingredient[-1] == ' ':
        ingredient = ingredient[:-1]
    
    if '(' in ingredient and not ')' in ingredient:
        ingredient = ingredient[:ingredient.index('(')]
        
    if ingredient == '' or ingredient == ' ' :
        return ingredientDict
    
    ingredient = ingredient.lower()
    
    if ingredient in ingredientDict:
        ingredientDict[ingredient] += 1
    else:
        ingredientDict[ingredient] = 1
    return ingredientDict

def extractIngredient(allIngredientsRecipesList):
    ingredientDict = {}
    for ingredientsRecipesList in allIngredientsRecipesList:
         # check if it is really a list of categories
        if not isinstance(ingredientsRecipesList, list): continue
        for listOfIngredients in ingredientsRecipesList:
            for string in listOfIngredients.split('or '):
                try:                    
                    # sometimes ingredient will be like this : carrot, peeled and chopped
                    # so we remove everything after ','
                    string = string.split(',')[0]
                    if len(string) == 0 or string == ' ': continue

                    # Sometimes string is '12 thick-sliced bacon strips (about 1 pound)'
                    # So we want to remove brackets and whats inside
                    if string[-1] == ')':
                        string = string.split('(')[0]
                    if len(string) == 0 or string == ' ': continue
                    
                    if len(string.split(' ')) == 1 : # easy case : a word alone
                        ingredientDict = updateDict(ingredientDict, string)
                        continue
                    
                    elif string[0].isdigit and len(string.split(' ')) == 2 : # easy case : quantity and ingredient
                        ingredient = string.split(' ')[1]
                        # update dict
                        ingredientDict = updateDict(ingredientDict, ingredient)
                        continue
                        
                    elif len(string.split(' ')) == 2 : # easy case : 2 words 
                        ingredientDict = updateDict(ingredientDict, string)
                        continue
                        
                    # now more complicated cases
                    lastDigitIndex = -1
                    for index, char in enumerate(string) : 
                        if char.isdigit():
                            lastDigitIndex = index

                    unitAndIngredient = ''
                    if lastDigitIndex == -1 :
                            unitAndIngredient = string
                    else :
                        unitAndIngredient = string[lastDigitIndex+2:]

                    # Now we have to seperate unit measure and ingredient.
                    if len(unitAndIngredient.split(' ')) == 1 :
                        ingredientDict = updateDict(ingredientDict, unitAndIngredient)
                        continue
                    
                    ingredient = ''
                    # if the word 'of' is in the string
                    if ' of ' in unitAndIngredient:
                        # get the index of 'of'
                        index = unitAndIngredient.index(' of ')
                        # and keep everything after that as ingredient
                        
                        ingredient = unitAndIngredient[index+4:]

                    # else considere string is formated like this 'something ingredient'
                    # so keep everything after first space
                    else:
                        index = unitAndIngredient.index(' ')
                        ingredient = unitAndIngredient[index+1:]

                    ingredientDict = updateDict(ingredientDict, ingredient)
                    
                except ValueError:
                    print("Error in string : ", string)
                except :
                    print(string)
                    print("Unexpected error:", sys.exc_info()[0])
                    
    return ingredientDict
In [7]:
ingredientsDict = extractIngredient(df.ingredients.tolist())
sorted_ingredientsDict = sorted(ingredientsDict.items(), key=operator.itemgetter(1), reverse=True)

Après traitement et extraction des données,on obtient la liste d'ingrédients suivante (ordre décroissant des ingrédients les plus utilisés au moins utilisés).

La première colonne correspond au nom de l'ingrédient et la deuxième colonne correspond à sa fréquence d'apparition.

In [8]:
dFrame = pd.DataFrame(sorted_ingredientsDict, columns=['Ingredients','Frequency'])
dFrame.head()
Out[8]:
Ingredients Frequency
0 salt 6538
1 sugar 5764
2 olive oil 4612
3 unsalted butter 4050
4 water 3240

Le jeu de données contiendrait donc au total 24 608 ingrédients différents.

On remarque par exemple que les 5 ingrédients les plus utilisés sont:

In [10]:
df_head.iplot(kind='bar',x='Ingredients',y='Frequency')

Il s'agit du sel, du sucre, de l'huile d'olive, du beurre doux, et de l'eau.

Ces ingrédients sont des condiments pour la plupart, ce qui semble logique car ils sont souvent utilisés que ça soit dans les recettes salées ou les recettes sucrées.


Distribution des ingrédients par recette

In [11]:
def getIngredientCountList(allIngredientsRecipesList):
    ingredientCountList = []
    for ingredientsRecipesList in allIngredientsRecipesList:
        # check if it is really a list of categories
        if not isinstance(ingredientsRecipesList, list): continue
        ingredientCountList.append(len(ingredientsRecipesList))
        
    return ingredientCountList
In [12]:
import plotly.figure_factory as ff
import plotly.plotly as py

hist_data = getIngredientCountList(df.ingredients.tolist())

fig = ff.create_distplot([hist_data], ["group_labels"], bin_size=.5, curve_type='normal', colors=['#3A4750'])

# Add title
fig['layout'].update(title='Distribution des ingrédients par recette')

# Plot!
py.iplot(fig, filename='Distribution des ingrédients par recette')
C:\Users\YUMI\Anaconda3\lib\site-packages\IPython\core\display.py:689: UserWarning:

Consider using IPython.display.IFrame instead

Out[12]:

La distribution du total des ingrédients par recette nous montre qu'en moyenne la plupart des recettes utilisent environ 8 à 10 ingrédients.

Nous allons ensuite utiliser ces informations pour les afficher dans notre interface web et pouvoir comparer des similitudes entre les recettes.


La suite logique serait d'exploiter ce travail pour générer un fichier json personnalisé pour notre interface web.

Cependant, traiter automatiquement les ingrédients présentent plusieurs difficultés:

  1. La fonction extractIngredient traite les différents cas dans des "if", ce qui n'est pas optimal et peut engendrer des erreurs.
  2. L'extraction et traitement automatique d'un grand jeu de données (20 000 recettes) inclu de nombreuses exceptions qui peuvent nous échapper et compromettre les résultats.

Il serait donc intéressant de trouver d'autres méthodes de NLP efficaces qui pourrait répondre à notre problématique.