dlquantizationOptions

Опции для квантования обученной глубокой нейронной сети

расширьте все на странице

Описание

dlquantizationOptions объект предоставляет возможности для квантования обученной глубокой нейронной сети к масштабированным 8-битным целочисленным типам данных. Используйте dlquantizationOptions объект задать метрическую функцию, чтобы использовать, который сравнивает точность сети до и после квантования.

Чтобы узнать о продуктах, требуемых квантовать глубокую нейронную сеть, смотрите Необходимые условия Рабочего процесса Квантования.

Создание

Синтаксис

quantOpts = dlquantizationOptions
quantOpts = dlquantizationOptions(Name,Value)

Описание

quantOpts = dlquantizationOptions создает dlquantizationOptions объект со значениями свойств по умолчанию.

пример

quantOpts = dlquantizationOptions(Name,Value) создает dlquantizationOptions объект с дополнительными свойствами, заданными одним или несколькими аргументами пары "имя-значение".

Свойства

развернуть все

Cell-массив указателей на функцию, задающий функции для вычисления метрик валидации квантованной сети.

Пример: options = dlquantizationOptions('MetricFcn', {@(x)hComputeModelAccuracy(x, net, groundTruth)});

Типы данных: cell

Опции среды выполнения FPGA

Это свойство влияет на FPGA, предназначающийся только.

Имя потока битов FPGA, заданного как вектор символов.

Пример: 'Bitstream', 'zcu102_int8'

Это свойство влияет на FPGA, предназначающийся только.

Имя dlhdl.Target объект, который имеет имя платы и информацию об интерфейсе платы.

Пример: 'Target', hT

Примеры

свернуть все

Этот пример использует:

Скрипт Open Live Script

В этом примере показано, как квантовать настраиваемые параметры в слоях свертки нейронной сети для графического процессора и исследовать поведение квантованной сети. В этом примере вы квантуете squeezenet нейронную сеть после переобучения сети, чтобы классифицировать новые изображения согласно Обучать Нейронной сети для глубокого обучения, чтобы Классифицировать Новый пример Изображений. В этом примере память, требуемая для сети, уменьшается приблизительно на 75% посредством квантования, в то время как точность сети не затронута.

Загрузите предварительно обученную сеть. net выходная сеть Обучать Нейронной сети для глубокого обучения, чтобы Классифицировать Новый пример Изображений.

load net
net
net = 
  DAGNetwork with properties:

         Layers: [68×1 nnet.cnn.layer.Layer]
    Connections: [75×2 table]
     InputNames: {'data'}
    OutputNames: {'new_classoutput'}

Задайте данные о калибровке и валидации, чтобы использовать для квантования.

Калибровочные данные используются, чтобы собрать динамические диапазоны весов и смещений в свертке и полносвязных слоях сети и динамические диапазоны активаций во всех слоях сети. Для лучших результатов квантования калибровочные данные должны быть представительными для входных параметров к сети.

Данные о валидации используются, чтобы протестировать сеть после квантования, чтобы изучить эффекты ограниченного диапазона и точность квантованных слоев свертки в сети.

В этом примере используйте изображения в MerchData набор данных. Задайте augmentedImageDatastore объект изменить размер данных для сети. Затем разделите данные в наборы данных калибровки и валидации.

unzip('MerchData.zip');
imds = imageDatastore('MerchData', ...
    'IncludeSubfolders',true, ...
    'LabelSource','foldernames');
[calData, valData] = splitEachLabel(imds, 0.7, 'randomized');
aug_calData = augmentedImageDatastore([227 227], calData);
aug_valData = augmentedImageDatastore([227 227], valData);

Создайте dlquantizer возразите и задайте сеть, чтобы квантовать.

quantObj = dlquantizer(net);

Задайте метрическую функцию, чтобы использовать, чтобы сравнить поведение сети до и после квантования. Этот пример использует hComputeModelAccuracy метрическая функция.

