Intelligent oven control method, device and equipment based on food material state and medium

Abstract

The embodiment of the invention discloses an intelligent oven control method and device based on food material states, equipment and a medium. A specific embodiment of the method comprises the steps of obtaining a target image corresponding to a to-be-cooked food material placed in an inner cavity of an oven; preprocessing the obtained target image to obtain a standardized image; performing state recognition processing on the standardized image to obtain state information corresponding to the to-be-cooked food material; generating a cooking control strategy based on the state information; performing security verification on the cooking control strategy, and generating a cooking control instruction in response to the cooking control strategy passing the security verification; and controlling the oven to execute cooking operation based on the cooking control instruction. According to the embodiment, through non-contact visual identification and multi-layer decision verification, the use convenience and safety are enhanced while the cooking individuation and automation degree are improved.

Description

Technical Field

[0001] The embodiments disclosed herein relate to the field of computer technology, and more specifically to a smart oven control method, apparatus, device, and medium based on the state of the ingredients. Background Technology

[0002] With the rapid development of smart kitchen equipment, automating and personalizing the cooking process has become an important trend. Currently, attempts to make ovens smart mainly rely on the following methods: First, users preset fixed temperatures, times, and heating modes; second, through a built-in limited recipe library, users can select the corresponding preset program based on the ingredient name; and third, by integrating simple sensors, such as weight sensors or contact probes, to measure a single parameter (such as total weight or core temperature) and fine-tune the time.

[0003] However, the above methods often present the following technical problems: First, fixed programs and preset recipes completely ignore the actual individual differences in the state of ingredients placed in the oven each time (such as type, freshness, and size), failing to achieve true "cooking according to ingredients" and easily leading to poor cooking results. Second, simple sensor feedback can only provide extremely limited status information (such as total weight), unable to identify the type of ingredients non-contactly and non-destructively, nor can it assess multi-dimensional quality such as freshness, resulting in one-sided and inaccurate control. Furthermore, how to seamlessly integrate and reliably implement vision-based intelligent decision-making with the precise, safe, and collaborative control of the underlying hardware also constitutes a key technical obstacle.

[0004] The information disclosed in this background section is only intended to enhance the understanding of the background of the inventive concept, and therefore may contain information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0005] The summary portion of this disclosure is intended to provide a brief overview of the concepts, which will be described in detail in the detailed description portion later. This summary portion is not intended to identify key or essential features of the claimed technical solutions, nor is it intended to limit the scope of the claimed technical solutions.

[0006] Some embodiments of this disclosure provide intelligent oven control methods, devices, electronic devices, and computer-readable media based on the state of food ingredients to solve one or more of the technical problems mentioned in the background section above.

[0007] In a first aspect, some embodiments of this disclosure provide a smart oven control method based on the state of ingredients, comprising: acquiring a target image corresponding to an ingredient to be cooked placed in the oven cavity; preprocessing the acquired target image to obtain a standardized image; performing state recognition processing on the standardized image to obtain state information corresponding to the ingredient to be cooked; generating a cooking control strategy based on the state information, wherein the cooking control strategy includes various cooking stages; performing a security verification on the cooking control strategy; and generating a cooking control command in response to the cooking control strategy passing the security verification, wherein the cooking control command includes various driving parameter information that corresponds one-to-one with each of the cooking stages; and controlling the oven to perform cooking operations based on the cooking control command.

[0008] Secondly, some embodiments of this disclosure provide an intelligent oven control device based on the state of ingredients, comprising: an acquisition unit configured to acquire a target image corresponding to an ingredient to be cooked placed in the oven cavity; a preprocessing unit configured to preprocess the acquired target image to obtain a standardized image; a recognition unit configured to perform state recognition processing on the standardized image to obtain state information corresponding to the ingredient to be cooked; a first generation unit configured to generate a cooking control strategy based on the state information, wherein the cooking control strategy includes various cooking stages; a second generation unit configured to perform a security verification on the cooking control strategy, and, in response to the cooking control strategy passing the security verification, generate a cooking control command, wherein the cooking control command includes various driving parameter information that corresponds one-to-one with the various cooking stages; and a control unit configured to control the oven to perform cooking operations based on the cooking control command.

[0009] Thirdly, some embodiments of this disclosure provide an electronic device, including: one or more processors; and a storage device having one or more programs stored thereon, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the method described in any implementation of the first aspect above.

[0010] Fourthly, some embodiments of this disclosure provide a computer-readable medium having a computer program stored thereon, wherein the program, when executed by a processor, implements the method described in any of the implementations of the first aspect above.

[0011] Fifthly, some embodiments of this disclosure provide a computer program product, including a computer program that, when executed by a processor, implements the method described in any of the implementations of the first aspect above.

[0012] The above embodiments of this disclosure have the following beneficial effects: The intelligent oven control method based on the state of ingredients, as described in these embodiments, enables automatic perception of the individual states of different ingredients, dynamic generation and safe execution of personalized cooking strategies, thus improving the stability, intelligence, and safety of the cooking effect. Specifically, traditional fixed-program or simple sensor feedback control methods may encounter problems such as unchanging cooking parameters, one-sided control basis, and inability to achieve "cooking according to ingredients" when faced with differences in ingredient states (e.g., type, freshness, size). Relying solely on user experience or limited recipes can easily lead to cumbersome operation, unreproducible results, and safety hazards due to improper parameter settings. Therefore, the method of these embodiments provides a complete closed-loop solution from perception to execution. First, a target image corresponding to the ingredient to be cooked, placed inside the oven cavity, is acquired. This provides the most original, non-contact visual data source for the entire control system, laying the objective foundation for all subsequent analysis and processing, and eliminating reliance on manual user input or a single physical sensor. Next, the acquired target image is preprocessed to obtain a standardized image. Therefore, through illumination correction, noise filtering, geometric correction, and standardization transformation, interference from the shooting environment and equipment distortion are effectively eliminated, unifying the images to a stable and comparable analytical benchmark, greatly improving the accuracy and robustness of subsequent state recognition algorithms. Then, state recognition processing is performed on the standardized images to obtain the state information corresponding to the ingredients to be cooked. Thus, through a cascaded deep learning model (category recognition and state analysis model) and rule base (scoring rule base, feature weight mapping table), automated and refined extraction of multi-dimensional state information such as ingredient type, freshness level, and weight estimate is achieved. This solves the key bottleneck of traditional methods' inability to comprehensively assess the intrinsic quality of ingredients non-contactly, providing precise and quantitative decision-making basis for personalized control. Subsequently, a cooking control strategy is generated based on the above state information. Thus, through a multi-level adjustment logic of "obtaining basic parameters - adjusting based on freshness - adjusting based on weight," abstract ingredient state information is dynamically mapped to a personalized strategy containing specific cooking stages and their parameters (such as temperature and time). This allows the cooking program to adapt to the actual condition of the ingredients, achieving an intelligent leap from a "fixed program" to a "dynamic strategy." Next, the aforementioned cooking control strategy undergoes safety verification, and in response to passing the verification, cooking control commands are generated. Thus, before strategy execution, an automated verification process based on the physical properties of the ingredients and safety regulations is introduced to review the temperature and duration of each stage for compliance. This effectively prevents safety risks such as overheating and overbaking that may result from deviations in strategy generation, and accurately converts the safe-passing strategy into timing commands that drive the oven hardware (heating elements, fan, steam valve), ensuring reliable conversion from control intent to execution signal. Finally, based on the aforementioned cooking control commands, the oven is controlled to perform the cooking operation.Therefore, the intelligent output of all the aforementioned perception, decision-making, and verification stages is ultimately implemented as the coordinated and time-sequential control of the oven's core physical actuators (heating tubes, circulating fan, steam valve). This completes a closed loop from visual information to physical heating actions, solving the key technical obstacles of coordinated control between intelligent algorithms and underlying hardware, and realizing the physical implementation of automated and personalized cooking. Furthermore, because this method constructs an end-to-end automated process of "image perception, state recognition, strategy generation, security verification, instruction conversion, and hardware execution," each stage is tightly coupled and information flows smoothly, thus systematically solving the problem of unstable cooking results caused by ignoring differences in ingredient states. Through non-contact visual recognition and multi-layered decision verification, while improving the personalization and automation of cooking, it also enhances ease of use and safety. Attached Figure Description

[0013] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and elements are not necessarily drawn to scale.

[0014] Figure 1 This is a flowchart of some embodiments of the intelligent oven control method based on the state of ingredients according to the present disclosure; Figure 2 This is a schematic diagram of the structure of some embodiments of the intelligent oven control device based on the state of ingredients according to the present disclosure; Figure 3 This is a schematic diagram of the structure of an electronic device suitable for implementing some embodiments of the present disclosure. Detailed Implementation

[0015] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0016] It should also be noted that, for ease of description, only the parts relevant to the invention are shown in the accompanying drawings. Unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.

[0017] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.

[0018] It should be noted that the terms "a" and "a plurality of" used in this disclosure are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0019] The names of messages or information exchanged between multiple devices in the embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

[0020] This disclosure will now be described in detail with reference to the accompanying drawings and embodiments.

[0021] Figure 1 A flow 100 of some embodiments of the intelligent oven control method based on food state according to this disclosure is shown. The intelligent oven control method based on food state includes the following steps: Step 101: Obtain the target image corresponding to the food to be cooked placed in the oven cavity.

[0022] In some embodiments, the executing entity (e.g., a computing device) of the intelligent oven control method based on the state of ingredients can acquire a target image corresponding to the ingredients to be cooked placed in the oven cavity.

[0023] In some optional implementations of certain embodiments, the aforementioned execution entity may obtain the target image corresponding to the food to be cooked placed in the oven cavity through the following steps: Step one: Acquire the original images corresponding to the ingredients to be cooked. These original images can be unblended or unprocessed images obtained by capturing the ingredients inside the oven cavity from different angles, at different times, or using different imaging parameters (such as focus) using one or more image acquisition devices. The image acquisition devices can be camera modules fixed at specific locations inside the oven cavity (such as the top or side wall), capable of stable operation in a cooking environment (such as within a certain temperature and humidity range), such as high-temperature resistant cameras. The ingredients to be cooked can be food raw materials that the user has placed inside the oven cavity, ready for heating and cooking. In practice, the executing entity can control the computing power camera positioned above the oven cavity to start and drive it to adjust its focus or shooting angle, capturing multiple frames of images continuously or intermittently, centered on the ingredients to be cooked, thereby obtaining the original images. For example, controlling the camera fixed above the oven cavity to continuously capture three frames, each corresponding to slightly different focus points or angles, these three frames are the three original images.

