KR102554626B1 - Machine learning method for incremental learning and computing device for performing the same - Google Patents

Abstract

In the machine learning method for incremental learning of the present invention, a model is built using training data, and the built model is gradually updated using only new weights generated based on new training data.

Description

Machine learning method for incremental learning and computing device for performing the same

The present invention relates to machine learning, and more particularly, to machine learning related to incremental learning.

In order to improve the adaptability and reliability of supervised machine learning models widely used in the field of artificial intelligence (AI), various studies on incremental learning have been attempted. Incremental Learning: Incremental learning makes it possible to increase the adaptability of a model to a constantly changing environment.

Machine learning models based on artificial neural networks (ANNs), such as deep neural networks (DNNs), convolutional neural networks (CNNs), recurrent neural networks (RNNs), etc. It is a well-known fact that there are limitations in implementing incremental or continual learning due to the problem of catastrophic forgetting (CF), and that it is difficult to explain the model or its results because the internal structure of the model is very complex. .

ANN-based machine learning models, when new training data is input, can get out of the optimized state (previously learned state) for the entire previous training data and cause a CF problem in which previously learned content is forgotten. It is difficult to incrementally extend the model (gradual update or incremental performance improvement).

Various methods are being studied to improve the CF problem, but since most studies involve model performance degradation, methods for effectively improving the CF problem are still incomplete.

Gradient boosting, one of the decision tree-based ensemble techniques, is an algorithm that outperforms ANN-based algorithms for non-image multivariate numeric data (multivariate numeric data or multivariate numeric heterogeneous data). Gradient Boosting, GB). However, since this technique also optimizes the entire learning data in building a model, it does not easily provide incremental learning.

An object of the present invention to solve the above problems is to provide a machine learning method and a computing device for easily performing incremental learning without deteriorating model performance.

The foregoing and other objects, advantages and characteristics of the present invention, and methods of achieving them will become clear with reference to the embodiments described below in detail in conjunction with the accompanying drawings.

A machine learning method for incremental learning according to an aspect of the present invention for achieving the above object includes encoding training data labeled with a plurality of class labels; Creating a plurality of variable networks classified by the plurality of class labels by configuring variables included in the encoded training data as nodes and connecting adjacent nodes among the nodes with edges having weights representing connection strength. step; determining variable networks selected according to performance among the plurality of generated variable networks as main variable networks; building a model by combining the determined main variable networks; encoding new training data; After calculating new weights using the encoded instance of the new training data, normalizing the calculated new weights; and gradually updating the built model by updating the weight of each of the determined main variable networks based on the normalized new weight.

A computing device for executing a machine learning method for incremental learning according to another aspect of the present invention includes a processor; a storage for storing training data labeled with a plurality of class labels and new training data; and a machine learning module that builds a model using the training data labeled with the plurality of class labels under the control of the processor, wherein the machine learning module includes the training data labeled with the plurality of class labels and the new model. an encoder that encodes training data; Creating a plurality of variable networks classified by the plurality of class labels by configuring variables included in the encoded training data as nodes and connecting adjacent nodes among the nodes with edges having weights representing connection strength. variable network generator; Among the plurality of generated variable networks, variable networks selected according to performance are determined as main variable networks, new weights are calculated using instances of the encoded new training data, and the calculated new weights are normalized. variable network determinant; a model builder that builds a model by combining the determined main variable networks; and based on the normalized new weight and an update unit for incrementally updating the built model by updating the weight of each of the determined key variable networks.

According to the present invention, when new training data is input, the previously built model is maintained and the previously built model is learned using only the weights generated based on the new training data. Progressive learning is easy because the model can be updated without changing it.

1 is a flowchart illustrating a machine learning method for incremental learning according to an embodiment of the present invention.
FIG. 2 is a diagram for explaining a feature sequence selected in a feature sequence selection step shown in FIG. 1 .
3 is a diagram for schematically explaining the model building step (S400) shown in FIG.
FIG. 4 is a diagram for explaining the ensemble configuration of each sub-model shown in FIG. 1;
5 is a block diagram of a computing device implemented to perform a machine learning method for incremental learning according to an embodiment of the present invention.

