Adding the Project Files

Code and Report files, Data Files

Author: srp98

Object Tracking Data/Bayesian_Network/Bayesian_Test.m

@@ -0,0 +1,111 @@
+clear all
+close all
+
+Data = xlsread('Data.xlsx');
+
+% X1 = normc(Data(:,1));
+% X2 = normc(Data(:,2));
+
+X1 = Data(:,1);
+X2 = Data(:,2);
+
+% X1 = normc(X1);
+% X2 = normc(X2);
+
+%Given Datasets 'X1' and 'X2'
+
+% figure(1)
+% plot(X2);
+% hold on
+% plot(X1,'-r');
+% hold off
+
+figure(1)
+plot(X1,X2);
+
+%Training with the first 60 samples of the given data
+
+StepSize = 1;
+
+S1 = X1(1:StepSize:60);
+S2 = X1(2:StepSize:61);
+S3 = X2(1:StepSize:60);
+S4 = X2(2:StepSize:61);
+
+S5 = [S1 S2 S3 S4]';
+
+T = X1(3:StepSize:62)';
+
+save S5
+save T         %Saving our Inputs and Outputs for Training Phase
+
+time1 = clock;   %Clocking the begin time so as to calculate the time taken
+
+a1 = minmax(S1');
+a2 = minmax(S2');
+a3 = minmax(S3');
+a4 = minmax(S4');
+
+Min_Max = [a1; a2; a3; a4];   %Min-max of the data for scaling purpose in the network
+
+net = newff(Min_Max,[100 1],{'purelin' 'purelin'},'trainbr');    %Using a feedforward network with 100 hidden layers
+
+net.trainParam.goal = 0.000001;
+net.trainParam.epochs = 1000;
+net.performFcn = 'mae';
+%net.plotFcns = {'plotPerform','plottrainstate','ploterrhist','plotfit','plotregression'};
+
+
+net = train(net,S5,T);
+
+save 'DataNN'
+save net
+save X1 
+save X2
+
+%Testing remaining 30 nodes in the data
+
+StepSize = 1;
+
+S1 = X1(61:StepSize:87);
+S2 = X1(62:StepSize:88);
+S3 = X2(61:StepSize:87);
+S4 = X2(62:StepSize:88);
+
+S6 = [S1 S2 S3 S4]';
+
+R = X1(63:StepSize:89)';
+
+Ra = sim(net,S6);
+
+save S6
+
+time2 = clock;
+
+figure(2)
+plot(R);
+hold on
+plot(Ra,':r');
+hold off
+
+%Calculating Total Time Taken in secs
+
+Total_Time_Secs = (time2(5) - time1(5)) * 60 + (time2(5) - time1(6));
+
+%Calculating the Mean Absolute Prediction Error (MAPE)
+%R actual output
+%Ra predicted output
+
+Er = Ra - R;
+figure(3)
+plot(Er)
+
+R = R + 1;         %Doing this step as MAPE doesnt take '0''s as input which leads to infinite error
+Ra = R + 1;
+MAPE = errperf(R,Ra,'mape');
+MSPE = errperf(R,Ra,'mspe');    %Comparison of the Error Percentages
+
+save R 
+save Ra 
+save MAPE
+save MSPE

Object Tracking Data/Bayesian_Network/Data.dat.xls

@@ -0,0 +1,258 @@
+function V=errperf(T,P,M)
+
+%ERRPERF Determine various error related performance metrics.
+%
+% ERRPERF(T,P,M) uses T and P, which are target and prediction vectors
+% respectively, and returns the value for M, which is one of several error
+% related performance metrics.
+%
+% T and P can be row or column vectors of the same size. M can be one of
+% the following performance metrics:
+%
+%   mae (mean absolute error)
+%   mse (mean squared error)
+%   rmse (root mean squared error)
+%
+%   mare (mean absolute relative error)
+%   msre (mean squared relative error)
+%   rmsre (root mean squared relative error)
+%
+%   mape (mean absolute percentage error)
+%   mspe (mean squared percentage error)
+%   rmspe (root mean squared percentage error)
+%
+% EXAMPLE:
+%
+%   rand('state',0)
+%
+%   T = [0:0.2:1]
+%   P = rand(size(T)).*T
+%
+%   errperf(T,P,'mae') returns 0.1574
+%
+% To compute the relevant performance metric, the function uses recursion
+% to first compute one or more error vectors. The function can therefore
+% secondarily be used to compute these error vectors. M can therefore also
+% be one of the following:
+%
+%   e (errors)
+%   ae (absolute errors)
+%   se (squared errors)
+%
+%   re (relative errors)
+%   are (absolute relative errors)
+%   sre (squared relative errors)
+%
+%   pe (percentage errors)
+%   ape (absolute percentage errors)
+%   spe (squared percentage errors)
+%
+% REMARKS:
+%
+%   - The Neural Network Toolbox also has functions to compute mae and mse.
+%     This function does not make use of the toolbox.
+%
+%   - Percentage error equals relative error times 100.
+%
+%   - The abbreviations used in the code, and the calculation tree are
+%     documented in a comments section within the file.
+%
+% VERSION: 20070703
+% MATLAB VERSION: 7.4.0.287 (R2007a)
+% LICENSE: As-is; public domain
+%
+% See also MAE, MSE.
+
+%{
+VERSION HISTORY:
+20070703: - Added MATLAB version check.
+20070606: - Added support for metrics MARE, MSRE, and RMSRE.
+          - Addressed a possible division by zero condition in calculating
+            relative and percentage errors.
+20070528: - Original version.
+
+KEYWORDS:
+perf, performance, metric, performance measure, machine learning
+%}
+
+%% Comments
+
+%{
+
+Abbreviations:
+
+a: absolute
+e: error(s)
+M: METRIC
+m: mean
+P: PREDICTIONS
+p: percentage
+r: relative (if before e)
+r: square root (if before m)
+s: squared
+T: TARGETS
+V: VALUE(S)
+
+Calculation tree:
+
+e
+|
+|-ae-mae
+|
+|-se-mse-rmse
+|
+|-re-pe
+  |  |
+  |  |-ape-mape
+  |  |
+  |  |-spe-mspe-rmspe
+  |
+  |-are-mare
+  |
+  |-sre-msre-rmsre
+
+%}
+
+%% Check MATLAB version
+
+if datenum(version('-date'))<datenum('29-Jan-2007')
+    error(['The MATLAB version in use is ',version('-release'),'. ',...
+           'This function requires at least version 2007a.'])
+end
+
+%% Parse and validate input
+
+Inputs=inputParser;
+
+Inputs.addRequired('T',@(x) isnumeric(x) && ndims(x)==2 && ...
+                            (size(x,1)==1 || size(x,2)==1));
+Inputs.addRequired('P',@(x) isnumeric(x) && ndims(x)==2 && ...
+                            (size(x,1)==1 || size(x,2)==1));
+Inputs.addRequired('M',@(x) ischar(x) && ~isempty(x));
+                
+Inputs.parse(T,P,M);
+clear Inputs
+
+assert(isequal(size(T),size(P)),'T and P must have the same size.')
+
+%% Transform input
+
+M=lower(M);
+
+%% Compute metric
+
+switch M
+  
+  % Errors
+  case 'e'
+    
+    V=T-P;
+    
+  % Absolute errors
+  case 'ae'
+    
+    Ve=errperf(T,P,'e');
+    V=abs(Ve);
+    
+  % Mean absolute error
+  case 'mae'
+    
+    Vae=errperf(T,P,'ae');
+    V=mean(Vae);
+	
+  % Squared errors
+  case 'se'
+    
+    Ve=errperf(T,P,'e');
+    V=Ve.^2;
+  
+  % Mean squared error
+  case 'mse'
+    
+    Vse=errperf(T,P,'se');
+    V=mean(Vse);
+  
+  % Root mean squared error
+  case 'rmse'
+
+    Vmse=errperf(T,P,'mse');
+    V=sqrt(Vmse);
+    
+  % Relative errors
+  case 're'
+    
+    assert(all(T),'All elements of T must be nonzero.')
+    Ve=errperf(T,P,'e');
+    V=Ve./T;
+    
+  % Absolute relative errors
+  case 'are'
+    
+    Vre=errperf(T,P,'re');
+    V=abs(Vre);
+  
+  % Mean absolute relative error
+  case 'mare'
+    
+    Vare=errperf(T,P,'are');
+    V=mean(Vare);
+  
+  % Squared relative errors
+  case 'sre'
+    
+    Vre=errperf(T,P,'re');
+    V=Vre.^2;
+  
+  % Mean squared relative error
+  case 'msre'
+    
+    Vsre=errperf(T,P,'sre');
+    V=mean(Vsre);
+  
+  % Root mean squared relative error
+  case 'rmsre'
+    
+    Vmsre=errperf(T,P,'msre');
+    V=sqrt(Vmsre);
+  
+  % Percentage errors
+  case 'pe'
+    
+    Vre=errperf(T,P,'re');
+    V=Vre*100;
+    
+  % Absolute percentage errors
+  case 'ape'
+    
+    Vpe=errperf(T,P,'pe');
+    V=abs(Vpe);
+    
+  % Mean absolute percentage error
+  case 'mape'
+    
+    Vape=errperf(T,P,'ape');
+    V=mean(Vape);
+    
+  % Squared percentage errors
+  case 'spe'
+    
+    Vpe=errperf(T,P,'pe');
+    V=Vpe.^2;
+    
+  % Mean squared percentage error
+  case 'mspe'
+    
+    Vspe=errperf(T,P,'spe');
+    V=mean(Vspe);
+    
+  % Root mean squared percentage error
+  case 'rmspe'
+    
+    Vmspe=errperf(T,P,'mspe');
+    V=sqrt(Vmspe);
+    
+  otherwise
+    
+    error('M is invalid.')
+    
+end