[0024] Step two involves performing a sharpness assessment on each of the original images to obtain corresponding assessment results. This sharpness assessment can be a process of calculating a sharpness metric for each original image using a sharpness assessment algorithm. This sharpness metric can be a scalar value used to measure the level of detail and edge sharpness in an image, such as the Tenengrad function value based on gradient magnitude or the Laplacian variance value. Each assessment result is a sharpness metric generated by the sharpness assessment and corresponds one-to-one with each of the original images. In practice, the execution entity can extract the corresponding grayscale image for each acquired original image, then apply a sharpness assessment algorithm (such as calculating the response variance of its Laplacian operator) to obtain a scalar value, i.e., a sharpness metric. This value is then used as the assessment result for that original image. This process is repeated for each original image to obtain the assessment results. For example, the Laplacian variance of the three original images acquired in step one is calculated, resulting in three evaluation results with values ​​of 520, 850, and 310.

[0025] Step 3: Based on the above evaluation results, generate the target image corresponding to the food to be cooked. The target image can be a single image selected from the original images according to preset rules, or generated after further optimization (such as image fusion), representing the current visual state of the food to be cooked and input into subsequent preprocessing steps. Image fusion can be a process of combining multiple original images taken at different focus points with complementary sharp areas into a single, globally sharp image using a multi-focus image fusion algorithm. For example, a multi-scale transformation-based image fusion method can be used. In practice, the executing entity can compare the magnitudes of the various evaluation results and directly select the original image with the highest evaluation result value as the target image. Alternatively, a sharpness threshold can be set, selecting only original images whose evaluation results exceed the threshold. If multiple original images are selected, a multi-focus image fusion algorithm needs to be used to perform image fusion processing on the selected original images to obtain a globally sharp fused image, which is then used as the target image. For example, based on the evaluation results obtained in step two (values ​​of 520, 850, and 310 respectively), since the evaluation result (850) of the second original image is the highest, the executing entity can directly select this original image as the target image. Alternatively, if the preset sharpness threshold is 500, then the evaluation results of the first and second original images both exceed the threshold. In this case, a multifocal image fusion algorithm can be used to process these two images to generate a fused image, which can then be determined as the target image.

[0026] Step 102: Preprocess the acquired target image to obtain a standardized image.

[0027] In some embodiments, the aforementioned execution entity may preprocess the acquired target image to obtain a standardized image.

[0028] In some optional implementations of certain embodiments, the aforementioned execution entity may preprocess the acquired target image to obtain a standardized image through the following steps: Step one involves performing illumination correction processing on the target image to obtain a brightness-balanced image. This illumination correction processing can be an image processing procedure used to eliminate or reduce shadows, overexposure, or brightness differences caused by uneven illumination. The brightness-balanced image is an image with a more uniform overall brightness distribution obtained after illumination correction processing. In practice, the execution entity can use an automatic white balance algorithm based on the gray-world assumption, a Retinex theoretical algorithm, or a homomorphic filtering method to perform illumination correction processing on the target image to compensate for possible spatial unevenness in the light source distribution within the oven cavity, thereby obtaining a brightness-balanced image. For example, a Retinex algorithm based on multi-scale retina (MSR) can be used to process the target image to obtain a brightness-balanced image.

[0029] Step two involves performing noise filtering on the aforementioned brightness-equalized image to obtain a denoised image. This noise filtering process can be used to suppress or eliminate random noise (such as Gaussian noise or salt-and-pepper noise) in the image to improve the signal-to-noise ratio. The denoised image is the one obtained after noise filtering, with significantly reduced noise interference. In practice, the executing entity can use algorithms such as Gaussian filtering, median filtering, bilateral filtering, or non-local means filtering to perform noise filtering on the brightness-equalized image, thereby obtaining a denoised image. For example, using a median filtering algorithm, a 3x3 filtering window is used to traverse each pixel of the brightness-equalized image, replacing the center pixel value with the median gray value of the pixels within the window to effectively filter out possible salt-and-pepper noise, resulting in a denoised image.

[0030] Step three involves performing geometric correction processing on the denoised image to obtain a geometrically corrected image. This geometric correction process can be used to correct image shape distortion caused by optical distortion of the image acquisition device (such as a camera) lens (e.g., barrel distortion, pincushion distortion) or the viewing angle. The geometrically corrected image is an image obtained after geometric correction where the object's shape and proportions are closer to its true physical form. In practice, the executing entity can use a distortion model correction algorithm based on pre-calibrated camera intrinsic parameters (e.g., focal length, principal point coordinates) and distortion coefficients to remap the pixel positions in the denoised image, thereby obtaining the geometrically corrected image. For example, based on the camera's factory calibration parameters (intrinsic parameters), a correction algorithm based on the Brown-Conrady distortion model can be applied to perform inverse distortion mapping on the denoised image, resulting in a geometrically corrected image where a straight object appears as a straight line after correction.

[0031] Step four involves performing a standardization transformation on the geometrically corrected image to obtain a standardized image. This standardization transformation includes size normalization and color space normalization. This process adjusts the image to a uniform and standardized size and color space representation, ensuring that the input data received by the subsequent state recognition model has a consistent format. The standardized image is the final image obtained after size and color space normalization, meeting the model's input requirements. In practice, the executing entity can first perform size normalization on the geometrically corrected image, for example, by scaling it to a preset fixed resolution (e.g., 224x224 pixels) using bilinear interpolation. Then, color space normalization is performed, for example, converting the image from the original RGB color space and normalizing it to a specific color space model, such as sRGB, and normalizing the pixel values ​​(e.g., scaling the pixel value range from [0,255] to [0,1] or zero-centering). The final standardized image is then obtained. For example, the geometrically corrected image is first uniformly scaled to a height and width of 224 pixels. Then, the image is converted to the sRGB color space, and the pixel value of each channel is divided by 255.0 to obtain a standardized image with values ​​in the range of [0,1], which is used as the input for the subsequent state recognition model.

[0032] Step 103: Perform state recognition processing on the standardized image to obtain the state information corresponding to the ingredients to be cooked.

[0033] In some embodiments, the execution entity may perform state recognition processing on the standardized image to obtain the state information corresponding to the food ingredients to be cooked.

[0034] In some optional implementations of certain embodiments, the execution entity may perform state recognition processing on the standardized image through the following steps to obtain the state information corresponding to the food ingredients to be cooked: Step one involves inputting the standardized images into a pre-trained food category recognition model to obtain the category identifiers corresponding to the ingredients to be cooked. This pre-trained food category recognition model can be an image classification model trained on a deep convolutional neural network (CNN) architecture (e.g., ResNet, MobileNet, or EfficientNet). This model learns the mapping relationship from input images to corresponding food categories through supervised learning training on a training dataset containing a large number of labeled food categories (e.g., sweet potatoes, chicken wings, steak, pizza, etc.). The category identifiers can be labels, codes, or names output by the model to uniquely represent the food category, such as "sweet potato," "chicken wings," or "steak." In practice, training the model may include the following steps: First, collect and construct a large-scale food image dataset, where each image is correctly labeled with its food category. Then, preprocess the dataset (e.g., scaling, augmentation). Next, select a deep convolutional neural network as the underlying architecture and use this dataset to train the model by minimizing the loss function (e.g., cross-entropy loss) between the predicted category and the true label using an optimization algorithm (e.g., stochastic gradient descent). After training, the model possesses the ability to identify food types based on input images. During the inference phase, the executing agent inputs the standardized images into the deployed model. The model outputs a probability distribution vector representing the confidence level of the image belonging to each preset category. The executing agent selects the category with the highest confidence level as the recognition result and uses the output recognition result to determine the category identifier corresponding to the food to be cooked. For example, using a ResNet-50 model pre-trained on the ImageNet dataset as a base, and fine-tuning it using a dataset of common fresh food images collected internally by the company (containing 23 major categories), a food category recognition model is obtained. Inputting a standardized image into this model, the probability of the "chicken wings" category in the model's output vector is 0.985. Therefore, the executing agent determines the output recognition result "chicken wings" as the category identifier.

[0035] Step two involves inputting the standardized images and category identifiers into a pre-trained state analysis model to obtain the visual features corresponding to the ingredients to be cooked. The pre-trained state analysis model can be a deep learning model based on multi-task learning or a specifically designed network structure (such as a feature extraction network with multiple branches). This model is trained to extract multiple visual features highly correlated with quality (especially freshness) from images of specific types of ingredients. Its training data typically includes images of the same ingredient at different freshness levels and corresponding quality labels (such as expert ratings). The visual features can be multiple feature vectors extracted and output by the model from the input images, used to quantify the appearance of the ingredients, including color distribution features, local binary pattern texture features, and edge contour morphology features. The color distribution features can be feature vectors obtained by calculating the histogram or statistical moments of the image in a specific color space (such as HSV, Lab), used to characterize the overall color and color uniformity of the ingredients. The local binary pattern texture features can be feature vectors calculated using the LBP operator and its variants, used to describe the micro-texture roughness, contrast, etc., of the ingredient surface. The aforementioned edge contour morphological features can be feature vectors calculated through edge detection, contour extraction, and shape descriptors (such as Hu moments and Fourier descriptors of contours), used to describe the edge sharpness, integrity, and overall shape regularity of the food. In practice, the training of the aforementioned state analysis model needs to be conducted separately or jointly for different types (or categories) of food. The training data should include images of the corresponding type of food at various freshness levels, labeled with target values ​​related to visual features (such as color statistics, texture scores, and morphological scores) or direct freshness scores. The model learns its feature extraction capability by minimizing the loss (or joint loss) between its predicted features and the true labeled features. During the inference phase, the executing agent inputs the aforementioned standardized images along with the category identifiers obtained in step one (used to indicate or select the corresponding feature extraction path or weights within the model) into the model. The model performs forward propagation, outputting the aforementioned visual feature vectors of preset dimensions from its specific network layers. For example, a multi-task state analysis model can be trained for "poultry" food (such as chicken wings and chicken legs). The training data consisted of images of chicken wings stored for different durations, accumulated from laboratory tests, and were labeled with metrics such as color saturation, skin wrinkling, and edge sharpness. The model employed a shared convolutional backbone network followed by three independent sub-network branches, used for regressing color histogram features, LBP texture feature vectors, and contour shape descriptors, respectively. During training, mean squared error loss was used to optimize the outputs of each of the three branches.When applied, the input is a standardized image of chicken wings and the category identifier "chicken wings". The model triggers the internal parameters corresponding to "poultry" and outputs a 256-dimensional color feature vector, a 128-dimensional texture feature vector and a 64-dimensional morphological feature vector, which together constitute the above-mentioned visual features.

