WO2021094597A1 - Mikroskop und verfahren mit ausführen eines faltenden neuronalen netzes - Google Patents

Mikroskop und verfahren mit ausführen eines faltenden neuronalen netzes Download PDF

Info

Publication number
WO2021094597A1
WO2021094597A1 PCT/EP2020/082160 EP2020082160W WO2021094597A1 WO 2021094597 A1 WO2021094597 A1 WO 2021094597A1 EP 2020082160 W EP2020082160 W EP 2020082160W WO 2021094597 A1 WO2021094597 A1 WO 2021094597A1
Authority
WO
WIPO (PCT)
Prior art keywords
filter
learned
matrix
weights
kernels
Prior art date
Application number
PCT/EP2020/082160
Other languages
English (en)
French (fr)
Inventor
Manuel AMTHOR
Daniel Haase
Original Assignee
Carl Zeiss Microscopy Gmbh
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Carl Zeiss Microscopy Gmbh filed Critical Carl Zeiss Microscopy Gmbh
Priority to US17/775,768 priority Critical patent/US20220382038A1/en
Priority to CN202080077686.8A priority patent/CN114846382B/zh
Publication of WO2021094597A1 publication Critical patent/WO2021094597A1/de

Links

Classifications

    • G—PHYSICS
    • G02—OPTICS
    • G02B—OPTICAL ELEMENTS, SYSTEMS OR APPARATUS
    • G02B21/00—Microscopes
    • G02B21/36—Microscopes arranged for photographic purposes or projection purposes or digital imaging or video purposes including associated control and data processing arrangements
    • G02B21/365—Control or image processing arrangements for digital or video microscopes
    • G02B21/367—Control or image processing arrangements for digital or video microscopes providing an output produced by processing a plurality of individual source images, e.g. image tiling, montage, composite images, depth sectioning, image comparison
    • G—PHYSICS
    • G02—OPTICS
    • G02B—OPTICAL ELEMENTS, SYSTEMS OR APPARATUS
    • G02B21/00—Microscopes
    • G02B21/06—Means for illuminating specimens
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F18/00—Pattern recognition
    • G06F18/20—Analysing
    • G06F18/24—Classification techniques
    • G06F18/241—Classification techniques relating to the classification model, e.g. parametric or non-parametric approaches
    • G06F18/2413—Classification techniques relating to the classification model, e.g. parametric or non-parametric approaches based on distances to training or reference patterns
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/04—Architecture, e.g. interconnection topology
    • G06N3/045—Combinations of networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/08—Learning methods
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
    • G06V10/00—Arrangements for image or video recognition or understanding
    • G06V10/70—Arrangements for image or video recognition or understanding using pattern recognition or machine learning
    • G06V10/82—Arrangements for image or video recognition or understanding using pattern recognition or machine learning using neural networks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
    • G06V20/00—Scenes; Scene-specific elements
    • G06V20/60—Type of objects
    • G06V20/69—Microscopic objects, e.g. biological cells or cellular parts
    • G06V20/698—Matching; Classification
    • G—PHYSICS
    • G02—OPTICS
    • G02B—OPTICAL ELEMENTS, SYSTEMS OR APPARATUS
    • G02B21/00—Microscopes
    • G02B21/06—Means for illuminating specimens
    • G02B21/08—Condensers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N3/00—Computing arrangements based on biological models
    • G06N3/02—Neural networks
    • G06N3/08—Learning methods
    • G06N3/082—Learning methods modifying the architecture, e.g. adding, deleting or silencing nodes or connections

