INTRODUCTION

An ITS is simple in operation. A set of questions to be given by the student is recorded in a database and is
graded with a difficulty level by the author of the question. A student can then give an appropriate question,
depending upon the difficulty of the question. However, in order for a student to progress in their learning,
it is necessary to pitch questions so that they sufficiently make the student, without it being impossibly
difficult. Therefore, it is necessary to track the student’s change in ability as they progress through the
learning material. Similarly, the system is able to regrade questions in the question database. For example,
a question may have been graded by the author as being relatively easy. However, it may transpire that
populations of students actually find it difficult. This will be boom out by most students who should have
performed well with the question actually performing poorly. Such a situation negates the pedagogy stated
above. Our system is able to statistically determine that a question has been misgraded and is able to
remedy the situation.

AUTOTUTORS

STORAGE REQUIREMENTS (KNOWLEDGE REPRESENTATION)

For the purpose of design and conceptualization, ITSs are described as four major components:
The DOMAIN KNOWLEDGE, which is aimed to store, manipulate and reason with knowledge of the
domain being taught. The PEDAGOGICAL MODULE, which provides information about the teaching
strategy that must be used to a specific student. The STUDENT MODEL, that stores and analyzes
information of student’s current state of knowledge and the personal characteristics. The INTERFACE,
which handles the form of communication between the ITSs and the student.
One of the most important features of an ITS should provide is the capability to adapt its behavior to the
specific traits of the student. A human teacher bases his pedagogical decisions on the information about
student’s learning performance obtained during the instruction, as well as by observing his problem
solutions. The pedagogical module of an ITS uses the information collected by the student model during
the interaction of the student with the ITS based on the actions performed by him/her. From this point of
view the student model is analogous to an educational test instrument that attempts to measure student
characteristics.
LEARNING ALGORITHM FOR MAPPING INTO NEURAL NETWORKS
¾ Construct an AND-OR dependency graph based on the rules.
• Each node in the AND-OR dependence graph becomes a unit in the neural network.
• Insert additional units fro OR nodes.
 ¾ Set the biases of each AND unit and the weights coming into the AND unit such that the unit will
get activated only when all of its inputs are true.
¾ Set the biases of each OR unit and the weights coming into the OR unit such that the unit will get
activated only when at least one of its inputs is true.
¾ Add links with low weights between otherwise unconnected nodes in adjacent layers of the
network to allow learning over the long run

Figure 1: Mapping Rule into Score Page Network.

The input unit is will be set to 1 for the current content stored in network, similarly the other input unit will
be set only if the next current word gives the practical considerations of BPN.

Figure 2: Estimating the Value of the links.

Artificial neural networks resemble the human brain n the following two ways:
¾ An ANN acquires knowledge through learning.
¾ An ANN’s knowledge is stored within inter-neuron connection strengths known as synaptic
weights.
The true power and advantage of ANNs lie in their ability to represent both linear and non-linear
relationships and in their ability to learn these relationships directly from the data. Linear models are
simply inadequate when it comes to modeling data that contains non-linear characteristics.
This algorithm consists of two passes.
Forward Pass:
For each pattern, the activation is propagated from the input to the output. Here, the input to hidden and the
output was found out.
Backward Pass:
¾ The error calculated at the output and then propagated backwards through the network to estimate
the contribution to the error from each unit.
¾ Each weight value was changed by a small amount so as to reduce the total error.
Collect the data from the students by asking questions initially network structure was defined which is
suitable to our problem solving. The network structure used here was Feed Forward Network which
belongs to interlayer connected i.e., the neurons in one layer were connected to neurons in adjacent layer.
The neurons on the first layer sent their output to the neurons on the second layer, but they don’t receive
any input back from the neurons on the second layer. Node properties are defined followed by the network
structure. Here, Autotutor use sigmoidal function that is given by:
F (x) = 1/1+e^x where the output will be between ‘0’ and ‘1’.
Then the training algorithm was selected and the algorithm used here was Back-Propagated Algorithm,
which was found to be a learning rules. Network having supervised learning rules that is the training data
consists of many pairs of input/output training patterns and therefore the learning will benefit from the
assistance of the teacher. By giving a new training pattern the weights may be updated. The supervised
learning used here was Delta learning, where the weights are modified relative to the difference between
the target and the actual output. This learning rule was used since it is guaranteed to learn for all problems
and accuracy improves with training.

The Autotutors can be enhanced in the following implementations:

TRAINING THE AUTOTUTOR BY BPN
• Give the questions to the students and collect the data from them and store it is sub files.
• Apply them to the input vector. Xp = Xp1, Xp2, Xp3… to the input units.
• Calculate the net input values to the hidden layer units, Net = (Xpm, Win)

Figure 3: Training the Network.

• Calculate the outputs from hidden layer, H = f (net)
• Move to the Output layer; calculate the net input values to each unit, Net = (hp, W2n)
• Calculate Output, O = F (net)
• Calculate the error terms for Output units, D = (t – O). O (l – O) where, t-target O-Output
• Calculate error terms for hidden units, E = h (l – h). d. W2
The error terms on the hidden units are calculated before the connected weights to the output layer
units have been updated.
• Updated weights on Output layer, W2^new = W2^old + ^W2
W2t = n dh + x ^W2 (t-1) n - Learning rate < 1, x – Momentum factor
• Update weights on hidden layer, W1 = W1 + ^W1
^Wn = n e Xpm + W1 (t-1)
By choosing the weight value randomly, find the input to hidden layer and the output then find the error
between target and output. Now (adjust) update the weights and train the dataset to minimize the error.