[0036] Step 3: Based on the aforementioned category identifiers, retrieve the feature weight mapping table corresponding to the category identifiers from a pre-set scoring rule library. This pre-set scoring rule library can be a database or configuration file stored in memory, containing feature weight mapping tables for different food categories. The feature weight mapping table can be a lookup table or vector defining the weight coefficient of each feature (or group of features) among the aforementioned visual features when calculating the overall state score. In practice, the executing entity uses the aforementioned category identifier (e.g., "chicken wings") as an index or key to query the pre-set scoring rule library, retrieve and read the feature weight mapping table corresponding to the category identifier. For example, the executing entity queries the scoring rule library, finds and retrieves the corresponding feature weight mapping table based on the category identifier "chicken wings." The table content might be: color distribution feature weight 0.5, local binary pattern texture feature weight 0.3, edge contour morphology feature weight 0.2.

[0037] Step four: Based on the aforementioned feature weight mapping table, perform weighted fusion processing on each visual feature to obtain a comprehensive feature value. This weighted fusion processing can be a calculation process that linearly or non-linearly combines multiple feature vectors according to their corresponding weight coefficients. The comprehensive feature value can be a scalar value or a low-dimensional vector representing the overall visual state of the food after weighted fusion. In practice, the executing entity first normalizes each visual feature (which may have different dimensions) to the same scale. Then, based on the weight coefficients defined in the called feature weight mapping table, each feature vector is weighted. Finally, all weighted feature values ​​(or aggregate statistics of vectors, such as the mean) are summed or calculated using an aggregation function to obtain the comprehensive feature value. For example, multiplying the color distribution feature (value 0.8), local binary pattern texture feature (value 0.6), and edge contour morphology feature (value 0.9) obtained in step two by their corresponding weights (0.5, 0.3, 0.2) and then summing them yields 0.8. 0.5 + 0.6 0.3 + 0.9 0.2 = 0.76. The final value of 0.76 is the comprehensive characteristic value.

[0038] Step 5: Based on the aforementioned comprehensive feature values, generate a comprehensive status score corresponding to the ingredients to be cooked. This comprehensive status score can be a quantitative assessment of the overall freshness or quality of the ingredients, typically set within a predetermined range (e.g., 0 to 100 points). In practice, the executing entity can map the comprehensive feature values ​​to a comprehensive status score using a predefined scoring function or lookup table. This scoring function can be linear, piecewise linear, or based on a more complex model (e.g., a sigmoid function), aiming to transform the feature values ​​into a more intuitive score. For example, the scoring function can be defined as: Comprehensive Status Score = Comprehensive Feature Value 100. If the comprehensive characteristic value is 0.76, the corresponding comprehensive status score is 76 points.

[0039] Step Six: Based on the comprehensive status score, determine the freshness level of the ingredients to be cooked. This freshness level can be a discrete level based on the comprehensive status score, used to qualitatively describe the freshness of the ingredients, such as "fresh," "average," or "not fresh." In practice, the executing entity can pre-store freshness level thresholds. The freshness level is determined by comparing the comprehensive status score with these preset thresholds. For example, preset thresholds: a score greater than or equal to 80 is "fresh," a score less than 80 but greater than or equal to 60 is "average," and a score less than 60 is "not fresh." In the example above, the comprehensive status score is 76, so the freshness level is determined to be "average."

[0040] Step 7: Based on the pixel area corresponding to the ingredient to be cooked in the standardized image, generate an estimated weight value for the ingredient to be cooked. The pixel area can be the total number of pixels belonging to the ingredient region in the standardized image. The estimated weight value can be an approximation of the ingredient's mass calculated based on the pixel area and corresponding calibration coefficients. Each calibration coefficient is stored in a pre-stored mass parameter table. This pre-stored mass parameter table can be a lookup table or database established and stored through prior calibration experiments, recording various calibration coefficients (e.g., the average mass represented by a unit pixel area, in grams per pixel) corresponding to different ingredient types (or type identifiers) and used to convert pixel area into a mass estimate. In practice, the execution entity first segments the ingredient region from the standardized image using an image segmentation algorithm. This image segmentation algorithm can be a computer vision algorithm capable of distinguishing between the foreground (ingredient) and background of an image, such as a deep learning-based semantic segmentation model (e.g., U-Net, DeepLab series models), or traditional thresholding and region growing algorithms. After obtaining a binary mask of the food region through segmentation, the total number of foreground pixels in the mask is calculated, thus obtaining the aforementioned pixel area. Then, the execution entity queries the pre-stored quality parameter table based on the category identifier to obtain the calibration coefficient corresponding to that category identifier. Finally, the pixel area is multiplied by the corresponding calibration coefficient to obtain the weight estimate. For example, for the category identifier "chicken wings," the image segmentation algorithm is used to segment the standardized image, resulting in a chicken wing region pixel area of ​​5000 pixels. The pre-stored quality parameter table is consulted, finding that the calibration coefficient for "chicken wings" is 0.01 grams per pixel. Therefore, the estimated weight is 50 grams.

[0041] Step 8: Based on the aforementioned category identifier, freshness grade, and weight estimate, generate the status information corresponding to the ingredient to be cooked. This status information can be a structured data object or data set, including the category identifier, freshness grade, and weight estimate corresponding to the ingredient to be cooked. In practice, the executing entity combines and encapsulates the category identifier obtained in Step 1, the freshness grade determined in Step 6, and the weight estimate calculated in Step 7 (e.g., storing it in a data structure or forming a specific message format), and determines it as the status information corresponding to the ingredient to be cooked for subsequent steps. For example, the generated status information can be represented as: {"Category Identifier": "Chicken Wings", "Freshness Grade": "Average", "Weight Estimate": 50}.

[0042] Step 104: Generate a cooking control strategy based on the status information.

[0043] In some embodiments, the aforementioned executing entity may generate a cooking control strategy based on the aforementioned state information.

[0044] In some optional implementations of certain embodiments, the aforementioned execution entity may generate a cooking control strategy based on the aforementioned state information through the following steps: Step 1: Based on the aforementioned category identifier, obtain the recommended basic cooking parameter information set corresponding to the ingredient to be cooked. This recommended basic cooking parameter information set can be a pre-set cooking program template data associated with a specific ingredient category. It includes the suggested cooking stages for completing the cooking of that ingredient category, and the recommended basic cooking parameter information corresponding to each cooking stage. The aforementioned cooking stages can be cooking steps arranged in chronological or event order, with different heating objectives (e.g., preheating, constant temperature baking, browning, keeping warm). The aforementioned recommended basic cooking parameter information can be a set of parameters describing the basic heating operation of each cooking stage, typically including at least the target temperature and target duration, and may also include the heating mode (e.g., top and bottom heating, hot air circulation, steam assistance). The target temperature can be the oven heating temperature corresponding to any cooking stage. The target duration can be the duration of the corresponding target temperature achieved in any cooking stage. In practice, the executing entity uses the aforementioned category identifier as an index to query a pre-stored cooking knowledge base or recipe database, retrieving and obtaining the aforementioned recommended basic cooking parameter information set bound to that category identifier. For example, based on the category identifier "chicken wings," the recommended basic cooking parameters are retrieved from the database. This set includes three cooking stages: Cooking Stage 1 (preheating) has a target temperature of 200°C, a target duration of 5 minutes, and a heating mode of top and bottom heating; Cooking Stage 2 (baking) has a target temperature of 180°C, a target duration of 15 minutes, and a heating mode of hot air circulation; and Cooking Stage 3 (browning) has a target temperature of 220°C, a target duration of 3 minutes, and a heating mode of top and bottom heating.

[0045] Step two: Based on the aforementioned freshness level, the recommended basic cooking parameters are adjusted to obtain the first adjusted parameters. This first adjustment can be a correction of the recommended basic cooking parameters (especially target temperature and target time) based on the freshness level of the ingredients. The first adjusted parameters are the recommended basic cooking parameters after the first adjustment. In practice, the executing entity pre-stores first adjustment rules for different freshness levels. These first adjustment rules can be an adjustment coefficient table (e.g., for "moderate" freshness, the temperature increases by 5°C or the time is extended by 10%). Specifically, the executing entity looks up the corresponding rule based on the freshness level and applies this rule to calculate and adjust the target temperature and / or target duration in the recommended basic cooking parameters to obtain the first adjusted parameters. For example, if the freshness level is "moderate," the preset first adjustment rule is: if the freshness is "moderate," then the target temperature for all cooking stages increases by 5°C, and the total time is extended by 10% (proportionally allocated to each cooking stage). Adjusting the recommended basic cooking parameters for the chicken wings as described above, we can obtain the following: For cooking stage 1, the first adjustment parameter is a target temperature of 205°C, a target duration of 5.5 minutes, and a heating mode of top and bottom heating; for cooking stage 2, the first adjustment parameter is a target temperature of 185°C, a target duration of 16.5 minutes, and a heating mode of hot air circulation; for cooking stage 3, the first adjustment parameter is a target temperature of 225°C, a target duration of 3.3 minutes, and a heating mode of top and bottom heating.

[0046] Step 3: Based on the estimated weight, the first adjustment parameters are adjusted to obtain the second adjustment parameters. This second adjustment can be a correction of the first adjustment parameters (especially the target time) based on the estimated weight of the ingredients. The second adjustment parameters are the first adjustment parameters after the second adjustment. In practice, the executing entity pre-stores second adjustment rules for different weight ranges; generally, the larger the weight, the longer the total time required. Specifically, the executing entity substitutes the estimated weight into the preset second adjustment rules, calculates the adjustment amount for the target time, and applies it to the first adjustment parameters to obtain the second adjustment parameters. For example, the estimated weight is 50 grams. The preset second adjustment rule is: based on 50 grams, for every 10 grams increase, the target time increases by 5%. In the example above, the weight is the baseline value, so the time does not need adjustment. Therefore, the second adjustment parameters are the same as the first adjustment parameters. If the weight is 70 grams, then increase the target duration of each of the first adjustment parameters for each of the above cooking methods by 10% to obtain the second adjustment parameters.

