exponenta event banner

Выполнение функций MATLAB на графическом процессоре

Функции MATLAB с аргументами gpuArray

Сотни функций в MATLAB ® и других панелях инструментов запускаются автоматически на графическом процессоре, если вы поставляете gpuArray аргумент.

A = gpuArray([1 0 1; -1 -2 0; 0 1 -1]);
e = eig(A);

При каждом вызове любой из этих функций с хотя бы одним gpuArray в качестве аргумента ввода данных функция выполняется на GPU. В результате функция генерирует gpuArray, если только возвращаемые данные MATLAB не являются более подходящими (например, size). Можно смешивать входные данные, используя массивы gpuArray и MATLAB в одном вызове функции. Дополнительные сведения о том, когда функция работает на GPU или CPU, см. в разделе Специальные условия ввода gpuArray. Функции с поддержкой GPU включают дискретное преобразование Фурье (fft), умножение матрицы (mtimes), деление левой матрицы (mldivide) и сотни других. Дополнительные сведения см. в разделе Проверка поддерживаемых GPU функций.

Проверка поддерживаемых GPU функций

Если функция MATLAB поддерживает gpuArrays, можно ознакомиться с дополнительной информацией об использовании графического процессора на странице ее функции. См. раздел Массивы графических процессоров в разделе Расширенные возможности в конце страницы функций.

Совет

Отфильтрованный список функций MATLAB, поддерживающих массивы GPU, см. в разделе Список функций (массивы GPU).

Несколько панелей инструментов MATLAB включают функции со встроенной поддержкой графического процессора. Чтобы просмотреть списки всех функций этих панелей инструментов, поддерживающих gpuArrays, используйте ссылки в следующей таблице. Функции в списках с индикаторами предупреждения имеют ограничения или примечания по использованию, специфичные для выполнения функции на графическом процессоре. Примечания по использованию и ограничения можно проверить в разделе Расширенные возможности страницы ссылки на функцию. Для получения информации об обновлениях отдельных функций, поддерживающих графический процессор, см. примечания к выпуску.

Имя панели инструментовСписок функций с поддержкой gpuArrayДокументация по графическому процессору
MATLABФункции с поддержкой gpuArray 
Статистика и машинное обучение Toolbox™Функции с поддержкой gpuArray (инструментарий для статистики и машинного обучения) 
Toolbox™ обработки изображенийФункции с поддержкой gpuArray (панель инструментов обработки изображений)Вычисления графического процессора (панель инструментов обработки изображений)
Глубокое обучение Toolbox™

Функции с поддержкой gpuArray (Deep Learning Toolbox)

* (см. также Глубокое обучение с помощью графических процессоров)

Компьютерное зрение Toolbox™Функции с поддержкой gpuArray (Computer Vision Toolbox)Генерация и ускорение кода графического процессора (панель инструментов компьютерного зрения)
Коммуникационный Toolbox™Функции с поддержкой gpuArray (Communications Toolbox)Поддержка генерации и ускорения кода (инструментарий для обмена данными)
Toolbox™ обработки сигналовФункции с поддержкой gpuArray (панель инструментов обработки сигналов)Создание кода и поддержка графического процессора (панель инструментов обработки сигналов)
Звуковые Toolbox™Функции с поддержкой gpuArray (Audio Toolbox)Создание кода и поддержка графического процессора (панель инструментов аудио)
Вейвлет- Toolbox™Функции с поддержкой gpuArray (Wavelet Toolbox)Создание кода и поддержка графического процессора (Wavelet Toolbox)
Toolbox™ фитинга кривойФункции с поддержкой gpuArray (панель инструментов фитинга кривой) 

Функции, поддерживаемые графическим процессором, можно просмотреть из всех продуктов MathWorks ® по следующей ссылке: функции, поддерживаемые графическим процессором. Кроме того, можно выполнить фильтрацию по продукту. На панели справки щелкните Функции. В списке функций перейдите на левую панель, чтобы выбрать продукт, например MATLAB. В нижней части левой панели выберите Массивы графического процессора. При выборе продукта, не имеющего функций с поддержкой графического процессора, фильтр массивов графического процессора недоступен .

