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.
from IPython.display import Image
Image(filename="images/description_roastedalmond.png")
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.
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()
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
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
recipeCategCount = getNumbersOfRecipeByCategories(df)
sorted_recipeCategCount = sorted(recipeCategCount.items(), key=operator.itemgetter(1), reverse=True)
dFrame1 = pd.DataFrame(sorted_recipeCategCount, columns=['Categorie','Frequency'])
dFrame1.head()
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.
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
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.
dFrame = pd.DataFrame(sorted_ingredientsDict, columns=['Ingredients','Frequency'])
dFrame.head()
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:
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.
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
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')
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:
Il serait donc intéressant de trouver d'autres méthodes de NLP efficaces qui pourrait répondre à notre problématique.