[0047] Step four: Based on the aforementioned second adjustment parameter information, generate a cooking control strategy corresponding to the ingredients to be cooked. This cooking control strategy can be a structured cooking execution plan, specifying the sequential stages of cooking (the aforementioned cooking stages) and the specific parameters executed at each stage (the aforementioned cooking stage parameters, i.e., the aforementioned second adjustment parameter information). In practice, the executing entity determines the aforementioned second adjustment parameter information as the parameters for each cooking stage. Then, the aforementioned cooking stages and their corresponding cooking stage parameters are combined and encapsulated to form a complete and executable cooking control strategy. For example, the cooking control strategy for the final chicken wings is structured as follows: Cooking Stage 1: Cooking stage parameters are {target temperature: 205°C, target duration: 5.5 minutes, heating mode: top and bottom heating}; Cooking Stage 2: Cooking stage parameters are {target temperature: 185°C, target duration: 16.5 minutes, heating mode: hot air circulation}; Cooking Stage 3: Cooking stage parameters are {target temperature: 225°C, target duration: 3.3 minutes, heating mode: top and bottom heating}.

[0048] Step 105: Perform a security check on the cooking control strategy, and generate a cooking control command in response to the cooking control strategy passing the security check.

[0049] In some embodiments, the execution entity may perform security verification on the cooking control strategy and, in response to the cooking control strategy passing the security verification, generate cooking control instructions.

[0050] In some optional implementations of certain embodiments, the execution entity may perform security verification on the cooking control strategy through the following steps, and, in response to the cooking control strategy passing the security verification, generate cooking control instructions: Step one: Based on the category identifier of the food to be cooked, obtain the corresponding physical characteristic parameters and safety specification parameters of the food. The physical characteristic parameters can be parameters describing the inherent properties of the food related to safety during heating, such as its main components (e.g., moisture, protein, fat content), thermal conductivity, and critical temperature thresholds that may produce harmful substances (e.g., acrylamide, heterocyclic amines). The safety specification parameters can be general safety constraints set based on food safety standards, cooking practices, or equipment limitations, such as recommended maximum core temperatures for different food categories, upper temperature limits that the surface should not exceed, and maximum heating times set to prevent overcooking or scorching. In practice, the implementing entity uses the category identifier as an index to query a pre-stored safety parameter database, retrieving and obtaining the physical characteristic parameters and safety specification parameters associated with that category identifier. For example, based on the category label "chicken wings", the database can be queried to obtain its physical characteristics parameters, including the critical temperature range for protein denaturation being 60°C-75°C, and the temperature at which fat begins to oxidize in large quantities being approximately 180°C; safety specifications include a safe upper limit for the core temperature of 85°C (based on food safety), a recommended surface temperature not exceeding 220°C (based on preventing scorching), and a recommended maximum duration of continuous heating in a single session not exceeding 60 minutes.

[0051] Step two, for each cooking stage in the above cooking control strategy, perform the following steps: Sub-step one involves extracting the target temperature and target duration corresponding to the cooking stage from the aforementioned cooking control strategy. The target temperature and target duration can be the target temperature and target time for that cooking stage determined in step 104. In practice, the executing entity parses the data structure of the cooking control strategy, sequentially reads the cooking stage parameters corresponding to each cooking stage, and extracts the target temperature and target duration values ​​for each cooking stage. For example, for "Cooking Stage 2" in the cooking control strategy, extracting its corresponding cooking stage parameters yields a target temperature of 185°C and a target duration of 16.5 minutes.

[0052] Sub-step two involves generating the safe temperature range and safe duration range for the cooking stage based on the aforementioned physical characteristic parameters and safety specification parameters. The safe temperature range can be a range within which the target temperature for this cooking stage is allowed to be set, based on the upper temperature limit (e.g., the recommended upper limit for surface temperature) in the safety specification parameters and the key temperature threshold (e.g., fat oxidation temperature) in the physical characteristic parameters. The safe duration range can be a range within which the target duration for this cooking stage is allowed to be set, based on the recommended maximum heating time in the safety specification parameters. In practice, the executing entity processes the acquired parameters by applying a predetermined safe range derivation logic. Specifically, for the safe temperature range: the executing entity typically uses the recommended upper limit for surface temperature in the safety specification parameters as the upper limit of the safe temperature range. Simultaneously, it uses the key safe temperature threshold (e.g., fat oxidation temperature) in the physical characteristic parameters or a preset minimum effective cooking temperature as the lower limit of the safe temperature range. Regarding the safe duration range: The implementing entity uses the recommended maximum single continuous heating time from the aforementioned safety specifications as the total duration limit, and calculates the safe duration range for the current stage based on the proportion of the total duration of all stages in the aforementioned cooking control strategy, or a preset minimum duration requirement for each stage. For example, the physical characteristic parameters and safety specifications obtained from step one are: fat oxidation temperature approximately 180°C, recommended upper limit for surface temperature 220°C, and maximum single heating time 60 minutes. The current cooking stage is cooking stage 2 (baking), with a preset minimum duration of 5 minutes. Regarding the safe temperature range: taking the recommended upper limit of surface temperature 220°C as the upper limit; taking the fat oxidation temperature 180°C (or the preset minimum cooking temperature of 100°C) as the lower limit, the safe temperature range is determined to be [100°C, 220°C]. Regarding the safe duration range: taking the total safe duration of 60 minutes as the upper limit; taking the preset minimum duration of 5 minutes for each stage as the lower limit, the safe duration range is determined to be [5 minutes, 60 minutes].

[0053] Sub-step three involves comparing the target temperature with the safe temperature range and the target duration with the safe duration range to obtain comparison result information. This comparison result information can be a marker or data recording the comparison result. In practice, the executing entity determines whether the extracted target temperature corresponding to the cooking stage falls within the safe temperature range determined in sub-step two, and whether the target duration corresponding to the cooking stage falls within the determined safe duration range. Based on these two determinations, the corresponding comparison result information is generated. For example, suppose the target temperature for the current cooking stage is 185°C and the target duration is 16.5 minutes. Comparing this to the range determined in the example of sub-step two: 185°C falls within [100°C, 220°C], and 16.5 minutes falls within [5 minutes, 60 minutes]. Therefore, the generated comparison result information indicates that the target temperature and target duration are within the safe temperature range.

[0054] Step three: In response to the determination that each comparison result indicates the target temperature is within a safe temperature range and the target duration is within a safe duration range, a verification result indicating success is generated; otherwise, a verification result indicating failure is generated. This verification result can serve as the final judgment on the overall safety of the cooking control strategy. In practice, the executing entity iterates through and checks the comparison result information generated for each cooking stage in the cooking control strategy. Only when the comparison result information for all cooking stages indicates the target temperature is within a safe temperature range and the target duration is within a safe duration range is an overall verification result indicating success (e.g., "Verification Successful"). If the comparison result information for any stage indicates failure (e.g., temperature or duration exceeds limits), a verification result indicating failure is generated (e.g., "Verification Failed"). For example, assuming the comparison result information for all three cooking stages indicates the target temperature is within a safe temperature range and the target duration is within a safe duration range, a verification result indicating success is generated. If the target temperature for a certain cooking stage is 230°C (exceeding the upper limit of 220°C), then the comparison result information for that cooking stage indicates that the target temperature is not within the safe temperature range, while the target duration is within the safe duration range, and ultimately generates a verification result indicating that the cooking has failed.

[0055] Step four: In response to the above verification result indicating success, the parameters of each cooking stage in the above cooking control strategy are converted to obtain the driving parameter information. This conversion process can be described as mapping abstract cooking stage parameters (such as target temperature, duration, and mode) to specific instruction parameters that can directly control the actions of the oven's underlying hardware actuators. The driving parameter information can be a set of underlying parameters corresponding one-to-one with each cooking stage, used to control specific actuators (such as heating elements, circulating fans, and steam valves). In practice, the executing entity uses a pre-stored hardware control mapping table or conversion algorithm to convert the target temperature, heating mode, and target duration of each cooking stage into the power level or PID parameters of the heating element, the control instructions for the fan and steam valve, and the timer setpoint, respectively. For example, the cooking stage parameter "target temperature: 185°C, heating mode: hot air circulation, target duration: 16.5 minutes" is converted into the driving parameter information: {heating element power: 75%, circulating fan: on (high speed), steam valve: off, stage timer: 990 seconds}.

[0056] Step five involves timing-arranging the aforementioned drive parameter information to obtain cooking control instructions. This timing-arranging process can be a sequence of instructions that can be executed or parsed sequentially by the oven control system, organizing the drive parameter information of each cooking stage according to their order. The resulting cooking control instructions can be a final control program or instruction stream containing complete timing logic and hardware control details, which can be directly loaded and executed by the oven's main controller. In practice, the executing entity arranges the drive parameter information corresponding to each cooking stage, along with the stage start / end trigger conditions, into an ordered list or a message in a specific format, according to the cooking stages defined in the cooking control strategy. For example, the final generated cooking control instructions are a JSON-formatted instruction array containing three object elements, each corresponding to one of the three cooking stages, and each object containing the drive parameter information converted for that cooking stage.

[0057] Step 106: Based on the cooking control instructions, control the oven to perform the cooking operation.

[0058] In some embodiments, the aforementioned execution entity may control the oven to perform cooking operations based on the aforementioned cooking control instructions.

[0059] In some optional implementations of certain embodiments, the execution entity can control the oven to perform cooking operations based on the cooking control instructions through the following steps: First, following the order of each cooking stage described above, perform the following steps for each cooking stage: The first sub-step involves acquiring the drive parameter information corresponding to the current cooking stage. This current cooking stage can be the cooking stage that is to be executed or is currently being executed in the cooking control command. The drive parameter information can be the set of parameters generated in step 105 that corresponds to the current cooking stage and is used to directly control the oven hardware actuator. In practice, the executing entity reads the drive parameter information corresponding to the cooking stage to be executed from the data structure of the cooking control command in a preset order. For example, when starting to execute the cooking control command, the drive parameter information corresponding to "Cooking Stage 1 (Preheating)" is read first: {Heating element power: 100%, Circulating fan: Off, Steam valve: Off, Stage timer: 300 seconds}.