Глубокое обучение с помощью графических процессоров

Для многих функций Deep Learning Toolbox поддержка графического процессора выполняется автоматически при наличии подходящего графического процессора и Toolbox™ параллельных вычислений. Преобразование данных в gpuArray не требуется. Ниже приведен неисчерпывающий список функций, которые по умолчанию выполняются на графическом процессоре, если они доступны.

  • trainNetwork (инструментарий для глубокого обучения)

  • predict (инструментарий для глубокого обучения)

  • predictAndUpdateState (инструментарий для глубокого обучения)

  • classify (инструментарий для глубокого обучения)

  • classifyAndUpdateState (инструментарий для глубокого обучения)

  • activations (инструментарий для глубокого обучения)

Дополнительные сведения об автоматической поддержке графического процессора в Deep Learning Toolbox см. в разделе Глубокое обучение с большими данными на графических процессорах и параллельно (Deep Learning Toolbox).

Для расширенных сетей и рабочих процессов, использующих сети, определенные как dlnetwork Объекты или функции модели (Deep Learning Toolbox) преобразуют данные в gpuArray. Используйте функции с поддержкой gpuArray (Deep Learning Toolbox) для запуска пользовательских циклов обучения или прогнозирования на графическом процессоре.

Проверка или выбор графического процессора

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

Для глубокого обучения MATLAB обеспечивает автоматическую параллельную поддержку нескольких графических процессоров. См. раздел Глубокое обучение с помощью MATLAB на нескольких графических процессорах (инструментарий глубокого обучения).

Использование функций MATLAB с графическим процессором

В этом примере показано, как использовать функции MATLAB с поддержкой графического процессора для работы с gpuArrays. Проверить свойства графического процессора можно с помощью gpuDevice функция.

gpuDevice
ans = 
  CUDADevice with properties:

                      Name: 'GeForce GTX 1080'
                     Index: 1
         ComputeCapability: '6.1'
            SupportsDouble: 1
             DriverVersion: 10.1000
            ToolkitVersion: 10.1000
        MaxThreadsPerBlock: 1024
          MaxShmemPerBlock: 49152
        MaxThreadBlockSize: [1024 1024 64]
               MaxGridSize: [2.1475e+09 65535 65535]
                 SIMDWidth: 32
               TotalMemory: 8.5899e+09
           AvailableMemory: 6.9012e+09
       MultiprocessorCount: 20
              ClockRateKHz: 1733500
               ComputeMode: 'Default'
      GPUOverlapsTransfers: 1
    KernelExecutionTimeout: 1
          CanMapHostMemory: 1
           DeviceSupported: 1
            DeviceSelected: 1

Создайте вектор строки, повторяющий значения от -15 до 15. Чтобы передать его графическому процессору и создать gpuArray, используйте gpuArray функция.

X = [-15:15 0 -15:15 0 -15:15];
gpuX = gpuArray(X);
whos gpuX
  Name      Size            Bytes  Class       Attributes

  gpuX      1x95                4  gpuArray              

Для работы с gpuArrays используйте любую функцию MATLAB с поддержкой графического процессора. MATLAB автоматически выполняет вычисления на графическом процессоре. Дополнительные сведения см. в разделе Выполнение функций MATLAB на графическом процессоре. Например, используйте комбинацию diag, expm, mod, round, abs, и fliplr.

gpuE = expm(diag(gpuX,-1)) * expm(diag(gpuX,1));
gpuM = mod(round(abs(gpuE)),2);
gpuF = gpuM + fliplr(gpuM);

Постройте график результатов.

imagesc(gpuF);
colormap(flip(gray));

При необходимости обратного переноса данных из графического процессора используйте gather. Возврат к процессору может быть дорогостоящим и, как правило, не требуется, если не требуется использовать результат с функциями, не поддерживающими gpuArray.

