CN113807491A

CN113807491A - Method for simulating target food item using artificial intelligence

Info

Publication number: CN113807491A
Application number: CN202010543907.8A
Authority: CN
Inventors: 卡里姆·皮查拉; 巴勃罗·萨莫拉; 马蒂亚斯·穆彻尼克; 奥兰多·瓦斯克斯
Original assignee: Notco Delaware Co ltd
Current assignee: Notco Delaware Co ltd; Notco Delaware LLC
Priority date: 2020-06-15
Filing date: 2020-06-15
Publication date: 2021-12-17

Abstract

Methods and systems for simulating a target food item using artificial intelligence are disclosed. The system can learn from open source and proprietary databases. The characteristics of the source ingredients may be used to train the predictive model to match the characteristics of a given target food item. A formulation including a combination of the most relevant source ingredients and their proportions may be determined using a trained predictive model. A set of existing recipes can be used as a data set for training a Recurrent Neural Network (RNN) and/or other suitable models. The RNN may be used to determine a recipe for simulating a target food item. The recipe may include a cooking process for a set of ingredients in the recipe and may be cooked by a chef. The recipe may be further modified as necessary based on human feedback on the sensory descriptors.

Description

Method for simulating target food item using artificial intelligence

Technical Field

The present disclosure relates generally to food science and artificial intelligence, and in particular to simulating a target food item using machine learning.

Background

Relates to the related technology in the fields of food science and artificial intelligence.

Disclosure of Invention

Embodiments of the present disclosure provide a computer-implemented method for generating a recipe using plant-based ingredients to simulate a given animal-based food item. The method comprises the following steps: identifying a set of features associated with a given animal-based food item using a target ingredient database, wherein the target ingredient database is configured to store a respective set of features for each of a plurality of animal-based food items; training a predictive model to select potential candidates from a plurality of plant-based ingredients stored in a source ingredient database to match the identified set of features associated with the given animal-based food item, wherein the source ingredient database is configured to store a respective set of features for each of the plurality of plant-based ingredients; based on the identified matches of the set of features, determining a recipe using the trained predictive model, the recipe for combining the potential candidates in a particular proportion; training a Recurrent Neural Network (RNN) using a set of existing recipes to determine a cooking process for the recipe; and generating a recipe using the RNN, the recipe including a cooking process to simulate a given animal-based food item.

Embodiments of the present disclosure also provide a computer-implemented method for generating a recipe for simulating a given target food item. The method comprises the following steps: identifying a set of features associated with a given target food item using a target ingredient database, wherein the target ingredient database is configured to store a respective set of features for each of a plurality of target food items; identifying two or more source ingredients using a source ingredient database based on the identified matches of the set of features associated with the given target food item, wherein the source ingredient database is configured to store a respective set of features for each of a plurality of source ingredients; determining a recipe for combining two or more source ingredients in a particular ratio to simulate a given target food item; and generating a recipe comprising a cooking process for the recipe based on the set of existing recipes.

Embodiments of the present disclosure also provide a system for generating a recipe for simulating a given target food item. The system comprises: a source ingredient database configured to store a respective set of characteristics for each of a plurality of source ingredients; a target ingredient database configured to store a respective set of characteristics for each of a plurality of target food items; a recipe generator configured to generate a recipe for combining two or more source ingredients in a particular ratio to match a set of characteristics associated with a given target food item; a recipe database configured to store a set of existing recipes, each existing recipe in the set modified to include a specific format; and a recipe generator configured to generate a recipe for simulating the given target food item by determining a cooking process for the two or more source ingredients based on the recipe and a set of existing recipes.

Drawings

FIG. 1 shows a high-level diagram of a system that may utilize a machine learning algorithm to generate recipes using source ingredients to simulate a given target food item, in accordance with certain embodiments;

FIG. 2 illustrates a source ingredient database configured to store a respective set of characteristics for each of a plurality of source ingredients in certain embodiments;

FIG. 3 illustrates a target ingredient database configured to store a respective set of characteristics for each of a plurality of target ingredients in certain embodiments;

FIG. 4 shows an example set of existing recipes that may be stored in an existing recipe database;

FIG. 5 illustrates processing steps for making recipes include primitive (atomic) instructions (direction) according to certain embodiments;

FIG. 6 shows an example set of recipes that may be stored in a database of a chef;

FIG. 7 illustrates a block diagram of a recipe generator in some embodiments;

FIG. 8 illustrates a block diagram of a recipe generator in some embodiments;

FIG. 9 illustrates a computer-implemented method of generating a recipe for simulating a given target food item, in accordance with certain embodiments;

FIG. 10 illustrates a computer-implemented method of determining a recipe for a recipe used to simulate a target food item; and

fig. 11 illustrates a computer-implemented method of determining a recipe that includes a cooking process for a recipe.

Detailed Description

The following description of the embodiments is not intended to limit the invention to these embodiments, but rather to enable any person skilled in the art to make and use the invention.

Today, many negative consequences of the use of animals in the food industry are known, such as deforestation, pollution, human health and allergies, and the like. The animal-based food item may be a food product comprising any animal-based ingredient, such as cow's milk and all dairy products, egg-based emulsions (e.g., mayonnaise), meat-based foods (e.g., beef hamburgers, sausages, etc.). Many products are available in the market that can provide an alternative to animal-based food products, such as chicken, patties, milk, and the like. The disclosed embodiments may utilize data science, food science, and/or machine learning algorithms to find combinations of source ingredients that are likely to taste, look, and/or feel like a given target food item. The source ingredients and/or the target food items may be plant-based, animal-based, or synthetic. Certain embodiments can provide a recipe using plant-based ingredients that can simulate an animal-based food product from a sensory (e.g., flavor and/or texture) and/or visual perspective. In some examples, a certain recipe may be used to cook a combination of plant-based ingredients to taste, look, and/or feel like cow's milk.

In certain embodiments, the machine learning algorithm may include creating a filter for a given target food item and a plurality of source ingredients (e.g., a set of N source ingredients). In some examples, a given target food item may be animal-based and the source ingredients may include plant-based ingredients. In some examples, the target food item may have any suitable basis (e.g., animal-based, plant-based, and/or synthetic, etc.), and the source ingredients may include any suitable combination of animal-based ingredients, plant-based ingredients, synthetic ingredients, and/or any suitable type of ingredients. The screening may represent each source ingredient in a D-dimensional space that includes features related to physicochemical, nutritional, and/or molecular descriptors (e.g., where different source ingredients may have different feature values for physicochemical, nutritional, and/or molecular descriptor features, etc.). A feature selection process can be used to train several predictive algorithms to match a hypothetical space of N source ingredients (used as data features) to a given target food item. The predictive model may use one or more supervised machine learning methods, such as gradient enhanced tree and Lasso (least absolute value contraction and selection operator) regression, to make the prediction.

In some embodiments, the prediction algorithm may use feature compression techniques such as core principal component analysis and/or automatic coding to train the prediction model. In some other embodiments, the predictive model may be trained without any feature compression techniques. Once the predictive model is trained, the most important features for prediction can be selected as potential candidates for simulating the target food item. After selecting the potential candidates, an optimization process may be performed to find a recipe that includes a particular proportion of the source ingredients to simulate the target food item.

