Computer-implemented method for generating an individual artificial neural network, computer-readable storage medium, and system

Abstract

The invention relates to a computer-implemented method (100) for generating an individual artificial neural network, ANN, (10, 400), comprising the following: - loading (110): input data (11) comprising data elements (20), e.g. image, audio, sensor and / or tabular data; data to be predicted (12), which assign respective labels (30) to the data elements (20) of the input data (11); a target hardware specification (13) which specifies for which hardware configuration, for example a special FPGA chip, a maximum possible number of calculations per second, or a specific memory size, the ANN (10, 400) is to be generated; - determining (120) at least one network architecture (14), comprising: selecting / predicting (121) network parameter values (16) using the input data (11), the data to be predicted (12), and the target hardware specification (13); defining (122) the network architecture (17) using the network parameter values (16); training (130) the determined at least one network architecture (14) in order to generate a trained ANN (10, 400) using the input data (11) and the data to be predicted (12).

Description

[0001] Computer-implemented method for generating an individual artificial neural network, computer-readable storage medium and system

[0002] Description

[0003] The invention relates to a computer-implemented method for generating an individual artificial neural network, a corresponding computer-readable storage medium and system.

[0004] Artificial intelligence and machine learning methods are known to be used for a wide variety of tasks. For example, it is known to identify quality defects in production by analyzing images captured by cameras. Furthermore, it is known to perform environmental analysis for robotic systems using artificial intelligence methods. Other conceivable applications include pest and weed control in agriculture and forestry, the detection of loading errors in transport companies, capacity analysis in traffic, which can also be supported by drones, and image analysis as an application for mobile devices.

[0005] Other sensor-based applications include quality control and failure prediction in manufacturing, health monitoring of animals and humans, and audio-to-text recognition. Even with tabular input data, machine learning or artificial intelligence methods can be used, for example, to predict inventory levels or identify the causes of errors.

[0006] To solve the aforementioned problems, it is conceivable to choose from a variety of different methods. One possibility is the use of artificial neural networks. An artificial neural network (kNN) is a model based on the functioning of biological nervous systems. It consists of many interconnected neurons (nodes) arranged in layers. These neurons process input data by performing mathematical operations and passing information through the network. kNNs are used to recognize complex patterns, make decisions and predictions by learning from large datasets. kNNs have been extensively researched. There is a wide variety of different network structures or structural elements, architectures, and training methods. A major challenge lies in selecting a suitable artificial neural network architecture for a given application.

[0007] Three basic methods of network creation are known in the state of the art. A first approach involves the manual definition of the network architecture by an expert who manually creates a network based on existing research findings. This approach has the disadvantage of requiring a long development time and correspondingly high development costs. Furthermore, there is a very large body of expert knowledge that is not always unambiguous and may even contradict each other. A further pressing problem is the lack of sufficient numbers of qualified experts in this field to make this approach accessible to every company.

[0008] Another option is to use a pre-built network architecture and adapt it to the specific use case. A disadvantage of this approach is the limitation of the input data if the type of input data does not match the input type of the corresponding network. Furthermore, depending on the architecture, the amount of training data may be small. Additionally, this approach has limitations regarding the structural elements used in the architecture. For example, these are not optimized for the hardware used to implement the trained artificial neural network. The type of data may also not be optimized for the predictive application, for example, if the training data only includes objects with simple geometries and the application involves complex geometries.It is also conceivable that easily classifiable objects in the training data could lead to overfitting, preventing the implementation of complex applications. Furthermore, optimization for specific hardware is difficult; for example, quantization during training is hard to account for. Overall, adapting to the hardware used for training and running the artificial neural network is very challenging with this approach.

[0009] A third option is the use of so-called Neural Architecture Search, which involves trying out different architectures. This trial-and-error approach is performed within an optimization algorithm or through reinforcement learning. However, the well-known Neural Architecture Search approaches primarily use information gathered during training, rather than information relevant to the specific application. Furthermore, many approaches fail to consider the hardware used. In cases where hardware is taken into account, a large number of architectures must be examined, making the selection or trial-and-error process very time-consuming. Additionally, the search space processed by the optimization algorithm is very large. To obtain meaningful results, the search space must be restricted. However, this restriction often leads to suboptimal results.Furthermore, it is often necessary for an expert to first consider a basic structure for the use case and then determine which hyperparameters will be part of the optimization.

[0010] Overall, it can be stated that the individual creation of network architectures for a specific use case, especially for implementation on specific hardware, is not adequately resolved.

[0011] It is therefore an object of the invention to improve the creation of artificial neural networks. Furthermore, it is a particular object of the invention to enable the automated creation of artificial neural networks optimized for specific hardware. It is also a particular object of the invention to improve the creation of artificial neural networks for specific application scenarios, i.e., for specific input data. Finally, it is a particular object of the invention to accelerate the automated creation of artificial neural networks.

[0012] The problem is solved by the subject matter of the independent claims. The problem is further solved, in particular, by a computer-implemented method for generating a unique artificial neural network (kNN) comprising the following:

[0013] Loading:

[0014] o Input data that includes data elements such as image, audio, sensor and / or tabular data;

[0015] o predictable data that assign labels to the data elements of the input data;

[0016] a target hardware specification that indicates for which hardware configuration, e.g., a specific FPGA chip, a maximum possible number of calculations per second, or a specific memory size, the kNN should be generated; Determination of at least one network architecture, including:

[0017] o Selecting / predicting network parameter values ​​using the input, predicted data, and target hardware specifications;

[0018] o Defining at least one network architecture using the network parameter values;

[0019] Training the specified at least one network architecture to generate a trained kNN using the input data and the predicted data.

[0020] A key aspect of the invention is that the determination of the at least one network architecture is performed using predicted or selected network parameter values. For this prediction or selection, the input data, the predicted data, and the target hardware specifications are used. This describes a two-stage process in which network parameter values ​​are first determined, from which the at least one network architecture is then derived. This mechanism makes it possible, on the one hand, to consider the input data, the predicted data, and the target hardware specifications, and on the other hand, to draw upon known structures of artificial neural networks, for example, when network parameter values ​​provide clues to specific network architectures or elements of network architectures.

[0021] The input data can be, for example, sensor data such as voltage values, temperature values, or distance values. It is also conceivable that the input data consists of image data, such as that captured by 2D or 3D camera systems. Furthermore, the input data can be tabular data, such as inventory levels. The target hardware specification can provide information about the hardware on which the artificial neural network is to run. This could include information about available memory, RAM, VRAM, or processor clock speed. The target hardware specification can also specify a particular hardware component, such as a specific FPGA chip. In this case, the method could be further configured to retrieve relevant hardware information about the hardware component, which is then used to predict the network parameter values.

[0022] In one embodiment, the input data can specify an input type, and loading the input data can include determining the input type of the input data, where the input type can specify a type of input data, and selecting / predicting the network parameter values ​​can also be performed using the input type.

[0023] The input data itself can therefore already contain information that helps determine the corresponding network parameter values. For example, the input type can indicate that the data elements in the input data are image data. Furthermore, an application can be specified, e.g., that the data is used in autonomous driving. It is also conceivable that the input type is determined by a classification system, e.g., an AI system, preferably an artificial neural network. It is also conceivable that the input type specifies a file type. In addition, it is conceivable that the input type specifies an age or timestamp of the corresponding data elements. With the last-mentioned embodiment, it is thus conceivable that the input data is video data.

[0024] In one embodiment, the input data can include context information, which can specify a relationship between individual data elements, e.g., whether a group of data elements shows the same object from different perspectives. The selection / prediction of the network parameter values ​​can also be performed using this context information. In another embodiment, the context information can include, for example, user-entered information about the area around an object that is relevant for classifying the object. Furthermore, in another embodiment, the context information can indicate whether a classification is easy or difficult. The context information can also include information indicating how much the background in an image can differ from the backgrounds of other images.

[0025] In further embodiments, the contextual information can include a specification indicating the size and / or size of an area in an image that is relevant for classification, i.e., which area in the image primarily influences the classification. Furthermore, in one embodiment, the contextual information can include a specification indicating how many areas in an image can be relevant for classification, e.g., if a component is classified as unsatisfactory when the number of defects exceeds a threshold, e.g., three.

[0026] Such contextual information has the advantage that more detailed information about the input data or labels is available, which helps to determine the network parameter values.

[0027] In one embodiment, the labels of the anticipated data can specify a plurality of classes, whereby a label can assign a class to each data element of the input data.

[0028] The labels can thus represent the so-called "ground truth" used to train the artificial neural network. Different classes can be provided, with each data element potentially assigned a class. Furthermore, it is conceivable that different classes can be assigned to parts of a data element for specific applications. For example, when segmenting images—that is, assigning individual image areas to specific classes—a classification of the individual pixels is performed, allowing the user to select whether a pixel belongs to a particular class or not. In this respect, the input data can represent the individual images, with the expected data containing labels for each individual pixel of the corresponding images.In one embodiment, the labels of the anticipated data can each specify an image area in the data elements of the input data, in which, for example, a specific or an undefined object may be located.

[0029] The labels can therefore be designed to indicate image areas in which individual objects are located. The objects can be assigned to specific classes. For example, an object could be labeled "conductor trace," with a corresponding class being "circuit element." Alternatively, it is also conceivable that each object could have its own separate class.

[0030] In one embodiment, the method can include generalizing the labels of the anticipated data such that only partial information from each label can be used when determining the network parameter values ​​and for training.

[0031] Depending on the application, it can be advantageous to generalize the labeling. For example, the data to be processed might contain very specific labels for individual data elements. As explained in the previous example, a large number of objects, such as circuit elements, might be arranged in an image. Each circuit element could be assigned its own class, depending on the component. However, such detail is not necessary for fault analysis, for example, to determine whether a conductor track has faulty sections. In such a case, it is sufficient to distinguish between faulty conductor tracks and other objects in the image. Therefore, the corresponding labels can be generalized. Such generalization can be performed automatically or manually. In a manual execution, a user can merge the relevant classes and their labels.In automatic generalization, this can be achieved, for example, by providing information that the application should only output information indicating that a specific image contains an error. In such a case, the system can automatically group together all classes associated with an error. In one embodiment, the method can include augmenting the input data, particularly after the loading step.

[0032] Generate at least one copy of the data elements of the input data;

[0033] Applying at least one transformation to the copies of the data elements, wherein applying the transformation includes in particular:

[0034] o Applying a filter, e.g. a color filter;

[0035] o Applying a rotation, translation, enlargement, reduction and / or reflection;

[0036] Generating labels for the copies of the data elements using the labels of the corresponding data elements of the input data; and

