使用scikitlearn、NLTK、Docker、Flask和Heroku构建食谱推荐API

import nltk
vocabulary = nltk.FreqDist()

# 我已经做好了原料的预处理
for ingredients in recipe_df['ingredients']:
    ingredients = ingredients.split()
    vocabulary.update(ingredients)
    
for word, frequency in vocabulary.most_common(200):
    print(f'{word};{frequency}')

def ingredient_parser(ingredients):

    # 量度和常用词（已被词形还原）
    measures = ['teaspoon', 't', 'tsp.', 'tablespoon', 'T', ...]
    words_to_remove = ['fresh', 'oil', 'a', 'red', 'bunch', ...]
    
    # 将成分列表从字符串转换为列表
    if isinstance(ingredients, list):
       ingredients = ingredients
    else:
       ingredients = ast.literal_eval(ingredients)
       
    # 我们首先去掉所有的标点符号
    translator = str.maketrans('', '', string.punctuation)
    
    # 初始化nltk的lemmatizer
    lemmatizer = WordNetLemmatizer()
ingred_list = []
    for i in ingredients:
        i.translate(translator)
        
        # 我们用连字符和空格分开
        items = re.split(' |-', i)
        
        # 把所有内容都改成小写
        items = [word for word in items if word.isalpha()]
        
        # 小写
        items = [word.lower() for word in items]
        
        # 统一编码
        items = [unidecode.unidecode(word) for word in items]
        
        # 词形还原，这样我们可以比较
        items = [lemmatizer.lemmatize(word) for word in items]
        
        # 删除停用词
        stop_words = set(corpus.stopwords.words('english'))
        items = [word for word in items if word not in stop_words]
        
        # #避免测量单词/短语, 例如. heaped teaspoon
        items = [word for word in items if word not in measures]
        
        # 删除常见的简单词汇
        items = [word for word in items if word not in words_to_remove]
        if items:
           ingred_list.append(' '.join(items))
           ingred_list = ' '.join(ingred_list)
    return ingred_list

recipe_df = pd.read_csv(config.RECIPES_PATH)
recipe_df['ingredients_parsed'] = recipe_df['ingredients'].apply(lambda x: ingredient_parser(x))
df = recipe_df.dropna()
df.to_csv(config.PARSED_PATH, index=False)

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
import pickle
import config

# 加载解析的食谱数据集
df_recipes = pd.read_csv(config.PARSED_PATH)

# Tfidf需要unicode或string类型
df_recipes['ingredients_parsed'] = df_recipes.ingredients_parsed.values.astype('U')

# TF-IDF特征提取程序
tfidf = TfidfVectorizer()
tfidf.fit(df_recipes['ingredients_parsed'])
tfidf_recipe = tfidf.transform(df_recipes['ingredients_parsed'])

# 保存tfidf模型和编码
with open(config.TFIDF_MODEL_PATH, "wb") as f:
     pickle.dump(tfidf, f)
     
with open(config.TFIDF_ENCODING_PATH, "wb") as f:
     pickle.dump(tfidf_recipe, f)

from sklearn.metrics.pairwise import cosine_similarity
from sklearn.feature_extraction.text import TfidfVectorizer
import pickle
import config
from ingredient_parser import ingredient_parser

# 加载tdidf模型和编码
with open(config.TFIDF_ENCODING_PATH, 'rb') as f:
     tfidf_encodings = pickle.load(f)
with open(config.TFIDF_MODEL_PATH, "rb") as f:
     tfidf = pickle.load(f)
     
# 使用ingredient_parser分析配料
try:
    ingredients_parsed = ingredient_parser(ingredients)
except:
    ingredients_parsed = ingredient_parser([ingredients])
    
# 使用我们预训练的tfidf模型对输入成分进行编码
ingredients_tfidf = tfidf.transform([ingredients_parsed])

# 计算实际食谱和测试食谱之间的余弦相似性
cos_sim = map(lambda x: cosine_similarity(ingredients_tfidf, x), tfidf_encodings)
scores = list(cos_sim)

