Upload 27 files

Model_S_h2_m1/Model_Evaluation/Read_me.m

@@ -0,0 +1,11 @@
+%
+% Run these two files first:
+% 	Run_Evaluation_main_Model.m
+% only for once for model='GDT,'SGD'
+% These files can be run anytime afterwards  
+% 	-- Run_Evaluation_post_Model.m
+% 	-- Run_Evaluation_Confusion_Matrix.m
+% These files can be run at anytime: 
+% 	-- Run_Evaluation_Model_individual.m
+%
+

Model_S_h2_m1/Model_Evaluation/Run_Evaluation_Confusion_Matrix.m

@@ -0,0 +1,54 @@
+%clear all
+%%%%% Find positive rate by confusion matrixes
+%
+model='S_h2_m1'; % or 'ANN'
+nmb_of_lab=1000;
+nmb_of_batches=10;
+nmb_of_ft_models=6;
+nmb_of_image_set=zeros(1,10);
+pr_set=zeros(1,10);
+model_accuracy_comparison=zeros(1,nmb_of_ft_models);
+pm.nmb_of_lab=nmb_of_lab;
+edges=1:1:(nmb_of_lab+1);
+top_n_labels=10;
+
+confusion_matrixes=zeros(nmb_of_lab,nmb_of_lab,nmb_of_batches,nmb_of_ft_models);
+model_c_matrixes=zeros(nmb_of_lab,nmb_of_lab,nmb_of_ft_models);
+top_100_pr_by_batch=zeros(nmb_of_batches,nmb_of_ft_models); % 100 postive rate
+top_100_pr_by_model=zeros(1,nmb_of_ft_models); % 100 postive rate
+batch_nmbs=zeros(1,nmb_of_batches);
+for fs=1:nmb_of_ft_models
+    top_100_accnt=[];
+    c_matrix=zeros(nmb_of_lab,nmb_of_lab);
+    for imgnt1kdataset=1:nmb_of_batches
+        reportname1 = sprintf('../Evaluation_Data/Model_Accuracy/training_data_batch_%d_feature_module_performance_%s_var.mat', imgnt1kdataset,model);
+        aa=sprintf('classification_data_%d',fs);
+        bb=load(reportname1,aa);
+        c_data=bb.(aa);
+        true_lab=c_data(:,1);
+        pred_lab=c_data(:,2);
+        nmb_of_data=length(true_lab);
+        c_mtx_output=fun_confusion_matrix(true_lab,pred_lab,pm);
+        bb=c_mtx_output.conf_matrix;
+        confusion_matrixes(:,:,imgnt1kdataset,fs)=bb;
+        c_matrix=c_matrix+nmb_of_data*bb;
+        top_100_pr_by_batch(imgnt1kdataset,fs)=length(c_mtx_output.lab_100);
+        top_100_accnt=[top_100_accnt,c_mtx_output.lab_100];
+        batch_nmbs(imgnt1kdataset)=nmb_of_data;
+    end
+    model_c_matrixes(:,:,fs)=c_matrix/sum(batch_nmbs);
+    histN = histcounts(top_100_accnt,edges);
+    idx=(histN==nmb_of_batches);
+    top_100_pr_by_model(fs)=sum(1*idx);
+end
+mean(top_100_pr_by_batch,1) % average 100-rate by data batch
+top_100_pr_by_model % 100-rate for the feature-aggreated models. 
+%%
+fs=6; % 1 to 6
+[rates,labs]=fun_top_n_label_rate(model_c_matrixes(:,:,fs),top_n_labels);
+[rates,labs]'
+
+imgnt1kdataset=1; %1 to 10 by data batch
+[rates,labs]=fun_top_n_label_rate(confusion_matrixes(:,:,imgnt1kdataset,fs),259);
+[rates,labs]'
+%%

Model_S_h2_m1/Model_Evaluation/Run_Evaluation_Model_Individual.m

@@ -0,0 +1,92 @@
+% clear all
+model='S_h2_m1';
+nmb_of_hidden_layers=2;
+% model_type='GDT'; % or "SGD'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%% Choose any combination to run  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+imgnt1kdataset=2; % in [1,10]
+image_batch=1:100; % randomly choose in [1, nmb_of_images]
+
+reportname1 = sprintf('/work/mathbiology/lheath2/data/imagenet1k/mat/train_data_batch_%d.mat', imgnt1kdataset);
+% or choose validation data
+% reportname1 = sprintf('/work/mathbiology/lheath2/data/imagenet1k/mat/val_data.mat');
+% image_batch=1:100;
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%% Input Model Parameters
+nmb_of_modules=40;
+nmb_of_module_subsets=2;
+nmb_of_labs_per_module=25;
+cross_entropy=1;
+channels_names={'R','G','B','RGg1','RBg1','GBg1','RGg2','RBg2','GBg2','RB','RG','GB','eRGB','BW','X','Y','Z'};
+feature_RGB=[1 0 0
+    0      1      0
+    0      0      1
+    0.618  0.382  0
+    0.618  0      0.382
+    0      0.618  0.382
+    0.382  0.618  0
+    0.382  0      0.618
+    0      0.382  0.618
+    0.5    0.5    0
+    0.5    0      0.5
+    0      0.5    0.5
+    1/3    1/3    1/3    
+    0.299  0.587  0.114
+    0.4125 0.3576  0.1804
+    0.2126 0.7152  0.0722
+    0.0193 0.1192  0.9502]; 
+nmb_of_colors=length(channels_names);
+
+param.model=model;
+param.nmb_of_hidden_layers=nmb_of_hidden_layers;
+param.image_size=[64,64];
+param.nmb_of_colors=nmb_of_colors;
+param.downsizing=2;
+param.x_trim=1;
+param.y_trim=1;
+param.compute_decimal_place=4;
+param.dwnsz_on=1;
+
+param.patch=0;
+param.nmb_of_modules=nmb_of_modules;
+param.nmb_of_module_subsets=nmb_of_module_subsets;
+param.channels_names=channels_names;
+param.cross_entropy=cross_entropy;
+param.nmb_of_labs_per_module=nmb_of_labs_per_module;
+param.feature_RGB=feature_RGB;
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+tic
+data_load=load(reportname1,'data','labels');
+
+input_image=data_load.data(image_batch,:); % Input images to the trained model
+true_label=double(data_load.labels(image_batch)); 
+t_img=fun_transform_data_rgbfeatures(input_image,param); % Transform the input
+image=t_img.transformed_image;
+mpout=fun_ANN_Model(image,param); % Output of the model's ANN
+
+toc
+%%
+% Choose any combination for 'param.channel_sel' to build  
+%   the ala-carte, feature-aggregated model's accuracy rate
+%
+
+param.channel_sel=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17];
+% param.channel_sel=[1,2,3,4,5,6,7,8,9];
+% param.channel_sel=[1,2,3];
+
+[pred_label,likelyhood]=fun_majority_rule_prediction(mpout,param); % Output of the model
+
+nmb_of_images=length(true_label);
+idx=(abs(true_label-pred_label)==0);
+aa=sum(1*idx);
+pr=aa/nmb_of_images*100 % Possitive Rate, or accuracy of the model
+%%
+% Top-1 rate
+bb=likelyhood(idx);
+cc=length(bb);
+idx1=(bb==length(param.channel_sel));
+aa=sum(idx1*1);
+top_1=aa/cc*100

