Failure cause analysis for a machine line

Abstract

The invention relates to a method for determining the cause of a failure in a machine line for filling and packaging food and / or beverages. The machine line comprises a plurality of machines. The method is used to detect operating states for each of the machines and store same as a data set. After an operating standstill of a machine is detected, the period of time of the data set is requested in order to determine the cause of the failure, and said period of time is used as the basis for an input for a spatial-temporal relational graph convolution network. For each machine of the machine line, the stRGCN specifies the probability that the corresponding machine is the cause of the operating standstill.

Description

[0001] Root cause analysis for a machine line

[0002] The invention relates to a method for determining a cause of an error in a machine line, in particular in a machine line for filling and packaging food and / or beverages, and to a machine line.

[0003] Today's filling and packaging systems in the liquid food industry are highly optimized and process up to 120,000 units per hour. A typical filling and packaging system typically comprises a multitude of different machines and modules connected by conveyor belts. The units, such as bottles, cans, pallets, containers, or similar, are transported from one machine to the next, passing through the individual machines in the line in a predetermined sequence.

[0004] If a single machine in such a line fails, other machines will inevitably fail due to disruption of the material flow. To maintain high performance, a continuous analysis process is required to identify and consistently correct weak points within the line.

[0005] Therefore, in the event of a malfunction involving multiple machines, it is important to identify as quickly as possible the machine or machines in the line responsible for the line or part of the line being down. Previously, this task was primarily accomplished through expertise, with an expert in the complex machine line examining the system based on experience to identify the fault.

[0006] However, this manual approach is usually based on empirical data and can be time-consuming. By using artificial intelligence, available training data from a machine line can be used to train a model for that machine line that is more capable of identifying failure causes. However, such methods require sufficient training data, and the AI ​​model must have been trained explicitly for the specific machine system. Therefore, there is a need for improved machine lines and improved methods for determining the cause of failure in a machine line.

[0007] The object is achieved according to the invention by a method according to claim 1 and a machine line according to claim 8. Embodiments and further developments are covered in the subclaims.

[0008] One embodiment of the invention relates to a method for determining the cause of a fault in a machine line. The machine line may comprise a plurality of machines. Various materials, such as empties, bottles, cans, pallets, containers, or liquids, may be transported along an arrangement between the individual machines.

[0009] According to this embodiment, for each of the plurality of machines, an operating state of the machine is continuously recorded at a specific sampling rate and stored as a data set in a memory. The data set can, for example, have the dimensions M x S x T, where M is the number of the plurality of machines, S is the number of different operating states, and T is the number of time steps. An operational downtime of a machine in the machine line is then detected. For example, this can be the lead machine. However, the downtime of any other machine in the machine line can also be detected, and its cause can subsequently be analyzed.

[0010] A data set is then retrieved, for example, from the same memory in which the state data is / was originally stored. The retrieved data set comprises operating states of each of the plurality of machines for a period from a predetermined time before the downtime until at least the time of the downtime. Input data is then fed into a spatio-temporal relational graph convolutional network (stRGCN). The input data comprises a plurality of layers of the graph from the retrieved data set, each layer being associated with information about an operating state. More specifically, the input data for each node of the graph from the retrieved data set comprises a plurality of properties, each of these properties being associated with information about an operating state.

[0011] The input data is then processed by the stRGCN, and finally, a result is output by the stRGCN. The output of the stRGCN is the output of the last layer based on the processing of the input data. This last layer comprises a graph that has only one feature per node. In other words, the last layer contains only one output channel. The output layer indicates, for each node of the graph, a probability that the corresponding machine represented by the respective node is the cause of the downtime.

[0012] The stRGCN provides a model that can be trained and used for a variety of machine lines. Furthermore, the model can be transferred and applied to one or more other machine lines.

[0013] An embodiment of the invention relates to a machine line in which the above method is implemented.

[0014] Exemplary aspects of the invention are illustrated in the drawings. They show:

[0015] Figure 1 : a diagram showing a production line with k work areas M, each consisting of n machines;

[0016] Figure 2: a diagram showing a graphical representation of the

[0017] Machine speed against the main flow of a filling line, as is exemplary for machines of a returnable glass line;

[0018] Figure 3a: an exemplary Gantt chart of an exemplary error propagation in a machine line;

[0019] Figure 3b: an exemplary time delay between starts and stops of two machines due to a fault cause that is responsible for the downtime of a first machine;

[0020] Figure 4a: a block diagram for the concept of a general machine learning approach;

[0021] Figure 4b: a block diagram for the concept of multitask learning;

[0022] Figure 4c: a block diagram for the concept of transfer learning;

[0023] Figure 4d: a block diagram for the concept of combining multitask learning and transfer learning;

[0024] Figure 5: a block diagram for an exemplary machine line represented as a directed graph structure;

[0025] Figure 6: a general architecture of a fully convolutional neural network; Figure 7: a newly introduced fully convolutional architecture for neural

[0026] networks;

[0027] Figure 8: an exemplary flowchart for a method for determining a cause of a fault in a machine line;

[0028] Figure 9: an exemplary plant configuration for PET containers and

[0029] adhesive packaging;

[0030] Figure 10: an exemplary system configuration for PET containers and

[0031] shrink packer;