Definitions

  • the present disclosure relates to a method in which a convolutional neural network is carried out.
  • the invention also relates to a machine-readable storage medium and a microscope which is set up to carry out the method.
  • CNN Convolutional Neural Networks
  • Examples are image processing, segmentation or classification of images or object recognition in images.
  • the neural network can be part of a machine learning algorithm, in particular a deep learning algorithm.
  • a microscope with a trained deep neural network for image processing is described in US 2019/0 333 199 A1, for example.
  • Input data for the neural network can be images or can be obtained from images that were recorded with a microscope of a sample to be examined.
  • a generic microscope comprises: a light source for illuminating a sample to be examined; an objective for relaying detection light from the sample; a camera for taking a microscope image using the detection light coming from the lens; and a computing device which is set up to process the microscope image and output an image processing result.
  • a generic method comprises the execution of a convolutional neural network, an output tensor being calculated from an input tensor with the aid of a first filter or convolution layer.
  • the first convolution layer comprises one or more filter kernels.
  • an input tensor is understood to be a multidimensional array of data to which a calculation for generating the output sensor is applied. In the case of a three-dimensional input tensor, this can, for example, correspond to a number of N two-dimensional matrices of input data.
  • the input tensor can also be referred to as an activation map (English: Feature Map).
  • the number of dimensions of the input tensor can in principle be arbitrary or greater than / equal to three.
  • the input tensor can be formed by predefined input data which are present in one or more lists or are formed from these.
  • a depth of the input tensor can also be referred to as the number of channels.
  • an input tensor can be an image in which the channels correspond to different colors; in particular, there can be three channels for RGB colors. In later layers of a CNN, the depth of the entrance tensor is usually much higher, for example greater than 100 or 1000.
  • the filter kernel or kernels can also be referred to as a filter, kernel, filter kernel or, in the case of a 3D filter kernel, as a convolution / filter matrix with a depth N (that is to say a number of N two-dimensional filter matrices).
  • the term convolution / filter matrix is intended to clarify that mathematically a convolution is to take place with the input tensor, in particular a discrete convolution.
  • an inner product of the filter kernel can be calculated with a currently underlying section of the input tensor in order to calculate a value of the output sensor.
  • the method of calculating the convolution per se can take place in various ways, for example a matrix of the input tensor can first be converted into a vector, which is offset against a matrix formed from the filter kernel or a vector formed therefrom.
  • a convolution layer 100 ′ of a convolutional neural network according to the prior art is described with reference to FIG. 1.
  • Figure 1 shows schematically an input tensor 10 'which is convoluted with M number of filter kernels in 12A-12M, whereby the output tensor 20' is calculated.
  • the input tensor 10 ' has the dimensions C c U c N, that is to say a number of Y rows, X columns and a depth of N, that is to say N different two-dimensional XxY positions.
  • Each of the M filter kernels 12A-12M has the dimensions K c K c N, that is to say a number of N layers of two-dimensional K c K matrices.
  • K c K c N that is to say a number of N layers of two-dimensional K c K matrices.
  • a 3x3 matrix or 5x5 matrix is often used, where N can be significantly greater than K, for example greater than 100 or 1000.
  • the output tensor 20' is generated, which in the example shown has the dimensions X * Y * M.
  • the depth of the output sensor 20 ' is determined by the number of filter cores in M.
  • the convolution calculation is carried out in a known manner, for example as shown in FIG. 8-9 of DE 102017 113 733 A1 and briefly described below:
  • Each XxYx1 position of the output sensor is calculated by one of the filter kernels 12A-12M from FIG.
  • Each of the K c K c 1 filter layers of this filter kernel (or their reflection) is multiplied by a section of the corresponding position of the input tensor.
  • the position of the section of the input tensor used corresponds to the position of the calculated value in the output tensor.
  • the filter kernel By sliding the filter kernel over the input tensor 10 ', the various values of a C c U c 1 position of the output sensor 20' are calculated.
  • the total number of values / entries of the filter kernels 12A-12M is here K * K * N * M.
  • This number of values are the parameters that are to be determined on the basis of training data in a machine learning algorithm.
  • a learned machine learning algorithm in which the values of the filter kernels were determined, can then be applied to an input tensor in order to process this data or evaluate.
  • the number of parameters K * K * N * M to be learned can be very high, for example greater than 100,000. This large number of parameters to be determined increases the computing and hardware requirements. Even if dedicated hardware is used for these calculations, the time required remains a relevant factor.
  • Macro-architecture adaptation [6]; Post-processing of a trained model, e.g. a compression in which model parameters are quantized or a pruning in which negligible components of a CNN are removed.
  • a trained model e.g. a compression in which model parameters are quantized or a pruning in which negligible components of a CNN are removed.
  • Post-processing Networks generated by pruning do not get any better than architectures of comparable size.
  • pruning, compression or scaling down the architecture usually results in a loss of performance.
  • a parameter reduction can be achieved with the same or even improved performance. This can be explained by the positive regularization effect, which prevents over-adjustment, e.g. in the case of very deep networks [2, 8]. This is particularly useful for small data sets.
  • FIG. 3 shows an input tensor 10 'from N-positions of two-dimensional matrices 10 ⁇ to 10'N, from which an output tensor 20' with M-positions of two-dimensional matrices 20 ⁇ to 20'M is to be calculated by convolution calculations.
  • DSC Depthwise Separable Convolutions
  • Each filter kernel 13A-13N has a depth of 1 and is therefore a K c K matrix, for example a 5x5 matrix.
  • the intermediate tensor 14 is now folded / matrix-multiplied with a 1 c 1 c N filter kernel 16A, with which a layer 20 ⁇ of the output sensor 20 'is calculated.
  • filter kernels 16A-16M used to calculate the M-positions 20 ⁇ to 20'M of the output sensor 20 'from the intermediate tensor 14.
  • the value of M can be set arbitrarily according to the desired depth of the output sensor 20 '.
  • all filter kernels 13A-13N of the first convolution process and one of the filter kernels 16 of the second convolution process are used. All entries of the filter kernels used here are parameters to be learned.
  • the different layers of the output sensor 20 are computed with the same filter kernel in 13A-13N of the first convolution process. This creates a dependency between the various layers 20 ⁇ to 20’M of the
  • Output sensor 20 generated.
  • the number of parameters to be learned is K * K * N + N * M and is thus lower than in the case of FIG. 1 if there all entries of the filter kernels 12A-12M are parameters to be learned, that is to say K * K * M * N parameters.
  • the intermediate tensor does not have the depth D m , but D m * K m . Otherwise, the
  • a method for processing microscope images, a computing device and a microscope can be regarded as an object of the invention specify which can determine an image processing result from the microscope image, in particular a classification, image segmentation or object identification, particularly robustly with the help of a folding neural network, and generalizability to unseen microscope images is particularly high.
  • At least one of the filter kernels can be represented by at least one filter matrix with learning parameters and dependent filter matrices with implicit parameters, which are determined by means of the learning parameters (the filter matrix of this filter kernel) and one or more weights to be learned.
  • Program code is stored on a machine-readable storage medium of the invention which is set up to cause the method according to the invention to be carried out when executed by a computing device.
  • the computing device is set up according to the invention to calculate an input tensor from a recorded microscope image and to carry out the method according to the invention.
  • a position of the output sensor is calculated by a filter kernel which comprises a K * K * 1 filter matrix with parameters to be learned, while the other positions of this filter kernel are dependent on the K * K * 1 filter matrix, for example by each Position is formed by a factor to be learned multiplied by the mentioned K * K * 1 filter matrix.
  • a position of the output sensor is calculated with the aid of the filter kernels 13A-13N, which are independent of one another; their values are learned freely from one another.
  • the invention thus uses a parameter reduction within a filter kernel which is used to calculate a position of the output sensor (intrakernel parameter reduction), with which the experimentally observed redundancies or dependencies can be used.
  • intrakernel parameter reduction the different positions of the output sensor are calculated by the same filter kernels 13A-13N.
  • the reduced number of parameters to be learned not only enables faster calculations, but can also improve the robustness of a machine learning algorithm, especially with smaller amounts of training data.
  • the parameter reduction acts as a kind of regularization, which counteracts an overadaptation of the neural network to training data.
  • 1x1 grouped conversions can be used for efficient calculation options, which offer immense speed advantages compared to standard convolution layers.
  • An optional visualization of deep neural networks is also made easier due to the reduced number of parameters.
  • parameters are sometimes reduced by post-processing. The resources required for training (memory, time, energy) remain unchanged.
  • only a smaller number of parameters have to be learned from the start, so that only a fraction of the computational effort is required during the training phase.
  • the filter matrix with learning parameters denotes a matrix of a filter kernel, for example a 2D matrix of a 3D filter kernel. Higher dimensions are also possible, with a convolution / filter matrix in the name used here being a layer of a filter kernel.
  • the learning parameters designate parameters whose values are to be learned using training data using a machine learning algorithm.
  • the number of parameters (learning parameters) can be exactly the same as the size of the matrix, so in the case of a 3 * 3 matrix there can be nine learning parameters.
  • Other matrices of this filter kernel should now be dependent on this filter matrix with learning parameters and are therefore referred to as “filter matrices with implicit parameters”.
  • the designation "implicit parameters" is intended to make it clear that these parameters are not learned independently / freely from one another. Rather, the implicit parameters are described with a mathematical dependency on the filter matrix with learning parameters, with at least one weight to be learned also being included. For example, the filter matrix with learning parameters can be multiplied by a weight to be learned in order to form one of the filter matrices with implicit parameters. In the case of 3x3 filter matrices, this example means that a filter matrix with implicit parameters contains a total of 9 values / entries, but is only defined by a single weight value to be learned and by the 3x3 filter matrix with learning parameters.
  • the multiplication of a weight to be learned by the filter matrix with learning parameters should only be understood as an exemplary embodiment. Other mathematical links are also possible. In addition, advantages of the invention are at least partially achieved with only a slight reduction in the number of parameters to be learned. An upper limit for the number of weights to be learned can therefore be set such that the number of all weights to be learned plus the number of all learning parameters is smaller than the size of the affected or all of them Filter kernel.
  • the “size” of the filter kernel is intended to denote the number of its entries, in the example of FIG. 1 a filter kernel thus has a size of K * K * N and the size of all M filter kernels together is K c K c N c M.
  • each of these filter kernels uses at least one (or exactly one) filter matrix with learning parameters, it being possible for the filter matrices with learning parameters of different filter kernels to be independent of one another.
  • M filter kernels of size K c K c N there can thus be, for example, M filter matrices with K * K learning parameters.
  • Weights to be learned are used to determine the remaining filter matrices ("dependent filter matrices") together with the filter matrices with learning parameters.
  • the same learning parameters can be used for different filter matrices in order to further reduce the number of parameters to be learned.
  • At least one of the filter kernels can be “represented” in the manner described with a filter matrix with learning parameters and by means of weights to be learned.
  • This is understood to mean various concrete mathematical formulations or methods of calculation which, as a result, are the same as the filter kernel described and can therefore also be represented by such a kernel.
  • one of the filter kernels or each filter kernel can be formed by a body to be folded with the input tensor, the body being formed by the at least one filter matrix with learning parameters and the weights to be learned. If the learning parameters and the weights are known or specified, each entry of this body is completely defined.
  • a body is understood here to be a multidimensional block of numbers.
  • one of the described filter kernels (or each of the filter kernels in each case) is implemented by at least a first body (learning parameter body) and a second body (weight body), which are calculated, in particular, convolved, one after the other with the input tensor.
  • the first body comprises or is formed by the filter matrix with learning parameters and in particular none of the weights to be learned.
  • all layers can be the same as the filter matrix mentioned with the learning parameters, or the same K c K c 1 filter matrix with learning parameters is always used for the convolution calculation.
  • the second body comprises or is formed by (alone) the weights to be learned and not by the learning parameters.
  • the weight field can thus be a vector of the form 1 c 1 * N.
  • the two bodies can now be folded with the input tensor, whereby the order of the two convolution calculations is in principle arbitrary. For the purposes of this invention, the use of two such bodies is viewed as a possible representation of the aforementioned filter kernel.
  • the second field which contains the weights to be learned, can be multiplied by the input tensor (convolution with a 1 c 1 c N field); if the input tensor has the size C c U c N, then each XxYx1 position of the input tensor is multiplied by a weight, i.e. each entry of a C c U c 1 position is multiplied by the same weight and different C c U c 1 - Depending on the variant of the invention, layers can be multiplied with different weights or (partially) the same weight.
  • a convolution then takes place with the first body, which in principle can be formed solely by a KxK filter matrix or by a K c K c N filter matrix in which each KxKx1 layer is the same.
  • the N positions of the input tensor multiplied by the weights can first be added together to form a C c U c 1 -field, possibly still calculating a convolution with a K c K c 1 filter matrix (which can contain the learning parameters) is.
  • the C c U c N input tensor with the K c K c 1 filter matrix with learning parameters or with the K c K c N filter matrix in which every K c K c I position is the same can, folded layer by layer, that is, each C c U c I layer of the input tensor is convoluted with the K c K c 1 filter matrix, so that the resulting body has a depth of N; this is then folded point by point with the 1 c 1 c N weight body, so that the resulting body has a depth of 1 and thus forms a layer of the output sensor.
  • one of the dependent filter matrices is formed by multiplying one of the weights to be learned by the filter matrix with learning parameters.
  • the same weight is multiplied by each learning parameter.
  • the weight is included via an activation function, that is, over a non-linear function such as a sigmoid function, e.g. an arctangent function.
  • the weight can be the argument of the activation function and the result of this is offset against a filter matrix with learning parameters, eg multiplied in order to define a dependent filter matrix.
  • the argument of the activation function can be formed from offsetting, for example multiplication, a weight and a learning parameter, and the result of the activation function is an entry (implicit parameter) of one of the dependent filter matrices.
  • the entries of the output sensor are entered into the activation function and a tensor calculated with this is output as the result of this convolution layer.
  • the weights to be learned are intended to establish a correlation between the different layers of a filter kernel.
  • the weights thus create a dependency between different layers of a filter kernel.
  • a number of weights of all filter kernels to be learned plus a number of all learning parameters is smaller than a total number of elements of all filter kernels.
  • the number of weights to be learned per filter kernel can be selected to be less than or equal to the number of dependent filter matrices of this filter kernel. In this way, exactly one weight to be learned can be used per dependent filter matrix by one of the filter kernels; alternatively, for example, the same weight to be learned is used for several of the dependent filter matrices of the same filter kernel.
  • each filter kernel comprises only a single filter matrix with learning parameters or also two or more filter matrices with learning parameters. All other dependent filter matrices of this filter kernel can each be defined by a weight to be learned and the filter matrix with learning parameters several weights that are offset against the filter matrices with learning parameters. It can also be provided that the same weight to be learned is used for all or some of the dependent filter matrices of one of the filter kernels.
  • the dependent filter matrices of this filter kernel can be formed by a combination of the filter matrices with learning parameters linked to the weights.
  • a dependent filter matrix can be represented as a linear combination of two or more filter matrices with learning parameters, which are each multiplied by a weight.
  • the remaining filter kernels can be formed in the same way or can differ in their number of filter matrices with learning parameters.
  • the filter matrices with learning parameters of different filter kernels of the same convolution layer can be different or independent of one another.
  • at least one of the filter kernels can also not have its own filter matrix with learning parameters, but instead be formed as a function of one or more filter matrices with learning parameters from one or more of the remaining filter kernels.
  • different filter kernels can also share filter matrices with learning parameters and additionally comprise different filter matrices with learning parameters.
  • the same weight to be learned can optionally be used for a dependent filter matrix of several or all filter kernels. This further reduces the number of parameters to be learned and the robustness in machine learning applications can be further increased.
  • convolution layers are used, in particular for deep learning implementations. At least some of the folding layers are formed as described for the first folding layer. Various of the designs described here can be selected for different folding layers.
  • a second input tensor for a second convolution layer is formed from the output tensor of the first convolution layer. In principle, the output tensor can be used directly as a second input tensor, but optional intermediate layers can also be used, for example an activation layer and / or a pooling layer.
  • the pooling layer If the pooling layer is applied to the output tensor or a tensor formed from it, it forms a value for a new tensor from several neighboring values, which can be the second input tensor or from which the second input tensor is calculated. For example, in average pooling, an average is formed from several neighboring values and transferred to the new tensor. In the case of max pooling, a respective maximum value from several neighboring values is transferred to the new tensor. In this way, a certain translational invariance with regard to features in the input tensor can be achieved.
  • the second convolution layer comprises a plurality of filter kernels which are referred to as second filter kernels to distinguish them from the filter kernels in the first convolution layer.
  • a second output tensor is calculated from the second input tensor.
  • At least some of the weights of the filter kernels of the first convolution layer to be learned can at the same time also be used as weights for determining dependent filter matrices of the second filter kernels. In this way, a further reduction in parameters is possible.
  • the filter kernels of the first and second convolution layers can generally have different depths. In order to use common weights, it is therefore expedient to adapt the weights of the first folding layer to a different depth of the second folding layer.
  • the weights for a second filter kernel of the second convolution layer can be formed by linear combinations of the weights that are used along a depth in the first convolution layer. For example, if the filter kernels of the first convolution layer have the depth N and the second filter kernels the depth 2N, a mean value of these can be inserted between two weights, which generates a weight vector of depth or size 2N and the local sequence of the weights for the second Folding layer / filter layer is preserved.
  • the learning parameters can be the entries of a filter matrix with learning parameters, but alternatively the entries of this filter matrix can also be formed only with the aid of the learning parameters. For example, two entries in this filter matrix can be determined by the same learning parameter or entries in this filter matrix can be formed by linear combinations of the learning parameters.
  • the learning parameters and the weights to be learned do not have to be determined directly with the aid of training data. Rather, it is also possible to derive values for the learning parameters and the weight to be learned from the filter kernel of a conventional, already trained machine learning algorithm. For example, by means of a data adaptation with the aid of a loss function or a regression adaptation, values of the learning parameters and weights to be learned can be determined with which the filter kernels of the machine learning algorithm already trained can be simulated as authentically as possible.
  • pruning can also be used: Here, initially determined values of the weights are thinned out, that is, as many entries as possible in the associated weight matrix are set to 0. This reduces the complexity of the weight matrix and speed advantages can be achieved.
  • Possible applications of a machine learning algorithm that uses the method described here include image analysis or also speech, text or audio processing.
  • the output sensor mentioned here can be passed on to one or more deeper layers of the neural network, the end result being, for example, a result image, a classification, segmentation, object identification, information message to a user or a control command.
  • the control command can in particular be a control command for a measuring device, for example a microscope, with which the image was recorded.
  • Fig. 1 is a schematic representation of a prior art convolution layer
  • FIG. 2 is a schematic representation of a filter kernel of FIG.
  • FIG. 3 is a schematic illustration of a convolution calculation according to FIG.
  • FIG. 4 is a schematic representation of one embodiment of a folding layer used in accordance with the present invention.
  • Fig. 5 is a schematic representation of a filter kernel of Fig. 4.
  • FIGS. 6-10 are each a schematic representation of weights for determining the filter kernels from FIG. 4;
  • Fig. 11 is a table for explaining the number of parameters to be learned in machine learning applications.
  • Fig. 12 is a schematic representation of an embodiment of a microscope according to the invention.
  • FIG. 4 illustrates an exemplary embodiment of a method according to the invention in which a folding neural network is carried out.
  • the neural network can be part of a machine learning algorithm.
  • a first convolution layer 100 of the neural network which calculates an output tensor 20 from an input tensor 10, is shown schematically.
  • the designation first convolution layer 100 is not intended to define that this is the first convolution layer of the neural network that is used; rather, other convolution layers can be implemented before the illustrated first convolution layer 100.
  • the first convolution layer 100 comprises a plurality of filter kernels 15A to 15M. A convolution is calculated from each of the filter kernels 15A to 15M with the input tensor 10 so as to form the output tensor 20.
  • the input tensor 10 can be identical or identical to the input tensor 10 ′ from FIG. 1.
  • the output sensor 20 has the dimensions Y1 * X1 * M, where Y1 and X1 can be identical to or different from the dimensions Y and X of the input sensor 10.
  • the sizes of Y1 and X1 can depend on a padding or stride, for example, where a padding describes adding numbers (e.g. zeros) to the input tensor for the convolution calculations and where a stride describes a jump / step size in the convolution calculation.
  • the filter kernels 15A to 15M each have the dimension K c K * N.
  • the filter kernels 15A to 15M can in principle have different values for K or K1 and K2.
  • FIG. 5 illustrates the K * K * N entries / elements of the filter kernel 15A and the corresponding entries of the filter kernel 15M from FIG. 4.
  • a filter matrix or filter layer 15A1 of the filter kernel 15A is formed from learning parameters L1-L9. Values for the learning parameters L1-L9 are learned in a training step of the machine learning algorithm on the basis of training data.
  • the remaining filter matrices 15A2 to 15AN represent dependent filter matrices which are formed from implicit parameters P1-P9, PT-P9 ', ..., R-R9 ". These implicit parameters are not learned as freely determinable values through a training step of the machine learning algorithm.
  • weights W (Wi, 2, Wi, 3, WI, N).
  • the weights W are multiplied by the filter matrix 15A in order to form the dependent filter matrices 15A2 to 15AN.
  • Each of the filter kernels 15A-15M can thus be represented as:
  • the weights W are learned in a training step of the machine learning algorithm.
  • the number of parameters for which values are to be learned in a training step are therefore only K * K + N for the filter kernel 15A, which is considerably less than the number of its elements, ie K * K * N.
  • the above descriptions can also apply analogously to the other filter kernels, in particular to the filter kernel 15M shown in FIG. 5 with the learning parameters L11-L19 and the implicit parameters P11-P19, P11'-P19 ', ..., P11 "-P19 “, Which are defined by the weights W M, 2 , W M, 3 , ..., WM , N.
  • the first column of weights (Wi , i , ..., WM , I) can also be omitted or set to a constant value, so that the number of parameters to be learned per filter kernel is not K * K + N but K * K + N -1 is.
  • Which of the layers of the filter kernels 15A ... 15M is a filter matrix with learning parameters L1-L9 can in principle be chosen arbitrarily, and this does not have to be the first layer of the filter kernel.
  • weights is often used for the learning parameters L1-L9 in relation to the filter kernel.
  • the weights are therefore directly the entries of a filter kernel, whereby the number of such weights in the prior art is usually equal to the number of elements of the filter kernel, i.e. K * K * N.
  • the weights W in the invention do not form the Entries of the filter kernel 15A, but are offset against the convolution matrix 15A1, which contains the learning parameters L1-L9, in order to form entries in the filter kernel 15A.
  • the filter kernel 15A from FIG. 5 can be similar to the filter kernel from FIG. 2, but the number of mutually independent parameters of the filter kernel is significantly reduced.
  • the remaining filter kernels of the convolution layer 100 can be formed in the same way as the filter kernel 15A.
  • all entries in the weight matrix W are freely learnable parameters.
  • the filter kernels 15A-15M are thus independent of one another.
  • the number of weights to be learned for the convolution layer 100 is thus N * M or (N-1) * M if the weights for the filter kernel 15A, for example, run from Wi , 2 to WI , N, as shown in FIG.
  • the total number of parameters to be learned of the convolution layer 100 comprises the stated number of weights to be learned plus the number of learning parameters, which can be K 2 * M here.
  • Fig. 7 shows an example of the weight matrix W with all weights set to the same value.
  • This constant can be a parameter to be learned or a fixed number.
  • many operations can be simplified, accelerated, or even eliminated entirely.
  • the result is an extreme saving in parameters and time.
  • the number of parameters is reduced by a factor of 75 or more, depending on the CNN architecture. Due to the strong parameter reduction, a model with this convolution layer is no longer as efficient as the original model or a model according to FIG Microscopy environment) a good and usually better generalizability is achieved.
  • gradations are possible in which the number of parameters is smaller than in FIG. 6 and larger than in FIG. 7.
  • a specific channel of the input tensor 10 is thereby weighted equally for all filter kernels 15A-15M. This corresponds to a filter-independent weighting of the input tensor and can in turn be implemented in a memory-efficient and time-efficient manner, in particular with 1x1 convolution in CNNs.
  • This, in turn, can be implemented very efficiently in a CNN, with which, in addition to saving parameters, a significant speed advantage can also be achieved.
  • the entries in matrices A and B are weights / weight parameters to be learned in one training step.
  • the entries of the weight matrix W are thus linear combinations of the weight parameters of the matrices A and B.
  • This design of the weight matrix W is motivated by the observation that in the case of a weight matrix W as in FIG. 6, the learned weights correlate strongly across different filter kernels.
  • M ' is smaller than N, for example smaller than 0.2 * N or smaller than 0.1 * N.
  • M' ⁇ 0.5M can be specified in order to reduce the number of parameters compared to the weight matrix from FIG. 6.
  • ß 7 is the transposed matrix of B, I is the identity matrix and
  • F the Frobenius norm.
  • the regularization loss function is included in the optimization of the CNN training.
  • a type of principal component analysis (PCA) of the weight matrix W is thus learned during training.
  • the weights of the weight matrix W are described by a combination / linear combination of weight parameters.
  • the weight parameters are in one Learning training step.
  • the entries in the weight matrix W need not be representable as a matrix product of two matrices A and B, but can in principle be linked in any other way.
  • FIG. 11 it is compiled for various exemplary weight matrices W how high the number of parameters to be learned is and how great the parameter reduction is compared to a conventional convolution layer (standard CNN) in which the number is K 2 * M * N.
  • weight matrices W in FIGS. 6 to 10 serve to facilitate understanding, it being clear that modifications thereof are also possible.
  • the filter kernels can be defined by: per filter kernel exactly one respective filter matrix with learning parameters or also several filter matrices with learning parameters; and a weight block / weight matrix W with the weights to be learned.
  • the number of weights to be learned can in particular be less than or equal to the total number of dependent filter matrices of all filter kernels.
  • the size (number of entries) of the weight matrix W is greater than the number of weights to be learned, this should be understood to mean that the remaining entries in the weight matrices are defined by constants and / or by a dependency on one or more of the weights to be learned.
  • weights of the matrix B can be used for a plurality of filter layers, while these filter layers comprise matrices A which are different / independent from one another.
  • the microscope 50 comprises a light source 59 and a condenser 60 for illuminating a sample 58, which is positioned on a sample table 53. Detection light emanating from the sample 58 is transmitted along an optical axis 52 an objective 51 to a camera 56 for taking a sample image. An overview camera 57 can optionally also be held above a microscope stand 54, with which an overview image of the sample 58 can be recorded.
  • a computing device 55 is set up to process a recorded microscope image (that is, a sample image or overview image) and from this to form an input tensor which, as described above, is calculated in a neural network of a machine learning algorithm.
  • the computing device 55 is set up to carry out the steps described with reference to FIGS. 4 to 11.
  • the machine learning algorithm can in particular be trained to carry out a classification of the microscope image, in which case possible classes can include, for example, one or more of: sample, background, cover glass, sample vessel, cover glass edge, sample vessel edge, sample carrier label.
  • the machine learning algorithm can be trained to perform segmentation or detection in which, for example, the microscope image is segmented into different areas and / or certain objects in the image are identified and localized, for example sample areas, shadows or light reflections.
  • the machine learning algorithm can also be trained for image-to-image mapping, in which the result is an output image.
  • the computing device 55 can also be used in another microscope which, in contrast to the microscope shown, operates, for example, according to a different measuring principle or is a scanning or electron microscope.
  • a computing device as described here can also be provided in devices other than microscopes for image analysis.

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Multimedia (AREA)
  • Evolutionary Computation (AREA)
  • Health & Medical Sciences (AREA)
  • General Health & Medical Sciences (AREA)
  • Artificial Intelligence (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Computer Vision & Pattern Recognition (AREA)
  • Molecular Biology (AREA)
  • Computing Systems (AREA)
  • Software Systems (AREA)
  • Biomedical Technology (AREA)
  • Data Mining & Analysis (AREA)
  • Optics & Photonics (AREA)
  • Analytical Chemistry (AREA)
  • Chemical & Material Sciences (AREA)
  • General Engineering & Computer Science (AREA)
  • Mathematical Physics (AREA)
  • Computational Linguistics (AREA)
  • Biophysics (AREA)
  • Medical Informatics (AREA)
  • Databases & Information Systems (AREA)
  • Bioinformatics & Cheminformatics (AREA)
  • Bioinformatics & Computational Biology (AREA)
  • Evolutionary Biology (AREA)
  • Image Analysis (AREA)
  • Image Processing (AREA)

Abstract

Ein Verfahren zum Verarbeiten von Mikroskopbildern, um ein Bildverarbeitungsergebnis zu erzeugen, umfasst: Ausführen eines faltenden neuronalen Netzes, wobei eine erste Faltungsschicht (100) aus einem Eingangstensor (10), der aus einem Mikroskopbild gebildet wird, einen Ausgabetensor (20) berechnet. Der Ausgabetensor (20) wird zu einer oder mehreren weiteren Schichten des faltenden neuronalen Netzes gegeben, um das Bildverarbeitungsergebnis zu berechnen. Die erste Faltungsschicht (100) umfasst mehrere Filterkernel (15A-15M). Zumindest mehrere der Filterkernel (15A-15M) sind darstellbar durch jeweils zumindest eine Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) und jeweilige abhängige Filtermatrizen (15A2-15AN, 15M2-15MN) mit impliziten Parametern, welche mittels der Lernparameter (L1-L9, L11-L19) und eines oder mehrerer zu lernender Gewichte (W) bestimmt sind, wobei die Filtermatrizen (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) verschiedener Filterkernel (15A-15M) voneinander verschieden sind und verschiedene Lagen des Ausgabetensors (20) durch verschiedene Filterkernel (15A-15M) berechnet werden.