Model_S_h2_m1/Model_Evaluation/Run_Evaluation_main_Model.m

@@ -0,0 +1,242 @@
+%%%%%%%%%%% Model Evaluation %%%%%%%%%%%
+% The model is defined by its parameters W and b are saved in folder:
+%     ../Model_Parameter
+%
+% Choose model = 'any_name'.
+%
+% Step 3 can take a long time.
+%
+% The last part/section of Step 4 can be run anytime once this script
+%    is executed.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%% Step 1: Create two folders: ../Evaluation_Data/Model_Performance
+%                                   ../Evaluation_Data/Model_Accuracy
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%% Step 2: Initialize storage for performance result, only onetime.
+%
+model='S_h2_m1'; %'ANN' % for no distinction
+nmb_of_hidden_layers=2;
+
+nmb_of_data_batches=10;
+nmb_of_modules=40;
+nmb_of_module_subsets=2;
+nmb_of_feature_processes=6;
+nmb_of_feature_sel=3;
+nmb_of_features=17;
+
+for imgnt1kdataset=1:nmb_of_data_batches
+    reportname1 = sprintf('/work/mathbiology/lheath2/data/imagenet1k/mat/train_data_batch_%d.mat', imgnt1kdataset);
+    data_load=load(reportname1,'labels');
+    nmb_of_images=length(data_load.labels);
+    aa=mod(nmb_of_features,nmb_of_feature_sel);
+    for feature=1:nmb_of_feature_processes
+        if feature<nmb_of_feature_processes
+            nmb_of_sel_features=nmb_of_feature_sel;
+        else
+            if aa==0
+                nmb_of_sel_features=nmb_of_feature_sel;
+            else
+                nmb_of_sel_features=aa;
+            end
+        end
+        training_performance=zeros(2,nmb_of_modules,nmb_of_module_subsets,nmb_of_sel_features,nmb_of_images);
+        image0_perf=1;
+        reportname1 = sprintf('../Evaluation_Data/Model_Performance/training_performance_batch_%d_feature_%d_performance_%s_var.mat',...
+            imgnt1kdataset, feature, model);
+        str=struct('training_performance',training_performance,'image0_perf',image0_perf);
+        save(reportname1,"-fromstruct",str);
+    end
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%%%%%%% Step 3: Obtain the output of the model and the input, i.e., the training images
+%                 This part can be repeadely run until it is completed
+patch=0;
+nmb_of_labs_per_module=25;
+cross_entropy=1;
+
+param.model=model;
+param.nmb_of_hidden_layers=nmb_of_hidden_layers;
+
+param.image_size=[64,64];
+param.downsizing=2;
+param.x_trim=1;
+param.y_trim=1;
+param.compute_decimal_place=4;
+param.dwnsz_on=1;
+
+param.patch=patch;
+param.nmb_of_modules=nmb_of_modules;
+param.nmb_of_module_subsets=nmb_of_module_subsets;
+
+param.cross_entropy=cross_entropy;
+param.nmb_of_labs_per_module=nmb_of_labs_per_module;
+param.channel_sel=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17];
+nmb_of_features=length(param.channel_sel);
+nmb_of_batches=100;
+
+param.channels_names=[];
+param.nmb_of_colors=0;
+param.feature_RGB=[];
+
+parfor imgnt1kdataset=1:nmb_of_data_batches
+    channels_names={'R','G','B','RGg1','RBg1','GBg1','RGg2','RBg2','GBg2','RB','RG','GB','eRGB','BW','X','Y','Z'};
+    feature_RGB=[1 0 0
+        0      1      0
+        0      0      1
+        0.618  0.382  0
+        0.618  0      0.382
+        0      0.618  0.382
+        0.382  0.618  0
+        0.382  0      0.618
+        0      0.382  0.618
+        0.5    0.5    0
+        0.5    0      0.5
+        0      0.5    0.5
+        1/3    1/3    1/3
+        0.299  0.587  0.114
+        0.4125 0.3576  0.1804
+        0.2126 0.7152  0.0722
+        0.0193 0.1192  0.9502];
+    pm=param;
+    %%%%%%%%%%% Model's input, i.e., the training images
+    reportname1 = sprintf('/work/mathbiology/lheath2/data/imagenet1k/mat/train_data_batch_%d.mat', imgnt1kdataset);
+    data_load=load(reportname1,'data');
+    [nmb_of_images,~]=size(data_load.data);
+    for feature=1:nmb_of_feature_processes
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        reportname1 = sprintf('../Evaluation_Data/Model_Performance/training_performance_batch_%d_feature_%d_performance_%s_var.mat',...
+            imgnt1kdataset, feature, model);
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        saved_load=load(reportname1);
+        training_performance=saved_load.training_performance;
+        %     training_performance=zeros(2,nmb_of_modules,nmb_of_module_subsets,nmb_of_colors,nmb_of_images);
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        image0_perf=saved_load.image0_perf;
+        if feature<nmb_of_feature_processes
+            feature_seq=(1:nmb_of_feature_sel)+(feature-1)*nmb_of_feature_sel;
+        else
+            feature_seq=(1+(feature-1)*nmb_of_feature_sel):nmb_of_features;
+        end
+        pm.channels_names=channels_names(feature_seq);
+        pm.nmb_of_colors=length(pm.channels_names);
+        pm.feature_RGB=feature_RGB(feature_seq,:);
+        if image0_perf<nmb_of_images
+            for batch_nmb=1:nmb_of_batches
+                image_batch=fun_proc_batch(nmb_of_images,nmb_of_batches,batch_nmb,image0_perf);
+                if ~isempty(image_batch)
+                    inputimage=data_load.data(image_batch,:);
+                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+                    output=fun_transform_data_rgbfeatures(inputimage,pm);
+                    image=output.transformed_image;
+                    batch_training_performance=fun_ANN_Model(image,pm);
+                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+                    training_performance(:,:,:,:,image_batch)=batch_training_performance;
+                    image0_perf=image_batch(end);
+                end
+                [imgnt1kdataset, feature, batch_nmb]
+                out=fun_save_model_performance(model,imgnt1kdataset,feature,...
+                    training_performance,image0_perf);
+            end
+        end
+        fprintf('Model %s imgnt1kdataset = %d, pf = %d\n',model,imgnt1kdataset,feature);
+    end
+end
+%%%%%%%%%%%%%%%%%
+% Combine the performances of all features for the aggregated model
+%
+for imgnt1kdataset=1:nmb_of_data_batches
+    aa=[];
+    for feature=1:nmb_of_feature_processes
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        reportname1 = sprintf('../Evaluation_Data/Model_Performance/training_performance_batch_%d_feature_%d_performance_%s_var.mat',...
+            imgnt1kdataset, feature, model);
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        saved_load=load(reportname1);
+        bb=saved_load.training_performance;
+        aa=cat(4,aa,bb);
+    end
+    training_performance=aa;
+    reportname1 = sprintf('../Evaluation_Data/Model_Accuracy/training_data_batch_%d_feature_module_performance_%s_var.mat',...
+        imgnt1kdataset, model);
+    save(reportname1,'training_performance','-v7.3');
+end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%%%%%%% Step 4: Obtain the accuracy of the model
+%
+%%%%%%% Obtain the output of the model, i.e., the label prediction
+%             of the input images
+nmb_of_batches=12;
+%%%%%%%%%%%%%% Key Input %%%%%%%%%%%%%
+% five different feature-aggregates:
+feature_sel=[1 2 3 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
+    1 2 3 4 5 6 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN
+    1 2 3 4 5 6 7 8 9 NaN NaN NaN NaN NaN NaN NaN NaN
+    1 2 3 4 5 6 7 8 9 10 11 12 NaN NaN NaN NaN NaN
+    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 NaN NaN
+    1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17];
+nmb_of_ft_models=length(feature_sel(:,1));
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+for fs=1:nmb_of_ft_models
+    aa=feature_sel(fs,:);
+    idx=~isnan(aa);
+    param.channel_sel=aa(idx);
+    for imgnt1kdataset=1:nmb_of_data_batches
+        reportname1 = sprintf('/work/mathbiology/lheath2/data/imagenet1k/mat/train_data_batch_%d.mat', imgnt1kdataset);
+        data_load=load(reportname1,'labels');
+        nmb_of_images=length(data_load.labels);
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        reportname1 = sprintf('../Evaluation_Data/Model_Accuracy/training_data_batch_%d_feature_module_performance_%s_var.mat',...
+            imgnt1kdataset, model);
+        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+        saved_load=load(reportname1);
+        training_performance=saved_load.training_performance;
+        classification_data=zeros(nmb_of_images,4);
+        for batch_nmb=1:nmb_of_batches
+            image_batch=fun_proc_batch_update(nmb_of_images,nmb_of_batches,batch_nmb);
+            if ~isempty(image_batch)
+                true_label=double(data_load.labels(image_batch));
+                training_performance_temp=training_performance(:,:,:,:,image_batch);
+                [predicted_label,likelyhood]=fun_majority_rule_prediction(training_performance_temp,param);
+                top_1_majority=length(param.channel_sel);
+                classification_data(image_batch,:)=[true_label;predicted_label;likelyhood;0*likelyhood+top_1_majority]';
+            end
+        end
+        reportname1 = sprintf('../Evaluation_Data/Model_Accuracy/training_data_batch_%d_feature_module_performance_%s_var.mat', imgnt1kdataset,model);
+        aa=sprintf('classification_data_%d',fs);
+        str=struct(aa,classification_data);
+        save(reportname1,"-fromstruct",str,'-append');
+    end
+    fprintf('Model %s feature = %d\n',model, fs);
+end
+%%
+%%%%%%%%% Find the accuracy rates for featured models
+% This part can be run anytime once the main scripts above are executed. 
+%
+% % nmb_of_ft_models=5;
+% % nmb_of_image_set=zeros(1,10);
+% % pr_set=zeros(1,10);
+% % model_accuracy_comparison=zeros(1,nmb_of_ft_models);
+% % for fs=1:nmb_of_ft_models
+% %     for imgnt1kdataset=1:10
+% %         reportname1 = sprintf('../Evaluation_Data/Model_Accuracy_1/training_data_batch_%d_feature_module_performance_%s_var.mat', imgnt1kdataset,model);
+% %         aa=sprintf('classification_data_%d',fs);
+% %         bb=load(reportname1,aa);
+% %         c_data=bb.(aa);
+% %         true_lab=c_data(:,1);
+% %         pred_lab=c_data(:,2);
+% %         nmb_of_images=length(true_lab);
+% %         nmb_of_image_set(imgnt1kdataset)=nmb_of_images;
+% %         idx=(abs(true_lab-pred_lab)==0);
+% %         aa=sum(1*idx);
+% %         pr=aa/nmb_of_images*100;
+% %         pr_set(imgnt1kdataset)=pr;
+% %     end
+% %     model_accuracy_comparison(fs)=nmb_of_image_set*pr_set'/sum(nmb_of_image_set);
+% % end
+% % %%%% This shows the accuracy rates for the five featured models:
+% % model_accuracy_comparison
+%%