[0032] Figure 11 : an exemplary system configuration for cans or glass bottles; and

[0033] Figure 12: an example system configuration for cans.

[0034] One goal of the invention is the automatic detection of the fault-causing machine for each line downtime. This should be achieved with high accuracy and low implementation costs in a bottling plant. To achieve good accuracy, a neural network, and in particular a novel spatio-temporal relational graph convolutional network architecture, is used.

[0035] First, the background for determining the causes of a plant downtime will be explained. To this end, the concept of a filling and packaging line, including its components and control mechanisms, will be presented, and the characteristics of error propagation through a line will be explained. Subsequently, the available data and various approaches to data preprocessing will be presented.

[0036] Filling and packaging lines can vary greatly, ranging from processing cans to plastic bottles to glass bottles. There are also filling lines that process single-use bottles and those that use returnable bottles, which can also regularly feed in new bottles. Finally, each line is individually tailored to the needs of the customer, their building, and their products. These points demonstrate that generic analysis is a challenging task. However, there is standardized data that can be collected from any machine, and there are recurring patterns from the line perspective that can be used as a database for developing algorithms that offer significant added value. Examples of different lines are described in more detail in Figures 9 to 12.

[0037] The definition of a production line in general can be formulated as follows: "Production lines consist of material, work areas, and storage areas. The material flows from a work area to a storage area to a work area; it passes through each work and storage area exactly once in a fixed sequence." A generalized scheme for this type of line is shown in Figure 1 and describes the material flow through storage areas and work areas.

[0038] Figure 1 shows a schematic of a production line with k work areas M, each consisting of n machines. k+1 buffers B serve to store material between work steps. The storage areas serve as buffers between production steps and allow a work area to continue production for a while, even if, for example, the previous work step fails to forward material due to an error. Packaging and filling systems represent a special case of a line and differ from the general scheme due to several special features. These are described in detail below.

[0039] While a production line generally maintains a constant production speed across all work areas, the machine speeds along the bottle flow of a filling line are not constant. This is due to the presence of a central unit, also called the lead machine.

[0040] The goal is to ensure continuous operation of the lead machine. For this reason, the buffers between the machines are optimized to isolate the lead machine as much as possible from failures of the surrounding units. For example, the buffer in front of the lead machine should be as full as possible to allow the lead unit to maintain continuous production for as long as possible in the event of a failure of the upstream unit along the bottle flow.

[0041] If we continue to consider this example in the case where the error has been corrected, the buffer naturally has less stock than before. This amount of missing bottles in the buffer must be replenished. Therefore, the previous machines must be able to work faster than the lead machine. This is called overperformance. In this example, the entire line is set up using a V-diagram, as shown in Figure 2. Figure 2 shows the machine speeds along the bottle flow of a filling and packaging line. Typically, the filling machine is the lead machine for quality reasons, for example to avoid heating and oxidation of the product due to frequent stops. However, this is just an example and in principle any machine in the line can be the lead machine.

[0042] Due to the very high production speeds of, for example, 60,000 bottles per hour (almost 17 bottles per second) on a glass line and up to 120,000 cans per hour on a canning line, and the associated need for high mechanical precision, the probability of equipment failures or machine breakdowns is significantly higher than at slower production speeds. Therefore, the machine line must be prepared to absorb most failures that occur on the line by utilizing its buffers. Furthermore, there is always a need to identify the source of common failures on a line in order to eliminate the root cause.

[0043] Due to the interaction between machines, defects can propagate throughout a line. Figure 3a shows how the defect occurs as a standstill at the palletizer and propagates throughout the line via machines that enter the "jam" state. As this example demonstrates, the defect propagates in both spatial and temporal dimensions. The temporal progression of defect propagation is highly dependent on the occupancy of the intermediate belts and is therefore subject to significant fluctuations. Although the spatial defect propagation path usually occurs via the main flow, other paths besides the main flow, such as empty crate transport, are possible and occur in practice.

[0044] For error analysis, it is necessary to have as detailed a history as possible of all or all relevant machine states. Machine state describes the machine status of a machine. Various types of data are presented below that can be available in a standardized manner for most machines. However, these data are only examples, and other, less, or more data may also be available. Filling machines can usually provide standardized operating states, modes, and programs according to the Weihenstephan Standard.

[0045] Examples of machine states, ie operating states of a machine, are listed in the following table: j |

[0046] During operation of the machine line, the operating status of each of the numerous machines is continuously recorded (at a specific sampling rate). The recorded values, ie the recorded operating states for each machine, can be stored as a data set in a memory. The machine or operating states can be used for further processing and

[0047] The data can be used for fault and downtime analysis. Furthermore, the machine condition data can also be used for machine learning, such as training and inference.

[0048] For each line downtime (e.g., stop of the lead machine), a multivariate time series of machine states can be extracted from the data, as shown in Figure 3a. This results in a data set with dimensions M x S x T, where M is the number of machines, S is the number of different operating states, and T is the number of time steps.

[0049] A data set describing the operating states (e.g., 10 different possible states) over a certain period of time (e.g., 300 time steps) for a large number of machines (e.g., 20 machines) thus comprises a large amount of data: 20 x 10 x 300 = 60,000 data points. While it is in principle possible to use such data sets for further processing with modern computers, the present invention makes it possible to both reduce the computational load and improve adaptability to different systems.