Description

Mikroskop und Verfahren mit Ausführen eines faltenden neuronalen Netzes
Die vorliegende Offenbarung bezieht sich auf ein Verfahren, bei dem ein faltendes neuronales Netz ausgeführt wird. Außerdem betrifft die Erfindung ein maschinenlesbares Speichermedium und ein Mikroskop, welches zum Ausführen des Verfahrens eingerichtet ist.
Faltende neuronale Netze (englisch: Convolutional Neural Networks, CNN) werden für eine Vielzahl verschiedener Anwendungen eingesetzt. Beispiele sind die Bildverarbeitung, eine Segmentierung oder Klassifizierung von Bildern oder eine Objekterkennung in Bildern. Das neuronale Netz kann Teil eines Maschinenlern algorithmus sein, insbesondere eines Deep-Learning-Algorithmus. Ein Mikroskop mit einem trainierten tiefen neuronalen Netz zur Bildverarbeitung ist z.B. in US 2019 / 0 333 199 A1 beschrieben.
Eingabedaten für das neuronale Netz können Bilder sein oder aus Bildern gewonnen sein, welche mit einem Mikroskop von einer zu untersuchenden Probe aufgenommen wurden. Ein solches gattungsgemäßes Mikroskop umfasst: eine Lichtquelle zum Beleuchten einer zu untersuchenden Probe; ein Objektiv zum Weiterleiten von Detektionslicht von der Probe; eine Kamera zum Aufnehmen eines Mikroskopbildes mit Hilfe des Detektionslichts, das vom Objektiv kommt; und eine Recheneinrichtung, welche eingerichtet ist zum Verarbeiten des Mikroskopbildes und Ausgeben eines Bildverarbeitungsergebnisses.
Ein gattungsgemäßes Verfahren umfasst das Ausführen eines faltenden neuronalen Netzes, wobei aus einem Eingangstensor mit Hilfe einer ersten Filter- oder Faltungsschicht (englisch: Convolution Layer) ein Ausgabetensor berechnet wird. Die erste Faltungsschicht umfasst einen oder mehrere Filterkernel. Im Sinne dieser Offenbarung wird unter einem Eingangstensor ein multidimensionales Array an Daten verstanden, auf welche eine Berechnung zum Erzeugen des Ausgabetensors angewandt wird. Im Fall eines dreidimensionalen Eingangstensors kann dieser beispielsweise einer Anzahl von N zweidimensionalen Matrizen an Eingabedaten entsprechen. Der Eingangstensor kann auch als Aktivierungskarte (englisch: Feature Map) bezeichnet werden. Er kann der von einer vorhergehenden Faltungsschicht erzeugte Ausgabetensor sein bzw. aus einem solchen Ausgabetensor abgeleitet sein, oder auch durch Rohdaten gebildet sein. Die Anzahl an Dimensionen des Eingangstensors kann prinzipiell beliebig oder größer/gleich drei sein. Dabei kann der Eingangstensor durch vorgegebene Eingangsdaten gebildet sein, welche in einer oder mehreren Listen vorliegen oder aus diesen gebildet werden. Eine Tiefe des Eingangstensors kann auch als Anzahl an Kanälen bezeichnet werden. Beispielsweise kann ein Eingangstensor ein Bild sein, bei dem die Kanäle verschiedenen Farben entsprechen, insbesondere können drei Kanäle für RGB-Farben vorliegen. In späteren Schichten eines CNN ist die Tiefe des Eingangstensors meist wesentlich höher, beispielsweise größer als 100 oder 1000.
Die obige Erläuterung des Eingangstensors gilt übertragen auch für den Ausgabetensor (englisch: Output Tensor), welcher häufig als Feature Map bezeichnet wird.
Der oder die Filterkernel können auch als Filter, Kernel, Filterkern oder im Fall eines 3D-Filterkernels als Faltungs-/Filtermatrix mit einer Tiefe N (das heißt eine Anzahl von N zweidimensionalen Filtermatrizen) bezeichnet werden. Der Begriff Faltungs- /Filtermatrix soll verdeutlichen, dass mathematisch eine Faltung (Convolution) mit dem Eingangstensor erfolgen soll, insbesondere eine diskrete Faltung. Hierbei kann ein inneres Produkt des Filterkernels mit einem aktuell unterliegenden Ausschnitt des Eingangstensors berechnet werden, um einen Wert des Ausgabetensors zu berechnen. Die Berechnungsweise der Faltung an sich kann in verschiedener Weise erfolgen, z.B. kann eine Matrix des Eingangstensors zunächst in einen Vektor umgewandelt werden, welcher mit einer aus dem Filterkernel gebildeten Matrix oder einem daraus gebildeten Vektor verrechnet wird. Zum besseren Verständnis wird die Ausführung einer Faltungsschicht 100' eines faltenden neuronalen Netzes gemäß dem Stand der Technik mit Bezug auf Fig. 1 beschrieben.
Fig. 1 zeigt schematisch einen Eingangstensor 10‘, der mit einer Anzahl von M Filterkernein 12A-12M gefaltet wird, wodurch der Ausgabetensor 20' berechnet wird. Der Eingangstensor 10' hat die Dimensionen CcUcN, das heißt eine Anzahl von Y Zeilen, X Spalten und in der Tiefe eine Größe von N, das heißt N verschiedene zweidimensionale XxY-Lagen.
Jeder der M Filterkernel 12A-12M hat die Dimensionen KcKcN, also eine Anzahl von N Lagen aus zweidimensionalen KcK-Matrizen. Häufig wird eine 3x3-Matrix oder 5x5- Matrix verwendet, wobei N wesentlich größer als K sein kann, beispielsweise größer als 100 oder 1000.
Durch Faltung des Eingangstensors 10' mit den M Filterkernein 12A-12M wird der Ausgabetensor 20' erzeugt, welcher im dargestellten Beispiel die Dimensionen X*Y*M hat. Die Tiefe des Ausgabetensors 20' wird dabei durch die Anzahl an Filterkernein M bestimmt. Die Faltungsberechnung erfolgt in bekannter Weise, beispielsweise wie in Fig. 8-9 von DE 102017 113 733 A1 gezeigt und nachfolgend kurz beschrieben: Jede XxYx1-Lage des Ausgabetensors wird durch einen der Filterkernel 12A-12M aus Fig. 1 berechnet. Jede der KcKc1 -Filterlagen dieses Filterkernels (beziehungsweise deren Spiegelung) wird mit einem Ausschnitt der entsprechenden Lage des Eingangstensors multipliziert. Dies erfolgt für alle N Lagen und die jeweiligen Teilergebnisse werden zu einem Skalar addiert. Der verwendete Ausschnitt des Eingangstensors entspricht dabei in seiner Lage der Lage des ausgerechneten Werts im Ausgabetensor. Indem der Filterkernel über den Eingangstensor 10' geschoben wird, werden die verschiedenen Werte einer CcUc1- Lage des Ausgabetensors 20' berechnet. Die Faltung des nächsten der M Filterkernel mit dem Eingangstensor 10' ergibt die nächste CcUcI-Lage des Ausgabetensors 20‘.
Die Gesamtanzahl an Werten / Einträgen der Filterkernel 12A-12M ist hier K*K*N*M. Diese Anzahl an Werten sind die Parameter, die an Hand von Trainingsdaten bei einem Maschinenlernalgorithmus ermittelt werden sollen. Ein angelernter Maschinenlernalgorithmus, bei dem die Werte der Filterkernel festgelegt wurden, kann sodann auf einen Eingangstensor angewandt werden, um diese Daten zu verarbeiten oder auszuwerten. Die Anzahl an zu lernenden Parametern K*K*N*M kann sehr hoch sein, beispielsweise größer als 100.000. Durch diese große Anzahl zu ermittelnder Parameter steigen die Rechen- und Hardwareerfordernisse. Auch wenn dedizierte Hardware für diese Berechnungen verwendet wird, bleibt der benötigte Zeitaufwand eine relevante Größe. Es wäre daher wünschenswert, eine möglichst effiziente Gestaltung von Filterkernein bereitzustellen, welche die im Eingangstensor enthaltenen Informationen gut nutzen und die Gefahr einer Überanpassung an Trainingsdaten bei einem Maschinenlernalgorithmus reduzieren. Zudem sollten möglichst schnelle Berechnungen ermöglicht werden und eine Robustheit gegenüber Variationen der Daten des Eingangstensors bestehen.
Im Stand der Technik werden CNNs beispielsweise in der folgenden Literatur beschrieben:
[1] KRIZHEVSKY, Alex; SUTSKEVER, llya; HINTON, Geoffrey E. Imagenet Classification with deep convolutional neural networks. In: Advances in neural Information Processing Systems. 2012. S. 1097-1105.
[2] CHOLLET, Frangois. Xception: Deep learning with depthwise separable convolutions. In: Proceedings of the IEEE Conference on Computer Vision and pattern recognition. 2017. S. 1251-1258.
[3] IANDOLA, Forrest N., et al. SqueezeNet: AlexNet-level accuracy with 50x fewer Parameters and< 0.5 MB model size. arXiv preprint arXiv: 1602.07360, 2016.
[4] HOWARD, Andrew G., et al. Mobilenets: Efficient convolutional neural networks for mobile Vision applications. arXiv preprint arXiv: 1704.04861 , 2017.
[5] TAN, Mingxing; LE, Quoc V. EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. arXiv preprint arXiv: 1905.11946, 2019.
[6] RASTEGARI, Mohammad, et al. Xnor-net: Imagenet Classification using binary convolutional neural networks. In: European Conference on Computer Vision. Springer, Cham, 2016. S. 525-542.
[7] IOFFE, Sergey; SZEGEDY, Christian. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv: 1502.03167, [8] ZOPH, Barret, et al. Learning transferable architectures for scalable image recognition. In: Proceedings of the IEEE Conference on Computer Vision and pattern recognition. 2018. S. 8697-8710.
[9] TAN, Mingxing, et al. Mnasnet: Platform-aware neural architecture search for mobile. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition. 2019. S. 2820-2828.
In den oben genannten Veröffentlichungen werden insbesondere die folgenden CNNs beschrieben, auf welche nachfolgend näher eingegangen wird:
• Xception [2]
• SqueezeNet [3]
• MobileNet [4]
• EfficientNet [5]
• NasNet / MNasNet [8, 9]
• XNOR-Net [6]
Diese Algorithmen nutzen verschiedene Techniken, um die Parameteranzahl sowie den Rechenaufwand für CNNs zu reduzieren. Diese Techniken lassen sich grob unterteilen in: Anpassungen in der Mikroarchitektur, wobei einzelne Bausteine von CNNs durch andere Bausteine ersetzt werden, z.B. der Einsatz von Depthwise Separable Convolutions [2, 4, 5]; Anpassungen in der Makroarchitektur, wobei die Gesamtarchitektur eines CNNs angepasst wird, z.B. bei einer automatisierten Suche nach neuen Architekturen [4, 5]; Mischungen aus einer Mikro- und
Makroarchitekturanpassung [6]; Nachbearbeitungen eines trainiertes Modells, z.B. eine Kompression, in welcher Modellparameter quantisiert werden oder ein Pruning, in dem vernachlässigbare Bausteine eines CNNs entfernt werden.
Diese Techniken können folgende Nachteile haben:
• Anpassung Mikroarchitektur: Beim Einsatz von Depthwise Separable Convolutions [2, 4, 5] kommt es zu einer ineffektiven Nutzung der Kernel, da jeder nur einen anstatt aller Eingabekanäle faltet. Somit besteht die Gefahr, Redundanzen zu lernen und somit unnötig viele Parameter im Modell zu behalten.
• Anpassung Makroarchitektur: bei der automatisierten Suche nach neuen Architekturen [8, 9] kommt es zu einem extrem hohen Ressourcenverbrauch (beispielsweise von mehreren GPU-Monaten).
• Nachverarbeitung: Durch Pruning erzeugte Netze werden nicht besser als Architekturen vergleichbarer Größe. Darüber hinaus wird durch Pruning, Kompression oder einer Verkleinerung der Architektur meist Performance eingebüßt. Im Gegensatz dazu kann mit der vorliegenden Erfindung, wie sie nachfolgend beschrieben wird, eine Parameterreduzierung bei gleichbleibender oder sogar verbesserter Performance erzielt werden. Dies kann durch den positiven Regularisierungseffekt erklärt werden, welcher eine Überanpassung wie z.B. bei sehr tiefen Netzen [2, 8] verhindert. Dies ist besonders für kleine Datensätze von großem Vorteil.
Zur Abgrenzung der Erfindung gegenüber Depthwise Separable Convolutions (DSC, tiefenweise getrennte Faltungen) des Stands der Technik wird eine DSC mit Bezug auf Fig. 3 beschrieben. Fig. 3 zeigt einen Eingangstensor 10' aus N-Lagen zwei dimensionaler Matrizen 10Ά bis 10‘N, woraus durch Faltungsberechnungen ein Ausgabetensor 20' mit M-Lagen zwei-dimensionaler Matrizen 20Ά bis 20‘M berechnet werden sollen. Dies erfolgt bei DSC nicht durch einen einzigen Faltungsvorgang, sondern durch zwei nacheinander ausgeführte Faltungsvorgänge. Im ersten Vorgang wird jede der N-Lagen des Eingangstensors 10' mit einem jeweiligen Filterkernel 13A- 13N gefaltet, wodurch ein Tensor (Zwischentensor) 14 berechnet wird. Jeder Filterkernel 13A-13N hat eine Tiefe von 1 und ist somit eine KcK-Matrix, z.B. eine 5x5- Matrix. Im dargestellten Fall hat der Eingangstensor 10' eine Tiefe N=3, so dass durch Faltung der ersten Lage 10Ά des Eingangstensors 10' mit dem Filterkernel 13A eine erste Schicht 14A des Zwischentensors 14 berechnet wird; durch Faltung der zweiten Lage 10‘B des Eingangstensors 10' mit dem Filterkernel 13B wird eine zweite Schicht 14B des Zwischentensors 14 berechnet und durch Faltung der dritten Lage 10‘N des Eingangstensors 10' mit dem Filterkernel 13N wird eine dritte Schicht 14N des Zwischentensors 14 berechnet. Der Zwischentensor 14 wird nun mit einem 1 c1 cN Filterkernel 16A gefaltet/matrixmultipliziert, womit eine Schicht 20Ά des Ausgabetensors 20' berechnet wird. Es werden M verschiedene solcher Filterkernel 16A-16M verwendet, um aus dem Zwischentensor 14 die M-Lagen 20Ά bis 20’M des Ausgabetensors 20' zu berechnen. Der Wert von M kann beliebig festgelegt sein, entsprechend der gewünschten Tiefe des Ausgabetensors 20‘.
Um eine Schicht des Ausgabetensors 20' zu berechnen, z.B. die Schicht 20Ά, werden demnach alle Filterkernel 13A-13N des ersten Faltungsvorgangs sowie einer der Filterkernel 16 des zweiten Faltungsvorgangs (nämlich der Filterkernel 16A) genutzt. Alle Einträge der hierbei verwendeten Filterkernel sind zu lernende Parameter.
Die verschiedenen Schichten des Ausgabetensors 20' werden mit denselben Filterkernein 13A-13N des ersten Faltungsvorgangs berechnet. Dadurch wird eine Abhängigkeit zwischen den verschiedenen Schichten 20Ά bis 20’M des
Ausgabetensors 20' erzeugt. Im Beispiel von Fig. 3 beträgt die Anzahl der zu lernenden Parameter K*K*N + N*M und ist somit niedriger als im Fall von Fig. 1 , wenn dort alle Einträge der Filterkernel 12A-12M zu lernende Parameter sind, das heißt K*K*M*N Parameter.
Die Beschreibung eines konkreten Beispiels eines neuronalen Netzes, das Depthwise Separable Convolutions nutzt, findet sich in SIFRE, Laurent; MALLAT, Stephane: "Rigid-motion Scattering for image Classification”, Ph.D. thesis, 2014, http://www.cmapx.polytechnique.fr/%7Esifre/research/phd_sifre.pdf. Wie in der dortigen Fig. 6.3 veranschaulicht, wird die Faltungsberechnung einer einzigen Schicht ähnlich wie bei Fig. 3 der Anmeldung durch zwei aufeinanderfolgende
Faltungsvorgänge ausgeführt. Als Unterschied zu Fig. 3 ist die Anzahl der Filterkernel im ersten Faltungsvorgang allerdings nicht gleich der Tiefe des Eingangstensors (Dm in der dortigen Fig. 6.3), vielmehr gibt es Km mal so viele Filterkernel, womit der
Zwischentensor nicht die Tiefe Dm, sondern Dm *Km hat. Im Übrigen gelten die
Erläuterungen zu Fig. 3 der Anmeldung auch zu dieser Schrift.
Weitere Umsetzungen von faltenden neuronalen Netzen zur Bildverarbeitung sind beschrieben in: GUO, Yunhui, et al.: „Depthwise Convolution is All You Need for Learning Multiple Visual Domains”, arXiv:1902.00927v2, 19.02.2019, https://arxiv.Org/abs/1902.00927.
Als eine A u f g a b e der Erfindung kann angesehen werden, ein Verfahren zum Verarbeiten von Mikroskopbildern, eine Recheneinrichtung und ein Mikroskop anzugeben, welche aus dem Mikroskopbild ein Bildverarbeitungsergebnis, insbesondere eine Klassifizierung, Bildsegmentierung oder Objektidentifikation, mit Hilfe eines faltenden neuronalen Netzwerks besonders robust ermitteln können, und dabei eine Generalisierbarkeit auf ungesehene Mikroskopbilder besonders hoch ist.
Diese Aufgabe wird durch das Verfahren mit den Merkmalen des Anspruchs 1 , die Recheneinrichtung nach Anspruch 14 und das Mikroskop mit den Merkmalen des Anspruchs 15 gelöst.
Vorteilhafte Varianten des Verfahrens, der Recheneinrichtung und des Mikroskops der Erfindung sind Gegenstand der abhängigen Ansprüche und werden außerdem in der folgenden Beschreibung erläutert.
Bei dem Verfahren der oben genannten Art ist erfindungsgemäß mindestens einer der Filterkernel darstellbar durch zumindest eine Filtermatrix mit Lernparametern und abhängige Filtermatrizen mit impliziten Parametern, welche mittels der Lernparameter (der Filtermatrix von diesem Filterkernel) und eines oder mehrerer zu lernender Gewichte bestimmt sind.
Auf einem maschinenlesbaren Speichermedium der Erfindung ist Programmcode gespeichert, der dazu eingerichtet ist, bei Ausführung durch eine Recheneinrichtung das Durchführen des erfindungsgemäßen Verfahrens zu veranlassen.
Bei dem eingangs genannte Mikroskop ist die Recheneinrichtung erfindungsgemäß dazu eingerichtet, aus einem aufgenommenen Mikroskopbild einen Eingangstensor zu berechnen und das erfindungsgemäße Verfahren durchzuführen.
Voruntersuchungen zur Erfindung wurden mit herkömmlichen Filterkernein durchgeführt, in denen sämtliche Einträge frei lernbare Parameter sind. Konkrete Werte dieser Parameter wurden durch einen Trainingsschritt eines Maschinenlern algorithmus ermittelt. Hierbei wurde eine hohe Korrelation zwischen den Parameterwerten verschiedener Lagen / Tiefe (N) ermittelt. Dies ist in Fig. 2 verdeutlicht, welche die N Lagen des Filterkernels 12M aus Fig. 1 zeigt. In diesem Beispiel ist der KcKcN-Filterkernel 12M ein 3x3x22-Filterkernel und verschiedene Graustufen stehen für verschiedene Zahlenwerte. Es ist erkennbar, dass die N Lagen 12M1 bis 12MN an KcKc1 -Filtermatrizen des Filterkernels 12M eine hohe Korrelation zueinander haben. Dieser Zusammenhang konnte für verschiedene Trainingsdatensätze und Maschinenlernanwendungen beobachtet werden. Das Vorliegen einer Korrelation deutet darauf hin, dass die hohe Anzahl voneinander unabhängiger Parameter (bei dem Filterkernel 12M sind dies K*K*N, in Fig. 2 also 3*3*22=198) nicht notwendig sein muss. Vielmehr kann eine Abhängigkeit zwischen einer K*K*1 -Filtermatrix und übrigen Filtermatrizen dieses Filterkernels vorgegeben werden, wodurch bei ähnlichen Resultaten die Anzahl zu lernender Parameter deutlich reduziert werden kann. Diese Abhängigkeit unterscheidet sich von der eingangs zu Fig. 3 beschriebenen Abhängigkeit der Depthwise Separable Convolution Technik. Bei der vorgenannten Erfindungsvariante wird eine Lage des Ausgabetensors durch einen Filterkernel berechnet, welcher eine K*K*1 -Filtermatrix mit zu lernenden Parametern umfasst, während die übrigen Lagen dieses Filterkernels von der K*K*1 -Filtermatrix abhängig sind, z.B. indem jede Lage durch einen zu lernenden Faktor multipliziert mit der genannten K*K*1 -Filtermatrix gebildet wird. Im Gegensatz hierzu wird bei Fig. 3 der Anmeldung eine Lage des Ausgabetensors mit Hilfe der Filterkernel 13A-13N berechnet, welche voneinander unabhängig sind; ihre Werte werden frei voneinander gelernt. Die Erfindung nutzt also eine Parameterreduzierung innerhalb eines Filterkernels, welcher der Berechnung einer Lage des Ausgabetensors dient (Intrakernel-Parameterreduzierung), womit die experimentell beobachteten Redundanzen oder Abhängigkeiten ausgenutzt werden können. Hingegen erfolgt beim Beispiel von Fig. 3 keine Intrakernel-Parameterreduzierung, sondern eine Interkernel- Parameterreduzierung (die verschiedenen Lagen des Ausgabetensors werden durch dieselben Filterkernel 13A-13N berechnet).
Es hat sich gezeigt, dass die reduzierte Anzahl zu lernender Parameter nicht nur schnellere Berechnungen ermöglicht, sondern gerade bei geringeren Trainingsdatenmengen auch die Robustheit eines Maschinenlernalgorithmus verbessern kann. Dies kann dadurch erklärt werden, dass die Parameterreduzierung als eine Art Regularisierung wirkt, welche einer Überanpassung des neuronalen Netzes an Trainingsdaten entgegenwirkt. Für effiziente Berechnungsmöglichkeiten können insbesondere 1x1-Grouped-Convolutions genutzt werden, welche im Vergleich zu Standard-Faltungsschichten immense Geschwindigkeitsvorteile bieten. Auch eine optionale Visualisierung tiefer neuronaler Netze wird aufgrund der reduzierten Parameteranzahl erleichtert. Im Stand der Technik wird teilweise eine Parameterreduzierung durch Nachbearbeitung durchgeführt. Hierbei bleibt der benötigte Ressourcenaufwand für das Training (Speicher, Zeit, Energie) unverändert. Hingegen muss bei der vorliegenden Erfindung aber von Anfang an bloß eine kleinere Parameteranzahl gelernt werden, wodurch während der Trainingsphase nur ein Bruchteil an Rechenaufwand benötigt wird.
In der hier verwendeten Terminologie bezeichnet die Filtermatrix mit Lernparametern eine Matrix eines Filterkernels, beispielsweise eine 2D-Matrix eines 3D-Filterkernels. Auch höhere Dimensionen sind möglich, wobei eine Faltungs-/Filtermatrix in der hier verwendeten Benennung eine Lage eines Filterkernels ist. Die Lernparameter bezeichnen Parameter, deren Werte an Hand von Trainingsdaten durch einen Maschinenlernalgorithmus erlernt werden sollen. Die Anzahl an Parametern (Lernparametern) kann hierbei gerade gleich der Größe der Matrix sein, im Fall einer 3*3-Matrix kann es also neun Lernparameter geben. Andere Matrizen dieses Filterkernels sollen nun abhängig von dieser Filtermatrix mit Lernparametern sein und werden daher als „Filtermatrizen mit impliziten Parametern“ bezeichnet. Die Benennung „implizite Parameter“ soll verdeutlichen, dass diese Parameter nicht unabhängig / frei zueinander gelernt werden. Vielmehr werden die impliziten Parameter mit einer mathematischen Abhängigkeit von der Filtermatrix mit Lernparametern beschrieben, wobei zudem mindestens ein zu lernendes Gewicht eingeht. Beispielsweise kann die Filtermatrix mit Lernparametern mit einem zu lernenden Gewicht multipliziert werden, um eine der Filtermatrizen mit impliziten Parametern zu bilden. Im Fall von 3x3-Filtermatrizen bedeutet dieses Beispiel, dass eine Filtermatrix mit impliziten Parametern insgesamt 9 Werte/Einträge enthält, aber nur durch einen einzigen zu lernenden Gewichtswert sowie durch die 3x3-Filtermatrix mit Lernparametern definiert wird.
Die Multiplikation eines zu lernenden Gewichts mit der Filtermatrix mit Lernparametern soll lediglich als beispielhafte Ausführung verstanden werden. Andere mathematische Verknüpfungen sind ebenfalls möglich. Zudem werden Vorteile der Erfindung zumindest teilweise bereits bei einer nur geringeren Reduzierung der Anzahl zu lernender Parameter erreicht. Eine Obergrenze für die Anzahl an zu lernenden Gewichten kann daher so festgelegt sein, dass die Anzahl aller zu lernender Gewichte plus die Anzahl aller Lernparameter kleiner ist als die Größe des betroffenen oder aller Filterkernel. Die „Größe“ des Filterkernels soll hierbei die Anzahl seiner Einträge bezeichnen, im Beispiel von Fig. 1 hat ein Filterkernel somit eine Größe von K*K*N und die Größe aller M Filterkernel beträgt zusammen KcKcNcM.
Für eine stärkere Reduzierung der zu lernenden Parameteranzahl kann vorgesehen sein, dass nicht nur einer, sondern mehrere oder alle der Filterkernel einer Faltungsschicht in der beschriebenen Weise gebildet sind. Hierbei nutzt jeder dieser Filterkernel jeweils zumindest eine (oder genau eine) Filtermatrix mit Lernparametern, wobei die Filtermatrizen mit Lernparametern verschiedener Filterkernel voneinander unabhängig sein können. Bei M Filterkernel der Größe KcKcN kann es somit beispielsweise M Filtermatrizen mit K*K Lernparametern geben. Zu lernende Gewichte werden verwendet, um zusammen mit den Filtermatrizen mit Lernparametern die übrigen Filtermatrizen („abhängige Filtermatrizen“) zu bestimmen. Optional können hierbei dieselben Lernparameter für verschiedene Filtermatrizen verwendet werden, um die Anzahl zu lernender Parameter weiter zu reduzieren.
Im Sinne der Erfindung ist zumindest einer der Filterkernel in der beschriebenen Weise mit einer Filtermatrix mit Lernparametern und durch zu lernende Gewichte „darstellbar“. Hierunter werden verschiedene konkrete mathematische Formulierungen oder Berechnungsweisen verstanden, welche im Ergebnis dem beschriebenen Filterkernel gleich sind und daher auch durch einen solchen darstellbar sind. So kann einerseits einer der Filterkernel oder jeder Filterkernel durch jeweils einen mit dem Eingangstensor zu faltenden Körper gebildet sein, wobei der Körper durch die zumindest eine Filtermatrix mit Lernparametern und die zu lernenden Gewichte gebildet ist. Bei Kenntnis oder Vorgabe der Lernparameter und der Gewichte ist somit jeder Eintrag dieses Körpers vollständig definiert. Unter einem Körper wird hier ein mehrdimensionaler Zahlenblock verstanden. In einer alternativen Umsetzung wird einer der beschriebenen Filterkernel (oder jeder der Filterkernel jeweils) durch zumindest einen ersten Körper (Lernparameter-Körper) und einen zweiten Körper (Gewichte-Körper) implementiert, welche nacheinander mit dem Eingangstensor verrechnet, insbesondere gefaltet, werden. Dies kann durch eine Depthwise- Convolution (lagenweise Faltung) kombiniert mit einer punktweisen Faltung erfolgen. Der erste Körper umfasst oder wird gebildet durch die Filtermatrix mit Lernparametern und insbesondere keine der zu lernenden Gewichte. Bei einer Tiefe von N können hierbei alle Lagen gleich der genannten Filtermatrix mit den Lernparametern sein, bzw. wird stets dieselbe KcKc1 -Filtermatrix mit Lernparametern für die Faltungsberechnung verwendet. Der zweite Körper hingegen umfasst oder wird gebildet durch (allein) die zu lernenden Gewichte und eben nicht durch die Lernparameter. Bei einem CcUcN- Eingangstensor kann somit der Gewichte-Körper ein Vektor der Form 1 c1 *N sein. Die beiden Körper können nun mit dem Eingangstensor gefaltet werden, wobei die Reihenfolge der zwei Faltungsberechnungen prinzipiell beliebig ist. Im Sinne dieser Erfindung wird die Nutzung zweier solcher Körper als eine mögliche Darstellung des vorgenannten Filterkernels angesehen. Insbesondere kann der zweite Körper, der die zu lernenden Gewichte enthält, mit dem Eingangstensor multipliziert werden (Faltung mit einem 1 c1 cN-Körper); hat der Eingangstensor die Größe CcUcN, so wird jede XxYx1-Lage des Eingangstensors mit je einem Gewicht multipliziert, das heißt jeder Eintrag einer CcUc1 -Lage wird mit demselben Gewicht multipliziert und verschiedene CcUc1 -Lagen können je nach Erfindungsvariante mit unterschiedlichen Gewichten oder auch (teilweise) dem gleichen Gewicht multipliziert werden. Sodann erfolgt eine Faltung mit dem ersten Körper, welcher prinzipiell durch allein eine KxK-Filtermatrix gebildet sein kann bzw. durch eine KcKcN-Filtermatrix, bei der jede KxKx1-Lage hieraus gleich ist. Für eine einfache Berechnungsweise können die mit den Gewichten multiplizierten N Lagen des Eingangstensors zunächst zu einem CcUc1 -Körper zusammenaddiert werden, womit leidglich noch eine Faltung mit einer KcKc1- Filtermatrix (welche die Lernparameter enthalten kann) zu berechnen ist. Bei umgekehrter Reihenfolge der Faltungsoperationen wird zunächst der CcUcN- Eingangstensor mit der KcKc1 -Filtermatrix mit Lernparametern bzw. mit der KcKcN- Filtermatrix, in welcher jede KcKcI-Lage gleich sein kann, lagenweise gefaltet, das heißt jede CcUcI-Lage des Eingangstensors wird für sich betrachtet mit der KcKc1- Filtermatrix gefaltet, womit der resultierende Körper eine Tiefe von N hat; dieser wird sodann punktweise mit dem 1 c1 cN-Gewichtskörper gefaltet, womit der hieraus resultierende Körper eine Tiefe von 1 hat und somit eine Lage des Ausgabetensors bildet.
Bei manchen Erfindungsvarianten wird eine der abhängigen Filtermatrizen durch Multiplikation eines der zu lernenden Gewichte mit der Filtermatrix mit Lernparametern gebildet. Für die verschiedenen impliziten Parameter derselben abhängigen Filtermatrix wird dabei dasselbe Gewicht mit jedem Lernparameter multipliziert. Bei anderen Varianten geht das Gewicht über eine Aktivierungsfunktion ein, das heißt über eine nicht lineare Funktion wie eine Sigmoidfunktion, z.B. eine Arkustangens-Funktion. Das Gewicht kann das Argument der Aktivierungsfunktion sein und das Ergebnis hiervon wird mit einer Filtermatrix mit Lernparametern verrechnet, z.B. multipliziert, um eine abhängige Filtermatrix festzulegen. Alternativ kann das Argument der Aktivierungsfunktion aus Verrechnung, z.B. Multiplikation, eines Gewichts und eines Lernparameters gebildet sein und das Ergebnis der Aktivierungsfunktion ist ein Eintrag (impliziter Parameter) einer der abhängigen Filtermatrizen. In einer weiteren Gestaltung werden die Einträge des Ausgabetensors in die Aktivierungsfunktion eingegeben und ein hiermit berechneter Tensor wird als Ergebnis dieser Faltungsschicht ausgegeben.
Durch die zu lernenden Gewichte soll eine Korrelation zwischen den verschiedenen Lagen eines Filterkernels hergestellt werden. Es wird somit durch die Gewichte eine Abhängigkeit zwischen verschiedenen Lagen eines Filterkernels erzeugt. Dabei soll die Gesamtanzahl zu lernender Werte reduziert sein. Herkömmlicherweise ist diese Gesamtanzahl zu lernender Werte einer Filterschicht meist gleich der Gesamtzahl an Einträgen (=Elementen) aller Filterkernel dieser Filterschicht. Um eine Reduzierung der Anzahl zu lernender Werte zu erreichen, ist eine Anzahl zu lernender Gewichte aller Filterkernel plus eine Anzahl aller Lernparameter kleiner als eine Gesamtzahl an Elementen aller Filterkernel. Für eine stärkere Reduzierung der Anzahl zu lernender Werte kann die Anzahl zu lernender Gewichte pro Filterkernel kleiner oder gleich der Anzahl an abhängigen Filtermatrizen dieses Filterkernels gewählt sein. So kann pro abhängiger Filtermatrix von einem der Filterkernel genau ein zu lernendes Gewicht verwendet wird; alternativ wird z.B. für mehrere der abhängigen Filtermatrizen desselben Filterkernels dasselbe zu lernende Gewicht verwendet.
Nachstehend werden verschiedene Ausführungen beschrieben, die eine wesentliche Reduzierung der Anzahl zu lernender Werte/Parameter bereitstellen und gleichzeitig eine geeignete Abhängigkeit innerhalb der Filterkernel beschreiben, wodurch eine hohe Robustheit in Maschinenlernanwendungen erreicht wird:
Es kann vorgesehen sein, dass jeder Filterkernel nur eine einzige Filtermatrix mit Lernparametern oder auch zwei oder mehr Filtermatrizen mit Lernparametern umfasst. Alle übrigen abhängigen Filtermatrizen dieses Filterkernels können durch jeweils ein zu lernendes Gewicht und die Filtermatrix mit Lernparametern definiert sein bzw. durch mehrere Gewichte, die mit den Filtermatrizen mit Lernparametern verrechnet werden. Es kann auch vorgesehen sein, für alle oder manche der abhängigen Filtermatrizen von einem der Filterkernel dasselbe zu lernende Gewicht zu verwenden.
Wenn zumindest einer der Filterkernel zwei oder mehr Filtermatrizen mit Lernparametern umfasst, können die abhängigen Filtermatrizen dieses Filterkernels durch eine mit den Gewichten verknüpfte Kombination der Filtermatrizen mit Lernparametern gebildet sein. Beispielsweise kann eine abhängige Filtermatrix als Linearkombination aus zwei oder mehr Filtermatrizen mit Lernparametern dargestellt werden, welche jeweils mit einem Gewicht multipliziert sind. Die übrigen Filterkernel können in gleicher Weise gebildet sein oder können sich in ihrer Anzahl an Filtermatrizen mit Lernparametern unterscheiden.
Die Filtermatrizen mit Lernparametern verschiedener Filterkernel derselben Faltungsschicht können voneinander verschieden bzw. unabhängig sein. Alternativ kann auch zumindest einer der Filterkernel keine eigene Filtermatrix mit Lernparametern aufweisen, sondern stattdessen abhängig von einer oder mehreren Filtermatrizen mit Lernparametern von einem oder mehreren der übrigen Filterkernel gebildet sein. Im Fall, dass Filterkernel zwei oder mehr Filtermatrizen mit Lernparametern umfassen, können verschiedene Filterkernel sich auch Filtermatrizen mit Lernparametern teilen und zusätzlich voneinander verschiedene Filtermatrizen mit Lernparametern umfassen.
Dasselbe zu lernende Gewicht kann optional für je eine abhängige Filtermatrix mehrerer oder aller Filterkernel verwendet werden. Hierdurch wird die Anzahl zu lernender Parameter weiter verringert und es kann die Robustheit bei Maschinenlernanwendungen weiter gesteigert werden.
In Varianten der Erfindung werden mehrere Faltungsschichten verwendet, insbesondere für Deep-Learning-Umsetzungen. Zumindest einige der Faltungsschichten werden wie zur ersten Faltungsschicht beschrieben gebildet. Dabei können für verschiedene Faltungsschichten verschiedene der hier beschriebenen Ausführungen gewählt werden. Aus dem Ausgabetensor der ersten Faltungsschicht wird ein zweiter Eingangstensor für eine zweite Faltungsschicht gebildet. Prinzipiell kann der Ausgabetensor direkt als zweiter Eingangstensor übernommen werden, wobei aber auch optionale Zwischenschichten genutzt werden können, beispielsweise eine Aktivierungsschicht und/oder eine Pooling-Layer. Wird die Pooling-Layer auf den Ausgabetensor oder einen hieraus gebildeten Tensor angewandt, so bildet sie aus mehreren benachbarten Werten jeweils einen Wert für einen neuen Tensor, welcher der zweite Eingangstensor sein kann oder aus dem der zweite Eingangstensor berechnet wird. Beispielsweise wird bei einem Average-Pooling ein Durchschnitt aus mehreren benachbarten Werten gebildet und in den neuen Tensor übernommen. Bei einem Max-Pooling wird ein jeweiliger Maximalwert aus mehreren benachbarten Werten in den neuen Tensor übernommen. In dieser Weise kann eine gewisse Translationsinvarianz hinsichtlich Merkmalen im Eingangstensor erreicht werden.
Die zweite Faltungsschicht umfasst mehrere Filterkernel, welche zur Unterscheidung von den Filterkernein der ersten Faltungsschicht als zweite Filterkernel bezeichnet werden. Mit Hilfe der zweiten Filterkernel wird aus dem zweiten Eingangstensor ein zweiter Ausgabetensor berechnet. Zumindest einige der zu lernenden Gewichte der Filterkernel der ersten Faltungsschicht können gleichzeitig auch als Gewichte zur Bestimmung von abhängigen Filtermatrizen der zweiten Filterkernel verwendet werden. In dieser Weise ist eine weitere Parameterreduzierung möglich. Die Filterkernel der ersten und zweiten Faltungsschicht können allgemein verschiedene Tiefen haben. Um gemeinsame Gewichte zu nutzen, ist daher eine Anpassung der Gewichte der ersten Faltungsschicht an eine andere Tiefe der zweiten Faltungsschicht zweckmäßig. Hierfür können durch Linearkombinationen der Gewichte, die entlang einer Tiefe in der ersten Faltungsschicht verwendet werden, die Gewichte für einen zweiten Filterkernel der zweiten Faltungsschicht gebildet werden. Haben beispielsweise die Filterkernel der ersten Faltungsschicht die Tiefe N und die zweiten Filterkernel die Tiefe 2N, so kann zwischen zwei Gewichten jeweils ein Mittelwert aus diesen eingefügt werden, womit ein Gewichtsvektor der Tiefe oder Größe 2N erzeugt wird und die örtliche Reihenfolge der Gewichte für die zweite Faltungsschicht/Filterschicht bewahrt bleibt.
Die Lernparameter können gerade die Einträge einer Filtermatrix mit Lernparametern sein, wobei alternativ aber auch die Einträge dieser Filtermatrix lediglich mit Hilfe der Lernparameter gebildet sein können. Beispielsweise können zwei Einträge dieser Filtermatrix durch denselben Lernparameter bestimmt sein oder Einträge dieser Filtermatrix können durch Linearkombinationen der Lernparameter gebildet sein. Die Lernparameter und zu lernenden Gewichte müssen nicht direkt mit Hilfe von Trainingsdaten ermittelt werden. Vielmehr ist es auch möglich, Werte für die Lernparameter und zu lernenden Gewicht aus den Filterkernein eines herkömmlichen, bereits trainierten Maschinenlernalgorithmus abzuleiten. Beispielsweise mittels einer Datenanpassung mit Hilfe einer Verlustfunktion oder einer Regressionsanpassung können Werte der Lernparameter und zu lernenden Gewichte ermittelt werden, mit denen die Filterkernel des bereits trainierten Maschinenlernalgorithmus möglichst authentisch nachgebildet werden.
Werden die Lernparameter und zu lernenden Gewichte an Hand von Trainingsdaten ermittelt, kann auch ein „Pruning“ genutzt werden: Hierbei werden zunächst ermittelte Werte der Gewichte ausgedünnt, das heißt möglichst viele Einträge der zugehörigen Gewichtsmatrix werden auf 0 gesetzt. Dadurch wird die Komplexität der Gewichtsmatrix reduziert und Geschwindigkeitsvorteile können erzielen werden.
Mögliche Anwendungen eines Maschinenlernalgorithmus, der das hier beschriebene Verfahren nutzt, umfassen die Bildanalyse oder auch Sprach-, Text- oder Audioverarbeitung. Im Rahmen der Bildanalyse kann der hier genannte Ausgabetensor zu einer oder mehreren tieferen Schichten des neuronalen Netzwerks weitergegeben werden, wobei als Endergebnis beispielsweise ein Ergebnisbild, eine Klassifizierung, Segmentierung, Objektidentifikation, Informationsmeldung an einen Nutzer oder ein Steuerbefehl ausgegeben wird. Der Steuerbefehl kann insbesondere ein Steuerbefehl für ein Messgerät sein, beispielsweise ein Mikroskop, mit dem das Bild aufgenommen wurde.
Weitere Vorteile und Merkmale der Erfindung werden nachstehend mit Bezug auf die beigefügten schematischen Figuren beschrieben.
Fig. 1 ist eine schematische Darstellung einer Faltungsschicht des Stands der Technik;
Fig. 2 ist eine schematische Darstellung eines Filterkernels der
Faltungsschicht aus Fig. 1;
Fig. 3 ist eine schematische Darstellung einer Faltungsberechnung gemäß
Depthwise Separable Convolutions des Stands der Technik; Fig. 4 ist eine schematische Darstellung eines Ausführungsbeispiels einer erfindungsgemäß verwendeten Faltungsschicht;
Fig. 5 ist eine schematische Darstellung eines Filterkernels aus Fig. 4;
Fig. 6-10 sind jeweils eine schematische Darstellung von Gewichten zur Bestimmung der Filterkernel aus Fig. 4;
Fig. 11 ist eine Tabelle zur Erläuterung der Anzahl zu lernender Parameter in Maschinenlernanwendungen; und
Fig. 12 ist eine schematische Darstellung eines Ausführungsbeispiels eines erfindungsgemäßen Mikroskops.
Gleiche und gleich wirkende Bestandteile sind in den Figuren in der Regel mit denselben Bezugszeichen gekennzeichnet.
Fig. 4 illustriert ein Ausführungsbeispiel eines erfindungsgemäßen Verfahrens, bei dem ein faltendes neuronales Netz ausgeführt wird. Das neuronale Netz kann Teil eines Maschinenlernalgorithmus sein. Schematisch dargestellt ist eine erste Faltungsschicht 100 des neuronalen Netzes, welche aus einem Eingangstensor 10 einen Ausgabetensor 20 berechnet. Die Bezeichnung erste Faltungsschicht 100 soll nicht definieren, dass es sich hierbei um die zu aller erst angewandte Faltungsschicht des neuronalen Netzes handelt, vielmehr können andere Faltungsschichten vor der dargestellten ersten Faltungsschicht 100 ausgeführt werden. Die erste Faltungsschicht 100 umfasst mehrere Filterkernel 15A bis 15M. Es wird eine Faltung aus jedem der Filterkernel 15A bis 15M mit dem Eingangstensor 10 berechnet, um so den Ausgabetensor 20 zu bilden.
Der Eingangstensor 10 kann gleich oder identisch zum Eingangstensor 10' aus Fig. 1 sein. Der Ausgabetensor 20 hat die Dimensionen Y1 *X1 *M, wobei Y1 und X1 gleich oder verschieden zu den Dimensionen Y und X des Eingabetensors 10 sein können. Die Größen von Y1 und X1 können beispielsweise von einem Padding oder Stride abhängen, wobei ein Padding ein Ergänzen von Zahlen (z.B. nullen) am Eingangstensor für die Faltungsberechnungen beschreibt und wobei ein Stride ein Springen / eine Schrittweite in der Faltungsberechnung beschreibt. Die Filterkernel 15A bis 15M haben jeweils die Dimension KcK*N. Die hier beschriebenen Ausführungen können auch dahingehend verallgemeinert werden, dass die Filterkernel die Dimension K1 cK2*N haben und K1 und K2 gleich oder unterschiedlich sein können. Zudem können prinzipiell die Filterkernel 15A bis 15M verschiedene Werte für K bzw. K1 und K2 haben.
Wie eingangs zu Fig. 2 beschrieben wurde, wurde in Vorarbeiten zur Erfindung erkannt, dass die verschiedenen KcK*1- Filtermatrizen eines herkömmlichen Filterkernels eine hohe Korrelation zueinander haben. Diese Erkenntnis kann genutzt werden, um die Anzahl zu lernender Parameter eines Filterkernels zu verringern, ohne die Menge an Informationen, die durch den Filterkernel aus dem Eingangstensor extrahiert wird, bedeutsam zu reduzieren. Dadurch kann auch die Robustheit des Filters bei Verwendung des neuronalen Netzes in einem Maschinenlernalgorithmus verbessert werden.
Fig. 5 illustriert die K*K*N Einträge / Elemente des Filterkernels 15A sowie die entsprechenden Einträge des Filterkernels 15M aus Fig. 4. Eine Filtermatrix oder Filterlage 15A1 des Filterkernels 15A wird aus Lernparametern L1-L9 gebildet. Werte für die Lernparameter L1-L9 werden in einem Trainingsschritt des Maschinenlernalgorithmus an Hand von Trainingsdaten gelernt. Die übrigen Filtermatrizen 15A2 bis 15AN stellen abhängige Filtermatrizen dar, welche aus impliziten Parametern P1-P9, PT-P9', ... , R -R9“ gebildet sind. Diese impliziten Parameter werden nicht als frei bestimmbare Werte durch einen Trainingsschritt des Maschinenlernalgorithmus gelernt. Vielmehr werden sie mit Hilfe der Lernparameter L1-L9 vorgegeben, indem diese mit Gewichten W = (Wi,2, Wi,3, WI,N) verrechnet werden. Konkret werden in diesem Beispiel die Gewichte W mit der Filtermatrix 15A multipliziert, um so die abhängigen Filtermatrizen 15A2 bis 15AN zu bilden. Die Einträge der abhängigen Filtermatrix 15A2 sind demnach definiert als: P1=L1 *WI,2, P2=L2*WI,2, ..., P9=L9*WI,2.
Jeder der Filterkernel 15A-15M kann somit dargestellt werden als:
Py,x,n ~ Pn Gy,x mit Wn e IR, wobei Fy,x,n einen der Filterkernel bezeichnet, Wn die Gewichte für diesen Filterkernel angibt und Gy,x die Filtermatrix mit Lernparametern dieses Filterkernels angibt. Die Indizes x und y können hierbei von 1 bis K laufen, während n von 1 bis N läuft.
Die Gewichte W werden dabei in einem Trainingsschritt des Maschinenlernalgorithmus gelernt. Die Anzahl an Parametern, für welche Werte in einem Trainingsschritt zu lernen sind, betragen für den Filterkernel 15A somit bloß K*K+N, was erheblich unter der Anzahl seiner Elemente, d.h. K*K*N, liegt. Die obigen Beschreibungen können sinngemäß auch für die übrigen Filterkernel gelten, insbesondere für den in Fig. 5 dargestellten Filterkernel 15M mit den Lernparametern L11-L19 und den impliziten Parametern P11-P19, P11‘-P19‘, ... , P11 “-P19“, welche über die Gewichte WM,2, WM,3, ... , WM,N definiert sind. Die erste Spalte an Gewichten (Wi,i, ... , WM,I) kann auch entfallen oder auf einen konstanten Wert gesetzt werden, womit die Anzahl an zu lernenden Parametern pro Filterkernel nicht K*K+N sondern K*K+N-1 beträgt.
Welche der Lagen der Filterkernel 15A ... 15M eine Filtermatrix mit Lernparametern L1-L9 ist, kann prinzipiell beliebig gewählt sein, und es muss sich hierbei nicht um die erste Lage des Filterkernels handeln.
Klarstellend sei erwähnt, dass im Stand der Technik der Begriff „Gewichte“ in Bezug auf Filterkernel häufig für die Lernparameter L1-L9 verwendet wird. Die Gewichte sind beim Stand der Technik daher direkt die Einträge eines Filterkernels, womit die Anzahl solcher Gewichte beim Stand der Technik meist gleich der Anzahl der Elemente des Filterkernels ist, also K*K*N. Hingegen bilden die Gewichte W bei der Erfindung nicht die Einträge des Filterkernels 15A, sondern werden mit der Faltungsmatrix 15A1 , die die Lernparameter L1-L9 enthält, verrechnet, um Einträge im Filterkernel 15A zu bilden.
Indem die Gewichte W zusammen mit einer Filtermatrix mit Lernparametern verwendet wird, kann der Filterkernel 15A aus Fig. 5 dem Filterkernel aus Fig. 2 ähneln, wobei aber die Anzahl voneinander unabhängiger Parameter des Filterkernels wesentlich verringert ist. Die übrigen Filterkernel der Faltungsschicht 100 können gleich wie der Filterkernel 15A gebildet sein. Somit kann für jeden der Filterkernel 15A-15M jeweils ein Vektor mit Gewichten vorliegen bzw. zusammengefasst eine Gewichtsmatrix W. Beispiele von Gewichtsmatrizen sind in den Figuren 6 bis 10 gezeigt. Fig. 6 zeigt eine Gewichtsmatrix W mit den Dimensionen M*N. Die N-Einträge einer Zeile bilden somit die Gewichte für einen der Filterkernel 15A-15M, wobei die Gewichtsmatrix insgesamt M Zeilen hat, entsprechend der Anzahl an Filterkernein 15A-15M. Im Beispiel von Fig. 6 sind alle Einträge der Gewichtsmatrix W frei lernbare Parameter. Die Filterkernel 15A-15M sind somit unabhängig voneinander. Die Anzahl zu lernender Gewichte für die Faltungsschicht 100 beträgt somit N*M, beziehungsweise (N-1)*M, wenn die Gewichte für beispielsweise den Filterkernel 15A, wie in Fig. 5 gezeigt, von Wi,2 bis WI,N laufen. Die Gesamtanzahl zu lernender Parameter der Faltungsschicht 100 umfasst in diesem Beispiel die genannte Anzahl zu lernender Gewichte plus die Anzahl an Lernparametern, welche hier K2*M betragen kann.
Fig. 7 zeigt ein Beispiel der Gewichtsmatrix W, wobei alle Gewichte auf denselben Wert festgelegt sind. Diese Konstante kann ein zu lernender Parameter oder eine fest vorgegebene Zahl sein. Dadurch lassen sich viele Operationen vereinfachen, beschleunigen, oder fallen sogar gänzlich weg. Resultat ist eine extreme Parameter- und Zeiteinsparung. Die Parameteranzahl ist je nach CNN-Architektur ca. um den Faktor 75 oder mehr verringert. Durch die starke Parameterreduzierung ist ein Modell mit dieser Faltungsschicht zwar nicht mehr so leistungsfähig wie das Ursprungsmodell oder ein Modell gemäß Fig. 6. Dies kann jedoch für weniger komplexe Aufgabenstellungen von Vorteil sein, da hierbei auch anhand sehr kleiner Datensätze (wie sie z.B. typisch im Mikroskopieumfeld sind) eine gute und meist bessere Generalisierbarkeit erreicht wird.
Zwischen den Extremen der Figuren 6 und 7 sind Abstufungen möglich, bei denen die Parameteranzahl kleiner als bei Fig. 6 und größer als bei Fig. 7 ist. Im Fall von Fig. 8 wird eine Gewichtsmatrix W verwendet, deren Einträge gemäß wm,n = vn spaltenweise konstant sind, das heißt alle Einträge derselben Spalte haben den gleichen Wert. Ein bestimmter Kanal des Eingangstensors 10 wird dadurch für alle Filterkernel 15A-15M gleich gewichtet. Dies entspricht einer filterunabhängigen Gewichtung des Eingangstensors und kann wiederum Speicher- und zeiteffizient, insbesondere mit 1x1-Faltungen in CNNs implementiert werden.
In ähnlicher Weise wird bei Fig. 9 eine Gewichtsmatrix W verwendet, deren Einträge w ,n = Vm sind, das heißt alle Einträge in einer Zeile von W haben denselben zu lernenden Wert. Dies bedeutet, dass alle Kanäle des Eingangstensors 10 für einen der Filterkernel gleich gewichtet werden. Effektiv führt dies also zu einer Gewichtung der Kanäle im Ausgabetensor. Dies lässt sich wiederum sehr effizient in einem CNN umsetzen, womit neben der Parameterersparnis auch ein deutlicher Geschwindigkeitsvorteil erreicht werden kann.
Die Gewichtsmatrix oder der Gewichtsblock W kann auch durch eine Niedrigrang- Approximation (englisch: „low rank approximation“) dargestellt werden, im Beispiel von Fig. 10 durch ein Matrixprodukt W = AB, wobei W eine M*N-Matrix ist, A eine M*M‘- Matrix ist und B eine M'cN-Mathx ist. Die Einträge der Matrizen A und B sind in einem Trainingsschritt zu lernende Gewichte / Gewichtsparameter. Die Einträge der Gewichtsmatrix W sind somit Linearkombinationen der Gewichtsparameter der Matrizen A und B. Motiviert ist diese Gestaltung der Gewichtsmatrix W durch die Beobachtung, dass im Fall einer Gewichtsmatrix W wie aus Fig. 6 die gelernten Gewichte stark über verschiedene Filterkernel hinweg korrelieren. M‘ ist kleiner als N, beispielsweise kleiner als 0,2*N oder kleiner als 0,1 *N. Zudem kann M‘<0,5M festgelegt werden, um die Parameteranzahl gegenüber der Gewichtsmatrix aus Fig. 6 zu reduzieren. In der Praxis wird für CNNs mit der Gewichtsmatrix aus Fig. 10 und einem Wert von M‘=0,1M noch eine Leistungsfähigkeit erwartet, die zur Gewichtsmatrix aus Fig. 6 vergleichbar ist, wobei aber gegenüber der Gewichtsmatrix aus Fig 6 eine Parameterreduzierung um etwa den Faktor 5 erzielt wird. Im Vergleich zu Standard-Faltungsschichten entspricht dies einer Parameterreduzierung um etwa den Faktor 50.
Um den Lernprozess im niedrigdimensionalen Raum zu regularisieren, können die Zeilen der Matrix B orthonormiert sein. Dies kann mit einer Regularisierungs- Verlustfunktion (Löss Function) L erreicht werden, L = || BBT- I ||F. Hierbei ist ß7 die transponierte Matrix von B, I ist die Einheitsmatrix und || . ||F die Frobenius-Norm. Die Regularisierungs-Verlustfunktion wird mit in die Optimierung des CNN-Trainings aufgenommen. Damit wird im Training eine Art Hauptkomponenten-Zerlegung (englisch: Principal Component Analysis, PCA) der Gewichtsmatrix W gelernt.
In Abwandlungen der Gewichtsmatrix aus Fig. 10 werden die Gewichte der Gewichtsmatrix W, wie bei Fig. 10, durch eine Kombination/Linearkombination aus Gewichtsparametern beschrieben. Hierbei sind die Gewichtsparameter in einem Trainingsschritt zu lernen. Im Unterschied zu Fig. 10 müssen die Einträge der Gewichtsmatrix W aber nicht als Matrixprodukt aus zwei Matrizen A und B darstellbar sein, sondern können in prinzipiell beliebiger anderer Weise verknüpft sein.
In Fig. 11 ist für verschiedene beispielhafte Gewichtsmatrizen W zusammengestellt, wie hoch die Anzahl zu lernender Parameter ist und wie stark die Parameterreduzierung gegenüber einer herkömmlichen Faltungsschicht (Standard CNN) ist, bei welcher die Anzahl K2*M*N beträgt. Der Faktor der Parameterreduzierung ist für den in der Praxis häufigen Fall geschätzt, dass K=3 und N»K2 gilt.
Die Beispiele von Gewichtsmatrizen W der Figuren 6 bis 10 dienen dem leichteren Verständnis, wobei klar ist, das auch Abwandlungen hiervon möglich sind. Allgemeiner ausgedrückt können die Filterkernel definiert werden durch: pro Filterkernel genau eine jeweilige Filtermatrix mit Lernparametern oder auch jeweils mehrere Filtermatrizen mit Lernparametern; und einen Gewichtsblock / eine Gewichtsmatrix W mit den zu lernenden Gewichten. Die Anzahl der zu lernenden Gewichte kann insbesondere kleiner oder gleich der Gesamtanzahl abhängiger Filtermatrizen aller Filterkernel sein.
Ist die Größe (Anzahl an Einträgen) der Gewichtsmatrix W größer als die Anzahl zu lernender Gewichte, soll dies so verstanden werden, dass übrige Einträge der Gewichtsmatrizen durch Konstanten und/oder durch eine Abhängigkeit von einem oder mehreren der zu lernenden Gewichte definiert sind.
Werden zwei oder mehr Filterschichten verwendet, können sich diese auch Gewichte teilen. Das heißt, zumindest einige der oben beschriebenen Gewichte werden auch in einer oder mehreren anderen Filterschichten verwendet. Mit Bezug auf Fig. 10 können insbesondere die Gewichte der Matrix B für mehrere Filterschichten verwendet werden, während diese Filterschichten voneinander verschiedene/unabhängige Matrizen A umfassen.
Ausführunqsbeispiel eines Mikroskops
Fig. 12 zeigt schematisch ein Ausführungsbeispiel eines Mikroskops 50 gemäß der Erfindung. Das Mikroskop 50 umfasst eine Lichtquelle 59 und einen Kondensor 60 zum Beleuchten einer Probe 58, die auf einem Probentisch 53 positioniert wird. Von der Probe 58 ausgehendes Detektionslicht wird entlang einer optischen Achse 52 mit einem Objektiv 51 zu einer Kamera 56 geleitet, zum Aufnehmen eines Probenbildes. Über ein Mikroskopstativ 54 kann optional auch eine Übersichtskamera 57 gehalten sein, mit welcher ein Übersichtsbild der Probe 58 aufgenommen werden kann. Eine Recheneinrichtung 55 ist dazu eingerichtet, ein aufgenommenes Mikroskopbild (das heißt ein Probenbild oder Übersichtsbild) zu verarbeiten und hieraus einen Eingangstensor zu bilden, welcher wie oben beschrieben in einem neuronalen Netz eines Maschinenlernalgorithmus verrechnet wird. Die Recheneinrichtung 55 ist dabei dazu eingerichtet, die in Bezug auf die Figuren 4 bis 11 beschriebenen Schritte durchzuführen. Der Maschinenlernalgorithmus kann insbesondere darauf trainiert sein, eine Klassifikation des Mikroskopbildes durchzuführen, wobei mögliche Klassen beispielsweise eine oder mehrere umfassen können aus: Probe, Hintergrund, Deckglas, Probengefäß, Deckglasrand, Probengefäßrand, Probenträgerbeschriftung. Alternativ oder zusätzlich kann der Maschinenlernalgorithmus darauf trainiert sein, eine Segmentierung oder Detektion durchzuführen, in welcher beispielsweise das Mikroskopbild in verschiedene Bereiche segmentiert wird und/oder bestimmte Objekte im Bild identifiziert und lokalisiert werden, beispielsweise Probenbereiche, Schatten oder Lichtreflexe. Auch kann der Maschinenlernalgorithmus für eine Bild-zu-Bild- Abbildung trainiert sein, in welcher das Ergebnis ein Ausgabebild ist.
Die Recheneinrichtung 55 kann auch in einem anderen Mikroskop verwendet werden, welches im Unterschied zum dargestellten Mikroskop beispielsweise nach einem anderen Messprinzip arbeitet oder ein Scan- oder Elektronenmikroskop ist. Auch in anderen Geräten als Mikroskopen kann zur Bildanalyse eine wie hier beschriebene Recheneinrichtung vorgesehen sein.
Mit Hilfe des beschriebenen neuronalen Netzes können in Maschinenlern anwendungen robuste Ergebnisse, die gegenüber Variationen der Eingabedaten sehr stabil sind, erzielt werden, wobei der benötige Rechenaufwand vorteilhafterweise verhältnismäßig gering ist. Dedizierte Hardware ist hierbei nicht erforderlich. Die Generalisierbarkeit eines auf diesem neuronalen Netz basierenden Maschinenlernalgorithmus ist hoch, das heißt, auch bei im Training nicht beobachteten Daten funktioniert der Algorithmus zuverlässig und ist datensparsam. Zudem ist mit den beschriebenen Filterkernein ein Trainieren eines Maschinenlernalgorithmus „from scratch“ gut möglich, das heißt ein Trainieren ohne Vortraining an Referenzdaten. Aufgrund der speziellen hier beschriebenen Weise der Parameterreduzierung kann die Leistungsfähigkeit des Maschinenlernalgorithmus unter Umständen sogar erhöht sein.
Bezugszeichenliste
10 10 Eingangstensor
12A - 12M Filterkernel des Stands der Technik
12M1 - 12MN Filtermatrizen des Filterkernels 12M
13, 13A - 13N Filterkernel einer depthwise separable convolution (tiefenweise getrennte Faltung) des Stands der Technik
14 Zwischentensor, berechnet mit den Filterkernein 13
15A-15M Filterkernel
15A1 -15AN Filtermatrizen des Filterkernels 15A 15M1 -15MN Filtermatrizen des Filterkernels 15M
16, 16A - 16M Filterkernel einer depthwise separable convolution (tiefenweise getrennte Faltung) des Stands der Technik
20, 20' Ausgabetensor
20Ά - 20‘M Lagen des Ausgabetensors 20'
50 Mikroskop
51 Objektiv
52 optische Achse des Objektivs 51
53 Probentisch
54 Mikroskopstativ
55 Recheneinrichtung
56 Kamera 57 Übersichtskamera
58 Probe
59 Lichtquelle
60 Kondensor
100 Faltungsschicht
100' Faltungsschicht des Stands der Technik
A Matrix zur Bestimmung der Einträge der Gewichtsmatrix W
B Matrix zur Bestimmung der Einträge der Gewichtsmatrix W
K Höhe und Breite der Filterkernel
M Tiefe des Ausgabetensors; Anzahl der Filterkernel, Zeilenanzahl/Höhe der Gewichtsmatrix W
M' Spaltenanzahl der Matrix A; Zeilenanzahl der Matrix B
N Tiefe des Eingangstensors und der Filterkernel, Spaltenanzahl/Breite der Gewichtsmatrix W
L1-L9, L10-L19 Lernparameter
P1 -P9, P1 ‘-P9‘, P1 “-P9“, P11-P19, P11-P19“, P11 “-P19“ implizite Parameter X Breite/Spaltenanzahl des Eingangstensors
Y Höhe/Zeilenanzahl des Eingangstensors vn Zeile der Gewichtsmatrix W bzw. Vektor mit Gewichten vm Spalte der Gewichtsmatrix W bzw. Vektor mit Gewichten w Gewichte, Gewichtsmatrix