[0060] The second sub-step involves controlling the oven's heating elements, circulating fan, and steam valve based on the acquired drive parameter information corresponding to the current cooking stage. This control can be achieved by sending control signals to the corresponding hardware actuators in the oven according to specific values ​​or status commands in the drive parameter information, causing them to enter a preset operating state. In practice, the actuator parses the drive parameter information and converts each parameter into low-level control signals: converting the power percentage into the duty cycle or corresponding voltage of the pulse width modulation (PWM) signal applied to the heating element; converting the fan's on / off state and speed setting into the fan motor's drive signal; and converting the steam valve's on / off state and opening degree into the valve's control level or pulse width. Subsequently, these control signals are sent simultaneously or sequentially to initiate the heating program for the current cooking stage. For example, based on the drive parameter information for "Cooking Stage 1," the actuator controls the upper and lower heating elements to start heating at 100% power, keeps the circulating fan off, keeps the steam valve closed, and starts a 300-second countdown timer.

[0061] The second step involves executing the following steps at a preset cycle during the execution of each cooking stage. Specifically, after the heating program for a cooking stage is initiated, before the countdown timer for that cooking stage ends (i.e., "during execution"), the execution entity can repeatedly execute the following sub-steps at a preset time cycle (e.g., every 30 seconds): The first sub-step involves acquiring progress images of the ingredients to be cooked. These progress images can be images captured in real-time by an image acquisition device inside the oven cavity during the current cooking stage, reflecting the current visual state of the ingredients. In practice, when the preset period is reached, the executing entity controls the camera inside the oven (i.e., the image acquisition device mentioned in step 101) to capture one or a set of images of the oven cavity as the progress images. For example, at 30 seconds, 60 seconds, and 90 seconds after the start of "Cooking Stage 2 (Baking)," the camera can be controlled to capture an image of the chicken wings inside the oven cavity as a progress image.

[0062] The second sub-step involves feature extraction processing of the acquired process image to obtain real-time state features. This feature extraction process can be similar to or simplified from parts of the state recognition process described in step 103, aiming to quickly acquire visual features that characterize key changes in the appearance of the food. These real-time state features can be visual feature vectors extracted from the process image for comparison with standard reference data, such as simplified color histograms, texture contrast, and area change rates. In practice, the executing entity performs rapid preprocessing on the process image (e.g., scaling, color space conversion), and then uses efficient image processing operators to calculate a set of preset visual feature values, constituting the real-time state features. For example, for the captured process image, the mean value of the red channel in its RGB color space, the overall gray-level co-occurrence matrix (GLCM) contrast of the image, and the estimated projected area of ​​the food by subtracting the background are extracted to form a three-dimensional feature vector as the real-time state features.

[0063] The third sub-step involves comparing the aforementioned real-time state features with a preset standard feature reference dataset to obtain state deviation information. The preset standard feature reference dataset can be visual feature trajectory data representing the ideal cooking process, pre-established through experiments for different types of ingredients and different cooking stages. This dataset can contain standard feature values ​​or value ranges that the ingredients "should present" at various time points in each cooking stage under ideal conditions. The aforementioned state deviation information can be data that quantitatively represents the difference between the real-time state features and the standard feature reference data, such as the difference or distance between each feature dimension. In practice, the executing entity first queries the standard feature reference dataset for each standard feature value corresponding to the elapsed time in the current cooking stage, based on the current ingredient type and the current cooking stage. Then, it calculates the difference between each dimension feature value in the real-time state features and the corresponding standard feature values, and aggregates these differences into a vector or a scalar deviation value as the state deviation information. For example, for "chicken wings" at 60 seconds after the start of "cooking stage 2 (baking)," querying the standard feature reference dataset yields the standard feature values ​​for that moment as [red mean: 150, texture contrast: 0.5, relative area: 0.95]. If the real-time state features are [145, 0.48, 0.93], then the calculated state deviation information is the difference vector [-5, -0.02, -0.02].

[0064] The fourth sub-step involves generating dynamic adjustment parameters corresponding to the current cooking stage based on the aforementioned state deviation information. These dynamic adjustment parameters can be corrections used to fine-tune the driving parameters of the current cooking stage (such as heating element power and fan speed), aiming to reduce the state deviation and bring the actual cooking process closer to the ideal trajectory. In practice, the executing entity generates dynamic adjustment parameters by querying a pre-set adjustment rule mapping table. This pre-set adjustment rule mapping table stores the mapping relationship between different state deviation information (or deviation ranges) and the corresponding hardware parameter adjustment amounts. This mapping table is obtained through prior experimental calibration: in the experimental environment, cooking deviations are systematically introduced, and the optimal hardware parameter adjustment amounts required to bring the process back to the ideal trajectory are recorded, thus forming a rule base. In practice, the executing entity parses the aforementioned state deviation information (e.g., the difference vector [-5, -0.02, -0.02]). First, based on the type (e.g., color, texture, shape) and direction (positive / negative) of the deviation, it queries the pre-set adjustment rule mapping table to retrieve the basic adjustment amounts for one or more core controlled hardware parameters (such as heating element power and circulating fan speed). Then, based on the magnitude of the deviation, the base adjustment amount is scaled proportionally to calculate the precise dynamic adjustment parameters mentioned above. For example, for "chicken wings" in the "baking" stage, the preset adjustment rule mapping table might contain a rule like this: "If the color characteristic value (average red value) is lower than the standard value, the base adjustment action is: increase the heating element power by +5%." The current state deviation information shows a color deviation of -5. The executing entity queries this rule and scales the base adjustment amount (+5%) according to the deviation magnitude (for example, setting the scaling factor to -2% / unit deviation), thus calculating the specific power adjustment value as: (-5) × (-2%) = +10%. This "+10%" represents the dynamic adjustment parameter, indicating a 10% increase in power based on the current output.

[0065] The fifth sub-step involves adjusting the oven's heating element, circulating fan, or steam valve based on the aforementioned dynamic adjustment parameters. In practice, the actuator combines the dynamic adjustment parameters with the currently effective drive parameter information to calculate a new, temporary control signal, which is then immediately sent to the corresponding hardware actuator. For example, based on the calculated dynamic adjustment parameter "power increase +10%", and given that the current heating element power is 75%, the actuator sets the new temporary target power to 85% (75% + 10%), and subsequently adjusts the duty cycle of the control signal sent to the heating element to the corresponding 85% power level, continuing this adjustment until the next adjustment cycle, thereby achieving real-time closed-loop control.

[0066] Step 106 of this embodiment solves the technical problem of "how to sense changes in the state of ingredients in real time and make dynamic adjustments after cooking is started according to a personalized strategy, so as to cope with uncertainties and individual differences in the cooking process and ensure that the final result approaches the ideal goal". Existing technologies have the following shortcomings in the above aspects: On the one hand, traditional ovens or existing intelligent programs mostly adopt open-loop control, and once the program is started, it executes according to fixed parameters, unable to respond to non-ideal changes in the ingredients (such as uneven size or initial temperature differences); on the other hand, even with contact sensors such as temperature probes, only single-point information can be obtained, and the overall evolution of the appearance quality of the ingredients cannot be comprehensively evaluated; furthermore, there is a lack of a mechanism to quickly close the loop between real-time visual feedback and underlying hardware control, causing a disconnect between "perception" and "execution". If the above problems are solved, cooking control can be upgraded from static "program execution" to dynamic "process optimization", significantly improving the stability and robustness of cooking effects in complex real-world scenarios. To achieve this effect, this disclosure: The first sub-step of the first step obtains the driving parameter information corresponding to the current cooking stage. Therefore, to solve the problem of disconnect between instructions and execution in open-loop control, the execution blueprint (drive parameters) for the current stage is accurately read from the cooking control instructions that have passed safety verification. This ensures that the strategy, which has undergone intelligent planning and safety verification, can be loaded into the execution unit without errors, laying the data foundation for precise physical control. The second sub-step of the first step controls the oven's heating element, circulating fan, and steam valve based on the acquired drive parameter information. Thus, by converting digital drive parameters (such as power percentage and switching status) into specific hardware control signals (such as PWM duty cycle and motor drive level) in real time, the abstract cooking strategy is transformed into the coordinated action of physical actuators such as heating elements, fans, and steam valves. This solves the "last mile" problem from strategy to implementation, achieving a reliable mapping from intelligent decision-making to the physical world. The first sub-step of the second step acquires the process image of the ingredients to be cooked. Thus, during the execution of each cooking stage, process images reflecting the real-time status of the ingredients are actively acquired at fixed intervals. This is equivalent to installing "eyes" on the control system, enabling non-contact, global, and visual monitoring of the cooking process. It completely replaces the "blind operation" mode of traditional open-loop control, providing the most original and rich perceptual input for closed-loop feedback. The second sub-step of the second step involves feature extraction processing of the acquired process images to obtain real-time state features. Then, using efficient image processing operators, key visual features strongly correlated with cooking quality (such as quantified values ​​of color, texture, and shape) are quickly extracted from the process images. This step compresses the raw image pixel information into a core data vector representing the current state, solving the problem that massive amounts of image data cannot be directly used for real-time control decisions, and providing standardized and lightweight input for subsequent intelligent analysis.The third sub-step of the second step compares the aforementioned real-time state features with a preset standard feature reference dataset to obtain state deviation information. Thus, by comparing real-time features with the standard value of the "ideal cooking trajectory" at the corresponding moment, the multi-dimensional quantitative deviation (such as the difference vector) between the current state and the ideal target is accurately calculated. This is the first time that an instantaneous, quantitative diagnosis of "deviation" has been achieved during the cooking process, enabling the system to clearly know "what is currently lacking and by how much," providing a direct basis for precise intervention. The fourth sub-step of the second step generates dynamic adjustment parameters corresponding to the current cooking stage based on the aforementioned state deviation information. This introduces a decision-making mechanism based on a preset adjustment rule mapping table. This mechanism mimics the thought process of an experienced chef who "adjusts the heat based on the state," converting the quantified state deviation (such as a lighter color) into specific hardware parameter adjustments (such as increasing power by 10%) through table lookup and calculation. This solves the core control problem of how to intelligently translate "perceived deviation" into "the force of corrective action," achieving a closed loop from perception to decision-making. The fifth sub-step of the second step adjusts the oven's heating element, circulating fan, or steam valve based on the aforementioned dynamic adjustment parameters. This immediately applies the adjustment parameters from the decision output to the running hardware actuators, correcting their operating state in real time (e.g., adjusting the heating element power). This ultimately completes the full real-time control loop of "monitoring-analysis-decision-execution." This transforms the cooking process from a passive execution of a fixed program into a dynamic optimization process capable of continuous self-correction and adaptation to real-time changes in the ingredients. In summary, the core contribution of the execution and adjustment mechanism constructed in step 106 lies in transforming the traditional open-loop, rigid program execution into a dynamic, closed-loop process control system based on real-time visual feedback. The first step ensures accurate loading and rigid execution of the strategy, forming the backbone of the control; the second step, on this basis, adds a flexible, intelligent fine-tuning layer, enabling it to cope with various uncertainties in actual cooking. The two-layer architecture works in tandem, enabling the smart oven to not only "adapt to the ingredients" at the beginning but also "adjust according to the conditions" during the process. This enhances the ability to track the ideal cooking goal and the stability of the final result in complex physical cooking environments, truly achieving a leap from "automation" to "intelligence".