NEURAL MODEL FOR AUTOTUTOR

Figure 4: Neural Model

The questions in the wanted subject are put into Autotutor. Both the possible Questions and Answers are
stored in the desired. Now the questions that are given as input to the Autotutor are trained with questions
in the desired and their corresponding answers are displayed to the students. By applying data from sub
files to input vector, the net input was calculated by using adder function (i.e.) net value. The net is
processed by an activated function to produce the neurons to give output. Here, F is called a squashing
function. Here, Autotutor use sigmoid function (meaning S shaped).
F (net) = out = 1/1+e^ (-net)
Then the desired is subtracted from the actual output to find the error and its propagated backwards to
minimize the error by adjusting weights. Thus, the neural model was constructed by Autotutor.

TESTING THE AUTOTUTOR

For testing BPN, the program prompts the user for the following inputs.
¾ Step 1: Learner asks question (or presents problem).
¾ Step 2:Tutor answer question (or begins to solve the problem).
¾ Step 3: Tutor gives short immediate feedback on the quality of the answer (or solution).
¾ Step 4: The tutor short learner collaboratively improves the quality of the answer.
¾ Step 5: The tutor assesses the learner’s understanding of the answer.

As with training, the program normalizes the input and output parameter of the test signals prior to
initialization through network. The result file contains rows of data, where each row contains the non-
normalized vector output from each node in the output layer. The next series of data points correspond to
the absolute difference between the non-normalized vector output of the network and actual target output
vectors. The final value represents the sum of error taken across the output nodes of network. For each
entry in the list of extraction candidates, Autotutor first bind the variables to their candidate values. Then,
Autotutor perform a forward propagation on the trained Score Page network and outputs the score of the
network for the test document based on the candidate bindings. If the output value of the network is greater
than the threshold defined during the training step. Autotutor record the bindings as an extraction,
otherwise, these bindings are discarded.

Figure 5: Testing a Trained Network.

IMPLEMENTATION
This program implements the Natural language processing network. It is used to detect the structure by
propagating error backwards through the network. The program learns to predict the best solution among
various inputs. In this implementation, it has been shown that Neural Networks can be used to tackle a
problem to a certain extent, which appears at first glance to be not quite suitable for Neural Networks. The
BPN introduced in this paper for error minimization can be implemented O (nlogn) flops per steps and
require O (n) memory allocations. Thus, they are very efficient for large-scale computation. In this paper,
Autotutor have demonstrated the feasibility of implementing large (data) classifiers following an
approximation by means of sigmoidal function. The solution fro a given problem improves as the
numbered of training sample increases. Autotutor has been tested on nearly 200 students in a computer
literacy course. The tutoring was provided as extra credit in the course at a point in time after the students
had allegedly read the relevant chapters and attended a lecture in the course. So, Autotutor gave students an
opportunity to have additional studying of the material.

MAIN RESULTS

For illustration, consider one of the experiments that Autotutor conducted on Intelligent Tutoring System.
Autotutor was tested on 56 students in a computer literacy course. The students received extra credit for
participating in the experiment. Each student had one of the topics in neural networks (riles, architectures,
applications) assigned to one of the three conditions, using a suitable counterbalancing scheme: Autotutor
(student uses Autotutor to study one of the topics), Reread (student re-reads a chapter for a topic), and a no-
read Control (student doesn’t re-study a topic). A repeated measures designed was used so that the
Autotutor could evaluate aptitude X treatment interactions; that is, Autotutor could access whether
Autotutor is relatively effective for some categories of learners but not others (such as high versus low
performers overall). On the average, students took 58 minutes to use Autotutor, which was somewhat less
time than the 75 minutes assigned in the Reread condition. There were 3 outcome measures. There was a
sample of test bank questions that were in an N-alternative multi-choice format. There was a sample of
deep multi-choice questions, one questions for each of the 56 topics, that tapped causal inferences and
reasoning. And finally, there was a close test that had 4 critical words deleted from the ideal answers of
each topic; the students filled with these blanks with answers. The proportion of correct responses served as
the metric of performance. Autotutor also combined all these outcome measures into a composite score.
There were significant differences in the composite scores among the three conditions, with means of .63,
.58, and, .56 in the Autotutor, Reread, and Control conditions, respectively. Planned comparisons showed
the following pattern:
Autotutor > Reread = Control.
These results support the conclusion that Autotutor had a significant impact on learning gains. Our research
revealed that Autotutor is almost as good as an expert in computer literacy in evaluating the quality of
contributions in the tutorial dialog.

CONCLUSIONS

Autotutor are an effective and economically viable means of assists students to overcome in learning
difficulties. However, their widespread use has been inhibited by high developmental costs associated with
building such systems. The only way forward is to develop ITS architectures with reused and interoperable
components. This paper describes a neural network architecture fro the development of Autotutors for the
procedural and object-oriented programming paradigms. Finally, a number of studies will be conducted to
acquire the knowledge needed by domain and pedagogical models, e.g., studies of error made by students;
students determining the relationship between a student’s learning style pedagogical preferences. Thus, the
learner’s performance is effectively evaluated with respect to more specific neural units.

REFERENCES

¾ Beale and Jackson – Neural Computing.

¾ James A. Freeman / David M.Skapura, Neural Networks Algorithm, Applications and
Programming Techniques.
¾ Giangrandi, P. and Tasso, C. Truth Maintenance Techniques for Modeling Student’s
Behavior. Journal of Artificial Intelligence in Education
¾ Mayo, M., and Mitrovi’ C, A. Using a probabilistic student model to control problem
difficulty.