[0050] According to one embodiment, the data set can be preprocessed. For this purpose, the time information is processed in such a way that each journal no longer needs to be evaluated. To achieve this, according to one embodiment, a time window is defined for the machine line, which is extracted from the entire time series of a system for a specific downtime of a machine (e.g., the lead machine).

[0051] The time windows are selected to contain all the information needed to analyze the corresponding error propagation. Figure 3b illustrates error propagation from one machine to another.

[0052] In this case, two machines m; and rrij are shown that are directly connected to each other, e.g., by a conveyor belt. The goal is now to extract the temporal coupling of the machines when one stops the other. For example, mi stops and thus no longer delivers any bottles to the belt. Consequently, rrij can only continue working as long as there are still bottles on the conveyor belt and use the conveyor belt's buffer function. The given example is shown in Figure 3b as a so-called Gantt chart, which graphically represents the temporal sequence of states in the form of bars on a time axis. This figure also visualizes the variables T and t used to describe the temporal problem. For the described example, the duration between the downtimes of mi and rrij can be given by: where the number of bottles on the conveyor belt connecting mi and rrij is denoted as N, while v cur,j represents the current speed of rrij. The opposite effect in the line is the restart of the machines. In this case, m must first start production to prepare bottles on the conveyor belt, which must be transported to rrij for processing. This time delay is called z?j art designated.

[0053] However, both delays are not necessarily constant across multiple events for many reasons. The responsible operator is always an influencing factor. For example, they often have to acknowledge a message from the machine before restarting. In addition to the operator, machines can be "prevented" by another machine, which means that they have a direct signal exchange, and thus, for example, one of the two machines in our example has to wait for a signal from a third machine.

[0054] In addition, the condition of the conveyor before the error propagates can significantly influence the time delay. In the event that the machines stop, the conveyor can serve as a buffer. Depending on the fill level of this buffer (linearly dependent on the number of bottles Njj), the subsequent machine has to process a different number of bottles, which is directly proportional to the remaining production time.

[0055] To start a fault analysis, a time window must first be defined, which is cut from the entire time series of a machine line for a specific downtime of the lead machine. It should contain all the information to analyze the corresponding fault propagation. After this preprocessing, the data from this time window is used as input for an algorithm, as described in detail later. For most machinery, the fault propagation from the initiating machine to the lead machine usually takes no longer than 10 minutes. In larger bottling plants, the fault propagation can take up to 15 minutes. Therefore, to train machine learning models, for example, data is extracted in a time window that begins 10 minutes or 15 minutes before the lead machine downtime and ends with the end of the lead machine downtime.To analyse the cause of a fault during operation of the machine system (i.e. not during training of a model), a shortened data range can be used, e.g. 10 min before the main machine stops up to the current point of the recordings.

[0056] Since the downtimes of the master machines are of variable length, the time windows also have a variable length and can only be used in this form by algorithms capable of processing data with dynamic length in the time dimension. And this is usually not the case. The usual approach to this problem is to cut time windows of constant length. Although this approach meets certain requirements, valuable information is lost during the master machine stop. The invention therefore also uses a second option to extract time windows with data from, typically, 10 minutes before the filler stop until its end.

[0057] If an algorithm is capable of processing data with dynamic temporal length, it can be used as input. For other algorithms, such as neural networks, that use convolutions for the temporal dimension, the invention introduces a different approach by downsampling the entire time window to a fixed number of journals.

[0058] One goal of the invention is to reduce the effort per rollout of a machine learning algorithm for a filling and packaging line. The optimal solution for a large number of rollouts is to have an initial effort (e.g., training an ML model) and then no additional effort per new customer or new machine line. This can be achieved if the trained model is able to identify the causal machine for each line. Since each new machine line corresponds to a new classification task, the model must be able to solve multiple tasks (multi-task learning) if it is trained on all available training examples from different machine lines. In addition, tasks (machine lines) that were not represented in the training must also be solved (transfer learning).

[0059] For illustration purposes, Figures 4a to 4d show various machine learning approaches. Figure 4a shows a general machine learning approach in which an ML model 401 is used for learning and prediction for each machine line. With this common machine learning approach, a data set must be collected for each machine line and a neural network must be trained for each individual machine line. This means that each model only has the data from this machine line available for training, which limits the size of the data set. In addition, after the system has been deployed and configured in the filling plant, a time period for data collection is required for the initial training of the model, which is why the algorithm cannot be used right from the start. In this machine learning approach, random forest algorithms or the common fully convolutional NN architecture, for example, can be used.

[0060] Figure 4b shows the multitask learning approach, in which a model learns generalized patterns across different machine lines. In contrast to the general approach, the invention makes it possible to train an ML model on the combined data from all possible machine systems. This is possible due to the novel network architecture described later. This approach results in higher accuracy and improved generalization capabilities of the model, as it can learn from different training data. Furthermore, the training effort only needs to be performed once, instead of training a separate neural network for each machine line.

[0061] Another advantage of the novel network architecture is the possibility of transfer learning, as shown in Figure 4c. Since the model is independent of the input graph (described later), it can be trained on one machine line and subsequently transferred to another. This makes it possible to use an ML model without having data from that machine line. This is particularly important for rapid deployment on a machine line, as machine line operators typically do not want to deploy 100 or 200 labels before the first results are available.