Specific structural or functional descriptions of the embodiments according to the concept of the present invention disclosed in this specification are only illustrated for the purpose of explaining the embodiments according to the concept of the present invention, and the embodiments according to the concept of the present invention It can be implemented in various forms and is not limited to the embodiments described herein.

Embodiments according to the concept of the present invention can apply various changes and can have various forms, so the embodiments are illustrated in the drawings and described in detail herein. However, this is not intended to limit the embodiments according to the concept of the present invention to specific disclosures, and includes modifications, equivalents, or substitutes included in the spirit and scope of the present invention.

Terms used in this specification are only used to describe specific embodiments, and are not intended to limit the present invention. Singular expressions include plural expressions unless the context clearly dictates otherwise. In this specification, terms such as "comprise" or "have" are intended to designate that the described feature, number, step, operation, component, part, or combination thereof exists, but one or more other features or numbers, It should be understood that the presence or addition of steps, operations, components, parts, or combinations thereof is not precluded.

The present invention relates to a supervised learning algorithm that facilitates incremental learning that conventional machine learning cannot efficiently implement. In the present invention, in a supervised learning method for predicting the label of a target variable for data composed of a plurality of variables (variables or features) and target variables, a network of significant features (Significant Feature Network: SFN) are found, and a learning model is constructed using the mutual relationship of the values included in the variable combination from the learning data, and the constructed learning model is used for classification prediction of new data.

In the present invention, when a previously built model is additionally learned using a new data set, incremental learning is very easy because a new model covering the new data set can be built by adding gradual changes to the existing model.

Hereinafter, a machine learning method for incremental learning according to an embodiment of the present invention will be described in detail with reference to the drawings. In addition, the following embodiments relate to supervised learning for the purpose of classification. However, it is not limited thereto, and those skilled in the art will be able to fully understand from the following description that the present invention can also be applied to supervised learning for the purpose of regression.

1 is a flowchart illustrating a machine learning method for incremental learning according to an embodiment of the present invention.

A machine learning method for incremental learning according to an embodiment of the present invention can be largely divided into a step of performing learning and prediction on a single data set and a step of performing incremental learning on an additional data set.

First, "steps of performing learning and prediction on a single data set" will be described, and then "steps of performing incremental learning on additional data sets" will be described. In this specification, a single data set is

Steps to train and predict on a single data set

Referring to FIG. 1, in the step of performing learning and prediction on a single data set, training data sets 101 and 102 and test data sets 110 and 111 are prepared ( preparing (S100), encoding (S200), discovering Significant Feature Networks (SFN) (S300), building a model (S400), and A prediction step (S500) is included.

A. Preparing a training data set and a verification data set (S100)

The training data set 101 includes a number of training data labeled with a number of class labels to build a model 400: 400_1, 400_2, ..., 400_N.

Each training data consists of multi-dimensional feature variables and class labels as target features or target variables. Each variable (feature or variable) can consist of continuous or discrete numeric or character values.

The verification data set 110 has the same configuration as the training data set 101, but is different from the training data sets 101 and 102 in that it is used for the purpose of verifying the predictive performance of a previously built model.

The training data set 101 and the verification data set 110 can be divided into before and after encoding, and the training data set 101 and the verification data set 110 before encoding are raw training data sets and raw training data sets. They may be called raw test data sets.

B. Encoding step (S200)

In the encoding step (S200), a process in which the encoder 200 encodes the training data set 101 and the verification data set 110 is performed. Encoding may be processing the training data set 101 into data suitable for training (or learning) of the model 400 and processing the verification data set 110 into data suitable for verifying the model 400 .

In encoding (S200), if the value of a variable is continuous, it is converted into a discrete value, discontinuous value, or categorical value, or a value consisting of text is appropriately converted. It can be converted into numbers.

Converting a continuous value of a variable into a discrete value or a categorical value, or converting a value composed of characters into a numerical value can be converted according to a defined (or programmed) encoding rule. Encoding rules may be static or dynamic during the entire process of learning and prediction.

Also, the encoding (S200) may reset a range of discrete or categorical values or convert an input value into another value. Here, resetting the range of discrete or categorical values may be, for example, resetting values divided into 10 steps into 5 steps, and converting an input value into another value, for example, , -2, -1,0,1,2 may be converted to 1,2,3,4,5.

C. Discovering the main variable network (SFN) (S300)

The step of discovering the SFN (S300) is a significant feature network, which is a key component of the model 400, using the training data set 201 encoded by the encoder 200 (or the encoded training data set). , SFN) may be discovered. Here, discovering the SFN may be detecting, extracting, or calculating the SFN using the encoded training data set 201 .

