MIME-Version: 1.0 Content-Type: multipart/related; boundary="----=_NextPart_01D2B64A.2F741EA0" This document is a Single File Web Page, also known as a Web Archive file. If you are seeing this message, your browser or editor doesn't support Web Archive files. Please download a browser that supports Web Archive, such as Microsoft Internet Explorer. ------=_NextPart_01D2B64A.2F741EA0 Content-Location: file:///C:/E625A1F0/NeurApp_help.htm Content-Transfer-Encoding: quoted-printable Content-Type: text/html; charset="us-ascii"
Exploring Approximation
by Artificial Neural
Networks
by Igor Grešovnik
This software is based on the Investigative Generic Lib=
rary
(IGLib). &=
nbsp; &nbs=
p; &=
nbsp;
Contents=
:
2.2 One Parametric
Approximations
2.2.1  =
; Defining
the Approximated Function and Training Data.
2.2.2  =
; Training
the Neural Network
2.2.4  =
; Checking
Results
2.3 Functions of 2 Variab=
les
with 3D Surface Plots
2.3.1  =
; Defining
the Approximated Function and Training Data.
2.3.2  =
; Network
Architecture and Training Parameters.
2.3.3  =
; Showing
Training Data and Results
2.4 Accessing Help and Web
Pages
NeurApp is an educational software intended for exploring how neural n= etwork-based approximations work on functions of one or two variables. You can input different functions to be approximated by an artificial neural network (ANN= ), generate training points that are used to build the approximation, set parameters of training procedure, train the neural network on the generated data, and compare the obtained model (i. e., the approximation obtained by = the trained neural network) to the original function that was used for generati= on of training data.
User interface is intuiti= ve and you can start using the program without reading this manual and without pri= or knowledge about artificial neural networks. Initial values of various parameters are chosen in such a way that meaningful results should be obtai= ned by these initial values. After some clicks on action buttons, when you figu= re out how the software works, you can change training parameters to see how approximations can be improved with optimal settings, try which is the mini= mum quantity of data (number of sampling points) necessary to obtain a meaningful approximation, experiment with more complex model functions and explore graphically which are the details that are more difficult to approximate.= p>
The purpose of this softw= are is manifold. The software is primarily designed to build and improve intuitive understanding of approximative models - how they work, what is their purpose and what are their limitations. You can explore how the underlying mathemat= ical concept works "in vivo", without necessarily knowing much about mathematics behind. This can be a wonderful introduction before learning ab= out mathematics of approximation, it can add intuitive component when you alrea= dy know something about mathematics behind, or you can just play with these approximate models out pure curiosity. The software might be interesting to high school students just as well as to professionals who more use approximative modeling in science or engineering and other business context= s.
We initially created the = software for ourselves, to quickly test new algorithms and visually identify their w= eak points. Then we learned how often people have different misconceptions about approximation techniques, even when they work in environment where applicat= ion of these techniques would be beneficial, or they actually use them through = some black box-like software. We realized that software like NeurApp can help improve understanding of approximations in mor= e intuitive ways. Humans are visual beings and being able to visually compare graphs of= the original functions and their approximations together with data used to build approximations, to zoom and rotate in order to easily notice and focus on individual details, and to do this within an interactive loop where approximated functions, quantity of input data and algorithm parameters can= be varied and results of these changes visualized immediately, these possibilities can improve core understanding of approximative modeling easier than long hours= of theoretical lectures. Lessons learned with such hands-on approach are more vivid and better remembered.
Reshaping software for ed= ucative purposes led to some simplifications. Instead of a number of algorithms that could be switched between, we enabled only one in order to keep the user focused. This software does not address some of the most wide spread (and dangerous) misconceptions about approximative models, which are related to effects of dimensionality. Some intuitive understanding can be built up by comparing 1D and 2D models and models of increasing complexity (e.g. by inc= reasing modality - the number of minima or maxima - of the approximated function). = However, drastic increase of complexity in higher dimensions can not be embraced in = this way and its understanding can not be acquired without more rigorous mathematical treatment. Supporting facilities for learning about these effe= ct through experimentation and visualization are provided by other software su= ch as NeuralShell and AnnApp.
Installing and using the = software is extremely simple. In order to install the software, just grab the archiv= e, expand it, and copy the contained file into some directory. Double-click on= the executable file in any file browser (such as the Windows Explorer) in order= to execute the software.
In order to start using t= he software, click either on the ”1D Approximation” or on the “2D Approximation” tab, dependent on whether you want to approximate functions of one or two variables. Then, click on the “Generate Data” button, wait a moment until a graph of the model function with the generated training points is shown, and then click the “Start” button. This will trigger the training procedure and wh= en training is finished, the obtained approximated function will be plotted. <= /p>
Training may take a while, dependent on the value of the number of epochs that are performed. Everythi= ng else is quite intuitive; you can change the number of generated training points, choose or manually insert the approximated function, and adjust parameters of the training procedure.
When approximating functi=
ons of 2
variables, graphs of the original function and its approximation will be sh=
own
in a separate window rather than in embedded window. After pressing the
“Generate Data” button, wait until the graph window is launched,
then you can view it from different angles and zoom it. Before proceeding
further, close the graph window. After pressing the “Start” but=
ton,
wait again until graph is launched, and close the graph window when viewing=
is
done. You can interact with 3D graphics windows by mouse and keyboard, press
the ‘R’ key in order to position the objects in default way, and
the ‘T’ button in order to change the interaction mode
Figure 1=
: GUI for approximation of functions of one var=
iable.
a. Bouds of the sampled
interval
b. Function that is sampl=
ed
c. Number of training poi=
nts
for ANN
d. Button to generate tra=
ining
data
e. Option for random samp=
ling
(unchecked means equidistant)
f. =
ANN settings
g. Start training
h. Reset all to default
i. =
Error type with convergence graph
j. =
Main graph showing the original (sampled) function, train=
ing
points and approximation
While approximation of fu= nctions of a single variable is the least interesting problem in ANN-based modeling, playing with such approximations is instructive because very clear graphic representations of results can be made.
Exploring 1D ANN-based approximations in NeurApp is intuitive and can be learned in a minute. Clic= king on the “1D Approximation” tab on the top of the applicat= ion’s form activates the user interface for 1D approximations. To see how it work= s, click first on the “Generate data” button and then on th= e “Start” button, and that’s it.
Clicking on the “Generate data” button samples the function that you want to approximate an= d is specified next to the “f(x) =3D ” label, in order to gen= erate function values used to train the neural network. After the training data is generat= ed, it is immediately shown on the graph on the right-hand side (together with = the approximated function on the interval where values are sampled), and the “Start” button gets active. Pressing the start button tr= ains the neural network on the data that has been generated.
During the training proce= dure, the neural network tries to produce an intrinsic function that fits well the training data, without knowing anything about the original function used to generate that data. After training is done, the graph on the top right of t= he form shows the approximation generated by the neural network, the training = data used to generate this approximation, and the original function used to generated the data. In this way you can visualize how much the approximated function deviates from the original one.
You can vary the number of sampled function values in the training data, change interval on which trai= ning data is generated, modify the approximation function itself, and change neu= ral network architecture and training parameters and observe how any of these circumstances affect the accuracy of the approximation (i.e., how closely t= he approximation fits the original function). In further subsections it is explained how to adjust specific things that influence the approximation. <= /p>
When starting the applica= tion, there is already a pre-set default function to be approximated. You can cha= nge the approximated function by using the input field next to the “f(= x) =3D” label, and this can be done in two ways. If the checkbox “Function defined by user” is unchecked, you can choose one of the pre-defi= ned functions from the drop-down list that opens when clicking on the triangular arrow positioned on the right-hand side of the text field.
In order to define at own= will an arbitrary function to be approximated, check the “Function defined= by user” checkbox. When the checkbox is checked, you can insert expr= essions defining an arbitrary function in a standard symbolic way by using “<= i>x” for independent variables, standard operators such as +, -, * (multiplicati= on), / (division), a number of standard mathematical functions, and parentheses = for grouping expressions and overriding operator precedence in order to define order of evaluation. There is no operator for powers, and you must used the function “pow”, e.g. the expression “pow(x,3/2)= 221; means the independent variable x raised to the power of 3/2 (which is equivalent to calculating square root of x and raising the obtained value to the third power).
Warning: You can not inse= rt your own function definition when the “Function defined by userR= 21; checkbox is not checked. The text field for inserting functions is green wh= en user defined functions are allowed. If you insert an invalid expression that defines the approximated function (e.g. forget a bracket or use a mathemati= cal function that is not defined, the text field will turn orange when you atte= mpt to generate the data.
In the “Bounds= i>” box, you can define the interval on which the approximated function is samp= led in order to generate the training data. Number of function values to be generated and used in training is defined next to “Number of training samples”. If the “Random training data” is checked then function will be evaluated in randomly chosen points. Otherwise, it is sampled in equidistant points on the selected interval.
Generation of function va= lues used for training (sampling) is triggered by clicking on the “Generate Data” button. Sampled function values are shown as points on the graph where the original function is shown, too.
The ANN-based approximati= on of the original function is calculated by training the neural network on the sampled values generated before. In this procedure, the internal state of t= he neural network is continuously updated in such a way that the discrepancy b= etween the training data and the outputs generated by the network are minimized. Training (generation of the approximation) begins by pressing the “Start” button and finishes either when the prescribed accuracy is reached or when = the maximal prescribed training time (measured in epochs, i.e. in iterat= ions of the training algorithm) elapses.
The user can define the r= equired accuracy by setting a tolerance (a small positive number) on the RMS (root = mean square) error, which is inserted next to the “RMS” label= . The training procedure will stop when the error measure drops below the user defined tolerance. In order to prevent infinite looping when the tolerance = can not be achieved, the maximal number of epochs can be set next to the ”= ;Max. Epochs” label. If the training algorithm performs that number of epochs, it will stop even if the required accuracy is not reached. The box = next to “Epochs in bundle” just defines granularity of convergence checks, which are not performed after every epoch (iteration) of the training procedure, but only after each specified number of iterations defined by this parameter. This has no significant effect on results in most cases, but speed ups computation by a small factor.
Network architecture can = be defined next to the “Neurons in hidden layers” label. Networks w= ith one or two layers of hidden neurons can be used, and the number of neurons in e= ach hidden layer can be independently defined in the corresponding field. The second number can be 0 meaning that a neural network with a single hidden l= ayer is be used. In general, more neurons in hidden layers means more connections between neurons, thus more free parameters (weights) to be adjusted and bet= ter fitting capabilities of the network (but also increased probability for overfitting and longer computation times). Therefore, approximation of more complex functions (e.g. with wild oscillations or sharp transitions) requir= es more neurons to achieve comparable accuracy as with simple functions, provi= ded of course that the number of training data is also appropriately larger. In= a two layer network, each neuron of the first hidden layer is connected to ea= ch neuron in the second layer, meaning that the number of connection increases quadratically with simultaneously increasing number of neurons in both laye= rs.
Two parameters of the tra= ining procedure, namely the learning rate and the momentum, can be adjusted in the corresponding text fields. These parameters can be both set= to positive values lesser than 1. Increasing the learning rate means that the weights and biases are more quickly adjusted in the opposite direction of t= he error gradient in order to decrease the error, which means faster decrease = of errors at the beginning, but can cause more numerical instability. Momentum adds inertia to the training procedure, and simply adds a fraction of the previous weight update to the current one calculated by error back propagat= ion.
In neural networks used, =
output
signals of neurons are transformed by a sigmoid activation function that ha=
s a
range between 0 and
It is obvious that the in= terval should at least contain all the values generated by sampling, i.e. all func= tion values contained in the training data. However, since it is likely that some function values on the sampled interval exceed the interval that contains a= ll sampled values, some extension of the interval should be provided beyond th= at, and this is what we call the safety factor. User can vary the output safety factor from 1 upwards by inserting the factor into the text field next to t= he “Output Safety Factor” label.
As far as inputs are conc= erned, any input from minus to plus infinity can be fed to the neural network to produce the appropriate output. Inputs are transformed by the sigmoid funct= ion before they are sent to the neurons in the next layer. However, since the s= lope of the transforming function approaches zero far from 0, it is numerically desirable that most of the inputs that will be fed to the network fall on t= he interval [-1, 1]. Input value= s are therefore also scaled in a similar way as outputs, and the mapping function= is specified in such a way that all inputs from the training data are mapped c= lose to the interval [-1, 1] before they are fed to the neural network. The input safety factor defines how much smaller from the reference [-1, 1] interval = is the interval to which all inputs from the training data fall when scaled be= fore being fed to the network.
When the training procedu= re is completed (after clicking the “Generate Data” and then the “Start” buttons), results are shown automatically. The original function, its neural network approximation calculated by the training procedure, and the training data on basis of which the model is calculated = are plotted on the graph located on the top-right portion of the form.
On the graph below, insid= e the “Approximation error” box, the course of different error measures during the training procedure can be shown, plotted against the nu= mber of epochs. By clicking on the appropriate radio button you can choose which= error measure is shown on the graph, while final values for all error measures are written in the appropriate boxes.
Figure 2=
: Convergence of different types of errors.
Max Training =
Error
Maximum absolute error calculated on complete training= data set after each set of epochs (Epochs in Bundle) and shown on graph
Rms Training =
Error
Root mean square error calculated on complete training= data set after each set of epochs (Epochs in Bundle) and shown on graph
Max Verificat=
ion
Error
Maximum absolute error calculated on complete verifica= tion data set after each set of epochs (Epochs in Bundle) and shown on graph. Verification data are not used in training procedure, but are separated from training data and used just for verification the accuracy of ANN during and after training.
Rms Verificat=
ion
Error
Root mean square error calculated on complete verifica= tion data set after each set of epochs (Epochs in Bundle) and shown on graph. = p>
Fi=
gure 3: GUI for
approximation of functions of two variables.
a. Bounds of the graph
b. Option for scaling to =
range
(0,1) in all directons
c. Definition of approxim=
ated
(sampled) functtion
d. Number of training poi=
nts
for ANN in both directions
e. Button to generate tra=
ining
data
f. Option for random samp=
ling
g. ANN settings
h. Start training
i. Reset all to default
j. Error type
k. What to show on graph,=
with
sliders for opacity
Exploring 2D approximatio= ns is just as simple as exploring 2D approximations. You can start without any sp= ecial knowledge, just click on the “2D Approximation” tab in o= rder to display the appropriate panel (Figure 3), and then the “Generate Data”= and then the “Start” button. Before clicking on the ̶= 0;Start” button, you should wait until the graphic window showing the approximated function and sampled data is displayed, and close the window. Graphs are shown in a separate windows in order to allow better quality and interaction with 3D graphs.
When the training procedu= re completes, the graph showing the result is open immediately in a new window. You can interact with the graph (rotate it, zoom in or out, and translate i= t) in order to view interesting details from the best perspective, and you sho= uld close the graph before performing other actions.
The function to be approx=
imated
is defined similarly as for 1D approximation (see Section 2.2.1). In the case of user defined function, the
expression defining the function can contain two independent variables, den=
oted
by x and y, respectively. Since there are two variables, four
interval bounds must be defined in the “Bouds” box. Thes=
e define
minimal and maximal values of independent variables x and y in generated
sampling points. Besides, there is a checkbox saying "Scale All to Range 1". If this is
checked then graphs will be scaled such that all edges of the graph along
co-ordinate axes will have the same lengths. This is useful when ranges of =
data
values along co-ordinate axes have huge differences in scale and hraphs in =
real
proportions would seem excessively elongated in cerain directions.
Everything is rather simi= lar than in 1D approximation, and some differences are outlined below. Also the numb= er of sampled values is defined by two values instead of one. If you clear the “Random Training Data” checkbox then values are sampled = on a regular grid of points, where the text field beside “Samples on X = axis” defines number of points on the grid in x direction, and “Samples = on Y axis” defines number of points on the grid in the perpendicular (= y) direction. If the “Random Training Data” checkbox is checked th= en sampling points are generated randomly (with uniform distribution) and the = two directions are not distinguished what concerns the generated points. The to= tal number of the generated sampling points equals to the product of both numbe= rs, but their order is interchangeable.
Things related to the net= work architecture and parameters of the training algorithm are defined in the sa= me way as in the case of 1D approximation (see Section 2.2.2).
Just take into account th= at in general, in the case of two independent variables, more degrees of freedom = are needed for the same quality of approximation as in 1D. This means that the number of neurons in each hidden layer should usually be higher than in the= 1D case, but consequently also the number of sampling points should be higher.= To be precise, this is a bit simplified and overly generalized statement since= the optimal number of neurons varies from case to case and depends primarily on= the complexity of the function to be approximated. However, on average over a l= arge range of functions, the statement is valid.
Fi=
gure 4: Results of a 2
parametric approximation are shown as 3D graph. Right-hand side: window that
shows the original function sand training data. 3D graphics is rendered by =
the
VTK graphical engine.
Training data and the approximated function are shown, after clicking on the “Generate data”, in a separate interactive 3D window. In a similar way, the resulting approximation is shown, together with the approximated function a= nd training data, after clicking the “Start” button (Figure 4). You user can interact with 3D graphs by mouse a= nd keyboard in order to adjust the viewing angles, position and zoom as desire= d. Close the window after viewing is done, since failing to do so may result in undesirable effects, depending on the operating system.
· j / t – toggles between = joystick or trackball mode. In joystick mode, motion occurs continuously as l= ong as mouse button is pressed. In trackball mode, motion occurs only during dragging (when the mouse button is pressed and the mouse cursor moves). The trackball mode is more suitable for finely adjusting the view.
· left mouse button – rotates the= camera (in the camera mode, switched on by pressing the c key) or graphic objects (in the actor mode, switched on by pressing a). The camera is rotated around the focal point (which can be repositioned by pressing the <= i>f key over a graphic primitive). In trackball mode, you must press the button= and move the mouse cursor, while in joystick mode pressing the button is enough (switch between the two modes by pressing the t or the j key)= .
· Ctrl + left mouse button – rota= tes the camera (in camera mode, switched on by presing the c key) or gra= phic objects (or actors, switched on by pressing the a keys) around the a= xis perpendicular to the projection plane.
· Shift + left mouse button – pans the camera (moves it parallel to the projection plane) in camera mode or translates the graphic objects (actors) in actor mode. Does the same as the middle mouse button.
· middle mouse button – pans the camera (moves it parallel to the projection plane) in camera mode (switched= on by pressing the c key) or translates the graphic objects (actors) in= actor mode (the a key). In joystick mode, translation is from the center of viewport toward the mouse cursor position (toggled by pressing j for joystick and t for trackball mode). Camera mode is switched on by pressing the c key and actor mode by pressing the a key.
· right mouse button – zooms the camera (in camera mode, switched on by pressing the c key) or the graphic objects (actors). In joystick mode (switched on by pressing the = j key) the direction of zoom depends on whether the mouse cursor is located in the top half of the window or viewport (zooms in) or in the lower half (zoo= ms out) while the zoom speed depends on the distance from the horizontal centerline.
· mouse wheel – zooms in or out, dependent on the direction of rotation.
·
f – flies to the point u=
nder
the mouse cursor, and sets the focal point on it (rotations then occur arou=
nd
that point). This command works only when the mouse cursor is located close=
ly
enough over a graphic primitive (auxiliary objects such as axes do not coun=
t). It
centers the graph around the point under the mouse cursor. If later on the
graph is translated, the point of rotation still remains on the same point
until the next ” fly to” operation is performed.
· c / a – toggles between = camera and actor modes. In camera mode, user interaction affects the camera position and focal point, while in actor mode it affects the object (“= ;actor” in VTK terminology) under the mouse pointer. Therefore in actor mode one can rotate and translate different objects independently. This enables e.g. separation of different graphic objects. You can press a, then click= on the graph of the original function with the middle mouse button and drag it away from other objects, then press c and center the view around the graphs of the approximation and sampled points in order to view them togeth= er, without the original function.
· p – pick operation. This shows a wire frame around the object under the mouse cursor. This may turn useful in rare occasions in order to see to which object the graphic primitive under = the cursor belongs, e.g. when separating objects in actor mode.
· s / w – all objects beco= me represented as surfaces / in wire frame. You will seldom need this command.=
· e / q – exits / quits the graphic window.
User interaction capabili= ties can be used to precisely position the view in order to make interesting details appear more obvious, but also for achieving some special effect. Figure 5 demonstrates, for example, how actor mode (switch= ed on by pressing the a key and switched off by pressing the c k= ey to go back to camera mode) can be used to move the graph of the approximati= on apart from the graphs of the approximated function and sampled values used = for training. This has been done in the following way. First the trackball mode= was switched on by pressing t. Then the graph was rotated (left mouse button, with holding the Ctrl key for rotation in the projection plane), translated (Shift + left mouse button) and zoomed (right mouse button or mouse wheel) in order to achieve the appropriate view. Then, the actor mode was switched on by pressing the a key, and the approximation (the colored surface) was moved away from the original location to the right by pressing and holding the Shift key and pres= sing the left mouse button and moving the mouse to the right. Finally, th= e c key was pressed in order to get back to the camera mode and finely tune the whole graph by translation of the camera. Since objects were not zoomed whi= le in the actor mode and since rotations were not performed since entering the actor mode, one can see the realistic ratios between the original function (blue wireframe) and its approximation (colored surface) and it is obvious = that the approximation has lesser total span than the original.
In the camera mode (switc= hed on by pressing the c key), all graphic objects stand still and the came= ra rotates and translates around. In the actor mode (switched on by pressing t= he a key), camera remains still and the selected graphic object (which may consi= st of many graphic primitives, such as the whole surface in the above described case) moves and rotates (thus it can also change position with respect to o= ther objects).
Fi=
gure 5: Separation of =
the
graph of the original function and sampling points (left-hand side) and
approximation (right-hand side) by using the actor mode. Case is the same as
shown in Figure
4.
&= nbsp; &nbs= p; &= nbsp; &nbs= p; &= nbsp; &nbs= p; &= nbsp;
Figure 6=
: Convergence of different types of errors.
Max Training =
Error
Maximum absolute error calculated on complete training= data set after each set of epochs (Epochs in Bundle) and shown on graph
Rms Training =
Error
Root mean square error calculated on complete training= data set after each set of epochs (Epochs in Bundle) and shown on graph
Max Verificat=
ion
Error
Maximum absolute error calculated on complete verifica= tion data set after each set of epochs (Epochs in Bundle) and shown on graph. Ve= rification data are not used in training procedure, but are separated from training da= ta and used just for verification the accuracy of ANN during and after trainin= g.
Rms Verificat=
ion
Error
Root mean square error calculated on complete verifica= tion data set after each set of epochs (Epochs in Bundle) and shown on graph. = p>
Figure 7=
: Accessing help and other information.
Figure 8=
: NeurApp has an intuitive user interface. All you need to
remember is to press the “Generate Data” and then the “Tr=
ain
Network” button, which is the same for functions of one and two varia=
bles.
Other controls are for changing parameters of the training procedure, bound=
s of
training data, and the function to be approximated.
Figure 9=
: After pressing the
“Train Network” button, training of the neural network begins, =
and
the result is shown immediately after training is complete (the same applie=
s to
functions of two variables). It is easy to compare the generated ANN model =
with
the original function. Smaller graph shows how error was reduced during the
training procedure, making possible to correct some parameters such as
tolerances and maximal number of epochs if results are not as expected.
Figure 10: Example 3D plot of =
the
original function of 2 variables and the generated training data on the sur=
face
of the function graph.
Figure 11: After training of t=
he
neural network is complete, a surface plot of the approximated function is
shown together with the original function and with the generated training d=
ata.
Error magnitude is shown in color scale.
Figure 12: One can interactive=
ly
adjust the viewing angle and zoom in order to inspect properties of the
approximation in detail.
Figure 13: Finally, there are a
number of display options that make inspection of the approximation and its
errors really easy and clear. One can individually switch on or off display=
of
training points, grid, surfaces and contours of the original function and i=
ts
approximation. Transparency of both surfaces can be continuously adjusted. =
In
this figure, both original and approximated surface were drawn relatively
opaque, therefore it is immediately clear where approximated function has
higher or lower values than the original one. Contours of the original func=
tion
are displayed, which gives better feeling of 3D shapes.
Figure 14: This shows the same approximation as the prev=
ious
image, but surface of the approximation function is more transparent and
surface of the original function is not shown. This makes comparison of grids easies,
color indication of regions with greater or smaller errors is still visible,
and contours and grids are not obscured.
Figure 15: Zoomed detail with the same settings as in the
previous figure.
Software was initially de= veloped by Igor Grešovnik and Tadej Kodelja as an easy to use and intuitive to= ol for exploring features of approximation by the artificial neural networks (= ANN). Authors have developed the software while working on ANN-based model of pro= cess parameters in material production in the Centre of Excellence for Biosensor= s, Instrumentation and Process Control (COBIK). In the scope of h= is work at COBIK, Tadej Kodelja was also working on his Ph.D. thesis under supervis= ion of Prof. Božidar Šarler and Igor Grešovnik.
The software is based on = the Investigative Generic Library (IGLib), a framework library for development of = engineering applications. The library itself is based on the .NET framework and relies = on a number of third party libraries. It has been used by several commercial software projects as well as in research projects. Among the others, it ser= ves as code base for the software for industrial ANN-based modeling, NeurApp. This is a complex software used as support to ta= ckle challenging modeling problems in industry. It requires some expertise and skills to use that software, but with the benefit of a powerful and flexible problem solving tool. The software is used internally for performing resear= ch and providing services to industry, but authors are open for all kinds of c= ollaboration where the software can be utilized.
Motivation for developmen= t of NeurApp came partially from authors’ personal needs, since authors wanted to = quickly gain better insight in features and function of different ANN-based algorit= hms, either existent from third-party libraries or the ones developed by the aut= hors. For this purpose, they created a simple software where one can conceive arbitrary functions of one or two variables, input these functions through a graphical user interface and set them as the reference functions for ANN-ba= sed models, sample function values on a regular grid or randomly, train the tra= in different neural networks with different parameters, and inspect properties= of the obtained approximative models by observing various statistics and by vi= sual comparison of the model and the original reference function. In this way one can quickly develop some basic feeling of performance features of tested algorithms.
Additional motivation was= in creating a tool that could be easily utilized to demonstrate some features of the artificial neural networks to our colleagues. People often have wrong expectations about the ANN-based modeling. Many times they heavily overesti= mate the capabilities of the neural network modeling, considering this tool as a kind of Panacea, an almighty remedy for all problems. It is sometimes diffi= cult to explain that ANNs are just an ordinary (though very strong in some aspec= ts) utility for black box modeling. As such, it crucially depends on the availability and quality of data, thus being susceptible to many kinds of d= ata deficiency and absolutely adherent to the “garbage in, garbage out= 221; principle. By the tool such as NeurApp, it is easier to more lively demonstrate how ANN-= based modeling works.
For authors’ needs,= the first versions of software had the possibility to switch between ANN architectures and training algorithms. The software was later adapted to be= better suited for general public, enabling the users to play with a single network architecture and training algorithm in order to produce more easily compara= ble impressions.
Below is a collection of = selected references and links that are in some way related to the NeurApp software. They are mainly related to the authors’ past work that brought to the situation where NeurApp was created. References [1] - [= 3] are some papers published within the scope of our work at the Centre of Excellence for Biosensors, Instrumentation and Process Control (COBIK). [8] - [11] are references related to optimization shell = Inverse, which is a complex industrial & research optimization software written = in C that preceded the IGLib library, and where many concepts and ideas u= sed in the IGLib library (a framework library for development of technic= al applications developed by Igor Grešovnik, reference [6]) come from. Aforge.Net (reference [7]) is a library that is used as neural networks computation engine in NeurApp.
References [14] and [15] are links to the institution Centre of Excellence for biosensors, instrumentation and process control (COBIK) and the laboratory where the authors currently work. Within COBIK, authors are developing methodologies for application of artificial neural networks to modeling of industrial processes. The problem solving software developed in the scope of this work is based on the IGLib = ([6]). This is also the case with NeurApp= i>, which is just a side product of the above work initially developed as a simple tool for authors’ training in basic features of ANN-based approximation.
The more professional sof= tware used for actual research & industrial work is quite complex and require= s a high level of expertise from the user, and it is interpreter - centered rat= her than a GUI - based. It is used internally for performing research tasks and= to offer services to industry, with interfaces to a number of partner software= and with some specialized interfaces for users in partner organizations. This software is designed to be highly flexible and quickly adaptable to new problems and customer requirements. The software is not available for purch= ase, but authors will welcome any suggestion for collaboration on research, development or industrial projects or request for customized software, where they can provide reliable and professional service.
[1] Grešovnik,
[2] Grešovnik,
[3= span>]&= nbsp; Grešovnik, I.; Kodelja, T.; Vertnik, R.; Senčič. B.; Kovačič= ;, M.; Šarler, B. (2012): Application of artificial neural networks in de= sign of steel production path. Computers, Materials and Continua, vol. 30, pp. 19-38.
[4]=
Grešovnik,
[ [6] Grešovnik,
[7] Aforge.Net. (2012): Artificial intellig=
ence
library. Available at: http://www.aforgenet.com/. [8] Gresovnik, =
I.
(2000): A General Purpose Computational Shell =
for
Solving Inverse and Optimisation Problems - Applications to Metal Forming
Processes
[9] Grešovnik,
[10] Grešovnik,
[11] Grešovnik,
[12] Grešovnik,
http://www2.arnes.si/~ljc3m2=
/igor/ioptlib/doc/optlib.pdf.
[13] Grešovnik,
[14] Centre of Excellence for biosensors,
instrumentation and process control (COBIK) http://www.cobik.si/index?lang=3Deng.
[15] Laboratory for Advanced Materials Systems, COBIK: = http://www.cobik.si/laboratoriji/laboratorij-za-sisteme-z-naprednimi-ma= teriali?lang=3Deng
1. Introduction &nbs= p; &= nbsp; &nbs= p; &= nbsp; &nbs= p; &= nbsp; &nbs= p; 2.1. Installation and Use |
Igor Grešovnik: NeurApp
NeurApp
<=
b>About<=
span
lang=3DSL style=3D'mso-no-proof:yes'> the Software &n=
bsp;  =
; &n=
bsp;  =
; &n=
bsp;  =
; &n=
bsp;  =
; &n=
bsp; NeurApp=
References
=
&nb=
sp; =
&nb=
sp; =
&nb=
sp; =
&nb=
sp; =
&nb=
sp; NeurApp
Sandbox  =
; &n=
bsp;  =
; &n=
bsp;  =
; &n=
bsp;  =
; &n=
bsp;  =
;