def get_recommendations(N, scores):
    # 加载食谱数据集
    df_recipes = pd.read_csv(config.PARSED_PATH)
    
    # 对分数排序，得到N个最高的分数
    top = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:N]
    
    # 在dataframe中创建建议
    recommendation = pd.DataFrame(columns = ['recipe', 'ingredients', 'score', 'url'])
    
    count = 0
    for i in top:
        recommendation.at[count, 'recipe'] = title_parser(df_recipes['recipe_name'][i])
        
        recommendation.at[count, 'ingredients'] = ingredient_parser_final(df_recipes['ingredients'][i])
        
        recommendation.at[count, 'url'] = df_recipes['recipe_urls'][i]
        recommendation.at[count, 'score'] = "{:.3f}".format(float(scores[i]))
        
        count += 1
    return recommendation

{ "ingredients" : "1 (15 ounce) can tomato sauce, 1 (8 ounce) package uncooked pasta shells, 1 large zucchini - peeled and cubed, 1 teaspoon dried basil, 1 teaspoon dried oregano, 1/2 cup white sugar, 1/2 medium onion, finely chopped, 1/4 cup grated Romano cheese, 1/4 cup olive oil, 1/8 teaspoon crushed red pepper flakes, 2 cups water, 3 cloves garlic, minced",

  "recipe" : "Zucchini and Shells",  
  
  "score: "0.760",
 
  "url":"https://www.allrecipes.com/recipe/88377/zucchini-and-shells/"
}

# app.py
from flask import Flask, jsonify, request
import json, requests, pickle
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from ingredient_parser import ingredient_parser
import config, rec_sys

app = Flask(__name__)
@app.route('/', methods=["GET"])
def hello():
    # 这是我们API的主页
    # 它可以通过http://127.0.0.1:5000/访问
    return HELLO_HTML
    
HELLO_HTML = """
     <html><body>
         <h1>Welcome to my api: Whatscooking!</h1>
         <p>Please add some ingredients to the url to receive recipe recommendations.
            You can do this by appending "/recipe?ingredients= Pasta Tomato ..." to the current url.
         <br>Click <a href="/recipe?ingredients= pasta tomato onion">here</a> for an example when using the ingredients: pasta, tomato and onion.
     </body></html>
     """
     
@app.route('/recipe', methods=["GET"])
def recommend_recipe():
    # 可以通过http://127.0.0.1:5000/recipe访问
    ingredients = request.args.get('ingredients')
    recipe = rec_sys.RecSys(ingredients)
    
    # 我们需要将输出转换为JSON。
    response = {}
    count = 0    
    for index, row in recipe.iterrows():
        response[count] = {
                            'recipe': str(row['recipe']),
                            'score': str(row['score']),
                            'ingredients': str(row['ingredients']),
                            'url': str(row['url'])
                          }
                          
        count += 1
        
    return jsonify(response)
if __name__ == "__main__":
   app.run(host="0.0.0.0", debug=True)

web: gunicorn app:app

# 包括从何处获取映像（操作系统）
FROM ubuntu:18.04

MAINTAINER Jack Leitch 'jackmleitch@gmail.com'

# 自动按Y
RUN apt-get update && apt-get install -y \
    git \
    curl \
    ca-certificates \
    python3 \
    python3-pip \
    sudo \
    && rm -rf /var/lib/apt/lists/*
    
# 设置工作目录
WORKDIR /app

# 将currect目录中的所有内容复制到app目录中。
ADD . /app

# 安装所有要求
RUN pip3 install -r requirements.txt

# 下载wordnet作为它用来词形还原
RUN python3 -c "import nltk; nltk.download('wordnet')"

# CMD在容器启动后执行
CMD ["python3", "app.py"]

docker build -f Dockerfile -t whatscooking:api

docker run -p 5000:5000 -d whatscooking:api

docker pull jackmleitch/whatscooking:api