[0062] The combination of multi-task learning and transfer learning is shown in Figure 4d and is most promising for combining rapid adoption with the highest possible accuracy. In this case, the model is trained on all available data, but can also be applied to machine lines without available data and labels.

[0063] This means that the present invention provides a neural network that is trained or can be trained on all tasks / machine lines that provide labeled / labeled data, and the trained model can be used to classify the fault machine on all lines that provide sufficient data as input for the model, even for those machine lines that do not provide any labels (i.e., training data) beforehand.

[0064] Each task consists of transforming data about the machine line failure time xe (M x T x S) into a vector of class probabilities y, where the set of classes C is equal to the set of machines M. Thus, the ML algorithm should assign a class probability to each machine present in the input data x.

[0065] This leads to demanding requirements that have to be solved for a single model: The model must be able to:

[0066] - Process inputs with variable form (different number of machines per machine line)

[0067] - to provide a variable form of class probabilities (different number of machines per machine line)

[0068] - use the same set of network parameters (weights) for all tasks

[0069] The following presents a new neural network architecture designed to meet these requirements.

[0070] Before describing the novel ML architecture, the mathematical description of a machine line will be discussed using Figure 5. To obtain an exact and mathematical description of the line, it is represented as a directed graph with the machines as nodes, as shown in Figure 5. The directed edges represent the material flow.

[0071] All machines are described by a machine state, as shown in the table above. An example categorization of machine states can be divided into productive, shortage, backlog, self-fault, and planned downtime. However, this categorization is only an example.

[0072] A shortage state indicates that a machine is out of material at its feeder for processing. A backlog is the opposite scenario. Here, the machine stops because there is no more space behind it to dispense its product.

[0073] The so-called lead machine occupies a special position within the line. During production, the goal is to keep the lead machine running as consistently as possible for performance and quality reasons. A stoppage of the lead machine therefore means a stoppage of the entire production line. If the lead machine stops, the user wants to know the machine responsible for this stoppage in order to subsequently improve line performance.

[0074] The principles of the neural networks used herein are discussed below. Over the past decades, research in the field of neural networks has evolved, and the types of neural network layers have changed significantly. After a long period of research with multilayer perceptrons, also called feedforward artificial neural networks (consisting of fully connected layers), the introduction of convolutional neural networks represented a breakthrough, for example, in image processing. Their major advantages include the sharing of weights and thus overcoming the "curse of dimensionality," the recognition of patterns independent of local shifts in the input, and the processing of multidimensional inputs, such as images, while maintaining the original two-dimensional structure.However, convolutional neural networks require an input arranged on a grid, which requires a constant number of neighbors. In contrast, many structures in nature belong to non-Euclidean domains and can be represented as graphs. Hence, graph neural networks and many types of graph convolutional neural networks were invented.

[0075] In the present invention, graph convolutional neural networks are used to classify the machine in a filling and packaging plant that causes a failure or downtime. Additionally, requirements arising from multi-task learning and transfer learning are addressed.

[0076] Therefore, instead of the usual architecture that combines convolutional layers for feature extraction and fully connected decision layers that output class probabilities, embodiments of the invention use fully convolutional architectures, where the class probabilities are output by the last convolutional layer without additional fully connected layers above it. By using graph convolution layers, a network can be constructed that automatically adapts its output size, the size of the class probability vector, to the number of machines in the input data.

[0077] Thus, a single model can solve the task of cause classification for all available filling plants.

[0078] In the appendix to this description, convolutional layers and then graph convolutional layers, particularly relational graph convolutional layers, are introduced. Furthermore, a combination of convolutional layers and graph convolutional layers is explained, so-called spatio-temporal graph convolutions, which uses 1D convolutional layers for temporal and graph convolutional layers for spatial pattern recognition. This technology is used herein to develop two types of graph convolution networks: The invention provides spatio-temporal graph convolutions to process the complete multivariate time series data by performing both temporal and spatial convolutions. Both models are built according to the aforementioned fully convolutional architecture to meet the requirements of multi-task learning and transfer learning.Details on the above-mentioned neural networks are provided in more detail in the appendix.

[0079] To describe the advantages of the novel “fully convolutional” architecture described herein, reference is made to Figures 6 and 7.

[0080] To stack the introduced layers into a neural network, the invention uses a fully convolutional architecture to minimize the number of learnable weights within the network.

[0081] This novel architecture will be explained in comparison to conventional fully convolutional architectures using the example of the Relational Graph Convolutional Network (RGCN - Figure 6). The neural network in this example consists only of graph convolutions as layers and an MxS-shaped input.

[0082] In Figures 6 and 7, the shapes of the data before and after each graph convolution layer of a NN architecture are represented as a graph drawn in the plane of the foil, comprising a series of features displayed as slices in the depth dimension. For example, the input has five features representing the five machine states, and thus the input has five slices.

[0083] In the general architecture, as shown in Figure 6, the class probabilities, the model's output, are displayed in the depth dimension, as each probability is calculated from a slice of the final graph convolution result. Note that this network can only predict a fixed number of classes because the number of features in the final hidden layer is fixed. Thus, there is one final hidden layer per class in Figure 6.

