guif.m

来自「神经网络的工具箱, 神经网络的工具箱,」· M 代码 · 共 2,017 行 · 第 1/4 页

au('average.next.enable', 'on');
au('intervals.next.enable', 'off');
au('intervals.eleveltext.visible', 'off');
au('intervals.eleveledit.visible', 'off');
au('intervals.compute.visible', 'off');
au('intervals.ok.enable', 'off');
graphics_snn('intervals');

%==================================================================
% AVERAGE_PREVIOUS 
%
% GUIF('av_previous')
%==================================================================

elseif strcmp(cmd, 'av_previous')

graphics_snn('remove');

%==================================================================
% AVERAGE_HELP 
%
% GUIF('av_help')
%==================================================================

elseif strcmp(cmd, 'av_help')

popup_message_snn('Sorry, no help available.');

%==================================================================
% AVERAGE_NEXT 
%
% GUIF('av_next')
%==================================================================

elseif strcmp(cmd, 'av_next')

graphics_snn('intervals');


%==================================================================
%==================================================================
% INTERVAL_AVERAGE 
%
% GUIF('int_average')
%==================================================================

elseif strcmp(cmd, 'int_average')

nets = gu('nets');
data = gu('data');
over = gu('average.over');
alfa = gu('alfa');

stdout_snn('Summarizing networks to one for error estimation...\n');
one_net = summarize_snn(nets(over), data, alfa);
stdout_snn('...done\n');

au('one_net', one_net);
au('intervals.ok.enable', 'off');
au('intervals.next.enable', 'off');
au('intervals.eleveltext.visible', 'on');
au('intervals.eleveledit.visible', 'on');
au('intervals.compute.visible', 'on');

graphics_snn('intervals');

%==================================================================
% INTERVAL_ELEVELEDIT 
%
% GUIF('int_eleveledit')
%==================================================================

elseif strcmp(cmd, 'int_eleveledit')

new = str2num(get(gcbo, 'String'));
if (new ~= gu('intervals.elevel'))
   au('intervals.elevel', new);
   au('intervals.next.enable', 'off');
   au('intervals.ok.enable', 'off');
   graphics_snn('intervals');
end

%==================================================================
% INTERVAL_COMPUTE 
%
% GUIF('int_compute')
%==================================================================

elseif strcmp(cmd, 'int_compute')

elevel = gu('intervals.elevel');
nets = gu('nets');
datasets = gu('datasets');
over = gu('average.over');
alfa = gu('alfa');
one_net = gu('one_net');

data = datasets(1).data;

stdout_snn('Start training network for error estimation.\n');
c_point_conf = c_confidence_snn(elevel, nets(over), data, alfa);
[c_point_pred, noise_net, noise_record] = ...
            c_prediction_snn(elevel, nets(over), datasets, alfa, one_net);
stdout_snn('Errors estimated, press ''OK'' to continue.\n');
au('c_point_conf', c_point_conf);
au('c_point_pred', c_point_pred);
au('noise_net', noise_net);
au('noise_record', noise_record);

au('intervals.ok.enable', 'on');
au('intervals.next.enable', 'off');
graphics_snn('intervals');

%==================================================================
% INTERVAL_OK 
%
% GUIF('int_ok')
%==================================================================

elseif strcmp(cmd, 'int_ok')

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%P = gu('prediction.P');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

au('intervals.next.enable', 'on');
au('prediction.next.enable', 'off');

analysis = gu('analysis');
inputnames = gu('arch.inputnames');
ninputs = prod(size(inputnames));
i= 1; k = 1;
while(i <= ninputs)
   groupsize = prod(size(analysis(i).group));
   if (groupsize> 1)
      text = inputnames{i};
      for l = 1:(groupsize-1)
          text = [text '/' inputnames{i+l}];
      end
      inputpop.text{k} = text;
      inputpop.number{k} = analysis(i).group;
      k = k + 1;
   else
      inputpop.text{k} = inputnames{i};
      inputpop.number{k} = i;
      k = k + 1;
   end
   i = i + groupsize;
end
inputpop.text{k} = 'none';
inputpop.value = [k k];
au('prediction.inputpop', inputpop);
outputpop.text = gu('arch.outputnames');
outputpop.value = 1;
au('prediction.outputpop', outputpop);

graphics_snn('predict');

%==================================================================
% INTERVAL_PREVIOUS 
%
% GUIF('int_previous')
%==================================================================

elseif strcmp(cmd, 'int_previous')

graphics_snn('average');

%==================================================================
% INTERVAL_HELP 
%
% GUIF('int_help')
%==================================================================

elseif strcmp(cmd, 'int_help')

popup_message_snn('Sorry, no help available.');

%==================================================================
% INTERVAL_NEXT 
%
% GUIF('int_next')
%==================================================================

elseif strcmp(cmd, 'int_next')

graphics_snn('predict'); 


%==================================================================
% PREDICT_SLIDE 
%
% GUIF('pre_slide')
%==================================================================

elseif strcmp(cmd, 'pre_slide')

ud = get(gco, 'UserData');
value = get(gco, 'Value');
set(ud.edithandle, 'String', num2str(value));

Ppredict = gu('prediction.P');
Ppredict(ud.number) = value;
au('prediction.P', Ppredict);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%P = gu('prediction.P');
%in_use = find(gu('remove.net_used'));
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(in_use), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_EDIT 
%
% GUIF('pre_edit')
%==================================================================

elseif strcmp(cmd, 'pre_edit')

