1. DiscoverNet: Adaptive Simulation-Based Learning Environment
And Support System for Designing Neural Networks
Safia Belkada, Alexandra I. Cristea and Toshio Okamoto
AI & Knowledge Engineering Lab., Graduate School of Information Systems
University of Electro-Communications
Choufugaoka 1-5-1, Chofu-shi, Tokyo 182-8585, Japan
safia@ai.is.uec.ac.jp
Abstract
For the greatest part, intelligent tutoring systems (ITS) have attempted to implement traditional
methods of learning, teaching, train-and-practice, in which students solve relatively simple problems,
chosen in advance by the teacher. Recently however, adaptive educational systems and flexible learning
systems are being considered, as an alternative, powerful new strategy of teaching/learning. This paper
presents the development of an adaptive simulation-based learning environment for designing neural
networks (DiscoverNet), for discovery and self-learning. We chose ‘neural networks’ (NN) as
application domain, due to the fact that their study is particularly suitable for an adaptive, learner level
adjusted approach, as we will show in the paper. We embedded in the NN Computer Aided Design
(CAD) teaching system also a consultant module that is responsible for the educational orientation
during the design of neural networks. Our consulting function is based on storing and processing the
domain knowledge on NN, as well as the current user’s NN knowledge, in a knowledge based neural
network (KBNN) form. This paper presents our DiscoverNet system, with a special focus on the
adaptive features of the KBNN consultant module. We also present a case study for the beginner user,
as well as the results obtained. We will also discuss the educational methods used, as well as the
advantages we are aiming at with these methods.
1 Introduction
1.1 Background and Related Work
Recently, the trend towards developing interactive learning environments or intelligent tutoring systems is gaining
in strength, and, as McArthur et al. [5] pointed out, there are various examples of such researches now a days.
Simulation-learning environments have been proven to be an effective learning strategy [2,5]. This kind of strategy
allows learning by using simulation, by engaging learners to manipulate, freely and directly, concrete objects in the
experimental environment, and observe the changes induced by their manipulations. The aim of this type of
functionality is to foster the integration of theory and practice. The various possible situations, which are implied
implicitly or explicitly in the environment, build up the learner’s experience and, through trial and error, attract the
1

2. learner and support him/ her in establishing his/ her independence and develop his/ her fundamental comprehension
[1,3,10].
Building support environments using only symbolic, knowledge-based systems often leads to the well-known
knowledge acquisition bottleneck. A sub-symbolic neural network model can be trained to perform reasonably well -
based on the training data sets - but it cannot readily incorporate domain knowledge or provide explanation of the
results. A hybrid system made of a combination of the two approaches cited above has been shown [6] to outperform
both, when used separately. There are different approaches to constructing hybrid intelligent systems, which aim to
exploit the features of knowledge-based systems and neural network methods [6,8,11]. One way [11] is to translate the
domain theory into a neural network, and thereby determine the neural network’s topology, then refine the reformulated
rules, by using, for instance, backpropagation. The KBNN algorithm falls in this category [11]. We are building on the
KBNN approach, but with the difference that we use the KBNN network space as a search space for the correct network
topology, closest to the user designed network, as we will show further on.
1.2 Neural Networks as a Problem Solving Tool
There has been a great interest in artificial neural networks over the last few years, as researchers from diverse
backgrounds have produced theoretical foundations and demonstrated numerous useful applications of this field [9].
Neural networks are tools for solving many types of problems. These problems may be characterized as mapping,
clustering, and constrained optimization. There are several neural networks available for each type of problem. For
many applications, the mapping of the problem on a neural network requires detailed understanding of neural networks,
which can be achieved only by performing calculations by oneself, and by developing some simulators for extremely
simple examples. Most students that have to use neural networks, often have to face great difficulties to even acquire a
working knowledge of the very basics. Such problems, indeed very common in many areas, require however knowledge
about highly abstract concepts. When using neural networks for different domain applications, this involves
constructing simulators, and this can be very difficult to do, for example, during a NN lecture. For the same reasons,
students cannot really be expected to solve anything by trivial exercises during tutorials. This is not so much due to the
conceptual difficulties inherent in the neural networks, but a simple consequence of the representational complexity of
such a model, unrelated to the pedagogical method used. To overcome these problems, we build an adaptive learning
environment, to encourage the student to develop a deep understanding of the mechanisms of training and applying
neural networks.
2