[0084] The general approach of Figure 6 can be used for the classification of cause machines, but the invention provides a better solution.

[0085] The classification problem described here has the special property that the machines are represented as nodes, and the goal is to determine which graph node is the causal machine. Thus, the causal machine is to be found in the graph, not in the dimension of the features.

[0086] The invention exploits this property by calculating the class probabilities as the last, sole feature of the graph, thus outputting them in the dimension of the graph, not the features. This is shown in Figure 7, where each node (i.e., each machine) in the NN output corresponds to a class. The graph remains unchanged during its passage through the NN.

[0087] In this architecture, the model can learn to predict the class probability per node very accurately and is transferable between any machine line. In the new NN architecture, the probabilities are returned as a graph of nodes with a feature trained to represent the class probability.

[0088] Now that the architecture of the combined layers has been established, we'll take a closer look at the graph information used. Considering a filling and packaging plant, the edges of the graph are intuitively represented as directed connections that represent the material flow. Unlike directed connections, errors can propagate in both directions along the conveyor belts.

[0089] The algorithm attempts to reconstruct the path of error propagation before a machine stop from the machine status data, and thus from the information about shortages and backlogs. However, to convert the information about shortages or backlogs into information about the origin of the error, the direction of the material flow must be known.

[0090] To provide this information to the graph convolutional network, several relationships are used between the nodes. One represents the information propagating downstream (compared to the material flow), which means that the model is provided with the adjacency matrix corresponding to the material flow graph. The second represents the information propagating upstream, while the third connects each node to itself, thus allowing the model to "remember" information across the layers. These latter connections are commonly referred to as self-loops.

[0091] In contrast to the conventional approach, a huge improvement is achieved: Since graph convolution is independent of the size of the graph, the new architecture can process any machine line with the same set of weights.

[0092] The fact described above that the nodes of the graph are the classes of the classification problem is a very unusual property of the problem, which can usually only be used with a defined input form. It opens up two very promising options: multi-task learning and transfer learning, as described above.

[0093] Figure 8 shows a flowchart of an exemplary method for determining a cause of a fault in a machine line.

[0094] In step S802, for each of the plurality of machines, an operating state of the machine is continuously recorded at a specific sampling rate and stored as a data set in a memory. The data set can, for example, have dimensions of M x S x T, where M is the number of the plurality of machines and S is the number of different operating states. In step S804, a downtime of a machine in the machine line is detected. For example, this can be the lead machine. However, the downtime of any other machine in the machine line can also be detected, and its cause can subsequently be analyzed.

[0095] In step S806, a data set is retrieved. The retrieved data set includes operating states of each of the plurality of machines for a period from a predetermined time before the downtime to at least the time of the downtime.

[0096] In step S808, input data is input into a spatio-temporal relational graph convolutional network (stRGCN). The input data comprises a plurality of layers of the graph from the retrieved dataset, each layer being associated with information about an operating state, as described above with reference to Figures 6 and 7. More specifically, the input data for each node of the graph from the retrieved dataset comprises a plurality of properties, each of which is associated with information about an operating state.

[0097] In step S810, the input data is processed by the stRGCN, and finally, in step S812, a result is output. The output of the stRGCN is the output of the last layer. This output comprises information in the form of the input graph with one feature per node. More specifically, this last layer (i.e., the output layer) comprises a graph with only one feature per node. In other words, the last layer comprises only one output channel based on the processing of the input data. The output layer indicates, for each node of the graph, a probability that the corresponding machine represented by the respective node is the cause of the downtime.

[0098] The stRGCN provides a model that can be trained and used for a variety of machine lines. Furthermore, the model can be transferred and applied to one or more unknown machine lines.

[0099] The following Figures 9 to 12 describe various exemplary system configurations for different bottle filling systems in which the invention or at least parts and aspects of the invention can be implemented. The description of Figures 9 to 12 is intended only to provide a general overview of machines in which errors can propagate and in which machine downtimes can occur. Figure 9 shows an exemplary system configuration 1000 for PET bottles or PET containers and adhesive packs. As can be seen in Figure 9, the system configuration 1000 comprises a wide variety of modules that form a line at the end of which finished filled PET containers are output in the form of a pack on pallets. Some of the modules and machines can be optional, and the invention is not limited to the precise shape and arrangement of the system configurations.

[0100] The system configuration 1000 comprises an oven 1002 for preforms, a preform sorter with a feeding machine 1004, and a blow molding machine 1008. The modules 1002, 1004, and 1008 generally form a stretch blow molding machine in which PET containers are produced and formed from a starting material. The produced PET containers are forwarded to a filler 1010, where the bottles are filled. The filler can optionally include a rinser. Various particles such as dust, cardboard, or remnants of wooden pallets can settle in the preforms during storage or transport. These can be removed with the rinser. A closer can be arranged at the end of the filler, by means of which the PET containers are closed after filling.

[0101] Optionally, the system configuration 1000 can include a rotating device downstream of the filler 1010, which is used for hot filling of the PET containers. Via one or more conveyor belts 1016, which can also include a buffer 1018 for intermediate loading of filled containers, the filled PET containers are conveyed to a separator 1020 and then to a drying device 1024, in which the PET containers are dried.

