generate function that defines data types for fixed-凯发k8网页登录

train model

load the ionosphere data set and train a binary svm classification model.

load ionosphere
mdl = fitcsvm(x,y,'kernelfunction','gaussian');

mdl is a classificationsvm model.

save model

save the svm classification model to the file mymdl.mat by using savelearnerforcoder.

savelearnerforcoder(mdl,'mymdl');

define fixed-point data types

use generatelearnerdatatypefcn to generate a function that defines the fixed-point data types of the variables required for prediction of the svm model.

generatelearnerdatatypefcn('mymdl',x)

generatelearnerdatatypefcn generates the mymdl_datatype function.

create a structure t that defines the fixed-point data types by using mymdl_datatype.

t = mymdl_datatype('fixed')

t = struct with fields:
               xdatatype: [0x0 embedded.fi]
           scoredatatype: [0x0 embedded.fi]
    innerproductdatatype: [0x0 embedded.fi]

the structure t includes the fields for the named and internal variables required to run the predict function. each field contains a fixed-point object, returned by fi (fixed-point designer). the fixed-point object specifies fixed-point data type properties, such as word length and fraction length. for example, display the fixed-point data type properties of the predictor data.

t.xdatatype

ans = 
[]
          datatypemode: fixed-point: binary point scaling
            signedness: signed
            wordlength: 16
        fractionlength: 14
        roundingmethod: floor
        overflowaction: wrap
           productmode: fullprecision
  maxproductwordlength: 128
               summode: fullprecision
      maxsumwordlength: 128

define entry-point function

define an entry-point function named myfixedpointpredict that does the following:

function [label,score] = myfixedpointpredict(x,t) %#codegen
mdl = loadlearnerforcoder('mymdl','datatype',t);
[label,score] = predict(mdl,x);
end

note: if you click the button located in the upper-right section of this example and open the example in matlab®, then matlab opens the example folder. this folder includes the entry-point function file.

generate code

the xdatatype field of the structure t specifies the fixed-point data type of the predictor data. convert x to the type specified in t.xdatatype by using the cast (fixed-point designer) function.

x_fx = cast(x,'like',t.xdatatype);

generate code for the entry-point function using codegen. specify x_fx and constant folded t as input arguments of the entry-point function.

codegen myfixedpointpredict -args {x_fx,coder.constant(t)}

code generation successful.

codegen generates the mex function myfixedpointpredict_mex with a platform-dependent extension.

verify generated code

pass predictor data to predict and myfixedpointpredict_mex to compare the outputs.

[labels,scores] = predict(mdl,x);
[labels_fx,scores_fx] = myfixedpointpredict_mex(x_fx,t);

compare the outputs from predict and myfixedpointpredict_mex.

verify_labels = isequal(labels,labels_fx)

verify_labels = logical
   1

isequal returns logical 1 (true), which means labels and labels_fx are equal.

if you are not satisfied with the comparison results and want to improve the precision of the generated code, you can tune the fixed-point data types and regenerate the code. for details, see tips in generatelearnerdatatypefcn, data type function, and fixed-point code generation for prediction of svm.

train model

load the census1994 data set, which contains the variables adultdata and adulttest. these variables contain demographic data from the us census bureau used to predict whether an individual makes over $50,000 a year. you can use adultdata to train a model and adulttest to test the trained model.

load census1994

consider a model that predicts the salary category of employees given their age, working class, education level, capital gain and loss, and number of working hours per week. extract the variables of interest and save them in tables.

tbl = adultdata(:,{'age','education_num','capital_gain','capital_loss','hours_per_week'});
tbltest = adulttest(:,{'age','education_num','capital_gain','capital_loss','hours_per_week'});

fixed-point code generation does not support tables or categorical arrays. so, define the predictor data using a numeric matrix, and define the class labels using a logical vector. a logical vector uses memory most efficiently in a binary classification problem.

x = table2array(tbl);
y = adultdata.salary == '<=50k';
xtest = table2array(tbltest);
ytest = adulttest.salary == '<=50k';

the software uses one fixed-point data type for the predictor data. therefore, normalizing predictor data makes the fixed-point data type more robust against overflows and underflows. also, normalization reduces the amount of computation required to generate the lookup table for score transformation.

normalize the predictor data x and xtest. use the mean and standard deviation of the training data x to normalize the test data xtest.

[x,c,s] = normalize(x);
xtest = normalize(xtest,'center',c,'scale',s);

train a classification tree model. specify the minimum number of leaf node observations (minleafsize) and the maximum number of decision splits (maxnumsplits) to reduce the memory footprint of the model. specify logit for the score transformation.

mdl = fitctree(x,y,'weight',adultdata.fnlwgt, ...
    'minleafsize',10,'maxnumsplits',100, ...
    'scoretransform','logit');