[0037] Adding the generated labels to the expected data.

[0038] To increase the amount of available data for training the artificial neural network, it is conceivable to create copies of the input data and subject the data elements of these copies to transformations. For example, color filters can be used to simulate different lighting conditions, such as times of day. Furthermore, geometric transformations like rotations, reflections, or translations can be used to simulate capturing an object from different camera perspectives. Naturally, similar operations are conceivable for other data types, such as audio data, where, for instance, high-pass, band-pass, or low-pass filters can be used.

[0039] In one embodiment, the target hardware specification may include:

[0040] a calculation type specification that can indicate whether calculations should be performed by an accelerator unit or in target hardware;

[0041] a storage space specification that can indicate a maximum usable storage space for parameters of the kNN, and / or that indicates whether optimization during training should focus on reducing storage space;

[0042] a calculation specification that can indicate a maximum number of calculations per second and / or whether optimization during training should focus on optimizing computing power;

[0043] A quantization specification that indicates the number of bits with which the target hardware quantizes.

[0044] The computation type specification can therefore further define the type of hardware on which the artificial neural network's calculations should be performed. For example, when using a specific FPGA, it is common to also use external accelerator units to achieve better performance in the production system. This can be taken into account by specifying the target hardware. Furthermore, the memory space specification can indicate how much space the trained artificial neural network will occupy in the target hardware's memory. This specification thus affects the maximum number of parameters the trained artificial neural network may have. Therefore, when creating the network architecture (at least one), it is important to consider that only a maximum number of neurons or layers can be used.Furthermore, the calculation specification can be used to indicate how many calculations per second are possible with the target hardware. This can be very relevant for certain applications, for example, when there are strict requirements for a maximum throughput time for a prediction by the artificial neural network in the application, such as in the manufacturing process.

[0045] In one embodiment, the training of the specific at least one network architecture can be performed using training information, which may include:

[0046] a relevance indicator that can specify whether precision or recall should be prioritized when training the kNN; and / or

[0047] A training parameter can specify an optimization algorithm, a loss function, a maximum training duration for the kNN, a training termination condition, and / or whether models meeting a quality criterion should be cached. The relevance parameter specifies whether precision or recall should be prioritized. Precision and recall are used in machine learning to evaluate the performance of a classification model. Precision indicates how many of the cases predicted as positive by the model are actually positive—for example, how many of the data elements assigned to a class actually belong to that class. Recall, on the other hand, measures how many of the actually positive cases were correctly identified by the model. With respect to a training corpus, this calculates whether all data elements to be assigned to a class were indeed correctly assigned.Precision and recall are often in tension. Increasing precision frequently decreases recall, and vice versa. The relevance parameter can be used to control how the training is designed, i.e., whether precision or recall should be prioritized, or whether they should be balanced. The relevance parameter can also be used by the optimization algorithm or the loss function to control precision or recall.

[0048] The training settings can help to terminate training sessions that don't seem promising. Furthermore, the training settings allow you to specify that certain models should be saved. This has the advantage that, for example, the three best models can be made available to a user, who can then conduct a separate evaluation based on these models to select the best one.

[0049] In one embodiment, the method may further include analysis, in particular before determining the network architecture, the input data and / or the predicted data, wherein the analysis may include:

[0050] Determine a number of labels per class in the anticipated data;

[0051] Determining the number of objects in images;

[0052] Determining the size of objects in images; and / or determining filter changes, e.g., determining an average brightness value of pixels in an area of ​​an object after applying a high-pass filter, in particular for each color channel, wherein determining the at least one network architecture can also be performed using the results of the analysis.

[0053] The specified parameters can improve the provision / selection of network parameter values, as they provide further indications of which known architectures or network structures or layer arrangements are suitable for the input data or anticipated data.

[0054] In one embodiment, the kNN can be implemented as a convolutional neural network, a long-short-term-memory-based network, or a transformer-based network. Each of these networks has specific use cases for which it performs well. For example, convolutional neural networks are frequently used in image processing because they can very efficiently process large amounts of images. For sequential data, such as text, long-short-term-memory and transformer-based networks have proven suitable.

[0055] In one embodiment, the network parameters can include the network parameter values:

[0056] Information on the input data, e.g. image size or data type, wherein the information on the input data can be used when determining the at least one network architecture to determine the properties of an input layer of the kNN, e.g. a number of inputs, and / or number of channels of the input layer;

[0057] Information on desired predictions, e.g. image size or data type, wherein the information on the desired predictions is used when determining the at least one network architecture to determine the properties of an output layer of the kNN, e.g. the number of outputs, and / or the number of channels of the output layer;

[0058] Information on shrinking and / or enlarging layers, wherein the information on shrinking and / or enlarging layers can be used in determining the at least one network architecture to determine the number of shrinking and / or enlarging layers, a scaling from the inputs of a layer to the outputs of a layer and / or a number of channels;

[0059] Information for calculating the number of output channels, wherein the information for calculating the number of output channels can be used when determining the at least one network architecture to determine the number of channels at the output of a layer, wherein the information for calculating the number of output channels can specify a minimum and / or maximum number of output channels, wherein in particular a function for calculating the number of channels for a layer can be specified;

[0060] Information on the connection of layers, wherein the information on the connection of layers can be used when determining the at least one network architecture to determine connections between individual layers, wherein the output of one layer is made available to another layer by means of the connection, wherein the information on the connection of layers can include a specification regarding the layers to be connected and / or a layer type, wherein the specification of the layer type can be used when determining the at least one network architecture to connect layers of different types;

[0061] Information on structural elements, wherein the information on structural elements can be used to determine the at least one network architecture,

[0062] o to reduce and / or generalize data using a link layer, so-called pyramid pooling,

[0063] o to determine the number of channels at the output of a link layer, in particular the number of channels at the output of the link layer can be determined depending on a layer type, and / or

[0064] o to determine the number of channels of an input layer of a layer,

[0065] Information on context-dependent structural elements, wherein context-dependent structural elements can be used in determining the at least one network architecture to use known layer structures, wherein the information on context-dependent structural elements can in particular specify a type of context-dependent structural element and a number of affected layers;

[0066] Information for adapting to a computation type on target hardware, wherein the information for adapting to a computation type on target hardware can be used when determining the at least one network architecture to adapt a quantization;

[0067] Information on multiple outputs of the kNN, wherein the information on multiple outputs of the kNN can be used when determining the at least one network architecture to define different outputs of the kNN, where the outputs differ in the size of the outputs, i.e., a scaling.

[0068] The set of parameters described above offers an efficient way to generate at least one network architecture. It is therefore unnecessary to individually adjust the various hyperparameters of a neural network and find an optimal combination of these parameters, which is very time-consuming. Instead, corresponding network parameter values ​​are predicted for the aforementioned network parameters, enabling the targeted creation of at least one network architecture, since the parameter values ​​are derived from the input data. This results in an overall efficient determination of at least one network architecture.

[0069] In one embodiment, defining the at least one network architecture using the network parameter values ​​may include selecting and assembling structural elements and / or the network parameter values ​​may be used as part of a boundary condition of a mathematical optimization procedure.

[0070] In one embodiment, a layer can comprise a plurality of interconnected sublayers, wherein the plurality of sublayers can include:

[0071] an input layer that can process the data of a previous layer, whereby during processing an input layer's input data can be scaled to the size of an output layer and / or a filter can be applied, which can lead to an increase or decrease in the number of channels,

[0072] an aggregation layer that can receive data from another connected layer and combine it with output data from the input layer, for example by means of a mathematical operation such as addition, subtraction, multiplication, division, and / or an output layer that can process the combined data of the aggregation layer and / or provide a defined number of channels at its output.

[0073] In one embodiment, it is also conceivable that a layer is parameterized by a module type and a number of modules used. The module type can, for example, specify which type of sublayer combination is used, such as the use of one or more residual blocks (ResNet blocks), one or more Mobilenet blocks (also known as "inverted residual blocks"), or similar. The layer parameterization can specify how the data is processed, for example, whether a reduction or increase of the output size is achieved (as with ResNet blocks with Stride=2) and / or how many of these modules should be provided per layer.

[0074] Depending on the module type, the modules can be structured according to the above-described structure of numerous interconnected layers.

[0075] By using the layered structure described above, it is possible to connect different layers and allow data to flow between individual layers, for example via so-called skip connections. Furthermore, this structure ensures that the data can always be adapted to the necessary dimensions of the subsequent layer during processing.

[0076] In one embodiment, the selection / prediction of the network parameter values ​​can be performed using a rule set, wherein the rule set can include a plurality of rules, each defining network parameter values ​​for at least one of the network parameters for properties of the input data set, for properties of the data to be predicted and / or properties of the target hardware.

[0077] To enable the most efficient processing and prediction of network parameters, rules can be used. These rules can, for example, reflect existing knowledge, such as from research or from network architectures already proven in practice. The rules can assign network parameters corresponding to the properties of the input data set, the properties of the predicted data, and / or the properties of the target hardware. The rules thus define a mapping of properties to network parameter values.

[0078] In one embodiment, the method may include assigning a multitude of properties of the input data set, properties of the anticipated data and / or properties of the target hardware to thematic groups of network parameters that together can define a property of at least one network architecture.

[0079] In one embodiment, a group of network parameters can be assigned a rule that can assign corresponding network parameter values ​​to the network parameters of the group.

[0080] On the one hand, it is conceivable that a multitude of network parameters together determine a property of at least one network architecture. Furthermore, it is possible that a group of network parameters is assigned to a rule. Thus, it is conceivable that not a single rule is defined for each property, but rather that several properties are assigned a rule that determines a network parameter value from these properties. The network parameters, in turn, can be grouped accordingly in order to infer a property of at least one network architecture. This grouping can therefore occur in two places, which further reduces the search space, leading to a further increase in efficiency when determining the at least one network architecture. It is also conceivable that one rule takes into account the definition of network parameters by another rule.In other words, this means that rules can be applied sequentially to take into account the results of previously applied rules when assigning network parameter values. In one embodiment, a rule of the rule set can be implemented as a decision tree, an artificial neural network, and / or computer code.

[0081] It is therefore conceivable that different methods are used to implement the rules. These different methods can also be combined to achieve an optimal result.

[0082] In one embodiment, a rule of the rule data set can be created by optimizing network parameters that may be determined for input data of a reference data set.

[0083] It is therefore conceivable that by using reference data, for which, for example, an optimal artificial neural network is known, corresponding rules can be derived.

[0084] In one embodiment, the method may include a rule optimization, which may include:

[0085] a) Predicting a network parameter value for a reference data set, which may include, in particular, reference input data and predicted reference data, using a rule; b) Comparing the predicted network parameter with an optimal reference parameter value;

[0086] c) If the comparison indicates that the predicted network parameter deviates from the optimal reference parameter value by more than one optimization threshold: Determine properties of the reference data set, in particular the reference input data, that determine the selection of the network parameter value and adapt the rule taking into account the determined properties, and repeat steps a) to b) using the adapted rule;

[0087] d) If the comparison indicates that the predicted network parameter deviates from the optimal reference parameter value by less than the optimization threshold: Use the optimized rule as part of the rule dataset. In one embodiment, it is conceivable that the rule optimization itself is supported by machine learning. The rule optimization may include:

[0088] Prediction of network parameter values ​​by applying an output rule to a reference data set, e.g., applying manually created rules;

[0089] Optimizing the network parameter values ​​by applying an optimization algorithm, in particular optimization with respect to precision and / or recall;

[0090] Determine at least one optimized rule using the output rule, the optimized network parameter values ​​and the reference dataset, in particular using a machine learning method.

[0091] With the embodiment described above, it is therefore possible to further optimize the rules using AI methods. This assumes that one or more sets of initial rules are created and provided manually, e.g., taking into account known approaches and literature.

[0092] Subsequently, network parameter values ​​are determined using this rule(s). These determined network parameter values ​​can then be used to create various network architectures. It is also possible for the initial rules to specify a set of different possible network parameter values, e.g., a network depth that can range from 2 to 5 layers.

[0093] Furthermore, specific network architectures can be used to determine optimized network parameter values. This involves individually modifying the network parameter values ​​to achieve an optimum, for example, regarding precision or recall.

[0094] The optimized network parameter values ​​can then be used to determine optimized rules. For example, machine learning methods can be used to find a mapping that corresponds to the optimized network parameter values ​​and the input data. A k-nearest neighbors (kNN) algorithm is preferably used for this purpose.

[0095] This provides a way to determine optimal rules for calculating network parameter values. In one embodiment, it is also conceivable that previously predicted network parameter values ​​are taken into account when predicting a network parameter value; for example, the depth, i.e., the number of layers, can be predicted first, and then other parameter values ​​that depend on this value can be predicted based on that depth.

[0096] It is explicitly intended that the embodiments described above can also be considered an independent invention. Optimizing the rule has the advantage that the rules can be generated automatically. Thus, it is not necessary for an expert to provide their expertise in the form of rules. Furthermore, this makes it possible to efficiently create a large number of rules.

[0097] In one embodiment, the training may include determining hardware requirements; e.g., a number of operations per network iteration, RAM requirements, and / or VRAM requirements, wherein the method may further include determining training data using the hardware requirements, e.g., a batch size, throughput times for a batch, which can be used in particular to determine a data set size per epoch.

[0098] This allows training to be performed in a hardware-specific manner. In particular, the available memory and processing power can be taken into account. Based on these requirements, the training data can be divided accordingly; for example, a batch size can be determined to define the data set size per epoch. Specifically, the number of operations that can be executed in parallel can be determined.

[0099] In one embodiment, the method can include exporting the trained kNN for hardware configuration.

[0100] It is therefore planned that, after the kNN is trained, it will be exported according to the hardware configuration. The type of hardware configuration used can be taken into account. For example, HDL or VHDL code can be generated for use on an FPGA. Alternatively, C++ or C code could be generated for execution on general-purpose computers. It is also conceivable that instead of exporting the code itself, a compiled version is created, meaning the export process can include compiling the generated code. During compilation, the target hardware on which the kNN is to be executed can be considered, i.e., the hardware specified by the target hardware configuration. It is also possible to export the trained kNN along with the trained weights and an abstracted architecture definition, for example, using the Open Neural Network Exchange (ONNX).

[0101] In one embodiment, loading can include receiving the input data, the anticipated data and / or the target hardware information via a communication network, e.g. the Internet, in particular from a client computer.

[0102] It is therefore conceivable that the process is executed in a distributed system. For example, a user on a client computer could select or enter the input data, the data to be predicted, and the target hardware specifications. This information can then be transmitted via a communication network to a server unit, which may be configured to perform the steps described above.

[0103] Accordingly, in one embodiment, the trained kNN and / or the exported kNN may be transferred to a client computer and / or target hardware configured to execute the kNN.

[0104] The user can therefore receive the fully trained kNN on the client computer after training and use it in an application. Furthermore, it is conceivable that the trained kNN could be directly exported to the target hardware, for example in a production environment or other system used in production, such as a vehicle.

[0105] In one embodiment, the method can include assigning labels to the data elements of the input data to generate the anticipated data, particularly through a development environment on a client computer. It is therefore also possible for a user to create the labels using a development environment running on a client computer, thus defining the anticipated data that is then loaded. This has the advantage that the user can be supported in the labeling process by the development environment, for example, through appropriate tools such as the marking of image components or audio segments.

[0106] In one embodiment, the data to be sent beforehand can specify at least two labeling subclasses, wherein each labeling subclass can be assigned to a (single) label, and can thus define a labeling hierarchy, wherein the selection of the network parameter values ​​can take into account the labeling subclasses and labeling hierarchy, and wherein defining the at least one network architecture can include defining a sub-architecture for each labeling subclass, wherein the sub-architectures can each be configured to assign input data to one of the labeling subclasses after training.

[0107] With the described embodiment, it is conceivable that specific sub-architectures for each subclass can be created by using a labeling hierarchy. For example, a first class "Damage" could have the subclasses "Minor Scratches" and "Defects." The defined network architecture can then include a sub-architecture for the detection of "Damage," a sub-architecture for "Minor Scratches," and a sub-architecture for "Defects." Such an architecture can significantly improve the recognition of specific patterns corresponding to classes or subclasses.

[0108] In one embodiment, the setting can include allocating available hardware resources to each of the sub-architectures, such as memory areas or GPU / CPU cycles, as specified by the target hardware specification, and the sub-architectures can be executed by the allocated hardware resources when the trained kNN is run.

[0109] By using label subclasses, specific hardware resources can be assigned to the corresponding subarchitectures. This increases control over hardware allocation. Furthermore, it allows, for example, different subarchitectures to be calculated on different processing cores, or different memory modules to be uniquely assigned to specific subarchitectures. This enables, for instance, a network architecture with multiple subarchitectures to be efficiently executed on different or distributed hardware.

[0110] In one embodiment, the setting can include determining an output layer taking into account the labeling subclasses, wherein the number of neurons in the output layer can depend on the respective labeling subclass.

[0111] The described embodiment is based on the consideration that a different number of neurons at the output layer is advantageous for different structures, i.e., for specific labeling subclasses. For example, in image processing, it is conceivable that fewer neurons are needed in the output layer for coarse structures, such as scratches, than for fine structures, such as blemishes. In other words, a feature map is provided that has high spatial resolution with a small receptive field, or a feature map with low spatial resolution and a large receptive field. This embodiment thus further optimizes the use of the available hardware, especially when specific hardware components are assigned to the sub-architectures for execution.

[0112] In one embodiment, labeling subclasses can each specify an average proportion of an object specified by the labeling subclass in an input image, wherein a fine output layer, i.e., an output layer with a higher number of neurons that allow for higher spatial resolution, can be determined if the average proportion is below a specified threshold, and a coarse output layer, i.e., an output layer with a lower number of neurons that allow for low spatial resolution, can be determined if the average proportion is below the threshold.

[0113] The described embodiment provides a further optimization. The core of the optimization lies in relating the number of neurons in the output layer to the proportion of an object in the overall image. If the object represents only a small proportion of the overall image, i.e., if the pixels of the image that specify the object represent only a small fraction of the total pixels of the image, e.g., less than 20%, less than 15%, less than 10%, less than 5%, less than 1%, less than 0.5%, less than 0.1%, or less than 0.01%, then a finer output layer with more neurons is used.

[0114] If the object represents a larger proportion of the overall image, i.e., if the pixels of the image that specify the object represent a larger proportion of the total pixels of the image, e.g., more than 0.01%, more than 0.1%, more than 1%, more than 5%, more than 10%, more than 15%, or more than 20%, then a coarser output layer with fewer neurons is used.

[0115] In other words, adjusting the number of neurons in the output layer allows for customization of the output resolution, depending on the label class or subclass. In this context, a higher number of neurons means a relatively higher number of neurons compared to a lower number. Thus, a fine output layer has more neurons than a coarse output layer.

[0116] In one embodiment, before loading the input data, the data elements of the input data can be cropped to relevant areas, e.g., image areas that have characteristic properties for labeling, e.g., the representation of scratches on surfaces.

[0117] To achieve further improvement, i.e., further optimization of computing resource utilization, the input data or data elements within the input data can be restricted to relevant areas. For example, with image data, a section of the image can be selected and then processed for the corresponding data element. With video data, a section of the image can also be used, but a temporal restriction can also be applied, meaning only specific sequences of a video sequence are processed. A similar approach can be used with audio data, where only specific audio segments are processed.

[0118] Cropping can be performed by a user, for example, by selecting an image area in a GUI that displays specific features, such as damage like a scratch. This can be repeated for all data elements of the input data, so that only the modified input data is used for further processing.

[0119] In one embodiment, the loading can include loading a user specification, wherein the user specification includes at least one architecture parameter, e.g., a size of an output layer, wherein the determination of the at least one network architecture is performed such that the user specification is satisfied in the determined at least one network architecture.

[0120] To achieve the user's specifications in the specified network architecture, the user's specifications, e.g., the size of the output layer, can be considered when selecting / predicting the network parameter values. Thus, the user specification can define a boundary condition that influences the selection of network parameter values ​​accordingly. For example, if an output layer with 100 outputs or neurons is required, a network parameter value can be determined that specifies a structural element for an output layer with 100 outputs or neurons. This structural element is then used in the network architecture.

[0121] In one embodiment, this can:

[0122] • Determining at least one network architecture for each network parameter includes selecting / predicting a large number of network parameter values ​​within a range or set of values,

[0123] • Defining a variety of network architectures using different combinations of network parameter values, and

[0124] • The training may include training the multitude of network architectures to generate a multitude of trained kNNs, and the procedure may further include:

[0125] e) Execute one trained kNN from the set of trained kNNs on a target hardware specified by the target hardware specification; f) Check whether the executed kNN is executable on the target hardware, e.g., whether the kNN can be fully loaded into main memory or video RAM; g) Output the executed kNN as a generated individual kNN if the executed kNN is executable on the target hardware; h) Continue the procedure at step e) if the executed kNN is not executable on the target hardware.