result = gather(gpuF);
whos result
  Name         Size            Bytes  Class     Attributes

  result      96x96            73728  double              

В общем случае могут быть различия в результатах при запуске кода на CPU из-за числовой точности и алгоритмических различий между GPU и CPU. Ответы на CPU и GPU являются одинаково допустимыми аппроксимациями с плавающей запятой к истинному аналитическому результату, подвергнутому различному округлению во время вычисления. В этом примере результаты являются целыми числами и round устраняет ошибки округления.

Резкость изображения с помощью графического процессора

В этом примере показано, как резкость изображения выполняется с помощью gpuArrays и функций с поддержкой графического процессора.

Прочитайте изображение и отправьте его в графический процессор с помощью gpuArray функция.

image = gpuArray(imread('peppers.png'));

Преобразуйте изображение в двойное и применяйте свертки для получения градиентного изображения. Затем, используя градиентное изображение, очертить его на коэффициент amount.

dimage = im2double(image); 
gradient = convn(dimage,ones(3)./9,'same') - convn(dimage,ones(5)./25,'same');
amount = 5;
sharpened = dimage + amount.*gradient;

Изменение размеров, печать и сравнение исходных и заточенных изображений.

imshow(imresize([dimage, sharpened],0.7));
title('Original image (left) vs sharpened image (right)');

Вычисление набора Mandelbrot с помощью функций с поддержкой графического процессора

В этом примере показано, как использовать функции MATLAB с поддержкой GPU для вычисления известной математической конструкции - набора Мандельброта. Проверьте графический процессор с помощью gpuDevice функция.

Определите параметры. Алгоритм Мандельброта итерирует по сетке вещественных и мнимых частей. Следующий код определяет количество итераций, размер сетки и пределы сетки.

maxIterations = 500;
gridSize = 1000;
xlim = [-0.748766713922161, -0.748766707771757];
ylim = [ 0.123640844894862,  0.123640851045266]; 

Вы можете использовать gpuArray для переноса данных в графический процессор и создания gpuArrayили можно создать массив непосредственно на графическом процессоре. gpuArray предоставляет версии GPU многих функций, которые можно использовать для создания массивов данных, таких как linspace. Дополнительные сведения см. в разделе Создание массивов графических процессоров напрямую.

x = gpuArray.linspace(xlim(1),xlim(2),gridSize);
y = gpuArray.linspace(ylim(1),ylim(2),gridSize);
whos x y
  Name      Size              Bytes  Class       Attributes

  x         1x1000                4  gpuArray              
  y         1x1000                4  gpuArray              

Многие функции MATLAB поддерживают gpuArrays. При вводе аргумента gpuArray для любой функции, поддерживающей графический процессор, эта функция запускается автоматически на графическом процессоре. Дополнительные сведения см. в разделе Выполнение функций MATLAB на графическом процессоре. Создание сложной сетки для алгоритма и массива count для результатов. Чтобы создать этот массив непосредственно на графическом процессоре, используйте ones функции и укажите 'gpuArray'.

[xGrid,yGrid] = meshgrid(x,y);
z0 = complex(xGrid,yGrid);
count = ones(size(z0),'gpuArray');

Следующий код реализует алгоритм Мандельброта с помощью функций с поддержкой GPU. Поскольку код использует gpuArrays, вычисления выполняются на GPU.

z = z0;
for n = 0:maxIterations
    z = z.*z + z0;
    inside = abs(z) <= 2;
    count = count + inside;
end
count = log(count);

По завершении вычислений постройте график результатов.

imagesc(x,y,count)
colormap([jet();flipud(jet());0 0 0]);
axis off

Работа с разреженными массивами на GPU

Следующие функции поддерживают разреженные gpuArrays.