After having estimated the combination of source ingredients and their proportions to be used in the recipe, it is possible to find a cooking process that can be applied to the selected source ingredients. The cooking process may also include actions to be taken and sequences for performing the actions. For example, the action may include grinding, mixing, boiling, frying, and the like. In some embodiments, one or more Recurrent Neural Network (RNN) models (and/or other suitable artificial intelligence models) may be trained using an already existing recipe. Additionally or alternatively, any suitable artificial intelligence method (e.g., described herein, etc.) may be applied (e.g., trained with any suitable recipe, etc.) based on any suitable recipe (e.g., training on a model, etc.). Recipes can be obtained from the world wide web and/or other sources (e.g., the output of the models described herein) and can be modified to include a wide range of manually processed tags that can contain the necessary oversight to differentiate ingredients and processes. The modified recipe including the label may be used as a primary data source for training the RNN model(s) (and/or other suitable artificial intelligence models). The RNN model(s) (and/or other suitable artificial intelligence models) may be trained using ingredients and various sequences for using the ingredients in corresponding cooking processes. Given a set of ingredients based on a recipe provided by a predictive model, the RNN model (and/or other suitable artificial intelligence model) may be capable of classifying the given ingredients and predicting each of the ingredient process (es) (and/or other suitable model). In certain embodiments, eventually (and/or at any suitable time), a complete sequence representing a cooking process for simulating a recipe for a given target food item may be generated.

Fig. 1 shows a high-level diagram of a system 100 that can utilize machine learning algorithms to generate recipes using source ingredients to simulate a given target food item in terms of flavor, color, feel, and/or functionality. The source ingredients may include plant-based ingredients, animal-based ingredients, water-based ingredients, synthetic ingredients, or combinations thereof. The target food item may also include a plant-based ingredient, an animal-based ingredient, a water-based ingredient, a synthetic ingredient, or a combination thereof. The system 100 may include a source ingredient database 102, a target ingredient database 104, a recipe generator 106, a recipe generator 108, an existing recipe database 110, a recipe feedback panel 112, and/or a database 114 of chefs.

Some non-limiting examples of plant-based ingredients may include vegetables (e.g., onion, potato, garlic, spinach, carrot, celery, pumpkin, etc.), fruits (e.g., apple, pear, grape, etc.), herbs (e.g., oregano, caraway, basil, etc.), spices (black pepper, turmeric, paprika, cinnamon, etc.), oils (e.g., corn oil, olive oil), nuts (e.g., almond, walnut, pistachio, etc.), beans (e.g., lentils, peas, soybeans, dried beans, etc.), starches, proteins, fibers, carbohydrates, sugars, and the like. Some non-limiting examples of animal-based ingredients may include dairy products (e.g., milk, butter, cheese, yogurt, ice cream, etc.), egg-based products (e.g., mayonnaise, salad dressings, etc.), meat products (e.g., hamburger patties, sausages, hot dogs, bacon, etc.), and/or seafood (e.g., fish, crab, lobster, etc.). Synthetic ingredients may include artificially produced food products such as meat analogues, artificial sweeteners, artificial milk, and the like.

The source ingredient database 102 may be configured to store a respective set of characteristics for each of a plurality of source ingredients. The respective set of characteristics of each source ingredient may include physicochemical, biochemical, nutritional, and/or molecular characteristics. The physicochemical characteristics may include data characteristics associated with physical and/or chemical characteristics of a given source ingredient. Biochemical characteristics may be associated with chemical processes occurring in living organisms such as plants or animals. For example, Near Infrared (NIR) spectroscopy techniques may be used to identify physical and/or chemical characteristics of the ingredient. The nutritional characteristics may include nutritional elements of the ingredient. The molecular characteristics may include the molecular formula or arrangement of elements of the furnish. By way of example, the set of features may include existing amino acids, vitamins, minerals (e.g., magnesium, manganese, zinc, sodium, potassium, selenium, copper, iron, phosphorus, calcium, ash, etc.), carotenes, ethanol, alkaloids, fatty acids, carbohydrates, cholesterol, fiber, sugar, water, or proteins. An example source ingredient database 102 is discussed with reference to fig. 2.

As shown in fig. 2, the source ingredient database 102 may store a plurality of source ingredients, for example, a first source ingredient 102a, a second source ingredient 102b, a third source ingredient 102c, and a pth source ingredient 102P. Each of first, second, third, and

pth source ingredients

102a, 102b, 102c, and 102P may include a respective set of features, such as feature 1, feature 2, feature 3, and so forth. Feature 1 may be a first type of feature, feature 2 may be a second type of feature, feature 3 may be a third type of feature, and so on. As an example, the features 1102 a1, 1102b1, ·, and 1102P 1 may represent amino acids of the first source ingredient 102a, the second source ingredient 102b, and the pth source ingredient 102P, respectively. The features 2102 a2, 2102 b2,.. and 2102P 2 may represent vitamins of the first source ingredient 102a, the second source ingredient 102b, and the pth source ingredient 102P, respectively. The features 3102 a3, 3102 b3,. and 3102P 3 may represent the energy of the first, second and

pth source ingredients

102a, 102b, 102P, respectively. The source ingredient database 102 may be implemented using memory, such as Random Access Memory (RAM), electrically erasable programmable read-only memory (EEPROM), flash memory, a hard drive, an optical drive, solid state memory, or any type of memory suitable for database storage.

Referring back to fig. 1, the target ingredient database 104 may additionally or alternatively be configured to store a respective set of characteristics for each of a plurality of target ingredients. The corresponding set of characteristics stored in the target ingredient database 104 may include the same type of characteristics as the source ingredient database 102, e.g., physicochemical, biochemical, nutritional, or molecular characteristics, but the target ingredient database 104 may additionally or alternatively include different types of characteristics than other databases (e.g., types of characteristics included in the source ingredient database 102, etc.). In one example, the set of features associated with a given animal-based food item, the respective set of features of each of the plurality of food items (e.g., animal-based food items stored in target ingredient database 104, etc.), and the respective set of features of each of the plurality of source ingredients (e.g., plant-based ingredients stored in source ingredient database 102) may each be associated with a same set of feature types, e.g., wherein the same set of feature types includes at least one of a nutritional descriptor feature type, a physicochemical descriptor feature type, and a molecular descriptor feature type. An example target ingredient database 104 is discussed with reference to fig. 3.

As shown in fig. 3, the target ingredient database 104 may store a first target ingredient 104a, a second target ingredient 104b, a third target ingredient 104c, and a tth target ingredient 104T. Similar to the source ingredient database 102, each of the first, second, third, and

ttest ingredients

104a, 104b, 104c, 104T may include a respective set of characteristics: feature 1, feature 2, feature 3, etc. As an example, the features 1104 a1, 1104 b1, · and 1104T1 may represent amino acids of the first target ingredient 104a, the second target ingredient 104b and the tth target ingredient 104T, respectively. The features 2104 a2, 2104 b2, · and 2104T 2 may represent vitamins of the first target ingredient 104a, the second target ingredient 104b and the ttt target ingredient 104T, respectively. The characteristics 3104 a3, 3104 b3,. and 3104T 3 may represent the energy of the first target ingredient 104a, the second target ingredient 104b, and the tth target ingredient 104T, respectively. The target ingredient database 104 may be implemented using memory, such as RAM, EEPROM, flash memory, a hard drive, an optical drive, solid state memory, or any type of memory suitable for database storage.