[0102] After drying, the PET containers are conveyed to a labeling machine 1026. The labeling machine 1026 can be designed for various labeling techniques, such as labeling using hot melt, cold melt, self-adhesive labels, or sleeves. After the PET containers have been printed or labeled, they are conveyed through a second drying device 1028, a line distributor 1030, conveyor belts 1032, an adhesive pack production line 1034, and a curing section to a handle applicator. In the adhesive pack production line 1034, the PET containers are grouped into specific group sizes and packaged into a pack, such as a "six-pack." In the handle applicator, a carrying handle is attached to the pack, which allows for comfortable carrying of the pack.The finished containers are then arranged accordingly by a robot 1042 for layer production and packed on pallets by a palletizer 1044. In the system configuration 1000, so-called format carriages or format racks can be arranged on various modules and machines to provide quickly interchangeable format sets for short changeover times and automatic tool changes. Examples of format carriages are the format carriage 1006 for the blow molding machine 1008, the format carriage 1012 for the filler 1010, the format carriage 1022 for the labeling machine 1026, the format carriage 1038 for the adhesive container production 1034, and the format carriage 1046 for the palletizer 1044.

[0103] Figure 10 shows another example system configuration 1100 for PET containers and shrink packers. System 1100 in Figure 10 includes many of the modules and machines from system configuration 1000 in Figure 3, but there are some differences. Therefore, the description of the modules already described in connection with Figure 9 is omitted for Figure 10.

[0104] A key difference between the two exemplary system configurations 1000 and 1100 is that the labeling machine 1126 with the labeling modules 1127 can be installed downstream of the blow molding machine 1008 and upstream of the filler 1008. For this purpose, the system configuration 1100 can comprise six transport lanes 1150 into which the PET containers can be pushed. After the PET containers have pushed into one of the six lanes 1150, they are conveyed into the film wrapping module 1152 and then into the shrink tunnel 1154.

[0105] Figure 11 shows an example system configuration 1200 for cans or glass bottles. The example system configuration 1200 from Figure 11 again has some similarities to the system configurations 1000 and 1100 from Figures 9 and 10, and the description of the system configuration is therefore limited to the differences between the system configurations.

[0106] As shown in Figure 11, the exemplary system configuration can comprise two separate feeds. A first feed, on the left in Figure 11, shows a branch for cans or, optionally, a partial branch for new, reusable bottles. The containers, i.e., cans or new bottles, are fed into the machine by a depalletizer 1302, where they are guided via conveyor belts to the filler 1010. A second feed, on the right in Figure 11, shows a partial branch for reusable bottles, which are fed into the system by a reusable sorting system (not shown).

[0107] In the case that the already used reusable bottles are introduced into the system 1200 via the sub-branch for reusable bottles, the reusable bottles first pass through the cleaning machine or washing machine 1304. Another possible difference in the exemplary system configuration 1200 is the transfer packer 1306 after the labeling machine 1026. The transfer packer can sort the bottles or cans into a carton clip application or into crates, or both.

[0108] Figure 12 shows an exemplary system configuration 1300 for cans, in which the elements already described in the other system configurations are no longer described. The cans in system configuration 1300 are fed into the depalletizer 1302 from a magazine 1402 containing cans. After passing through the filler and being filled, the cans are closed by means of a closure magazine 1404 and transported further along the system 1400 via the conveyor belts, as described above.

[0109] The optional Pasteurizer 1408 can be bypassed via the Bypass 1412 if not required. Freshly filled products can be pasteurized in the Pasteurizer 1408 for preservation.

[0110] In contrast to plant configurations 1000, 1100, and 1200, the exemplary plant configuration 1300 shows various tanks for corresponding consumables, such as tanks 1410 with rinsing liquid and / or the filling product and tanks 1406 with belt lubricant. These tanks can also be included in the exemplary plant configurations described above. For example, the chemical products 106 that are fed from the mixer 110 to the machines can be stored in tanks 1406 and 1410.

[0111] Attachment

[0112] Learning process of a neural network for classification

[0113] A neural network consists of layers that apply a linear function / (0; x), which depends on the model parameters 0, to the input x and apply a nonlinear activation function o to the output. By stacking, for example, L layers, a neural network f = h ° l2° ... ° IL(0; x) is created.

[0114] In this application, the activation functions tanh(x), . e i sigmoid(x) = (1 + e -x ), ReLU(x) = max(0; x) and softmax(xj). Since the

[0115] Softmax function is used to convert activations into class probabilities, C is the number of output nodes and simultaneously the number of classes.

[0116] To train a neural network f, a loss function £ must be defined to use it as input to an optimizer that adapts the network parameters using backpropagation.

[0117] When using neural networks for classification tasks, categorical cross entropy is usually used as the loss function:

[0118] Here, x denotes an example of the dataset, y the corresponding label in one-hot notation, and y the output of the model, i.e., a vector of class probabilities. Finally, C represents the number of classes.

[0119] To smooth the trajectory of the network parameters in their parameter space while they are optimized, the examples of the dataset are divided into batches of size B. Each batch consists of a set of examples X = xi, ..., XB and a set of corresponding labels Y = yi, ..., yß. For each batch, the loss log yb,c (2.11) and the corresponding backpropagation with parameter adjustments is calculated.