Claims

PATENTANSPRÜCHE
1. Verfahren zum Verarbeiten von Mikroskopbildern, um ein Bildverarbeitungsergebnis zu erzeugen, umfassend: Ausführen eines faltenden neuronalen Netzes, wobei eine erste Faltungsschicht (100) aus einem Eingangstensor (10), der aus einem Mikroskopbild gebildet wird, einen Ausgabetensor (20) berechnet, wobei der Ausgabetensor (20) zu einer oder mehreren weiteren Schichten des faltenden neuronalen Netzes gegeben wird, um das Bildverarbeitungsergebnis zu berechnen, wobei die erste Faltungsschicht (100) mehrere Filterkernel (15A-15M) umfasst, dadurch g e k e n n z e i c h n e t, dass mindestens mehrere der Filterkernel (15A-15M) darstellbar sind durch: jeweils zumindest eine Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) und jeweilige abhängige Filtermatrizen (15A2-15AN, 15M2-15MN) mit impliziten Parametern, welche mittels der Lernparameter (L1-L9, L11- L19) und eines oder mehrerer zu lernender Gewichte (W) bestimmt sind, wobei die Filtermatrizen (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) verschiedener Filterkernel (15A-15M) voneinander verschieden sind und verschiedene Lagen des Ausgabetensors (20) durch verschiedene Filterkernel (15A-15M) berechnet werden.
2. Verfahren nach Anspruch 1 , dadurch g e k e n n z e i c h n e t, dass das Bildverarbeitungsergebnis ein Ergebnisbild, eine Klassifizierung, eine Bildsegmentierung, eine Objektidentifikation oder ein Steuerbefehl ist, durch welchen ein Mikroskop, mit dem das Mikroskopbild aufgenommen wurde, gesteuert wird.
3. Verfahren nach Anspruch 1 oder 2, dadurch gekennzeichnet, dass eine der abhängigen Filtermatrizen (15A2-15AN, 15M2-15MN) einer der Filterkernel (15A-15M) durch Multiplikation eines der zu lernenden Gewichte (W) mit der Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) desselben Filterkernels (15A-15M) gebildet ist, und dass eine Anzahl zu lernender Gewichte (W) aller Filterkernel (15A-15M) plus eine Anzahl aller Lernparameter (L1-L9, L11-L19) kleiner ist als eine Gesamtzahl an Elementen aller Filterkernel (15A-15M).
4. Verfahren nach einem der Ansprüche 1 bis 3, dadurch gekennzeichnet, dass jeder Filterkernel (15A-15M) nur eine einzige Filtermatrix (15A1 -15M1 ) mit Lernparametern (L1-L9, L11-L19) umfasst und im Übrigen ausschließlich abhängige Filtermatrizen (15A2-15AN, 15M2-15MN) umfasst, die durch jeweils ein zu lernendes Gewicht (W) und die Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) definiert sind.
5. Verfahren nach einem der Ansprüche 1 bis 4, dadurch gekennzeichnet, dass für alle abhängigen Filtermatrizen (15A2-15AN, 15M2-15MN) von einem der Filterkernel (15A-15M) dasselbe zu lernende Gewicht (W, vm) verwendet wird.
6. Verfahren nach einem der Ansprüche 1 bis 5, dadurch gekennzeichnet, dass sich die Filterkernel (15A-15M) in ihrer jeweiligen Filtermatrix (15A1 -15M1 ) mit Lernparametern (L1-L9, L11-L19) unterscheiden.
7. Verfahren nach einem der Ansprüche 1 bis 6, dadurch gekennzeichnet, dass dasselbe zu lernende Gewicht (vn) für je eine abhängige Filtermatrix (15A2-15M2) mehrerer Filterkernel (15A-15M) verwendet wird.
8. Verfahren nach einem der Ansprüche 1 bis 7, dadurch gekennzeichnet, dass die Filterkernel (15A-15M) definiert werden durch: pro Filterkernel (15A-15M) eine jeweilige Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) und einen Gewichtsblock mit den zu lernenden Gewichten (W), wobei die Anzahl zu lernender Gewichte (W) kleiner oder gleich der Gesamtanzahl abhängiger Filtermatrizen (15A2-15AN, 15M2-15MN) aller Filterkernel (15A-15M) ist.
9. Verfahren nach Anspruch 8, dadurch gekennzeichnet, dass der Gewichtsblock als Matrix der Dimension M*N darstellbar ist, welche gebildet ist als Matrixprodukt aus zwei Matrizen (A, B) mit Dimensionen M*M‘ und M’*N, wobei diese zwei Matrizen (A, B) aus den zu lernenden Gewichten bestehen.
10. Verfahren nach einem der Ansprüche 1 bis 9, dadurch gekennzeichnet, dass zumindest einer der Filterkernel (15A-15M) zwei oder mehr Filtermatrizen (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) umfasst und die abhängigen Filtermatrizen (15A2-15AN, 15M2-15MN) dieses Filterkernels (15A-15M) durch eine mit den Gewichten (W) verknüpfte Kombination der Filtermatrizen (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) gebildet sind.
11. Verfahren nach einem der Ansprüche 1 bis 10, dadurch gekennzeichnet, dass jeder Filterkernel (15A-15M) durch einen mit dem Eingangstensor (10) zu faltenden Körper gebildet ist, wobei der Körper durch die zumindest eine Filtermatrix (15A1-15M1) mit Lernparametern (L1-L9, L11-L19) und die zu lernenden Gewichte (W) gebildet ist.
12. Verfahren nach einem der Ansprüche 1 bis 10, dadurch g e k e n n z e i c h n e t, dass einer der Filterkernel (15A-15M) einen Lernparameter-Körper und einen Gewichte-Körper umfasst, welche nacheinander mit dem Eingangstensor (10) gefaltet werden, um eine Lage des Ausgangstensors (20) zu berechnen, wobei der Lernparameter-Körper durch die zumindest eine Filtermatrix (15A1- 15M1 ) mit Lernparametern (L1 -L9, L11 -L19) gebildet ist, und wobei der Gewichte-Körper durch die zu lernenden Gewichte (W) gebildet wird.
13. Verfahren nach einem der Ansprüche 1 bis 12, wobei aus dem Ausgabetensor (20) der ersten Faltungsschicht (100) ein zweiter Eingangstensor für eine zweite Faltungsschicht gebildet wird, wobei die zweite Faltungsschicht zweite Filterkernel umfasst, mit denen aus dem zweiten Eingangstensor ein zweiter Ausgabetensor berechnet wird, dadurch g e k e n n z e i c h n e t, dass zumindest einige der zu lernenden Gewichte (W) der Filterkernel (15A- 15M) der ersten Faltungsschicht (100) gleichzeitig auch als Gewichte zur Bestimmung von abhängigen Filtermatrizen der zweiten Filterkernel der zweiten Faltungsschicht verwendet werden.
14. Maschinenlesbares Speichermedium mit darauf gespeichertem Programmcode, der dazu eingerichtet ist, bei Ausführung durch eine Recheneinrichtung (55) das Durchführen des Verfahrens nach einem der Ansprüche 1 bis 13 zu veranlassen.
15. Mikroskop zum Untersuchen einer Probe (58), umfassend eine Lichtquelle (59) zum Beleuchten der Probe (58), ein Objektiv (51) zum Weiterleiten von Detektionslicht von der Probe (58), eine Kamera (56) zum Aufnehmen eines Mikroskopbildes mit Hilfe des Detektionslichts, das vom Objektiv (51) kommt, und eine Recheneinrichtung (55), welche eingerichtet ist zum Verarbeiten des Mikroskopbildes und Ausgeben eines Bildverarbeitungsergebnisses, dadurch g e k e n n z e i c h n e t, dass die Recheneinrichtung (55) dazu eingerichtet ist, aus dem Mikroskopbild einen Eingangstensor (10) zu berechnen und das Verfahren nach einem der Ansprüche 1 bis 13 durchzuführen.
PCT/EP2020/082160 2019-11-15 2020-11-13 Mikroskop und verfahren mit ausführen eines faltenden neuronalen netzes WO2021094597A1 (de)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US17/775,768 US20220382038A1 (en) 2019-11-15 2020-11-13 Microscope and Method with Implementation of a Convolutional Neural Network
CN202080077686.8A CN114846382B (zh) 2019-11-15 2020-11-13 具有卷积神经网络实现的显微镜和方法

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102019130930.1A DE102019130930A1 (de) 2019-11-15 2019-11-15 Mikroskop und Verfahren mit Ausführen eines faltenden neuronalen Netzes
DE102019130930.1 2019-11-15