Model_S_h2_m1/Model_Evaluation/Run_Evaluation_post_Model.m

@@ -0,0 +1,40 @@
+%%%%%%%% Find the accuracy rates for featured models
+% This part can be run anytime once the main scripts above are executed. 
+%
+model='S_h2_m1';% or 'ANN'
+nmb_of_ft_models=6;
+nmb_of_image_set=zeros(1,10);
+pr_set=zeros(1,10);
+top_1_set=zeros(1,10);
+model_accuracy_comparison=zeros(2,nmb_of_ft_models);
+for fs=1:nmb_of_ft_models
+    for imgnt1kdataset=1:10
+        reportname1 = sprintf('../Evaluation_Data/Model_Accuracy/training_data_batch_%d_feature_module_performance_%s_var.mat',...
+            imgnt1kdataset, model);
+        aa=sprintf('classification_data_%d',fs);
+        bb=load(reportname1,aa);
+        c_data=bb.(aa);
+        true_lab=c_data(:,1);
+        pred_lab=c_data(:,2);
+        likelyhood=c_data(:,3);
+        top_1_majority=c_data(1,3);
+        nmb_of_images=length(true_lab);
+        nmb_of_image_set(imgnt1kdataset)=nmb_of_images;
+        idx=(abs(true_lab-pred_lab)==0);
+        aa=sum(1*idx);
+        pr=aa/nmb_of_images*100;
+        pr_set(imgnt1kdataset)=pr;
+        %%%%%%%% Top-1 rate %%%%%%%%%%%
+        bb=likelyhood(idx);
+        cc=length(bb);
+        idx1=(bb==top_1_majority);
+        aa=sum(idx1*1);
+        top_1=aa/cc*100;
+        top_1_set(imgnt1kdataset)=top_1;
+    end
+    model_accuracy_comparison(1,fs)=nmb_of_image_set*pr_set'/sum(nmb_of_image_set);
+    model_accuracy_comparison(2,fs)=nmb_of_image_set*top_1_set'/sum(nmb_of_image_set);
+end
+%%%% This shows the accuracy rates for the multiple featured models
+%               together with the Top-1 rate:
+model_accuracy_comparison

Model_S_h2_m1/Model_Evaluation/fun_ANN_Model.m

