Correcting component faults in ion implantation semiconductor manufacturing tools

Abstract

Methods, systems, and non-transitory computer-readable media are provided for correcting component failures in ion implantation semiconductor manufacturing tools. One method includes the steps of: receiving, from a sensor associated with an ion implantation tool, current sensor data corresponding to a feature; performing a feature analysis to generate additional features for the current sensor data; providing the additional features as input to a trained machine learning model; obtaining one or more outputs from the trained machine learning model, wherein the one or more outputs indicate a confidence level of a predicted window; predicting, based on the confidence level of the predicted window, whether one or more components of the ion implantation tool are within a pre-failure window; and performing a corrective action associated with the ion implantation tool in response to predicting that the one or more components are within the pre-failure window.

Description

[0001] This application is a divisional application of the invention patent application filed on January 17, 2020, with application number 202080012043.5 and title "Correcting Component Faults in Ion Implantation Semiconductor Manufacturing Tools". Technical Field

[0002] This disclosure relates to correcting component failures, and more specifically, to correcting component failures in semiconductor manufacturing tools. background

[0003] One of the limiting factors for uninterrupted performance of manufacturing equipment is component failure. For example, failure of the flooding gun and source gun can disrupt the performance of ion implantation tools. Component failure leads to unplanned downtime, which is costly for the user.

[0004] Overview

[0005] The following is a simplified overview of this disclosure to provide a basic understanding of some aspects of it. This overview is not a comprehensive overview of this disclosure. The overview is not intended to identify key or essential elements of this disclosure, nor is it intended to depict any scope of any particular implementation of this disclosure or any scope of the claims. The sole purpose of the overview is to present some concepts of this disclosure in a simplified form as a prelude to the more detailed description that follows.

[0006] In one aspect of this disclosure, a method may include: receiving current sensor data corresponding to a plurality of features from a plurality of sensors associated with an ion implantation tool. The method may further include: performing feature analysis to generate a plurality of additional features for the current sensor data. The method may further include: providing the plurality of additional features as input to a trained machine learning model. The method may further include: obtaining one or more outputs from the trained machine learning model. The one or more outputs may indicate a confidence level of a predicted window. The method may further include: predicting whether one or more components of the ion implantation tool are within a pre-failure window based on the confidence level of the predicted window. The method may further include: performing a correction action associated with the ion implantation tool in response to predicting that one or more components are within a pre-failure window.

[0007] In another aspect of this disclosure, a method may include receiving historical sensor data corresponding to a plurality of features from a plurality of sensors associated with an ion implantation tool. The method may further include determining a plurality of windows, the plurality of windows including a normal operation window for a first subset of the historical sensor data and a pre-failure window for a second subset of the historical sensor data. The method may further include performing feature analysis to generate a plurality of additional features for the historical sensor data. The method may further include training a machine learning model using training data including the plurality of additional features and a target output including the plurality of windows to generate a trained machine learning model. The trained machine learning model may be able to generate one or more outputs indicating whether one or more ion implantation tool components are within the pre-failure window.

[0008] In another aspect of this disclosure, a system may include a memory and a processing means coupled to the memory. The processing means is capable of receiving current sensor data corresponding to a plurality of features from a plurality of sensors associated with an ion implantation tool. The processing means may further perform feature analysis to generate a plurality of additional features for the current sensor data. The processing means may further provide the plurality of additional features as input to a trained machine learning model. The processing means may further obtain one or more outputs from the trained machine learning model. The one or more outputs may indicate a confidence level of a predicted window. The processing means may further predict whether one or more components of the ion implantation tool are within a pre-failure window based on the confidence level of the predicted window. The processing means may further perform a correction action associated with the ion implantation tool in response to the prediction that one or more components are within the pre-failure window. Brief description of the attached figures

[0009] The contents of this disclosure are illustrated by way of example and not limitation in the accompanying figures.

[0010] Figure 1 This is a block diagram illustrating an exemplary system architecture according to certain implementations.

[0011] Figure 2 It is an example dataset generator for creating datasets for machine learning models according to certain implementations.

[0012] Figure 3 This is a block diagram illustrating a system for predicting component failures according to certain embodiments.

[0013] Figures 4 to 6This is a flowchart illustrating an example method for predicting component failure according to certain implementations.

[0014] Figures 7A to 7B This is a block diagram illustrating a system for predicting component failures according to certain embodiments.

[0015] Figures 8A to 8B This is a graph illustrating predicted component failures according to certain implementations.

[0016] Figure 9 This is a block diagram illustrating a computer system according to certain implementations. Detailed Explanation

[0017] This article describes techniques for correcting component failures in semiconductor manufacturing tools. Component failures can disrupt the performance of manufacturing equipment. For example, failures in the flood gun and source gun can disrupt the performance of ion implantation semiconductor manufacturing tools. Component failures can lead to unplanned downtime, high user costs, equipment and product damage, and more. Premature component replacement can result in high maintenance costs, component waste, and unnecessary time spent on replacements.

[0018] The apparatus, systems, and methods disclosed herein provide correction for component failures in semiconductor manufacturing tools (e.g., end-of-life prediction of plasma source guns in ion implantation semiconductor manufacturing tools). The apparatus, systems, and methods disclosed herein can (e.g., by using a deep learning model) provide critical component failure predictions for ion implantation tools using obtained sensor readings. The processing device can receive current sensor data (e.g., pressure, temperature, flow rate, power, etc.) corresponding to features from a plurality of sensors associated with the manufacturing equipment (e.g., ion implantation tool). The processing device can further perform feature analysis to generate additional features for the current sensor data. Additional features can be generated based on one or more features. For example, additional features may include one or more of the following: ratio, range, increment, maximum value, etc. The processing device can further provide the additional features as input to a trained machine learning model and subsequently obtain one or more outputs from the trained machine learning model. One or more outputs can indicate the confidence level of the prediction window. The processing device can predict whether one or more components of the ion implantation tool are within the pre-failure window based on the confidence level of the prediction window. The pre-failure window can be a time window (e.g., 24 hours, 48 ​​hours) prior to the predicted occurrence of a component failure. The processing apparatus may further respond to the prediction that one or more components are within the pre-failure window by performing corrective actions associated with the ion implantation tool. Corrective actions (e.g., correcting and / or preemptively correcting component failures) may include providing an alarm, interrupting the operation of the manufacturing equipment, and / or replacing one or more components.

[0019] The apparatus, systems, and methods disclosed herein also provide training for machine learning models to predict component failures. In some embodiments, the processing apparatus may receive historical sensor data (e.g., historical values ​​of sensors, pressure, flow rate, power, etc.) corresponding to features from sensors associated with manufacturing equipment (e.g., ion implantation tools). The processing apparatus may further determine a window corresponding to the historical sensor data. The window may include a normal operation window for a first subset of the historical sensor data and a pre-failure window for a second subset of the historical sensor data. The processing apparatus may further perform feature analysis to generate additional features (e.g., ratios, ranges, increments, maximum values, etc.) for the historical sensor data. The processing apparatus may further use training data including the additional features and a target output including the window to train a machine learning model to generate a trained machine learning model. The trained machine learning model may be able to generate one or more outputs indicating whether one or more components (e.g., ion implantation tool components) are within the pre-failure window (e.g., to perform corrective actions associated with one or more components of the ion implantation tool). The machine learning model may be trained using historical sensor data associated with a first manufacturing equipment, and the machine learning model may be used to predict component failures in other manufacturing equipment.

