Запустите функции MATLAB на графическом процессоре

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

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

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

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

Проверяйте поддержанные графическим процессором функции

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

Совет

Для отфильтрованного списка функций MATLAB, которые поддерживают массивы графического процессора, см. Функциональный Список (массивы графического процессора).

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

ToolboxName Список функций с поддержкой gpuArrayСпецифичная для графического процессора документация
MATLABФункции с поддержкой gpuArray 
Statistics and Machine Learning Toolbox™Функции с поддержкой gpuArray (Statistics and Machine Learning Toolbox) 
Image Processing Toolbox™Функции с поддержкой gpuArray (Image Processing Toolbox)Графический процессор, вычислительный (Image Processing Toolbox)
Deep Learning Toolbox™

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

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

Computer Vision Toolbox™Функции с поддержкой gpuArray (Computer Vision Toolbox)Генерация кода графического процессора и ускорение (Computer Vision Toolbox)
Communications Toolbox™Функции с поддержкой gpuArray (Communications Toolbox)Генерация кода и ускоряющая поддержка (Communications Toolbox)
Signal Processing Toolbox™Функции с поддержкой gpuArray (Signal Processing Toolbox)Генерация кода и поддержка графического процессора (Signal Processing Toolbox)
Audio Toolbox™Функции с поддержкой gpuArray (Audio Toolbox)Генерация кода и поддержка графического процессора (Audio Toolbox)
Wavelet Toolbox™Функции с поддержкой gpuArray (Wavelet Toolbox)Генерация кода и поддержка графического процессора (Wavelet Toolbox)
Curve Fitting Toolbox™Функции с поддержкой gpuArray (Curve Fitting Toolbox) 

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

Глубокое обучение для графических процессоров

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

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

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

Проверяйте или выберите GPU

Если у вас есть графический процессор, то MATLAB автоматически использует его для расчетов графического процессора. Можно проверять графический процессор с помощью gpuDevice функция. Если у вас есть несколько графических процессоров, то можно использовать gpuDevice выбрать одного из них или использовать несколько графических процессоров с параллельным пулом. Для примера смотрите, Идентифицируют и Выбирают GPU и Use Multiple GPUs в Параллельном Пуле. Чтобы проверять, поддерживается ли ваш графический процессор, смотрите Поддержку графического процессора Релизом.

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

Используйте функции 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 Запуска на графическом процессоре. Например, используйте комбинацию diagexpmmodвокруг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              

В целом могут быть различия в результатах, если вы запускаете код по центральному процессору, из-за числовой точности и алгоритмических различий между графическим процессором и центральным процессором. Ответы на центральном процессоре и графическом процессоре являются оба одинаково допустимыми приближениями с плавающей точкой к истинному аналитическому результату, будучи подвергнутым различному округлению во время расчета. В этом примере результатами являются целые числа и 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)');

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

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

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

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

Можно использовать gpuArray функционируйте, чтобы передать данные графическому процессору и создать gpuArray, или можно создать массив непосредственно на графическом процессоре. gpuArray обеспечивает версии графического процессора многих функций, которые можно использовать, чтобы создать массивы данных, такие как 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');

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

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

Работа с разреженными массивами на графическом процессоре

Следующие функции поддерживают разреженный 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.

Работа с комплексными числами на графическом процессоре

Если выход функции, работающей на графическом процессоре, мог бы потенциально быть комплексным, необходимо явным образом задать его входные параметры как комплекс. Это применяется к 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

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

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

Список благодарностей

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

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

|

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

Больше о

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