mdl is a classificationtree model.

compute the classification error for the training data set and the test data set.

loss(mdl,x,y) 

ans = 0.1620

loss(mdl,xtest,ytest)

ans = 0.1683

the classifier misclassifies approximately 16% of the training data and 17% of the test data.

save model

save the classification model to the file mymdl.mat by using savelearnerforcoder.

savelearnerforcoder(mdl,'mymdl');

define fixed-point data types

use generatelearnerdatatypefcn to generate a function that defines the fixed-point data types of the variables required for prediction. use all available predictor data to obtain realistic ranges for the fixed-point data types.

generatelearnerdatatypefcn('mymdl',[x;xtest])

generatelearnerdatatypefcn generates the mymdl_datatype function.

create a structure t that defines the fixed-point data types by using mymdl_datatype.

t = mymdl_datatype('fixed')

t = struct with fields:
                   xdatatype: [0x0 embedded.fi]
    transformedscoredatatype: [0x0 embedded.fi]
               scoredatatype: [0x0 embedded.fi]

generate lookup table to approximate score transformation

create a (fixed-point designer) object by specifying these inputs:

approxobj = functionapproximation.transformfunction('mymdl',[x;xtest],t)

approxobj = 
  transformfunction with properties:
    problem: [1x1 functionapproximation.classregproblem]

approxobj has the property problem, which contains a classregproblem object. display the problem property of approxobj.

approxobj.problem

ans = 
  classregproblem with properties:
    functiontoapproximate: @(x)(1./(1 exp(-x)))
           numberofinputs: 1
               inputtypes: [1x1 embedded.numerictype]
         inputlowerbounds: -3.5296
         inputupperbounds: 13.3944
               outputtype: [1x1 embedded.numerictype]
                  options: [1x1 functionapproximation.options]

the classregproblem object in the problem property contains the information extracted from the inputs you specify when you create approxobj. for details, see the (fixed-point designer) reference page.

the input predictor data that you specify when you create the functionapproximation.transformfunction object determines the bounds inputlowerbounds and inputupperbounds. if the range between the two bounds is too large, generating the lookup table can be time consuming. in this example, you normalized x and scaled xtest to reduce the range.

create a new data type structure t_new by using the (fixed-point designer) function.

t_new = approximate(approxobj)

t_new = struct with fields:
                   xdatatype: [0x0 embedded.fi]
    transformedscoredatatype: [0x0 embedded.fi]
               scoredatatype: [0x0 embedded.fi]
         lookuptablefunction: '@mymdl_lookup'

approximate returns the output t_new and generates the lookup table function mymdl_lookup. t_new contains all the fields stored in t and an additional field lookuptablefunction, which contains a function handle to mymdl_lookup.

define entry-point function

define an entry-point function named myfixedpointpredict that predicts classification labels and scores using a trained model.

function [label,score] = myfixedpointpredict(x,t) %#codegen
mdl = loadlearnerforcoder('mymdl','datatype',t);
[label,score] = predict(mdl,x);
end

generate code

convert xtest to the type specified in t_new.xdatatype by using the cast (fixed-point designer) function.

xtest_fx = cast(xtest,'like',t_new.xdatatype);

generate code for the entry-point function using codegen. instead of specifying a variable-size input for the predictor data set, specify a fixed-size input by using coder.typeof. if you know the size of the predictor data set to pass to the generated code, then generating code for the fixed-size input is preferable for simplicity.

codegen myfixedpointpredict -args {coder.typeof(xtest_fx,[1,5],[0,0]),coder.constant(t_new)}

code generation successful.

codegen generates the mex function myfixedpointpredict_mex with a platform-dependent extension.

verify generated code

pass the test data set xtest to predict and myfixedpointpredict_mex to compare the outputs.

[labels,scores] = predict(mdl,xtest);
n = size(xtest,1);
labels_fx = true(n,1);
scores_fx = zeros(n,2);
for i = 1:n
    [labels_fx(i),scores_fx(i,:)] = myfixedpointpredict_mex(xtest_fx(i,:),t_new);
end

compare the outputs from predict and myfixedpointpredict_mex.

verify_labels = isequal(labels,labels_fx)

verify_labels = logical
   0

isequal returns logical 0 (false), which means labels and labels_fx are not the same. find the mismatched labels.

idx = find(labels_fx ~= labels)

idx = 2×1
        4815
       14114

the mex function returns the same labels as the predict function except for two samples in xtest.

find the maximum of the relative differences between the score outputs.

reldiff_scores = max(abs((double(scores_fx(:,1))-scores(:,1))./scores(:,1)))

reldiff_scores = 0.0407