[0020] This disclosure also offers technical advantages. Conventionally, components are used until failure occurs, or components are replaced prematurely. By predicting a failure window (e.g., end of life, 24 hours, 48 ​​hours) for one or more components using a processing device, the processing device can generate corrective actions to replace one or more components before failure. Replacing components before failure (e.g., rather than after failure) reduces downtime, damage to manufacturing equipment and products, unplanned maintenance, and emergency transport of replacement components, etc. Replacing components within the failure window (e.g., rather than prematurely and arbitrarily replacing components) reduces waste of currently usable components, reduces costs associated with too frequent component replacement, and reduces maintenance, etc. Receiving sensor data, reducing noise, and performing feature analysis (before using a trained machine learning model to predict whether one or more components are within the failure window) provides significant reductions in energy consumption (e.g., battery consumption), bandwidth, latency, etc., compared to analyzing all sensor data (e.g., including noise and all features).

[0021] Figure 1 This is a block diagram illustrating an exemplary system architecture 100 according to certain embodiments. System architecture 100 includes a client device 120, a fault prediction server 130, and data storage 140. The fault prediction server 130 may be part of a fault prediction system 110.

[0022] Client device 120, fault prediction server 130, data storage 140, server machine 170, server machine 180, manufacturing equipment 124 (e.g., ion implantation tool, etc.), and sensor 126 may be coupled to each other via network 160 for fault prediction. In some embodiments, network 160 is a public network that provides client device 120 with access to fault prediction server 130, data storage 140, and other publicly available computing devices. In some embodiments, network 160 is a private network that provides client device 120 with access to fault prediction server 130, data storage 140, and other privately available computing devices. Network 160 may include one or more wide area networks (WANs), local area networks (LANs), wired networks (e.g., Ethernet), wireless networks (e.g., 802.11 networks or Wi-Fi networks), cellular networks (e.g., LTE networks), routers, hubs, switches, server computers, and / or combinations thereof.

[0023] Manufacturing apparatus 124 can be used for semiconductor processing. Manufacturing apparatus 124 may include an ion implantation tool. The ion implantation tool inserts atoms into a semiconductor device to control the current of electricity flowing through the semiconductor device (e.g., to manufacture transistors, etc.). Manufacturing apparatus 124 (e.g., the ion implantation tool) may include components such as a flooding gun 124A, a source gun 124B, etc. The flooding gun 124A may be an electromechanical device that provides a stable flow of low-energy electrons to a target (e.g., a flooded region, an insulator, or a region on a semiconductor). The source gun 124B (e.g., a plasma source gun) may be a plasma source for depositing plasma on a semiconductor device (e.g., ejecting plasma at a considerable flow rate to achieve high-energy deposition of plasma on the semiconductor device).

[0024] The limiting factor for the uninterrupted performance of manufacturing equipment 124 (e.g., an ion implantation tool) may be the failure of one or more components (e.g., flooding gun 124A, source gun 124B, etc.), which can cause unplanned downtime. Sensor 126 can capture sensor data associated with manufacturing equipment 124 (e.g., raw sensor data, temperature, pressure, power, flow rate, etc.). For example, an ion implanter tool may be equipped with hundreds of sensors with acquisition rates of several kilohertz. Given the number of sensors, the rate of sensor data acquisition, and the expected lifespan of the components (e.g., six months, etc.), the amount of sensor data captured (e.g., raw sensor data) can be very large. Sensor data 142 from sensor 126 can be stored in data storage 140.

[0025] As described herein, semiconductor processing may include one or more of the following: semiconductor manufacturing for wafers or display manufacturing (e.g., flat panel display manufacturing). Fault prediction may be associated with one or more components of semiconductor manufacturing equipment (e.g., predicting faults in components used for semiconductor manufacturing for wafers) or with one or more components of display manufacturing (e.g., predicting faults in components used for display manufacturing).

[0026] Client device 120 may include computing devices such as personal computers (PCs), laptops, mobile phones, smartphones, tablets, netbooks, network-connected televisions (“smart TVs”), network-connected media players (e.g., Blu-ray players), set-top boxes, over-the-top (OTT) streaming devices, operator boxes, etc. Client device 120 may be able to transmit information (e.g., selection of manufacturing equipment 124 for fault prediction) via network 160 and receive instructions associated with predicted faults (e.g., confidence level of the predicted window, instructions to perform corrective actions, etc.) via network 160. Instructions associated with predicted faults may specify that one or more components of manufacturing equipment 124 are currently associated with a predicted window 156B of time (e.g., normal operation window, pre-fault window, fault window, etc.). Instructions associated with predicted faults may indicate one or more of the following: the amount of time until the fault, the component to be replaced, how to replace the component, whether the operation of manufacturing equipment 124 has been interrupted (e.g., shut down), or whether the operation of manufacturing equipment 124 should be interrupted. Client device 120 may display an alarm via a graphical user interface (GUI) in response to receiving an indication associated with a predicted fault. Each client device 120 may include an operating system that allows users to generate, view, and edit information and view alarms.

[0027] Client device 120 may include a correction action component 122. The correction action component 122 may receive user input (e.g., via a GUI displayed via client device 120) and may generate, based on the user input, an instruction to perform fault prediction on manufacturing equipment 124. The correction action component 122 may send the instruction to fault prediction server 130. In some embodiments, the correction action component 122 transmits sensor data 142 (e.g., from sensor 126 coupled to manufacturing equipment 124) to fault prediction server 130. The correction action component 122 may receive from fault prediction server 130 an instruction associated with a predicted fault (e.g., in response to fault prediction server 130 determining a fault pre-window). The correction action component 122 may cause a correction action to be performed. The correction action may refer to correcting and / or preemptively correcting a component fault (e.g., based on a predicted fault pre-window). For example, in order to enable the execution of a correction action, the correction action component 122 may provide an alarm (e.g., via the GUI of the client device 120, via the manufacturing equipment 124, etc.), interrupt the operation of the manufacturing equipment 124 (e.g., shut down one or more parts of the manufacturing equipment 124), and / or enable the replacement of one or more components.