function accuracy = hComputeModelAccuracy(predictionScores, net, dataStore)
%% Computes model-level accuracy statistics
    
    % Load ground truth
    tmp = readall(dataStore);
    groundTruth = tmp.response;
    
    % Compare with predicted label with actual ground truth 
    predictionError = {};
    for idx=1:numel(groundTruth)
        [~, idy] = max(predictionScores(idx,:)); 
        yActual = net.Layers(end).Classes(idy);
        predictionError{end+1} = (yActual == groundTruth(idx)); %#ok
    end
    
    % Sum all prediction errors.
    predictionError = [predictionError{:}];
    accuracy = sum(predictionError)/numel(predictionError);
end

Задайте метрическую функцию в dlquantizationOptions объект.

quantOpts = dlquantizationOptions('MetricFcn',{@(x)hComputeModelAccuracy(x, net, aug_valData)});

Используйте calibrate функционируйте, чтобы осуществить сеть с демонстрационными входными параметрами и собрать информацию области значений. calibrate функционируйте осуществляет сеть и собирает динамические диапазоны весов и смещений в свертке и полносвязных слоях сети и динамические диапазоны активаций во всех слоях сети. Функция возвращает таблицу. Каждая строка таблицы содержит информацию об области значений для настраиваемого параметра оптимизированной сети.

calResults = calibrate(quantObj, aug_calData)
calResults=95×5 table
                   Optimized Layer Name                      Network Layer Name        Learnables / Activations    MinValue     MaxValue
    __________________________________________________    _________________________    ________________________    _________    ________

    {'conv1_relu_conv1_Weights'                      }    {'relu_conv1'           }           "Weights"             -0.91985     0.88489
    {'conv1_relu_conv1_Bias'                         }    {'relu_conv1'           }           "Bias"                -0.07925     0.26343
    {'fire2-squeeze1x1_fire2-relu_squeeze1x1_Weights'}    {'fire2-relu_squeeze1x1'}           "Weights"                -1.38      1.2477
    {'fire2-squeeze1x1_fire2-relu_squeeze1x1_Bias'   }    {'fire2-relu_squeeze1x1'}           "Bias"                -0.11641     0.24273
    {'fire2-expand1x1_fire2-relu_expand1x1_Weights'  }    {'fire2-relu_expand1x1' }           "Weights"              -0.7406     0.90982
    {'fire2-expand1x1_fire2-relu_expand1x1_Bias'     }    {'fire2-relu_expand1x1' }           "Bias"               -0.060056     0.14602
    {'fire2-expand3x3_fire2-relu_expand3x3_Weights'  }    {'fire2-relu_expand3x3' }           "Weights"             -0.74397     0.66905
    {'fire2-expand3x3_fire2-relu_expand3x3_Bias'     }    {'fire2-relu_expand3x3' }           "Bias"               -0.051778    0.074239
    {'fire3-squeeze1x1_fire3-relu_squeeze1x1_Weights'}    {'fire3-relu_squeeze1x1'}           "Weights"             -0.77198     0.68818
    {'fire3-squeeze1x1_fire3-relu_squeeze1x1_Bias'   }    {'fire3-relu_squeeze1x1'}           "Bias"                -0.10144     0.32676
    {'fire3-expand1x1_fire3-relu_expand1x1_Weights'  }    {'fire3-relu_expand1x1' }           "Weights"              -0.7213     0.97523
    {'fire3-expand1x1_fire3-relu_expand1x1_Bias'     }    {'fire3-relu_expand1x1' }           "Bias"               -0.067021     0.30422
    {'fire3-expand3x3_fire3-relu_expand3x3_Weights'  }    {'fire3-relu_expand3x3' }           "Weights"             -0.61274     0.77511
    {'fire3-expand3x3_fire3-relu_expand3x3_Bias'     }    {'fire3-relu_expand3x3' }           "Bias"               -0.053607      0.1033
    {'fire4-squeeze1x1_fire4-relu_squeeze1x1_Weights'}    {'fire4-relu_squeeze1x1'}           "Weights"             -0.74225      1.0891
    {'fire4-squeeze1x1_fire4-relu_squeeze1x1_Bias'   }    {'fire4-relu_squeeze1x1'}           "Bias"                -0.10885     0.13878
      ⋮

