Recipe Recommendation from Available Ingredients using TF-IDF (Food.com Dataset)

Most home cooks decide what to cook from whatever is already in the kitchen, yet recipe websites are organised the other way round: pick a dish first, then discover half the ingredients are missing. Searching by a handful of available ingredients is also harder than it looks, because a plain keyword search treats salt, which appears in almost every recipe, as equally important as saffron, which appears in very few. This project builds the search from the pantry outward. Recipes from the Food.com corpus are indexed by their ingredient lists, the pantry is treated as a query, and TF-IDF weighting with cosine similarity ranks recipes so that sharing a rare ingredient counts for more than sharing a universal one. Every result explains itself with a match score, the ingredients already available and the short shopping list that remains.

1. RAW_recipes.csv from the Food.com release is loaded and cleaned: rows without ingredient lists are dropped, ingredient strings are lower-cased, quantities and preparation words are stripped, and plural forms are normalised to a single token.
2. A working subset is kept — recipes with complete ingredient lists and a realistic ingredient count — and each surviving recipe is stored as one document made only of its ingredient tokens.
3. TfidfVectorizer fits the corpus: term frequency is counted inside each recipe and inverse document frequency is computed across all recipes, down-weighting ingredients such as salt and water.
4. The fitted vectors are stored as a sparse recipe-by-ingredient matrix, so ranking a new pantry does not require refitting the model.
5. At query time the pantry chips are normalised with the same rules, transformed into the fitted TF-IDF space and compared with every recipe vector using cosine similarity.
6. Scores are converted to match percentages, recipes are filtered by cooking time, vegetarian flag and the maximum missing-ingredient count, and the survivors are sorted by score.
7. Each result card shows the have and missing ingredient split, and the detail view renders the full ingredient checklist and cooking steps for the selected Food.com record.

Tech stack:

• Python 3, pandas (dataset cleaning)
• scikit-learn TfidfVectorizer, cosine similarity
• Food.com Recipes and Interactions (Kaggle)
• Jupyter Notebook (indexing & evaluation)
• HTML, CSS, JavaScript (web interface)
• Sparse matrix storage (SciPy)

Dataset & model details

• Dataset: Food.com Recipes and Interactions, released on Kaggle by shuyangli94 and originally collected from Food.com (Majumder et al., 2019). RAW_recipes.csv holds approximately 231,637 recipes (Approximate, release-dependent) with name, minutes, tags, nutrition, number of steps, steps, description, ingredients and number of ingredients. This implementation indexes a filtered working subset with complete ingredient lists; the exact subset size is recorded in the report for the delivered run.
• Task: Information-retrieval ranking, not classification. Input = a set of available ingredient names entered by the user. Output = a ranked list of existing recipes with a cosine similarity score, a have/missing ingredient split and the recipe steps. There are no fixed output classes: each recipe is a retrievable document and the ingredient vocabulary forms the feature space.
• Model: TF-IDF vectorisation (scikit-learn TfidfVectorizer over normalised ingredient tokens) with cosine similarity ranking. No neural network is trained; the fitted IDF weights and the sparse document matrix are the model artefacts.
• Metrics: Precision@5 and Precision@10, Recall@10, corpus coverage and mean missing ingredients across the top 5, all computed on held-out test pantries in the evaluation notebook. Design target: Precision@5 of 0.70 or above and mean missing ingredients of 1.5 or fewer in the top 5. No performance figure is claimed as measured until the evaluation run is executed for the order.

• [Pantry-first ingredient input] Ingredients are added as removable chips, typed in or tapped from a quick-add list, so the query always shows exactly what the ranking is based on.
• [TF-IDF recipe index] Every recipe becomes a document of normalised ingredient tokens, vectorised with scikit-learn TfidfVectorizer so rare ingredients carry more weight than near-universal ones.
• [Cosine similarity ranking] The pantry vector is compared with every recipe vector and results are sorted by cosine score, displayed as a match percentage with the raw score kept visible.
• [Missing-ingredient shopping list] Each card separates ingredients already in the pantry from those still to buy, and a filter limits results to recipes missing zero, one or two items.
• [Time and vegetarian filters] A cooking-time slider and a vegetarian toggle narrow the ranked list without re-running the index, mirroring how a cook actually shortlists dishes.
• [Full recipe detail view] Selecting a result opens the complete ingredient checklist marked against the pantry, the shopping list and the step-by-step method from the dataset record.
• [Ranking explainer panel] A dedicated view walks through term frequency, inverse document frequency and cosine similarity with the evaluation metrics, so the method can be revised directly from the demo.
• [Offline evaluation notebook] Held-out test pantries are scored with Precision@K, Recall@K, coverage and mean missing ingredients, with the results table written into the project report.

• Complete source code for cleaning, TF-IDF indexing, ranking and the web interface
• Cleaned Food.com working subset with the preprocessing script that produced it
• Jupyter notebook covering indexing and the offline evaluation with metrics tables
• Project report PDF (background, TF-IDF theory, methodology, evaluation, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (TF-IDF, IDF weighting, cosine similarity, Precision@K, sparsity)
• Project abstract PDF