@@ -0,0 +1,77 @@
+function batch_training_performance=fun_ANN_Model(image,param)
+%
+% model=param.model;
+nmb_of_hidden_layers=param.nmb_of_hidden_layers;
+
+patch=param.patch;
+nmb_of_modules=param.nmb_of_modules;
+nmb_of_module_subsets=param.nmb_of_module_subsets;
+nmb_of_colors=param.nmb_of_colors;
+channels_names=param.channels_names;
+% cross_entropy=param.cross_entropy;
+nmb_of_labs_per_module=param.nmb_of_labs_per_module;
+sz=size(image);
+if length(sz)==2
+    nmb_of_data=1;
+else
+    nmb_of_data=sz(2);
+end
+
+if nmb_of_data>1
+    batch_training_performance=zeros(2,nmb_of_data,nmb_of_modules,nmb_of_module_subsets,nmb_of_colors);
+else
+    batch_training_performance=zeros(2,nmb_of_modules,nmb_of_module_subsets,nmb_of_colors);
+end
+for module=1:nmb_of_modules
+    for subset=1:nmb_of_module_subsets
+        for color=1:nmb_of_colors
+            reportname1 = sprintf('../Model_Parameter/Trained_Parameter_patch_%d_module_%d_subset_%d_ch_%s.mat',...
+                patch, module, subset, char(channels_names(color)));
+            %      str=struct('W', W, 'b', b);
+            temp_load=load(reportname1);
+            W=temp_load.W;
+            b=temp_load.b;
+            % Assign the trained parameters
+            %
+            W1=W.LayerName1;
+            W2=W.LayerName2;
+            b1=b.LayerName1;
+            b2=b.LayerName2;
+
+            if nmb_of_data>1
+                a_0=image(:,:,color); 
+            else
+                a_0=image(:,color);
+            end
+            nmb_of_labels=length(b2);
+            z1=W1*a_0+b1;
+            [a1,~]=fun_activation(z1);
+
+            z2=W2*a1+b2;
+            if nmb_of_hidden_layers==1
+                [a2,~]=fun_softmax(z2);
+                predicted_vector=a2;
+            else
+                W3=W.LayerName3;
+                b3=b.LayerName3;
+                nmb_of_labels=length(b3);
+                [a2,~]=fun_activation(z2);
+
+                z3=W3*a2+b3;
+                [a3,~]=fun_softmax(z3);
+                predicted_vector=a3;
+            end
+            prediction=fun_predicted_vector_2_label(predicted_vector,nmb_of_labels);
+            abs_label=prediction.label+(module-1)*nmb_of_labs_per_module;
+            if nmb_of_data>1
+                batch_training_performance(:,:,module,subset,color)=[abs_label;prediction.distance];
+            else
+                batch_training_performance(:,module,subset,color)=[abs_label;prediction.distance];
+            end
+        end
+    end
+end
+if nmb_of_data>1
+    batch_training_performance=permute(batch_training_performance,[1,3,4,5,2]);%
+end
+end

Model_S_h2_m1/Model_Evaluation/fun_activation.m

@@ -0,0 +1,21 @@
+function [out1,out2]=fun_activation(x)
+%
+%
+%
+[sz1,sz2]=size(x);
+A=zeros(sz1,sz2);
+B=zeros(sz1,sz1,sz2);
+for zz=1:sz2
+    [A(:,zz),B(:,:,zz)]=ReLU(x(:,zz));
+end
+
+out1=A;
+out2=B;
+%%%%%%%%
+    function [y,dy]=ReLU(s)
+        aa=(s>0).*1;
+        y=aa.*s;
+        dy=diag(aa);
+    end
+%%%%%%%%
+end

Model_S_h2_m1/Model_Evaluation/fun_confusion_matrix.m

@@ -0,0 +1,30 @@
+function output=fun_confusion_matrix(true_lab,pred_lab,pm)
+%
+nmb_of_images=length(true_lab);
+nmb_of_lab=pm.nmb_of_lab;
+% top_n=pm.top_n;
+edges=1:1:(nmb_of_lab+1);
+c_matrix=zeros(nmb_of_lab,nmb_of_lab);
+seq_lab=1:nmb_of_lab;
+% top_n_seq=1:top_n;
+p_seq=(1:nmb_of_images)';
+for lb=1:nmb_of_lab
+    idx1=(true_lab==lb);
+    aa=p_seq(idx1);
+    nmb=length(aa);
+    aa=pred_lab(aa);
+    [N,~]=histcounts(aa,edges);
+    rt=N/nmb*100;
+    c_matrix(lb,:)=rt;
+end
+aa=diag(c_matrix);
+% [~,cc]=sort(aa);
+idx100=(aa==100);
+output.lab_100=seq_lab(idx100);
+% idx=flip(cc);
+% c_matrix=c_matrix(idx, idx);
+output.conf_matrix=c_matrix;
+% top_n_lb=idx(top_n_seq);
+% top_n_rt=diag(c_matrix(top_n_seq,top_n_seq));
+% output.top_n_inf=[top_n_rt,top_n_lb];
+end

Model_S_h2_m1/Model_Evaluation/fun_majority_rule_prediction.m