Используйте validate функция, чтобы квантовать настраиваемые параметры в слоях свертки сети и осуществить сеть. Функция использует метрическую функцию, заданную в dlquantizationOptions объект сравнить результаты сети до и после квантования. 

valResults = validate(quantObj, aug_valData, quantOpts)
valResults = struct with fields:
       NumSamples: 20
    MetricResults: [1×1 struct]
       Statistics: [2×2 table]

Исследуйте валидацию выход, чтобы видеть эффективность квантованной сети.

valResults.MetricResults.Result
ans=2×2 table
    NetworkImplementation    MetricOutput
    _____________________    ____________

     {'Floating-Point'}           1      
     {'Quantized'     }           1      


valResults.Statistics
ans=2×2 table
    NetworkImplementation    LearnableParameterMemory(bytes)
    _____________________    _______________________________

     {'Floating-Point'}                2.9003e+06           
     {'Quantized'     }                7.3393e+05

В этом примере память, требуемая для сети, уменьшалась приблизительно на 75% посредством квантования. Точность сети не затронута.

Веса, смещения и активации слоев свертки сети, заданной в объекте dlquantizer теперь, используют масштабируемые 8-битные целочисленные типы данных.

В этом примере показано, как квантовать настраиваемые параметры в слоях свертки нейронной сети и исследовать поведение квантованной сети. В этом примере вы квантуете LogoNet нейронная сеть. Квантование помогает уменьшать требования к памяти глубокой нейронной сети путем квантования весов, смещений и активаций слоев сети к 8-битным масштабированным целочисленным типам данных. Использование MATLAB®, чтобы получить предсказание следует из целевого устройства.

Чтобы запустить этот пример, вам нужны продукты, перечисленные под FPGA в необходимых условиях рабочего процесса квантования.

Для дополнительных требований смотрите Необходимые условия Рабочего процесса Квантования.

Создайте файл в своей текущей рабочей директории под названием getLogoNetwork.m. Введите эти линии в файл:

function net = getLogoNetwork()
    data = getLogoData();
    net  = data.convnet;
end

function data = getLogoData()
    if ~isfile('LogoNet.mat')
        url = 'https://www.mathworks.com/supportfiles/gpucoder/cnn_models/logo_detection/LogoNet.mat';
        websave('LogoNet.mat',url);
    end
    data = load('LogoNet.mat');
end

Загрузите предварительно обученную сеть.

snet = getLogoNetwork();
snet = 

  SeriesNetwork with properties:

         Layers: [22×1 nnet.cnn.layer.Layer]
     InputNames: {'imageinput'}
    OutputNames: {'classoutput'}

Задайте данные о калибровке и валидации, чтобы использовать для квантования.

Калибровочные данные используются, чтобы собрать динамические диапазоны весов и смещений в свертке и полносвязных слоях сети и динамические диапазоны активаций во всех слоях сети. Для лучших результатов квантования калибровочные данные должны быть представительными для входных параметров к сети.

Данные о валидации используются, чтобы протестировать сеть после квантования, чтобы изучить эффекты ограниченного диапазона и точность квантованных слоев свертки в сети.

Этот пример использует изображения в logos_dataset набор данных. Задайте augmentedImageDatastore объект изменить размер данных для сети. Затем разделите данные в наборы данных калибровки и валидации.

curDir = pwd;
newDir = fullfile(matlabroot,'examples','deeplearning_shared','data','logos_dataset.zip');
copyfile(newDir,curDir);
unzip('logos_dataset.zip');
imageData = imageDatastore(fullfile(curDir,'logos_dataset'),...
 'IncludeSubfolders',true,'FileExtensions','.JPG','LabelSource','foldernames');
[calibrationData, validationData] = splitEachLabel(imageData, 0.5,'randomized');

