利用机器学习探索食物配方：通过Word2Vec模型进行菜谱分析

 #load the recipes dataset
 filepath = "/kaggle/input/foodrecipes/recipes.csv"
 df_recipes = pd.read_csv(filepath, encoding="ISO-8859-1")
 
 #drop rows where cuisine, ingregients are NA
 df_recipes.dropna(subset=['cuisine', 'ingredients'],inplace=True)
 df_recipes

 #convert to lower case
 df_recipes['ingredients'] = df_recipes['ingredients'].apply(lambda x: x.lower())
 
 total_ingredients = []
 all_receipes_ingredients =  []
 
 for i in range(len(df_recipes)):
     all_ingredients = list()
     
     #split each recipe into different ingredients
     ingred = df_recipes.loc[i, "ingredients"][1:-1]
     
     for ing in (ingred.split(',')):
         ing = remove_stopwords(ing)
         ing = strip_numeric(ing)
         ing = re.sub(r'\(.*oz.\)|(®)|(.*ed)|(.*ly)|boneless|skinless|chunks|fresh|large|cook drain|green|frozen|ground','',ing).strip()
         ing = strip_short(ing,2)
         ing = strip_multiple_whitespaces(ing)
         ing = strip_punctuation(ing)
         ing = strip_non_alphanum(ing)
         
         #convert plurals to singular e.g. tomatoes --> tomato
         ing = (" ".join(TextBlob(ing).words.singularize()))
         
         all_ingredients.append(ing)
         total_ingredients.append(ing)
         
     all_receipes_ingredients.append(all_ingredients)
     
 counts_ingr = collections.Counter(total_ingredients)
 
 print('Size Ingredients dataset (with repetition):  \t{}'.format((len(total_ingredients))))
 print('Unique Ingredients dataset: \t\t\t{}'.format((len(counts_ingr.values()))))
 print('Size Receipes dataset:  \t{}'.format((len(all_receipes_ingredients))))

#add cleaned ingredients back to original dataframe
 df_recipes['clean_ingredients'] = pd.Series(all_receipes_ingredients)
 
 #record the number of ingredients for each recipe
 df_recipes['ingredient_count'] = df_recipes.apply(lambda row: len(row['clean_ingredients']), axis = 1)
 
 #convert time in seconds to minutes
 df_recipes['timeMins'] = df_recipes.totalTimeInSeconds.apply(lambda x: x/60)

 #find the most common ingredients used across all recipes
 print ("---- Most Common Ingredients ----")
 print (counts_ingr.most_common(10))print ("\n")#find the most common ingredients used across all recipes
 print ("---- Least Common Ingredients ----")
 print (counts_ingr.most_common()[-10:])

 #visualize the ingredients in WordCloud
 
 from wordcloud import WordCloud
 
 def plot_wordcloud(text, title=None, max = 1000, size=(12,8), title_size=16):
     """plots wordcloud"""
     wordcloud = WordCloud(max_words=max).generate(text)
     plt.figure(figsize=size)
     plt.title(title, size=title_size)
     plt.imshow(wordcloud, interpolation='bilinear')
     plt.axis("off")
 
 plot_wordcloud(' '.join(total_ingredients), title='Ingredients')

 #Train the Word2Vec model
 
 num_features = 300    
 # Word vector dimensionality - The size of the dense vector to represent each token or word
 #(i.e. the context or neighboring words). If you have limited data, then size should be a much smaller value
 #since you would only have so many unique neighbors for a given word
 
 min_word_count = 4                        
 # Minimium frequency count of words. The model would ignore words that do not satisfy the min_count.
 
 num_workers = 4       # How many threads to use behind the scenes?
 
 context = 10          
 # The maximum distance between the target word and its neighboring word.  
 
 downsampling = 1e-2  
 # threshold for configuring which higher-frequency words are randomly downsampled
             
 # Initialize and train the model
 model = word2vec.Word2Vec(all_receipes_ingredients, workers=num_workers, \
             size=num_features, min_count = min_word_count, \
             window = context,sample = downsampling, iter=20)
 
 # If you don't plan to train the model any further, calling
 # init_sims will make the model much more memory-efficient.
 model.init_sims(replace=True)

 # check the similar ingredients returned by the model for search_termssimilar_words = {search_term: [item[0] for item in model.wv.most_similar([search_term], topn=5)]
                   for search_term in ['paneer','egg','mango','bread', 'rice']}
 similar_words

 model.wv.most_similar('chocolate')

 model.wv.most_similar('mayonnaise')

 model.wv.most_similar(‘chicken’)

 model.wv.similarity(‘paneer’, ‘chicken’)

 x = ‘chicken’
 b= ‘cheese’
 a = ‘bread’
 predicted = model.wv.most_similar([x, b], [a])[0][0]
 print(“ {} is to {} as {} is to {} “.format(a, b, x, predicted))

 #visualization with Tsne
 from sklearn.manifold import TSNE
 
 words = sum([[k] + v for k, v in similar_words.items()], [])
 wvs = model.wv[words]
 tsne = TSNE(n_components=2, random_state=0, n_iter=1000, perplexity=2)
 np.set_printoptions(suppress=True)
 T = tsne.fit_transform(wvs)
 labels = words
 
 plt.figure(figsize=(14, 8))
 plt.scatter(T[:, 0], T[:, 1], c='orange', edgecolors='r')
 for label, x, y in zip(labels, T[:, 0], T[:, 1]):
     plt.annotate(label, xy=(x+1, y+1), xytext=(0, 0), textcoords='offset points')