abs
acos
acosd
acosh
acot
acotd
acoth
acsc
acscd
acsch
angle
asec
asecd
asech
asin
asind
asinh
atan
atand
atanh
bicg
bicgstab
ceil
cgs
classUnderlying
conj
cos
cosd
cosh
cospi
cot
cotd
coth
csc
cscd
csch
ctranspose
deg2rad
diag
end
eps
exp
expint
expm1
find
fix
floor
full
gmres
gpuArray.speye
imag
isaUnderlying
isdiag
isempty
isequal
isequaln
isfinite
isfloat
isinteger
islogical
isnumeric
isreal
issparse
istril
istriu
isUnderlyingType
length
log
log2
log10
log1p
lsqr
minus
mtimes
mustBeUnderlyingType
ndims
nextpow2
nnz
nonzeros
norm
numel
nzmax
pcg
plus
qmr
rad2deg
real
reallog
realsqrt
round
sec
secd
sech
sign
sin
sind
sinh
sinpi
size
sparse
spfun
spones
sprandsym
sqrt
sum
tan
tand
tanh
tfqmr
times (.*)
trace
transpose
tril
triu
uminus
underlyingType
uplus 
  

Можно создать разреженный gpuArray либо путем вызова sparse со входом gpuArray или путем вызова gpuArray с разреженным входом. Например,

x = [0 1 0 0 0; 0 0 0 0 1]
     0     1     0     0     0
     0     0     0     0     1
s = sparse(x)
   (1,2)        1
   (2,5)        1
g = gpuArray(s);   % g is a sparse gpuArray
gt = transpose(g); % gt is a sparse gpuArray
f = full(gt)       % f is a full gpuArray
     0     0
     1     0
     0     0
     0     0
     0     1

Разреженные gpuArrays не поддерживают индексирование. Вместо этого используйте find для поиска ненулевых элементов массива и их индексов строк и столбцов. Затем замените требуемые значения и создайте новый разреженный gpuArray.

Работа с комплексными номерами на GPU

Если вывод функции, выполняемой на GPU, потенциально может быть сложным, необходимо явно указать его входные аргументы как сложные. Это относится к gpuArray или к функциям, вызываемым в коде, выполняемом arrayfun.

Например, при создании gpuArray, который может иметь отрицательные элементы, используйте G = gpuArray(complex(p)), то вы можете успешно выполнить sqrt(G).

Или в пределах функции, переданной arrayfun, если x является вектором вещественных чисел, а некоторые элементы имеют отрицательные значения, sqrt(x) генерирует ошибку; вместо этого следует позвонить sqrt(complex(x)).

Если результатом является gpuArray комплексных данных и все мнимые части равны нулю, эти части сохраняются, а данные остаются сложными. Это может оказать влияние при использовании sort, isrealи так далее.

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

ФункцияДиапазон ввода для реального вывода
acos(x)abs(x) <= 1
acosh(x)x >= 1
acoth(x)abs(x) >= 1
acsc(x)abs(x) >= 1
asec(x)abs(x) >= 1
asech(x)0 <= x <= 1
asin(x)abs(x) <= 1
atanh(x)abs(x) <= 1
log(x)x >= 0
log1p(x)x >= -1
log10(x)x >= 0
log2(x)x >= 0
power(x,y)x >= 0
reallog(x)x >= 0
realsqrt(x)x >= 0
sqrt(x)x >= 0

Особые условия для входов gpuArray

Функции с поддержкой GPU выполняются на GPU только тогда, когда данные находятся на GPU. Например, следующий код выполняется на GPU, поскольку данные, первый вход, находятся на GPU:

>> sum(gpuArray(magic(10)),2);
Однако этот код не выполняется на GPU, поскольку данные, первый вход, не находятся на GPU:
>> sum(magic(10),gpuArray(2));
Если входной аргумент gpuArrays содержит такие элементы, как размеры, коэффициенты масштабирования или количество итераций, то функция собирает их и вычисляет на ЦП. Функции выполняются на GPU только в том случае, если фактическими аргументами данных являются gpuArrays.

Признание

MAGMA - библиотека подпрограмм линейной алгебры, использующих преимущества ускорения GPU. Функции линейной алгебры, реализованные для gpuArrays в Parallel Computing Toolbox, используют MAGMA для достижения высокой производительности и точности.

См. также

|

Связанные примеры

Подробнее