[0126] One way in which the determination of at least one network architecture can be carried out is further specified by the embodiment described above. In this embodiment, value ranges for network parameters are defined. These network parameter values ​​of different network parameters can then be combined with one another, resulting in a multitude of network architectures. It is also conceivable that the value ranges are sampled again, i.e., that values ​​are selected from the value range to obtain a predetermined number of network parameter values ​​for a given value range.

[0127] Subsequently, the various network architectures can be tested on hardware specified by the hardware specification. For this purpose, a trained kNN is executed on the hardware, and it is checked whether the executed kNN is executable on the target hardware. In the context of this application, "executable" means that predetermined conditions are met, such as the kNN being able to be fully loaded into a VRAM.

[0128] If a kNN is executable on the target hardware, then in this implementation it is output as the generated individual kNN. Otherwise, the process continues with another kNN.

[0129] In one embodiment, the steps can each be performed in a sequence for the trained kNNs that is predetermined by the complexity of the kNNs, wherein the complexity is determined in particular by the number of parameters, the number of layers and / or weighted properties of the kNNs, wherein the procedure in particular starts with the most complex kNN.

[0130] To determine the order in which the numerous generated network architectures should be tested, their complexity can be taken into account. This approach is based on the consideration that in many cases, a complex network architecture achieves better results than a simple one. Therefore, the most complex architecture can be used as the starting point. Once a network architecture has been found that is executable by the target hardware, the most complex, and in many cases the best, network architecture executable by the target hardware within the context of the invention has been identified.

[0131] In one embodiment, loading can include adjusting the input data, e.g. reducing the size of images or lowering the resolution.

[0132] In one embodiment, an adjustment of the input data can be specified by a regression or classification unit.

[0133] The described implementations make it possible to adjust the input data not only manually, but also automatically. For example, it is conceivable that a resolution, e.g., dpi (dots per inch), could be set to a value so that a user can just barely recognize the relevant features of an image, such as damage.

[0134] If the user has frequently performed such adjustments, the user data can be used as training data for a regression or classification unit, i.e., as training data for a supervised learning process. Artificial neural networks or classical methods such as a Bayesian classifier are conceivable as regression or classification units.

[0135] Another possibility is the use of reinforcement learning. For example, a classifier can suggest an adjustment. If the user does not change this suggestion, this can be fed back to a reinforcement learning algorithm as positive feedback. If the suggested adjustment is not accepted, for example because the user changes a resolution, this can be fed back to a reinforcement learning algorithm as negative feedback. This provides a continuous and user-specific AI support function.

[0136] In one embodiment, the loading of the anticipated data may include a labeling step, wherein the labeling step may include anomaly detection for the data elements of the input data, and the labels may be assigned based on the anomaly detection.

[0137] In one embodiment, adjusting the input data can include reducing the data elements of the input data to an area identified by anomaly detection.

[0138] A further improvement can be achieved if no foreseeable data exists for the input data, i.e., no labels are present. In this case, the labels must be created manually by a user, for example, by marking areas in images that show specific damage, such as scratches or dents.

[0139] To support this step mechanically, anomaly detection can be used. Anomaly detection identifies data points that deviate significantly from normal behavior or expected patterns by first learning a model of the "normal" data distribution and then checking new data points to see if they lie outside the defined normality boundaries. The system typically learns from historical data how normal processes behave or how images or data look, and can then recognize unusual patterns. Possible algorithms for implementing anomaly detection include Isolation Forest, One-Class SVM, or an autoencoder.

[0140] The data elements identified through anomaly detection can then be labeled, e.g., "Damage," by a user. This makes it possible to efficiently load the predicted data even without existing labels.

[0141] The problem is further solved in particular by a computer-readable storage medium which contains instructions that cause at least one processor to implement a method as described above when the instructions are executed by the at least one processor.

[0142] The task is further solved in particular by a system for generating an individual artificial neural network, kNN, comprising: a preparation unit trained to,

[0143] o Input data that includes data elements such as image, audio, sensor and / or tabular data;

[0144] o predictable data that assign labels to the data elements of the input data;

[0145] o a target hardware specification that indicates for which hardware configuration, e.g. a specific FPGA chip, a maximum possible number of calculations per second, or a specific memory size, the kNN should be generated; to load;

[0146] a network determination unit that is trained to determine at least one network architecture, wherein the determination includes: o Selecting / predicting network parameter values ​​using the input, the predicted data and the target hardware specification;

[0147] o Defining / determining the at least one network architecture using the network parameter values;

[0148] a training unit that is trained to train the specified at least one network architecture to generate a kNN using the input data and the predicted data.

[0149] In one embodiment, the input data can specify an input type, and the preparation unit can be further configured to perform a determination of the input type of the input data as part of the loading process, wherein the input type can specify a type of input data, and wherein the network determination unit can be further configured to perform the selection / prediction of the network parameter values ​​also using the input type.

[0150] In one embodiment, the input data can include context information, which can specify a relationship between individual data elements, e.g., whether a group of data elements shows the same object from different perspectives. The network determination unit can be configured to perform the selection / prediction of the network parameter values ​​using this context information. In another embodiment, the context information can include, for example, user-entered information about the area around an object that is relevant for classifying the object. Furthermore, in another embodiment, the context information can indicate whether a classification is easy or difficult. The context information can also include information indicating how much the background in an image can differ from the backgrounds of other images.

[0151] In further embodiments, the contextual information can include a specification indicating the size and / or size of an area in an image that is relevant for classification, i.e., which area in the image primarily influences the classification. Furthermore, in one embodiment, the contextual information can include a specification indicating how many areas in an image can be relevant for classification, e.g., if a component is classified as unsatisfactory when the number of defects exceeds a threshold, e.g., three.

[0152] In one embodiment, the preparation unit can be configured to generalize the labels of the predicted data in such a way that only a portion of the respective label information can be used to determine the network parameters and for training.

[0153] In one embodiment, the preparation unit can be further configured to augment the input data, particularly after loading, by

[0154] Generate at least one copy of the data elements of the input data;

[0155] Applying at least one transformation to the copies of the data elements, wherein the application of the transformation may in particular include:

[0156] o Applying a filter, e.g. a color filter;

[0157] o Applying a rotation, translation, enlargement, reduction and / or reflection;

[0158] Generating labels for the copies of the data elements using the labels of the corresponding data elements of the input data; and

[0159] Adding the generated labels to the predicted data. In one embodiment, the system may include an analysis unit configured to analyze input data and / or the predicted data, particularly before defining / determining a network architecture, wherein the analysis may include:

[0160] Determine a number of labels per class in the anticipated data;

[0161] Determining the number of objects in images;

[0162] Determining the size of objects in images; and / or determining filter changes, e.g. determining an average brightness value of pixels in an area of ​​an object after applying a high-pass filter, especially for each color channel.

[0163] In one embodiment, the network determination unit can be configured to perform the selection / prediction of the network parameter values ​​using a rule set, wherein the rule set can include a plurality of rules, each of which defines network parameter values ​​for at least one of the network parameters for properties of the input data set, for properties of the data to be predicted and / or properties of the target hardware.

[0164] In one embodiment, the network determination unit can be further configured to assign a multitude of properties of the input data set, properties of the predicted data and / or properties of the target hardware to thematic groups of network parameters, which together can define a property of a network architecture.

[0165] In one embodiment, the system may include an optimization unit that may be configured to perform a rule optimization, comprising:

[0166] a) Predicting a network parameter value for a reference dataset, which may include, in particular, reference input data and predicted reference data, using a rule; b) Comparing the predicted network parameter with an optimal reference parameter value; c) If the comparison indicates that the predicted network parameter deviates from the optimal reference parameter value by more than an optimization threshold: Determining properties of the reference dataset, in particular the reference input data, that determine the selection of the network parameter value and adapting the rule taking into account the determined properties and repeating steps a) to b) using the adapted rule; d) If the comparison indicates that the predicted network parameter deviates from the optimal reference parameter value by less than the optimization threshold: Using the optimized rule as part of the rule set.

[0167] In one embodiment, it is also conceivable that previously predicted network parameter values ​​are taken into account when predicting a network parameter value; for example, the depth, i.e., the number of layers, can first be predicted, and then other parameter values ​​that depend on this value can be predicted based on this value.

[0168] In one embodiment, the training may include determining hardware requirements, e.g., a number of operations per network iteration, RAM requirements, and / or VRAM requirements, wherein the network determination unit may be further trained to perform a determination of training data using the hardware requirements, e.g., a batch size, throughput times for a batch, which may in particular be used to determine a data set size per epoch.

[0169] In one embodiment, the system can have an export unit that can be configured to export the trained kNN for the hardware configuration.

[0170] In one embodiment, a communication unit and a client computer can be provided, wherein the communication unit can be configured to receive the input data, the predicted data, and / or the target hardware information from the client computer via a communication network, e.g., the Internet. In another embodiment, the communication unit can be configured to transmit the trained kNN and / or the exported kNN to a client computer and / or to target hardware that can be configured to execute the kNN.

[0171] In one embodiment, the network determination unit can be configured to perform a selection and assembly of structural elements when defining the at least one network architecture using the network parameter values, and / or the network parameter values ​​can be used as part of a boundary condition of a mathematical optimization procedure.

[0172] In one embodiment, the client computer may be configured to run a development environment which may be set up to assign labels to the data elements of the input data to generate the anticipated data.

[0173] In one embodiment, the data to be sent beforehand can specify at least two labeling subclasses, wherein each labeling subclass can be assigned to a (single) label and thus define a labeling hierarchy, wherein the network determination unit can be configured to take the labeling subclasses and labeling hierarchy into account when selecting the network parameter values, and wherein the network determination unit can further be configured to perform a sub-architecture definition for each labeling subclass when determining the at least one network architecture, wherein the sub-architectures can each be configured to assign input data to one of the labeling subclasses after training.

[0174] In one embodiment, the network determination unit can be configured to allocate available hardware resources to each of the sub-architectures during the determination process, using target hardware specified by the target hardware specification, e.g., memory areas or GPU / CPU cycles, and wherein, when the trained kNN is executed, the sub-architectures can be executed using the allocated hardware resources.

[0175] In one embodiment, the network determination unit can be configured to perform a determination of an output layer when setting it up, taking into account the labeling subclasses, whereby the number of neurons of the output layer can depend on the respective labeling subclass.

[0176] In one embodiment, the labeling subclasses can each specify an average proportion of an object specified by the labeling subclass in an input image, wherein the network determination unit can be configured to determine a fine output layer, i.e., an output layer with a higher number of neurons that allow for higher spatial resolution, when the average proportion is below a specified threshold, and to determine a coarse output layer, i.e., an output layer with a smaller number of neurons that allow for lower spatial resolution, when the average proportion is below the threshold.