Publications (1)

Publication Number Publication Date
WO2021094597A1 true WO2021094597A1 (de) 2021-05-20

Family

ID=73455687

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/EP2020/082160 WO2021094597A1 (de) 2019-11-15 2020-11-13 Mikroskop und verfahren mit ausführen eines faltenden neuronalen netzes

Country Status (4)

Country Link
US (1) US20220382038A1 (de)
CN (1) CN114846382B (de)
DE (1) DE102019130930A1 (de)
WO (1) WO2021094597A1 (de)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE102021114350A1 (de) 2021-06-02 2022-12-08 Carl Zeiss Microscopy Gmbh Verfahren und Vorrichtung zur faltungsfreien Bildverarbeitung

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE102017113733A1 (de) 2016-07-01 2018-01-04 Google Inc. Faltendes neuronales Netzwerk auf programmierbarem zweidimensionalem Bildprozessor
WO2018067962A1 (en) * 2016-10-06 2018-04-12 Google Llc Image processing neural networks with separable convolutional layers
CA2948499A1 (en) * 2016-11-16 2018-05-16 The Governing Council Of The University Of Toronto System and method for classifying and segmenting microscopy images with deep multiple instance learning
US20190333199A1 (en) 2018-04-26 2019-10-31 The Regents Of The University Of California Systems and methods for deep learning microscopy

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US11055063B2 (en) * 2016-05-02 2021-07-06 Marvell Asia Pte, Ltd. Systems and methods for deep learning processor
US10740896B2 (en) * 2017-12-29 2020-08-11 Leica Biosystems Imaging, Inc. Processing of histology images with a convolutional neural network to identify tumors
CN108427958B (zh) * 2018-02-02 2021-06-01 哈尔滨工程大学 基于深度学习的自适应权值卷积神经网络水下声纳图像分类方法
CN109086773B (zh) * 2018-08-29 2022-03-04 电子科技大学 基于全卷积神经网络的断层面识别方法
CN110232719B (zh) * 2019-06-21 2021-10-26 腾讯科技（深圳）有限公司 一种医学图像的分类方法、模型训练方法和服务器

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE102017113733A1 (de) 2016-07-01 2018-01-04 Google Inc. Faltendes neuronales Netzwerk auf programmierbarem zweidimensionalem Bildprozessor
WO2018067962A1 (en) * 2016-10-06 2018-04-12 Google Llc Image processing neural networks with separable convolutional layers
CA2948499A1 (en) * 2016-11-16 2018-05-16 The Governing Council Of The University Of Toronto System and method for classifying and segmenting microscopy images with deep multiple instance learning
US20190333199A1 (en) 2018-04-26 2019-10-31 The Regents Of The University Of California Systems and methods for deep learning microscopy