[0120] Convolutional layer

[0121] In the invention, convolutional layers are mainly used in neural networks. To introduce these, the standard definition for a discrete convolution follows. where fe IR Kdenotes the convolution filter, * the convolution operation, and xen denotes a 1d series of data of length T.

[0122] In machine learning, the filter consists of learnable parameters (weights), i.e. W (l) for layer I (cf. equation 2.13), which are adapted by backpropagation. These learned filters are responsible for detecting the corresponding learned patterns in the input h (0) or the hidden dimension h (l) In this case, the

[0123] Convolution operation between weights and input nodes by the term We use the superscript notation (I) for the corresponding layer. Thus, hj denotes (l) the i-th neuron of layer I.

[0124] As is common in the implementation of neural networks, a bias b is added to the convolution result. To enable the network to learn nonlinear dependencies, an activation function o is applied to the sum of the convolution result and the bias.

[0125] Furthermore, the summation is performed over the indices j provided by Mi, which can thus be adapted to different choices of input h. In other words, one can choose from which nodes the information (from layer I) is taken when calculating hj (l+1) should be taken into account. An example where this is necessary is dilation. This concept is introduced in the following section. To introduce another common notation for layers, we rewrite equation 2.13 as

[0126] Equations 2.13 and 2.14 describe the same calculation specification.

[0127] Temporal Convolutional Layer

[0128] Equation 2.12 is extended to a dilated convolution operation by using d as the dilation factor. This causes the kernel to only consider every d-th step in x. In this way, the receptive field of the layers grows linearly with increasing d. By increasing the dilation factor from the topmost layer towards the input (as described, for example, in “Graph wavenet for deep spatial-temporal graph modeling,” Zonghan Wu, Shirui Pan, Guodong Long, Jing Jiang, and Chengqi Zhang; arXiv preprint arXiv: 1906.00121 , 2019), the receptive field of the network grows exponentially with layer depth, which enables effective handling of long-range dependencies in the data.

[0129] Additionally, gating is introduced through the use of where l / V, W, b, and b are model parameters, and O represents the element-wise product. Furthermore, o(-) is an activation function of the outputs, typically the hyperbolic tangent function, while g(-) is the sigmoid function, which determines the proportion of information passed to the next layer and thus represents the gating functionality. In this approach, the gating mechanism allows the model to decide whether a computed feature should be passed to the next layer based on the input used to compute that feature. Graph Convolutional Layers

[0130] The convolution operation on graphs follows the same idea as "classical" CNNs, but the mathematical formulation must be adapted to the dynamic number of neighbors per node, as this changes the number of sources providing information for a given node.

[0131] Note that Mj in Equation 2.13 consists of the same number of elements for each convolution operation. More intuitively, the data domain processed by a kernel always has the same shape. In contrast, graph data, because it is not evenly distributed on a grid like images, consists of a variable number of neighbors for each node. The information from each individual neighbor should be considered during the convolution operation at the current node.

[0132] Therefore, Mj from Equation 2.13 is replaced by the neighborhood of node i, denoted by Ni. Furthermore, for indistinguishable edges, there is no reasonable way to assign different weights to them, so the same weight W is used to propagate information from all neighbors. In addition to the information from the neighbors, the information from the current node is also taken into account by adding a so-called self-loop with weight Wo.

[0133] The introduction of the described changes leads to equation 2.17.

[0134] For an efficient implementation, equation 2.17 is translated into equation 2.18