[0177] In one embodiment, the preparation unit can be configured to perform a cropping of the data elements of the input data to relevant areas before loading the input data, e.g. image areas that have characteristic properties for a label, e.g. the representation of scratches on surfaces, wherein the relevant areas are specified in particular by the / a context specification.

[0178] In one embodiment, the preparation unit can be configured to perform a loading of a user specification during loading, wherein the user specification can include at least one architecture parameter, e.g., a size of an output layer, and wherein the network determination unit can be configured to perform the determination of the at least one network architecture in such a way that the user specification is fulfilled in the determined at least one network architecture.

[0179] In one embodiment:

[0180] • The network determination unit must be configured to select / predict a multitude of network parameter values ​​within a range or set of values ​​when determining at least one network architecture for each network parameter; • The network determination unit must be configured to define a multitude of network architectures using different combinations of network parameter values; and

[0181] • the training unit must be designed to perform training on a multitude of network architectures to generate a multitude of trained kNNs,

[0182] the training unit may also be trained to:

[0183] e) Executing one trained kNN from the multitude of trained kNNs on a target hardware specified by the target hardware specification; f) Checking whether the executed kNN is executable on the target hardware, e.g., whether the kNN can be fully loaded into main memory or video RAM;

[0184] g) Output the executed kNN as a generated individual kNN if the executed kNN is executable on the target hardware; h) Continue the procedure at step e) if the executed kNN is not executable on the target hardware.

[0185] In one embodiment, the steps can be performed in a sequence for the trained kNNs that is predetermined by the complexity of the kNNs, wherein the complexity is determined in particular by the number of parameters, the number of layers and / or weighted properties of the kNNs, wherein the steps in particular begin with the most complex kNN.

[0186] In one embodiment, the preparation unit can be configured to perform an adjustment of the input data during loading, e.g. reducing the size of images or lowering the resolution, in particular using a context specification.

[0187] In one embodiment, an adjustment of the input data can be specified by a regression or classification unit.

[0188] In one embodiment, the preparation unit can be configured to perform a labeling step when loading the anticipated data. This labeling step can include anomaly detection for the data elements of the input data, and the labels can be assigned based on this anomaly detection. In another embodiment, adapting the input data can include reducing the size of the input data elements to an area identified by the anomaly detection. This offers similar advantages to those already described in connection with the method. Further embodiments are described in the dependent claims.

[0189] The invention will now be explained in more detail using exemplary embodiments. These will show:

[0190] Fig. 1 shows a flowchart of a process;

[0191] Fig. 2 is an illustration of the labeling of data elements;

[0192] Fig. 2A is an illustration of a class hierarchy;

[0193] Fig. 3 is an illustration of a contextual statement;

[0194] Fig. 4 shows a flowchart of the determination step;

[0195] Fig. 4A shows a flowchart for determining a sub-architecture;

[0196] Fig. 4B shows a flowchart of an alternative embodiment;

[0197] Fig. 5 shows a flowchart of a process in which an input type is determined;

[0198] Fig. 6 shows a schematic representation of a method for augmenting input data;

[0199] Fig. 7 shows a schematic representation of the analysis of input data and predicted data;

[0200] Fig. 7A shows a schematic representation of the classification of input data;

[0201] Fig. 7B. a schematic representation of the use of anomaly detection; Fig. 8 a schematic representation of an artificial neural network;

[0202] Fig. 9 shows a schematic representation of a layer of an artificial neural network;

[0203] Fig. 10 shows a schematic representation of an input layer with filter modules;

[0204] Fig. 11 shows a schematic representation of a filter module;

[0205] Fig. 12 shows a schematic representation of an artificial neural network with an intermediate layer;

[0206] Fig. 13 shows a schematic representation of a compound layer;

[0207] Fig. 14 shows a schematic representation of a structural element;

[0208] Fig. 15 shows a schematic representation of another structural element;

[0209] Fig. 16 shows a schematic representation of an initial scaling layer;

[0210] Fig. 17 shows a flowchart for a procedure for creating a rule;

[0211] Fig. 18 shows a system overview; and

[0212] Fig. 19 is an illustration of a computer system.

[0213] Fig. 1 shows a flowchart of a method 100 for generating a custom artificial neural network (hereinafter abbreviated as "kNN"). The method begins with a loading step 110, in which input data 11, data to be sent 12, and a target hardware specification 13 are loaded. The loading can, for example, involve loading from a mass storage device. In the illustrated embodiment, the input data is a dataset containing image data, meaning that individual data elements of the input data 11 represent images. The data to be sent 12 comprises labels for the individual data elements of the input data 11. In the illustrated embodiment, the labels specify objects that are represented by the data elements of the input data 11. The target hardware specification 13 specifies the hardware on which the kNN to be generated is to be executed.In the illustrated embodiment, a specific FPGA chip is specified. In one embodiment, the loading process 110 can optionally include loading a user preset 9. The user preset 9 then includes a specification of which image areas in the input data 11 and / or the anticipated data 12 are relevant for solving the task, e.g., class assignment or object recognition. For example, the user preset 9 can be created by a user on a graphical user interface, where the user can mark image areas in the input data 11 that then form the user preset 9. For audio or video data, for example, time segments can be marked to show the relevant time periods. Once a user preset 9 has been received, it can be used to process the input data 11 and / or the anticipated data 12 accordingly.to trim in order to continue the further procedure with the processed input data 11 and / or foreseeable data 12.

[0214] In one embodiment, user specification 9 includes at least one architecture parameter that provides specific information about the network architecture. In the illustrated embodiment, information about the size of the output layer is received.

[0215] After the loading step 100, at least one network architecture 14 is determined in the determining step 120. The input data 11, the predicted data 12, and the target hardware specification 13 are used for this purpose. Furthermore, in one embodiment, a boundary condition received as a user specification 9 can be taken into account. Thus, when a target value for an output layer is received as a user specification 9, this is used as a boundary condition in determining the network architecture 120 to identify the at least one network architecture 14 that follows the boundary condition. Subsequently, in the training step 130, the determined at least one network architecture 14 is trained to generate a trained kNN 10, which can then be output.

[0216] Figure 2 shows exemplary data elements 20, 20', 20", which are part of input data 11. Figure 2 shows three color channels, each corresponding to a data element 20, 20', 20". This means that each color channel, for example, data element 20, comprises a plurality of pixels 23 that specify brightness values. A label 30 is provided for each of the color channels, i.e., for each of the data elements 20, 20', 20". In the illustrated embodiment, the label 30 specifies an image area 32 in which an object 31 is located. Furthermore, a class 33 is assigned. This means that the label 30 provides information about the position in the image, for example, between which pixels, of an object 31 belonging to an object class 33. For example, the class 33 could be called "Vehicle".In another embodiment, it is conceivable that a label 30 is not provided separately for each color channel, but rather that one data element encompasses all three color channels.

[0217] The assigned class 33, or labeling class, can also be part of a class hierarchy 37. Figure 2A shows that a class 33 is a (labeling) subclass of a (labeling) class 34. Figure 2A also shows a further subclass 35. For example, it is conceivable that class 34 indicates a "damage" and subclasses 33 and 35 indicate a specific "damage," e.g., "dents" or "scratches." Furthermore, deeper hierarchies 37 are conceivable; that is, subclasses can have further subclasses, e.g., "vehicle" has the subclass "motorized vehicles," and this in turn has the subclass "car." It is further intended that the label 30 not only indicates a class 33, but also implicitly the position in the class hierarchy 37. The class hierarchy 37, or the position within the class hierarchy 37, can then be taken into account when selecting the network parameter values.In particular, this makes it possible to define sub-architectures for individual subclasses 33, 35, and 36, which are assigned to the respective subclasses 33, 35, and 36. For example, the network architecture can have a first sub-architecture designed for detecting objects of subclass 33 in images and a second sub-architecture designed for detecting objects of subclass 36 in images. Thus, a "coarse" and a "specific" detection of objects in images can be implemented. This approach exploits the fact that semantically more general classes tend to be detected more efficiently.

[0218] Fig. 3 shows a schematic representation of a context statement 24. The input data 11 is represented by data elements 20, 20', 20", 20''. The data elements 20, 20', 20", 20'' all show the same object from different perspectives. Context statement 24 groups these data elements 20, 20', 20", 20'' to store the information that all representations depict the same object. In the illustrated embodiment, image data is used. However, it is also conceivable that, for example, audio data could form the data elements, with the context statement indicating that the same sound was recorded by different microphones.

[0219] The context information 24 is provided as part of the input data 11, so that it is taken into account when determining the network architecture 14.

[0220] Figure 4 shows a flowchart for the Determine step 120. The Determine step 120 comprises a Select step 121, in which network parameters 16 are determined taking into account the input data, the predicted data 12, and the target hardware specification 13. This means that in the Select step 121, corresponding values ​​are set for a predefined set of parameters. These network parameter values ​​16 are then used in the Define step 122 to define a network architecture 17. In other words, this means that the network parameter values ​​16 indicate how the network architecture 17 must be designed to be optimal for the input data 11, the predicted data 12, and the target hardware specification 13.

[0221] Figure 4A shows a flowchart for determining sub-architectures when using a class hierarchy 37 in the anticipated data 12. In this case, the selection step 122 also considers the class hierarchy 37, or rather the classes and subclasses 33, 35, 36, and their positions in the class hierarchy 37. Thus, network parameter values ​​16 are selected that correspond to all higher-level classes and the specific class in the class hierarchy 37. For example, if a label exists for the class "Car", network parameter values ​​16 for a higher-level class "Vehicle" are also selected. In the subsequent setting step 122', sub-architectures 17' are generated for each of the relevant classes 33, 35, 36. For example, for the detection of the classes “car” and “vehicle”, two sub-architectures 17’ are created, each of which is trained to detect either “cars” or “vehicles” in image data.It is also provided that each of the individual sub-architectures 17' is assigned available hardware resources, specified by the target hardware specification 13. Thus, it can be determined at this stage which parts of the trained kNN will use specific hardware resources during execution. For example, memory areas or GPU / CPU cycles can be assigned to the sub-architectures 17'.