[0067] In addressing the personalized cooking control issues mentioned in the background technology using the aforementioned intelligent oven control method based on food condition, the following technical problem arises in the intended application scenario: In high-frequency, multi-variety cooking environments such as home kitchens and small restaurants, the following technical problem often occurs: After the oven repeatedly performs cooking tasks with different ingredients, grease, food residue, and carbonized deposits easily accumulate on the inner cavity walls, heating elements, and fan blades. This leads to decreased heat transfer efficiency, poor temperature uniformity, and odor generation, resulting in cooking effects gradually deviating from expectations, increased energy consumption, and potential food safety hazards. To meet the following requirements for this application scenario—self-cleaning capability under high-frequency use and long-term cooking stability—we have decided to adopt the following solution: Optionally, the aforementioned implementing entity may also perform the following steps: The first step involves acquiring an image of the finished product corresponding to the ingredients after cooking, following the completion of the cooking operation by controlling the oven, and also acquiring the oven's cumulative operating time. The finished product image can be an image captured by the oven's internal image acquisition device after the cooking operation is completely finished (i.e., all cooking stages are complete), used to record the final cooking result. The cumulative operating time can be the sum of the oven's running time for all cooking stages (including preheating, heating, etc.) since the last cleaning step, and this value is typically stored in the oven's non-volatile memory and continuously updated. The cleaning step can be a physical cleaning step automatically executed by the oven to remove stains from the internal cavity and heating element surfaces. This step includes at least two key stages: steam rinsing and high-temperature drying and scorching, achieved through the coordinated action of hardware actuators such as steam valves, circulating fans, and heating elements. In practice, this step is triggered when the oven controller detects that a complete cooking process has been completed. The executing entity first controls the camera inside the oven to capture a clear image of the finished product, and then reads the current cumulative operating time from the memory. For example, after a chicken wing baking session is completed, the system triggers a photo of the baked chicken wing and reads the record to show that the oven has been working for a total of 35 hours.