Создайте dlquantizer возразите и задайте сеть, чтобы квантовать.

dlQuantObj = dlquantizer(snet,'ExecutionEnvironment','FPGA');

Используйте calibrate функционируйте, чтобы осуществить сеть с демонстрационными входными параметрами и собрать информацию области значений. calibrate функционируйте осуществляет сеть и собирает динамические диапазоны весов и смещений в свертке и полносвязных слоях сети и динамические диапазоны активаций во всех слоях сети. Функция возвращает таблицу. Каждая строка таблицы содержит информацию об области значений для настраиваемого параметра оптимизированной сети.

 dlQuantObj.calibrate(calibrationData)
ans = 
        Optimized Layer Name        Network Layer Name    Learnables / Activations     MinValue       MaxValue 
    ____________________________    __________________    ________________________    ___________    __________

    {'conv_1_Weights'          }      {'conv_1'    }           "Weights"                -0.048978      0.039352
    {'conv_1_Bias'             }      {'conv_1'    }           "Bias"                     0.99996        1.0028
    {'conv_2_Weights'          }      {'conv_2'    }           "Weights"                -0.055518      0.061901
    {'conv_2_Bias'             }      {'conv_2'    }           "Bias"                 -0.00061171       0.00227
    {'conv_3_Weights'          }      {'conv_3'    }           "Weights"                -0.045942      0.046927
    {'conv_3_Bias'             }      {'conv_3'    }           "Bias"                  -0.0013998     0.0015218
    {'conv_4_Weights'          }      {'conv_4'    }           "Weights"                -0.045967         0.051
    {'conv_4_Bias'             }      {'conv_4'    }           "Bias"                    -0.00164     0.0037892
    {'fc_1_Weights'            }      {'fc_1'      }           "Weights"                -0.051394      0.054344
    {'fc_1_Bias'               }      {'fc_1'      }           "Bias"                 -0.00052319    0.00084454
    {'fc_2_Weights'            }      {'fc_2'      }           "Weights"                 -0.05016      0.051557
    {'fc_2_Bias'               }      {'fc_2'      }           "Bias"                  -0.0017564     0.0018502
    {'fc_3_Weights'            }      {'fc_3'      }           "Weights"                -0.050706       0.04678
    {'fc_3_Bias'               }      {'fc_3'      }           "Bias"                    -0.02951      0.024855
    {'imageinput'              }      {'imageinput'}           "Activations"                    0           255
    {'imageinput_normalization'}      {'imageinput'}           "Activations"              -139.34        198.72

Создайте целевой объект с пользовательским именем для вашего целевого устройства и интерфейса, чтобы соединить ваше целевое устройство к хосту - компьютеру. Интерфейсные опции являются JTAG и Ethernet. Создать целевой объект, введите: 

hTarget = dlhdl.Target('Intel', 'Interface', 'JTAG');

Задайте метрическую функцию, чтобы использовать, чтобы сравнить поведение сети до и после квантования. Сохраните эту функцию в локальном файле.

function accuracy = hComputeModelAccuracy(predictionScores, net, dataStore)
%% hComputeModelAccuracy test helper function computes model level accuracy statistics

% Copyright 2020 The MathWorks, Inc.
    
    % Load ground truth 
    groundTruth = dataStore.Labels;
    
    % Compare predicted label with ground truth 
    predictionError = {};
    for idx=1:numel(groundTruth)
        [~, idy] = max(predictionScores(idx, :)); 
        yActual = net.Layers(end).Classes(idy);
        predictionError{end+1} = (yActual == groundTruth(idx)); %#ok
    end
    
    % Sum all prediction errors.
    predictionError = [predictionError{:}];
    accuracy = sum(predictionError)/numel(predictionError);
end

Задайте метрическую функцию в dlquantizationOptions объект.

options = dlquantizationOptions('MetricFcn', ...
    {@(x)hComputeModelAccuracy(x, snet, validationData)},'Bitstream','arria10soc_int8',...
'Target',hTarget);