Referring back to fig. 1, the recipe generator 106 may be configured to generate a recipe for a given target food item using (e.g., based on, etc.) source ingredients from the source ingredient database 102. The recipe can identify one or more source ingredients (e.g., two or more source ingredients, etc.) and/or their proportions. In some embodiments, the recipe generator 106 may create a screen of the target food item and a set of source ingredients. The set of source ingredients may include some or all of the first source ingredient 102a, the second source ingredient 102b, the third source ingredient 102c, and the pth source ingredient 102P. The screening may represent each food item in a D-dimensional space that includes physicochemical, nutritional, or molecular characteristics associated with the food item. For example, each food item may be represented in a vector space of a plurality of features associated with physicochemical, nutritional, or molecular properties.

The recipe generator 106 may be configured to determine a recipe that includes a set of source ingredients and/or their proportions that match a target in a feature space. In some examples, the recipe generator 106 may use the target ingredient database 104 to identify a set of characteristics associated with a given target food item. For example, the target may be a target food item (e.g., an animal-based brownie) and the source ingredient may be a plant-based ingredient (e.g., lettuce, carrots, peanut butter). In some examples, a feature selection process may be used to train one or more predictive models to match from a hypothetical space of a set of source ingredients (used as data features) to a given target food item. Training of the predictive model may not use sensory descriptors (e.g., flavor, color, texture, or taste) as data features for matching with the target food item, however the matching may indirectly correspond to the sensory descriptor(s) that simulate the target food item. The predictive model may be based on a gradient enhancement tree for regression. The gradient enhanced tree can be trained to suit a particular target by using available physicochemical, nutritional, or molecular characteristics. Each goal may be a new regression problem. The recipe may be determined by presenting a feature selection problem to the trained predictive model, where the feature may be the source ingredient. The feature selection process may include using a predictive model to select the most relevant features as a potential set of source ingredients to be included in the recipe. The recipe generator 106 may be further configured to perform an optimization process to find a particular proportion for the selected source ingredients to use in generating the recipe. In certain embodiments, a Lasso optimization may be performed to balance the proportions of the different ingredients in the set of source ingredients. For example, ingredients that contribute little to nothing (e.g., a proportion less than 0.001%) may be deleted. In one variation, the recipe generator 106 may be configured to determine a recipe that includes a set of source ingredients without determining proportions of the source ingredients.

In some embodiments, the prediction model(s) may use feature compression techniques, such as core principal component analysis (KPCA) or automatic encoding; however, the predictive model may be trained without a feature compression step. KPCA or automatic encoding may provide techniques for nonlinear feature extraction to reduce the dimensionality of the feature data set. Note that any dimension reduction technique may be used without departing from the scope of the disclosed techniques.

In certain embodiments, the prediction model(s) (and/or other suitable model(s), e.g., recipe generator model(s), etc.), suitable components of embodiments of system 100, and/or suitable portions of embodiments of the methods described herein may include, apply, employ, execute, use, be based on, and/or otherwise associated with artificial intelligence methods (e.g., machine learning methods, etc.) including any one or more of the following: supervised learning (e.g., using gradient-enhanced trees, using logistic regression, using back-propagation neural networks, using random forests, decision trees, etc.), unsupervised learning (e.g., using a priori (Apriori) algorithm, using K-means clustering), semi-supervised learning, deep learning algorithms (e.g., neural networks, bounded Boltzmann (Boltzmann) machines, deep belief network methods, convolutional neural network methods, recursive neural network methods, stacked autoencoder methods, etc.), reinforcement learning (e.g., using Q-learning algorithms, using time difference learning), regression algorithms (e.g., normal least squares, logarithmic regression, stepwise regression, multiple adaptive regression splines, locally estimated scatter plot smoothing, etc.), example-based methods (e.g., K-nearest neighbors, learning vector quantization, self-organizing maps, etc.), regularization methods (e.g., ridge regression, minimum absolute value convergence and selection operators, elastic nets, etc.), decision tree learning methods (e.g., classification and regression trees, iterative dichotomy 3, C4.5, chi-square automated interaction detection, decision stumps, random forests, multivariate adaptive regression splines, gradient enhancers, etc.), Bayesian (Bayesian) methods (e.g., naive Bayes, mean single dependence estimators, Bayesian belief networks, etc.), core methods (e.g., support vector machines, radial basis functions, linear discriminant analysis, etc.), clustering methods (e.g., k-means clustering, expectation maximization, etc.), correlation rule learning algorithms (e.g., priori algorithms, Eclat algorithms, etc.), artificial neural network models (e.g., perception methods, back propagation methods, Hopfield network methods, self-organizing mapping methods, etc.), learning vector quantization methods, etc.), dimensionality reduction methods (e.g., principal component analysis, partial least squares regression, Sammon (Sammon) mapping, multidimensional scaling, projection pursuit, etc.), integration methods (e.g., enhancement, bootstrap aggregation, AdaBoost, stacked generalization, gradient enhancer methods, random forest methods, etc.), and/or any suitable artificial intelligence methods.

The models described herein (e.g., recipe prediction models, recipe generator models, etc.) may be run or updated as follows: once; at a predetermined frequency; each time a process is performed; each time a trigger condition is met and/or at any other suitable time and frequency. The model may be run or updated simultaneously with one or more other models, serially, at varying frequencies, and/or at any other suitable time. May be based on the most recent data that was recently received; the historical data validates, strengthens, calibrates, or otherwise updates each model, or each model may be updated based on any other suitable data.

The recipe may be a combination of selected source ingredients and/or their respective proportions intended to simulate a given target food item. For example, formulation f may be_iIs defined as a group M_iTo each M_iFor the ingredients comprising the source and their respective proportions: f. of_i＝{(p₁,I₁)；(p₂,I₂)；…,(p_Mi,I_Mi)}. Once the combination of source ingredients is obtained, formulation f can be combined_iFed into a recipe generator 108 that can predict the order in which the source ingredients are intended to be used when cooking, as well as the actions associated with one or more of the source ingredients (e.g., cutting, boiling, frying, stirring, etc.).