[0222] After determining the sub-architectures 17', these sub-architectures 17' are used to define the final network architecture 17. The network architecture 17 then encompasses, for example, the sub-architectures 17' completely. Furthermore, the network architecture 17 can either have multiple output layers for displaying the results of the sub-architectures 17', or the outputs of the sub-architectures 17' can be combined in a single output layer of the network architecture 17. Thus, the number of neurons in the output layer, i.e., the number of output values, can depend on the respective class. For example, a feature map with low spatial resolution and a large receptive field can be provided for coarse structures. Conversely, a feature map with a small receptive field and high spatial resolution can be provided for fine structures (e.g., scratches).This can be particularly advantageous if a user or algorithm has specified a restriction regarding the image areas to be examined.

[0223] Figure 4A shows the process of a modified embodiment. In principle, the steps of the method according to Figure 4A are identical to the steps of Figure 1 or Figure 4 and Figure 4A. In contrast to the method 100 according to Figure 1, the method of Figure 4A does not generate a single network architecture, but rather a plurality of network architectures 14'.

[0224] In the procedure shown in Fig. 4B, the selection / prediction 121' of the network parameter values ​​is performed by selecting or determining a multitude of network parameter values ​​16' within a value range or a set of values. The value ranges can be provided by a user as part of the user specification 9. Alternatively, default values ​​can be used. The subsequent definition 122' involves defining a multitude of network architectures 14' using different combinations of network parameter values. Thus, a multitude of network architectures 14' are generated. These network architectures 14' are then trained in the training step 130' to obtain a multitude of trained kNNs 10'.

[0225] To determine which kNN from the set of kNNs 10' is the generated individual kNN 10, the trained kNNs 10' are executed in a subsequent test step 140 on hardware specified by the target hardware specification 13, e.g., a specific GPU. In a verification step 150, it is checked whether the executed kNN is executable on the target hardware, e.g., whether the kNN can be fully loaded into main memory or video RAM. If the executed kNN is executable on the target hardware, the procedure continues with an output step 160 and outputs the executed kNN as the generated individual kNN 10. If the executed kNN is not executable on the target hardware, the procedure continues with test step 140, checking another kNN from the set of kNNs 10'. The order in which the kNNs 10' are executed and tested depends on the complexity of the respective kNNs 10'.Complexity can be specified, for example, by the number of parameters of the respective kNNs, i.e., the number of weights and connections that make up the respective kNN. The number of layers can also be considered. In one implementation, a complexity value is determined and weighted for each property, such as the number of parameters or the number of layers. This allows combinations of complexity values ​​to be used to determine the ranking. It is advantageous to start with the most complex kNN because, if the most complex kNN meets the hardware requirements, the less complex kNNs will also do so, and a complex kNN tends to perform better than a less complex one.

[0226] Fig. 5 shows a flowchart for a method for determining a kNN (kin-nearest neighbors) where an input type determination 111 is performed as part of the loading step 110. The other steps of the method are identical to the method shown in Fig. 1. The input type determination 111 allows an input type 18 to be determined for the input data 11. This means, for example, that it is determined whether the input data is image data, audio data, or tabular data. The input type 18 is then used in the determining step 120 to determine the network architecture 14. Fig. 6 shows an example flowchart for a method 200 for augmenting the input data 11. The method 200 begins with a creation step 210, in which copies of the data elements of the input data 201 are created for input data 11.In the subsequent transformation step 220, a transformation is performed on the copies of the data elements of the input data 201 using a transformation 202. For example, image data can be scaled, rotated, mirrored, or transformed in a similar manner. Furthermore, audio data can be transformed by amplification or other modification. It is also conceivable that filters are applied to the data elements of the input data 11. Subsequently, labels 30' are generated for the now-transformed copies of the data elements of the input data 201 in the generate step 230.

[0227] For this purpose, the labels 30 associated with the input data 11 can be used. These are contained in the anticipated data 12. If, for example, the label 30 of a data element of the input data 11 indicates that an object is located at a specific position in an image, then label 30' can be generated which, through a corresponding transformation, adjusts the position of the object depending on how the transformation was performed on the data element. However, since the transformations 202 are deterministic, it is also possible to transform the labels.

[0228] In the subsequent adding step 240, the generated labels 30' and the copies of the data elements of the input data 211 are added to the anticipated data 12 and the input data 11. Thus, these can be used normally in the further procedure, as shown, for example, in Fig. 1.

[0229] Figure 7 shows a flowchart for the Analyze step 300. In Analyze step 300, the input data 11 and the predicted data 12 can be analyzed. For example, in a Determine Number of Labels step in step 310, a number of labels 311 is determined. This step can refer explicitly to the predicted data 12, but can also be executed in combination with the input data 11. Furthermore, in Determine Number of Objects step 320, a number of objects 321 can be determined that are indicated by the input data 11. The number of objects 321 can correspond to a number of classes, but this is not required. In addition, in Determine Size of Images step 330, the size of the images in the input data 11 can be determined. All images in the input data 11 can have the same size or different sizes.Furthermore, in a determine-filter-change step 340, a filter change 341 can be determined. The number of labels 311, the number of objects 321, the size of objects, and the filter change 341 can then be used in the determine step 121 to determine the network architecture 14.

[0230] Figure 7A shows method 100, where the loading step 110 is modified compared to the method in Figure 1. All further steps are identical to the method in Figure 1. As part of the loading step 110, a regression or classification 112 of the input data 11 is first performed. This regression or classification can, for example, detect objects in an image and segment the image accordingly. Based on the result of the regression or classification, an adjustment 113 of the input data 11 is then performed, whereby the input data 11 is, for example, trimmed to the detected objects. Thus, the input data 11 can be reduced to the relevant areas. During the adjustment 113, the resolution of an image can also be reduced until the classification of the image fails or no longer assigns the correct classes.

[0231] Another possibility for preprocessing the input data 11 is shown in Fig. 7B. Fig. 7B shows the method 100, where the loading step 110 is modified compared to the method in Fig. 1. In the method of Fig. 7B, an anomaly detection 114 is performed on the input data 11. Autoencoders, such as a standard convolutional autoencoder, can be used to determine a reconstruction error. Such an autoencoder is trained before the method is executed using images that do not show any errors. This allows the system to determine which pixels in an image contribute most to an error, indicating, for example, the location of a scratch on an object in the image. With this anomaly detection 114, relevant image areas can thus be identified. In the subsequent adaptation step 113, the input data 11 can be restricted to the areas identified by the anomaly detection 114 for further processing.It is also provided that in an optional assignment step 115 the results of the anomaly detection 114 are used to assign the labels 30 to the input data 11.

[0232] Figure 8 shows an example and schematic representation of a Convolutional Neural Network 400. The Convolutional Neural Network (hereinafter referred to simply as CNN) has seven layers 410, 420, 430, 440, 450, 460, 470. The CNN 400 is divided into three segments. In a first reduction section 401, the size of the input data for each subsequent layer is reduced in each associated layer 410, 420, 430.

[0233] In the enlarging section 402, the size of the input data is increased for each subsequent layer. Section 403 is a decreasing section.

[0234] Figure 8 shows, as an example for layer 410, that the input data size E is 128 * 128. This could refer to a pixel size. More generally, however, it simply denotes the size of the input data for the corresponding layer. Furthermore, in the context of layer 410, it is shown that the input size of 128 * 128 is halved in each dimension. That is, the size is reduced to 128 / 2 * 128 / 2.

[0235] Layer 420 specifies that its input is 64 * 64, which corresponds to the output of layer 410. Layer 410 is further characterized by the number of channels. Specifically, layer 410 has an input channel size of 3 and an output channel size of 16. The output channel size is determined by the function F, which has four parameters. The function F (input channel number, minimum output channel number, maximum output channel number, magnification) calculates the number of channels at the layer's output. The input channel number parameter specifies how many channels the layer has at its input. The minimum output channel number specifies the minimum number of channels the layer's output should have, and the maximum output channel number specifies the maximum number of channels the layer's output may have.

[0236] The enlargement parameter can take the value true or false and indicates whether the number of channels should be increased or decreased. The number of channels can be influenced by matrix folding. As explained in more detail in connection with Figures 10 and 11, sublayers of a layer have corresponding filters that perform matrix folding and thus influence the number of channels.

[0237] Fig. 9 schematically illustrates the structure of a single layer 500.

[0238] Layer 500 comprises an input layer 510, an aggregation layer 520, and an output layer 530. The input layer 510 receives the outputs of a preceding output layer 530' at its input. As can be seen in Fig. 9, a size and number of channels are also determined for the input layer 510. Essentially, the input layer 510 is responsible for scaling the data to the output size of the layer. This is achieved using a function Fg, which halves or doubles the size, depending on the layer type, i.e., whether the layer is an enlarging or a shrinking layer. The number of channels in the input layer is determined by a function FK_e. This means that the function FK_e specifies the number of channels at the output of the input layer. As explained in the context of Fig. 10, a variety of filters are applied in the input layer 510, which vary the number of channels.Therefore, the function FK_e determines the number of channels depending on the filters to be executed in input layer 510.

[0239] The outputs of input layer 510 are combined in an aggregation layer 520 via a connection 501 to another layer, specifically to the output layer 530 of a different layer. This combination can be implemented as a mathematical operation, such as addition, subtraction, division, or multiplication. Logical operators can also be used. The output of the aggregation layer is provided to an output layer 530 of layer 500. The output layer's task is to process the combined data and provide the required number of channels, defined by the function F. No adjustment of the channel size takes place in output layer 530. The output of output layer 530 is then provided to the input layer 510' of a subsequent layer and to the aggregation layer 520 of any subsequent layer.

[0240] Fig. 10 shows a schematic representation of an input layer 510.

[0241] As already mentioned, the input layer 510 receives the outputs from an output layer 530. The data is provided to several filter modules 511-1-1 to 511-nm in the input layer. The filter modules themselves are interconnected in various ways, meaning that the outputs of one filter module can be made available to other filter modules. Filter modules are explained in more detail in Figure 11.

[0242] Figure 11 shows an example of a filter module 511, which consists of a multitude of filters 512-1-1 to 512-nm arranged sequentially and in parallel. A filter is often also referred to as a kernel. A filter is thus a small matrix with learned weights, which is frequently smaller than the size of the input data. This matrix is ​​folded over the input image, i.e., it is shifted over the input image and performs an element-wise multiplication with the sub-area of ​​the image or input data. This operation thus generates a scalar value for this specific sub-area. The filter defines weights that are learned. Each filter can learn different properties of the input data in order to act as a detector for these properties in the calculation of the predicted data.

[0243] Figure 12 shows another kNN, which is essentially identical to the kNN 400 of Figure 8. However, in the kNN 400 of Figure 12, a connecting layer 480 is inserted between layers 430 and 440. Such a connecting layer 480 is shown in more detail in Figure 13. As can be seen, the connecting layer 480 has a connecting input layer 481. The connecting layer also has a plurality of scaling layers 482-1 to 482-m. This allows the data to be processed in parallel and viewed at different resolutions.