[0068] The second step involves feature extraction from the finished product image to obtain a multi-dimensional visual feature vector. This feature extraction can be a process of calculating quantized values ​​from the finished product image using image processing operators. The multi-dimensional visual feature vector can be an array composed of quantized feature values ​​of multiple different dimensions. In practice, the execution entity first converts the finished product image from the RGB color space to HSV or Lab space. For the main food area, its color histogram is calculated (e.g., quantizing the hue H channel into 64 intervals and statistically analyzing pixel distribution), or its color moments (including the first-order moment mean, second-order moment variance, etc.). Then, the finished product image is converted to a grayscale image, and each pixel is processed using the Local Binary Pattern (LBP) operator to generate an LBP encoded image. Subsequently, the statistical histogram of this encoded image (e.g., a 59-dimensional unified pattern histogram) is calculated as a texture feature. Next, a thresholding algorithm (e.g., Otsu's method) or an edge detection algorithm (e.g., the Canny operator) is used to segment the food outline from the image. Based on this contour, its area, perimeter, and aspect ratio of the minimum bounding rectangle are calculated. Finally, the executing entity combines the calculated color histogram, LBP histogram, and various shape parameters into a longer array, which is then used as a multi-dimensional visual feature vector. For example, processing an image of a finished roasted chicken wing results in a 126-dimensional multi-dimensional visual feature vector containing a 64-dimensional color histogram, a 59-dimensional LBP histogram, and 3 shape parameters.

[0069] Step 3: Based on the aforementioned multi-dimensional visual feature vectors, generate a cooking effect score. This score can be a quantitative evaluation of the overall cooking outcome. In practice, the executing entity inputs the multi-dimensional visual feature vectors obtained in step 2 into a pre-trained neural network model for performance scoring to calculate the cooking effect score. This pre-trained neural network model can be a multilayer perceptron specifically designed for regression tasks. Its structure includes: an input layer (the number of neurons equals the feature vector dimension), one or two hidden layers containing activation functions (such as ReLU), and an output layer that outputs a single scalar value. The training method for this pre-trained neural network model is as follows: First, collect a large-scale training dataset where each sample contains a multi-dimensional visual feature vector (input) extracted from the finished product image and a corresponding human sensory score (target output) evaluated by experts or a standardized process. Then, on this dataset, use an optimization algorithm (such as Adam) to minimize the loss function (such as mean squared error) between the model's predicted value and the true score through backpropagation, thereby training the model's final weight parameters. In practice, the implementing entity inputs the aforementioned multi-dimensional visual feature vectors to be evaluated into the pre-trained performance scoring neural network model. The model calculates through forward propagation, producing a continuous numerical value at its output layer; this value is the model's predicted cooking performance score. For example, using a neural network model with a structure of [126 input dimensions, 64 hidden dimensions, 32 hidden dimensions, 1 output dimension], after inputting the 126-dimensional multi-dimensional visual feature vectors corresponding to chicken wings, the model outputs a score of 85.

[0070] The fourth step involves generating an oven cavity maintenance instruction in response to the cooking performance score falling below a preset quality threshold and the cumulative operating time exceeding a preset maintenance cycle threshold. The preset quality threshold can be the lower limit score for determining whether the cooking performance is satisfactory (e.g., 70 points). The preset maintenance cycle threshold can be the lower limit of the cumulative operating time for recommending a cleaning step (e.g., 30 hours). Both are pre-set and stored fixed values ​​or configurable parameters. In practice, when the cooking performance score is below the preset quality threshold and the cumulative operating time exceeds the preset maintenance cycle threshold, an oven cavity maintenance instruction indicating the need for a cleaning step is generated. This two-condition mechanism avoids triggering unnecessary cleaning processes due to a single operational error or short-term light use. For example, if the cooking performance score is 65 points (below 70 points) and the cumulative operating time is 35 hours (exceeding 30 hours), an oven cavity maintenance instruction is generated. If the score is 85 points, even if the operating time reaches the target, no oven cavity maintenance instruction will be generated.

[0071] The fifth step involves acquiring real-time images of the oven cavity and generating oven cavity status information based on these images. This oven cavity status information indicates whether the cavity is currently in a safe state for automatic cleaning, typically indicating whether the oven cavity is empty or not. In practice, after generating a maintenance command, the execution unit controls the image acquisition device to capture real-time images of the oven's interior. Subsequently, the image is processed using background subtraction and connected component analysis. Specifically, the real-time image is compared with a pre-stored baseline image in an absolutely clean, empty cavity state using a difference operation in grayscale space to obtain a difference image. Next, the difference image is thresholded, and the area of ​​connected components is analyzed. If no connected component with an area greater than a preset safety threshold (e.g., 1000 pixels) exists, it is determined that the user has removed the food and utensils, generating status information indicating that the oven cavity is empty; otherwise, status information indicating that the oven cavity is not empty is generated. For example, after capturing a real-time image and comparing it with a reference image, the area of ​​the largest connected region in the differential image is only a few pixels (which may be noise), which is lower than the preset safety threshold of 1,000 pixels. Therefore, state information representing that the oven cavity is empty is generated.

[0072] Step 6: In response to the generated oven cavity status information indicating that the oven cavity is empty, perform the following cleaning steps according to the above oven cavity maintenance instructions: The first sub-step involves steam rinsing the oven cavity according to the aforementioned oven cavity maintenance instructions. This steam rinsing includes controlling the steam valve to inject high-temperature steam into the oven cavity and controlling the circulating fan to operate at a first cleaning speed. This steam rinsing process can be a step of softening and initially cleaning grease inside the cavity using high-temperature steam. In practice, the execution unit controls the oven's steam valve to open, allowing water from the water storage module to enter the high-temperature steam generator, and continuously injecting the generated steam into the oven cavity for a first preset time (e.g., 5 minutes). Simultaneously, the circulating fan is controlled to operate at a first cleaning speed (e.g., 800 rpm) to promote uniform circulation and distribution of steam within the cavity.

[0073] The second sub-step involves subjecting the oven cavity to high-temperature drying and scorching after steam rinsing. This high-temperature drying and scorching process includes controlling the heating element to operate at a clean power setting and controlling the circulating fan to operate at a second clean speed. The clean power setting can be a heating level lower than the rated cooking power (e.g., 30% of the rated power), designed to dry the cavity and carbonize any remaining organic matter. In practice, after the steam rinsing process, the actuator closes the steam valve. Subsequently, the heating element is controlled to begin heating at the clean power setting (e.g., 30% power), and the circulating fan is controlled to switch to a higher second clean speed setting (e.g., 1200 rpm) for a second preset duration (e.g., 10 minutes) to complete the drying and high-temperature scorching.

[0074] Step 7: In response to completing the above cleaning steps, a verification image of the oven cavity is acquired. In practice, after the cleaning steps (first sub-step and second sub-step) are completed, the aforementioned executing entity controls the image acquisition device to capture a new image of the oven cavity as a verification image for evaluating the cleaning effect.

[0075] Step 8: Based on the aforementioned verification image, generate a residue identification result for the oven cavity. This residue identification result determines whether there are still significant stains remaining in the cavity after cleaning. In practice, the executing entity uses image difference analysis and threshold judgment to calculate pixel-level differences in grayscale values ​​or specific color channels between the verification image and the reference image (or another standard cleaning image) used in Step 5. After calculating the pixel-level differences, the proportion of pixels whose differences exceed a sensitive threshold (e.g., 30 grayscale values) is obtained (i.e., the residue pixel proportion). If this proportion is lower than a preset cleaning acceptance threshold (e.g., 1%), a residue identification result indicating no residue is generated; otherwise, a residue identification result indicating the presence of residue is generated. For example, if the calculated difference pixel proportion between the verification image and the reference image is 0.5%, which is lower than the preset cleaning acceptance threshold of 1%, a residue identification result indicating no residue is generated.

[0076] Step 9: In response to the residue identification result indicating the presence of residue, repeat the above cleaning steps. This step constitutes a cleaning closed-loop control logic. If step 8 generates a residue identification result indicating the presence of residue, the execution entity automatically starts a new round of cleaning steps (starting from the first sub-step) to perform cleaning again. This cycle can be set to a maximum number of repetitions (e.g., 3 times). If the number of repetitions exceeds the limit and residue is still determined to be present, a maintenance failure alarm can be generated to notify the user.

[0077] Steps one through nine of this disclosure address the technical problem of "how to objectively evaluate the effect of a single cooking session after achieving personalized cooking control, and intelligently judge and execute oven cleaning and maintenance based on this, so as to form a complete automated closed loop from cooking to maintenance." Existing technologies have the following shortcomings in the above aspects: on the one hand, they lack objective and quantitative evaluation methods for cooking effects, relying on subjective user judgment, which cannot provide reliable feedback for system optimization; on the other hand, maintenance decisions rely on fixed time periods, failing to correlate actual cooking performance degradation with equipment contamination, resulting in inaccurate maintenance timing (too early or too late); furthermore, cleaning execution relies entirely on manual user operation, and there is a lack of effect verification after cleaning, making it difficult to ensure that the equipment is in optimal working condition for a long time. Solving these problems can significantly improve the autonomous management capabilities of the smart oven, ensure the long-term stability of cooking effects, and optimize user experience and equipment lifespan. To achieve this effect, this disclosure adds the following steps after the core cooking control process: First, in response to the oven completing the above cooking operation, obtain the finished product image corresponding to the ingredients to be cooked after cooking, and obtain the cumulative working time of the oven. Therefore, to address the lack of data foundation in traditional solutions, two key data points were proactively collected: the finished product image representing the final visual result of the cooking process, and the cumulative duration reflecting the historical workload of the equipment. This provides a solid and traceable factual basis for all subsequent objective evaluations and data-driven decisions, replacing the vague user recollections or simple timing methods of traditional solutions. The second step involves feature extraction from the finished product image to obtain a multi-dimensional visual feature vector. Then, by applying specific image processing operators (such as color space conversion and histogram statistics, LBP texture analysis, threshold segmentation, and shape parameter calculation), subjective sensory impressions such as "golden color" and "crispy on the outside and tender on the inside" are deconstructed into a series of quantifiable digital features (such as a 126-dimensional feature vector). This process completely solves the problems of inconsistent standards and lack of quantification in traditional evaluations, achieving a refined and objective description of the appearance quality of the cooked food. The third step, based on the aforementioned multi-dimensional visual feature vector, generates a cooking effect score. Therefore, by inputting quantified features into a pre-trained neural network model for performance evaluation, and utilizing the complex mapping relationship learned by the model from massive amounts of "feature-expert rating" data, a comprehensive score approaching professional level is output. This solves the problem of arbitrary subjective evaluation, providing a unified, reliable, and comparable "report card" for each cooking session, making horizontal comparison and vertical trend analysis of cooking effects possible, and providing a key feedback loop for algorithm optimization. In the fourth step, in response to the cooking performance score falling below a preset quality threshold and the cumulative working time exceeding a preset maintenance cycle threshold, an oven cavity maintenance command is generated. Thus, an innovative dual-condition triggering mechanism of "decreased performance" and "long-term use" is introduced.This mechanism precisely links performance characteristics (poor results) with equipment status (requiring maintenance), effectively overcoming the mechanical shortcomings of fixed-cycle maintenance that "ignores operating conditions." It prevents false alarms caused by single operational errors (such as poor-quality ingredients) and avoids unnecessary maintenance while the equipment is still being cleaned, making maintenance decisions intelligent, precise, and economical. The fifth step involves acquiring real-time images of the oven cavity and generating oven cavity status information based on these images. This allows for proactive safety confirmation before automated physical cleaning, using image analysis technology (background subtraction and connected area analysis). This step establishes a crucial safety interlock, resolving the safety hazard of automated processes potentially ignoring items left untouched by the user and initiating cleaning directly, ensuring the safety and reliability of the entire intelligent maintenance process. The sixth step, responding to an empty cavity, executes cleaning steps (including steam rinsing and high-temperature drying). This transforms the traditionally tedious and non-standard cleaning work, entirely dependent on manual user intervention, into a standardized procedure automatically controlled by the system's hardware (steam valves, fans, heating elements). This eliminates the reliance on human intervention in maintenance execution, achieving true automation. The two-stage cleaning process (steam softening and high-temperature decomposition) simulates an efficient physicochemical cleaning process, effectively removing daily accumulated oil stains. Steps seven and eight acquire verification images and generate residue identification results. Therefore, cleaning is not simply finished after execution; instead, the cleaning effect is quantitatively evaluated using specific methods such as image difference analysis (e.g., calculating the percentage of residual pixels). This introduces an "effect verification" step completely absent in traditional solutions, providing an objective acceptance standard for cleaning quality and solving the unsupervised problem of cleaning being "done but not done properly." Step nine, in response to the identification result indicating the presence of residue, repeats the above cleaning steps. Thus, a closed-loop control logic is established based on the verification results. If cleaning fails to meet the standards, the system automatically initiates a new round of cleaning until the standards are met or the maximum number of attempts is reached. This gives the system the ability to self-correct and continuously optimize task completion quality, significantly improving the reliability and thoroughness of maintenance tasks and resolving the legacy issue of potentially ineffective single cleaning sessions. In summary, steps one through nine of this embodiment are interconnected and progressively build upon each other, constructing a complete intelligent maintenance management closed loop from "objective data collection, quantitative effect evaluation, intelligent decision triggering, safety confirmation, automatic execution, effect verification to closed-loop control." This not only solves the pain points of traditional solutions, such as subjective evaluation, rigid decision-making, reliance on human intervention, and unreliable results, but also upgrades discrete maintenance activities into a continuous, self-optimizing equipment health management service. This enables the intelligent oven system to not only achieve personalized cooking but also possess the core capabilities to ensure long-term stable performance and maintain a food safety environment, enhancing the product's intelligence, practical value, and user satisfaction.

[0078] The above embodiments of this disclosure have the following beneficial effects: The intelligent oven control method based on the state of ingredients, as described in these embodiments, enables automatic perception of the individual states of different ingredients, dynamic generation and safe execution of personalized cooking strategies, thus improving the stability, intelligence, and safety of the cooking effect. Specifically, traditional fixed-program or simple sensor feedback control methods may encounter problems such as unchanging cooking parameters, one-sided control basis, and inability to achieve "cooking according to ingredients" when faced with differences in ingredient states (e.g., type, freshness, size). Relying solely on user experience or limited recipes can easily lead to cumbersome operation, unreproducible results, and safety hazards due to improper parameter settings. Therefore, the method of these embodiments provides a complete closed-loop solution from perception to execution. First, a target image corresponding to the ingredient to be cooked, placed inside the oven cavity, is acquired. This provides the most original, non-contact visual data source for the entire control system, laying the objective foundation for all subsequent analysis and processing, and eliminating reliance on manual user input or a single physical sensor. Next, the acquired target image is preprocessed to obtain a standardized image. Therefore, through illumination correction, noise filtering, geometric correction, and standardization transformation, interference from the shooting environment and equipment distortion are effectively eliminated, unifying the images to a stable and comparable analytical benchmark, greatly improving the accuracy and robustness of subsequent state recognition algorithms. Then, state recognition processing is performed on the standardized images to obtain the state information corresponding to the ingredients to be cooked. Thus, through a cascaded deep learning model (category recognition and state analysis model) and rule base (scoring rule base, feature weight mapping table), automated and refined extraction of multi-dimensional state information such as ingredient type, freshness level, and weight estimate is achieved. This solves the key bottleneck of traditional methods' inability to comprehensively assess the intrinsic quality of ingredients non-contactly, providing precise and quantitative decision-making basis for personalized control. Subsequently, a cooking control strategy is generated based on the above state information. Thus, through a multi-level adjustment logic of "obtaining basic parameters - adjusting based on freshness - adjusting based on weight," abstract ingredient state information is dynamically mapped to a personalized strategy containing specific cooking stages and their parameters (such as temperature and time). This allows the cooking program to adapt to the actual condition of the ingredients, achieving an intelligent leap from a "fixed program" to a "dynamic strategy." Next, the aforementioned cooking control strategy undergoes safety verification, and in response to passing the verification, cooking control commands are generated. Thus, before strategy execution, an automated verification process based on the physical properties of the ingredients and safety regulations is introduced to review the temperature and duration of each stage for compliance. This effectively prevents safety risks such as overheating and overbaking that may result from deviations in strategy generation, and accurately converts the safe-passing strategy into timing commands that drive the oven hardware (heating elements, fan, steam valve), ensuring reliable conversion from control intent to execution signal. Finally, based on the aforementioned cooking control commands, the oven is controlled to perform the cooking operation.Therefore, the intelligent output of all the aforementioned perception, decision-making, and verification stages is ultimately implemented as the coordinated and time-sequential control of the oven's core physical actuators (heating tubes, circulating fan, steam valve). This completes a closed loop from visual information to physical heating actions, solving the key technical obstacles of coordinated control between intelligent algorithms and underlying hardware, and realizing the physical implementation of automated and personalized cooking. Furthermore, because this method constructs an end-to-end automated process of "image perception, state recognition, strategy generation, security verification, instruction conversion, and hardware execution," each stage is tightly coupled and information flows smoothly, thus systematically solving the problem of unstable cooking results caused by ignoring differences in ingredient states. Through non-contact visual recognition and multi-layered decision verification, while improving the personalization and automation of cooking, it also enhances ease of use and safety.

[0079] Further reference Figure 2 As an implementation of the methods shown in the above figures, this disclosure provides some embodiments of an intelligent oven control device based on the state of the ingredients. These device embodiments are similar to... Figure 1 Corresponding to the method embodiments shown, the device can be specifically applied to various electronic devices.

[0080] like Figure 2 As shown, an intelligent oven control device 200 based on food status in some embodiments includes: an acquisition unit 201, a preprocessing unit 202, a recognition unit 203, a first generation unit 204, a second generation unit 205, and a control unit 206. The acquisition unit 201 is configured to acquire a target image corresponding to the food to be cooked placed in the oven cavity; the preprocessing unit 202 is configured to preprocess the acquired target image to obtain a standardized image; the recognition unit 203 is configured to perform status recognition processing on the standardized image to obtain status information corresponding to the food to be cooked; the first generation unit 204 is configured to generate a cooking control strategy based on the status information, wherein the cooking control strategy includes various cooking stages; the second generation unit 205 is configured to perform a security check on the cooking control strategy, and, in response to the cooking control strategy passing the security check, generate a cooking control command, wherein the cooking control command includes various driving parameter information that corresponds one-to-one with each of the cooking stages; and the control unit 206 is configured to control the oven to perform cooking operations based on the cooking control command.

[0081] It is understandable that the units described in the device 200 are related to the reference. Figure 1 The steps in the described method correspond to each other. Therefore, the operations, features, and beneficial effects described above for the method also apply to the device 200 and the units contained therein, and will not be repeated here.

[0082] The following is for reference. Figure 3 It shows a schematic diagram of the structure of an electronic device 300 suitable for implementing some embodiments of the present disclosure. Figure 3 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments of this disclosure.

[0083] like Figure 3 As shown, the electronic device 300 may include a processing unit 301 (e.g., a central processing unit, a graphics processor, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 302 or a program loaded from a storage device 308 into a random access memory (RAM) 303. The RAM 303 also stores various programs and data required for the operation of the electronic device 300. The processing unit 301, ROM 302, and RAM 303 are interconnected via a bus 304. An input / output (I / O) interface 305 is also connected to the bus 304.

[0084] Typically, the following devices can be connected to I / O interface 305: input devices 306 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 307 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; and communication devices 309. Communication device 309 allows electronic device 300 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 3 An electronic device 300 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively. Figure 3 Each box shown can represent a device or multiple devices as needed.

[0085] In particular, according to some embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, some embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication device 309, or installed from storage device 308, or installed from ROM 302. When the computer program is executed by processing device 301, it performs the functions defined in the methods of some embodiments of this disclosure.

[0086] It should be noted that, in some embodiments of this disclosure, the computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium may be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In some embodiments of this disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In some embodiments of this disclosure, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0087] In some implementations, clients and servers can communicate using any currently known or future-developed network protocol such as HTTP (Hypertext Transfer Protocol) and can interconnect with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet of Things), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future-developed networks.