The recipe generator 108 may be configured to generate a recipe for simulating a target food item, the recipe including a cooking process for a set of source ingredients in a recipe. The cooking process may include a set of actions, tools, steps, and/or respective proportions of source ingredients based on a recipe generated by recipe generator 106 (and/or by any suitable source). As an example, a recipe r may be_i＝{f_i,Q_iIs defined to include the formula f_iAnd procedure Q_i2D tuple of the sequence of (a). Can be used for the process Q_iIs defined as { (a)₁,t₁,h₁,η₁)；(a₂,t₂,h₂,η₂)；...；(a_Ui,t_Ui,h_Ui,η_Ui) Wherein each tuple ((a)_m,t_m,h_m,η_m)(m＝[1...U_i]) Can be operated by action a)_m(e.g. boiling), tools t_m(e.g. pan), step h in a recipe sequence_m(e.g., third step to be performed) and in step h_mA group of source ingredients eta referred to in_m{I₁,I₂,...,I_MiAnd (9) composition. Note that U_iCan be greater than or equal to M_iSince can be in the same direction as r_iOne ingredient is used in more than one step of the correlation.

The recipe generator 108 may include a deep recurrent neural network that may be trained using existing recipes that have been previously generated. Existing recipes can be obtained from various websites or other sources and can be processed to provide a structured data set having a certain format. In some instances, existing recipes may be collected by crawling various websites. Existing recipes may be stored in the existing recipe database 110. Each existing recipe may include original text. As an example, each existing recipe may include an ingredient list that may specify the name of each ingredient, the amount of each ingredient, and the status of each ingredient (e.g., four avocados, cut in half, and pitted). Each existing recipe may also include instructions describing a guide list for the cooking ingredients. An example set of existing recipes is discussed with reference to fig. 4. The set of existing recipes may be part of an existing recipe database 110.

Fig. 4 shows an example set of existing recipes 400 that may be stored in the existing recipe database 110. The set of existing recipes 400 may include a first recipe 402a, a second recipe 402b, ·. Each of the

recipes

402a, 402b,.. 402h may include a respective name, ingredient, and/or instruction. For example, a first recipe 402a may include a name 404, a list of ingredients 406, and an instruction 408. Ingredient list 406 may include a first ingredient 406a, a second ingredient 406b, an. Each ingredient may include an ingredient name, amount, and/or status associated with it. For example, the first ingredient 406a may include an ingredient name 406a1, a quantity 406a2, and a status 406a 3. Similarly, the instructions 408 may include a set of instructions, for example, a first instruction 408 a. The set of existing recipes 400 can be processed by the recipe generator 108 to be used as a training set to train one or more RNN models (and/or other suitable artificial intelligence models, etc.). For example, each recipe in the set of existing recipes 400 can be processed to have a particular format in preparation for training the RNN model. Processing of an example recipe is discussed with reference to fig. 5.

Fig. 5 illustrates the processing of an existing recipe 500 for a plain puree. The recipe 500 may belong to the set of existing recipes 400. For example, the recipe 500 may be a first recipe 402a, a second recipe 402b,.. or an H-th recipe 402H. The recipe 500 may have been obtained from an online website or another source. The recipe 500 can include an ingredient listing 502 and/or instructions 504. The recipe 500 can be processed by the recipe generator 108 to include a particular format prepared for training one or more RNN models (and/or other suitable artificial intelligence models, etc.). In some embodiments, the processing may include a combination of automated processing or manual processing. For example, the original text of the ingredient list 502 may be automatically processed to identify the ingredient name, amount, and/or status as shown in the modified ingredient list 506. The modified ingredient list 506 may include ingredients from the ingredient list 502 represented as one or more words (e.g., olive oil, onion, salt, etc.). The amount of each ingredient in the modified ingredient list 506 may or may not be specified, and the unit of measure may vary across ingredients (e.g., 5 tablespoons of olive oil, 1 yellow onion). Each ingredient may have zero or more states associated with it (e.g., separated, sliced, shredded, etc.).

The instructions 504 may describe a set of instructions for cooking the ingredients listed in the ingredients list 502. In some embodiments, the instructions 504 may be manually processed (and/or automatically processed) to include labels for distinguishing words corresponding to ingredients from words corresponding to a cooking process. For example, a set of instructions in the instructions 504 may be manually processed (and/or automatically processed) to include steps for cooking ingredients as shown in the cooking process 508. In some embodiments, each step may be a text passage including one or more primitive guidelines having only one verb (or any suitable number of verbs and/or other types of words), and each primitive instruction may indicate an action to be performed on one or more ingredients. The cooking process 508 may include a step 508a for a respective action 508b to be performed on a respective ingredient 508 c. For example, as shown in fig. 5, step 1 may indicate that the action "heat" is to be performed on the ingredients "olive oil" and "soy sauce". Ingredients 508c listed in cooking process 508 may include all ingredients from ingredient list 502. In some examples, the cooking process 508 may also include tools (not shown) used in the process, such as a cauldron, frying pan, measuring spoon, and the like.

Referring back to fig. 1, the recipe generator 108 may use a set of existing recipes stored in an existing recipe database 110 as a training set for training one or more RNN models (and/or other suitable artificial intelligence models, etc.). The RNN model (and/or other suitable neural network) may be a type of artificial neural network in which connections between nodes may form a directed graph along a time series. The RNN model (and/or other suitable neural network) may use its internal states to process an input sequence. One or more RNN models (and/or other suitable artificial intelligence models, etc.) may be trained to receive a recipe f generated by recipe generator 106_iAnd provide a list of actions and/or corresponding source ingredients for the cooking process to simulate a given target food item. In certain embodiments, to begin using formulation f_iTo generate a new recipe for the target food item, recipe f can be added_iThe source ingredient specified in (1) is encoded as a heat vector. To begin the process, the one heat vector may be fed to the RNN model (and/or other suitable model) along with the first retained label (e.g., start) and the first action and the one or more ingredients may be obtained. To generate the next action and its associated ingredients, the previous action may be added to the list of previously generated actions. Can now turn newThe action list and ingredient list are used as inputs to one or more RNN models (and/or other suitable artificial intelligence models, etc.). The generation of the new recipe may end when the second reservation label is returned (e.g., ended).

A plurality of such recipes can be obtained for each target food item. For example, for a given target food item T, a set of recipes R ═ { R can be generated₁,r₂,...,r_R}. Can be based on the formula f_iFraction s (f) of difference from target food item T_i) Assigned to each recipe r_i(i＝[1...R]). In some examples, the score s (f) for each recipe can be calculated_i) Is calculated as

Wherein the formula f_iAny suitable function G (r) may be used_i) From its corresponding recipe r_iExtracting. Herein, p is_kIs a formula f_iIncluded ingredient I_kRatio of (A) to (B), I_k _jIs ingredient I_kOf the variable j, and T_jIs the value of the target food item in feature j. However, the score s (f) may be determined in any suitable manner based on any suitable variables_i)。

In one example, a set of recipes can be generated (e.g., including any generated recipes, etc.), wherein each recipe in the set of recipes can include a respective cooking process for a respective recipe, and wherein a score can be determined for each recipe in the set of recipes based on a match to a given target food item (e.g., a match of a recipe to a given target food item, such as a degree of difference between a recipe and a given target food item, etc.).

Based on the fraction s (f)_i) (and/or other suitable data), one or more recipes may be picked and/or cooked by one or more people (and/or machines such as one or more robots, intelligent cooking appliances, and/or by any suitable entity and/or component, etc.). For example, a set of recipes R generated by the recipe generator 108 may be provided to the recipe feedback panel 112. The recipe feedback panel 112 may includeA person cooking one or more recipes, and/or a group of persons tasting a cooked food item. For example, a cook may cook many recipes for a target or may cook a recipe in many different ways. The cook may cook the recipe as is, or may change the proportions or ingredients as specified by the recipe (e.g., slightly; largely; in percentage amounts; in absolute amounts; based on manual action by the cook; based on recommendations and/or other outputs of one or more models; etc.). Feedback on the cooked food item may be provided by the chef and/or by the group of people. For example, the feedback may include feedback on sensory descriptors (e.g., color, flavor, taste, mouthfeel, etc.) as well as visual appearance. In some examples, the feedback provided by the recipe feedback panel 112 can include a modified recipe. The modified recipe, its preparation, one or more pictures, sensory feedback, and/or any other relevant information may be saved to the chef's database 114. In some examples, the recipe generated by the recipe generator 108 may be in a format similar to the modified ingredient list 506 and/or the cooking process 508. In other examples, the recipe may have been modified by the recipe generator 108 to include free text, similar to the ingredients 502 and the instructions 504. The free-text based recipe may be generated manually, automatically (e.g., using any suitable type of model described herein, etc.), and/or by any suitable means. An example set of recipe recipes that may be stored in the database 114 of a chef may be discussed with reference to fig. 6.