[0244] The data is passed to subsequent layers for further processing via a link output layer 483. The inclusion of a link layer can also be specified during the design of the network architecture, for example, by a rule.

[0245] Fig. 14 shows a schematic representation of a structural element 600. The structural element 600 has a plurality of layers 610, 620, 630, 640. The structural element 600 shown in Fig. 14 is a known structure that allows parallel processing of the difference of the input data, which are then combined. Such structural elements can be used to form the network architecture 14.

[0246] Another structural element is shown in Fig. 15. In particular, structural element 700 is shown there, which allows separate processing of input data and a combination of the processed data. The combination can be carried out, for example, by concatenation, addition, or subtraction.

[0247] Figure 16 shows an output scaling layer 800, which can be used to enable different network output elements. The structure of Figure 16 creates multiple scaling layers that scale and process the input data to different sizes. Thus, different scaling options are available at the output of the output scaling layer.

[0248] Figure 17 shows a procedure for creating a rule 900. The procedure begins with the prediction 910 of a network parameter value 902 for a reference data set 901 using a rule 905. The rule 905 can be created manually. Subsequently, the predicted network parameter value 902 is compared with an optimal reference parameter value 903 in a comparison step 920. The comparison can be implemented, for example, by simply calculating the difference between the two values. If the deviation is greater than an optimization threshold 904, the procedure continues with the determination 930 of properties of the reference data set 901. The determined properties of the reference data set 901 determine the selection of the network parameter value 902. Based on the determination of the corresponding properties, the rule 905 is adjusted. The procedure then continues with the prediction step 910.If the comparison shows that the deviation is below the optimization threshold 904, then rule 905 is used as part of the rule set in the use step 940.

[0249] Figure 18 illustrates a system 1000 configured to execute the described methods and concepts. The system 1000 includes a communication unit 1700, which is communicatively connected to a preparation unit 1100. The preparation unit 1100 is communicatively connected to an analysis unit 1400, a network determination unit 1200, and a storage unit 1500. The network determination unit 1200 is further connected to a training unit 1300, which in turn is communicatively connected to an optimization unit 1600. The communication unit 1700 is connected via a communication network 15, for example, the Internet, to a client computer unit 1800, which has a development environment 1810.

[0250] The preparation unit 1100 is configured to load input data 11. Furthermore, the preparation unit 1100 is configured to load predictable data 12 and target hardware specifications. The network determination unit 1200 is configured to determine the network architecture 14, and is configured to execute the procedural steps described in the other figures to determine the network architecture 14. The training unit 1300 is configured to train the determined network architecture 14 to generate a kNN using the input data and the predictable data. The trained kNN can be stored in the storage unit 1500 and transmitted to the client computer 1800 via the communication unit 1700.

[0251] Figure 19 illustrates a computer system 2000, which is configured to implement the procedures described above. The computer system 2000 comprises a storage unit 2100, a processing unit 2200, and a communication unit 2300. The processing unit 2200 is specifically configured to implement all the procedure steps as described above.

[0252] List of references

[0253] 9 User preference

[0254] 10 artificial neural networks

[0255] 10' Variety of artificial neural networks

[0256] 11 Input data

[0257] 12 predicted dates

[0258] 13 Target Hardware Specification

[0259] 14 Network architecture

[0260] 15 Communication network

[0261] 16 network parameter values

[0262] 17' Partial architecture

[0263] 18 Input type 19 Class of labeling

[0264] 20, 20', 20",

[0265]

[0266] 20 data elements

[0267] 22, 22', 22' Color channel

[0268] 23 pixels

[0269] 24 Contextual information

[0270] 30, 30' Labeling / Label

[0271] 31 objects

[0272] 32 image area

[0273] 33rd grade

[0274] 100 procedures

[0275] 110 loading step

[0276] 111 Input type determination

[0277] 112 Regression / Classification

[0278] 113 To adapt

[0279] 114 Anomaly Detection

[0280] 115 Assignment Step

[0281] 120 Determine-Step

[0282] 121 Select-Step

[0283] 122, 122' Set-Step

[0284] 130 Training Step

[0285] 140 Test Step

[0286] 150 test steps

[0287] 160 Output Step

[0288] 200 Augmentation Step

[0289] 201 Copies of the data elements of the input data 202 Transformation

[0290] 210 Generate Step

[0291] 220 Applying a Transformation

[0292] 230 Generate Step

[0293] 240 Add-Step

[0294] 300 Analyze Step

[0295] 310 Determining a number of labels 311 Number of labels

[0296] 320 Determining the number of objects 321 Number of objects

[0297] 330 Determining the size of images

[0298] 331 Size of objects 340 Determining filter changes 341 Filter changes

[0299] 400 Convolutional Neural Network 401 Shrinking Section

[0300] 402 Enlargement Section

[0301] 403 Reducing Section

[0302] 410, 420, 430, shift

[0303] 440, 450, 460

[0304] 500

[0305] 501 Interlayer connection 480 Interlayer connection

[0306] 481 Connection input layer 482-1, 482-m Scaling layer

[0307] 483 Connection output layer 510, Input layer

[0308] 511 Filter module

[0309] 511-1-1,

[0310] 511-1-m

[0311] 511-nl

[0312] 511 nm

[0313] 512 filters

[0314] 512-1-1

[0315] 512-1-m

[0316] 512-nl

[0317] 512 nm

[0318] 520, 520' Aggregation layer

[0319] 530, 530', 530'' Initial layer

[0320] 600 structural elements

[0321] 610, 620, 630, 640 shift

[0322] 650 filters

[0323] 700 structural elements

[0324] 710, 720, shift

[0325] 730, 740, 750

[0326] 760 filters

[0327] 800 Output scaling layer 810 Input layer

[0328] 820-1, 820-m Scaling layer 900 Procedure for creating a rule 901 Reference data set

[0329] 902 Network parameter value

[0330] 903 Reference parameter value

[0331] 904 Optimization threshold

[0332] Rule 905

[0333] 910 Prediction Step

[0334] 920 Compare Step

[0335] 930 Determine-Step

[0336] 940 Use-Step

[0337] 1000 System

[0338] 1100 Preparation unit

[0339] 1200 network determination unit

[0340] 1300 training unit

[0341] 1400 analysis units

[0342] 1500 storage units

[0343] 1600 optimization unit

[0344] 1700 communication unit

[0345] 1800 client computers

[0346] 1810 Development Environment

[0347] 2000 computer system

[0348] 2100 storage unit

[0349] 2200 processing units

[0350] 2300 Communication unit

[0351] E entrances of a shift

[0352] A Exits of a shift

[0353] K channels

Claims

Computer-implemented method for generating an individual artificial neural network, computer-readable storage medium and system Claims 1. Computer-implemented method (100) for generating an individual artificial neural network, kNN, (10, 400) comprising the following: Load (110) of: o Input data (11) comprising data elements (20), e.g. image, audio, sensor and / or tabular data; o predictable data (12) that assign labels (30) to the data elements (20) of the input data (11); o a target hardware specification (13) that specifies for which hardware configuration, e.g. a specific FPGA chip, a maximum possible number of calculations per second, or a specific memory size, the kNN (10, 400) is to be generated; Determining (120) at least one network architecture (14), comprising: o Selecting / predicting (121) network parameter values ​​(16) using the input (11), predicted data (12) and target hardware specification (13); o Defining (122) the network architecture (14) using the network parameter values ​​(16); Training (130) of the specified at least one network architecture (14) to generate a trained kNN (10, 400) using the input data (11) and the predicted data (12).

2. Method (100) according to one of the preceding claims characterized by a generalization of the labels (30) of the predicted data (12) such that only a partial piece of information of each label (30) is used when determining (120) the network parameter values ​​(16) and for training (130).

3. Method (100) according to one of the preceding claims since by means of a sign that The input data includes a context specification, where the context specification can indicate a relationship between individual data elements, e.g., whether a group of data elements shows the same object from different perspectives, and where the selection / prediction of the network parameter values ​​can also be performed using the context specification.

4. Method (100) according to any one of the preceding claims since you don't have a sign, that's it The target hardware specification (13) includes: a calculation type specification that indicates whether calculations should be performed by an accelerator unit or in target hardware; a storage space specification that indicates a maximum usable storage space for parameters of the kNN (10, 400), a calculation specification that indicates a maximum number of calculations per second, a relevance specification that indicates whether precision or recall should be preferred when generating the kNN (10, 400), and / or a training specification that specifies a maximum training time (130) of the kNN (10, 400), a termination condition for training (130), and / or indicates whether models that meet a quality criterion should be cached.