@@ -0,0 +1,74 @@
+function [predicted_label,likelyhood]=fun_majority_rule_prediction(training_performance_temp,param)
+% training_performance_temp=mpout;
+% batch_training_performance([lab;dis],batch_of_data,module,subset,color)
+% batch_training_performance(:,:,5,2,3)=[[1 2 0];[3 4 -1]];
+var_on=1;%1; %0 for minmax, 1 for variance, which is the best; range-2nd best
+% channels_names={'R','G','B','BW','RGB'};
+% channel_sel=[1,2,3,4,5];
+% channel_sel=[1,2,3];
+% batch_training_performance=permute(training_performance,[1,5,2,3,4]);
+channel_sel=param.channel_sel;
+
+sz=size(training_performance_temp);
+if length(sz)==5
+    batch_training_performance=permute(training_performance_temp,[1,5,2,3,4]);
+    aa=squeeze(batch_training_performance(:,:,:,1,channel_sel)); % to ([lab;dis],batch_of_data,module,color)
+    bb=squeeze(batch_training_performance(:,:,:,2,channel_sel));
+    cc=cat(3,aa,bb); % cat in module dimension to ([lab;dis],batch_of_data,module,color)
+    trnpf=permute(cc,[3,4,2,1]); % to (module,color,batch_of_data,[lab,dis])
+    %     AB=squeeze(range(trnpf(:,:,:,1),2)); % to (module,batch_of_data) in labels
+    AB=trnpf(:,:,:,1); % to (module,color,batch_of_data) in labels
+    dtsz=sz(5);
+    mdzs=2*sz(2);
+else
+    batch_training_performance=training_performance_temp;
+    aa=squeeze(batch_training_performance(:,:,1,:)); % to ([lab;dis],module,color)
+    bb=squeeze(batch_training_performance(:,:,2,:));
+    cc=cat(2,aa,bb); % cat in module dimension to ([lab;dis],module,color)
+    trnpf=permute(cc,[2,3,1]); % to (module,color,[lab,dis])
+    %     AB=squeeze(range(trnpf(:,:,1),2)); % to (module) in labels
+    AB=trnpf(:,:,1); % to (module,color) in labels
+    dtsz=1;
+    mdzs=2*sz(2);
+end
+predicted_label=zeros(1,dtsz);
+likelyhood=zeros(1,dtsz);
+seq=1:mdzs;
+
+channel_rel_seq=1:length(channel_sel);
+if dtsz>1
+    for m=1:dtsz
+        [~,bb]=mode(squeeze(AB(:,channel_rel_seq,m)),2); %majority rule start
+        aa=max(bb);
+        idx=(bb==aa);
+        seq_0=seq(idx); % majority rule end
+        if var_on==1
+            seq_1=var(trnpf(seq_0,channel_rel_seq,m,2),0,2);
+        else
+            % seq_1=max(trnpf(seq_0,channel_sel,m,2),[],2).*var(trnpf(seq_0,channel_sel,m,2),0,2); %var(trnpf(seq_0,channel_sel,m,2),0,2).*sum(trnpf(seq_0,channel_sel,m,2).^2,2);
+            % seq_1=range(trnpf(seq_0,channel_sel,m,2),2);
+            seq_1=range(trnpf(seq_0,channel_rel_seq,m,2),2).*var(trnpf(seq_0,channel_rel_seq,m,2),0,2);
+        end
+        [~,idx]=min(seq_1);
+        ps=seq_0(idx);
+        predicted_label(m)=trnpf(ps,1,m,1);
+        likelyhood(m)=aa;
+    end
+else
+    [~,bb]=mode(squeeze(AB(:,channel_rel_seq)),2);
+    aa=max(bb);
+    idx=(bb==aa);
+    seq_0=seq(idx);
+    if var_on==1
+        seq_1=var(trnpf(seq_0,channel_rel_seq,2),0,2);
+    else
+        % seq_1=max(trnpf(seq_0,channel_sel,m,2),[],2).*var(trnpf(seq_0,channel_sel,m,2),0,2); %var(trnpf(seq_0,channel_sel,m,2),0,2).*sum(trnpf(seq_0,channel_sel,m,2).^2,2);
+        % seq_1=range(trnpf(seq_0,channel_sel,m,2),2);
+        seq_1=range(trnpf(seq_0,channel_rel_seq,2),2).*var(trnpf(seq_0,channel_rel_seq,2),0,2);
+    end
+    [~,idx]=min(seq_1);
+    ps=seq_0(idx);
+    predicted_label=trnpf(ps,1,1);
+    likelyhood=aa;
+end
+end

Model_S_h2_m1/Model_Evaluation/fun_predicted_vector_2_label.m

@@ -0,0 +1,36 @@
+function out=fun_predicted_vector_2_label(vector,nmb_of_labels)
+%
+% predicted vector of length 25 to digit label 1, ..., 25
+% vector=predicted_vector;
+[~,dtsz]=size(vector);
+digit=zeros(1,dtsz);
+distance=zeros(1,dtsz);
+nn=nmb_of_labels;
+v=vector(1:nn,:);
+I=eye(nn);
+vv=zeros(nn,1);
+for j=1:dtsz
+    for i=1:nn
+        [cc,~]=loss_function(v(:,j),I(:,i));
+        vv(i)=cc;
+    end
+    [aa,idx]=min(vv);
+    digit(j)=idx;
+    distance(j)=aa;
+end
+out.label=digit;
+out.distance=distance;
+%%%%%%%%%%
+    function [loss,dloss]=loss_function(predicted_x,true_y)
+        % cross_entropy loss
+        %
+        eps=1e-8;
+        [n, N]=size(true_y);
+        loss=sum(sum((true_y+eps).*log((true_y+eps)./(predicted_x+eps))))/N;
+        %         ind_loss=sum((true_y+eps).*log((true_y+eps)./(predicted_x+eps)),1);
+        bb=-(true_y(1:end-1,:)+eps)./(predicted_x(1:end-1,:)+eps);
+        w=bb+ones(n-1,1)*(true_y(end,:)+eps)./(predicted_x(end,:)+eps);
+        dloss=w'/N;
+    end
+%%%%%%%%%%
+end

Model_S_h2_m1/Model_Evaluation/fun_proc_batch.m

@@ -0,0 +1,18 @@
+function image_batch=fun_proc_batch(nmb_of_images,nmb_of_batches,batch_nmb,image0)
+%
+%
+image_batch=[];
+nmb_of_batch_inc=floor(nmb_of_images/nmb_of_batches);
+bstrt=1+(batch_nmb-1)*nmb_of_batch_inc;
+bend=batch_nmb*nmb_of_batch_inc;
+if batch_nmb<nmb_of_batches && image0<nmb_of_images
+    if bstrt>=image0 && image0<bend
+        image_batch=image0:bend;
+    end
+end
+if batch_nmb==nmb_of_batches && image0<nmb_of_images
+    if bstrt>=image0 
+        image_batch=image0:nmb_of_images;
+    end
+end
+end

Model_S_h2_m1/Model_Evaluation/fun_proc_batch_update.m

@@ -0,0 +1,19 @@
+function image_batch=fun_proc_batch_update(nmb_of_images,nmb_of_batches,batch_nmb)
+%
+%
+image0=1;
+image_batch=[];
+nmb_of_batch_inc=floor(nmb_of_images/nmb_of_batches);
+bstrt=1+(batch_nmb-1)*nmb_of_batch_inc;
+bend=batch_nmb*nmb_of_batch_inc;
+if batch_nmb<nmb_of_batches && image0<nmb_of_images
+    if bstrt>=image0 && image0<bend
+        image_batch=bstrt:bend;%image0:bend;
+    end
+end
+if batch_nmb==nmb_of_batches && image0<nmb_of_images
+    if bstrt>=image0 
+        image_batch=bstrt:nmb_of_images;%image0:nmb_of_images;
+    end
+end
+end

Model_S_h2_m1/Model_Evaluation/fun_save_model_performance.m

@@ -0,0 +1,7 @@
+function out=fun_save_model_performance(model,imgnt1kdataset,pf,...
+        training_performance,image0_perf)
+    reportname1 = sprintf('../Evaluation_Data/Model_Performance/training_performance_batch_%d_feature_%d_performance_%s_var.mat', imgnt1kdataset,pf,model);
+        str=struct('training_performance',training_performance,'image0_perf',image0_perf);
+    save(reportname1,"-fromstruct",str);
+    out=[];
+end

Model_S_h2_m1/Model_Evaluation/fun_softmax.m

@@ -0,0 +1,39 @@
+function [out1,out2]=fun_softmax(S)
+%
+% Column-wise normaliztion
+%
+[sz1,sz2]=size(S);
+A=zeros(sz1,sz2);
+B=zeros(sz1-1,sz1,sz2);
+for zz=1:sz2
+    [aaa,bbb]=softmax(S(:,zz));
+    A(:,zz)=aaa;
+    B(:,:,zz)=bbb;
+end
+out1=A;
+out2=B;
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    function [y,dy]=softmax(S)
+        %         bb=1e+2;
+        bb=1;
+        S=S/bb;
+        aa=exp(S);
+        sm=sum(exp(S))+1e-16;
+        y=aa./sm;
+
+        [n,~]=size(S);
+        m=n-1;
+        dy=zeros(m,n);
+        for i=1:m
+            for j=1:n
+                if j~=i
+                    dy(i,j)=-exp(S(i)).*exp(S(j));
+                else
+                    dy(i,j)=exp(S(i)).*sm-exp(S(i)).*exp(S(j));
+                end
+            end
+        end
+        dy=dy/sm^2/bb;
+    end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+end