FIG. 6 shows an example set of recipes 600 that can be stored in the database 114 of a chef. The set of recipes 600 can be generated using the system 100 of fig. 1. The set of recipe recipes 600 can include a first recipe 602a, a second recipe 602b, … …, and a Wth recipe 602W. The first recipe 602a can include an ingredient list 604, a cooking process 606, a photograph 608, and human feedback 610. The ingredient list 604 may include two or more source ingredients from the plurality of source ingredients 102a-102p as discussed with reference to fig. 2. For example, the ingredient list 604 may include the first source ingredient 102 a. Each ingredient may include a corresponding name and/or amount. For example, the first source ingredient 102a may include a name 604a1 and an amount 604a 2.

Cooking process 606 may include a set of instructions for cooking ingredients 604. For example, the cooking process 606 may include first instructions 606a, … …, and an nth instruction 606N. Each guideline may include multiple steps. For example, the first guidance 606a may include a first step 606 al. In some examples, each of the guidelines 606a-606n may have the same format as each of the guidelines in the instructions 504.

The photograph 608 may include a picture of the ingredients, cooked food, or an intermediate stage of the cooking process 606. The human feedback 610 may include a flavor 610a, a color 610b, and/or any other sensory feedback. Flavor 610a may comprise the flavor of the cooked food product and color 610b may comprise the color of the cooked food product. As an example, the human feedback 610 may be provided by the recipe feedback panel 112.

In some embodiments, the set of recipes 600 can include multiple versions of the same recipe used to simulate a particular target food item. As an example, the first recipe 602a can correspond to an original recipe generated by the recipe generator 108 for the target food item, and the second recipe 602b can correspond to a modified recipe based on the recipe feedback panel 112. Similarly, multiple versions of a recipe may be stored in different variations and/or corresponding photographs and/or human feedback.

FIG. 7 illustrates a block diagram 700 of the recipe generator 106 of FIG. 1. In some embodiments, the recipe generator 106 may include a screening process 702, a predictive model 704, a feature compression model 706, and/or an optimizer 708. Note that the components of the recipe generator 106 may be implemented using software, hardware, firmware, or a combination thereof. In some embodiments, one or more components of the recipe generator 106 may include a processor configured to execute instructions stored in a non-transitory computer readable medium.

The screening process 702 can be used to create a screen for a target food item and/or a source ingredient of a plurality of source ingredients. The screen may represent each food item in a D-dimensional space that may contain characteristics related to physicochemical, nutritional, and/or molecular descriptors (e.g., where different source ingredients may have different characteristic values for physicochemical, nutritional, and/or molecular descriptors, etc.). For example, each food item may be represented in a vector space of a plurality of features associated with a physicochemical, nutritional, or molecular descriptor. As discussed with reference to fig. 2 and 3, characteristics associated with the source ingredients may be stored in the source ingredient database 102 and/or characteristics associated with the target food item may be stored in the target ingredient database 104. The screening process 702 may be configured to identify a set of characteristics associated with a given target food item using the target ingredient database 104 by creating a screen of the target food item and the plurality of source ingredients.

The predictive model 704 may be implemented using machine learning techniques for regression, such as gradient enhancement trees. The predictive model 704 may be trained to match targets from a hypothetical space of the various source ingredients (used as data features). For example, the gradient enhanced tree can be trained to suit a particular target by using available physicochemical, nutritional, or molecular characteristics. The recipe may be determined by presenting a feature selection problem to the trained predictive model, where the feature may be the source ingredient. The most relevant features selected using the predictive model 704 may be a potential set of source ingredients to be included in the recipe. Training predictive model 704 to match a set of features of each of the plurality of source ingredients to the identified set of features associated with the target food item may indirectly correspond to simulating a sensory descriptor (e.g., flavor, color, texture, or taste) of the target food item; however, the set of features used for matching may not directly include the sensory descriptor of the target food item. Additionally or alternatively, any suitable artificial intelligence method (e.g., as described herein, etc.) may be used for predictive model 704.

In some embodiments, the feature compression model 706 may be used to perform feature compression, such as core principal component analysis (KPCA) or automated encoding. In some other embodiments, the predictive model 704 may be trained without any feature compression. For example, feature compression may be performed to reduce the dimensionality of the feature data set.

The optimizer 810 may be used to perform an optimization process to determine a particular proportion of selected source ingredients to generate a recipe. In some examples, a Lasso optimization may be performed to determine proportions of different source ingredients in the set of source ingredients. Note that other techniques for finding the optimal proportions of the source ingredients in the formulation are possible within the scope of the disclosed techniques.

Fig. 8 shows a block diagram 800 of the recipe generator 108 of fig. 1. In some embodiments, the recipe generator 108 may include an existing recipe collector 802, a recipe processor 804, a training model 806, a recipe selector 808, and/or a recipe formatter 810. Note that the components of the recipe generator 108 may be implemented using software, hardware, firmware, or a combination thereof. In some embodiments, one or more components of the recipe generator 108 may include a processor configured to execute instructions stored in a non-transitory computer readable medium.

The existing recipe collector 802 may be configured to obtain existing recipes from an online website, manual input, or other suitable source. The existing recipe collector 802 can be configured to obtain existing recipes automatically (e.g., through an API and/or other data requests for retrieval, crawling, etc.), manually (e.g., through manual input, etc.), and/or by any suitable means. Existing recipes can be processed to include a particular format, and/or can be used as training data to simulate a target food item for a determined cooking process for a set of source ingredients provided in a recipe. Existing recipes may be stored in an existing recipe database 110 as discussed with reference to fig. 4. The existing recipes may include recipes similar to the recipe 500 discussed with reference to fig. 5.

The recipe processor 804 may be configured to perform automatic and/or manual processing of existing recipes stored in the existing recipe database 110. Automatic and/or manual processing may be used to distinguish between words corresponding to ingredients and words corresponding to processes by tagging the corresponding words. As discussed with reference to fig. 5, the recipe 500 may be processed to provide a modified ingredient list 506 including ingredient names, amounts, and/or states, and/or a cooking process 508 including a primitive specification for the respective ingredients.

Training model 806 may implement one or more RNN models (and/or other suitable artificial intelligence models, etc.) that may be used to determine a cooking process for a set of ingredients in a recipe. One or more RNN models (and/or other suitable artificial intelligence models, etc.) may be trained on a series of ingredients from an existing recipe and/or their corresponding processes. The training model 806 may be capable of classifying a given set of source ingredients and predicting each of the source ingredient processes, up to a complete sequence that may represent a complete food recipe for simulating a given target food item. In certain embodiments, to begin using formulation f_iTo generate a new recipe for the target food item, recipe f can be added_iThe source ingredient specified in (1) is encoded as a heat vector. To begin the process, the one heat vector may be fed to training model 806, and a first action and/or one or more ingredients may be obtained. To generate the next action and its associated ingredients, the previous action may be added to the list of previously generated actions. This process may be repeated until a complete sequence of source ingredients representing a complete food recipe is obtained.