[0088] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device. The aforementioned computer-readable medium carries one or more programs that, when executed by the electronic device, cause the electronic device to: acquire a target image corresponding to the food to be cooked placed in the oven cavity; preprocess the acquired target image to obtain a standardized image; perform state recognition processing on the standardized image to obtain state information corresponding to the food to be cooked; generate a cooking control strategy based on the state information, wherein the cooking control strategy includes various cooking stages; perform a security verification on the cooking control strategy; and, in response to the cooking control strategy passing the security verification, generate a cooking control instruction, wherein the cooking control instruction includes various driving parameter information that corresponds one-to-one with each of the cooking stages; and control the oven to perform cooking operations based on the cooking control instruction.

[0089] Computer program code for performing operations of some embodiments of this disclosure can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0090] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0091] The units described in some embodiments of this disclosure can be implemented in software or hardware. The described units can also be housed in a processor; for example, a processor may be described as including an acquisition unit, a preprocessing unit, a recognition unit, a first generation unit, a second generation unit, and a control unit. The names of these units do not necessarily limit the unit itself; for example, an acquisition unit may also be described as "a unit that acquires a target image corresponding to the food to be cooked placed in the oven cavity."

[0092] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), system-on-a-chip (SoCs), complex programmable logic devices (CPLDs), and so on.

[0093] Some embodiments of this disclosure also provide a computer program product, including a computer program that, when executed by a processor, implements any of the above-described intelligent oven control methods based on the state of the ingredients.

[0094] The above description is merely a selection of preferred embodiments of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in the embodiments of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described inventive concept. For example, technical solutions formed by substituting the above-described features with (but not limited to) technical features with similar functions disclosed in the embodiments of this disclosure.

Claims

1. A smart oven control method based on the state of ingredients, comprising: Obtain the target image corresponding to the food to be cooked placed inside the oven cavity; The acquired target image is preprocessed to obtain a standardized image; The standardized image is processed for state recognition to obtain the state information corresponding to the food to be cooked; Based on the state information, a cooking control strategy is generated, wherein the cooking control strategy includes various cooking stages; The cooking control strategy is subjected to security verification, and in response to the cooking control strategy passing the security verification, a cooking control instruction is generated, wherein the cooking control instruction includes each driving parameter information that corresponds one-to-one with each cooking stage. Based on the cooking control commands, the oven is controlled to perform cooking operations.

2. The method according to claim 1, wherein, The step of acquiring the target image corresponding to the food to be cooked placed in the oven cavity includes: Collect the original images corresponding to the ingredients to be cooked; The sharpness of each original image is evaluated to obtain the evaluation results corresponding to each original image. Based on the evaluation results, a target image corresponding to the ingredient to be cooked is generated.

3. The method according to claim 1, wherein, The preprocessing of the acquired target image to obtain a standardized image includes: The acquired target image is subjected to illumination correction processing to obtain a brightness-balanced image; The brightness-equalized image is subjected to noise filtering to obtain a noise-reduced image; The denoised image is subjected to geometric correction processing to obtain a geometrically corrected image; The geometrically corrected image is subjected to a normalization transformation to obtain a normalized image, wherein the normalization transformation includes size normalization and color space normalization.

4. The method according to claim 1, wherein, The step of performing state recognition processing on the standardized image to obtain the state information corresponding to the ingredient to be cooked includes: The standardized image is input into a pre-trained food type recognition model to obtain the type identifier corresponding to the food to be cooked; The standardized image and the category identifier are input into a pre-trained state analysis model to obtain various visual features corresponding to the ingredients to be cooked, wherein each visual feature includes color distribution features, local binary pattern texture features, and edge contour morphology features. Based on the category identifier, the feature weight mapping table corresponding to the category identifier is called from the preset scoring rule library; According to the feature weight mapping table, the visual features are weighted and fused to obtain a comprehensive feature value; Based on the comprehensive feature values, a comprehensive status score is generated for the ingredients to be cooked; Based on the comprehensive status score, the freshness level corresponding to the ingredients to be cooked is generated; Based on the pixel area corresponding to the food to be cooked in the standardized image, generate an estimated weight value for the food to be cooked. Based on the type identifier, the freshness level, and the weight estimate, the status information corresponding to the ingredient to be cooked is generated.

5. The method according to claim 4, wherein, The step of generating a cooking control strategy based on the state information includes: Based on the category identifier, obtain the set of recommended basic cooking parameters corresponding to the ingredient to be cooked, wherein the set of recommended basic cooking parameters includes each recommended basic cooking parameter and each cooking stage, and each recommended basic cooking parameter corresponds one-to-one with each cooking stage; Based on the freshness level, the recommended basic cooking parameters are adjusted to obtain the first adjustment parameters. Based on the weight estimate, the first adjustment parameter information is adjusted a second time to obtain the second adjustment parameter information. Based on the second adjustment parameter information, a cooking control strategy corresponding to the ingredient to be cooked is generated, wherein the cooking control strategy includes each cooking stage and the corresponding cooking stage parameters.

6. The method according to claim 5, wherein, The step of performing a security verification on the cooking control strategy, and generating a cooking control command in response to the cooking control strategy passing the security verification, includes: Based on the type identifier of the food to be cooked, obtain the physical property parameters and safety specification parameters of the food to be cooked; For each cooking stage in the cooking control strategy, perform the following steps: Extract the target temperature and target duration corresponding to the cooking stage from the cooking control strategy; Based on the physical property parameters and safety specification parameters, the safe temperature range and safe duration range for the cooking stage are generated; The target temperature is compared with the safe temperature range, and the target duration is compared with the safe duration range to obtain comparison result information; In response to the determination that each comparison result in the obtained comparison result information represents that the target temperature is within the safe temperature range and the target duration is within the safe duration range, a verification result that represents the characterization as passed is generated; otherwise, a verification result that represents the characterization as failed is generated. In response to the verification result indicating that the test is passed, the parameters of each cooking stage in the cooking control strategy are converted to obtain the information of each driving parameter. The timing sequence of the various driving parameter information is processed to obtain cooking control commands.

7. A smart oven control device based on the state of ingredients, comprising: The acquisition unit is configured to acquire a target image corresponding to the food to be cooked placed inside the oven cavity; The preprocessing unit is configured to preprocess the acquired target image to obtain a standardized image; The recognition unit is configured to perform state recognition processing on the standardized image to obtain state information corresponding to the food to be cooked. The first generation unit is configured to generate a cooking control strategy based on the state information, wherein the cooking control strategy includes various cooking stages; The second generation unit is configured to perform a security check on the cooking control strategy, and, in response to the cooking control strategy passing the security check, generate a cooking control instruction, wherein the cooking control instruction includes driving parameter information that corresponds one-to-one with each cooking stage. The control unit is configured to control the oven to perform cooking operations based on the cooking control commands.

8. An electronic device, comprising: One or more processors; A storage device on which one or more programs are stored; When the one or more programs are executed by the one or more processors, the one or more processors implement the method as described in any one of claims 1 to 6.

9. A computer-readable medium having a computer program stored thereon, wherein, When the program is executed by the processor, it implements the method as described in any one of claims 1 to 6.

Images