[0028] Fault prediction server 130 may include one or more computing devices, such as rack-mounted servers, router computers, server computers, personal computers, mainframe computers, laptop computers, tablet computers, desktop computers, etc. Fault prediction server 130 may include fault prediction component 132. In some embodiments, fault prediction component 132 may receive sensor data 142 (e.g., from sensor 126 coupled to manufacturing equipment 124). Sensor data 142 may include recorded values ​​over time and corresponding timestamps for each value (e.g., a first recorded temperature at a first time point, a second recorded temperature at a second time point, etc.). Sensor data 142 may be raw tracking data (e.g., without any feature engineering). Fault prediction component 132 may remove noise from current sensor data 150, perform feature analysis to generate additional features for the current sensor data 150, predict whether one or more components of manufacturing equipment 124 are within a fault pre-window, and perform corrective actions associated with manufacturing equipment 124 in response to the prediction that one or more components are within the fault pre-window.

[0029] To predict whether a component is within the pre-fault window, the fault prediction component 132 can provide current sensor data 150 (e.g., current additional features 154) to a model 190 (e.g., a convolutional long short-term memory (LSTM) model, a deep learning model, a random forest model, etc.) for fault prediction. The fault prediction component 132 can receive a confidence level 158 from the model 190 based on the current sensor data 150 for the predicted window 156B.

[0030] Each feature of sensor data 150 (e.g., historical feature 146, current feature 152, etc.) may include a sequence (e.g., first value, second value, etc.), a timestamp (e.g., time of the first value, time of the second value, etc.), and an indication of which sensor 126 corresponds to the sequence. Each additional feature (e.g., historical additional feature 148, current additional feature 154) may be generated by performing one or more operations on one or more of the features. One or more operations may include one or more of the following: ratio, range, increment, or maximum value of features (e.g., corresponding sensor data) from one or more of the plurality of sensors 126. For example, the first feature may be a sequence of pressure measurements received from the pressure sensor of sensor 126, the second feature may be a sequence of temperature measurements received from the temperature sensor of sensor 126, and the first additional feature may be a sequence of pressure measurements divided by the ratio of each corresponding temperature measurement (e.g., the first additional feature may be a sequence including a first pressure value at a first time point divided by a first temperature value at a first time point, a second pressure value at a second time point divided by a second temperature value at a second time point, etc.).

[0031] Data storage 140 may be a memory (e.g., random access memory), a drive (e.g., a hard disk drive, a flash memory drive), a database system, or another type of component or device capable of storing data. Data storage 140 may include multiple storage components (e.g., multiple drives or multiple databases) that can span multiple computing devices (e.g., multiple server computers). Data storage 140 may store one or more of the following: sensor data 142 (e.g., historical sensor data 144, historical features 146, historical additional features 148, current sensor data 150, current features 152, current additional features 154, etc.), windows 156 (e.g., historical window 156A, predicted window 156B), confidence levels 158, etc.

[0032] In some implementations, the fault prediction system 110 further includes server machine 170 and server machine 180. Server machine 170 and server machine 180 may be one or more computing devices (such as rack-mounted servers, router computers, server computers, personal computers, mainframe computers, laptop computers, tablet computers, desktop computers, etc.), data storage (e.g., hard disks, memory databases), networks, software components, or hardware components.

[0033] Server machine 170 includes a data set generator 172, which is capable of generating one or more data sets (e.g., ...). Figure 2 The set of data inputs 210 and the set of target outputs 220 are used to train, validate, or test machine learning models 190. See below for further details. Figure 2 and Figure 6 The operation of the dataset generator 172 is described in detail. In some embodiments, the dataset generator 172 may divide historical sensor data 144 into a training set (e.g., 60 percent of historical sensor data 144), a validation set (e.g., 20 percent of historical sensor data 144), and a test set (e.g., 20 percent of historical sensor data 144). Server machine 180 includes a training engine 182. In some embodiments, server machine 180 includes a training engine 182, a validation engine 184, and a test engine 186. Training engine 182 may be able to train machine learning model 190 using the training set from dataset generator 172. Training engine 182 may generate one or more trained machine learning models 190.

[0034] The validation engine 184 can use a validation set from the dataset generator 172 to validate the trained machine learning model 190. The validation engine 184 can determine the accuracy of each trained machine learning model 190 based on the validation set. The validation engine 184 can discard trained machine learning models 190 with accuracy that does not meet a threshold accuracy.

[0035] The testing engine 186 can use a test set from the dataset generator 172 to test the trained machine learning model 190. Based on the test set, the testing engine 186 can determine the trained machine learning model 190 with the highest accuracy among all trained machine learning models.

[0036] Machine learning model 190 may refer to a model artifact created by training engine 182 using a training set, which includes data inputs and corresponding target outputs (correct answers to the corresponding training inputs). Patterns can be found in the dataset that map the data inputs to the target outputs (correct answers), and provide the machine learning model 190 with a mapping to capture these patterns. In some implementations, machine learning model 190 may use one or more LSTM layers and softmax layers (see...). Figures 7A to 7B ).

[0037] In some implementations, the fault prediction component 132 may provide historical sensor data 144 and a historical window 156A to a dataset generator 172. The dataset generator 172 may provide historical sensor data 144 as input and historical window 156A as output to one or more of a training engine 182, a validation engine 184, and / or a testing engine 186 to perform one or more of the following: training, validating, or testing a machine learning model 190.

[0038] In some implementations, the fault prediction system 110 may generate different models 190 based on one or more of the following: different hyperparameters (e.g., different numbers of LSTM layers), different types of machine learning models, different sets of historical additional features 148, etc. The fault prediction system 110 may perform one or more of the following: train, validate, or test different models 190, and select the most accurate model 190.

[0039] In some implementations, the fault prediction component 132 can provide current sensor data 150 as input to a trained machine learning model 190, and run the trained machine learning model 190 using the input to obtain one or more outputs. (The following text is related to...) Figure 4 As described in detail, the fault prediction component 132 can determine the predicted window 156B (e.g., based on the output of the trained machine learning model 190, by extracting the confidence level of the predicted window 156B from the output). The fault prediction component 132 can also determine confidence data based on the output. The confidence data can indicate the confidence level of the manufacturing equipment 124 corresponding to the predicted window 156B. The fault prediction component 132 can use the confidence level 158 to select the predicted window 156B.

[0040] Confidence data may include or indicate a confidence level 158 for a predicted window 156B corresponding to future failures of one or more components of manufacturing equipment 124. In one example, the confidence level is a real number between 0 and 1, where 0 indicates no confidence in the predicted window 156B corresponding to future failures of one or more components of manufacturing equipment 124, and 1 indicates absolute confidence in the predicted window 156B corresponding to future failures of one or more components of manufacturing equipment 124.

[0041] The fault prediction component 132 can determine multiple predicted windows 156B and corresponding confidence levels 158 (e.g., a 10% confidence level for the normal operation window and a 90% confidence level for the pre-fault operation window) based on the output of model 190. In some embodiments, the fault prediction component 132 selects the prediction window with the highest confidence level. In some embodiments, the fault prediction component 132 selects the prediction window with a confidence level exceeding 50%.