The recipe selector 808 may select one or more recipes provided by the training model 806. In some examples, the training model 806 may provide a variety of recipes for each target food item. For example, for a given target food item, a set of recipes can be generated. In some embodiments, the recipe selector 808 may be based on the score s (f)_i) One or more recipes are selected. Fraction s (f)_i) It can indicate how similar the recipe is to the target food item in the feature space. As an example, a lower score (e.g., based on a smaller difference between the recipe and the characteristics of the target food item, etc.) may indicate that the recipe is closer to the target food item in the characteristic space. As another example, a higher score (e.g., based on a suitable calculation, etc.) may be used to indicate a preferred recipe (e.g., a recipe closer to the target food item in the feature space, etc.). Can select one or moreA variety of recipes are provided to the recipe feedback panel 112 for feedback. One or more recipes can be cooked by a chef and human feedback can be collected on any suitable combination of sensory descriptors (e.g., color, flavor, taste, mouthfeel, etc.) and/or visual appearance. In some examples, one or more recipes may be modified based on the feedback. In some examples, the feedback provided by the recipe feedback panel 112 can include a modified recipe. The modified recipe, its preparation, one or more pictures, sensory feedback, and/or any other relevant information may be saved to the database 114 of the chef as discussed with reference to fig. 6.

The recipe formatter 810 may be configured to format the recipe in a format for storage in the chef's database 114. For example, each respective recipe may be stored in a format in the database 114 of the chef as discussed with reference to fig. 6. In some examples, the recipe generated by the recipe generator 108 may have a format similar to the modified ingredient list 506 and/or the cooking process 508. In other examples, the recipe may have been modified by the recipe generator 108 to include free text, similar to the ingredients 502 and/or the instructions 504.

However, embodiments of system 100 may be configured in any suitable manner.

Fig. 9 illustrates a computer-implemented method 900 of generating a recipe for simulating a given target food item. Method 900 may be performed by any suitable embodiment of system 100 (e.g., of fig. 1).

In step 902, a set of characteristics associated with a given target food item may be identified using a target ingredient database. The target ingredient database may be configured to store a respective set of characteristics for each of a plurality of target food items. For example, the target ingredient database 104 may be used to identify a set of characteristics associated with a given target food item. The set of characteristics associated with the target food item may include one or more of characteristic 1, characteristic 2, characteristic 3, etc. of the respective target ingredient. In some examples, the target ingredient database 104 may store a respective set of characteristics for each of a plurality of animal-based food items (and/or any suitable type of food item, etc.). The corresponding set of characteristics may include amino acids, vitamins, carbohydrates, fibers, color, odor, and/or texture, etc.

In step 904, two or more source ingredients may be identified using a source ingredient database based on a match of the identified set of characteristics associated with the target food item. The source ingredient database may be configured to store a respective set of characteristics for each of a plurality of source ingredients. As an example, the source ingredient database 102 may be used to identify two or more source ingredients. In some examples, the source ingredient database 102 may store a respective set of characteristics for each of a plurality of plant-based food items (and/or any suitable type of food item, etc.). The feature type of the respective set of features may be the same as the feature type of the set of features associated with the target food item (e.g., amino acids, vitamins, carbohydrates, fibers, colors, odors and/or textures, other feature types, etc.). In certain embodiments, the recipe generator 106 may identify two or more source ingredients by training the predictive model 704 to match a respective set of features of each of the plurality of source ingredients to the identified set of features associated with the target food item.

In step 906, a recipe can be generated that combines two or more source ingredients from the plurality of source ingredients in a particular ratio based on a match of a set of characteristics associated with a given target food item. As discussed with reference to FIG. 1, the recipe generator 106 can be used to generate a recipe f to combine two or more source ingredients in a particular ratio based on matching of a set of characteristics associated with a given target food item T using a characteristic selection process_i. The recipe generator 106 can perform an optimization process using the optimizer 708 to determine a particular ratio for combining two or more source ingredients in a recipe.

In step 908, a recipe including a cooking process for the recipe is generated based on a set of existing recipes. The set of existing recipes can be similar to the set of existing recipes 400. The set of existing recipes may be obtained from online resources and stored in the existing recipe database 110. The cooking process may be determined by the recipe generator 108 using the recipe. The cooking process may include an action to be taken on two or more source ingredients and/or a sequence for performing the action. For example, the action may include cutting, boiling, mixing, and the like.

The recipe generator 108 may use the training model 806 to generate one or more recipes based on the training dataset and/or the recipe. A training data set may be prepared using a set of existing recipes collected by the existing recipe collector 802 and modified by the recipe processor 804 to support a particular format. The recipe selector 808 can be based on one or more recipes r_iA respective score s (f) associated with each of_i) A recipe for simulating a given target food item is selected from one or more recipes generated by the recipe generator 108. In some examples, recipes may be provided to the recipe feedback panel 112 for feedback. The recipe may be cooked by a person and feedback on the taste and/or other sensory descriptors may be provided by a chef and/or a group of persons who tasted the cooked food item. Based on the feedback, the recipe may be modified and/or stored in the database 114 of the chef.

Fig. 10 illustrates a computer-implemented method 1000 for determining a recipe for a simulated target food item. Any suitable embodiment of the system 100 of fig. 1 may be used to perform the computer-implemented method 1000 to determine a recipe for simulating a target food item using source ingredients. The target food item or source ingredient may be a plant-based, animal-based, or artificially generated (e.g., synthetic) food item.

In step 1002, a target ingredient database and/or a source ingredient database may be prepared. Each of the target ingredient database and the source ingredient database may be described using the same type of features, such as physicochemical, nutritional, and molecular descriptors (and/or different types of features). As discussed with reference to fig. 1-3, the target ingredient database 104 and the source ingredient database 102 may include the same type of features, e.g., feature 1, feature 2, feature 3, etc. (and/or different features).

In step 1004, a screen for a given target food item and a set of source ingredients may be created. The screening may represent each source ingredient in a D-dimensional space that is based on (e.g., contains) a respective set of characteristics for each source ingredient, the set of characteristics including physicochemical, nutritional, and/or molecular descriptors (e.g., where different source ingredients may have different characteristics for physicochemical, nutritional, and/or molecular descriptors, etc.). As discussed with reference to fig. 7, the recipe generator 106 can use the filtering process 702 to create a filter for a given target food item and a set of source ingredients.

In optional step 1006, a feature compression method for determining a more compact representation of the feature space may be performed. As discussed with reference to FIG. 7, if desired, the recipe generator 106 may perform feature compression using the feature compression model 706 to reduce the dimensionality of the feature data set. The feature compression model 706 may use core principal component analysis (KPCA), autoencoding, or another suitable method for feature compression.

In step 1008, a predictive model may be trained to match features of the target food item using a set of features of the source ingredients based on a feature selection process. As discussed with reference to FIG. 7, the recipe generator 106 may use a predictive model 704 implemented using a gradient enhanced tree regression model. The predictive model 704 may be trained to match targets from a hypothetical space of the various source ingredients (used as data features). For example, the gradient enhanced tree can be trained to suit a particular target by using available physicochemical, nutritional, or molecular characteristics.

Step 1010 may include using a predictive model to select the most relevant source ingredients for inclusion in the recipe for simulating the target food item. The recipe generator 106 may use the prediction model 704 to determine the recipe f by presenting feature selection questions to the trained prediction model 704_iWherein the characteristic may be a source ingredient. The most relevant features selected using the predictive model 794 may be a potential set of source ingredients to be included in the recipe.