3. 1.3 Our Research Goal and Methodology
In this paper we propose a framework based on a hybrid approach, integrating a knowledge-based system with the
neural network paradigm, to support learning neural networks within the DiscoverNet system. DiscoverNet allows
learners (for the sake of convenience only, we will use in the remaining the word “user” to refer to learner) to build
their neural network simulators, by blending theory and praxis within the environment, and facilitate learning through a
tutoring program. The system is based on the concept that neural networks can be broken down into a fundamental set
of neural components [4]. The user constructs his/her domain theory in the environment where s/he can choose some
components and find the pattern of relationships among these components. We embedded a consultant module in the
system that is responsible for the educational orientation during the design of neural networks. The consultant
reproduces the initial neural network, which is made by the user during the manipulations of neural objects, by using a
set of inference rules, to help determine the network's architecture and initial weight values. The consultant examines
which information is lacking or wrong, and sends it to the user, together with the initial network, showing the user
his/her misconceptions. The system has an object-oriented architecture, in which an adaptive user interface adjusts to the
user's skills, and has the role of the motivator in the discovery learning process. I.e., the interface allows visualizing
neural models as concrete neural objects. A user builds his/her models by making use of the neural objects and methods
provided by the library of objects. The system is based on a network of networks, adapting itself to the current user. The
order of constructing neural networks was chosen to reflect the complexity of the course material. However, the
material at each level is independent, so that the user may enter the design session at any level and in almost any order
s/he desires.
In this paper we will first show the difficulties that appear in teaching neural networks, and thereby justify the need
of an adaptive learning environment for this field. We identify the interaction with the design mechanism and the
visualization of abstract concepts as two different components of the pedagogical tool for teaching neural networks. Our
students are seniors, or graduate students, in science and engineering. It is assumed that the user is familiar with
calculus and some vector-matrix notions and operations. The mathematical treatment has been kept at a minimal level
in the system, allowing the users to build their neural networks by blending theory and praxis within the environment,
without too much delay or overhead.
The paper is organized as follows. Section 2 describes the basic features of the CAD learning system and its
underlying learning environment. In Section 3 we describe the computational aspects of the support system, via the
domain knowledge representation, followed by an illustration of the advice process. Experimental results and their
3

4. evaluation are reported in section 4, highlighting learning capabilities and properties of the system. Finally, we draw
some conclusions and evaluate our system from the educational point of view.
2. Simulation-Based Learning Environment
2.1 Neural Network Models and Preliminary Research
The most distinctive element in neural networks, as opposed to traditional computational structures, is denoted as
learning. Learning represents the adaptation of some characteristic neural network parameters, by using a set of
examples (known as outcomes of the problem for given conditions) so that, for given input patterns, the outputs reflect
the value of specific functions. The final data-modeling goal is to be able to generalize from prior examples (to be able
to estimate the outcomes of the problem under unknown conditions). Neural networks represent the combination of
architecture (topology) and appropriate learning techniques. Most NNs are often classified as single layer or multilayer
NNs. A neural network model is formally defined by a quadruple < S, W, L, F >, where W is a set of weights (wji), L is
a set of learning algorithms (la), F is a set of external activation functions (fact), and S is further defined by a pair (N, C),
where N is a set of units (ni) and C a set of connections (ci). Assume n units in a neural network model. We have the
following definitions:
N = {ni| 1 ≤ n}
C ⊆ {(ni→ nj) | 1 ≤ (i, j) ≤ n}
W ⊆ {(ni→ nj, wji) | 1 ≤ (i, j) ≤ n}
L = {la1, la2…}
F = {fact1, fact2…} (1)
The number of connections between the units defines the number of layers in the NN. Each two connected units have
an associated weight. The weights represent information being used by the model to solve the problem. Each learning
algorithm is a mapping that transforms one neural network state, which is defined by the set of W, to another neural
network state. For the most typical neural network setting, training is accomplished by presenting a sequence of vectors
or patterns. The weights are then adjusted according to a learning algorithm, i.e., in backpropagation, by summing the
weighted inputs and applying an external activation function. Typically, the same activation function is used for all units
in any particular layer. For instance, let F be a set of activation functions F ={f}, and Xi, Yj a sets of input and output
units. Assume that xi ∈ Xi and yj ∈ Yj. The output, yj, is expressed as:
yinj=Σxiwii ( 2)
4