[0042] For illustrative and not limiting purposes, aspects of this disclosure describe training a machine learning model and using the trained model to determine a predicted window 156B using current sensor data 150. In other embodiments, a heuristic or rule-based model is used to determine the predicted window 156 based on sensor data 142 (e.g., historical sensor data 144, current sensor data 150, etc.). The predicted window 156 may be monitored or otherwise used relative to the sensor data 142 in the heuristic or rule-based model. Figure 2 Data input 210 describes any information.

[0043] In some implementations, the functionality of client device 120, fault prediction server 130, server machine 170, and server machine 180 can be provided by a smaller number of machines. For example, in some implementations, server machine 170 and server machine 180 can be integrated into a single machine. In some other implementations, server machine 170, server machine 180, and fault prediction server 130 can be integrated into a single machine.

[0044] Typically, functions described in one embodiment as being performed by client device 120, server machine 170, and server machine 180 may also be performed on fault prediction server 130 in other embodiments, if appropriate. Additionally, functions belonging to a particular component may be performed by different or multiple components operating together. For example, in some embodiments, fault prediction server 130 may receive user input instructing manufacturing equipment 124 (e.g., a semiconductor processing tool) for fault prediction, and fault prediction server 130 may provide alarms, shut down manufacturing equipment 124, etc., based on a confidence level 158 of the predicted window 156B. In another example, client device 120 may perform one or more of the following: remove noise from sensor data 142, perform feature analysis on sensor data 142, determine the confidence level 158 of the predicted window 156B, predict whether one or more components are within the pre-fault window, or perform corrective actions. In another example, dataset generator 172 may remove noise from historical sensor data 144 and perform feature analysis on historical sensor data 144.

[0045] Furthermore, the function of a specific component can be performed by different or multiple components operating together. One or more of the fault prediction server 130, server machine 170, or server machine 180 can be accessed via an appropriate application programming interface (API) as a service provided to other systems or devices.

[0046] In this implementation, "user" may refer to a single individual. However, other implementations of this disclosure cover "user" as an entity controlled by a plurality of users and / or automated sources. For example, a collection of individual users united as an administrator group may be considered a "user".

[0047] Although embodiments of this disclosure are discussed in relation to sensor data 150 received from sensor 126 coupled to manufacturing equipment 124, embodiments are generally applicable to data received over time (e.g., irregular time-series data, etc.). Embodiments are generally applicable to optimizing processes that generate data over time. Examples of manufacturing equipment 124 for wafer or display fabrication are physical vapor deposition (PVD) equipment, chemical vapor deposition (CVD) equipment, atomic layer deposition (ALD) equipment, chemical mechanical polishing (CMP) equipment, and etching equipment.

[0048] Figure 2 It is an example data set generator 272 according to certain implementations (e.g., Figure 1 Data set generator 172), used to use historical sensor data 244 (e.g., Figure 1 Historical sensor data 144), for machine learning models 290 (e.g., Figure 1 Model 190) creates a data set. Figure 2 System 200 shows a data set generator 272, data input 210, and target output 220.

[0049] In some implementations, dataset generator 272 generates datasets (e.g., training sets, validation sets, test sets) including one or more data inputs 210 (e.g., training inputs, validation inputs, test inputs) and one or more target outputs 220. The dataset may also include mapping data that maps the data inputs 210 to the target outputs 220. Data inputs 210 may also be referred to as “features,” “attributes,” or “information.” In some implementations, dataset generator 272 may provide the dataset to one or more of training engine 182, validation engine 184, or testing engine 186, wherein the dataset is used to train, validate, or test machine learning model 190. Some implementations of generating training sets may be relative to… Figure 6 Let me describe it further.

[0050] In some implementations, data input 210 may include one or more feature sets 212A for historical sensor data 244. Each feature set 212 may include at least one of the following: historical feature 246 (e.g., Figure 1 Historical feature 146) or additional historical feature 248 (e.g., Figure 1 Historical additional features 148). For example, feature set 212 may include one or more historical additional features 248.

[0051] In some implementations, the dataset generator 272 may generate a first data input 210A corresponding to the first feature set 212A to train, validate, or test a first machine learning model, and the dataset generator 272 may generate a second data input 210B corresponding to the second feature set 212B to train, validate, or test a second machine learning model.

[0052] In some implementations, the dataset generator 272 may discretize the target output 220 (e.g., for a classification algorithm used in a regression problem). Discretization of the target output 220 can convert continuous values ​​of variables into discrete values. In some implementations, the discrete values ​​for the target output 220 indicate a history window 256 (e.g., a normal operation window, a pre-failure window, a failure window, etc.). In some implementations, the discrete values ​​for the target output 220 indicate how much time has passed since installation for one or more components to fail (e.g., days, hours, etc.).

[0053] The data input 210 and target output 220 used to train, validate, or test the machine learning model may include information from a specific facility (e.g., from a specific semiconductor manufacturing facility). For example, historical sensor data 244 may be used with... Figure 1 The current sensor data 150 originates from the same manufacturing facility. In some embodiments, the information used to train the machine learning model may come from a specific group of parts from a manufacturing facility with specific characteristics (e.g., parts from a specific timeframe, parts for a specific type of manufacturing equipment, etc.), and allow the trained machine learning model to predict a failure window for a specific group of parts based on historical sensor data associated with one or more parts sharing characteristics of the specific group. In some embodiments, the information used to train the machine learning model may be available from parts from two or more manufacturing facilities, and allow the trained machine learning model to determine the outcome for a part based on input from one manufacturing facility. In some embodiments, the information used to train the machine learning model may be associated with one or more first ion implantation tools, and the trained machine learning model may be used to predict part failures for one or more second ion implantation tools different from the one or more first ion implantation tools.

[0054] In some implementations, after generating data input 210 and using the dataset to train, validate, or test the machine learning model 190, additional historical sensor data and corresponding historical windows from one or more manufacturing facilities may be used to train, validate, test, or tune the machine learning model 190 (e.g., adjusting weights associated with the input data of the machine learning model 190, such as connection weights in a neural network, adjusting hyperparameters, etc.).