Specifically, the step of searching for SFN (S300) includes, for example, a feature sequence generating step (S301), a node and edge formation step (S302), Weight calculation step (S303), weight normalization step (S304), variable network evaluation step (S305), feature network ranking step (S306) and SFN selection ( selecting significant feature networks) step (S307).

The SFN can be acquired (discovered, detected, extracted, or calculated) through an iteration of the above steps (S301 to S306), and in the SFN selection step (S307) in the network ranking step (S306). A process of selecting specific feature sequences ranked at the top by SFN is performed. A model is constructed using the SFN selected in this way. Hereinafter, each step for deriving the SFN will be described in detail.

C-1. Generation of feature sequences (S301)

FIG. 2 is a diagram showing an example of variable permutations generated by the feature sequence generating step (S301) shown in FIG. 1 .

Referring to FIG. 2 , variable permutation is selecting two or more variables (or two or more generated variables) from an encoded training data set 201 composed of multiple variables and arranging them in a specific order.

The feature sequence is, for example, if N variables are selected from among all variables and arranged in a specific order, as shown in FIG. 2, a specific permutation consisting of f ₁ , f ₂ , f ₃ , ??, f _N this can be made

Generating a specific variable permutation is a method of selecting a feature without transforming the variable and a feature generation method of creating a new variable based on the variables included in the encoded training data set 201. can be divided into

Variable selection methods for variable permutation generation, e.g., random selection methods, methods considering all combinations, methods derived from other machine learning methods, mutual information in information theory There may be various methods, such as how to use .

As a variable generation method for variable permutation generation, for example, using a deep learning-based variable extraction method such as linear discriminant analysis (LDA), principal component analysis (PCA), or autoencoder There may be a variety of methods, including methods.

Formation step of C-2 node and edge (S302)

When a specific variable permutation is selected in the previous step (S301), a node and an edge are defined, and a feature network can be configured through them.

Nodes (f ₁₁ , f _{12, ...} f _1i, f _21, f _{22, ...} f _N1 , f _N2 , f _NP, ??), as shown in Figure 2, each variable (f ₁ , f ₂ , f ₃ , ??, f _N ) are defined as encoded values, and edges (w ₁₁ , w ₁₂ , w ₁₃ , w _1α, w _21, w _22, w _23, w _2β, ??) are adjacent nodes The connection between them is defined. Here, the connection of nodes within the same variable is not considered. For example, the variable f ₂ contains f ₂₁ , f ₂₂ , ?? Nodes such as f _2j exist, and they are connected to nodes of adjacent variables f ₁ and f ₃ with edges (or connecting lines representing weights). In this way, through the connection of nodes and edges, a feature network for the selected variable permutation is constructed.

C-3 weight calculation step (S303)

Edges connecting nodes have a specific value, and this specific value is defined as a weight representing the connection strength of nodes. Weights can be obtained from encoded training data 201 . When an instance of the encoded training data 201 is input, weights of edges connecting nodes activated by the instance are calculated. Here, an instance means each example or sample constituting the data when the data required for learning or inference (prediction) by the machine learning model is given. Accordingly, an instance may also be called a training example or a training sample constituting training data.

