function data = coach(P,filter,act_func,learningstyle,learningfunc)
            trainingfunc = '';
            hardlim_flag = 0;
            if strcmp(learningstyle,'Incremental') == 1
                % set layer transfer function [purelin or any other]
                keySet = {'gradient rule','gradient rule improved with momentum','hebb rule','hebb rule with decaying weight','Widrow-Hoff learning rule'};
                valueSet = {'learngd','learngdm','learnh','learnhd','learnwh'};
                M = containers.Map(keySet,valueSet);
                trainingfunc = M(learningfunc);
             else
                 keySet = {'gradient descent','gradient descent with adaptive learning rate','gradient with moment','Levenberg-Marquardt','scaled conjugate gradient'};
                 valueSet = {'traingd','traingda','traingdm','trainlm','trainscg'};
                 M = containers.Map(keySet,valueSet);
                 trainingfunc = M(learningfunc);
            end

            AT = load('PerfectArial.mat');

            T1 = AT.Perfect;
            T=[];
            for c = 1:50
            T =[T T1];
            end

            switch filter
                case 'Perceptron'
                    perc = perceptron;
                    perc = train(perc,P,T);
                case 'Associative Memory'
                    classifier.performParam.lr = 0.5; % learning rate
                    classifier.trainParam.goal = 1e-6; % goal=objective
                    W = T*pinv(P);
                    P = W * P;
            end

             switch act_func
                case 'Hardlim'
                     act_func='hardlim';
                     hardlim_flag = 1;
                 case 'Linear'
                     act_func = 'purelin';
                otherwise
                    act_func = 'logsig' ;

             end

            T=[];
            for c = 1:50
                T =[T eye(10)];
            end

            if hardlim_flag == 1
             classifier = perceptron;
             classifier = configure(classifier,P, T);


            W1=rand(10,256);
            b1=rand(10,1);

            classifier.IW{1,1}=W1;
            classifier.b{1,1}=b1;
            classifier = train(classifier, P, T);

            else

            classifier = network;
            classifier.numInputs = 1;
            classifier.inputs{1}.size = 256;
            %set the number of layers
            classifier.numLayers = 1;
            classifier.layers{1}.size = 10;

            %connect input to layer 1
            classifier.inputConnect(1) = 1;
            %connect bias to layer 1
            classifier.biasConnect(1) = 1;
            classifier.outputConnect(1) = 1;

            %nect(1) = 1;


            %learningfunc = '';


            if strcmp(learningstyle,'Incremental') == 1
                     % set layer transfer function [purelin or any other]
                       classifier.layers{1}.transferFcn = act_func;
              classifier.trainFcn = 'trainlm';
                classifier.inputweights{1,1}.learnFcn= trainingfunc;
                classifier = train(classifier,P,T) ; % train network

            else
                   classifier.layers{1}.transferFcn = act_func;

                    %chamo a funcao train
                    classifier.trainFcn = trainingfunc;
                    classifier = trainc(classifier,P,T) ; % train network

            end
            end

            %DADOS AQUI PARA ESTUDO
             P = load('t.mat');

             test = P.test;
             result = classifier(test);
             T = [eye(10) eye(10) eye(10) eye(10) eye(10) eye(10) eye(10) eye(10) eye(10) eye(10)];
             performance = perform(classifier,T,result)
            new = [];
            [Maxs,I] = max(result);
            counter = 0;
            for i = 1:100
                if(mod(I(i),10)==i)
                   counter = counter + 1;
                end
            end
             accuracy = counter/100
             data = {filter, act_func, learningstyle, learningfunc, performance, accuracy};
end