Designing A Learning System in Machine Learning
Designing a Learning System
In order to get a successful learning system, it should be designed for a proper design, several steps should be followed.
Why we need to follow steps because in order to get perfect and efficient system.
Steps:
- Choosing a training example
-
Choosing the target Example
-
Choosing a representation for target function
-
Choosing a learning algorithm for approximating the target function
1. Choosing the Training Experience
Choosing a training experience contain three attribute are taken
• Type of feedback
• Degree
• Distribution of example
Type of feedback
Weather the training experience provides direct or indirect feedback regarding the choices made by Performance system.
Direct feedback
Indirect feedback
Example : checkers game
Degree
Of which learners (person who undergoing training) will control the sequence of training.
Example
Distribution Of Example
How well it respond the distribution of example aver which Performance of final system is measured more possible combinations, situation.
Example: testing job
2. Choosing a Target Function
First we need to chose the target experience, what type of knowledge is leaner and how it is used by the performance system
Example: checkers game
It contains the legal moves from any board, the program how to choose the best moves among them legal moves
- Travel only in the forward direction
-
At a time you can move only once in a chance
-
In a diagonal direction
-
Jumping over the opponent side
-
Back moves are not allowed ( only legal moves)
One move i.e., is called target move
Target Function – V(b)
Board state = b
Legal moves set = B
How do you assign the Value of b
b Is the final board state that is won, then V(b)=100
b Is the final board state that is lost, then V(b)=-100
b Is the final board state that is draw, then V(b)=0
If b is not a final state then V(b)=〖V(b)〗^’
b^’- Is the best final state
Choosing a Representation of Target Function
For any board state (b), we calculate function ‘c’ as a linear combination ( the degree is 1 ), of following board features
I.e. c (b)
Features
x_1= Number of black pieces on board
x_2= Number of red pieces on board
x_3= Number of black king pieces on board
x_4= Number of red king pieces on board
x_5= Number of black pieces threatened by red, the black which can beaten by red
x_6= The number of red pieces threatened by black
Linea function representation in the form of
V(b)=w_(0x_1 )+w_1 x_1+w_2 x_2+w_3 x_3+w_4 x_4+w_5 x_5+w_6 x_6
x_1—–x_6= These are feature
w_1—–w_6=Numerical weights for each and every features
w_0=Called additive constant to the board value
Choosing a learning for approximating the target function
Here we are learning an algorithm for approximate the target function
In order to understand a target function we need to set some of the training example
The training example it will describe a particular board state and the training value
Board state is represented by b
Training value is represented by V_train (b)
Training Example is represented in the form of
Training Example is required in order to understand clearly about the target function
order pair=(b,V_train (b))
b-x=coordinate
V_train (b)=y-coordinate
Example: the number of black coins to win the game x_2=0
x_2 Means the number of red coins
V_train (b)=+100
b=(x_1=3,x_2=0,x_3=1,x_4=0,x_5=0,x_6=0)
<(x_1=3,x_2=0,x_3=1,x_4=0,x_5=0,x_6=0)+100>
We need to do 2 steps in this phase
Estimating the Training Value
In each and every steps we need to estimate, in every step we need to consider the successor, depending upon the next step of the opponents, assign a value to successor it represents the next board state.
V_train (b)=V^n (successor( b))
It will estimate that this move will help or destroy opponents
V^n-It represents approximation
Adjusting the Weights
We will be using some algorithms to find Weights linear function. Here we are using LSM ( Least Mean Square) it is used to maximize the error
Error=(V_train (b)-V^n 〖 (b)〗^n 2=Positive
If error = 0 we need to change weight
If error is positive each weight is increased is proportion
If error is negative each weight is decreased is proportion
Final design
In the final design we have four different modules
Performance system
Critic
Generalizer
Experiment Generator
Any new problem taken as input , output will be solution trace ( grace history) this kind of problem is that previously, what happened that will be output for the Performance system.
It will take input as the previous history by the performance system generator an output regarding the training example.
Generalizer it will take input as a training example, it will generate a hypothesis ( is nothing but an imagination) ,
experimental generator it will take input as a hypothesis, it will generate the input, it will generate a new problem.
It will maximize the experiment Generator.