The weight may be calculated according to a predefined weight calculation rule. One of the weight calculation methods is a method of dividing the network into classes and updating the weights.

For example, when training data having three class labels from 1 to 3 is given, three variable networks consisting of the same variable permutation are created, and the training data with class label No. 1 has the weight of network No. 1, and 2 Training data with the first class label are used to calculate the weights of the second network, and training data with the third class label are used to calculate the weights of the third network. This means that variable networks with different weights are created according to class labels for one variable permutation.

C-4 weight normalization step (S304)

When weights of edges are calculated by a plurality of instances included in the encoded training data set 1 (201), a normalization process is performed on the calculated weights.

The normalization process may be performed according to a predefined weight normalization rule. Here, the weight normalization rule may be, for example, a rule for setting the sum of edges between two adjacent variables to be 1.

C-5 variable network evaluation (assessing feature network) step (S305)

The variable network evaluation step (S305) is a step of calculating a network evaluation index indicating how good the variable network has in distinguishing classes using the variable network and weight information generated by the above steps.

There are two main methods for evaluating variable networks.

The first method is a method of mathematically extracting a figure of merit from the characteristics included in the weight information of the variable network. A second method may be to evaluate the performance of variable networks by calculating class distinction accuracy using multiple variable networks, the normalized weights, and instances labeled with class labels not used (or used) for weight calculation. there is. Any method can arithmetically evaluate the variable network.

C-6 Feature network ranking step (S306)

The variable network rank may be determined based on the evaluation index of the variable network arithmetically derived by the performance result of the previous step (S305). In the initial implementation, the variable network selected first is ranked first, but if another variable network is selected in step S301 and the process up to S306 is repeated, the rank may be changed. Ranks are indicated by subscripts, such as SFN ₁ , SFN ₂ , SFN ₃ , ??

C-7 SFN selection (selecting significant feature networks) step (S307)

In the previous step (S306), a predetermined number of variable networks ranked at the top are selected. The selected variable networks are utilized for model construction as principal variable networks (SFNs).

D. Building a model (S400)

FIG. 3 is a diagram for schematically explaining the model building step (S400) shown in FIG. 1, and FIG. 4 is a diagram for explaining the ensemble configuration of each sub-model shown in FIG.

Referring to FIG. 3 , the model construction step (S400) is a step of constructing a model using the main variable network selected through the previous step (S307). The entire model 400 is composed of a plurality of submodels distinguished for each class.

As shown in FIG. 1, a model built to distinguish N classes is configured to include N submodels (400_1, 400_2, ..., 400_N). And, as shown in FIG. 4, each sub-model may be composed of an ensemble combining main variable networks selected in the previous step (S307).

The most basic way to construct an ensemble is to construct all submodels with the same main variable networks. When weights are updated using training data, instances of training data are used to calculate and update weights of main variable networks of submodels corresponding to respective class labels, as shown in FIG. 3 . After the training process, the generated sub-models are composed of the same main variable networks, but have different weight information.

E. Prediction Step (S500)

In the prediction step (S500), an instance of the verification data set 110 is input to all sub-models (400_1, 400_2, ... 400_N) included in the built model 400, and the sub-model having the largest weight score corresponds to It is selected as the predicted class of the instance.

A weight score of a specific sub-model for an instance of the verification data set 110 may be derived using a corresponding weight score of key variable networks (SFNs) constituting the sub-model.

As shown in FIG. 4, the weight score of submodel 1 can be calculated as a linear combination of weight scores of main variable networks constituting submodels such as SFN1 (S311), SFN2 (S312), and SFN3 (S313). can

Let W(Di, SFN _j ) be a weight score of SFN _j for the ith instance D _i of the verification data set 110 . At this time, the weight score W ₁ (D _i ) of submodel 1 is calculated as follows.

c _j is a coefficient representing the contribution according to the rank of SFN. For example, if _cj = 1, weighted scores are calculated in equal proportions for all SFNs regardless of rank. In this case, the value of _cj may be set differently according to j (according to the SFN) with a difference according to rank.