5. yj =fact(yinj) ( 3)
We have based our CAD teaching environment on some knowledge extraction from three domain specialists, teachers
and professors of Neural Networks at university level and higher. The information based on their experience was
refined and used for the implementation of our system.
2.2 Knowledge Representation and Object Manipulation in DiscoverNet
Abstract
Class
neural
Learning algorithms
Backprop
Kohonen
-addNeuronLayer
-createMapLayer
-connectLayers
-getActivationArea
-learn�
.
Weight matrices Layers Units
-changeWeights -activateSigmoid -activation funct
--compOutputErr
Unit map
Comment objects
Specific
objects
pattern Input value
The domain knowledge of neural networks is represented in the system as a KBNN set of neural objects stored in
Inputs objects
the object library (figure 1). The object library consists of a package of classes, which provide meta- representations for
the graphical objects. The architecture of each class has two levels. The object knowledge level is based on objects and
Figure 1: Neural Net Knowledge Base
contains the core of formal and procedural concepts related to the neural network models. The user creates instances of
a class when s/he manipulates objects. For instance (figure 2), in the feedforward neural networks [7], the initial
instances are the creation of activation functions instances, initial matrix weight instances, and control parameters
instances. The user can interactively create instances and specify the values associated with the relevant functions. The
structural knowledge level allows the exploration of the design stage by defining concepts and relations (e.g., learning
algorithm) over the object knowledge. The structural knowledge is a set of rules defined on sets of instances from the
domain knowledge. The modeling of the domain knowledge of neural network consists of hierarchical relations
between various neural network models, as described in Figure 1. We construct models of knowledge for various neural
network models and various design models for a particular knowledge model.
5

6. Each object encapsulates a state and events. Modeling knowledge domain consists of hierarchical relationships of
various neural network models: we construct knowledge models for the various neural network models, and various
design models established for a particular knowledge model. The levels shown in Figure 1 do not represent levels of
abstraction, they only show, which classes are present and what classes have relationships to each other. The abstract
class “Neural” contains generic methods, e.g., a method to set the initial learning rate of a neural net. Note that the
system prototype contains classes suitable for the Backpropagation network and the Kohonen Feature Map network.
These types of neural networks are considered as most powerful, yet basic, models [7]. We chose these models because
they are the most used, and the equations that describe the models are simple compared to other models. Multilayer
perceptrons (MLP) are feedforward networks trained with static backpropagation [7]. These networks are used in many
applications requiring static pattern classification. Backpropagation is a learning algorithm used to change the weights
connected to the network’s hidden layer(s) [7]. The backpropagation uses a computed output error to change the
weights values in backward direction. It is vitally important to choose the correct algorithm, since the choice of the
algorithm can affect the final neural network performance. For the first steps in the neural network domain, a novice
user can try to handle similar problems of growing complexity.
Figure 2 shows a simplified user action model constructed by the consultant. Each node represents a design
object instance. Each design object tree can be decomposed into components required to accomplish the higher-level
node restrictions. Actions are at the lowest level in the graph. The decomposition may lead to nodes that are sequential.
Sequential nodes represent actions that must be performed in the prescribed order. Arcs represent events that describe
the initiating and terminating state of an action.
Major learner actions
Supervised Unsupervise
learning d learning
Actions to design a specific neural network
Learning Algorithm,
e.g.,backpropagation Input data
Architectu (training/testing data)
re
Parameters’
specification
Related components actions
6

7. Weight matrix
Number of layers/ Learning rate
units
Threshold
specifications
Connections’ type
e.g., full_connection
Figure2: User’s Design Model
In the following, the state and event concepts that we used will be explained.
2.2.1 State
A state, X, is a class variable which is a numerical attribute (e.g., an initial weight matrix), a characteristic of a
neural object (e.g., activation function) or a process (e.g., learning algorithm). It can be computed from predefined
formulas.
2.2.2 Event
Our definition of events is analogue to the definition of events in object-oriented computation. The event handling
determines the communication between interactive objects. Our communication model is a connective model, which
allows any object to communicate with any other one. However, for instance, in order for the “full_connection” object
to communicate with a unit object, it must have a pointer to that object. In such a case, the “full_ connection” object
can invoke some method on the unit object that handles the communication. The neural network model is constructed
from a collection of objects and the appropriate relationship between them. The overall design is provided by the object
interaction. However, although breaking down neural models into a set of neural objects reduces their complexity, it
sometimes leads to larger sets of objects. To manage these objects we determine the relationship existing between them
by using the inheritance mechanism.
Figure 3 shows an example of object interaction mechanism via messages that lead to object state transition.
Message
corresponding to
the trigging
simulation stage Simulation trace file
Message
analyzer
Message object transmission
Activate object
7
Figure 3: objects interactions