Model_S_h2_m1/Model_Evaluation/fun_top_n_label_rate.m

@@ -0,0 +1,11 @@
+function [rates,labs]=fun_top_n_label_rate(c_mtrx,top_n)
+% 
+aa=c_mtrx;
+bb=diag(aa);
+[~,cc]=sort(bb);
+cc=flip(cc);
+dd=bb(cc);
+seq=1:top_n;
+rates=round(dd(seq),4);
+labs=round(cc(seq),0);
+end

Model_S_h2_m1/Model_Evaluation/fun_transform_data_rgbfeatures.m

@@ -0,0 +1,107 @@
+function output=fun_transform_data_rgbfeatures(img_data,param)
+%
+%img_data=data_load.data;
+output.transformed_image=[];
+output.mnsv=[];
+output.maxsv=[];
+output.ipvsz=[];
+
+image_size=param.image_size;
+img_x_dim=image_size(1);
+img_y_dim=image_size(1);
+% nmb_of_colors=3;%param.nmb_of_colors; %=5;
+% nmb_of_colors=length(param.channel_sel);
+
+compute_decimal_place=param.compute_decimal_place;
+feature_RGB=param.feature_RGB;
+[nmb_of_colors,~]=size(feature_RGB);
+
+[data_size,~]=size(img_data);
+reshaped_images=zeros(data_size,img_x_dim,img_y_dim,3);
+for m=1:data_size
+    aa=double(img_data(m,:));
+    reshaped_images(m,:,:,:)=reshape(aa,img_x_dim,img_y_dim,3);
+end
+
+if param.dwnsz_on==1
+    x_trim=param.x_trim;
+    y_trim=param.y_trim;
+    downsizing=param.downsizing;
+    x_dwnsz_dim=fix(img_x_dim/downsizing);
+    y_dwnsz_dim=fix(img_y_dim/downsizing);
+
+    ipvsz=(x_dwnsz_dim-2*x_trim)*(y_dwnsz_dim-2*y_trim);
+    xsq=1:downsizing;
+    ysq=1:downsizing;
+    output.transformed_image=zeros(ipvsz,data_size,nmb_of_colors);
+    output.mnsv=zeros(data_size,nmb_of_colors);
+    output.maxsv=zeros(data_size,nmb_of_colors);
+    output.ipvsz=ipvsz;
+
+    temp_img=zeros(ipvsz,3);
+    for m=1:data_size
+        img=squeeze(reshaped_images(m,:,:,:));
+        for color=1:3
+            img1=squeeze(img(:,:,color));
+            aa=zeros(ipvsz,1);
+            for ii=(1+x_trim):(x_dwnsz_dim-x_trim)
+                for jj=(1+y_trim):(y_dwnsz_dim-y_trim)
+                    aa((jj-y_trim)+((ii-x_trim)-1)*(y_dwnsz_dim-2*y_trim),1)=mean(img1(xsq+2*(ii-1),ysq+2*(jj-1)),'all');
+                end
+            end
+            temp_img(:,color)=aa;
+%             mnsv=mean(aa);
+%             aa=aa-mnsv;
+%             maxsv=max(abs(aa));
+%             output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+%             output.mnsv(m,color)=mnsv;
+%             output.maxsv(m,color)=maxsv;
+        end
+        for color=1:nmb_of_colors
+            c1=feature_RGB(color,1);
+            c2=feature_RGB(color,2);
+            c3=feature_RGB(color,3);
+            aa=c1*temp_img(:,1)+c2*temp_img(:,2)+c3*temp_img(:,3);
+            mnsv=mean(aa);
+            aa=aa-mnsv;
+            maxsv=max(abs(aa));
+            output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+            output.mnsv(m,color)=mnsv;
+            output.maxsv(m,color)=maxsv;
+        end
+    end
+else    
+    temp_img=zeros(img_x_dim*img_y_dim,3);
+    for m=1:data_size
+        img=squeeze(reshaped_images(m,:,:,:));
+        for color=1:3
+            aa=img(:,:,color);
+            aa=aa(:);
+            temp_img(:,color)=aa;
+%             mnsv=mean(aa);
+%             aa=aa-mnsv;
+%             maxsv=max(abs(aa));
+%             output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+%             output.mnsv(m,color)=mnsv;
+%             output.maxsv(m,color)=maxsv;
+        end
+        for color=1:nmb_of_colors
+            c1=feature_RGB(color,1);
+            c2=feature_RGB(color,2);
+            c3=feature_RGB(color,3);
+            aa=c1*temp_img(:,1)+c2*temp_img(:,2)+c3*temp_img(:,3);
+            mnsv=mean(aa);
+            aa=aa-mnsv;
+            maxsv=max(abs(aa));
+            output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+            output.mnsv(m,color)=mnsv;
+            output.maxsv(m,color)=maxsv;
+        end             
+    end    
+end
+if data_size==1
+    output.transformed_image=squeeze(output.transformed_image);
+%     output.mnsv(m,:,color)=squeeze(output.mnsv(m,:,color));
+%     output.maxsv(m,:,color)=squeeze(output.maxsv(m,:,color));
+end
+end

Model_S_h2_m1/Training_Evaluation/Run_Training_Evaluation.m

@@ -0,0 +1,11 @@
+% clear all
+%
+model='S_h2_m1';
+nmb_of_hidden_layers=2;
+
+fun_training_evaulation(model,nmb_of_hidden_layers)
+%%
+% rtmax=max(pstvrt_model,[],'all')
+% rtmin=min(pstvrt_model,[],'all')
+% rtmed=median(pstvrt_model(:),'all')
+% rtmean=mean(pstvrt_model(:),'all')

Model_S_h2_m1/Training_Evaluation/fun_activation.m

@@ -0,0 +1,21 @@
+function [out1,out2]=fun_activation(x)
+%
+%
+%
+[sz1,sz2]=size(x);
+A=zeros(sz1,sz2);
+B=zeros(sz1,sz1,sz2);
+for zz=1:sz2
+    [A(:,zz),B(:,:,zz)]=ReLU(x(:,zz));
+end
+
+out1=A;
+out2=B;
+%%%%%%%%
+    function [y,dy]=ReLU(s)
+        aa=(s>0).*1;
+        y=aa.*s;
+        dy=diag(aa);
+    end
+%%%%%%%%
+end

Model_S_h2_m1/Training_Evaluation/fun_predicted_vector_2_label.m