Steps to perform incremental learning on additional data sets

One of the important features of the present invention is that it is possible to easily perform incremental learning on the newly added training data 102 . First, it is assumed that the model 400 is built based on the training data set 1 (101). Then, a new training data set 2 (102) is input to the encoder (200).

The encoder (200) performs encoding on the new training data set 2 (102) and generates an encoded training data set 2 (102).

Thereafter, instead of performing all of the processes (S301 to S307) included in the SFN search step (S300) for the encoded training data set 2 (102), a weight scoring process (S303) and weight normalization are performed. Progressive learning is performed by sequentially performing only the process S304 to update the weights of the already built model 400 with normalized weights for the encoded training data set 2 102 .

When new training data is input, gradual learning can be easily performed because learning is performed by maintaining a previously built model and updating only state variables called weights.

5 is a block diagram of a computing device implemented to perform a machine learning method for incremental learning according to an embodiment of the present invention.

Referring to FIG. 5 , a computing device 600 includes a storage 610, a machine learning module 620, a processor 630, a memory 640, and a system bus (610, 620, 630, 640) connecting them. 650) may be included.

Storage 610 stores training data (or training data set) 102 and validation data (or validation data set) 110, 111 labeled with a plurality of class labels for building a model (400 in FIG. 1). It is a hardware device that stores new training data (or new training data set) 102 for incrementally updating the model (400 in FIG. 1) through incremental learning.

The storage 610 is, for example, a computer readable medium, for example, a magnetic medium such as a hard disk, a floppy disk and a magnetic tape, an optical recording medium such as a CD-ROM and a DVD, a floptical disk ).

The machine learning module 620 builds a model (400 in FIG. 1) under the control or execution of the processor 630, and uses only new weights generated based on the new training data 102 to build the model ( 400 of FIG. 1) may be a hardware module or a software module that gradually updates (learns).

The machine learning module 620 may include a plurality of sub-modules classified according to functions, and the plurality of sub-modules include, for example, an encoder 621, a feature networks (FN) generator 622 , a significant feature networks (SFN) determiner 623, a model builder 624 and an update unit 625.

The encoder 621 is a component that encodes training data labeled with a plurality of class labels, and performs, for example, the process of step S200 described in FIG. 1 . The encoder 621 converts continuous values of variables included in the training data into discrete values or categorical values according to predefined encoding rules.

The encoder (621) also encodes the new training data (102) to generate new weights based on the new training data (102).

A variable network (FN) generator 622 organizes the variables included in the encoded training data into nodes, connects adjacent nodes among the nodes with edges having weights indicating connection strength, and then connects the plurality of class labels. As a configuration for generating a plurality of variable networks classified as , it may be a configuration for performing steps S301 and S302 described in FIG. 1 .

The variable network (FN) generator 622 generates a variable permutation by arranging two or more variables included in the encoded training data in a specific order according to the execution of step S301.

For example, the variable network (FN) generator 622 randomly selects two or more variables from the encoded training data, and then arranges the randomly selected two or more variables in the specific order to generate the variable permutation.

As another example, the variable network (FN) generator 622 performs linear discriminant analysis (LDA), principal component analysis (PCA), and deep learning (deep learning) on two or more variables included in the encoded training data. After transforming into new variables using a variable extraction method based on learning, the variable permutation is generated by arranging the new variables in a specific order.

When the variable permutation is generated, the variable network (FN) generator 622 configures the values included in each of the listed variables into nodes, and connects adjacent nodes among the configured nodes to the edge according to the specific order. Thus, a plurality of variable networks classified into the plurality of class labels are generated for the generated variable permutation.

The principal variable network (SFN) determiner 623 determines variable networks selected according to performance among the generated plurality of variable networks as principal variable networks.