[0055] Figure 3 The diagram is used to determine the predicted window 356B (e.g., Figure 1 The confidence level of the predicted window 156B is 358 (e.g., Figure 1 A block diagram of system 300 with a confidence level of 158. System 300 can provide failure prediction for semiconductor manufacturing tools (e.g., end-of-life prediction for plasma source guns in ion implantation semiconductor manufacturing tools).

[0056] At box 310, system 300 (e.g., Figure 1 The fault prediction system 110) executes historical sensor data 344 (e.g., Figure 1 Historical sensor data 144) data partitioning (e.g. via Figure 1The server machine 170 uses a dataset generator 172 to generate a training set 302, a validation set 304, and a test set 306. In some implementations, the system 300 generates a plurality of feature sets corresponding to each dataset.

[0057] At box 312, system 300 uses training set 302 to perform model training (e.g., via...). Figure 1 The system 300 can use multiple feature sets of the training set 302 (e.g., the first feature set of the training set 302, the second feature set of the training set 302, etc.) to train multiple models.

[0058] At box 314, system 300 uses validation set 304 to perform model validation (e.g., via...). Figure 1 (Validation engine 184). System 300 can use the corresponding feature set of validation set 304 to validate each trained model. At box 314, the system can determine the accuracy of each of one or more trained models, and can determine whether one or more trained models have an accuracy that meets a threshold accuracy. In response to determining that no trained model has an accuracy that meets the threshold accuracy, the process returns to box 312, where system 300 uses different feature sets of the training set to perform model training. In response to determining that one or more trained models have an accuracy that meets the threshold accuracy, the process continues to box 316.

[0059] At box 316, system 300 performs model selection to determine which of one or more trained models that meet a threshold accuracy has the highest accuracy (e.g., the selected model 308). In response to determining that two or more trained models meeting the threshold accuracy have the same accuracy, the process returns to box 312, where system 300 performs model training using a further refined training set, corresponding to a further refined feature set, to determine the trained model with the highest accuracy.

[0060] At box 318, system 300 uses test set 306 to perform model tests (e.g., via...). Figure 1The system 300 uses a test set 306 to test the selected model 308. At box 318, the system 300 can use the test set 306 to determine if the accuracy of the selected model 308 meets a threshold accuracy. In response to the selected model 308's accuracy not meeting the threshold accuracy (e.g., the selected model 308 is overfitting to the validation set 304), the process continues to box 312, where the system 300 performs model training using different training sets corresponding to different feature sets. In response to determining that the selected model 308 has an accuracy that meets the threshold accuracy based on the test set 306, the process continues to box 320. At least in box 312, the model can learn patterns from historical sensor data for prediction, and in box 318, the system 300 can apply the model to the remaining data (e.g., the test set 306) to test the predictions.

[0061] In some implementations, in addition to using different feature sets (e.g., different combinations of historical additional features 148) for one or more of the different models during training, validation, or testing, system 300 may also include different hyperparameters in the different models to determine which features and which hyperparameters provide the highest accuracy. In some implementations, instead of using different feature sets for one or more of the different models during training, validation, or testing, system 300 uses different hyperparameters in the different models (e.g., where each model uses the same set of historical additional features 148) to determine which hyperparameters provide the highest accuracy.

[0062] At box 320, system 300 uses a trained model (e.g., the selected model 308) to receive current sensor data 350 (e.g., Figure 1 The current sensor data 150) and output the confidence level 358 of the predicted window 356B (e.g., Figure 1 The confidence level of the predicted window 156B is 158.

[0063] In response to receiving additional sensor data, the additional sensor data can be input into box 312 to update the trained model via model retraining.

[0064] Figures 4 to 6This is a flowchart illustrating example methods 400, 500, and 600 associated with fault prediction according to certain embodiments. Methods 400, 500, and 600 may be executed by processing logic, which may include hardware (e.g., circuitry, special-purpose logic, programmable logic, microcode, processing devices, etc.), software (such as instructions that run on a processing device, general-purpose computer system, or special-purpose machine), firmware, microcode, or a combination of the foregoing. In one embodiment, methods 400, 500, and 600 may be partially executed by fault prediction system 110. In some embodiments, methods 400, 500, and 600 may be executed by fault prediction server 130. In some embodiments, non-transitory computer-readable storage medium stores instructions that, when executed by a processing device (e.g., the processing device of fault prediction system 110), cause the processing device to perform methods 400, 500, and 600.

[0065] For simplicity, methods 400, 500, and 600 are depicted and described as a series of actions. However, actions according to this disclosure may occur in various sequences and / or simultaneously, and may occur with other actions not presented or described herein. Furthermore, depending on the subject matter disclosed, methods 400, 500, and 600 may be implemented without performing all the illustrated actions. Additionally, those skilled in the art will understand and recognize that methods 400, 500, and 600 may alternatively be represented as a series of interrelated states via state diagrams or events.

[0066] Figure 4 This is a flowchart of a method 400 for predicting component failures according to certain embodiments. In some embodiments, method 400 is executed by the processing logic of the failure prediction component 132 of the failure prediction server 130.

[0067] At block 402, the processing logic receives current sensor data (e.g., current sensor data 150) corresponding to a feature from a sensor (e.g., sensor 126) associated with the manufacturing equipment (e.g., manufacturing equipment 124, ion implantation tool). The feature can be a sequence of current sensor data, where each sequence of current sensor data is captured by a corresponding sensor. In some embodiments, the current sensor data is streamed to the processing logic. The processing logic may receive the sensor data in the form of one or more datasets, matrices, etc. In some embodiments, the sensor data is stored and aggregated in data storage 140.

[0068] In some implementations, at block 404, the processing logic removes noise from the current sensor data. In some implementations, the processing logic removes noise from the current sensor data by averaging the current sensor data over a time interval (e.g., averaging sensor data values ​​over a 10-second time interval). In some implementations, the processing logic removes noise by removing outliers from the current sensor data.

[0069] At block 406, the processing logic performs feature analysis to generate additional features for the current sensor data (e.g., current additional feature 154). Additional features may include one or more of the following: ratios, ranges, increments, or maximum values ​​of corresponding sensor data from one or more of the plurality of sensors. In some implementations, additional features may include statistical characteristics of key sensors (e.g., mean, standard deviation, etc.).

[0070] In some implementations, the processing logic performs feature analysis by receiving user input indicating additional features to be computed. In some implementations, (see...) Figure 5 The model is generated based on user input with additional features, user input with other parameters, or in the absence of user input, for feature analysis (e.g., feature engineering). The model for feature analysis can be a convolutional neural network (CNN) (e.g., a CNN that performs one-dimensional convolutions). CNNs are adept at learning the temporal structure in sensor data 142 and can determine invariant features for fault and normal data (e.g., for determining the normal operation window, the pre-fault window, etc.).

[0071] The processing logic can perform analysis by receiving current sensor data in a matrix and processing the matrix via one-dimensional convolution to output a complex number of additional features.

[0072] At box 408, (e.g., after noise removal) the processing logic provides additional features as input to the trained machine learning model. The trained machine learning model may include one or more LSTM layers and softmax layers. The trained machine learning model may have already learned spatial features as sequences through one or more LSTM layers. A time series structure may be incorporated into the predictions. The trained machine learning model may be weighted to penalize misclassifications (e.g., to avoid generating false positives). The current prediction generated by method 400 may be based on previous time steps of the current sensor data 150.

[0073] A trained machine learning model can be generated based on historical sensor data from a second plurality of sensors associated with a manufacturing apparatus (e.g., a second ion implantation tool) that is different from the manufacturing apparatus (e.g., an ion implantation tool) in block 402.

[0074] At box 410, the processing logic obtains one or more outputs from a trained machine learning model. In some implementations, the one or more outputs indicate a confidence level (e.g., confidence level 158) for a predicted window (e.g., predicted window 156B). In some implementations, the processing logic extracts the confidence level of the predicted window from the one or more outputs. In some implementations, the processing logic determines multiple predicted windows and corresponding confidence levels (e.g., a confidence level of 10% for a normal operating window and a confidence level of 90% for a pre-failure window).

[0075] At box 412, the processing logic predicts whether one or more components of the manufacturing equipment (e.g., an ion implantation tool) are within the pre-failure window based on the confidence level of the predicted window. The processing logic can predict that one or more components are within the pre-failure window by determining that the confidence level of the predicted window indicates a pre-failure window with a confidence level greater than 50%.

[0076] At block 414, the processing logic determines whether the confidence level of the predicted window indicates that one or more components of the ion implantation tool are within the pre-failure window. In response to the confidence level of the predicted window indicating that one or more components are not within the pre-failure window, the process continues to block 402, where additional sensor data is received (e.g., a loop of method 400). In response to the confidence level of the predicted window indicating that one or more components are within the pre-failure window, the process continues to block 416. The one or more components can be components of the ion implantation tool, such as at least one of a flooding gun or a source gun.

[0077] At box 416, the processing logic performs a corrective action associated with the ion implantation tool (e.g., in response to a prediction that one or more parts are within a fault pre-failure window). The corrective action may include one or more of the following: causing the graphical user interface to display an alarm, interrupting the operation of the manufacturing equipment (e.g., the ion implantation tool) (e.g., shutting down, slowing down, stopping a specific process, etc.), or causing one or more parts to be replaced.

[0078] Figure 5 This is a flowchart of a method 500 for training a machine learning model to predict component failures, according to certain embodiments. In some embodiments, method 500 is... Figure 1 The fault prediction system 110 processes the logic to perform this. In some implementations, method 500 is performed by... Figure 1The processing logic of server machine 180 is used to execute this. In some implementations, method 500 is performed by... Figure 1 The training engine 182 is used to execute the training on server machine 180.

[0079] At block 502, the processing logic receives historical sensor data (e.g., historical sensor data 144) corresponding to features (e.g., measurement values ​​and corresponding timestamps received from sensors (e.g., sensor 126) associated with the manufacturing equipment 124 (e.g., ion implantation tool).

[0080] In some implementations, at block 504, the processing logic removes noise from the historical sensor data. The processing logic removes noise from the historical sensor data by one or more of the following: averaging the historical sensor data over a time interval, or removing outliers.

[0081] At box 506, the processing logic determines a window (e.g., historical window 156A) comprising a normal operation window for a first subset of historical sensor data and a pre-failure window for a second subset of historical sensor data. The processing logic determines the window by determining the time of failure (e.g., based on the peak value of sensor data, the peak value of a health index, such as...). Figure 8B (In the middle). The processing logic can determine sensor data captured more than a set time amount (e.g., 24 hours, 48 ​​hours) before the fault time corresponds to the normal operation window, sensor data captured between the fault time and the set time amount before the fault corresponds to the pre-fault window, and sensor data captured after the fault time corresponds to the fault window.

[0082] At box 508, the processing logic performs feature analysis to generate additional features for the historical sensor data (e.g., historical additional feature 148). The additional features may include one or more of the following: ratios, ranges, increments, or maximum values ​​of corresponding sensor data from one or more of the plurality of sensors. The processing logic performs feature analysis by receiving historical sensor data from a matrix and processing the matrix via one-dimensional convolution to output the plurality of additional features.

[0083] In some implementations, the processing logic receives user input corresponding to additional features (e.g., operations and specific sensors associated with the additional features). The processing logic may be trained with a CNN (e.g., based on user input with additional features, user input utilizing parameters, in the absence of user input, etc.), and the trained CNN may be used in method 400 to determine additional features (e.g., current additional feature 154) for use with a trained machine learning model.

[0084] At box 510, the processing logic uses training data including additional features (e.g., after noise removal) and a target output including a window to train a machine learning model (e.g., the machine learning model includes one or more LSTM layers and softmax layers) to generate a trained machine learning model. The trained machine learning model may be able to generate one or more outputs indicating whether one or more ion implantation tool components (e.g., from one or more ion implantation tools, from one or more manufacturing equipment 124, etc.) are within the pre-failure window (see [link to relevant documentation]). Figure 4 Method 400).

[0085] In some implementations, the processing logic uses one or more of different features (e.g., historical feature 146, historical additional feature 148) or different hyperparameters to train multiple models. The processing logic may perform one or more of the following: train, validate, or test different models (e.g., evaluate models) to select the model that gives the highest accuracy.

[0086] In some implementations, the processing logic deploys a machine learning model trained to predict whether one or more components of the manufacturing equipment (e.g., the flooding gun, source gun, etc. of an ion implantation tool) are within a pre-failure window, in order to perform corrective actions (e.g., corrective actions associated with one or more ion implantation tools). In some implementations, the trained machine learning model receives input based on current sensor data from a second plurality of sensors associated with a second ion implantation tool (e.g., different from the ion implantation tool used to train the machine learning model), to predict whether one or more components are within a pre-failure window.

[0087] Figure 6 This is a flowchart of a method 600 for generating a dataset for a machine learning model to predict component failures, according to certain embodiments. According to embodiments of this disclosure, the failure prediction system 110 may use method 600 to perform at least one of the following: training, validating, or testing a machine learning model. In some embodiments, one or more operations of method 600 may be performed by, for example, relative to... Figure 1 and Figure 2 The data set generator 172 described for server machine 170 is used for execution. It can be noted that it can be used relative to... Figure 1 and Figure 2 The described components are used to illustrate. Figure 6 In terms of.

[0088] Reference Figure 6 At box 602, the processing logic initializes the data set T as an empty set.

[0089] At box 604, the processing logic generates a first data input (e.g., a first training input, a first validation input), the first data input including a first set of features for historical sensor data (e.g., relative to...). Figure 2 (As described). The first data input may include one or more features (e.g., historical feature 146) and / or one or more additional features (e.g., historical additional feature 148) of historical sensor data (e.g., historical sensor data 144).

[0090] At block 606, the processing logic generates a first target output for one or more of the data inputs (e.g., a first data input). The first target output provides an indication of a history window (e.g., history window 156A).

[0091] At box 608, the processing logic optionally generates mapping data indicating the input / output mapping. The input / output mapping (or mapping data) may refer to data inputs (e.g., one or more of the data inputs described herein), a target output for the data inputs (e.g., where the target output identifies the predicted window), and the association between the data inputs and the target output.

[0092] At box 610, the processing logic will add the mapping data generated at box 610 to the data set T.

[0093] At block 612, the processing logic branches based on whether the dataset T is sufficient to perform at least one of the following: training, validating, or testing the machine learning model 190. If sufficient, execution proceeds to block 614; otherwise, execution continues back to block 604. It should be noted that in some implementations, the sufficiency of the dataset T may be determined solely based on the number of input / output mappings in the dataset, while in other implementations, the sufficiency of the dataset T may be determined based on one or more other criteria (e.g., a measure of the diversity of data examples, accuracy, etc.) in addition to or instead of the number of input / output mappings.

[0094] At block 614, the processing logic provides a dataset T to train, validate, or test the machine learning model 190. In some embodiments, the dataset T is a training set and is provided to the training engine 182 of the server machine 180 to perform training. In some embodiments, the dataset T is a validation set and is provided to the validation engine 184 of the server machine 180 to perform validation. In some embodiments, the dataset T is a test set and is provided to the test engine 186 of the server machine 180 to perform testing. In some embodiments, the dataset T may be divided into a training set, a validation set, and a test set (e.g., the training set may be 60%, the validation set may be 20%, and the test set may be 20%). In response to a trained (e.g., validated, tested, and meeting a threshold accuracy) machine learning model, the trained machine learning model (e.g., via fault prediction component 132) can be used for fault prediction (see... Figures 3 to 4 ).

[0095] In the case of a neural network, for example, the input value of a given input / output mapping (e.g., a numerical value associated with data input 210) is input into the neural network, and the output value of the input / output mapping (e.g., a numerical value associated with the target output 220) is stored in the output node of the neural network. The connection weights in the neural network are then adjusted according to a learning algorithm (e.g., backpropagation, etc.), and the process is repeated for other input / output mappings in the dataset T. A trained machine learning model can be implemented by the fault prediction component 132 (the fault prediction component of the fault prediction server 130) to predict fault windows for one or more components.

[0096] Figures 7A to 7B These are block diagrams illustrating systems 700A and 700B for fault prediction according to certain embodiments.

[0097] Reference Figure 7A The system 700A can receive input data 710. Input data 710 can be sensor data in a matrix. Noise can be removed from the sensor data (e.g., by averaging raw data over a time interval to generate sensor data, or by removing outliers from the sensor data).

[0098] System 700A can perform a one-dimensional convolution 720 (e.g., a one-dimensional convolution of a trained CNN) on input data 710. In some embodiments, the CNN (e.g., the CNN performing a one-dimensional convolution) is trained based on user input associated with additional features (e.g., instructions for generating additional features). System 700A can perform a one-dimensional convolution 720 on input data 710 (e.g., after noise removal) to perform feature analysis to generate additional features for the input data. Additional features may include one or more of the following: ratios, ranges, increments, maximum values, etc., corresponding to the sensor data.

[0099] System 700A can input additional features into the LSTM layer 730 of the machine learning model. The number of LSTM layers can be a hyperparameter that can be tuned by training and retraining the machine learning model based on sensor data.

[0100] System 700A can transmit the output of LSTM layer 730 to softmax layer 740, and softmax layer 740 can generate corresponding confidence levels for one or more predicted windows (e.g., categories).

[0101] Reference Figure 7B System 700B includes an LSTM layer 730 capable of receiving additional features based on input data 710. The output of the LSTM layer 730 can be passed to a softmax layer 740. The softmax layer can generate one or more outputs. The one or more outputs can include corresponding confidence levels for one or more predicted windows. For example, the softmax layer can generate a first confidence level for a normal operation window, a second confidence level for a pre-failure window, and a third confidence level for a failure window. The total confidence level can be 100%. Windows corresponding to confidence levels greater than 50% can be used.

[0102] Figures 8A to 8B These are diagrams 800A and 800B illustrating fault prediction according to certain implementation methods.

[0103] Reference Figure 8A Chart 800A displays characteristic values ​​over time (e.g., historical additional feature 148, current additional feature 154, etc.). A first time window may correspond to category 0 (e.g., normal operation window). A second time window may correspond to category 1 (e.g., pre-failure window). A third time window may correspond to category 2 (e.g., failure window). Category 0 may end while category 1 may begin a set amount of time (e.g., 24 hours, 48 ​​hours, etc.) prior to the failure date (e.g., historical failure date, predicted failure date). Category 1 may end while category 2 may begin at the time of failure of one or more components. Historical sensor data can be labeled according to the corresponding window (e.g., category 0, 1, or 2).

[0104] Reference Figure 8B Chart 800B displays a health index plotted over time (e.g., the health index has a corresponding timestamp). The health index may be based on one or more of the results of convolutional LSTM, sensor data, additional features, etc.

[0105] The health index remains generally stable within the normal operating window. It peaks during the pre-failure window and typically declines around the time of the failure. A first subset of the sensor data corresponds to timestamps within the normal operating window, a second subset to timestamps within the pre-failure window, and a third subset to timestamps within the failure window. Each subset of the sensor data can be labeled according to its corresponding window (e.g., category).

[0106] Figure 9 This is a block diagram illustrating a computer system 900 according to certain embodiments. In some embodiments, the computer system 900 may be connected to other computer systems (e.g., via a network, such as a local area network (LAN), intranet, extranet, or the Internet). The computer system 900 may operate as a server or client computer in a client-server environment, or as a peer-to-peer computer in a peer-to-peer or distributed network environment. The computer system 900 may be provided by a personal computer (PC), tablet PC, set-top box (STB), personal digital assistant (PDA), mobile phone, network device, server, network router, switch or bridge, or means capable of executing a set of instructions (sequential or otherwise) of actions to be performed by a specified means. Furthermore, the term "computer" should include any collection of computers that individually or collectively execute a set of instructions (or multiple sets of instructions) to perform any one or more of the methods described herein.

[0107] In a further aspect, the computer system 900 may include a processing device 902, a volatile memory 904 (e.g., random access memory (RAM)), a non-volatile memory 906 (e.g., read-only memory (ROM) or electrically erasable programmable ROM (EEPROM)), and a data storage device 916, which may communicate with each other via a bus 908.

[0108] The processing device 902 may be provided by one or more processors, such as general-purpose processors (e.g., complex instruction set computing (CISC) microprocessors, reduced instruction set computing (RISC) microprocessors, very long instruction word (VLIW) microprocessors, microprocessors that implement other types of instruction sets, or microprocessors that implement combined types of instruction sets) or special-purpose processors (e.g., application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), or network processors).

[0109] The computer system 900 may further include a network interface device 922. The computer system 900 may also include a video display unit 910 (e.g., LCD), an alphanumeric input device 912 (e.g., keyboard), a cursor control device 914 (e.g., mouse), and a signal generation device 920.

[0110] In some embodiments, the data storage device 916 may include a non-transitory computer-readable storage medium 924 on which instructions 926 encoded for any one or more of the methods or functions described herein may be stored, including instructions for... Figure 1 The fault prediction unit 132 or the correction action unit 122 encodes instructions and instructions for implementing the methods described herein.

[0111] During the execution of instruction 926 by computer system 900, instruction 926 may also be stored, in whole or in part, in volatile memory 904 and / or in processing device 902. Therefore, volatile memory 904 and processing device 902 may also constitute machine-readable storage media.

[0112] Although computer-readable storage medium 924 is shown as a single medium in the exemplary example, the term "computer-readable storage medium" should include a single medium or multiple media (e.g., a centralized or distributed database and / or associated caches and servers) that store one or more sets of executable instructions. The term "computer-readable storage medium" should also include any tangible medium capable of storing or encoding a set of instructions for execution by a computer, which causes the computer to perform any one or more of the methods described herein. The term "computer-readable storage medium" should include, but is not limited to, solid-state memory, optical media, and magnetic media.

[0113] The methods, components, and features described herein can be implemented by discrete hardware components or integrated into the functionality of other hardware components (e.g., ASICs, FPGAs, DSPs, or similar devices). Alternatively, the methods, components, and features can be implemented by firmware modules or functional circuitry within a hardware device. Furthermore, the methods, components, and features can be implemented by any combination of hardware devices and computer program components, or as a computer program.

[0114] Unless otherwise expressly stated, terms such as “receive,” “execute,” “provide,” “obtain,” “extract,” “predict,” “remove,” “make,” “interrupt,” “determine,” “train,” “deploy,” or similar terms refer to actions and processes performed or implemented by a computer system that manipulates and converts data represented as physical (electronic) quantities within computer system registers and memories into other data similarly represented as physical quantities within computer system memory or registers or other such information storage, transmission, or display devices. Furthermore, the terms “first,” “second,” “third,” “fourth,” etc., as used herein are intended as labels to distinguish different elements and may not have an ordering significance according to the numerical representation of these terms.

[0115] The examples described herein also relate to an apparatus for performing the methods described herein. This apparatus may be specifically configured to perform the methods described herein, or it may comprise a general-purpose computer system selectively programmed by a computer program stored in a computer system. Such a computer program may be stored in a computer-readable tangible storage medium.

[0116] The methods and illustrative examples described herein are not inherently related to any particular computer or other device. Various general-purpose systems may be used in accordance with the teachings described herein, or it may prove convenient to construct more specialized devices to perform the methods described herein and / or each of the individual functions, routines, subroutines, or operations of the methods. Examples of the structures of various such systems are illustrated in the foregoing description.

[0117] The foregoing description is intended to be illustrative and not restrictive. Although this disclosure has been described with reference to specific illustrative examples and embodiments, it will be understood that this disclosure is not limited to the described examples and embodiments. The scope of this disclosure should be determined by referring to the appended claims together with the full scope of the equivalents of the claims.

Claims

1. A method for predicting component failure, the method comprising the steps of: determining, based on sensor data, that one or more components of a wafer or display manufacturing equipment are within a pre-failure window following a normal operating window, wherein corresponding data points in the normal operating window are generally stable along a first health index value, wherein the corresponding data points in the pre-failure window increase from the first health index value to a peak at a second health index value; and in response to determining that the one or more components are within the pre-failure window, causing a corrective action associated with the one or more components of the wafer or display manufacturing equipment to be performed.

2. The method of claim 1, wherein the step of determining that the one or more components are within the pre-failure window comprises the steps of: providing the sensor data as input to a trained machine learning model; and obtaining, from the trained machine learning model, one or more outputs indicating that the one or more components are within the pre-failure window.

3. The method of claim 2, wherein the trained machine learning model is trained based on historical sensor data and based on a historical window associated with the historical sensor data, the historical window comprising the normal operating window and the pre-failure window.

4. The method of claim 1, wherein the sensor data is associated with the one or more components of the wafer or display manufacturing equipment.

5. The method of claim 1, wherein the corresponding data points of the pre-failure window decrease from the peak at the second health index value to a third health index value, the third health index value corresponding to a failure time at an end of the pre-failure window.

6. The method of claim 5, wherein the failure time corresponds to a failure of the one or more components.

7. The method of claim 1, wherein causing the corrective action to be performed comprises one or more of: causing a graphical user interface to display an alert; interrupting operation of the wafer or display manufacturing equipment; or causing the one or more components to be replaced.

8. A method for predicting component failure, the method comprising the steps of: identifying historical sensor data associated with a wafer or display manufacturing equipment; and identifying a historical window associated with the historical sensor data, wherein: corresponding data points of the historical sensor data are generally stable along a first health index value in a normal operating window of the historical window; the corresponding data points of the historical sensor data increase from the first health index value to a peak at a second health index value in a pre-failure window of the historical window; and the historical sensor data and the historical window are used to determine, based on current sensor data, whether one or more components are within the pre-failure window to cause a corrective action associated with the one or more components to be performed.

9. The method of claim 8, further comprising the step of: A machine learning model is trained using training data including the historical sensor data and a target output including the historical window to generate a trained machine learning model that can generate one or more outputs indicating whether the one or more components are within the pre-fault window, so as to perform the correction action associated with the one or more components.

10. The method of claim 8, wherein the current sensor data is associated with one or more components of the current wafer or display manufacturing equipment.

11. The method of claim 8, wherein the corresponding data point in the pre-fault window decreases from the peak value at the second health index value to a third health index value, the third health index value corresponding to the fault time at the end of the pre-fault window.

12. The method of claim 11, wherein the failure time corresponds to a failure of the one or more components.

13. The method of claim 8, wherein performing the correction action comprises one or more of the following: This causes the graphical user interface to display an alert; Interrupt the operation of the wafer or display manufacturing equipment; or This allows one or more components to be replaced.

14. A system for predicting component failure, the system comprising: Memory; and A processing device coupled to the memory, the processing device performing the following operations: Based on sensor data, it is determined that one or more components of a wafer or display manufacturing equipment are in a pre-failure window following a normal operation window, wherein the corresponding data point in the normal operation window is substantially stable along a first health index value, and wherein the corresponding data point in the pre-failure window increases from the first health index value to a peak value at a second health index value. and In response to determining that the one or more components are within the pre-fault window, a correction action associated with the one or more components of the wafer or display manufacturing equipment is performed.

15. The system of claim 14, wherein in order to determine that the one or more components are within the pre-failure window, the processing device performs the following operations: Provide the sensor data as input to the trained machine learning model; and One or more outputs indicative of the one or more components within the pre-failure window are obtained from the trained machine learning model.

16. The system of claim 15, wherein the trained machine learning model is trained based on historical sensor data and on a historical window associated with the historical sensor data, the historical window including the normal operation window and the pre-fault window.

17. The system of claim 14, wherein the sensor data is associated with one or more components of the wafer or display manufacturing equipment.

18. The system of claim 14, wherein the corresponding data point in the pre-fault window decreases from the peak value at the second health index value to a third health index value, the third health index value corresponding to the fault time at the end of the pre-fault window.

19. The system of claim 18, wherein the failure time corresponds to a failure of the one or more components.

20. The system of claim 14, wherein, in order to perform the correction action, the processing device performs one or more of the following operations: This causes the graphical user interface to display an alert; Interrupt the operation of the wafer or display manufacturing equipment; or This allows one or more components to be replaced.

Images