8. 2.3 DiscoverNet System Architecture
With DiscoverNet the user designs a neural network model through different manipulations of objects existing in the
library and different requests to the system for helps and hints. Figure 4 shows a simplified control flow of DiscoverNet,
which consists of the following parts:
(i) Adaptive user interface: it consists of the learning and authoring environment related to the design of the neural
network models. It is in this part also, where the user model representing the individual’s understanding level is first
analyzed and built.
(ii) Knowledge based neural network: it accumulates neural network models. Each neural model consists of the
respective architectures, learning algorithm and set of parameters [7]. The selection of the appropriate parameters and
architecture for a given application is made after many trials.
(iii) Consultant module: it manages the communication between different parts and gives assistance to the user
whenever it is needed.
(iv) In Figure 4, the design database stores representations of the design description made by the user of the solving
procedures of one specific application.
(v) The object library contains components of neural networks.
(vi) The system gradually builds a user model, and uses it for the analysis and understanding of the real user’s needs.
The consultant module uses this model, in particular, to generate useful guidance and correct the user mistakes.
User Model
Object Library
Adaptive user Interface
User
Knowledge Base
CONSULTANTMODULE
Neural Network
(KBNN)
Advisor
Design
Database
8

9. Figure 4. Architecture of DiscoverNet System
3. Discovery Learning Support System
In this section, we analyze the approach used for the consultant. The consultant module gives advice to the user
considering different possible concept descriptions, by integrating a knowledge-based system with a neural network that
helps the former to refine the initial domain knowledge. The consultant has two main parts: the rule base and the
advice algorithm.
3.1 The Rule Base System
A rule-based system captures the decision-making of the design. The decision-making rules consist of packages of
classes that attempt to identify objects or decide on actions:
(i) Design classes contain a set of rules, which describe the construction of a neural network model according to what
constraints should be given in the design stage and what information is desired ( An example can be found in figure 5).
(ii) For each Design class we define a set of rules that describe a specific neural network model and we name it
Specification class (Please find and example in figure 6).
(iii) Advisor classes manage the communication between the user and the whole system.
Rule MLFFwithBP = new Rule(rb, "MLFF_with_BP",
new Clause(supervisedType,cEquals, "Norecurrent") ,
new Clause(activfunc,cEquals, "nolinear"),
new Clause(learning,cEquals, "Backpropagation"),
new Clause(training,cEquals, 巴 atch_training")) ;
�
Figure 5. Definition of rules in the Design class
RuleVariable supervisedType = new RuleVariable("Supervised_Type") ;
RuleVariable learning = new RuleVariable("learning") ;
RuleVariable activfunc = new RuleVariable("ActivFunc") ;
learning.setLabels("Delta_rule Error_correction Competitive_learning Backpropagation") ;
Figure 6. Definition of rule 痴 variables in the specification class
3.2 The Advice Process
In the following we examine the computational approach of the advice process by using our algorithm, which has
9

10. two phases:
1) Searching through the space of neural net architectures H.
2) Training the neural network and providing feedback information.
Figure 7 shows the advice process in the consultant. The consultant diagnoses a neural model made by the user by
constructing a script file during the user's manipulations of objects (considered as initial domain knowledge). The
algorithm uses the initial knowledge to help guide the search through the space H and determine a starting point in the
weights space. The algorithm then tries to translate the script file into a set of units represented as an AND/OR
dependency tree. From the tree, the consultant chooses a proper index, related to the learning algorithm, and examines
whether the architecture and the corresponding parameters can be approximated in the space H. The following
algorithm describes the searching method:
(i) Assume I <S2, W2,L2,F2> is a set of instances representing the initial knowledge (user input).
(ii) Select h <S1,W1,L1,F1> with q layers in H,
(iii) I= I+ U I-: I+ is the set of instances satisfying h, and I-,those that do not satisfy h,
(iv) Map h <S1,W1,L1,F1> with I <S2,W2,L2,F2>
(v) Compute the probability P to choose the best initial weights in h to be included in I+,
∑ w ji
( j ,i )∈I
(vi) Pi = , Where wji ∈ I is weight value from unit i to unit j. The probability of belonging to the
∑ w ji + ∑ w ji
( j ,i )∈I ( j , i )∈H
instance I- is (1-this probability). The consultant tends to assign most of the nodes that are heavily linked together. This
helps to minimize the destruction of the design model I made by the user, since nodes belonging to the designed model
are connected by heavily linked weights.
(vii) I can be mapped to h if card (I+)= card (h)
(viii)
(ix)and
Pi ≠ 0.
That is, h can induce all possible partitions of I+ instance if the dimension of h is equal to the one of I+.
: File transformation
: Algorithm 10
NN made by the system and
: Input/output Candidates of best parameters for
Script :file: Analyzer algorithm
Learner
Rulebase the neural model presented to the
Domain
Actions trace file transformation learner
Searcher/
Knowledge : Database the NN) H)
(Train
Algorithm (space

11. Design/specification
classes
Rule1: {MLP,
superv}
Rule2:
{MLP,Bp,input/outpu
Initial neural model
made by a user
AND/OR Tree
Consultant Module
Constructed Neural
Model: graphical
representation
Figure 7 Advice Process in the Consultant Module
The induced network is a fully connected neural network with L ={l}, where l is the learning algorithm chosen by the
user, F = {f1, f2…fq}, where F is the set of activation functions. The weight values are confined to the range from –1 to –1;
that is, -1 ≤wji ≤ 1 for all wji, 1≤(i, j) ≤n, where wji is the weight associated with the connection pointing from unit i to
unit j. The consultant optimizes the induced neural network as follows:
(i) Neurons chosen by the user are initialized with heavy weight connections,
(ii) Lightweight connections are added to the network to facilitate the correction of the user's NN,
(iii) Additional input neurons may be automatically added by the system to the network, to incorporate features,
which do not appear in the network made by the user,
(iv) The consultant initializes the weights and biases if needed (i.e., if not already initialized by the user).
The consultant examines which information is lacking or wrong and sends the result to the user together with the initial
network showing the user’s misconceptions.
4. Implementation and Results
11

12. The experimental results are organized into three subsections. The first part explains the functionality of the learning
environment while the second part illustrates an application example for parameter computation, and the last part
represents a case study of parameter settings for the novice user training. For the experimental purpose, we have used
simple logic functions as problem applications.
4.1 Sample Assistance Process
At the start of the session, the main screen pops up as shown by Figure 8. The user builds his/her network by
assembling objects. The system constrains the network to be physically possible, by graphical representation restrictions
(see figure 10). When the design is satisfactorily completed, the user is required to train the network by specifying a
learning algorithm accompanied with its specific parameters. The environment shows the output data of the network
and the corresponding graph. In fact, to build a neural model, starting with the data, the user constructs the topology of
his/her neural model and specifies its initial weight matrices and learning parameters. Each layer of the constructed
model has to contain vectors of data for input/output units. When the learning algorithm is selected from a list of
options contained within menus, the training session can be started. At the end of the training session, the output pattern
of the data and the corresponding graph are shown to the user as final results.
Since the selection of appropriate parameters is crucial for a fast convergence of the algorithm [8], the user may
impose some constraints on the parameters. It is practical that the user specifies how much correction should be applied
to the weights by tuning the parameters.
Figure 8. Neural Network Design Session
12

13. 4.2 A MLP Weight Computation Example
This section presents a weight computation case study. Suppose that we have the following 3-layered MLP:
Input layer Hidden layer Patterns to be learned: Input
target
Output layer 01 0
Input Values
11 1
Output value
Weight matrix 2
Weight matrix 1 0.35
0.62 0.42 0.81
− 0.17 0.55
Figure 9. Weight change according to input patterns
First, the weight values are set to random values in weight matrix 1 and weight matrix 2. The learning rate of the net
is set to 0.25. Next, the values of the first input pattern (0 1) are set to the neurons of the input layer (the output of the
input layer is the same as its input). The neurons in the hidden layer are activated:
Input of the hidden neuron 1 : 0 × 0.62 + 1 × 0.52 = 0.55
Input of the hidden neuron 2 : 0 × 0.42 + 1 * (-0.17) = -0.17
Output of the hidden neuron 1 : 1 1 + e −0.55 = 0.63
Output of the hidden neuron 2 : 1 1 + e +0.17 = 0.46 (4)
The neuron in the output layer are activated:
Input of output neuron : 0.35 × 0.63 + 0.81 × 0.46 = 0.59
Output of output neuron : 1 1 + e -0.6 = 0.64 (5)
Computation final error : - 0.64
0.32659
By applying the backpropagation algorithm, the weight matrix2 is changed to: , and the weight matrix1
0.79311
0.62 0.42
is changed to .
− 0.21 0.5126
The first input pattern has been therefore propagated through the net. The same procedure is used to for the next input
pattern, but with the changed weight values. After forward and backward propagation of the second pattern, one
learning step is complete and the net error can be calculated by adding up the square output errors of each pattern. By
13

14. performing this procedure repeatedly, this error value gets smaller and smaller. The algorithm is successfully finished,
if the net error value reaches zero or is below some error margin (threshold).
4.3 The Configuration Menu as a Key to Embedding NNs’ Simulators
Most of NNs have a number of learning parameters that have to be appropriately specified. The selection of the
appropriate parameters for large-scale applications is an important experiment problem for a fast convergence of the
algorithm [12]. The user may impose some constraints on the parameters. Consequently, in training novice users, it is
necessary to develop techniques to properly set these parameters. In our system, from the perspective of the user, the
differences that appear between various models are reflected in the NN initialization and configuration menu. As
previously mentioned, this menu depends on the architecture and the learning algorithm selected in the network item
menu. The parameter settings for the backpropagation learning algorithm are as follows: (i) the parameter panel
allows the setting of the specific backpropagation learning parameters, known as learning rate, momentum, and
threshold. (ii) the external activation function menu choice allows the setting of the units to either a sigmoid, or
hyperbolic tangent function. (iii) the threshold input allows a brute force elimination of training examples with the
outputs above or below a certain level. (iv) the train panel allows the selection of the training data, as well as of the
number of training epochs (the number of repetitive passes through the set of examples). (v) from the test panel, the
selection of the testing data set is possible, to test the generalization ability of the NN. As can be seen in the left part of
Figure 10, the user can specify parameters such as external activation function, error threshold, and/or iterations,
learning rate, I/O pairs of values. Figure 10 displays the simulation for a beginner user, simulating the XOR problem.
The architecture of the network is presented on the right side of figure 10. The weights and their dynamic change during
training are displayed next to the network architecture.
14

15. Figure 10: Parameters Setting’s Screen
From these first tests and results, after a first feedback from users, we have concluded that some of the layout
proprieties of the display should be changed, in order to improve the understanding, especially for the beginner user.
For instance, the representation of weights next to the network architecture could reflect the layer structure of the
network, enhancing comprehension and making the following of the learning procedure easier for the inexperienced
user. Moreover, the consultant functions should be refined, especially with regard to the dialogue model between
system (represented by the consultant) and the user.
5. Discussions and Conclusion
In this paper, we have presented the DiscoverNet system, which automatically generates a user-specific neural
network environment, and interacts to support the user in the designing process. The system is based on two main
components: the graphical CAD representation of an initial network and its outputs, and an interactive tutor that checks
the user’s actions during the design sessions. The methodology that underlies the design of the system is based on
constructing assistant script classes to follow the user's design steps; a script defines the sequence of assistance. An
initial neural network is projected in the space of neural network architectures H, only if it matches approximately some
rules of the space H; otherwise the initial neural network cannot be trained. We backed up our approach with
convincing results given by the knowledge based neural network approach. In this latter approach, prior domain
knowledge is used, and complete initial knowledge is not required; the initial knowledge is translated into a neural
network, and then refined into a correct knowledge representation. We presented an object-oriented approach for the
design of an adaptive learning environment for discovery and self-learning learning. The system is extended with a
consultant module that contributes in the learning stage. We focused on the description of the advice process algorithm
in the consultant. As the first step, in order to study the feasibility of such a system, we considered the typical
components and building blocks of the feedforward neural network and Kohonen Feature Map network. We chose
these models because they are the most used, and the equations that describe the models are simple compared to other
models.
15

16. From some first tests and results, we have concluded that some of the layout proprieties of the display should be
changed, in order to improve the understanding, especially for the beginner user. Moreover, the consultant functions
should be refined, especially with regard to the dialogue model between the consultant and the user.
From educational point of view, the system implements the “learning-by-discovery”, “learning-by-doing”,
“exploratory learning” and “reinforcement learning” teaching strategies. In our implementation, discovery learning
means to search for the appropriate neural network for a specific application, based on the information provided by
samples in the knowledge base. Our consultant function is based on gathering NN knowledge in a KBNN meta-
knowledge structure.
This tool is aimed both at students, as well as at in-service workers and researchers in different fields, who need a
quick tutorial of NN design and usage. Therefore, our ultimate goal of DiscoverNet development is to assist senior and
graduate students or engineers in designing NN, and performing NN experiments on different applications.
The DiscoverNet prototype has been successfully tested, however, more extensive in-class tests are needed. The
system is intended for the use in courses at the Graduate School of Information Systems at the University of Electro-
Communications, Japan. From these diverse groups of students we expect to gain valuable suggestions on future
extensions to the current version of DiscoverNet. Embedding additional NNs would be extremely beneficial for the
improvement of the current implementation.
As the system is implemented in Java, it can be easily transferred to the Internet, for long-distance and life-long-
based education purposes. Especially, with the so-called high-capacity, high-speed Japan Gigabit Network introduced
between several national universities, as well as private companies in Japan, this system will be just one of several
distance teaching tools that our laboratory will be offering to the research and education community involved in this
Gigabit project, which is supported by the Japanese Ministry of Posts and Telecommunications, and implemented by the
Telecommunications Advancement Organization (TAO).
We believe that that with this system, we are tackling the problem and serving the need of a systematic, automatic and
adaptive approach to neural network teaching.
References
[1] Goel, A., Lilly project Report: Teaching Design Skills, International Memo, AI Group, College of Computing,
Georgia Institute of Technology, October 1993.
16

17. [2] Belkada, S., Cristea, A., Okamoto, T.:Development of an intelligent simulation-based learning environment to
design and tutor neural networks, Paper presented in the seventh international conference on computer in Education
(ICCE99), vol.2, pp. 291-298, Tokyo,1999.
[3] Cerbin, B.: The course portfolio as a Tool for Continuous Improvement of teaching and learning. Paper presented at
American Association for Higher Education Double Feature Conference: the 8th Annual assessment conference and
the 1st Continuous Quality Improvement Conference, Chicago, June 1993.
[4] Chenoweth, T., Obradovic, Z.: A multi-component non-linear prediction system for the Sp 500 Index.
Neurocomputing, J., vol. 10, no3.3, pp. 275-290, 1996.
[5] McArthur, D., Lewis, M., and Bishay, M.: The Roles of Artificial Intelligence in Education: current progress and
future prospects. RAND, 1700 Main St. Santa Monica, CA 90407-2138, 1998.
[6] Fu, L. et al: Integration of neural heuristics into knowledge-based inference, Connection Science, 1, 325-340, 1989.
[7] Haykin, S.: Neural Networks: A comprehensive Foundation, New York, Macmillan, 1994.
[8] Pazzani, M., & Kibler, D.: The utility of knowledge in inductive learning. Machine Learning, 9, 57-94, 1992.
[9] Stephen, I.G.: Neural network learning and expert system, A Bradford book, the MIT Press Cambridge,
Massachusetts London, England, 1999.
[10]Shank, R.C., et al: Discovery systems. PROC. of AI-ED, Amsterdam, IOS, pp. 237, 1989.
[11]Towell, G.G., Shavlik, J.W., and Noordewier, M.O.: Refinement of approximately correct domain theories by
knowledge-based neural networks. Proceedings of the eighth national conference on Artificial intelligence, pages
861-866, Boston, MA. MIT Press, 1990.
[12]Venkateswaran, R., Obradovic, Z.: Efficient learning through cooperation, in Proceeding world Congress, Neural
Networks, San Diego, CA, Vol.3, pp. 390-395, 1997
17