For example, the principal variable network (SFN) determiner 623 calculates the weight of each of the plurality of variable networks using the instance of the encoded training data 201 (S303 in FIG. 1), After processing the process of normalizing the calculated weights (S304 in FIG. 1), the process of evaluating the performance of each variable network using the plurality of variable networks and the normalized weights (S305 in FIG. 1) is processed. .

Additionally, the principal variable network (SFN) determiner 623 calculates new weights using an instance of the new training data 202 encoded by the encoder 200 through step 303 of FIG. A process of normalizing the calculated new weight is processed through S304.

Thereafter, the main variable network (SFN) determiner 623 determines the ranking of the plurality of variable networks according to the evaluated performance (S306 of FIG. 1), and then ranks the plurality of variable networks according to a preset number among the plurality of variable networks. A process of determining variable networks ranked in as the main variable networks (S307 in FIG. 1) is processed.

The process of normalizing the weights calculated by the principal variable network (SFN) determiner 623 includes, for example, the plurality of class labels including a first class label and a second class label, and the plurality of variables When the networks include a first variable network and a second variable network, calculating weights of the first variable network using instances of the training data labeled with the first class label, using the second class label The process of calculating weights of the second variable network that are different from the weights of the first variable network using the labeled instances of the training data, and the process of normalizing the weights of the first variable network and the weights of the second variable network. can include

The process of evaluating the performance of each variable network by the principal variable network (SFN) determiner 623 calculates class discrimination accuracy using the plurality of variable networks, the normalized weights, and instances labeled with class labels. and a process of evaluating the performance of each variable network based on the calculated class discrimination accuracy.

The model builder 624 processes the process of building the model 400 by combining the principal variable networks determined by the principal variable network (SFN) determiner 623 .

The update unit 625 processes the process of incrementally updating the model 400 built by the model builder 624 based on the new weights normalized by the principal variable network (SFN) determiner 623. do.

For example, the update unit 625 may incrementally update the built model by adding the normalized new weight to the weight of each of the determined main variable networks.

The processor 630 is a component that controls and manages operations of the storage 610, the machine learning module 620, and the memory 640 through the system bus 650, and includes at least one CPU, at least one GPU, or can be a combination.

In FIG. 5, the processor 630 and the machine learning module 620 are shown as separate configurations, but may be integrated into one. For example, machine learning module 620 may be integrated into processor 630 .

The memory 640 is a hardware device that temporarily or permanently stores intermediate data or result data processed by each component in the processor 630 or the machine learning module 620, and stores program commands such as ROM, RAM, flash memory, etc. and may include hardware devices specially configured to do so.

Examples of program instructions include not only machine code generated by a compiler but also high-level language codes that can be executed by a computer using an interpreter or the like. The hardware devices described above may be configured to act as one or more software modules to perform the operations of the present invention, and vice versa.

The protection scope of the present invention is not limited to the description and expression of the embodiments explicitly described above. In addition, it is added once again that the scope of protection of the present invention cannot be limited due to obvious changes or substitutions in the technical field to which the present invention belongs.

Claims (13)