Чтобы скомпилировать и развернуть квантованную сеть, запустите validate функция dlquantizer объект. Используйте validate функция, чтобы квантовать настраиваемые параметры в слоях свертки сети и осуществить сеть. Эта функция использует выход функции компиляции, чтобы программировать плату FPGA при помощи файла программирования. Это также загружает сетевые веса и смещения. Развернуть функция проверяет на инструмент Куарта Intel и поддерживаемую версию инструмента. Это затем начинает программировать устройство FPGA при помощи sof файла, сообщений о ходе выполнения отображений, и время, которое требуется, чтобы развернуть сеть. Функция использует метрическую функцию, заданную в dlquantizationOptions объект сравнить результаты сети до и после квантования.

prediction = dlQuantObj.validate(validationData,options);
           offset_name          offset_address     allocated_space 
    _______________________    ______________    _________________

    "InputDataOffset"           "0x00000000"     "48.0 MB"        
    "OutputResultOffset"        "0x03000000"     "4.0 MB"         
    "SystemBufferOffset"        "0x03400000"     "60.0 MB"        
    "InstructionDataOffset"     "0x07000000"     "8.0 MB"         
    "ConvWeightDataOffset"      "0x07800000"     "8.0 MB"         
    "FCWeightDataOffset"        "0x08000000"     "12.0 MB"        
    "EndOffset"                 "0x08c00000"     "Total: 140.0 MB"

### Programming FPGA Bitstream using JTAG...
### Programming the FPGA bitstream has been completed successfully.
### Loading weights to Conv Processor.
### Conv Weights loaded. Current time is 16-Jul-2020 12:45:10
### Loading weights to FC Processor.
### FC Weights loaded. Current time is 16-Jul-2020 12:45:26
### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13570959                  0.09047                      30          380609145             11.8
    conv_module           12667786                  0.08445 
        conv_1             3938907                  0.02626 
        maxpool_1          1544560                  0.01030 
        conv_2             2910954                  0.01941 
        maxpool_2           577524                  0.00385 
        conv_3             2552707                  0.01702 
        maxpool_3           676542                  0.00451 
        conv_4              455434                  0.00304 
        maxpool_4            11251                  0.00008 
    fc_module               903173                  0.00602 
        fc_1                536164                  0.00357 
        fc_2                342643                  0.00228 
        fc_3                 24364                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13570364                  0.09047                      30          380612682             11.8
    conv_module           12667103                  0.08445 
        conv_1             3939296                  0.02626 
        maxpool_1          1544371                  0.01030 
        conv_2             2910747                  0.01940 
        maxpool_2           577654                  0.00385 
        conv_3             2551829                  0.01701 
        maxpool_3           676548                  0.00451 
        conv_4              455396                  0.00304 
        maxpool_4            11355                  0.00008 
    fc_module               903261                  0.00602 
        fc_1                536206                  0.00357 
        fc_2                342688                  0.00228 
        fc_3                 24365                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13571561                  0.09048                      30          380608338             11.8
    conv_module           12668340                  0.08446 
        conv_1             3939070                  0.02626 
        maxpool_1          1545327                  0.01030 
        conv_2             2911061                  0.01941 
        maxpool_2           577557                  0.00385 
        conv_3             2552082                  0.01701 
        maxpool_3           676506                  0.00451 
        conv_4              455582                  0.00304 
        maxpool_4            11248                  0.00007 
    fc_module               903221                  0.00602 
        fc_1                536167                  0.00357 
        fc_2                342643                  0.00228 
        fc_3                 24409                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13569862                  0.09047                      30          380613327             11.8
    conv_module           12666756                  0.08445 
        conv_1             3939212                  0.02626 
        maxpool_1          1543267                  0.01029 
        conv_2             2911184                  0.01941 
        maxpool_2           577275                  0.00385 
        conv_3             2552868                  0.01702 
        maxpool_3           676438                  0.00451 
        conv_4              455353                  0.00304 
        maxpool_4            11252                  0.00008 
    fc_module               903106                  0.00602 
        fc_1                536050                  0.00357 
        fc_2                342645                  0.00228 
        fc_3                 24409                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13570823                  0.09047                      30          380619836             11.8
    conv_module           12667607                  0.08445 
        conv_1             3939074                  0.02626 
        maxpool_1          1544519                  0.01030 
        conv_2             2910636                  0.01940 
        maxpool_2           577769                  0.00385 
        conv_3             2551800                  0.01701 
        maxpool_3           676795                  0.00451 
        conv_4              455859                  0.00304 
        maxpool_4            11248                  0.00007 
    fc_module               903216                  0.00602 
        fc_1                536165                  0.00357 
        fc_2                342643                  0.00228 
        fc_3                 24406                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


          offset_name          offset_address     allocated_space 
    _______________________    ______________    _________________

    "InputDataOffset"           "0x00000000"     "48.0 MB"        
    "OutputResultOffset"        "0x03000000"     "4.0 MB"         
    "SystemBufferOffset"        "0x03400000"     "60.0 MB"        
    "InstructionDataOffset"     "0x07000000"     "8.0 MB"         
    "ConvWeightDataOffset"      "0x07800000"     "8.0 MB"         
    "FCWeightDataOffset"        "0x08000000"     "12.0 MB"        
    "EndOffset"                 "0x08c00000"     "Total: 140.0 MB"