Non-Patent Citations (14)

* Cited by examiner, † Cited by third party
Title
ANDREW G HOWARD ET AL: "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications", 17 April 2017 (2017-04-17), pages 1 - 9, XP055556718, Retrieved from the Internet <URL:https://arxiv.org/pdf/1704.04861.pdf> [retrieved on 20190214] *
CHOLLET, FRANGOIS: "Xception: Deep learning with depthwise separable convolutions", PROCEEDINGS OF THE IEEE CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION, 2017, pages 1251 - 1258
GUO, YUNHUI ET AL.: "Depthwise Convolution is All You Need for Learning Multiple Visual Domains", ARXIV:1902.00927V2, 19 February 2019 (2019-02-19), Retrieved from the Internet <URL:https://arxiv.org/abs/1902.00927>
HAASE DANIEL ET AL: "Rethinking Depthwise Separable Convolutions: How Intra-Kernel Correlations Lead to Improved MobileNets", 2020 IEEE/CVF CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION (CVPR), IEEE, 13 June 2020 (2020-06-13), pages 14588 - 14597, XP033805317, DOI: 10.1109/CVPR42600.2020.01461 *
HOWARD, ANDREW G. ET AL.: "Mobilenets: Efficient convolutional neural networks for mobile vision applications", ARXIV PREPRINT ARXIV: 1704.04861, 2017
IANDOLA, FORREST N. ET AL.: "SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and< 0.5 MB model size", ARXIV PREPRINT ARXIV:1602.07360, 2016
IOFFE, SERGEYSZEGEDY, CHRISTIAN: "Batch normalization: Accelerating deep network training by reducing internal covariate shift", ARXIV PREPRINT ARXIV: 1502.03167, 2015
KRIZHEVSKY, ALEXSUTSKEVER, ILYAHINTON, GEOFFREY E: "Imagenet classification with deep convolutional neural networks", ADVANCES IN NEURAL INFORMATION PROCESSING SYSTEMS, 2012, pages 1097 - 1105, XP055309176
RASTEGARI, MOHAMMAD ET AL.: "European Conference on Computer Vision", 2016, SPRINGER, article "Xnor-net: Imagenet classification using binary convolutional neural networks", pages: 525 - 542
TAN, MINGXING ET AL.: "Mnasnet: Platform-aware neural architecture search for mobile", PROCEEDINGS OF THE IEEE CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION, 2019, pages 2820 - 2828
TAN, MINGXINGLE, QUOC V: "fficientNet: Rethinking Model Scaling for Convolutional Neural Networks", ARXIV PREPRINT ARXIV: 1905.11946, 2019
WANG GAIHUA ET AL: "An multi-scale learning network with depthwise separable convolutions", IPSJ TRANSACTIONS ON COMPUTER VISION AND APPLICATIONS, vol. 10, no. 1, 31 July 2018 (2018-07-31), XP055783543, DOI: 10.1186/s41074-018-0047-6 *
YAIR RIVENSON ET AL: "Deep Learning Microscopy", ARXIV.ORG, CORNELL UNIVERSITY LIBRARY, 201 OLIN LIBRARY CORNELL UNIVERSITY ITHACA, NY 14853, 12 May 2017 (2017-05-12), XP081276423, DOI: 10.1364/OPTICA.4.001437 *
ZOPH, BARRET ET AL.: "Learning transferable architectures for scalable image recognition", PROCEEDINGS OF THE IEEE CONFERENCE ON COMPUTER VISION AND PATTERN RECOGNITION, 2018, pages 8697 - 8710, XP033473794, DOI: 10.1109/CVPR.2018.00907

