In this paper the research related to the creation of a program complex, which realizes the automated generation of service-programs for the artificial intelligence systems based on the convolution neural networks is presented. The presented program complex to accelerate and simplify the generation and training of convolutional neural networks.
In modern world the recognition
technologies of photo and video images are
being implemented more intensively. The
development of this sphere became possible
due to the appearance of new convolution
neural network (CNN) architectures and the
modification of existing ones. The given type of
architecture turned out to be successful enough
for solving the tasks of image analysis,
segmentation and semantic recognition. The
higher the CNN accuracy and capabilities are,
the more complex CNN become. Some of the
most successful and widespread CNN
architectures at the moment have a plenty of
heterogeneous layers [
At the same time, the number of tasks that can be solved using CNN rises. The given tasks not always demand the application of the most complex and foremost CNN architectures, but they are still quite difficult and regular users without any knowledge of deep learning methods and their implementation skills would not be able to create and adapt these networks correctly. It can be said that the quantity of such tasks is growing faster than the number of professionals capable of solving them.
This leads to the fact that the task of creating
the systems of CNN generation automation
process for one or the other spheres is becoming
very relevant [
Additionally, a lot of CNNs are produced in forms of program prototypes (for instance, using MatLab) and such prototypes require improvement for implementing into the existing monitoring systems which are designed at specific stacks of applied programming languages (C++, Java, Python etc). In its turn, this makes the further development and the following implementation of prototypes more complicated.
For solving the given tasks, the system of
convolution neural networks automated
training was designed based on the
serviceoriented approach within the project presented
in this article. The approach of artificial neural
networks automated generation is not new and
there are some works upon this topic [
By present time, the designed system had
already been used for generating simple deep
neural networks that were introduced into
thirdparty program products for solving specific
applied tasks [
The service-oriented architecture (SOA) of
applications implies a module approach to the
program application development [
At the level of the program complex itself SOA maintains the modularity and interchangeability of CNN generation and training algorithms. Thus, the whole process of automated generation and training is divided into some consecutively evoked program modules: • the input data normalization module; • the generation module of chosen CNN or the module of pre-trained CNN architecture initialization; • the CNN training module (including verification and validation submodules).
Each of these modules is presented in several realization variants (for various CNN architectures) and certain realizations are chosen depending on the requirements. In addition, these modules are evoked from an external automated training module (it is currently implemented on the basis of a genetic algorithm) which was developed with an expectation of changeability. The other algorithms of solution search can be used instead of it and there is no need to make significant modifications to other modules for the use of these algorithms.
This approach is based on the principles of transparency and scalability which allows to expand the program product functionality by adding new modules, not by modifying the existing ones.
It is obvious that the given approach would not allow to implement the automated training of all possible CNN architectures. However, the generation and training processes of typical architectures have a precise and consecutive algorithm. Having implemented the given algorithm in the program complex it would be possible to solve the task of typical neural network solutions streaming (conveyor) implementation as the main one.
The service-oriented approach in the developed program complex occurs in the fact that all modules should not be necessarily installed to one and the same personal computer (PC). Modules can be distributed between different PCs or placed in cloud storages. Thus, the given program complex can be implemented in the form of a distributed system that blends into the SOA paradigm completely.
At the program product operation result
level SOA is maintained by the implementation
of autonomous service containing CNN trained
to solve a specific task. This service is
crossplatformed and it can be launched without any
prior installing and additional software setting
on the basis of some operation systems (which
is possible due to the cross-platform of the
given modules implementation language
Python [
The difficulty in CNN production and training lies in the fact that they are being trained only having a marked training dataset which describes the class of recognizable objects. The recognition of different object classes requires various CNN architectures and their parameter settings. Due to the CNN complexity this task becomes very resourceintensive.
restrictions of CNN trained with a teacher. Now
the approach which consists in multitasking
CNN creation for different science fields that
can solve the whole class of tasks is often used
selected objects. However, the development of
each of these CNNs is more resource-intensive
and demands participation of specialists able to
project the architectures of such networks. The
alternative solution described in this article is
the automated training of models. This kind of
solution implies simultaneous training of some
CNNs based on prepared information dataset
for the following situational choice of the most
precise model which leads to the necessity to
solve
the
task
of
models
parametrical
adaptation quality assessment. At the same
time, the formation task of training dataset in
common
case
does
not
require
special
knowledge [
implemented in the following way: 1.
CNN
In the first parent population a fixed number (M) is generated with randomly set parameters.
Nd of new
CNNs is generated, the parameters of which are selected randomly out of two occasionally chosen parent CNNs, and also Nr of CNN, the parameters which are set completely randomly considering the given value ranges for these the
CNN selection
is the roulette method parameters. performed
using
(formula 1) [
Although would the
use have of
specific fastened the operation speed for some task classes, but it inevitably would have slowed the operation speed for other classes. The inaccuracy estimation calculated using
CNN target parameter value relatively to the real value of a test dataset (formula 2) lies in the basis of the fitness function (2) = 1 √ =1( − )2 ∑ where εij is the output value of a target parameter, which was forecast by i-network in response to an input test j-vector, ωj is the real value of a test dataset in response to an input test j-vector, X is the quantity of test vectors.
The result of a calculation according to the given formula is a "fitness level" value, which is inversely proportional to the mean squared error of i-CNN at the test dataset. As a result of selection, M is selected to the current generation out of (M + Nd + Nr) CNN with the maximum pi value (choice probability of i-CNN). 4.
For all CNN the mean squared error of the target parameter value calculated by them relatively to the real test dataset value is computed. If at least one CNN shows the mean squared error lower than the set value, the cycle stops. The CNN with the lowest mean squared error is treated as a "winner". Otherwise, the return to point 2 takes place. In addition, the population of each iteration is stored separately. If the population of a current iteration coincides completely with a previous population, it means that during all iteration the CNN configuration with the most accuracy has not been found and the unconditional transition to step 5 is carried out. 5.
If a CNN with the mean squared error lower than the set value is not found, the cycle launches from the step 1 with a new parent population, for which new random parameter values are set. If the solution is not found after I iteration, the task is declared to be unsolvable with specified settings and the output from the algorithm is performed.
This program complex is developed in
programming language Python, the main assets
of which relate to its cross-platform,
extensibility and large amount of sided program
libraries used for solving specified tasks. The
suggested programming language was chosen
because at the moment it happens to be the main
solution for deep learning systems development
and also because it allows to realize SOA
paradigm easily [
Such stack of technologies is explained by the fact that the program does not face the implementation task of untypical solutions. On the contrary, the quick realization of already known architectures is required. The use of already developed, tested and optimized libraries satisfies the set task completely. At the same time, the key requirements are extensibility and scalability. Respectively, the program complex realization on the basis of a constantly extending program platform will allow to add new CNN architectures and their work tools at the cost of one program interface. The cross-platform of the described stack and the support of SOA paradigm will allow to scale the program complex to different hardware.
It is important to mention separately that
CUDA SDK is also included in the used
program libraries, which allows to exploit
hardware acceleration during artificial neural
network training using NVidia video cards [
For approbation of the program complex
prototype performing additional training of
Mask R-CNN (MRCNN) CNN architecture
trained on COCO dataset was developed. The
given configuration was chosen because of the
balance between universality and accuracy
[
The program complex was tested on the calculation task of the amount of deer in a herd from air photography. Besides the fact that deer do not belong to the COCO dataset and MRCNN is not able to distinguish them by default from the range of other creatures (sheep, gazelles, cows, horses), the specificity of this task has something to do with the fact that photos are made from various angles and distances, at different landscapes and during all seasons, which result in the fact that deer can be shot under different angles, in various scales and can have diverse colouring. What is more, due to the size of herds, deer often cover one another in photos. This leads to the fact that the described task in non-trivial and the application of CNN trained at common amount of data is impossible. In figure 1 the recognition results of one out of two images using MRCNN without additional training are shown.
It can be noted that there are plenty of false negative errors evoked by the COCO dataset specificity, in which there is an insufficient number of images with similar scaling of objects. To get rid of false operations, it is required to train the network using images marked for the specified task. That is why MRCNN was additionally trained using the CNN automated training system prototype. The training was conducted in the automated mode based on the training dataset specified by a user. The following parameters of a training process were varied in the prototype: • the quantity of training epochs; • the quantity of training steps in each epoch; • the speed of training; • the threshold of detection skipping.
The CNN declared to be the winner by a system was trained on 3 epochs, with 53 training steps in each, 0,0058 training speed and 0,86 threshold of detection skipping. The described network for the same image recognized correctly 58 out of 93 deer and did not perform any false negative error (figure 2).
Of course, the trained CNN did not reach the maximum possible accuracy, but it can be improved in the future. What is more, the recognition accuracy may be increased by using the other CNN architectures. But the prototype testing can be considered successful because program and service coverages were generated for additionally trained MRCNN which will allow to use the received CNN for solving the set task right away. Due to the unified interface, it will be possible to perform the implementation of the most accurate CNNs in the future. Even if in the following versions a different CNN architecture is used, the program and service coverage interface will not change, and it will not be required to introduce changes into the programs at the client side.
Nowadays, the program complex is at its prototype stage and it is used for the development of some off-site applications. First of all, to start the full operation the improvement of user application interface is needed. As at the prototyping step the product is used by specialists in machine learning, the current interface is not adapted for using by regular users. Because of this, the accessibility for the wide user audience which is one of the key tasks facing the program complex is not being solved at the moment.
In addition, because of the highperformance requirements, during the given program product functioning the program complex transition to highly productive servers is needed for the commercial use. The calculation specifity during CNN training puts a range of requirements to the hardware and the commercial use implies the parallel training of several models that can load the system significantly. Despite the calculation parallelism put in the program complex architecture using SOA, it is demanded to perform the additional research and stress-tests to outline the specific requirements to the hardware.
This work was supported by the RFBR grant №19-37-90112 and the budgetary theme 00732019-0004.