### FPGA bitstream programming has been skipped as the same bitstream is already loaded on the target FPGA.
### Deep learning network programming has been skipped as the same network is already loaded on the target FPGA.
### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13572329                  0.09048                      10          127265075             11.8
    conv_module           12669135                  0.08446 
        conv_1             3939559                  0.02626 
        maxpool_1          1545378                  0.01030 
        conv_2             2911243                  0.01941 
        maxpool_2           577422                  0.00385 
        conv_3             2552064                  0.01701 
        maxpool_3           676678                  0.00451 
        conv_4              455657                  0.00304 
        maxpool_4            11227                  0.00007 
    fc_module               903194                  0.00602 
        fc_1                536140                  0.00357 
        fc_2                342688                  0.00228 
        fc_3                 24364                  0.00016 
 * The clock frequency of the DL processor is: 150MHz


### Finished writing input activations.
### Running single input activations.


              Deep Learning Processor Profiler Performance Results

                   LastLayerLatency(cycles)   LastLayerLatency(seconds)       FramesNum      Total Latency     Frames/s
                         -------------             -------------              ---------        ---------       ---------
Network                   13572527                  0.09048                      10          127266427             11.8
    conv_module           12669266                  0.08446 
        conv_1             3939776                  0.02627 
        maxpool_1          1545632                  0.01030 
        conv_2             2911169                  0.01941 
        maxpool_2           577592                  0.00385 
        conv_3             2551613                  0.01701 
        maxpool_3           676811                  0.00451 
        conv_4              455418                  0.00304 
        maxpool_4            11348                  0.00008 
    fc_module               903261                  0.00602 
        fc_1                536205                  0.00357 
        fc_2                342689                  0.00228 
        fc_3                 24365                  0.00016 
 * The clock frequency of the DL processor is: 150MHz

Исследуйте MetricResults.Result поле валидации выход, чтобы видеть эффективность квантованной сети.

validateOut = prediction.MetricResults.Result
ans = 
    NetworkImplementation    MetricOutput
    _____________________    ____________

     {'Floating-Point'}         0.9875   
     {'Quantized'     }         0.9875

Исследуйте QuantizedNetworkFPS поле валидации выход, чтобы видеть эффективность кадров в секунду квантованной сети.

prediction.QuantizedNetworkFPS
ans = 11.8126

Веса, смещения и активации слоев свертки сети заданы в dlquantizer возразите теперь используют масштабируемые 8-битные целочисленные типы данных.

Смотрите также

Приложения

Функции

Темы

Введенный в R2020a

Документация Deep Learning HDL Toolbox

Поддержка

Для просмотра документации необходимо авторизоваться на сайте