5. Method (100) according to one of the preceding claims characterized by Analyzing (300), in particular before determining (120) the at least one network architecture (14), the input data (11) and / or the predicted data (12), wherein the analyzing (300) includes: Determine (310) a number (311) of labels (30) per class (33) in the foreseen data (12); Determine (320) a number (321) of objects (31) in images; Determine (330) a size (331) of objects (31) in images; and / or Determining (340) filter changes (341), e.g. determining an average brightness value of pixels (23) in an area of ​​an object (31) after applying a high-pass filter, in particular for each color channel (22, 22', 22"), where the determination (120) of the at least one network architecture (14) is also carried out using the results (311, 321, 331, 341) of the analysis (300).

6. Method (100) according to any one of the preceding claims since you don't have a sign, that's it Network parameters (16) include: Information on the input data (11), e.g. image size or data type, wherein the information on the input data (11) is used when determining (120) the at least one network architecture (14) to determine the properties of an input layer (510, 810) of the kNN (10, 400), e.g. number of inputs (E), and / or number of channels (K) of the input layer (51, 810); Information on desired predictions, e.g. image size or data type, wherein the information on the desired predictions is used when determining (120) the at least one network architecture (14) to determine the properties of an output layer (483, 530, 530', 530") of the kNN (10, 400), e.g. number of outputs (A), and / or number of channels (K) of the output layer (483, 530, 530', 530"); Information on shrinking and / or enlarging layers (401, 402), wherein the information on shrinking and / or enlarging layers (401, 402) is used in determining (120) the at least one network architecture (14) to determine the number of shrinking and / or enlarging layers (401, 402), a scaling from the inputs (E) of a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) to the outputs (A) of a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) and / or a number of channels (K); Information for calculating the number of output channels (K), wherein the information for calculating the number of output channels (K) is used when determining (120) the at least one Network architecture (14) can be used to determine the number of channels (K) at the output of a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750), wherein the information for calculating the number of output channels (K) specifies a minimum and / or maximum number of output channels (K), and in particular, a function for calculating the number of channels (K) for a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) is specified. Information on the connection of layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750), wherein the information on the connection of layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) is used in determining (120) the at least one network architecture (14) to determine connections (501) between individual layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750), wherein the connection (501) determines the output of a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) of another layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) is provided, wherein the information on the connection (501) of layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) is an indication regarding the layers to be connected (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) and / or include a layer type,where the layer type is used when determining (120) the at least one network architecture (14) to connect layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) of different types; Information on structural elements (600), wherein the information on structural elements is used when determining (120) the at least one network architecture (14), o to reduce and / or generalize data using a link layer (480), so-called pyramid pooling, o to determine a number of channels (K) at the output of a link layer (480), wherein in particular the number of channels (K) at the output of the link layer (480) is determined as a function of a layer type, and / or o to determine a number of channels (K) of an input layer (510, 810) of a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750), Information on context-dependent structural elements (600), wherein context-dependent structural elements (600) are used in determining (120) the at least one network architecture (14) to use known layer structures, wherein the information on context-dependent structural elements (600) in particular specifies a type of context-dependent structural elements (600) and a number of affected layers (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750); Information for adapting to a computation type on target hardware, wherein the information for adapting to a computation type on target hardware is used when determining (120) the at least one network architecture (14) to adapt a quantization; and / or Information on multiple outputs of the kNN (10, 400), wherein the information on multiple outputs of the kNN (10, 400) is used when determining (120) the at least one network architecture (14) to define different outputs of the kNN (10, 400), wherein the outputs differ in the size of the outputs, i.e., a scaling.

7. Method (100) according to any of the preceding claims, in particular according to claim 6, since you don't have a sign, that's it The definition of at least one network architecture using the network parameter values ​​includes selecting and combining structural elements and / or using the network parameter values ​​as part of a boundary condition of a mathematical optimization procedure.

8. Method (100) according to any one of the preceding claims since you don't have a sign, that's it a layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) of the kNN (10, 400) a multitude of interconnected Sublayers (510, 520, 520', 530, 530', 530") comprise the multitude of sublayers (510, 520, 520', 530, 530', 530"): an input layer (510, 810) that processes the data of a previous layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750), wherein during processing an input layer (510, 810) scaling of input data to the size (G) of an output layer (530, 530', 530") and / or an application of a filter (512, 512-1-1, 512-1-m, 512-nl, 512-nm, 650, 760) that results in an increase or decrease in the number of channels (K), an aggregation layer (520, 520') that receives the data from a connected other layer (410, 420, 430, 610, 620, 630, 640, 710, 720, 730, 740, 750) and combines it with output data from the input layer (510, 810), for example by means of a mathematical operation such as addition, subtraction, multiplication, division, and / or an output layer (530, 530', 530") that processes the combined data from the aggregation layer (520, 520') and / or provides a defined number of channels (K) at its output.

9. Method (100) according to any of the preceding claims, in particular according to claim 7, since you don't have a sign, that's it The selection / prediction (121) of the network parameter values ​​(16) is performed using a rule set, the rule set comprising a plurality of rules (905) which each define network parameter values ​​(16) for at least one of the network parameters for properties of the input data set (11), for properties of the data to be predicted (12) and / or properties of the target hardware (13).

10. Method (100) according to any of the preceding claims, in particular according to claim 8, ge ke n nzei ch net du rc h Assigning a multitude of properties of the input data set (11), properties of the anticipated data (12) and / or properties of the target hardware to thematic groups of network parameters that together define a property of a network architecture (14).

11. Method (100) according to any of the preceding claims, in particular according to claim 9, since you don't have a sign, that's it A rule (905) is assigned to a group of network parameters, which assigns corresponding network parameter values ​​(16) to the network parameters of the group.

12. Method (100) according to any of the preceding claims, in particular according to claim 8, since you don't have a sign, that's it a rule (905) of the rule data set is created by an optimization (900) of network parameters that are intended for input data (11) of a reference data set.

13. Method (100) according to any of the preceding claims, in particular according to claim 8, ge ke n nzei ch net du rc h a rule optimization (900), comprehensive: a) Predictions (910) of a network parameter value (902) for a reference data set (901), which in particular includes reference input data and predictable reference data, using a rule (905); b) Comparing (920) the predicted network parameter value (902) with an optimal reference parameter value (903); c) If the comparison (920) indicates that the predicted network parameter (902) deviates from the optimal reference parameter value (903) by more than an optimization threshold (904): Determine (930) properties of the reference data set (901), in particular the reference input data, which determine the selection of the network parameter value (902) and adapt the rule (905) taking into account the determined properties and repeat steps a) to b) using the adapted rule (905); d) If the comparison indicates that the predicted network parameter (902) deviates from the optimal reference parameter value (903) by less than the optimization threshold (904): Use (940) the optimized rule (905) as part of the rule set.

14. Method (100) according to one of the preceding claims, since by rch ge e ke n nz ch net that ss The training (130) includes determining hardware requirements, e.g., a number of operations per network iteration, RAM requirements and / or VRAM requirements, wherein the procedure (100) further includes determining training data using the hardware requirements, e.g., a batch size, throughput times for a batch, which is used in particular to determine a data set size per epoch.

15. Method (100) according to one of the preceding claims, since by rch g e ke n nz ch net that ss the data to be sent (12) specify at least two label subclasses (33, 35, 36), wherein each label subclass (33, 35, 36) is assigned to a (single) label (30), and thus define a label hierarchy (37), wherein the selection (121) of the network parameter values ​​(16) takes into account the label subclasses (33, 35, 36) and label hierarchy (37), and wherein the specification (122) of the at least one network architecture (17) includes a specification (122') of a sub-architecture for each label subclass (33, 35, 36), wherein the sub-architectures (17') are each trained to assign input data to one of the label subclasses (33, 35, 36) after training.

16. Method (100) according to any of the preceding claims, in particular according to claim 1, since you don't have a sign, that's it Setting is the allocation of available hardware resources to a target hardware specified by the target hardware specification, e.g. Memory areas or GPU / CPU cycles are allocated to each of the sub-architectures, with the sub-architectures being executable by the allocated hardware resources when the trained kNN is run.

17. Method (100) according to any of the preceding claims, in particular according to claim 14, since you don't have a sign, that's it Setting (122) includes determining an output layer taking into account the labeling subclasses, wherein the number of neurons in the output layer depends on the respective labeling subclass.

18. Method (100) according to any of the preceding claims, in particular according to claim 16, since you don't have a sign, that's it Label subclasses each specify an average proportion of an object specified by the label subclass in an input image, whereby a fine output layer, i.e., an output layer with a higher number of neurons that allow for higher spatial resolution, is determined if the average proportion is below a specified threshold, and a coarse output layer, i.e., an output layer with a lower number of neurons that allow for low spatial resolution, is determined if the average proportion is below the threshold.

19. Method (100) according to any one of the preceding claims, characterized by Before loading the input data, the data elements of the input data are cropped to relevant areas, e.g., image areas that have characteristic properties for labeling, e.g., the representation of scratches on surfaces, where the relevant areas are specified in particular by a context statement.

20. Method (100) according to one of the preceding claims, since by rch g e ke n nz ch net that ss The loading includes loading a user specification, wherein the user specification includes at least one architecture parameter, e.g., a size of an output layer, wherein the determination (120) of the at least one network architecture is performed such that the user specification is satisfied in the determined at least one network architecture.

21. Method (100) according to one of the preceding claims, since by rch g e ke n nz ch net that ss • determining (120) the at least one network architecture (14) for each network parameter includes selecting / predicting (121) a plurality of network parameter values ​​(16) in a range or set of values, • defining (122) includes defining a variety of network architectures (17) using different combinations of network parameter values ​​(16), • training (122) includes training the variety of network architectures (17) to generate a variety of trained kNNs (10, 400), the procedure further features: e) Executing a trained kNN from the multitude of trained kNNs on a target hardware specified by the target hardware specification; f) Checking whether the executed kNN is executable on the target hardware, e.g., whether the kNN can be fully loaded into main memory or video RAM; g) Output the executed kNN as a generated individual kNN if the executed kNN is executable on the target hardware; h) Continue the procedure at step e) if the executed kNN is not executable on the target hardware.

22. Method (100) according to any of the foregoing claims, in particular according to claim 20, since you don't have a sign, that's it The steps are performed in a sequence for the trained kNNs that is determined by the complexity of the kNNs, where the complexity is determined in particular by the number of parameters, the number of layers and / or weighted properties of the kNNs, and where the procedure starts in particular with the most complex kNN.

23. Method according to any one of the preceding claims, dadu rc hge mark et that Loading (110) includes adapting (113) the input data (11), e.g. reducing the size of images or lowering the resolution, especially using a context specification.

24. Method according to any of the preceding claims, in particular according to claim 22, dadu rc hge indicates that an adjustment (113) of the input data (11) is specified by a regression or classification unit.

25. Method according to any one of the preceding claims, dadu rc hge mark et that The loading (110) of the anticipated data (12) includes a labeling step, wherein the labeling step includes anomaly detection for the data elements of the input data, and wherein the labels (30) are assigned (115) based on the anomaly detection.

26. Method according to claim 24, dadu rc hge mark et that The adjustment (113) of the input data (11) includes reducing the data elements of the input data (11) to an area identified by the anomaly detection (114).

27. Computer-readable storage medium (2100) containing instructions that cause at least one processor (2200) to implement a method (100) according to any of the preceding claims when the instructions are executed by the at least one processor (2200).

28. System (1000) for generating an individual artificial neural network, kNN, (10, 400), in particular for carrying out a method according to one of claims 1-25, comprising: a preparatory unit (1100) that is trained to o Input data (11) comprising data elements (20, 20', 20", 20''), e.g. image, audio, sensor and / or tabular data; o predictable data (12) that assign labels (30) to the data elements (22) of the input data (11); o a target hardware specification (13) that specifies for which hardware configuration, e.g. a specific FPGA chip, a maximum possible number of calculations per second, or a specific memory size, the kNN (10, 400) should be generated; to load (110); a network determination unit (1200) which is trained to determine at least one network architecture (14) (120), wherein the determination (120) includes: o Selecting / predicting (121) network parameter values ​​(16) using the input (11), predicted data (12) and target hardware specification (13); o Defining (122) the at least one network architecture (14) using the network parameter values; a training unit (1300) which is trained to train the specified at least one network architecture (14) to generate a kNN (10, 400) using the input data (11) and the predicted data (12) (130).

Images