Also Published As

Publication number Publication date
CN114846382B (zh) 2024-05-28
US20220382038A1 (en) 2022-12-01
DE102019130930A1 (de) 2021-05-20
CN114846382A (zh) 2022-08-02

Similar Documents

Publication Publication Date Title
DE602004008471T2 (de) Verfahren und anordnung zur bestimmung einer objektkontur
WO2019001649A1 (de) Wissenstransfer zwischen verschiedenen deep-learning architekturen
DE102018104616A1 (de) Verfahren zum Aufteilen eines oder mehrerer Bilder einer Probe in nach Farbstoffen aufgeteilte Bilddaten, Computerprogrammprodukt, computerlesbares Medium, auf dem das Computerprogrammprodukt gespeichert ist, und System zum Aufteilen eines oder mehrerer Bilder einer Probe in nach Farbstoffen aufgeteilte Bilddaten
WO2019211068A1 (de) Verfahren und vorrichtung zum ermitteln eines tiefeninformationsbilds aus einem eingangsbild
EP3598195A1 (de) Verfahren zur mikroskopischen auswertung
DE102021201124A1 (de) Trainieren von bildklassifizierernetzen
WO2021094597A1 (de) Mikroskop und verfahren mit ausführen eines faltenden neuronalen netzes
EP1154369A2 (de) Verfahren zur zyklischen, interaktiven Bildanalyse sowie Computersystem und Computerprogramm zur Ausführung des Verfahrens
EP3740904A1 (de) Verfahren zum betreiben eines künstlichen neuronalen netzes
DE102021114350A1 (de) Verfahren und Vorrichtung zur faltungsfreien Bildverarbeitung
DE19537010C2 (de) Lernverfahren und -anordnung zur Nachbildung eines dynamischen Prozesses
DE102013224382A1 (de) Beschleunigte Objekterkennung in einem Bild
DE112022001991T5 (de) Tumorzelen-isolinien
DE112020001625T5 (de) Bildsuchsystem und Bildsuchverfahren
DE102020116013A1 (de) Verfahren zum Bereitstellen eines komprimierten künstlichen neuronalen Netzes mittels eines Autoencoders
EP4016081A1 (de) Verfahren und vorrichtung zum detektieren einer präsenz eines fluoreszenzmustertyps auf einem organschnitt mittels immunfluoreszenzmikroskopie
DE102020207613A1 (de) Verfahren zur Bewertung einer Schnittkante eines Körpers
DE202019103323U1 (de) Vorrichtung zum Erstellen eines maschinellen Lernsystems
WO2019242968A1 (de) Recheneinheit, verfahren und computerprogramm zum multiplizieren zumindest zweier multiplikanden
DE202021103700U1 (de) Vorrichtung zum Erzeugen eines künstlichen neuronalen Netzes
EP4356305A1 (de) Verfahren zum übertragen eines netzwerkverhaltens eines trainierten startnetzwerkes auf ein zielnetzwerk ohne verwendung eines originaldatensatzes
WO2022253574A1 (de) Verfahren und vorrichtung zur aufnahme von trainingsdaten
DE102019205822A1 (de) Verfahren zum Detektieren und Identifizieren von Objekten sowie System hierzu
DE202022104608U1 (de) Bildanalysemodell, das eine ganzzahlige Kopplungsschicht umfasst
DE102021205034A1 (de) Trainieren eines maschinenlernfähigen modells zur schätzung des relativen objektmassstabs

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 20808052

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 20808052

Country of ref document: EP

Kind code of ref document: A1