A machine learning method performed by a computing device, in a machine learning method for incremental learning,
encoding training data labeled with multiple class labels;
Creating a plurality of variable networks classified by the plurality of class labels by configuring variables included in the encoded training data as nodes and connecting adjacent nodes among the nodes with edges having weights representing connection strength. step;
determining variable networks selected according to performance among the plurality of generated variable networks as main variable networks;
building a model by combining the determined main variable networks;
encoding new training data;
After calculating new weights using the encoded instance of the new training data, normalizing the calculated new weights; and
Progressively updating the built model by updating the weights of each of the determined main variable networks based on the normalized new weights.
Machine learning method for incremental learning comprising a. In paragraph 1,
Encoding the training data,
Machine learning for incremental learning, which is a step of converting continuous values of variables included in the training data into discrete values or categorical values according to predefined encoding rules. method. In paragraph 1,
The step of generating a plurality of variable networks classified into a plurality of class labels,
generating a variable permutation by arranging two or more variables included in the encoded training data in a specific order; and
The values included in each of the listed variables are configured as nodes, and among the configured nodes, adjacent nodes are connected to the edge according to the specific order, and the generated variable permutation is classified into the plurality of class labels. Creating multiple variable networks
Machine learning method for incremental learning comprising a. In paragraph 3,
The step of generating the variable permutation,
randomly selecting two or more variables from the encoded training data; and
generating the variable permutation by arranging the two or more randomly selected variables in the specific order;
A machine learning method for incremental learning that includes a. In paragraph 3,
The step of generating the variable permutation,
Two or more variables included in the encoded training data are converted into new variables using linear discriminant analysis (LDA), principal component analysis (PCA), and deep learning-based variable extraction. converting; and
generating the variable permutation by listing the new variables in a specific order;
A machine learning method for incremental learning that includes a. In paragraph 1,
The step of determining the selected variable networks as main variable networks,
calculating the weight of each of the plurality of variable networks using the instance of the training data, and normalizing the calculated weight;
Evaluating performance of each variable network using the plurality of variable networks and the normalized weights;
ranking the plurality of variable networks according to the evaluated performance; and
determining, among the plurality of variable networks, variable networks ranked higher according to a preset number as the main variable networks;
A machine learning method for incremental learning that includes a. In paragraph 6,
Normalizing the calculated weights,
When the plurality of class labels include a first class label and a second class label, and the plurality of variable networks include a first variable network and a second variable network,
calculating weights of the first variable network using instances of the training data labeled with the first class label;
calculating weights of the second variable network that are different from weights of the first variable network using instances of the training data labeled with the second class label; and
Normalizing the weight of the first variable network and the weight of the second variable network
A machine learning method for incremental learning that includes a. In paragraph 6,
Evaluating the performance of each variable network,
calculating class discrimination accuracy using the plurality of variable networks, the normalized weights, and instances labeled with class labels; and
Evaluating the performance of each variable network based on the calculated class discrimination accuracy
A machine learning method for incremental learning that includes a. In paragraph 1,
The step of gradually updating the built model is,
The step of gradually updating the built model by adding the normalized new weight to the weight of each of the determined main variable networks. A computing device executing a machine learning method for incremental learning, comprising:
processor;
a storage for storing training data labeled with a plurality of class labels and new training data; and
A machine learning module for building a model using training data labeled with the plurality of class labels under the control of the processor;
The machine learning module,
an encoder that encodes training data labeled with a plurality of class labels and the new training data;
Creating a plurality of variable networks classified by the plurality of class labels by configuring variables included in the encoded training data as nodes and connecting adjacent nodes among the nodes with edges having weights representing connection strength. variable network generator;
Among the plurality of generated variable networks, variable networks selected according to performance are determined as main variable networks, new weights are calculated using instances of the encoded new training data, and the calculated new weights are normalized. variable network determinant;
a model builder that builds a model by combining the determined main variable networks; and
An update unit for incrementally updating the built model by updating the weights of each of the determined main variable networks based on the normalized new weights.
Computing device comprising a. In paragraph 10,
The variable network generator,
A first process of generating a variable permutation by arranging two or more variables included in the encoded training data in a specific order, configuring values included in each of the listed variables into nodes, and configuring the specific order among the configured nodes. A second process of generating a plurality of variable networks classified into the plurality of class labels for the generated variable permutation by connecting adjacent nodes to the edge according to the computing device. In paragraph 10,
The main variable network determinant,
A first process of calculating the weight of each of the plurality of variable networks using an instance of the training data and normalizing the calculated weight, each variable network using the plurality of variable networks and the normalized weight A second process of evaluating the performance of, a third process of determining the rank of the plurality of variable networks according to the evaluated performance, and a variable network ranked at the top according to a preset number among the plurality of variable networks in the main process. processing a fourth process of determining variable networks. In paragraph 10,
The update unit,
and processing a process of gradually updating the built model by adding the normalized new weight to the weight of each of the determined main variable networks.

Images