@@ -0,0 +1,36 @@
+function out=fun_predicted_vector_2_label(vector,nmb_of_labels)
+%
+% predicted vector of length 25 to digit label 1, ..., 25
+% vector=predicted_vector;
+[~,dtsz]=size(vector);
+digit=zeros(1,dtsz);
+distance=zeros(1,dtsz);
+nn=nmb_of_labels;
+v=vector(1:nn,:);
+I=eye(nn);
+vv=zeros(nn,1);
+for j=1:dtsz
+    for i=1:nn
+        [cc,~]=loss_function(v(:,j),I(:,i));
+        vv(i)=cc;
+    end
+    [aa,idx]=min(vv);
+    digit(j)=idx;
+    distance(j)=aa;
+end
+out.label=digit;
+out.distance=distance;
+%%%%%%%%%%
+    function [loss,dloss]=loss_function(predicted_x,true_y)
+        % cross_entropy loss
+        %
+        eps=1e-8;
+        [n, N]=size(true_y);
+        loss=sum(sum((true_y+eps).*log((true_y+eps)./(predicted_x+eps))))/N;
+        %         ind_loss=sum((true_y+eps).*log((true_y+eps)./(predicted_x+eps)),1);
+        bb=-(true_y(1:end-1,:)+eps)./(predicted_x(1:end-1,:)+eps);
+        w=bb+ones(n-1,1)*(true_y(end,:)+eps)./(predicted_x(end,:)+eps);
+        dloss=w'/N;
+    end
+%%%%%%%%%%
+end

Model_S_h2_m1/Training_Evaluation/fun_primecolor_2_features.m