ud = get(gco, 'UserData');
%min = get(ud.slidehandle, 'Min');
%max = get(ud.slidehandle, 'Max');
value = str2num(get(gco, 'String'));
%if (value > max), set(ud.slidehandle, 'Max', value), end;
%if (value < min), set(ud.slidehandle, 'Min', value), end;
%set(ud.slidehandle, 'Value', value);

Ppredict = gu('prediction.P');
Ppredict(ud.number) = value;
au('prediction.P', Ppredict);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%P = gu('prediction.P');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_CYCLESLIDE 
%
% GUIF('pre_cycleslide')
%==================================================================

elseif strcmp(cmd, 'pre_cycleslide')

ud = get(gco, 'UserData');
value = get(gco, 'Value');
set(ud.edithandle, 'String', num2str(value));

[x, y] = pol2cart(2*pi*value, 1);
Ppredict = gu('prediction.P');
Ppredict(ud.group(1)) = x;
Ppredict(ud.group(2)) = y;
au('prediction.P', Ppredict);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%P = gu('prediction.P');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_CYCLEEDIT 
%
% GUIF('pre_cycleedit')
%==================================================================

elseif strcmp(cmd, 'pre_cycleedit')

ud = get(gco, 'UserData');
value = str2num(get(gco, 'String'));

[x, y] = pol2cart(2*pi*value, 1);
Ppredict = gu('prediction.P');
Ppredict(ud.group(1)) = x;
Ppredict(ud.group(2)) = y;
au('prediction.P', Ppredict);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%P = gu('prediction.P');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_BOOLGROUPRADIO 
%
% GUIF('pre_boolgroupradio')
%==================================================================

elseif strcmp(cmd, 'pre_boolgroupradio')

analysis = gu('analysis');
P = gu('prediction.P');
ud = get(gco, 'UserData');
handles = gu('handles');

set(handles.prediction.boolradio(setdiff(ud.group, ud.number), 1), 'Value', 1);
set(handles.prediction.boolradio(ud.number, 1), 'Value', 0);
set(handles.prediction.boolradio(setdiff(ud.group, ud.number), 2), 'Value', 0);
set(handles.prediction.boolradio(ud.number, 2), 'Value', 1);

for k = setdiff(ud.group, ud.number)
    P(k) = analysis(k).min;
end
P(ud.number) = analysis(ud.number).max;
au('prediction.P', P);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_BOOLRADIO 
%
% GUIF('pre_boolradio')
%==================================================================

elseif strcmp(cmd, 'pre_boolradio')

analysis = gu('analysis');
P = gu('prediction.P');
ud = get(gco, 'UserData');
value = get(gco, 'Value');
if isfield(ud, 'highhandle')
   otherhandle = ud.highhandle;
   P(ud.number) = analysis(ud.number).min;
else 
   otherhandle = ud.lowhandle;
   P(ud.number) = analysis(ud.number).max;
end
au('prediction.P', P);

set(otherhandle, 'Value', 0);
set(gco, 'Value', 1);

%c_point_pred = gu('c_point_pred');
%noise_net = gu('noise_net');
%nets = gu('nets');
%alfa = gu('alfa');
%over = gu('average.over');
%[ylp, yup, y_av] = ...
%    prediction_snn(c_point_pred, noise_net, nets(over), alfa, P);
%au('ylp', ylp);
%au('yup', yup);
%au('y_av', y_av);

graphics_snn('predict');

%==================================================================
% PREDICT_INPUTPOP 
%
% GUIF('pre_inputpop')
%==================================================================

elseif strcmp(cmd, 'pre_inputpop')

value = gu('prediction.inputpop.value');
value(get(gcbo, 'UserData')) = get(gcbo, 'Value');
au('prediction.inputpop.value', value);
graphics_snn('predict');

%==================================================================
% PREDICT_OUTPUTPOP 
%
% GUIF('pre_outputpop')
%==================================================================

elseif strcmp(cmd, 'pre_outputpop')

au('prediction.outputpop.value', get(gcbo, 'Value'));
graphics_snn('predict');

%==================================================================
% PREDICT_OK 
%
% GUIF('pre_ok')
%==================================================================

elseif strcmp(cmd, 'pre_ok')

au('prediction.next.enable', 'on');
au('relevance.ok.enable', 'off');
graphics_snn('input_relevance');

%==================================================================
% PREDICT_PREVIOUS 
%
% GUIF('pre_previous')
%==================================================================

elseif strcmp(cmd, 'pre_previous')

graphics_snn('intervals');

%==================================================================
% PREDICT_HELP 
%
% GUIF('pre_help')
%==================================================================

elseif strcmp(cmd, 'pre_help')

popup_message_snn('Sorry, no help available.');

%==================================================================
% PREDICT_NEXT 
%
% GUIF('pre_next')
%==================================================================

elseif strcmp(cmd, 'pre_next')

graphics_snn('input_relevance');


%==================================================================
% REL_START
%
% GUIF('rel_start')
%==================================================================

elseif strcmp(cmd, 'rel_start')

net = gu('one_net');
data = gu('data');
groups = gu('prediction.inputpop.number');

F = fisher_nc_snn(net, data);
[expl_var, y, ds] = input_relevance_snn(net, data, F, groups);

au('relevance.expl_var', expl_var);
au('relevance.order', y);
au('relevance.ds', ds);

au('relevance.ok.enable', 'on');
graphics_snn('input_relevance');

%==================================================================
% REL_PREVIOUS 
%
% GUIF('rel_previous')
%==================================================================

elseif strcmp(cmd, 'rel_previous')

graphics_snn('predict');

%==================================================================
end