Step 1012 may include usingOptimizing a process to determine a recipe f_iThe respective proportions of each of the most relevant source ingredients in (a). The recipe generator 106 may perform an optimization process using the optimizer 810 to determine the particular proportions of the most relevant ingredients to generate the recipe f_i。

Fig. 11 illustrates a computer-implemented method 1100 for determining a recipe that includes a cooking process for a recipe generated by performing any suitable embodiment of the method 1000. The computer-implemented method 1100 may be performed using any suitable embodiment of the system 100 of fig. 1.

In step 1102, a set of existing recipes can be obtained for training the deep RNN (and/or any suitable artificial intelligence model). Each existing recipe may include a list of ingredients and a set of instructions. As discussed with reference to fig. 8, the existing recipe collector 802 can obtain a set of existing recipes from an online resource. For example, the set of existing recipes may include a set of recipes 400.

In step 1104, a set of existing recipes can be processed to modify each existing recipe to include only primitive usage specifications. As discussed with respect to the example recipe 500 with reference to fig. 5, the ingredient list 502 and/or the instructions 504 may be modified using an automatic process and a manual process to include primitive instructions for the respective ingredients as shown by the cooking process 508. For example, the primitive instructions may include "heat," "fry," "stir," "cook," and the like. In some examples, the set of existing recipes may be stored in the existing recipe database 110.

In step 1106, one or more RNN models (and/or other suitable artificial intelligence models, etc.) may be trained using the recipe and/or a set of existing recipes. One or more RNN models (and/or other suitable artificial intelligence models, etc.) may provide a cooking process that includes actions and/or lists of corresponding ingredients for generating one or more recipes to simulate a target food item. As discussed with reference to FIG. 8, a recipe f generated by the recipe generator 106 may be used_iAnd a set of existing recipes modified by the recipe processor 804 to train to implement one or moreA training model 806 of the RNN model (and/or other suitable artificial intelligence models, etc.). Training model 806 may provide a cooking process similar to cooking process 508 that includes a list of actions and corresponding ingredients for generating one or more recipes to simulate a target food item.

In step 1108, one or more recipes may be generated using the trained one or more RNN models (and/or other suitable artificial intelligence models, etc.) for each target food item. Each recipe may include an indication recipe f_iA corresponding score of the difference from the target food item. As discussed with reference to fig. 8, the training model 806 may be used to generate one or more recipes. Each recipe may include a respective score s (f)_i). Fraction s (f)_i) It can indicate how similar the recipe is to the target food item in the feature space. As an example, a lower score may indicate that the recipe is closer to the target food item in the feature space.

In step 1110, a recipe can be selected from one or more recipes based on the score. The selected recipe may be cooked or modified by a chef (and/or a robot, an intelligent cooking appliance, and/or any suitable entity). Later on the sensory panel may taste the cooked food product and may give feedback on the sensory descriptor. The selected one or more recipes can be provided to the recipe feedback panel 112 for feedback. As discussed with reference to fig. 6, one or more recipes can be cooked by a chef (and/or other suitable entity) and human feedback can be collected on sensory descriptors (e.g., color, flavor, taste, mouthfeel, etc.) as well as visual appearance. In some examples, one or more recipes may be modified based on the feedback. In some examples, the feedback provided by the recipe feedback panel 112 can include a modified recipe. The modified recipe, its preparation, one or more pictures, sensory feedback, and/or any other relevant information may be saved to the chef's database 114.

One or more instances and/or portions of embodiments of the methods and/or processes described herein may be performed asynchronously (e.g., sequentially), concurrently (e.g., in parallel; concurrently on different threads for parallel computing to increase system processing power; etc.), in a temporal relationship to a triggering event (e.g., execution of a portion of an embodiment of a method described herein), and/or in any other suitable order at any suitable time and frequency, by and/or using one or more instances of embodiments of the systems 100, components, and/or entities described herein.

As discussed with reference to fig. 1-11, the disclosed embodiments may utilize various machine learning algorithms and/or proprietary databases to generate recipes for a given target food item using different types of source ingredients. Certain embodiments may provide flexibility in using any type of source ingredient (e.g., plant-based, animal-based, or synthetic) to generate a recipe for any given type of target food item (e.g., plant-based, animal-based, or synthetic).

Portions of embodiments of the methods and/or systems described herein are preferably performed by a first party, but may additionally or alternatively be performed by one or more third parties, users, and/or any suitable entities.

Additionally or alternatively, the data described herein may be associated with any suitable time indicator (e.g., seconds, minutes, hours, days, weeks, time periods, time points, timestamps, etc.) that includes one or more of the following: a time indicator indicating when data is collected, determined (e.g., output by the models described herein), transmitted, received, and/or otherwise processed; a time indicator providing context for content described by the data; time-varying indicators (e.g., data over time; data variation; data patterns; data trends; data extrapolation and/or other predictions; etc.); and/or any other suitable indicator related to time.

Additionally or alternatively, parameters, metrics, inputs, outputs, and/or other suitable data may be associated with value types including any one or more of the following: scores (e.g., recipe scores, etc.), text values (e.g., indicating ingredients, actions, etc.), numerical values (e.g., indicating proportions of ingredients; indicating aspects of primitive usage, etc.), binary values, classifications, confidence levels, identifiers, values along a frequency spectrum, and/or any other suitable type of value. Any suitable type of data described herein may be used as input (e.g., for different models described herein; for components of system 100; etc.), generated as input (e.g., of a model; of a component of system 100; etc.), and/or manipulated in any suitable manner for any suitable component.

Additionally or alternatively, suitable portions of embodiments of the methods and/or systems described herein may include, apply, employ, perform, use, be based on, and/or otherwise be associated with one or more processing operations including any one or more of the following: extracting features, performing pattern recognition on the data, fusing data from multiple sources, combinations of values (e.g., averages, etc.), compressing, converting (e.g., digital-to-analog conversion, analog-to-digital conversion), performing statistical estimation on the data (e.g., ordinary least squares regression, non-negative least squares regression, principal component analysis, ridge regression, etc.), normalizing, updating, ranking, weighting, validating, filtering (e.g., for baseline correction, data clipping, etc.), denoising, smoothing, padding (e.g., gap-padding), alignment, model fitting, binning, windowing, clipping, transformation, mathematical operations (e.g., derivatives, moving averages, summations, subtractions, multiplications, divisions, etc.), data correlation, interpolation, extrapolation, clustering, image processing techniques, other signal processing operations, other image processing operations, visualization, and/or any other suitable processing operations.

Embodiments of system 100 and/or portions of embodiments of system 100 may be performed, in whole or in part, by, hosted on, in communication with, and/or otherwise include one or more of the following: a remote computing system (e.g., one or more servers, at least one networked computing system (stateless, stateful), etc.), a local computing system, a mobile phone device, other mobile devices, a personal computing device, a tablet, a database, an Application Programming Interface (API) (e.g., for accessing data described herein, etc.), and/or any suitable component. Communication through and/or between any components of the system 100 and/or other suitable components may include wireless communication (e.g., WiFi, bluetooth, radio frequency, Zigbee, Z-wave, etc.), wired communication, and/or any other suitable type of communication.

The components of an embodiment of system 100 may be physically and/or logically integrated in any manner (e.g., by any suitable distribution of functionality across components), for example, with respect to portions of an embodiment of the method.

