Home > Codi > CBR.m

CBR

PURPOSE ^

SYNOPSIS ^

This is a script file.

DESCRIPTION ^

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SUBFUNCTIONS ^

SOURCE CODE ^

0001 classdef (ConstructOnLoad = true) CBR < handle
0002     %Objecte CBR, aquest objecte és el que s'encarregara de mitjanįant
0003     %objectes PCA i CBR mantenir un model i una base de casos.
0004     
0005     properties (Access = private)
0006         %Model i Case_Base seran 2 objectes de tipus PCA que aniran lligats
0007         %a l'existencia de l'objecte actual, un cop els haguem assignat no
0008         %podran canviar-se. En el cas del model no es podra modificar.
0009         Model;%sera un objecte de tipus PCA i sera el nostre model descriptor del problema
0010         Case_Base;%PCA no model - La base de casos del problema
0011         
0012         %Aqui guardarem els parametres necesaris per les funcionalitats propies
0013         %del CBR. Un com s'han entrat no es nessesari entrar -les de nou a
0014         %menys que es bulgui canviar els seus valors.
0015         vk; %elements que agafem a cada nivell d'ordenaciķ
0016         dc; %metode de calcular les distāncies
0017         method; %metode d'elecciķ de la classe segons les classes dels veins
0018         
0019         %Aqui indicarem que s'ha fet una optimitzaciķ a la base de casos.
0020         %Si fem una optimitzaciķ els parametres vk, dc, i method queden
0021         %fixats per sempre!
0022         block;
0023         
0024         %Aqui emmagatzemarem temporalment els veins i els elements a
0025         %testejar per no haver de passar-los per parametre a cada funciķ.
0026         test;%Objecte de tipus PCA temporal on guardarem l'ultim set de dades tractat o a tractar en breu
0027         veins;%Aqui guardarem kNN veins
0028         classepredit;%variable per emmagatzemar la classe predita
0029         
0030         param;%parametre extre per les distancies 17 i 18 indica el tan per 1 a partir del qual considerem 1.
0031         
0032         treuoutliers;%indica si bolem treure els outliers o no
0033     end
0034     
0035     methods
0036         %constructor
0037         function obj=CBR(varargin)
0038             %Metode constructor de la classe CBR.
0039             %
0040             %Sense parametres d'entrada 'x = CBR();' creara un objecte
0041             %buit, tots els cams s'inicialitzen a buit.
0042             %
0043             %Amb parametres, Podem tenir 2 o 3 parametres d'entrada, els 2
0044             %primers correspondaran a un Model PCA i una Base de casos. El
0045             %3er parametre indicarā si bolem eliminar outliers o no.
0046             %
0047             %Parametres d'entrada:
0048             %
0049             %   varargin{1} (opcional) - Model PCA que s'utilitzara com a
0050             %                            model per projectar la base de
0051             %                            casos del Problema.
0052             %
0053             %   varargin{2} (opcional) - Objecte DATA que contindra la base
0054             %                            de casos per al nostre CBR.
0055             %
0056             %   varargin{3} (opcional) - 'YES' o 'NO' indica si es vol
0057             %                            treure outliers, si no s'indica no
0058             %                            es treuran.
0059             %                            Un cop contestada la pregunta es
0060             %                            seguira el mateix comportament
0061             %                            mentres existeixi l'objecte.
0062             %                            Indicant '' o qualsevol altre
0063             %                            valor no reconegut es preguntara a
0064             %                            l'usuari que fer.
0065             %
0066             %Parametres de sortida:
0067             %
0068             %    obj - El nou objecte CBR
0069             %
0070             
0071             %inicialitzara un objecte CBR.
0072             if nargin == 0
0073                 obj.Case_Base=[];%fem una copia avans de projectar per evitar problemes
0074                 
0075                 %inicialitzem tots els atributs
0076                 obj.vk=[];
0077                 obj.dc=[];
0078                 obj.method=[];
0079                 
0080                 obj.block =0; %la base de casos no esta bloquejada
0081                 
0082                 obj.test = [];
0083                 obj.veins=[];
0084                 obj.classepredit=[];%encara no hem predit cap classe per aquestes dades
0085                 obj.param=[];
0086             else
0087                 
0088                 model = varargin{1};%Recupero el model
0089                 C_B = varargin{2};%i la Base de Casos
0090                 
0091                 if nargin == 2
0092                     resp = 'NO'; %per defecte no treurem outlaiers si no ens ho indiquen!
0093                 else
0094                     resp = varargin{3};
0095                 end
0096                 z=whos('model');
0097                 if(not(strcmp(z.class,'PCA')))%si el tipus es correcte
0098                     %ens han passat alguna cosa que no era del tipus correcte
0099                     error('CBR\CBR: model parameter must be an object of type PCA');
0100                 end
0101                 
0102                 z=whos('C_B');
0103                 if(not(strcmp(z.class,'DATA')))%si el tipus es correcte
0104                     %ens han passat alguna cosa que no era del tipus correcte
0105                     error('CBR\CBR: C_B parameter must be an object of type DATA');
0106                 end
0107                 
0108                 obj.Model=model.copy();%fem una copia del model
0109                 
0110                 z=whos('resp');
0111                 if strcmp(z.class,'char')
0112                     obj.treuoutliers = resp;
0113                 else
0114                     error('CBR\CBR: resp parameter must be char type');
0115                 end
0116                 
0117                 outs = obj.Model.getOutLiers();
0118                 
0119                 while(sum(outs) > 0)
0120                     if isempty(obj.treuoutliers)
0121                         obj.treuoutliers = questdlg('There are outliers do you want to remove them?','Attention!','YES','NO','PLOT','YES');
0122                     end
0123                     switch obj.treuoutliers
0124                         case ''
0125                             outs = 1;
0126                             obj.treuoutliers=[];
0127                         case 'YES'
0128                             obj.Model.deleteBatch(outs);
0129                             outs=obj.Model.getOutLiers();
0130                         case 'NO'
0131                             outs = 0;
0132                         case 'PLOT'
0133                             obj.Model.plotOutLiers();
0134                             outs = 1;
0135                             obj.treuoutliers=[];
0136                         otherwise
0137                             error('CBR\CBR: resp parameter must be char type and valid ones are: YES, NO, PLOT');
0138                     end
0139                     
0140                 end
0141                 
0142                 
0143                 
0144                 %Projectem la base de casos!
0145                 obj.Case_Base=obj.Model.project(C_B.copy());%fem una copia avans de projectar per evitar problemes
0146                 
0147                 %inicialitzem tots els atributs
0148                 obj.vk=[];
0149                 obj.dc=[];
0150                 obj.method=[];
0151                 
0152                 obj.block =0; %la base de casos no esta bloquejada
0153                 
0154                 obj.test = [];
0155                 obj.veins=[];
0156                 obj.classepredit=[];%encara no hem predit cap classe per aquestes dades
0157                 obj.param=[];
0158                 
0159             end
0160         end
0161 
0162         function objo=copy(obj)
0163             %Metode constructor de Copia de la classe CBR. Creara un CBR
0164             %Copia de l'objecte actual.
0165             %
0166             %Parametres d'entrada:
0167             %
0168             %    no en te (obj es per defecte de la OO en matlab i es
0169             %    l'objecte actual)
0170             %
0171             %Parametres de sortida:
0172             %
0173             %    objo - El nou objecte CBR
0174             %
0175             
0176             %creem un CBR buit
0177             objo = CBR();
0178             
0179             %inicialitzem tots els parametres fen una copia dels de
0180             %l'objecte actual
0181             objo.Model = obj.Model.copy();
0182             objo.Case_Base = obj.Case_Base.copy();
0183             
0184             objo.vk = obj.vk;
0185             objo.dc = obj.dc;
0186             objo.method = obj.method;
0187             
0188             objo.block = obj.block;
0189             
0190             objo.test = obj.test;
0191             objo.veins = obj.veins;
0192             objo.classepredit = obj.classepredit;
0193             
0194             objo.param = obj.param;
0195             
0196             objo.treuoutliers = obj.treuoutliers;
0197         end
0198         
0199         %getters
0200         function m=getCaseBase(obj)
0201             %metode que retorna la base de casos que s'esta fent servir en
0202             %aquest moment, la retoorna com a objecte de tipus PCA, tal i
0203             %com el guardem dins el nostre objecte CBR.
0204             %Parametres d'entrada:
0205             %
0206             %   Aquest metode no te cap parametre d'entrada
0207             %
0208             %Parametres de sortida:
0209             %
0210             %   m - Retorna l'objecte PCA que fa de Case_Base al CBR
0211             %   actual.
0212             %
0213             m=obj.Case_Base;%Retornem les dades
0214         end
0215         function model=getModel(obj)
0216             %metode que retorna l'objecte PCA que fa de model en el nostre
0217             %CBR
0218             %Parametres d'entrada:
0219             %
0220             %   Aquest metode no te cap parametre d'entrada
0221             %
0222             %Parametres de sortida:
0223             %
0224             %   model - Retorna El model del nostre CBR
0225             %
0226             model=obj.Model.copy;%retornem el model
0227         end
0228         function out = isOptimized(obj)
0229             %metode que retorna Un boolea que indica si el nostre Objecte
0230             %CBR ha estat optimitzat o no
0231             %Parametres d'entrada:
0232             %
0233             %   Aquest metode no te cap parametre d'entrada
0234             %
0235             %Parametres de sortida:
0236             %
0237             %   out - Retorna cert si el CBR ha estat optimitzat i fals si
0238             %         no ha estat optimitzat
0239             %
0240             out=obj.block;
0241         end
0242         function out = getVK(obj)
0243             %metode que retorna el parametre VK actual del nostre objecte.
0244             %Per defecte el CBR si no se li indica la configuraciķ
0245             %utilitzarā la ultima coneguda, aquest metode indica l'ultim VK
0246             %utilitzat.
0247             %
0248             %VK indica el nombre de veins que es seleccionen a cada un dels
0249             %nivells de distancia, depenent de la distancia fa falta 1 o 2
0250             %nivells. En cas de tenir indicat 2 nivells i nomes necesitar 1
0251             %s'utilitzara com a vk el minim dels 2 valors indicats.
0252             %
0253             %Parametres d'entrada:
0254             %
0255             %   Aquest metode no te cap parametre d'entrada
0256             %
0257             %Parametres de sortida:
0258             %
0259             %   out - VK que s'utilitzaria en cas de no indicar-se
0260             %
0261             out = obj.vk;
0262         end
0263         function out = getDC(obj)
0264             %metode que retorna el parametre DC actual del nostre objecte.
0265             %Per defecte el CBR si no se li indica la configuraciķ
0266             %utilitzarā la ultima coneguda, aquest metode indica l'ultim DC
0267             %utilitzat.
0268             %
0269             % DC indica el criteri de distancia que utilitzem per calcular
0270             % les distancies entre els casos.
0271             %
0272             %Parametres d'entrada:
0273             %
0274             %   Aquest metode no te cap parametre d'entrada
0275             %
0276             %Parametres de sortida:
0277             %
0278             %   out - DC que s'utilitzaria en cas de no indicar-se
0279             %
0280            out=obj.dc; 
0281         end
0282         function out = getMethod(obj)
0283             %metode que retorna el parametre method actual del nostre
0284             %objecte. Per defecte el CBR si no se li indica la configuraciķ
0285             %utilitzarā la ultima coneguda, aquest metode indica l'ultim
0286             %method utilitzat.
0287             %
0288             %Method indica el metode de voting que s'utilitzara per decidir
0289             %la classe d'un cas a partir dels seus veins mes propers.
0290             %
0291             %Parametres d'entrada:
0292             %
0293             %   Aquest metode no te cap parametre d'entrada
0294             %
0295             %Parametres de sortida:
0296             %
0297             %   out - method que s'utilitzaria en cas de no indicar-se
0298             %
0299             out=obj.method;        
0300         end
0301         function out = getParam(obj)
0302             %metode que retorna el parametre param actual del nostre
0303             %objecte. Per defecte el CBR si no se li indica la configuraciķ
0304             %utilitzarā la ultima coneguda, aquest metode indica l'ultim
0305             %param utilitzat.
0306             %
0307             %param és el parametre extre per les distancies 17 i 18, indica
0308             %el tan per 1 a partir del qual considerem 1. l'agrupaciķ de
0309             %contribucions.
0310             %
0311             %Parametres d'entrada:
0312             %
0313             %   Aquest metode no te cap parametre d'entrada
0314             %
0315             %Parametres de sortida:
0316             %
0317             %   out - param que s'utilitzaria en cas de no indicar-se
0318             %
0319             out=obj.param;        
0320         end
0321         
0322         %Posar i treure casos
0323         function addCase(obj,dad,class,nom)
0324             %metode per afegir un cas a la nostre base de casos.
0325             %
0326             %Parametres d'entrada:
0327             %
0328             %   dad - matriu vidimencional de doubles amb les dades del
0329             %         cas. Les dimencions han de ser concistents amb les
0330             %         dels casos existens a la base de casos.
0331             %
0332             %   class - Double que ens indica la classe del cas
0333             %
0334             %   nom - String que indica l'identificador del lot.
0335             %
0336             %Parametres de sortida:
0337             %
0338             %   No en te
0339             %
0340             
0341             obj.Case_Base.addBatch(dad,class,nom);%l'afegim amb el metode de PCA per no haver de reprojectar
0342             
0343             %han modificat la base de casos si estavem a mig retreave els
0344             %resultats canviaran per tant obligarem que tornin a fer-lo
0345             obj.test = [];
0346             obj.veins=[];
0347             obj.classepredit=[];
0348         end
0349         function deleteCase(obj,i)
0350             %metode per eliminar un o diversos casos de la nostra base de
0351             %casos.
0352             %
0353             %Parametres d'entrada:
0354             %
0355             %   i - index que ens indica el lot o lots que bolem eliminar
0356             %       de la nostra base de casos
0357             %
0358             %Parametres de sortida:
0359             %
0360             %   No en te
0361             %
0362             
0363             obj.Case_Base.deleteBatch(i);%el/s treiem amb el metode de PCA per no haver de reprojectar
0364             
0365             %han modificat la base de casos si estavem a mig retreave els
0366             %resultats canviaran per tant obligarem que tornin a fer-lo
0367             obj.test = [];
0368             obj.veins=[];
0369             obj.classepredit=[];
0370         end
0371         function [dad clas nom] = getCase(obj,i)
0372             %metode per recuperar les dades d'un o diversos casos de la
0373             %nostra base de casos.
0374             %
0375             %Parametres d'entrada:
0376             %
0377             %   i - index que ens indica el lot o lots que bolem recuperar
0378             %       de la nostra base de casos
0379             %
0380             %Parametres de sortida:
0381             %
0382             %   dad - Matriu vidimencional amb les dades del lot
0383             %
0384             %   clas - La classe del lot
0385             %
0386             %   nom - L'identificador del lot.
0387             %
0388             
0389             %simplement invoquem el metode de PCA
0390             [dad clas nom] = obj.Case_Base.getBatch(i);
0391         end
0392         
0393         %Posar i treure lots del model
0394         function addCaseToModel(obj,dad,class,nom)
0395             %Metode per afegir un cas al nostre model
0396             %
0397             %Parametres d'entrada:
0398             %
0399             %   dad - matriu vidimencional de doubles amb les dades del
0400             %         cas. Les dimencions han de ser concistents amb les
0401             %         dels casos existens al model.
0402             %
0403             %   class - Double que ens indica la classe del cas
0404             %
0405             %   nom - String que indica l'identificador del lot.
0406             %
0407             %Parametres de sortida:
0408             %
0409             %   No en te
0410             %
0411             
0412             if(obj.block == 0)
0413                 obj.Model.addBatch(dad,class,nom);
0414                 %han modificat el model si estavem a mig retreave els
0415                 %resultats canviaran per tant obligarem que tornin a fer-lo
0416                 obj.test = [];
0417                 obj.veins=[];
0418                 obj.classepredit=[];
0419                 
0420                 %Projectem la base de casos de nou
0421                 obj.Case_Base=obj.Model.project(obj.Case_Base.getDATA());
0422                 
0423                 %Afegint casos pot ser que posem outliers!
0424                 outs = obj.Model.getOutLiers();
0425                 
0426                 while(sum(outs) > 0)
0427                     if isempty(obj.treuoutliers)
0428                         obj.treuoutliers = questdlg('There are outliers do you want to remove them?','Attention!','YES','NO','PLOT','YES');
0429                     end
0430                     switch obj.treuoutliers
0431                         case ''
0432                             outs = 1;
0433                             obj.treuoutliers=[];
0434                         case 'YES'
0435                             obj.Model.deleteBatch(outs);
0436                             outs=obj.Model.getOutLiers();
0437                         case 'NO'
0438                             outs = 1;
0439                             obj.treuoutliers=[];
0440                         case 'PLOT'
0441                             obj.Model.plotOutLiers();
0442                     end
0443                     
0444                 end
0445                 
0446             else
0447                 error('CBR\addCaseToModel: You can''t change your model if you made an optimitzation .');
0448             end
0449         end
0450         function deleteCaseFromModel(obj,i)
0451             %metode per eliminar un o diversos casos del nostra model
0452             %
0453             %Parametres d'entrada:
0454             %
0455             %   i - index que ens indica el lot o lots que bolem eliminar
0456             %       del nostre model
0457             %
0458             %Parametres de sortida:
0459             %
0460             %   No en te
0461             %
0462             if(obj.block == 0)
0463                 obj.Model.deleteBatch(i);
0464                 
0465                 %han modificat el model si estavem a mig retreave els
0466                 %resultats canviaran per tant obligarem que tornin a fer-lo
0467                 obj.test = [];
0468                 obj.veins=[];
0469                 obj.classepredit=[];
0470                 
0471                 %Projectem la base de casos de nou
0472                 obj.Case_Base=obj.Model.project(obj.Case_Base.getDATA());
0473                 
0474                 outs = obj.Model.getOutLiers();
0475                 
0476                 while(sum(outs) > 0)
0477                     if isempty(obj.treuoutliers)
0478                         obj.treuoutliers = questdlg('There are outliers do you want to remove them?','Attention!','YES','NO','PLOT','YES');
0479                     end
0480                     switch obj.treuoutliers
0481                         case ''
0482                             outs = 1;
0483                             obj.treuoutliers=[];
0484                         case 'YES'
0485                             obj.Model.deleteBatch(outs);
0486                             outs=obj.Model.getOutLiers();
0487                         case 'NO'
0488                             outs = 0;
0489                         case 'PLOT'
0490                             obj.Model.plotOutLiers();
0491                             outs = 1;
0492                             obj.treuoutliers=[];
0493                     end
0494                     
0495                 end
0496             else
0497                 error('CBR\addCaseToModel: You can''t change your model if you made an optimitzation .');
0498             end
0499             
0500         end
0501         
0502         
0503         %Retreave, reuse, revise i retain (control de parametres i retorns)
0504         function [index Test_set]= retrieve(obj,dades,ivk,idc,iparam)
0505             %metode de retrieve, s'encarrega de selecciķnar els casos més
0506             %propers al cas/ casos indicats a dades. ivk indicara quans
0507             %casos volem recuperar i idc la distancia a utilitzar iparam es
0508             %per les distancies 17 i 18.
0509             %
0510             %Parametres d'entrada:
0511             %
0512             %    dades - Objecte DATA amb casos als quals buscarem veins a
0513             %            la nostre base de casos.
0514             %
0515             %    ivk (opcional si ja s'ha indicat previament)
0516             %            indica el nombre de veins a recuperar en cada un
0517             %            dels nivells de la distancia.
0518             %
0519             %    idc (opcional si ja s'ha indicat previament)
0520             %            indica el metode de distancia que s'utilitzara per
0521             %            calcular les distancies.
0522             %
0523             %    iparam (opcional si ja s'ha indicat previament)
0524             %            Parametre auxiliar per les distancies 17 i 18 que
0525             %            indicara el tan per 1 de casos que es necesiten
0526             %            per considerar un grup de contribucions com a
0527             %            falla (1) o no (0).
0528             %
0529             %Parametres de sortida:
0530             %
0531             %   index - l'index dels casos mes propers.
0532             %
0533             %   Test_set - L'objecte dades projectat a sobre el model del
0534             %              problema
0535             %
0536             %
0537             %Apunts D'optimitzaciķ de codi:
0538             %
0539             %      - Si no es necesiten els parametres de sortida no
0540             %        demanar-los i es podran evitar calculs.
0541             %
0542             %      - A l'hora de fer retrieve de diversos casos es més
0543             %        eficient fer-los de cop.
0544             %
0545             
0546             %el parametre dades es sempre obligatori i ha de ser un objecte
0547             %DATA si no retornem error.
0548             z=whos('dades');
0549             if(not(strcmp(z.class,'DATA')))%comprovem que sigui del tipus correcte
0550                 %ens han passat unes dades de tipus incorrecte.
0551                 error('CBR\retrieve: dades parameter must be an object of type DATA');
0552             end
0553             
0554             %la resta de parametres son opcionals (sempre que els hagin entrat algun cop)
0555             if nargin >2
0556                 %Comprobem que el ivk que ens passen es del tipus correcte
0557                 z=whos('ivk');
0558                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0559                     %ens han passat unes dades de tipus incorrecte.
0560                     error('CBR\retrieve: The parameter ivk must be of type Double');
0561                 end
0562                 %ara comprobem que no s'hagi bloquejat la base de casos
0563                 if (obj.block ==1) && sum(obj.vk ~= ivk)~=0
0564                     error('CBR\retrieve: vk parameter must not be changed when the case base has been optimited. Remember, is not necesary to call the method retreave with all the parameters.');
0565                 else
0566                     obj.vk=ivk;
0567                 end
0568                 
0569                 %comprobem el parametre dc
0570                 z=whos('idc');
0571                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0572                     %ens han passat unes dades de tipus incorrecte.
0573                     error('CBR\retrieve: dc parameter must be of type Double');
0574                 end
0575                 if (obj.block ==1) && (obj.dc~=idc)
0576                     error('CBR\retrieve: dc parameter must not be changed when the case base has been optimited. Remember, is not necesary to call the method retreave with all the parameters.');
0577                 else
0578                     obj.dc=idc;
0579                 end
0580                 
0581                 if obj.dc ==17 || obj.dc == 18
0582                     if obj.block == 1 && obj.param~=iparam
0583                         error('CBR\reuse: This parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
0584                     else
0585                         if exist('iparam','var')
0586                             obj.param=iparam;
0587                         else
0588                             error('CBR\reuse:This distance needs an extra parameter!');
0589                         end
0590                     end
0591                 end
0592             end
0593             %comprovem que els hagin entrat algun cop
0594             if isempty(obj.vk)
0595                 error('CBR\retrieve: vk parameter never had a value. Remember, you can not use the short form.');
0596             end
0597             if isempty(obj.dc)
0598                 error('CBR\retrieve: dc parameter never had a value. Remember, you can not use the short form.');
0599             end
0600             
0601             %mirem si hi ha el parametre extra de la distancia
0602             if obj.dc ==17 || obj.dc == 18
0603                 if isempty(obj.param)
0604                     %no s'ha fet un retrieve
0605                     error('CBR\reuse:This distance needs an extra parameter!');
0606                 end
0607             end
0608             
0609             obj.classepredit=[];%encara no hem predit cap classe per aquestes dades
0610             
0611             %segons que ens demani l'usuari farem uns calculs o uns altres
0612             if nargout ~= 0
0613                 %Bolen parametres de sortida!!
0614                 obj.test = obj.Model.project(dades);%projectem les dades que ens passen al nostre model.
0615                 Test_set = obj.test;%preparem el retorn per l'usuari
0616                 
0617                 %si ens demanen mes elements dels que tenim, retornem tots els
0618                 %que poguem.
0619                 obj.vk(obj.vk>obj.Case_Base.getBatchCount())=obj.Case_Base.getBatchCount();%les components del vector que siguin mes grans que el nombre de lots que tenim passen a ser el nombre de lots.
0620                 
0621                 CBR_retrieve(obj);%cridem el retreave privat (el que fara realment el retreave)
0622                 
0623                 %Preparem el retorn per l'usuari on:
0624                 %dades son els "lots" veins
0625                 %class son les classes d'aquests veins
0626                 %noms son els noms d'aquests veins
0627  %               [dades class noms]=obj.Case_Base.getBatch(obj.veins.indexs_k2);%Per poder indexar sobre dades
0628                 %es més util disposar se l'index del lot vei k del lot!!
0629                 index = obj.veins.indexs_k2;
0630             else
0631                 %no hi ha retorn
0632                 obj.test = obj.Model.project(dades);%projectem les dades que ens passen al nostre model.
0633                 
0634                 %si ens demanen mes elements dels que tenim, retornem tots els
0635                 %que poguem.
0636                 obj.vk(obj.vk>obj.Case_Base.getBatchCount())=obj.Case_Base.getBatchCount();%les components del vector que siguin mes grans que el nombre de lots que tenim passen a ser el nombre de lots.
0637                 
0638                 CBR_retrieve(obj);%cridem el retreave privat
0639             end
0640             
0641         end
0642         function classe = reuse(obj,imethod)
0643             %Metode per fer un reuse sobre la base de casos actual. Per
0644             %poder utilitzar aquest metode s'ha d'haver fet avans un
0645             %retrieve.
0646             %
0647             %Parametres d'entrada:
0648             %
0649             %
0650             %   imethod (opcional si ja s'ha indicat previament)
0651             %             Metode que s'utilitzara per escollir la nova
0652             %             classe dels casos entrats a dades de la funcio
0653             %             retrieve
0654             %
0655             %Parametres de sortida:
0656             %
0657             %   classe - Classe assignada a cadascun dels lots de l'objecte
0658             %            dades sobre el qual s'ha fet l'ultim retrieve
0659             %
0660             %
0661             %Apunts D'optimitzaciķ de codi:
0662             %
0663             %      - Si no es necesiten els parametres de sortida no
0664             %        demanar-los i es podran evitar calculs.
0665             %
0666             
0667             %el parametremethod es opcional
0668             if nargin > 1
0669                 %comprobem correctesa de les dades
0670                 z=whos('imethod');
0671                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0672                     %ens han passat unes dades de tipus incorrecte.
0673                     error('CBR\reuse: imethod parameter must be of type Double.');
0674                 end
0675                 if obj.block ==1 && obj.method~=imethod
0676                     error('CBR\reuse: method parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
0677                 else
0678                     obj.method=imethod;
0679                 end
0680                 
0681             end
0682             
0683             %comprovem que l'hagin entrat algun cop
0684             if isempty(obj.method)
0685                 %no s'ha fet un retrieve
0686                 error('CBR\retrieve: method parameter never had a value. Remember, you can not use the short form.');
0687             end
0688             
0689             %mirem si tenim dades d'un retrieve
0690             if isempty(obj.test)
0691                 %no s'ha fet un retrieve
0692                 error('CBR\reuse:You can''t use reuse. Use retrieve first!!');
0693             end
0694             
0695             
0696             
0697             %cridem el rehuse privat
0698             CBR_reuse(obj);
0699             
0700             %retornem les classes si les bolen
0701             if nargout >0
0702                 classe=obj.classepredit;
0703             end
0704         end
0705         function [matri fallen]=revise(obj)
0706             %metode perque l'usuari comprovi si les dades s'han classificat
0707             %be o no.
0708             %Parametres d'entrada:
0709             %
0710             %   No en te, Cal que els casos entrats a la funciķ retrieve
0711             %   tinguin classe asignada per poder fer automaticament aquest
0712             %   pas. Si no tenen classes es demanara a l'usuari que les
0713             %   proporcioni mitjanįant un dialeg.
0714             %
0715             %Parametres de sortida:
0716             %
0717             %   matri - matriu de confusio
0718             %   fallen - indexs dels casos que fallen
0719             %
0720             
0721             %fem les comprovacions necessaries per assegurar que podem fer
0722             %un revise.
0723             if isempty(obj.test)
0724                 %no han fet el retrieve
0725                 error('CBR\revise: You can''t use revise. Use retrieve first!');
0726             end
0727             if isempty(obj.classepredit)
0728                 %no han fet el reuse
0729                 error('CBR\revise: You can''t use revise. Use reuse first!');
0730             end
0731             
0732             
0733             %cridem al revise intern
0734             [matri fallen]=CBR_revise(obj);
0735         end
0736         function retain(obj,fallen)
0737             %metode que rete tots els casos que han fallat en la seva
0738             %classigicaciķ, l'usuari ens ha d'indicar un vector amb els
0739             %casos que han fallat o no
0740             %
0741             %Parametres d'entrada:
0742             %
0743             %       fallen  - vector de logicals que indica si el CBR ha
0744             %                 fallat en classficar el cas o no
0745             %
0746             %Parametres de sortida:
0747             %       No en te
0748             %
0749             
0750             obj.CBR_retain(fallen);
0751         end
0752         
0753         %Metodes per optimitzar la base de casos (Control de parametres)
0754         function IBUdG(obj,nelem,descarta,ivk,idc,imethod,iparam)
0755             %Mčtode per netejar la base de casos. Aquest mčtode intentara
0756             %definir les fronteres de les classes i despoblar els centres.
0757             %Per fer-ho, es busca el cas amb una classe diferent més proper
0758             %a cada cas de la base de casos, anomenat enemic. L’enemic
0759             %s’afegeix a la base de casos optimitzada, sempre i quant no
0760             %estiguin ja inclosos a la base de casos.
0761             %
0762             %Tal com succeīa en altres mčtodes, els parāmetres “vk”,“dc” i
0763             %"method" no sķn necessaris si s’ha cridat amb anterioritat el
0764             %mčtode amb tots els parāmetres d’entrada. En aquest cas,
0765             %prendrem l’últim valor entrant dels parāmetres
0766             %
0767             %El parāmetre “descarta” serveix per “separar les fronteres”,
0768             %en problemes on el soroll és considerable aquest mčtode
0769             %tendeix a afegir masses casos a les fronteres. Per corregir
0770             %aquest defecte proposem descartar els X enemics més propers de
0771             %cada cas on X és el valor que es dona a descarta.
0772             %
0773             %Finalment, només indicar que el nombre d’enemics és crític a
0774             %l’hora de filtrar la base de casos. El valor recomanat és el
0775             %nombre mínim d’elements que es recuperen per un nou problema.
0776             %Si trčiem un nombre d’enemics inferior a aquest valor,
0777             %obtindrem una base de casos menor, perō que al mateix temps,
0778             %representa un major nombre de classificacions incorrectes. Per
0779             %altra banda, si el nombre d’enemics és superior al nombre
0780             %mínim de casos que recuperem, llavors tindrem una base de
0781             %casos més gran, perō que al mateix temps, tindrā un nombre de
0782             %classificacions incorrectes més baix.
0783             %
0784             %
0785             %Parametres d'entrada:
0786             %
0787             %       (Parametres opcionals si ja s'han indicat anteriorment)
0788             %
0789             %       ivk - Tupla que indica el nombre de veīns a retenir a
0790             %             cada nivell del cālcul de distāncia.
0791             %
0792             %       idc - Double que indica que indica el criteri per
0793             %             calcular la distāncia entre 2 casos.
0794             %
0795             %       imethod - Double que indica el mčtode a utilitzar per
0796             %                 assignar la classe als nous problemes.
0797             %
0798             %       iparam - Parametre per a les distancies 17 i 18
0799             %
0800             %
0801             %       (Parametres obligatoris)
0802             %
0803             %       nelem - Double que indica el nombre d’enemics a afegir
0804             %               per cada cas de la base de casos.
0805             %
0806             %       descarta - Double que indica quants dels enemics més
0807             %                  propers s’han d’ignorar (no afegir a la base
0808             %                  de casos)
0809             %
0810             %Parametres de sortida:
0811             %
0812             %       No en te
0813             %
0814 
0815 
0816             if nargin >3
0817                 z=whos('ivk');
0818                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0819                     %ens han passat unes dades de tipus incorrecte.
0820                     error('CBR\IBUdG: vk parameter must be of type Double.');
0821                 end
0822                 if (obj.block ==1) && sum(obj.vk ~= ivk)~=0
0823                     error('CBR\IBUdG: vk parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0824                 else
0825                     obj.vk=ivk;
0826                 end
0827                 %comprovar mides double o [double double] ??
0828                 z=whos('idc');
0829                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0830                     %ens han passat unes dades de tipus incorrecte.
0831                     error('CBR\IBUdG: dc parameter must be of type Double.');
0832                 end
0833                 if obj.block ==1 && obj.dc~=idc
0834                     error('CBR\IBUdG: dc parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0835                 else
0836                     obj.dc=idc;
0837                 end
0838                
0839                 z=whos('imethod');
0840                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0841                     %ens han passat unes dades de tipus incorrecte.
0842                     error('CBR\IBUdG: method parameter must be of type Double.');
0843                 end
0844                 if obj.block ==1 && obj.method~=imethod
0845                     error('CBR\IBUdG: method parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0846                 else
0847                     obj.method=imethod;
0848                 end
0849                 
0850                 if obj.dc ==17 || obj.dc == 18
0851                     if obj.block == 1 && obj.param~=iparam
0852                         error('CBR\IBUdG: This parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
0853                     else
0854                         if exist('iparam','var')
0855                             obj.param=iparam;
0856                         else
0857                             error('CBR\IBUdG:This distance needs an extra parameter!');
0858                         end
0859                     end
0860                 end
0861             end
0862             
0863             %mirem si hi ha el parametre extra de la distancia
0864             if obj.dc ==17 || obj.dc == 18
0865                 if isempty(obj.param)
0866                     %no s'ha fet un retrieve
0867                     error('CBR\IBUdG:This distance needs an extra parameter!');
0868                 end
0869             end
0870             
0871             if isempty(obj.vk) || isempty(obj.dc)  || isempty(obj.method)
0872                 error('CBR\IBUdG: At least 1 of them (vk , dc , method) never had a value. You can''t use the short form.');
0873             end
0874             
0875             obj.block=1;%ja no es poden canviar els parametres
0876             Calcula_IB_UdG(obj,nelem,descarta);
0877         end
0878         function IB3(obj,ivk,idc,imethod,iparam)
0879             %Mčtode per netejar la base de casos proposat per David W. Aha.
0880             %Aquest mčtode intenta definir les fronteres de les classes
0881             %lo més allunyades possible. La frontera entre 2 classes és la
0882             %zona de l’espai de cerca del problema en que dues classes
0883             %presenten una gran conflučncia.
0884             %
0885             % Algorisme base proposat per  David W. Aha.
0886             % The IB3 algorithm (CD = Concept Description)
0887             %   CD = []
0888             %   For each x in TrainingSet do
0889             %      For each y in CD do
0890             %         Sim[y] = Similarity(x, y)
0891             %      end
0892             %      if Exists y in CD   acceptable(y) then
0893             %         ymax   some acceptable y in CD with maximal Sim[y]
0894             %      else
0895             %         i   randomly selected value in CD
0896             %         ymax   some y in CD that is the i th most similar instance to x
0897             %      end
0898             %      if class(x)   class(ymax) then
0899             %         classification Ģ- correct
0900             %      else
0901             %         classification Ģ- incorrect
0902             %         CD Ģ- CD U [x]
0903             %      end
0904             %      For each y in CD do
0905             %         if Sim[y]   Sim[ymax] then
0906             %            Update y’s classification record
0907             %            if y’s record is significantly poor then
0908             %               CD Ģ- C   [y]
0909             %            end
0910             %         end
0911             %      end
0912             %   end
0913             %
0914             %Parametres d'entrada:
0915             %
0916             %       (Parametres opcionals si ja s'han indicat anteriorment)
0917             %
0918             %       ivk - Tupla que indica el nombre de veīns a retenir a
0919             %             cada nivell del cālcul de distāncia.
0920             %
0921             %       idc - Double que indica que indica el criteri per
0922             %             calcular la distāncia entre 2 casos.
0923             %
0924             %       imethod - Double que indica el mčtode a utilitzar per
0925             %                 assignar la classe als nous problemes.
0926             %
0927             %       iparam - Parametre per a les distancies 17 i 18
0928             %
0929             %
0930             %
0931             %Parametres de sortida:
0932             %
0933             %       No en te
0934             %
0935 
0936             if nargin >1
0937                 z=whos('ivk');
0938                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0939                     %ens han passat unes dades de tipus incorrecte.
0940                     error('CBR\IB3: vk parameter must be of type Double.');
0941                 end
0942                 if (obj.block ==1) && sum(obj.vk ~= ivk)~=0
0943                     error('CBR\IB3: vk parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0944                 else
0945                     obj.vk=ivk;
0946                 end
0947                 %comprovar mides double o [double double] ??
0948                 z=whos('idc');
0949                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0950                     %ens han passat unes dades de tipus incorrecte.
0951                     error('CBR\IB3: dc parameter must be of type Double.');
0952                 end
0953                 if obj.block ==1 && obj.dc~=idc
0954                     error('CBR\IB3: dc parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0955                 else
0956                     obj.dc=idc;
0957                 end
0958                 
0959                 z=whos('imethod');
0960                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
0961                     %ens han passat unes dades de tipus incorrecte.
0962                     error('CBR\IB3: method parameter must be of type Double.');
0963                 end
0964                 if obj.block ==1 && obj.method~=imethod
0965                     error('CBR\IB3: method parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
0966                 else
0967                     obj.method=imethod;
0968                 end
0969                 
0970                if obj.dc ==17 || obj.dc == 18
0971                     if obj.block == 1 && obj.param~=iparam
0972                         error('CBR\IB3: This parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
0973                     else
0974                         if exist('iparam','var')
0975                             obj.param=iparam;
0976                         else
0977                             error('CBR\IB3:This distance needs an extra parameter!');
0978                         end
0979                     end
0980                 end
0981             end
0982             
0983             if isempty(obj.vk) || isempty(obj.dc)  || isempty(obj.method)
0984                 error('CBR\IB3: At least 1 of them (vk , dc , method) never had a value. You can''t use the short form.');
0985             end
0986             
0987             %mirem si hi ha el parametre extra de la distancia
0988             if obj.dc ==17 || obj.dc == 18
0989                 if isempty(obj.param)
0990                     %no s'ha fet un retrieve
0991                     error('CBR\IB2:This distance needs an extra parameter!');
0992                 end
0993             end
0994             obj.block=1;%ja no es poden canviar els parametres
0995             
0996             Calcula_IB3(obj)
0997         end
0998         function IB2(obj,ivk,idc,imethod,iparam)
0999             %Mčtode per netejar la base de casos proposat per David W. Aha.
1000             %
1001             % IB2 és un algorisme incremental, va provant de classificar
1002             % casos, en cas que es falli en classificar-lo el cas serā
1003             % afegit a la base de casos, si per contra el cas es classifica
1004             % be no s’afegeix.
1005             %
1006             % Algorisme base proposat per  David W. Aha.
1007             % The IB2 algorithm (CD = ConceptDescription)
1008             %   CD = []
1009             %   for each x in Training Set do
1010             %     for each y in CD do
1011             %       Sim[y] = Similarity(x, y)
1012             %     end
1013             %     ymax = Max(Sim[])
1014             %     if class(x) = class(ymax)
1015             %       classification Ģ- correct
1016             %     else
1017             %       classification Ģ- incorrect
1018             %        CD = CD U [x]
1019             %     end
1020             %   end
1021             %
1022             %
1023             %Parametres d'entrada:
1024             %
1025             %       (Parametres opcionals si ja s'han indicat anteriorment)
1026             %
1027             %       ivk - Tupla que indica el nombre de veīns a retenir a
1028             %             cada nivell del cālcul de distāncia.
1029             %
1030             %       idc - Double que indica que indica el criteri per
1031             %             calcular la distāncia entre 2 casos.
1032             %
1033             %       imethod - Double que indica el mčtode a utilitzar per
1034             %                 assignar la classe als nous problemes.
1035             %
1036             %       iparam - Parametre per a les distancies 17 i 18
1037             %
1038             %
1039             %
1040             %Parametres de sortida:
1041             %
1042             %       No en te
1043             %
1044             
1045             if nargin >1
1046                 z=whos('ivk');
1047                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1048                     %ens han passat unes dades de tipus incorrecte.
1049                     error('CBR\IB2: vk parameter must be of type Double.');
1050                 end
1051                 if (obj.block ==1) && sum(obj.vk ~= ivk)~=0
1052                     error('CBR\IB2: vk parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1053                 else
1054                     obj.vk=ivk;
1055                 end
1056                 %comprovar mides double o [double double] ??
1057                 z=whos('idc');
1058                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1059                     %ens han passat unes dades de tipus incorrecte.
1060                     error('CBR\IB2: dc parameter must be of type Double.');
1061                 end
1062                 if obj.block ==1 && obj.dc~=idc
1063                     error('CBR\IB2: dc parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1064                 else
1065                     obj.dc=idc;
1066                 end
1067                 z=whos('imethod');
1068                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1069                     %ens han passat unes dades de tipus incorrecte.
1070                     error('CBR\IB2: method parameter must be of type Double.');
1071                 end
1072                 if obj.block ==1 && obj.method~=imethod
1073                     error('CBR\IB2: method parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1074                 else
1075                     obj.method=imethod;
1076                 end
1077                 
1078                 if obj.dc ==17 || obj.dc == 18
1079                     if obj.block == 1 && obj.param~=iparam
1080                         error('CBR\IB2: This parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
1081                     else
1082                         if exist('iparam','var')
1083                             obj.param=iparam;
1084                         else
1085                             error('CBR\IB2:This distance needs an extra parameter!');
1086                         end
1087                     end
1088                 end
1089             end
1090             
1091             if isempty(obj.vk) || isempty(obj.dc)  || isempty(obj.method)
1092                 error('CBR\IB2: At least 1 of them (vk , dc , method) never had a value. You can''t use the short form.');
1093             end
1094             %mirem si hi ha el parametre extra de la distancia
1095             if obj.dc ==17 || obj.dc == 18
1096                 if isempty(obj.param)
1097                     %no s'ha fet un retrieve
1098                     error('CBR\IB2:This distance needs an extra parameter!');
1099                 end
1100             end
1101             
1102             Calcula_IB2(obj);
1103             obj.block=1;%ja no es poden canviar els parametres
1104         end
1105         function DROP4(obj,ivk,idc,imethod,iparam)
1106             %Mčtode per netejar la base de casos proposat per Wilson i
1107             %Martinez. És un procés decremental, comenįa amb la base de
1108             %casos completa i en treu els que no sķn necessaris. A
1109             %continuaciķ tenim l’algorisme original proposat per Wilson i
1110             %Martinez, el qual s’ha adaptat per tal de treballar de la
1111             %forma més eficient possible sobre Matlab.
1112             %
1113             %
1114             %DROP4(Training Set = T): Instance set S
1115             %   Let SI = T
1116             %   //inicialize the lists of neighbours and associates
1117             %   For each instance i in S
1118             %     Make sure we know the neighbors of i in S
1119             %     Add i to each of its neihbors’ lists of associates
1120             %  //Do careful noise-filtering pass  For each instance i in S
1121             %    if i is misclassified by its neighbors
1122             %      removeifnothelping(i,S)
1123             %  //Do more aggresive reduction pass  Sort instances by distance to nearest enemy (furthest ones first)
1124             %  For each instance i in S(starting with those furthest from their nearest enemy)
1125             %  removeifnothelping(i,S)
1126             %  Return S
1127             %
1128             %Parametres d'entrada:
1129             %
1130             %       (Parametres opcionals si ja s'han indicat anteriorment)
1131             %
1132             %       ivk - Tupla que indica el nombre de veīns a retenir a
1133             %             cada nivell del cālcul de distāncia.
1134             %
1135             %       idc - Double que indica que indica el criteri per
1136             %             calcular la distāncia entre 2 casos.
1137             %
1138             %       imethod - Double que indica el mčtode a utilitzar per
1139             %                 assignar la classe als nous problemes.
1140             %
1141             %       iparam - Parametre per a les distancies 17 i 18
1142             %
1143             %
1144             %
1145             %Parametres de sortida:
1146             %
1147             %       No en te
1148             %
1149             
1150             if nargin >1
1151                 z=whos('ivk');
1152                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1153                     %ens han passat unes dades de tipus incorrecte.
1154                     error('CBR\DROP4: vk parameter must be of type Double.');
1155                 end
1156                 if (obj.block ==1) && sum(obj.vk ~= ivk)~=0
1157                     error('CBR\DROP4: vk parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1158                 else
1159                     obj.vk=ivk;
1160                 end
1161                 %comprovar mides double o [double double] ??
1162                 z=whos('idc');
1163                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1164                     %ens han passat unes dades de tipus incorrecte.
1165                     error('CBR\DROP4: dc parameter must be of type Double.');
1166                 end
1167                 if obj.block ==1 && obj.dc~=idc
1168                     error('CBR\DROP4: dc parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1169                 else
1170                     obj.dc=idc;
1171                 end
1172                 z=whos('imethod');
1173                 if(not(strcmp(z.class,'double')))%comprovem que sigui del tipus correcte
1174                     %ens han passat unes dades de tipus incorrecte.
1175                     error('CBR\DROP4: method parameter must be of type Double.');
1176                 end
1177                 if obj.block ==1 && obj.method~=imethod
1178                     error('CBR\DROP4: method parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method IBUdG with all the parameters, you can use the short form.');
1179                 else
1180                     obj.method=imethod;
1181                 end
1182                 
1183                 if obj.dc ==17 || obj.dc == 18
1184                     if obj.block == 1 && obj.param~=iparam
1185                         error('CBR\DROP4: This parameter must not be changed when the case base has been optimited. Remember that is not necessary to call the method reuse with all the parameters.');
1186                     else
1187                         if exist('iparam','var')
1188                             obj.param=iparam;
1189                         else
1190                             error('CBR\DROP4:This distance needs an extra parameter!');
1191                         end
1192                     end
1193                 end
1194             end
1195             
1196             if isempty(obj.vk) || isempty(obj.dc) || isempty(obj.method)
1197                 error('CBR\DROP4: At least 1 of them (vk , dc , method) never had a value. You can''t use the short form.');
1198             end
1199             
1200                         %mirem si hi ha el parametre extra de la distancia
1201             if obj.dc ==17 || obj.dc == 18
1202                 if isempty(obj.param)
1203                     %no s'ha fet un retrieve
1204                     error('CBR\DROP4:This distance needs an extra parameter!');
1205                 end
1206             end
1207             obj.block=1;%ja no es poden canviar els parametres
1208 
1209             ordena(obj);
1210             calcula_DROP4(obj);
1211         end
1212         
1213 %-------------------------------------------------------------------------%
1214 %% -------------------- Visualitzaciķ de l'objecte -----------------------
1215 %-------------------------------------------------------------------------%
1216 
1217         %que fer quan fan doble click subre un objecte
1218         function openvar(nom,~) %l'imput ignorat es l'objecte actual!
1219             %Aquesta es una funciķ que sobreescriu l'event per defecte de
1220             %doble click sobre un objecte de tipus CBR en el workspace.
1221             %sobreescrivim la funciķ de visualitzaciķ per defecte,
1222             %el parametre ignorat és l'objecte actual el nom ens el passen
1223             %en format text. Aqui invocarem una pantalla especifica per
1224             %visualitzar l'objecte.
1225             %
1226             %!!ATENCIO!! -> Aquest metode no hauria de ser invocat per
1227             %l'usuari directament a menys que sapiga molt bé que esta fent!
1228             
1229             x=whos('nom');
1230             if strcmp(x.class,'CBR')
1231                 %no puc saber el nom de la variable -> no fem res!
1232             else
1233                 if(evalin('base',['size(' nom ');']) == [1 1])
1234                     Menu_CBR(nom)
1235                  end
1236             end
1237         end
1238         %com es mostra a consola
1239         function disp(obj)
1240             %funciķ que sobreescriu la visualitzaciķ de l'objecte per
1241             %consola i en alguns menus desplegables de matlab.
1242             %Mostrarem informaciķ util per l'usuari (tamany de les dades)
1243             %en comptes de la informaciķ per defecte.
1244             %
1245             % Aquesta funciķ s'invoca automaticament per Matlab quan cal
1246             % l'usuari no necesita invocarla en cap moment.
1247             
1248             %fem els displays que faci falta
1249             disp('Model')
1250             obj.Model.disp()
1251             
1252             disp(' ')
1253             
1254             disp('Case Base')
1255             obj.Case_Base.disp()
1256             
1257         end
1258         
1259         function s = saveobj(obj)
1260             %Sobreescripture del metode Save de matlab perque funcioni
1261             %correctament amb objectes de tipus CBR.
1262             %
1263             % Parametres de sortida:
1264             % s - l'estructura que guardarem en memoria
1265             
1266             %retorna l'objecte en format Structura
1267             s.Model =  obj.Model;
1268             s.Case_Base =  obj.Case_Base;
1269             
1270             s.vk =  obj.vk;
1271             s.dc =  obj.dc;
1272             s.method =  obj.method;
1273             
1274             s.block =  obj.block;
1275             
1276             s.test =  obj.test;
1277             s.veins =  obj.veins;
1278             s.classepredit =  obj.classepredit;
1279             
1280             s.param =  obj.param;
1281             
1282             s.treuoutliers =  obj.treuoutliers;
1283         end
1284     end
1285     
1286     methods (Static)
1287         function obj = loadobj(obj)
1288             %Sobre escriptura del metode load de matlab perque funcioni
1289             %correctament amb objectes de tipus CBR.
1290             %
1291             %Parametres
1292             % obj - entra com a structura i surt com a objecte CBR
1293             
1294             if isstruct(obj)
1295                 % Call default constructor
1296                 newObj = CBR();
1297                 % Assign property values from struct
1298                 newObj.Model =  obj.Model;
1299                 newObj.Case_Base =  obj.Case_Base;
1300                 
1301                 newObj.vk =  obj.vk;
1302                 newObj.dc =  obj.dc;
1303                 newObj.method =  obj.method;
1304                 
1305                 newObj.block =  obj.block;
1306                 
1307                 newObj.test =  obj.test;
1308                 newObj.veins =  obj.veins;
1309                 newObj.classepredit =  obj.classepredit;
1310                 
1311                 newObj.param =  obj.param;
1312                 
1313                 newObj.treuoutliers =  obj.treuoutliers;
1314                 obj = newObj;
1315             end
1316         end
1317     end
1318     
1319     methods (Access = private)
1320         
1321         function CBR_retrieve(obj)
1322             %Calculs del metode retrieve
1323             
1324             switch (obj.dc)
1325                 case 1 % Distāncia sobre les components principals
1326                     % Inicialitzacions
1327                     testgT=obj.test.getT();
1328                     CBgT=obj.Case_Base.getT();
1329                    
1330                     
1331                     % Inicialitzem el valor de k
1332                     k = min(obj.vk);
1333                     % Inicialitzem el vector on es guardaran les distāncies
1334                     distancia = zeros(size(CBgT,1),size(testgT,1));
1335                    
1336                      rep = repmat(obj.Model.getLambda()',size(CBgT,1),1);
1337                     % Cālcul de les distāncies
1338                     for i = 1:size(testgT,1)
1339                         distancia(:,i) = sqrt(sum(((CBgT - repmat(testgT(i,:),size(CBgT,1),1) ).^2 ./ rep),2));
1340                     end
1341                     % Ordenaciķ dels casos segons la distāncia
1342                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1343                     % Selecciķ dels veīns més propers
1344                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1345                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1346                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1347                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1348 
1349                 case 2 % Distāncia sobre T^2
1350                     % Inicialitzacions
1351                     tegT2=obj.test.getT2();
1352                     CBgT2=obj.Case_Base.getT2();
1353                     % Inicialitzem el valor de k
1354                     k = min(obj.vk);
1355                     % Inicialitzem el vector on es guardaran les distāncies
1356                     
1357                     distancia = zeros(length(CBgT2),length(tegT2));
1358                     % Cālcul de les distāncies
1359                     for i = 1:length(tegT2)
1360                         distancia(:,i) = abs(CBgT2 - repmat(tegT2(i),length(CBgT2),1));
1361                     end
1362                     % Ordenaciķ dels casos segons la distāncia
1363                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1364                     % Selecciķ dels veīns més propers
1365                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1366                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1367                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1368                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1369                     
1370                 case 3 % Distāncia sobre Q
1371                     % Inicialitzacions
1372                     tegQ=obj.test.getQ();
1373                     CBgQ=obj.Case_Base.getQ;
1374                     % Inicialitzem el valor de k
1375                     k = min(obj.vk);
1376                     % Inicialitzem el vector on es guardaran les distāncies
1377                     distancia = zeros(length(CBgQ),length(tegQ));
1378                     % Cālcul de les distāncies
1379                     for i = 1:length(tegQ)
1380                         distancia(:,i) = abs(CBgQ - repmat(tegQ(i),length(CBgQ),1));
1381                     end
1382                     % Ordenaciķ dels casos segons la distāncia
1383                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1384                     % Selecciķ dels veīns més propers
1385                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1386                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1387                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1388                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1389                     
1390                 case 4 % Distāncia combinada sobre Q i T^2
1391                     % Inicialitzacions
1392                     tegQ=obj.test.getQ();
1393                     CBgQ=obj.Case_Base.getQ;
1394                     tegT2=obj.test.getT2();
1395                     CBgT2=obj.Case_Base.getT2();
1396                     
1397                     % Inicialitzem el valor de k1 i k2
1398                     k1 = obj.vk(1); k2 = obj.vk(2);
1399                     if k2 > k1
1400                         k2=k1;
1401                     end
1402                     % Inicialitzem els vectors on es guardaran les distāncies
1403                     distancia1 = zeros(length(CBgQ),length(tegQ));
1404                     distancia2 = zeros(k1,length(tegQ));
1405                     % Cālcul del primer nivell de distāncies (Q)
1406                     for i = 1:length(tegQ)
1407                         distancia1(:,i) = abs(CBgQ - repmat(tegQ(i),length(CBgQ),1));
1408                     end
1409                     % Ordenaciķ dels casos segons la primera distāncia
1410                     [ordenats_k1,indexs_k1] = sort(distancia1,1);
1411                     % Selecciķ dels veīns més propers del primer nivell
1412                     obj.veins.ordenats_k1 = ordenats_k1(1:k1,:);
1413                     obj.veins.indexs_k1 = indexs_k1(1:k1,:);
1414                     
1415                     % Cālcul del segon nivell de distāncies (T^2)
1416                     for i = 1:length(tegT2)
1417                         casos_restants = CBgT2(indexs_k1(1:k1,i));
1418                         distancia2(:,i) = abs(casos_restants - repmat(tegT2(i),k1,1));
1419                     end
1420                     % Ordenaciķ dels casos segons la segona distāncia
1421                     [ordenats_k2,indexs_k2] = sort(distancia2,1);
1422                     % Selecciķ dels veīns més propers del segon nivell
1423                     obj.veins.indexs_k2 = zeros(k2,length(tegT2));
1424                     for i = 1:length(tegT2)
1425                         obj.veins.indexs_k2(:,i) = indexs_k1(indexs_k2(1:k2,i),i);
1426                     end
1427                     obj.veins.ordenats_k2 = ordenats_k2(1:k2,:);
1428                     
1429                 case 5 % Distāncia combinada sobre Q i les principals components
1430                     % Inicialitzacions
1431                     CBgQ=obj.Case_Base.getQ;
1432                     CBgT=obj.Case_Base.getT();
1433                     tegT=obj.test.getT;
1434                     tegQ=obj.test.getQ();
1435                     % Inicialitzem el valor de k1 i k2
1436                     k1 = obj.vk(1); k2 = obj.vk(2);
1437                     if k2 > k1
1438                         k2=k1;
1439                     end
1440                     % Inicialitzem els vectors on es guardaran les distāncies
1441                     distancia1 = zeros(length(CBgQ),length(tegQ));
1442                     distancia2 = zeros(k1,size(tegT,1));
1443                     % Cālcul del primer nivell de distāncies (Q)
1444                     for i = 1:length(tegQ)
1445                         distancia1(:,i) = abs(CBgQ - repmat(tegQ(i),length(CBgQ),1));
1446                     end
1447                     % Ordenaciķ dels casos segons la primera distāncia
1448                     [ordenats_k1,indexs_k1] = sort(distancia1,1);
1449                     % Selecciķ dels veīns més propers del primer nivell
1450                     obj.veins.ordenats_k1 = ordenats_k1(1:k1,:);
1451                     obj.veins.indexs_k1 = indexs_k1(1:k1,:);
1452                     % Cālcul del segon nivell de distāncies (components principals)
1453                     rep=repmat(obj.Model.getLambda()',k1,1);
1454                     for i = 1:size(tegT,1)
1455                         casos_restants = CBgT(indexs_k1(1:k1,i),:);
1456                         distancia2(:,i) = sqrt(sum(((casos_restants - repmat(tegT(i,:),k1,1)).^2) ./ rep ,2));
1457                     end
1458                     % Ordenaciķ dels casos segons la segona distāncia
1459                     [ordenats_k2,indexs_k2] = sort(distancia2,1);
1460                     % Selecciķ dels veīns més propers del segon nivell
1461                     obj.veins.indexs_k2 = zeros(k2,length(tegQ));
1462                     for i = 1:size(tegT,1)
1463                         obj.veins.indexs_k2(:,i) = indexs_k1(indexs_k2(1:k2,i),i);
1464                     end
1465                     obj.veins.ordenats_k2 = ordenats_k2(1:k2,:);
1466                     
1467                 case 6 % Distāncia combinada sobre T^2 i les principals components
1468                     % Inicialitzacions
1469                     CBgT2=obj.Case_Base.getT2;
1470                     tegT2=obj.test.getT2;
1471                     % Inicialitzem el valor de k1 i k2
1472                     k1 = obj.vk(1); k2 = obj.vk(2);
1473                     if k2 > k1
1474                         k2=k1;
1475                     end
1476                     % Inicialitzem els vectors on es guardaran les distāncies
1477                     distancia1 = zeros(length(CBgT2),length(tegT2));
1478                     distancia2 = zeros(k1,size(tegT2,1));
1479                     % Cālcul del primer nivell de distāncies (T^2)
1480                     for i = 1:length(tegT2)
1481                         distancia1(:,i) = abs(CBgT2 - repmat(tegT2(i),length(CBgT2),1));
1482                     end
1483                     % Ordenaciķ dels casos segons la primera distāncia
1484                     [ordenats_k1,indexs_k1] = sort(distancia1,1);
1485                     % Selecciķ dels veīns més propers del primer nivell
1486                     obj.veins.ordenats_k1 = ordenats_k1(1:k1,:);
1487                     obj.veins.indexs_k1 = indexs_k1(1:k1,:);
1488                     % Cālcul del segon nivell de distāncies (components principals)
1489                     CBgT=obj.Case_Base.getT();
1490                     tegT=obj.test.getT;
1491                     
1492                     aux=CBgT(indexs_k1,:);
1493                     rep=repmat(obj.Model.getLambda()',k1,1);
1494                     for i = 1:size(tegT,1)
1495                         casos_restants = aux(indexs_k1(1:k1,i),:);
1496                         distancia2(:,i) = sqrt(sum((casos_restants - repmat(tegT(i,:),k1,1)).^2 ./ rep ,2) );
1497                     end
1498                     % Ordenaciķ dels casos segons la segona distāncia
1499                     [ordenats_k2,indexs_k2] = sort(distancia2,1);
1500                     % Selecciķ dels veīns més propers del segon nivell
1501                     obj.veins.indexs_k2 = zeros(k2,length(tegT2));
1502                     for i = 1:size(tegT,1)
1503                         obj.veins.indexs_k2(:,i) = indexs_k1(indexs_k2(1:k2,i),i);
1504                     end
1505                     obj.veins.ordenats_k2 = ordenats_k2(1:k2,:);
1506                     
1507                 case 7 % Distāncia sobre Contribucions de Q en distancia euclidiana
1508                     % Inicialitzacions
1509                     tegcQ=obj.test.getQContribution();
1510                     CBgcQ=obj.Case_Base.getQContribution();
1511                     % Inicialitzem el valor de k
1512                     k = min(obj.vk);
1513                     % Inicialitzem el vector on es guardaran les distāncies
1514                     d1=size(CBgcQ,1);
1515                     distancia = zeros(d1,size(tegcQ,1));
1516                     
1517                     % Cālcul de les distāncies
1518                     for i = 1:size(tegcQ,1)
1519                         distancia(:,i) = sqrt( sum( (CBgcQ - repmat(tegcQ(i,:),[d1 1]) ).^2, 2));
1520                     end
1521                     
1522                     % Ordenaciķ dels casos segons la distāncia
1523                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1524                     % Selecciķ dels veīns més propers
1525                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1526                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1527                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1528                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1529                     
1530                 case 8 % Distāncia sobre Contribucions de T^2 en distancia euclidiana
1531                     % Inicialitzacions
1532                     tegcT2=obj.test.getT2Contribution();
1533                     CBgcT2=obj.Case_Base.getT2Contribution();
1534                     % Inicialitzem el valor de k
1535                     k = min(obj.vk);
1536                     % Inicialitzem el vector on es guardaran les distāncies
1537                     d1=size(CBgcT2,1);
1538                     distancia = zeros(d1,size(tegcT2,1));
1539                     
1540                     % Cālcul de les distāncies
1541                     for i = 1:size(tegcT2,1)
1542                         distancia(:,i) = sqrt( sum( (CBgcT2 - repmat(tegcT2(i,:),[d1 1]) ).^2, 2));
1543                     end
1544                     
1545                     
1546                     % Ordenaciķ dels casos segons la distāncia
1547                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1548                     % Selecciķ dels veīns més propers
1549                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1550                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1551                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1552                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1553                     
1554                 case 9 % Distāncia sobre Contribucions de Q en distancia mahalanobis (STD)
1555                     % Inicialitzacions
1556                     tegcQ=obj.test.getQContribution();
1557                     CBgcQ=obj.Case_Base.getQContribution();
1558                     % Inicialitzem el valor de k
1559                     k = min(obj.vk);
1560                     % Inicialitzem el vector on es guardaran les distāncies
1561                     d1=size(CBgcQ,1);
1562                     distancia = zeros(d1,size(tegcQ,1));
1563                     
1564                     %si Tenim nomes un cas a la base de casos da STD es 0!!
1565                     if(obj.Case_Base.getBatchCount()<2)
1566                         %no podem fer mahalanobis, farem distancia
1567                         %euclidiana normal
1568                         for i = 1:size(tegcQ,1)
1569                             distancia(:,i) = sqrt(sum(CBgcQ.^2 - repmat(tegcQ(i,:).^2,[d1 1]),2));
1570                         end
1571                     else %podem fer mahalanobis
1572                         % Cālcul de les distāncies
1573                         rep = (repmat(obj.Case_Base.getQContributionLimitStd(),[d1 1])).^2;
1574                         for i = 1:size(tegcQ,1)
1575                             distancia(:,i) =sqrt( sum( (CBgcQ -  repmat(tegcQ(i,:), [d1 1])).^2 ./ rep, 2) );
1576                             % distancia(:,i) = sqrt(sum((obj.Case_Base.getQContribution())./obj.Case_Base.getStd() - repmat((aux(i,:))/obj.Case_Base.getStd(),[d1 1])).^2,2);
1577                         end
1578                     end
1579                     % Ordenaciķ dels casos segons la distāncia
1580                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1581                     % Selecciķ dels veīns més propers
1582                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1583                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1584                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1585                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1586                     
1587                  case 10 % Distāncia sobre Contribucions de T^2 en distancia mahalanobis (STD)
1588                     % Inicialitzacions
1589                     tegcQ=obj.test.getT2Contribution();
1590                     CBgcQ=obj.Case_Base.getT2Contribution();
1591                     % Inicialitzem el valor de k
1592                     k = min(obj.vk);
1593                     % Inicialitzem el vector on es guardaran les distāncies
1594                     d1=size(CBgcQ,1);
1595                     distancia = zeros(d1,size(tegcQ,1));
1596                     
1597                     %si Tenim nomes un cas a la base de casos da STD es 0!!
1598                     if(obj.Case_Base.getBatchCount()<2)
1599                         %no podem fer mahalanobis, farem distancia
1600                         %euclidiana normal
1601                         for i = 1:size(tegcQ,1)
1602                             distancia(:,i) = sqrt(sum(CBgcQ.^2 - repmat(tegcQ(i,:).^2,[d1 1]),2));
1603                         end
1604                     else %podem fer mahalanobis
1605                         % Cālcul de les distāncies
1606                         rep = (repmat(obj.Case_Base.getT2ContributionLimitStd(),[d1 1])).^2;
1607                         for i = 1:size(tegcQ,1)
1608                             distancia(:,i) =sqrt( sum( (CBgcQ -  repmat(tegcQ(i,:), [d1 1])).^2 ./ rep, 2) );
1609                             % distancia(:,i) = sqrt(sum((obj.Case_Base.getQContribution())./obj.Case_Base.getStd() - repmat((aux(i,:))/obj.Case_Base.getStd(),[d1 1])).^2,2);
1610                         end
1611                     end
1612                     % Ordenaciķ dels casos segons la distāncia
1613                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1614                     % Selecciķ dels veīns més propers
1615                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1616                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1617                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1618                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1619                     
1620                 case 11% Distāncia combinada sobre Q i T^2
1621                     % Inicialitzacions
1622                     tegT2=obj.test.getT2();
1623                     CBgT2=obj.Case_Base.getT2();
1624                     tegQ=obj.test.getQ();
1625                     CBgQ=obj.Case_Base.getQ();
1626                     % Inicialitzem el valor de k1 i k2
1627                     k = min(obj.vk);
1628                     % Inicialitzem el vector on es guardaran les distāncies
1629                     distancia1 = zeros(length(CBgT2),length(tegT2));
1630                     
1631                     % Cālcul de les distāncies per T^2
1632                     for i = 1:length(tegT2)
1633                         distancia1(:,i) = abs(CBgT2 - repmat(tegT2(i),length(CBgT2),1));
1634                     end
1635                     
1636                     % Distāncia sobre Q
1637                     % Inicialitzem el vector on es guardaran les distāncies
1638                     distancia2 = zeros(length(CBgQ),length(tegQ));
1639                     % Cālcul de les distāncies
1640                     for i = 1:length(tegQ)
1641                         distancia2(:,i) = abs(CBgQ - repmat(tegQ(i),length(CBgQ),1) );
1642                     end
1643                     
1644                     distancia=sqrt(distancia1.^2+distancia2.^2);
1645                     % Ordenaciķ dels casos segons la distāncia
1646                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1647                     % Selecciķ dels veīns més propers
1648                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1649                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1650                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1651                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1652                     
1653                 case 12% Distāncia sobre Signatures de Q
1654                     % Inicialitzacions
1655                     tegcQ=obj.test.getQContribution();
1656                     tegcQ = tegcQ > repmat((obj.test.getQContributionLimitMean + obj.test.getQContributionLimitStd * 3),[size(tegcQ,1) 1] ); %pasem a binari
1657                     CBgcQ=obj.Case_Base.getQContribution();
1658                     CBgcQ= CBgcQ> repmat((obj.Case_Base.getQContributionLimitMean + obj.Case_Base.getQContributionLimitStd * 3),[size(CBgcQ,1) 1] ); %pasem a binari
1659                     
1660                     % Inicialitzem el valor de k
1661                     k = min(obj.vk);
1662                     % Inicialitzem el vector on es guardaran les distāncies
1663                     d1=size(CBgcQ,1);
1664                     distancia = zeros(d1,size(tegcQ,1));
1665                     
1666                     % Cālcul de les distāncies
1667                     for i = 1:size(tegcQ,1)
1668                         distancia(:,i)=sum(repmat(tegcQ(i,:),[d1 1]) ~= CBgcQ,2);
1669                     end
1670                     distancia =  distancia / size(tegcQ,2);
1671                     % Ordenaciķ dels casos segons la distāncia
1672                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1673                     % Selecciķ dels veīns més propers
1674                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1675                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1676                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1677                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1678                     
1679                 case 13% Distāncia sobre Signatures de T^2
1680                     % Inicialitzacions
1681                     tegcT2=obj.test.getT2Contribution();
1682                     tegcT2 = tegcT2 > repmat((obj.test.getT2ContributionLimitMean + obj.test.getT2ContributionLimitStd * 3),[size(tegcT2,1) 1] ); %pasem a binari
1683                     CBgcT2=obj.Case_Base.getT2Contribution();
1684                     CBgcT2= CBgcT2> repmat((obj.Case_Base.getT2ContributionLimitMean + obj.Case_Base.getT2ContributionLimitStd * 3),[size(CBgcT2,1) 1] ); %pasem a binari
1685                     
1686                     % Inicialitzem el valor de k
1687                     k = min(obj.vk);
1688                     % Inicialitzem el vector on es guardaran les distāncies
1689                     d1=size(CBgcT2,1);
1690                     distancia = zeros(d1,size(tegcT2,1));
1691                     
1692                     % Cālcul de les distāncies
1693                     for i = 1:size(tegcT2,1)
1694                         distancia(:,i)=sum(repmat(tegcT2(i,:),[d1 1]) ~= CBgcT2,2);
1695                     end
1696                     distancia =  distancia / size(tegcT2,2);
1697                     % Ordenaciķ dels casos segons la distāncia
1698                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1699                     % Selecciķ dels veīns més propers
1700                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1701                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1702                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1703                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1704                     
1705                 case 14 % Signatures de Q agrupades per fases
1706                     % Inicialitzacions
1707                     tegcQ=obj.test.getQContribution();
1708                     tegcQ = tegcQ > repmat((obj.test.getQContributionLimitMean + obj.test.getQContributionLimitStd * 3),[size(tegcQ,1) 1] ); %pasem a binari
1709                     CBgcQ=obj.Case_Base.getQContribution();
1710                     CBgcQ= CBgcQ> repmat((obj.Case_Base.getQContributionLimitMean + obj.Case_Base.getQContributionLimitStd * 3),[size(CBgcQ,1) 1] ); %pasem a binari
1711                     dfases=repmat(obj.test.getDATA.getStagesDurations(),1,obj.test.getVariableCount);
1712                     if isempty(dfases)
1713                        error('There is no value in Fases. You can use this distance method without Fases value.') 
1714                     end
1715                     index = 1;
1716                     cdfases=cumsum(dfases);
1717                     tegcQ=double(tegcQ);
1718                     CBgcQ = double(CBgcQ);
1719                     for i=1:length(dfases)
1720                        tegcQ(:,i) = sum(tegcQ(:,index:cdfases(i)),2);
1721                        CBgcQ(:,i) = sum(CBgcQ(:,index:cdfases(i)),2);
1722                        index = index + dfases(i);
1723                     end
1724                     tegcQ(:,(length(dfases)+1):end) = [];
1725                     CBgcQ(:,(length(dfases)+1):end) = [];
1726                     % Inicialitzem el valor de k
1727                     k = min(obj.vk);
1728                     % Inicialitzem el vector on es guardaran les distāncies
1729                     d1=size(CBgcQ,1);
1730                     distancia = zeros(d1,size(tegcQ,1));
1731                     
1732                     % Cālcul de les distāncies
1733                     for i = 1:size(tegcQ,1)
1734                         distancia(:,i)=abs(sum(repmat(tegcQ(i,:),[d1 1]) - CBgcQ,2));
1735                     end
1736                     distancia =  distancia / max(cdfases);
1737                     % Ordenaciķ dels casos segons la distāncia
1738                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1739                     % Selecciķ dels veīns més propers
1740                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1741                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1742                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1743                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1744                     
1745                 case 15 % Signatures de T2 agrupades per fases
1746                     % Inicialitzacions
1747                     tegcQ=obj.test.getT2Contribution();
1748                     tegcQ = tegcQ > repmat((obj.test.getT2ContributionLimitMean + obj.test.getT2ContributionLimitStd * 3),[size(tegcQ,1) 1] ); %pasem a binari
1749                     CBgcQ=obj.Case_Base.getT2Contribution();
1750                     CBgcQ= CBgcQ> repmat((obj.Case_Base.getT2ContributionLimitMean + obj.Case_Base.getT2ContributionLimitStd * 3),[size(CBgcQ,1) 1] ); %pasem a binari
1751                     dfases=repmat(obj.test.getDATA.getStagesDurations(),1,obj.test.getVariableCount);
1752                     if isempty(dfases)
1753                        error('There is no value in Fases. You can use this distance method without Fases value.') 
1754                     end
1755                     index = 1;
1756                     cdfases=cumsum(dfases);
1757                     tegcQ=double(tegcQ);
1758                     CBgcQ = double(CBgcQ);
1759                     for i=1:length(dfases)
1760                        tegcQ(:,i) = sum(tegcQ(:,index:cdfases(i)),2);
1761                        CBgcQ(:,i) = sum(CBgcQ(:,index:cdfases(i)),2);
1762                        index = index + dfases(i);
1763                     end
1764                     tegcQ(:,(length(dfases)+1):end) = [];
1765                     CBgcQ(:,(length(dfases)+1):end) = [];
1766                     % Inicialitzem el valor de k
1767                     k = min(obj.vk);
1768                     % Inicialitzem el vector on es guardaran les distāncies
1769                     d1=size(CBgcQ,1);
1770                     distancia = zeros(d1,size(tegcQ,1));
1771                     
1772                     % Cālcul de les distāncies
1773                     for i = 1:size(tegcQ,1)
1774                         distancia(:,i)=abs(sum(repmat(tegcQ(i,:),[d1 1]) - CBgcQ,2));
1775                     end
1776                     distancia =  distancia / max(cdfases);
1777                     % Ordenaciķ dels casos segons la distāncia
1778                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1779                     % Selecciķ dels veīns més propers
1780                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1781                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1782                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1783                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1784                     
1785                 case 16 % Distāncia sobre Contribucions de Q en distancia mahalanobis (Lambda)
1786                                      % Inicialitzacions
1787                     testgT=obj.test.getT();
1788                     CBgT=obj.Case_Base.getT();
1789                    
1790                     
1791                     % Inicialitzem el valor de k
1792                     k = min(obj.vk);
1793                     % Inicialitzem el vector on es guardaran les distāncies
1794                     distancia = zeros(size(CBgT,1),size(testgT,1));
1795                    
1796 
1797                     % Cālcul de les distāncies
1798                     for i = 1:size(testgT,1)
1799                         distancia(:,i) = sqrt(sum(((CBgT - repmat(testgT(i,:),size(CBgT,1),1) ).^2 ),2));
1800                     end
1801                     % Ordenaciķ dels casos segons la distāncia
1802                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1803                     % Selecciķ dels veīns més propers
1804                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1805                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1806                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1807                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1808                     
1809                 case 17  % Signatures de Q agrupades per fases binaritzades
1810                     % Inicialitzacions
1811                     tegcQ=obj.test.getQContribution();
1812                     tegcQ = tegcQ > repmat((obj.test.getQContributionLimitMean + obj.test.getQContributionLimitStd * 3),[size(tegcQ,1) 1] ); %pasem a binari
1813                     CBgcQ=obj.Case_Base.getQContribution();
1814                     CBgcQ= CBgcQ> repmat((obj.Case_Base.getQContributionLimitMean + obj.Case_Base.getQContributionLimitStd * 3),[size(CBgcQ,1) 1] ); %pasem a binari
1815                     dfases=repmat(obj.test.getDATA.getStagesDurations(),1,obj.test.getVariableCount);
1816                     if isempty(dfases)
1817                        error('There is no value in Fases. You can use this distance method without Fases value.') 
1818                     end
1819                     index = 1;
1820                     cdfases=cumsum(dfases);
1821                     tegcQ=double(tegcQ);
1822                     CBgcQ = double(CBgcQ);
1823                     for i=1:length(dfases)
1824                        tegcQ(:,i) = sum(tegcQ(:,index:cdfases(i)),2);
1825                        CBgcQ(:,i) = sum(CBgcQ(:,index:cdfases(i)),2);
1826                        index = index + dfases(i);
1827                     end
1828                     tegcQ(:,(length(dfases)+1):end) = [];
1829                     CBgcQ(:,(length(dfases)+1):end) = [];
1830                     % Inicialitzem el valor de k
1831                     k = min(obj.vk);
1832                     % Inicialitzem el vector on es guardaran les distāncies
1833                     d1=size(CBgcQ,1);
1834                     distancia = zeros(d1,size(tegcQ,1));
1835                     
1836                     % Cālcul de les distāncies
1837                     tegcQ = tegcQ > repmat((dfases*obj.param),size(tegcQ,1),1 );
1838                     CBgcQ = CBgcQ > repmat((dfases*obj.param),size(CBgcQ,1),1 );
1839                     
1840                     %no cal fer el for!!
1841                     for i = 1:size(tegcQ,1)
1842                         distancia(:,i)=abs(sum(repmat(tegcQ(i,:),[d1 1]) - CBgcQ,2));
1843                     end
1844                     distancia =  distancia / size(tegcQ,2);
1845                     % Ordenaciķ dels casos segons la distāncia
1846                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1847                     % Selecciķ dels veīns més propers
1848                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1849                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1850                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1851                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1852                     
1853                 case 18 % Signatures de T2 agrupades per fases
1854                     % Inicialitzacions
1855                     tegcQ=obj.test.getT2Contribution();
1856                     tegcQ = tegcQ > repmat((obj.test.getT2ContributionLimitMean + obj.test.getT2ContributionLimitStd * 3),[size(tegcQ,1) 1] ); %pasem a binari
1857                     CBgcQ=obj.Case_Base.getT2Contribution();
1858                     CBgcQ= CBgcQ> repmat((obj.Case_Base.getT2ContributionLimitMean + obj.Case_Base.getT2ContributionLimitStd * 3),[size(CBgcQ,1) 1] ); %pasem a binari
1859                     dfases=repmat(obj.test.getDATA.getStagesDurations(),1,obj.test.getVariableCount);
1860                     if isempty(dfases)
1861                        error('There is no value in Fases. You can use this distance method without Fases value.') 
1862                     end
1863                     index = 1;
1864                     cdfases=cumsum(dfases);
1865                     tegcQ=double(tegcQ);
1866                     CBgcQ = double(CBgcQ);
1867                     for i=1:length(dfases)
1868                        tegcQ(:,i) = sum(tegcQ(:,index:cdfases(i)),2);
1869                        CBgcQ(:,i) = sum(CBgcQ(:,index:cdfases(i)),2);
1870                        index = index + dfases(i);
1871                     end
1872                     tegcQ(:,(length(dfases)+1):end) = [];
1873                     CBgcQ(:,(length(dfases)+1):end) = [];
1874                     % Inicialitzem el valor de k
1875                     k = min(obj.vk);
1876                     % Inicialitzem el vector on es guardaran les distāncies
1877                     d1=size(CBgcQ,1);
1878                     distancia = zeros(d1,size(tegcQ,1));
1879                     
1880                    % Cālcul de les distāncies
1881 
1882                     tegcQ = tegcQ > repmat((dfases *obj.param),size(tegcQ,1),1 );
1883                     CBgcQ = CBgcQ > repmat((dfases *obj.param),size(CBgcQ,1),1 );
1884                     
1885                     % Cālcul de les distāncies
1886                     for i = 1:size(tegcQ,1)
1887                         distancia(:,i)=abs(sum(repmat(tegcQ(i,:),[d1 1]) - CBgcQ,2));
1888                     end
1889                     distancia =  distancia / max(cdfases);
1890                     % Ordenaciķ dels casos segons la distāncia
1891                     [ordenats_k1,indexs_k1] = sort(distancia,1);
1892                     % Selecciķ dels veīns més propers
1893                     obj.veins.ordenats_k1 = ordenats_k1(1:k,:);
1894                     obj.veins.indexs_k1 = indexs_k1(1:k,:);
1895                     obj.veins.ordenats_k2 = obj.veins.ordenats_k1;
1896                     obj.veins.indexs_k2 = obj.veins.indexs_k1;
1897                     
1898                 %case xx
1899                 %si s'afegeixen noves distancies recordar a modificar drop4
1900                 %El drop4 optimitzat necesita saber quins metodes son
1901                 %distancies d'un nivell i quines de 2 si no donarā error!
1902                 
1903             end
1904         end   
1905         function CBR_reuse(obj)
1906             %calculs del metode reuse
1907             
1908             if(obj.vk(2)==1)
1909                 %Si nomes bolen un cas no calen calculs!
1910                  obj.classepredit= obj.Case_Base.getClass(obj.veins.indexs_k2(1,:));
1911             else
1912                 %obj.vk(2) > 1
1913                 vks = min(min(obj.vk),size(obj.veins.indexs_k2,1));
1914                 switch (obj.method)
1915                     case 1 % voting ponderat per distancia i frequencia de la classe
1916                         
1917                         classes=obj.Case_Base.getClass(); %les classes de tots els lots
1918                         n_classes=max(classes); %el numero de classes (el calculem aixi perque pot haver-hi classes buides mentres fem IB3 ...)
1919                         
1920                         classes_i = classes(obj.veins.indexs_k2(1:vks,:));%la classe de l'element
1921                         
1922                         %Calculem el que 'val' el bot de cada element
1923                         pes =  1./ obj.veins.ordenats_k2(1:vks,:);
1924                         if size(classes_i,1)==1
1925                             classes_i=classes_i';
1926                         end
1927                         if size(pes,1)==1
1928                             pes=pes';
1929                         end
1930                         freq=hist(classes(obj.veins.indexs_k2(1:vks,:)),1:n_classes); %Contem la frequencia en que ens apareixen les classes per cada observaciķ
1931                         if size(freq,1)==1
1932                             freq=freq';
1933                         end
1934                         %per tal d'afaborir als grups fem que el vot de l'element valgui mes per la classe predominant
1935                         if obj.test.getBatchCount == 1
1936                             pes=pes.*freq(classes_i); %modif ic 22/09/11
1937                         else
1938                             pes=pes.* (freq(classes_i + repmat((((1:obj.test.getBatchCount)-1).*n_classes),size(classes_i,1),1)));
1939                             %pes=pes.* (freq(classes_i + repmat((((1:obj.test.getBatchCount)-1).*n_classes),min([n_classes length(classes)]),1))); %multipliquem per la frequencia de la classe de l'element
1940                         end
1941                         %posem els pesos maxims a 0
1942                         maxi=zeros(1,obj.test.getBatchCount);
1943                         
1944                         %inicialitzem les classes a 0
1945                         obj.classepredit=zeros(1,obj.test.getBatchCount);
1946                         
1947                         for i=1:n_classes
1948                             if size(classes_i,1)>1
1949                                 index=classes_i(1:vks,:)==i;%un punter als que son de clase indicada
1950                             else
1951                                 index=(classes_i(1:vks)==i)';%quan es d'una sola dimencio s'ha de posar be
1952                             end
1953                             maxpes = pes .* index; %pasem de punters a tenir els pesos dels elements
1954                             
1955                             maxpes(isnan(maxpes)) = 0;% Per evitar problemes de Inf + NaN = NaN i ens interessa l'inf!!!
1956                             
1957                             pesos=sum(maxpes); % sumem els pesos dels elements de classe i
1958                             obj.classepredit(pesos > maxi)  = i; %si aquest pes 'pesos' es mes gran que l'anterior assignem la classe a l'element
1959                             maxi(pesos > maxi) =  pesos(pesos > maxi); %actualitzem el vector de pesos maxims
1960                         end
1961                         
1962                     case 2 %Votting simple
1963                         
1964                         classes=obj.Case_Base.getClass(); %les classes de tots els lots
1965                         n_classes=max(classes); %el numero de classes (el calculem aixi perque pot haver-hi classes buides mentres fem IB3 ...)
1966                         if n_classes == 1
1967                             obj.classepredit=ones(1,obj.test.getBatchCount);
1968                         else
1969                             vks = max(1,min(min(hist(classes,1:n_classes)),vks));
1970                             if isempty(vks) %no hi ha res a la C_B
1971                                 obj.classepredit=-ones(1,obj.test.getBatchCount);
1972                             elseif(vks == 1)
1973                                 obj.classepredit=classes(obj.veins.indexs_k2(1:vks,:)); %Contem la frequencia en que ens apareixen les classes per cada observaciķ
1974                             else
1975                                 freq=hist(classes(obj.veins.indexs_k2(1:vks,:)),1:n_classes); %Contem la frequencia en que ens apareixen les classes per cada observaciķ
1976                                 [~,obj.classepredit] = max(freq);%la posiciķ on es troba el maxim es la classe de l'element!
1977                             end
1978                         end
1979                         
1980                     case 3 %Votting ponderat per distancia
1981                         
1982                         classes=obj.Case_Base.getClass(); %les classes de tots els lots
1983                         n_classes=max(classes); %el numero de classes (el calculem aixi perque pot haver-hi classes buides mentres fem IB3 ...)
1984                         
1985                         classes_i = classes(obj.veins.indexs_k2(1:vks,:));%la classe de l'element
1986                         
1987                         %Calculem el que 'val' el bot de cada element
1988                         pes =  1./ obj.veins.ordenats_k2(1:vks,:);
1989                         
1990                         %posem els pesos maxims a 0
1991                         maxi=zeros(1,obj.test.getBatchCount);
1992                         
1993                         %inicialitzem les classes a 0
1994                         obj.classepredit=zeros(1,obj.test.getBatchCount);
1995                         
1996                         for i=1:n_classes
1997                             if size(classes_i,1)>1
1998                                 index=classes_i(1:vks,:)==i;%un punter als que son de clase indicada
1999                             else
2000                                 index=(classes_i(1:vks)==i)';%quan es d'una sola dimencio s'ha de posar be
2001                             end
2002                             maxpes = pes .* index; %pasem de punters a tenir els pesos dels elements
2003                             
2004                             maxpes(isnan(maxpes)) = 0;% Per evitar problemes de Inf + NaN = NaN i ens interessa l'inf!!!
2005                             
2006                             pesos=sum(maxpes); % sumem els pesos dels elements de classe i
2007                             obj.classepredit(pesos > maxi)  = i; %si aquest pes 'pesos' es mes gran que l'anterior assignem la classe a l'element
2008                             maxi(pesos > maxi) =  pesos(pesos > maxi); %actualitzem el vector de pesos maxims
2009                         end
2010                         
2011                     otherwise
2012                         error('CBR/reuse: Choose a valid method!');
2013                         
2014                 end
2015             end
2016             
2017         end
2018         function CBR_retain(obj,fallen)
2019             %Calculs del metode retain
2020             
2021             if( sum(fallen)~=0)
2022                 
2023                 %afegim un cas a la BD si s'ha predit malament
2024                 
2025                 if(size(fallen,1)~=1) && (size(fallen,2)~=1)
2026                     error('CBR/Retain: the class vector sise is not valid. A vector is needed');
2027                 end
2028                 
2029                 [dades class noms]=obj.test.getBatch(fallen);%els agafem
2030                 
2031                 obj.Case_Base.addBatch(dades,class,noms);%els afegim a la C_B projectantlos ...
2032             end
2033         end
2034         function [matri fallen] = CBR_revise(obj)
2035             %Calculs de la funcio revise
2036             
2037             if isempty(obj.test.getClass()) 
2038                 %hem de demanar la classe a l'usuari
2039                 c=input('Give the new class vector: exemple [ 1 1 1 2 ]\n');
2040                 obj.test.setClass(c);
2041             end
2042             
2043             %matriu de confusio i calcular els estadistics associats
2044             %si coneixem la classe del testset es automatic.
2045             matri = compute_extended_confusion_matrix(obj.classepredit,obj.test.getClass(), length(unique(obj.Case_Base.getClass())));
2046             fallen=(obj.classepredit~=obj.test.getClass());
2047         end
2048         
2049         function Calcula_IB_UdG(obj, nelem, descarta)
2050             %Calculs de IBUDG
2051             
2052             if descarta > nelem
2053                 nelem=descarta;
2054             end
2055             
2056             %nelem=nelem+descarta;
2057             
2058             %Metode per netejar la base de casos
2059             segur=obj.vk;
2060             obj.vk=[obj.Case_Base.getBatchCount() obj.Case_Base.getBatchCount()];
2061             obj.retrieve(obj.Case_Base.getDATA());
2062             obj.vk=segur;
2063             classes=obj.Case_Base.getClass();
2064             resu=classes(obj.veins.indexs_k1);
2065             %tenim una matriu amb dim(1) classe dels veins ordenats per
2066             %distancia i dim(2) tots els casos
2067             
2068             %el primer es ell mateix aixo ens va Be per saver kin agafar
2069             enemics=(resu~=repmat(resu(1,:),size(resu,1),1));%logics (els que no son de la meva classe)
2070             [~,IX]=sort(enemics,'descend');
2071             x2=1:obj.Case_Base.getBatchCount();
2072             x2=repmat(x2,nelem,1);
2073             x1=IX(1:nelem,:);
2074             %index=unique(obj.veins.indexs_k2((x1*obj.Case_Base.getBatchCount())+x2 - 1));
2075             
2076             %posem l'element de cada classe k "menys enemics te"  (centroide aproximat)
2077             bons=ones(size(unique(classes)))*nelem;
2078             indexcentres=zeros(size(unique(classes)));
2079             sumaenemics=sum(enemics(2:nelem,:),1);
2080             for i=1 : obj.Case_Base.getBatchCount()
2081                 if(bons(classes(i))>sumaenemics(i))
2082                     bons(classes(i))=sumaenemics(i);
2083                     indexcentres(classes(i))=i;
2084                 end
2085             end
2086             temp=unique(obj.veins.indexs_k2(sub2ind(size(obj.veins.indexs_k2),x1,x2)));
2087             temp2=unique(obj.veins.indexs_k2(sub2ind(size(obj.veins.indexs_k2),x1(1:descarta,:),x2(1:descarta,:))));
2088             temp=setdiff(temp,temp2);
2089             if size(temp,1)~=1
2090                 temp=temp';
2091             end
2092             
2093             indexcentres=setdiff(indexcentres,indexcentres(unique(classes(temp))));
2094             index = unique([temp indexcentres]);
2095             %a enemics buscar la posicio del primer 1 per cada columna
2096             
2097             
2098             
2099             obj.Case_Base.deleteBatch(setdiff(1:obj.Case_Base.getBatchCount(),index));
2100             %treuresoroll(obj,0.7,nelem,[obj.Case_Base.getBatchCount() obj.Case_Base.getBatchCount()],dc);
2101             
2102         end
2103         function calcula_DROP4(obj)
2104             %Calculs DROP4
2105             
2106             C_B_vella=obj.Case_Base.getDATA();%copia auxiliar de la C_B inicial
2107             cla=C_B_vella.getClass();%classes inicials
2108             %C_B_Vella l'utilitzarem de conjunt de test.
2109             
2110             %primer de tot un filtre per treure el soroll. A diferencia del
2111             %proposat als papers aqui no el fem iteratiu calculem de cop
2112             %tots els enemics i treiem els que tenen el 70% dels seus veins
2113             %de classes diferents a la seva. Aixķ fa que el nostre filtre
2114             %de soroll no depengui de l'ordre dels elements. Tambe es mes
2115             %rapid de calcular en matlab que la versiķ iterativa.
2116             
2117             treuresoroll(obj,0.7,min(obj.vk));
2118             
2119 
2120             %Per tal d'evitar haver de calcular totes les distancies a cada
2121             %iteraciķ el que farem es calcular un sol cop totes les
2122             %distancies i anar mantenint l'estructura dels veins perque
2123             %quedi com si haguessim fet el retreave pertinent.
2124             segur=obj.vk;%faig una copia del VK actual per no perdrel en fer un retreave de tots contra tots.
2125             obj.vk=[C_B_vella.getBatchCount() C_B_vella.getBatchCount()];%maxim possible aixi calculara totes les distancies
2126             obj.retrieve(C_B_vella);%tem el retreave
2127             obj.vk=segur;%tornem a deixar vk com estava
2128             
2129             
2130             %busquem el nombre de classificacio inicial
2131             classpredit = reuse(obj);%prediccio inicial
2132             encertats=sum(classpredit == cla);%classificaciķ inicial (no deixarem que vaxi)
2133             
2134             %Per cada lot hem de treurel de la base de casos i omprobar que
2135             %sense ell no vaixi el % de classificaciķ de la base de casos.
2136             for i=1:obj.Case_Base.getBatchCount()%per cada lot
2137                 %treiem el lot
2138                 [dades , clas , noms]=obj.Case_Base.getBatch(1);%(treurem sempre per davant i afegirem per derrera aixi evitem tenir indexs)
2139                 obj.Case_Base.deleteBatch(1);%treiem un lot
2140                 %busquem la classificaciķ de cada un dels elements de la C_B_vella
2141                 
2142                 %Ara tocaria fer:
2143                 %   retrieve(obj,C_B_vella);
2144                 %   reuse(obj);
2145                 %Perō aixo es extremadament inaficient en matlab per tant ens tocara fer el retreave a ma.
2146                 
2147                 %per si hi ha menys elements a la C_B dels que bolem agafar segons el retreave
2148                 vkseg = obj.vk;
2149                 obj.vk(1) = min(obj.vk(1),obj.Case_Base.getBatchCount);
2150                 obj.vk(2) = min(obj.vk(2),obj.Case_Base.getBatchCount);
2151                 
2152                 if (obj.dc <4 || obj.dc >6)%primer de tot controlem si es una distancia d'un nivell o de dos ya que el procediment canviarā.
2153                     %Aqui es on farem el ''retreave'' de les distancies
2154                     %d'un sol nivell.
2155                     
2156                     x=obj.veins.indexs_k2(:);%el passem els index a 1 dimenciķ
2157                     ins=x==1;%busquem els 1
2158                     
2159                     %calculem els indexs veins sense l'element (treiem els 1 i restem 1 als altres)
2160                     temporal=(reshape(x(not(ins))',size(obj.veins.indexs_k2,1)-1,size(obj.veins.indexs_k2,2)))-1; %i els hi restem 1
2161                     
2162                     %calculem la matriu d'index veins per si l'element s'afegeix posteriorment
2163                     x(ins)=obj.Case_Base.getBatchCount()+2; %substitueixo els 1 per num max+2
2164                     x=x-1;%refem els indexs de tots els altres elements restan 1 (els 1 passen a ser max i els 2->1 3->2....) aixo es per si acabem afegint l'element per darrera com quedara la matriu.
2165                     segur_i_k2=reshape(x,size(obj.veins.indexs_k2,1),size(obj.veins.indexs_k2,2));%posem be de nou la matriu per si l'element s'afegeix
2166                     %les distancies no canviaran si s'efegeix l'element
2167                     segur_o_k2=obj.veins.ordenats_k2;%faix una copia dels ordenats_k2
2168                     
2169                     %ja podem modificar index_k2 sense perill
2170                     obj.veins.indexs_k2=temporal;
2171                     
2172                     %calculem ordenats_k2 sense l'element que hem tret
2173                     x=obj.veins.ordenats_k2(:);%agafem els ordenats en format 1 dimenciķ
2174                     obj.veins.ordenats_k2=reshape(x(not(ins))',size(obj.veins.ordenats_k2,1)-1,size(obj.veins.ordenats_k2,2)); %treiem els que eren (index 1)
2175 
2176                     reuse(obj); %Fem un reuse per calcular la classe de cada element
2177                     
2178                 else
2179                     
2180                     %Aqui mantindrem fixes els K1 i K2 (amb tots els elements)
2181                     %%%%%%%%%%%%K1%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2182                     x=obj.veins.indexs_k1(:);%el passem els index a 1 dimenciķ
2183                     ins=x==1;%busquem els 1
2184                     
2185                     %calculem els indexs veins sense l'element (treiem els 1 i restem 1 als altres)
2186                     temporal=(reshape(x(not(ins))',size(obj.veins.indexs_k1,1)-1,size(obj.veins.indexs_k1,2)))-1; %i els hi restem 1
2187                     
2188                     %calculem la matriu d'index veins per si l'element s'afegeix posteriorment
2189                     x(ins)=obj.Case_Base.getBatchCount()+2; %substitueixo els 1 per num max+2
2190                     x=x-1;%refem els indexs de tots els altres elements restan 1 (els 1 passen a ser max i els 2->1 3->2....) aixo es per si acabem afegint l'element per darrera com quedara la matriu.
2191                     segur_i_k1=reshape(x,size(obj.veins.indexs_k1,1),size(obj.veins.indexs_k1,2));%posem be de nou la matriu per si l'element s'afegeix
2192                     %les distancies no canviaran si s'efegeix l'element
2193                     segur_o_k1=obj.veins.ordenats_k1;%faix una copia dels ordenats_k1
2194                     
2195                     %ja podem modificar index_k1 sense perill
2196                     obj.veins.indexs_k1=temporal;
2197                     
2198                     %calculem ordenats_k1 sense l'element que hem tret
2199                     x=obj.veins.ordenats_k1(:);%agafem els ordenats en format 1 dimenciķ
2200                     obj.veins.ordenats_k1=reshape(x(not(ins))',size(obj.veins.ordenats_k1,1)-1,size(obj.veins.ordenats_k1,2)); %treiem els que eren (index 1)
2201 
2202                     
2203                     %%%%%%%%%%%%K2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2204                     x=obj.veins.indexs_k2(:);%el passem els index a 1 dimenciķ
2205                     ins=x==1;%busquem els 1
2206                     
2207                     %calculem els indexs veins sense l'element (treiem els 1 i restem 1 als altres)
2208                     temporal=(reshape(x(not(ins))',size(obj.veins.indexs_k2,1)-1,size(obj.veins.indexs_k2,2)))-1; %i els hi restem 1
2209                     
2210                     %calculem la matriu d'index veins per si l'element s'afegeix posteriorment
2211                     x(ins)=obj.Case_Base.getBatchCount()+2; %substitueixo els 1 per num max+2
2212                     x=x-1;%refem els indexs de tots els altres elements restan 1 (els 1 passen a ser max i els 2->1 3->2....) aixo es per si acabem afegint l'element per darrera com quedara la matriu.
2213                     segur_i_k2=reshape(x,size(obj.veins.indexs_k2,1),size(obj.veins.indexs_k2,2));%posem be de nou la matriu per si l'element s'afegeix
2214                     %les distancies no canviaran si s'efegeix l'element
2215                     segur_o_k2=obj.veins.ordenats_k2;%faix una copia dels ordenats_k2
2216                     
2217                     %ja podem modificar index_k2 sense perill
2218                     obj.veins.indexs_k2=temporal;
2219                     
2220                     %calculem ordenats_k2 sense l'element que hem tret
2221                     x=obj.veins.ordenats_k2(:);%agafem els ordenats en format 1 dimenciķ
2222                     obj.veins.ordenats_k2=reshape(x(not(ins))',size(obj.veins.ordenats_k2,1)-1,size(obj.veins.ordenats_k2,2)); %treiem els que eren (index 1)
2223 
2224                     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2225                     %De K2 ens quedem nomes amb els que estiguin entre els
2226                     %vk(1) de K1 sempre i quan tinguem prous elements
2227                     ind=obj.veins.indexs_k1(1:obj.vk(1),:); %agafem els indexs
2228                     
2229                     %inicialitzem el tamany
2230 
2231                      orde = zeros(obj.vk(2),length(obj.veins.ordenats_k1));
2232                      inde = zeros(obj.vk(2),length(obj.veins.ordenats_k1));
2233                      
2234                      %per cada fila de ind
2235                     for buc=1:size(ind,1)
2236                         %agafem els que toquen de K2
2237                         orde(buc,:)=(obj.veins.ordenats_k1(obj.veins.indexs_k2==repmat(ind(buc,:),size(obj.veins.indexs_k2,1),1)))';
2238                         inde(buc,:)=(obj.veins.indexs_k1(obj.veins.indexs_k2==repmat(ind(buc,:),size(obj.veins.indexs_k2,1),1)))';
2239                     end
2240                     
2241                     %fem una copia de K2 per no perdrel's
2242                     s1 = obj.veins.indexs_k2;
2243                     s2 = obj.veins.ordenats_k2;
2244                     %posem els  K2 tallats a VK(2)
2245                     obj.veins.indexs_k2 = inde;
2246                     obj.veins.ordenats_k2 = orde;
2247                     
2248                     %fem el reuse
2249                     reuse(obj);                  
2250                     %reestablim els indexs
2251                     obj.veins.indexs_k2 = s1;
2252                     obj.veins.ordenats_k2 = s2;
2253                 end
2254 
2255                 %comparem amb la classe real dels elements
2256                 
2257                 %ja podem tornar a posar be VK
2258                 obj.vk = vkseg;
2259                 
2260                 if length(unique(obj.Case_Base.getClass)) ~= length(unique(C_B_vella.getClass)) || sum(obj.classepredit == cla) < encertats %hem empitjorat la clasificacio en treure l'element
2261                     obj.Case_Base.addBatch(dades,clas,noms);%el tornem a afegir
2262                     if (obj.dc <4 || obj.dc >6) %segons el tipus de distancia
2263                         %distancie 1 nivell
2264                          obj.veins.indexs_k2=segur_i_k2;%posem be els veins
2265                          obj.veins.ordenats_k2=segur_o_k2;%posem be les distancies als veins
2266                     else
2267                         %distancies 2 nivells
2268                         %per K1
2269                         obj.veins.indexs_k1=segur_i_k1;%posem be els veins
2270                         obj.veins.ordenats_k1=segur_o_k1;%posem be les distancies als veins
2271                         %per K2
2272                         obj.veins.indexs_k2=segur_i_k2;%posem be els veins
2273                         obj.veins.ordenats_k2=segur_o_k2;%posem be les distancies als veins
2274                     end
2275                     
2276                     
2277                     
2278                 else %ha millorat
2279                     %com que millora recalculem i no permetrem que vaixi
2280                     %d'aqui!
2281                     encertats=sum(obj.classepredit == cla);
2282                 end
2283             end
2284         end
2285         function Calcula_IB3(obj)
2286             %Calculs IB3
2287             %  The  IB3 algorithm  (CD  =  Concept  Description).
2288             %   CD  =  []
2289             %   For  each x  in  TrainingSet do
2290             %      For  each y  in  CD  do
2291             %          Sim[y] = Similarity(x, y)
2292             %      End
2293             %
2294             %      if  Exists{y  in  CD |   acceptable(y)} then
2295             %          ymax = some  acceptable  y  in  CD with maximal Sim[y]
2296             %      else
2297             %          i = randomly-selected value in CD
2298             %          ymax = some y in CD that is the i-th most similar instance to x
2299             %      end
2300             %
2301             %      if  class(x) = class(ymax) then
2302             %          classification  <- correct
2303             %      else
2304             %          classification  Ģ-  incorrect
2305             %          CD  <-  CD  U   {x}
2306             %      end
2307             %
2308             %      For  each y  in  CD  do
2309             %         if  Sim[y]  >   Sim[ymax] then
2310             %           Update  y's  classification  record
2311             %
2312             %           if  y's  record  is  significantly  poor then
2313             %               CD Ģ- C -  {y}
2314             %           end
2315             %         end
2316             %      end
2317             %   end
2318             
2319             %els elements del CD no han d'estar ordenats per classe
2320             
2321             Old_CD = obj.Case_Base.copy();%el set de test sera una copia de la nostra base de casos (Concept description)
2322             obj.Case_Base.deleteBatch(1:obj.Case_Base.getBatchCount());%treiem tots els lots de la nostra base de casos(CD=[])
2323             dades=obj.Case_Base.getDATA.copy();%sera l'element k comprovem
2324             
2325             taula=struct('encerts',0,'errors',0,'classe',0,'index',0);
2326             
2327             for x=1 : Old_CD.getBatchCount()%For each instance x in TrainingSet
2328                 [dad cla noms]=Old_CD.getBatch(x);%recuperem el lot x
2329                 if x~=1
2330                     %For each y in CD do
2331                     %   Sim[y] = Similarity(x,y)
2332                     %End
2333                     dades.addBatch(dad,cla,noms);%l'afegim a l'objecte dades
2334                     copy=obj.vk;
2335                     retrieve(obj,dades);%Busquem els seus veins
2336                     Sim = reuse(obj);%Trovem la seva classificaciķ segons la Case_Base actual
2337                     obj.vk=copy;
2338                     dades.deleteBatch(1);%eliminem el lot
2339                     
2340                     %if Exists{y in CD | acceptable(y)} then
2341                     %    ymax = some acceptable y in CD with maximal Sim[y]
2342                     %else
2343                     %    i = randomly-selected value in CD
2344                     %    ymax = some y in CD that is the i-th most similar instance to x
2345                     %end
2346                     
2347                     acceptables=(taula.encerts/(taula.encerts+taula.errors))>0.9;
2348                     candidat = obj.veins.indexs_k2(acceptables);
2349                     
2350                     if(not(isempty(candidat)))
2351                         Sim = taula.classe(candidat(1));
2352                         
2353                     else
2354                         %si no hi ha cap acceptable
2355                     end
2356                     
2357                     %if class(x) = class(ymax) then
2358                     %   classification <- correct
2359                     %else
2360                     %   classification <- incorrect
2361                     %   CD = CD U {x}
2362                     %end
2363                     if Sim ~= cla
2364                         %L'hem classificat be no cal fer res altrament l'afegim
2365                         obj.Case_Base.addBatch(dad,cla,noms);
2366                         taula.encerts=[taula.encerts 1];
2367                         taula.errors=[taula.errors 0];
2368                         taula.classe=[taula.classe cla];
2369                         taula.index=[taula.index x];
2370                         
2371                         taula.errors(obj.veins.indexs_k2(1))=taula.errors(obj.veins.indexs_k2(1))+1;
2372                     else
2373                         taula.encerts(obj.veins.indexs_k2(1))=taula.encerts(obj.veins.indexs_k2(1))+1;
2374                     end
2375                     
2376                     %For each y in CD do
2377                     %   if Sim[y] > Sim[ymax] then
2378                     %       Update y's classification record
2379                     %
2380                     %       if y's record is significantly poor then
2381                     %           CD = CD - {y}
2382                     %       end
2383                     %   end
2384                     %end
2385                     
2386                     %classes=obj.Case_Base.getClass();
2387                     %resu=classes(obj.veins.indexs_k2);
2388                     %enemics=(resu~=repmat(resu(1,:),size(resu,1),1));%logics (els que no son de la meva classe)
2389                     %sumaenemics=sum(enemics(1:size(enemics,1),:),1)./size(enemics,1);
2390                     enemics= taula.encerts./(taula.encerts + taula.errors);
2391                     
2392                     enemicsclase=zeros(max(unique(taula.classe)),1);%Inicialitzem!
2393                     for z=unique(taula.classe)
2394                         enemicsclase(z)=mean(enemics(taula.classe==z));
2395                     end
2396                     
2397                     
2398                     indexs=enemics < (enemicsclase(taula.classe) * 0.7)';%<- % que els fa despreciables despreciables
2399                     obj.Case_Base.deleteBatch(indexs);
2400                     
2401                     in=logical(1:length(taula.encerts));%x es un vector de 1 logics de longitud = al numero de lots
2402                     in(indexs)=0;%posem a 0 els que bolen eliminar
2403                     
2404                     taula.encerts=taula.encerts(in);
2405                     taula.errors=taula.errors(in);
2406                     taula.classe=taula.classe(in);
2407                     taula.index=taula.index(in);
2408                     
2409                 else
2410                     obj.Case_Base.addBatch(dad,cla,noms);%el primer s'afegirā sempre
2411                     taula.encerts=1;
2412                     taula.errors=0;
2413                     taula.classe=cla;
2414                     taula.index=1;
2415                 end
2416             end
2417         end
2418         function Calcula_IB2(obj)
2419             %Calculs IB2
2420             %
2421             % IB2 [Aha, 1991, 1992]
2422             %The  IB2 algorithm  (CD  =  ConceptDescription).
2423             %CD = []
2424             % for  each x  in Training  Set  do
2425             %   for  each  y  in  CD  do
2426             %       Sim[y] = Similarity(x, y)
2427             %   end
2428             %   ymax =  Max(Sim[]) <-
2429             %   if class(x)  =  class(ymax)
2430             %     classification  Ģ- correct
2431             %   else
2432             %     classification  Ģ- incorrect
2433             %       CD = CD U {x}
2434             %   end
2435             %end
2436             
2437             %els elements del CD no han d'estar ordenats per classe
2438             
2439             Old_CD = obj.Case_Base.copy();%el set de test sera una copia de la nostra base de casos (Concept description)
2440             obj.Case_Base.deleteBatch(1:obj.Case_Base.getBatchCount());%treiem tots els lots de la nostra base de casos(CD=[])
2441             dades=obj.Case_Base.getDATA.copy();%sera l'element k comprovem
2442             for x=1 : Old_CD.getBatchCount()%For each instance t in T (T -> Old_CD)
2443                 [dad cla noms]=Old_CD.getBatch(x);%recuperem el lot x
2444                 if x~=1
2445                     dades.addBatch(dad,cla,noms);%l'afegim a l'objecte dades
2446                     copia=obj.vk;
2447                     retrieve(obj,dades);%Busquem els seus veins
2448                     Sim = reuse(obj);%Trovem la seva classificaciķ segons la Case_Base actual
2449                     obj.vk=copia;
2450                     dades.deleteBatch(1);%eliminem el lot
2451                     if Sim ~= cla
2452                         %L'hem classificat be no cal fer res altrament l'afegim
2453                         obj.Case_Base.addBatch(dad,cla,noms);
2454                     end
2455                 else
2456                     obj.Case_Base.addBatch(dad,cla,noms);%el primer s'afegirā sempre
2457                 end
2458             end
2459         end
2460         
2461         function ordena(obj)
2462             %ordena la base de casos per la distancia al enemic mes proper
2463             %de cada element (els que tenen enemics molt aprop son els
2464             %lementables)
2465             
2466             %index=1:obj.Case_Base.getBatchCount;
2467             if obj.Case_Base.getBatchCount > 1 && length(unique(obj.Case_Base.getClass())) > 1%no es pot ordenar 1 sol lot!!
2468                 %calculem les distancies de tots contra tots
2469                 segur=obj.vk;
2470                 obj.vk=[obj.Case_Base.getDATA().getBatchCount() obj.Case_Base.getDATA().getBatchCount()];
2471                 obj.retrieve(obj.Case_Base.getDATA());
2472                 obj.vk=segur;%tornem a deixar vk com estava
2473                 
2474                 classes=obj.Case_Base.getClass();
2475                 resu=classes(obj.veins.indexs_k2);
2476                 enemics=(resu~=repmat(resu(1,:),size(resu,1),1));%logics (els que no son de la meva classe)
2477                 enemics= repmat((1:size(enemics,1)),size(enemics,2),1)'.*enemics;
2478                 enemics(enemics==0)=inf;
2479                 enemics=sort(enemics);
2480                 enemics=enemics(1,:);
2481                 enemics=obj.veins.ordenats_k2(sub2ind(size(obj.veins.ordenats_k2),enemics,1:size(obj.veins.ordenats_k2,2)));
2482                 [~,index]=sort(enemics);
2483                 obj.Case_Base.getDATA().shuffle(fliplr(index));
2484             end
2485 
2486         end
2487         function treuresoroll(obj,i,nelem)
2488             %i es el % de soroll que bolem eliminar i nelem es numero
2489             %d'elements que fem servir per fer el retrieve
2490             
2491             copy=obj.vk;%Quan hi ha un sol element retrieve canvia vk
2492             obj.retrieve(obj.Case_Base.getDATA());
2493             obj.vk=copy;
2494             classes=obj.Case_Base.getClass();
2495             resu=classes(obj.veins.indexs_k2);
2496             enemics=(resu~=repmat(resu(1,:),size(resu,1),1));%logics (els que no son de la meva classe)
2497             sumaenemics=sum(enemics(2:nelem,:),1)./nelem;
2498             indexs=sumaenemics>=i;
2499             obj.Case_Base.deleteBatch(indexs);
2500         end
2501         
2502     end
2503     
2504 end

Generated on Wed 12-Sep-2012 13:03:54 by m2html © 2005