[0135] 1 1 where H (l> is the input, l / l / ^ is the weight matrix, and the term D~ÄD~ represents the dependencies between the nodes. This term is composed of Ä = A + I Nwith IN as NxN identity matrix and from A, the adjacency matrix, and the diagonal matrix D i j = ,jÄ i j. In this notation, Ä represents the adiacency matrix of the undirected graph with additional self-connections.

[0136] In the case where edges can be differentiated into different types (contrary to Equation 2.17), meaning that there are now different relationships between the nodes, a weight can be learned for each type of relationship. For this case, Schlichtkrull et al. ("Modeling relational data with graph convolutional networks". In European semantic web conference, pages 593-607. Springer, 2018) introduce Equation 2.19, which extends Equation 2.17 by a summation over the relations r E and an additional learnable weight c,, r which evaluates the influence of each relation on the respective node.

[0137] Examples of different types of relationships between nodes of a knowledge graph include: a person "is a citizen of a country," "was educated at a university," or "has received an award." In this description, a distinction is made between error propagation by "backlog" and by "deficiency," i.e., upstream and downstream error propagation.

[0138] The transfer of the different types of relationships in equation 2.18 results in with R = {"Upstream", "Downstream", "Self-Loop"}. Thus, each layer of the graph convolution is a combination of three graph convolutions with a separate adiacency matrix. Aoownstream describes a directed graph that corresponds to the directed graph of the material flow through the machine line. Au ps tream corresponds to the same nodes, but the edges point in the opposite direction. Aseif-Loo PFinally, the identity matrix is ​​IN and describes the connections of each node to itself.

[0139] Blocks of layers

[0140] The invention uses a combination of spatial and temporal convolutions (as described, for example, in "Graph wavenet for deep spatial-temporal graph modeling" -, Zonghan Wu, Shirui Pan, Guodong Long, Jing Jiang, and Chengqi Zhang; arXiv preprint arXiv: 1906.00121 , 2019). Their approach is to combine a gated TCN and a GON with residual connections into one layer.

[0141] In the next step, these layers are combined into blocks. Each block consists of K layers. The outputs of all layers are concatenated, and two convolutional layers with ReLU activations are applied before the block outputs the information. These latter layers are described as "linear," which is a slightly misleading term. Therefore, let's go into a little more detail at this point: Since the concatenation of the layer outputs occurs in the dimension of the channels, a new number of channels results, which is the product of the number of layers and the number of channels before concatenation. To reduce this number of channels, two convolutions with 1x1 kernels are applied to the data. Effectively, these 1x1 convolutions act as if a fully connected (linear) layer were applied to the channels of a node in a log. Hence the term "linear."

[0142] Typically, layers are stacked within a neural network. In this case, a block of layers takes on the function normally performed by one layer. This means that a series of blocks is stacked, and after the last block, a decision layer is added, which converts the information into class probabilities to create a neural network for solving classification tasks.

[0143] Spatio-temporal Relational Graph Convolutional Neural Network (stRGCN)

[0144] This architecture uses three blocks of three layers each as an example. After the last block, two 1x1 convolutional layers with ReLU activations are added (similar to the last layers of each block) to reduce the number of channels (features) per node to one. Finally, the class probabilities are calculated using a softmax activation across the nodes. This approach again achieves the proposed full convolutional architecture.

Claims

Patent claims 1. A method for determining a cause of an operational downtime in a machine line for filling and packaging food and / or beverages, the machine line comprising a plurality of machines, material being transported along an array between the individual machines, and the method comprising: for each of the plurality of machines, continuously detecting, at a specific sampling rate, an operating state of the machine and storing the detected operating states as a data set in a memory, the machine line being represented by a graph, each of the plurality of machines being represented by a node and each connection for transporting material between the machines along a specific direction being represented as a directed edge in the graph; Detecting a downtime of the first machine in the machine line; Retrieving a data set, the retrieved data set comprising operating states of each of the plurality of machines for a period from a predetermined time before the downtime to at least the time of the downtime; Inputting input data into a spatio-temporal relational graph convolutional network (stRGCN), wherein the input data for each node of the graph from the retrieved data set comprises a plurality of properties, each of these properties being associated with information about an operating state; Processing of the input data by the stRGCN; and Outputting, by the stRGCN, information in the form of the input graph with one property per node based on the processing of the input data, wherein the output layer indicates for each of the nodes of the graph a probability that the corresponding machine represented by the respective node is the cause of the downtime.

2. The method according to claim 1, wherein the stRGCN provides a model that is trainable and usable for a plurality of machine lines and / or wherein the model is transferable and applicable to one or more unknown machine lines.

3. The method according to claim 1 or 2, wherein the nodes of the graph represent classes of a classification task that is solved by the stRGCN, and wherein the processing of the input data by the stRGCN comprises: Processing of input data with variable size of a dimension M to the same variable number M of classes within the classification task.

4. The method according to any one of claims 1 to 3, wherein the stRGCN uses graph convolutional layers that do not change a dimension of the data set of the graph, so that the graph remains unchanged during processing by the stRGCN.

5. The method according to any one of claims 1 to 4, wherein the stRGCN comprises a combination of spatial convolutional layers and temporal convolutional layers.

6. The method according to any one of claims 1 to 5, wherein the stRGCN outputs the probabilities as a single feature of the graph and in the dimension of the graph.

7. A machine line for filling and packaging food and / or beverages, the machine line comprising: a plurality of machines connected together in an array, wherein material is transported along the array between the individual machines; a sensor for each of the plurality of machines, each configured to continuously sense, at a specific sampling rate, an operating state of the machine, the machine line being represented by a graph, each of the plurality of machines being represented by a node and each connection for transporting material between the machines along a specific direction being represented as a directed edge in the graph; a memory for storing the data set; and a computing device configured to: TI Detecting a downtime of the first machine in the machine line; Retrieving a data set, the retrieved data set comprising operating states of each of the plurality of machines for a period from a predetermined time before the downtime to at least the time of the downtime; Inputting input data into a spatio-temporal relational graph convolutional network (stRGCN), wherein the input data for each node of the graph from the retrieved data set comprises a plurality of properties, each of these properties being associated with information about an operating state; Processing of the input data by the stRGCN; and Outputting, by the stRGCN, information in the form of the input graph with one property per node based on the processing of the input data, wherein the output layer indicates for each of the nodes of the graph a probability that the corresponding machine represented by the respective node is the cause of the downtime.

8. The machine line of claim 7, wherein the stRGCN provides a model that is trainable and usable for a plurality of machine lines and / or wherein the model is transferable and applicable to one or more unknown machine lines.

9. Machine line according to claim 7 or 8, wherein the nodes of the graph represent classes of a classification task that is solved by the stRGCN, and wherein the processing of the input data by the stRGCN comprises: Processing of input data with variable size of a dimension M to the same variable number M of classes within the classification task.

10. The machine line according to any one of claims 7 to 9, wherein the stRGCN outputs the probabilities as a single feature of the graph and in the dimension of the graph.

Images