Embodiments of method 900, system 100, and/or any suitable system and/or method described herein and/or variations thereof may include each combination and permutation of the various system components and various method processes, including any variations (e.g., embodiments, variations, examples, specific examples, figures, etc.), where the various portions of method 900 and/or processes described herein may be performed asynchronously (e.g., sequentially), concurrently (e.g., in parallel), or in any other suitable order by and/or using one or more instances, elements, components, and/or other aspects of system 100 and/or other entities described herein.

Any of the variations (e.g., embodiments, variations, examples, specific examples, figures, etc.) described herein and/or any portion of the variations described herein may be additionally or alternatively combined, aggregated, excluded, used, performed in series, performed in parallel, and/or otherwise applied.

The system 100, the method 900, and/or any suitable system and/or method described herein and/or variations thereof may be at least partially embodied and/or implemented as a machine configured to receive computer-readable instructions stored by a computer-readable medium. The instructions may be executed by computer-executable components that may be integrated with the system. The computer readable medium may be stored on any suitable computer readable medium such as RAM, ROM, flash memory, EEPROM, optical devices (CD or DVD), hard drives, floppy drives or any suitable device. The computer-executable components may be general-purpose processors or special-purpose processors, but any suitable special-purpose hardware or hardware/firmware combination may alternatively or additionally execute instructions.

As those skilled in the art will recognize from the foregoing detailed description and from the accompanying drawings and claims, modifications and variations can be made to system 100, method 900 and/or variations without departing from the scope as defined in the following claims.

Claims

1. A computer-implemented method for generating a recipe using plant-based ingredients to simulate a given animal-based food item, the method comprising:

identifying a set of features associated with the given animal-based food item using a target ingredient database, wherein the target ingredient database is configured to store a respective set of features for each of a plurality of animal-based food items;

training a predictive model to select potential candidates from a plurality of plant-based ingredients stored in a source ingredient database to match the identified set of features associated with the given animal-based food item, wherein the source ingredient database is configured to store a respective set of features for each of the plurality of plant-based ingredients;

based on the identified matches of the set of features, determining a recipe using a trained predictive model, the recipe for combining the potential candidates in a particular proportion;

training a Recurrent Neural Network (RNN) using a set of existing recipes to determine a cooking process for the recipe; and

generating a recipe using the RNN, the recipe including the cooking process to simulate the given animal-based food item.

2. The method of claim 1, wherein the set of features associated with the given animal-based food item, the respective set of features for each of the plurality of animal-based food items, and the respective set of features for each of the plurality of plant-based ingredients are each associated with a same set of feature types, and wherein the same set of feature types includes at least one of a nutritional descriptor feature type, a physicochemical descriptor feature type, and a molecular descriptor feature type.

3. The method of claim 1, wherein the cooking process includes a list of actions and corresponding potential candidates for use in the cooking process.

4. The method of claim 1, wherein the predictive model is based on gradient enhancement tree and minimum absolute value shrinkage and selection operator (Lasso) regression.

5. The method of claim 1, further comprising performing a feature compression method to determine a compact representation of the respective set of features for each of the plurality of plant-based ingredients, wherein training the predictive model comprises training the predictive model to select the potential candidates based on the compact representations of the respective set of features for each of the plurality of plant-based ingredients.

6. A computer-implemented method for generating a recipe for simulating a given target food item, the method comprising:

identifying a set of features associated with the given target food item using a target ingredient database, wherein the target ingredient database is configured to store a respective set of features for each of a plurality of target food items;

identifying two or more source ingredients using a source ingredient database based on the identified matches of the set of features associated with the given target food item, wherein the source ingredient database is configured to store a respective set of features for each of a plurality of source ingredients;

determining a recipe for combining the two or more source ingredients in a particular ratio to simulate the given target food item; and

generating a recipe comprising a cooking process for the recipe based on a set of existing recipes.

7. The method of claim 6, wherein identifying the two or more source ingredients comprises:

training a predictive model to match the respective set of features for each of the plurality of source ingredients with the identified set of features associated with the target food item; and

selecting the two or more source ingredients based on the matching.

8. The method of claim 7, wherein the predictive model is based on a gradient enhancement tree.

9. The method of claim 6, wherein determining the recipe comprises performing an optimization process using a minimum absolute value shrinkage and selection operator (Lasso) regression to determine the particular proportions for combining the two or more source ingredients in the recipe.

10. The method of claim 6, wherein each of the two or more source ingredients is represented in a D-dimensional space based on its respective set of features, the respective set of features including a physicochemical descriptor, a nutritional descriptor, and a molecular descriptor.

11. The method of claim 6, wherein the identified match of the set of features corresponds indirectly to simulating at least one of a flavor, color, texture, and taste of the target food item.

12. The method of claim 6, wherein generating the recipe comprises:

obtaining the set of existing recipes, each existing recipe comprising a respective list of ingredients, a respective amount, and a respective guide for cooking the respective list of ingredients;

modifying each of the existing recipes to include a respective primitive description of usage for cooking the respective ingredient list; and

training a recurrent neural network using the modified existing recipe and the recipe to determine the cooking process using the two or more source ingredients.

13. The method of claim 12, wherein modifying the set of existing recipes comprises manually marking each of the respective guide and the respective ingredient listing to include the respective primitive directions for cooking the respective ingredient listing.

14. The method of claim 6, wherein a set of recipes is generated that includes the recipes, wherein each recipe in the set of recipes includes a respective cooking process for a respective recipe, and wherein the method further comprises determining a score for each recipe in the set of recipes based on a match to the given target food item.

15. The method of claim 14, further comprising selecting the generated recipe based on a score of the generated recipe, wherein the generated recipe is cooked by a person and feedback on sensory descriptors of the cooked recipe is collected.

16. The method according to claim 15, wherein the cooked recipe is modified based on the feedback and the modified recipe is stored in a database of the chef.

17. A system for generating a recipe for simulating a given target food item, the system comprising:

a source ingredient database configured to store a respective set of characteristics for each of a plurality of source ingredients;

a target ingredient database configured to store a respective set of characteristics for each of a plurality of target food items;

a recipe generator configured to generate a recipe for combining two or more source ingredients in a particular ratio to match a set of characteristics associated with the given target food item;

a recipe database configured to store a set of existing recipes, each existing recipe in the set modified to include a specific format; and

a recipe generator configured to generate the recipe for simulating the given target food item by determining a cooking process for the two or more source ingredients based on the recipe and the set of existing recipes.

18. The system of claim 17, the recipe generator comprising:

a screening process configured to identify the set of characteristics associated with the given target food item using the target ingredient database by creating a screen of the target food item and the plurality of source ingredients;

a predictive model configured to determine the recipe for combining the two or more source ingredients in a particular ratio to match the set of characteristics associated with the given target food item based on a characteristic selection process; and

an optimizer configured to perform an optimization process to determine the particular proportions of the two or more source ingredients used to generate the recipe.

19. The system of claim 17, the recipe generator comprising:

an existing recipe collector configured to obtain recipes, each recipe comprising a series of ingredients, a corresponding amount, and directions for cooking the series of ingredients;

a recipe processor configured to process the recipe to include primitive instructions;

a training model configured to generate one or more recipes for the given target food item; and

a recipe selector configured to select the recipe for the given target food item using the respective scores associated with the one or more recipes.

20. The system of claim 19, wherein the selected recipe is cooked by the person and modified based on received sensory feedback of the cooked recipe.