@@ -0,0 +1,42 @@
+function images_bw=fun_primecolor_2_features(images,data_param,color,feature_RGB)
+%
+%
+sz=size(images);
+vone=ones(sz(1),1);
+ori_images=0*images;
+% feature_RGB=[1 0 0
+%     0      1      0
+%     0      0      1
+%     0.618  0.382  0
+%     0.618  0      0.382
+%     0      0.618  0.382
+%     0.382  0.618  0
+%     0.382  0      0.618
+%     0      0.382  0.618
+%     0.5    0.5    0
+%     0.5    0      0.5
+%     0      0.5    0.5
+%     1/3    1/3    1/3
+%     0.2126 0.7152 0.0722
+%     0.299  0.587  0.114];
+c1=feature_RGB(color,1);
+c2=feature_RGB(color,2);
+c3=feature_RGB(color,3);
+
+for cl=1:3
+    aa=squeeze(images(:,:,cl));
+    bb=squeeze(data_param.maxsv(:,1,cl));
+    cc=vone*(squeeze(data_param.mnsv(:,1,cl))');
+    ori_images(:,:,cl)=aa*diag(bb)+cc;
+end
+if color>=4
+    aa=c1*ori_images(:,:,1)+...
+        c2*ori_images(:,:,2)+c3*ori_images(:,:,3);
+    bb=mean(aa,1);
+    aa=aa-vone*bb;
+    cc=1./max(abs(aa),[],1);
+    images_bw=aa*diag(cc);
+else
+    images_bw=squeeze(images(:,:,color));
+end
+end

Model_S_h2_m1/Training_Evaluation/fun_save_result.m

@@ -0,0 +1,8 @@
+function out=fun_save_result(model,patch, module, subset,color,channels_names,training_performance)
+%
+reportname1 = sprintf('../Evaluation_Data/Model_Performance/Trained_Model_%s_patch_%d_module_%d_subset_%d_ch_%s.mat',...
+    model,patch, module, subset, char(channels_names(color)));
+% save(reportname1, 'training_performance', '-append');
+save(reportname1, 'training_performance');
+out=[];
+end

Model_S_h2_m1/Training_Evaluation/fun_softmax.m

@@ -0,0 +1,39 @@
+function [out1,out2]=fun_softmax(S)
+%
+% Column-wise normaliztion
+%
+[sz1,sz2]=size(S);
+A=zeros(sz1,sz2);
+B=zeros(sz1-1,sz1,sz2);
+for zz=1:sz2
+    [aaa,bbb]=softmax(S(:,zz));
+    A(:,zz)=aaa;
+    B(:,:,zz)=bbb;
+end
+out1=A;
+out2=B;
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    function [y,dy]=softmax(S)
+        %         bb=1e+2;
+        bb=1;
+        S=S/bb;
+        aa=exp(S);
+        sm=sum(exp(S))+1e-16;
+        y=aa./sm;
+
+        [n,~]=size(S);
+        m=n-1;
+        dy=zeros(m,n);
+        for i=1:m
+            for j=1:n
+                if j~=i
+                    dy(i,j)=-exp(S(i)).*exp(S(j));
+                else
+                    dy(i,j)=exp(S(i)).*sm-exp(S(i)).*exp(S(j));
+                end
+            end
+        end
+        dy=dy/sm^2/bb;
+    end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+end

Model_S_h2_m1/Training_Evaluation/fun_training_evaulation.m

@@ -0,0 +1,98 @@
+function out=fun_training_evaulation(model,nmb_of_hidden_layers)
+%
+%
+nmb_of_modules=40;
+nmb_of_module_subsets=2;
+
+channels_names={'R','G','B','RGg1','RBg1','GBg1','RGg2','RBg2','GBg2','RB','RG','GB','eRGB','BW','X','Y','Z'};
+% feature_RGB=[1 0 0
+%     0      1      0
+%     0      0      1
+%     0.618  0.382  0
+%     0.618  0      0.382
+%     0      0.618  0.382
+%     0.382  0.618  0
+%     0.382  0      0.618
+%     0      0.382  0.618
+%     0.5    0.5    0
+%     0.5    0      0.5
+%     0      0.5    0.5
+%     1/3    1/3    1/3
+%     0.299  0.587  0.114
+%     0.4125 0.3576  0.1804
+%     0.2126 0.7152  0.0722
+%     0.0193 0.1192  0.9502];
+
+nmb_of_colors=length(channels_names);
+patch=0;
+nmb_of_labs_per_module=25;
+
+pstvrt_model=zeros(nmb_of_colors,nmb_of_modules,nmb_of_module_subsets);
+%%
+parfor module=1:nmb_of_modules
+    %     pm=param;
+    channels_names={'R','G','B','RGg1','RBg1','GBg1','RGg2','RBg2','GBg2','RB','RG','GB','eRGB','BW','X','Y','Z'};
+    for subset=1:nmb_of_module_subsets
+        reportname1 = sprintf('../../Data_Transformation/Transformed_IN1k_Data/Transformed_Data_for_SGD/train_data_patch_%d_module_%d_subset_%d_for_%d_labels_per_module.mat', ...
+            patch,module,subset,nmb_of_labs_per_module);
+        data_load=load(reportname1);
+        % %         reportname1 = sprintf('../%s.mat',model);
+        % %         temp_load=load(reportname1);
+        % %         model_parameter=temp_load.model_parameters;
+        for color=1:nmb_of_colors
+            reportname1 = sprintf('../Model_Parameter/Trained_Parameter_patch_%d_module_%d_subset_%d_ch_%s.mat',...
+                patch, module, subset, char(channels_names(color)));
+            %      str=struct('W', W, 'b', b);
+            temp_load=load(reportname1);
+            W=temp_load.W;
+            b=temp_load.b;
+            % Assign the trained parameters
+            %
+            W1=W.LayerName1;
+            W2=W.LayerName2;
+            b1=b.LayerName1;
+            b2=b.LayerName2;
+            % %                 W1=model_parameter.W1(:,:,color,subset,module);
+            % %                 W2=model_parameter.W2(:,:,color,subset,module);
+            % %                 b1=model_parameter.b1(:,:,color,subset,module);
+            % %                 b2=model_parameter.b2(:,:,color,subset,module);
+            a_0=data_load.data(:,:,color);
+            true_label=data_load.labels;
+            dtsz=length(true_label);
+            nmb_of_labels=length(b2);
+            z1=W1*a_0+b1;
+            [a1,~]=fun_activation(z1);
+            z2=W2*a1+b2;
+
+            if nmb_of_hidden_layers==1
+                [a2,~]=fun_softmax(z2);
+                predicted_vector=a2;
+            else
+                W3=W.LayerName3;
+                b3=b.LayerName3;
+                nmb_of_labels=length(b3);
+                [a2,~]=fun_activation(z2);
+
+                z3=W3*a2+b3;
+                [a3,~]=fun_softmax(z3);
+                predicted_vector=a3;
+            end
+            prediction=fun_predicted_vector_2_label(predicted_vector,nmb_of_labels);
+            %%
+            % Compute the error and positive rates.
+            %
+            v=abs(true_label-prediction.label);
+            errt=sum(1.*(v>0))/dtsz;
+            pstvrt=(1-errt)*100;
+            pstvrt_model(color,module,subset)=pstvrt;
+            aa=(module-1)*nmb_of_labs_per_module; %data_load.label_table(2,1)-1;
+            training_performance=[true_label+aa;prediction.label+aa;prediction.distance];
+            out=fun_save_result(model,patch, module, subset,color,channels_names,training_performance);
+        end
+    end
+    module
+end
+reportname1 = sprintf('%s_1_performance.mat',model);
+save(reportname1, 'pstvrt_model');
+out=[];
+end

Model_S_h2_m1/Training_Evaluation/fun_transform_data_rgbfeatures.m

@@ -0,0 +1,91 @@
+function output=fun_transform_data_rgbfeatures(img_data,param)
+%
+%img_data=data_load.data;
+output.transformed_image=[];
+output.mnsv=[];
+output.maxsv=[];
+output.ipvsz=[];
+
+image_size=param.image_size;
+img_x_dim=image_size(1);
+img_y_dim=image_size(1);
+
+compute_decimal_place=param.compute_decimal_place;
+feature_RGB=param.feature_RGB;
+[nmb_of_colors,~]=size(feature_RGB);
+
+[data_size,~]=size(img_data);
+reshaped_images=zeros(data_size,img_x_dim,img_y_dim,3);
+for m=1:data_size
+    aa=double(img_data(m,:));
+    reshaped_images(m,:,:,:)=reshape(aa,img_x_dim,img_y_dim,3);
+end
+
+if param.dwnsz_on==1
+    x_trim=param.x_trim;
+    y_trim=param.y_trim;
+    downsizing=param.downsizing;
+    x_dwnsz_dim=fix(img_x_dim/downsizing);
+    y_dwnsz_dim=fix(img_y_dim/downsizing);
+
+    ipvsz=(x_dwnsz_dim-2*x_trim)*(y_dwnsz_dim-2*y_trim);
+    xsq=1:downsizing;
+    ysq=1:downsizing;
+    output.transformed_image=zeros(ipvsz,data_size,nmb_of_colors);
+    output.mnsv=zeros(data_size,nmb_of_colors);
+    output.maxsv=zeros(data_size,nmb_of_colors);
+    output.ipvsz=ipvsz;
+
+    temp_img=zeros(ipvsz,3);
+    for m=1:data_size
+        img=squeeze(reshaped_images(m,:,:,:));
+        for color=1:3
+            img1=squeeze(img(:,:,color));
+            aa=zeros(ipvsz,1);
+            for ii=(1+x_trim):(x_dwnsz_dim-x_trim)
+                for jj=(1+y_trim):(y_dwnsz_dim-y_trim)
+                    aa((jj-y_trim)+((ii-x_trim)-1)*(y_dwnsz_dim-2*y_trim),1)=mean(img1(xsq+2*(ii-1),ysq+2*(jj-1)),'all');
+                end
+            end
+            temp_img(:,color)=aa;
+        end
+        for color=1:nmb_of_colors
+            c1=feature_RGB(color,1);
+            c2=feature_RGB(color,2);
+            c3=feature_RGB(color,3);
+            aa=c1*temp_img(:,1)+c2*temp_img(:,2)+c3*temp_img(:,3);
+            mnsv=mean(aa);
+            aa=aa-mnsv;
+            maxsv=max(abs(aa));
+            output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+            output.mnsv(m,color)=mnsv;
+            output.maxsv(m,color)=maxsv;
+        end
+    end
+else    
+    temp_img=zeros(img_x_dim*img_y_dim,3);
+    for m=1:data_size
+        img=squeeze(reshaped_images(m,:,:,:));
+        for color=1:3
+            aa=img(:,:,color);
+            aa=aa(:);
+            temp_img(:,color)=aa;
+        end
+        for color=1:nmb_of_colors
+            c1=feature_RGB(color,1);
+            c2=feature_RGB(color,2);
+            c3=feature_RGB(color,3);
+            aa=c1*temp_img(:,1)+c2*temp_img(:,2)+c3*temp_img(:,3);
+            mnsv=mean(aa);
+            aa=aa-mnsv;
+            maxsv=max(abs(aa));
+            output.transformed_image(:,m,color)=round(aa/maxsv*10^compute_decimal_place)*10^(-compute_decimal_place);
+            output.mnsv(m,color)=mnsv;
+            output.maxsv(m,color)=maxsv;
+        end             
+    end    
+end
+if data_size==1
+    output.transformed_image=squeeze(output.transformed_image);
+end
+end

Model_S_h2_m1/Training_Evaluation/read_me.m

@@ -0,0 +1,12 @@
+%
+% 1. Manually create folder: ../Evaluation_Data/Transformed_Data_for_SGD
+% 2. Execute 
+% 		Run_Modularize_Data
+%    in the Data_Transformation folder
+%    to rearrange the training data into modules of labels, and divide 
+%    each module into subsets.
+% (These steps only need to run once.)
+% 3. Execute
+% 	    -- Run_Training_Evaluation_model
+%    by choosing the model type, SGD or GDT, from the first line
+%    of the file. 

Model_S_h2_m1/Training_Evaluation/run_script.m

@@ -0,0 +1,7 @@
+model='S_h1_m1';
+nmb_of_hidden_layers=1;
+Run_Training_Evaluation;
+
+model='S_h1_m2';
+nmb_of_hidden_layers=1;
+Run_Training_Evaluation;