Вычисления на GPU — бесплатный тест онлайн

Вопрос 1 из 30

Нужно реализовать действие: перенести числовой массив X на GPU, выполнить поэлементную операцию и вернуть компактный результат на CPU. Какой вариант выполняет его без подмены операции?

Xg = gpuArray(X); y=sum(sin(gather(Xg)).^2,"all");

Xg = gpuArray(X);
y = sum(sin(Xg).^2,"all");
y = gather(y);

y = gpuArray(sum(sin(X).^2,"all")); Xg = gather(X); y=sum(sin(Xg).^2,"all"); Xg = gpu(X); y=collect(sum(sin(Xg).^2));

Вопрос 2 из 30

В расчёте по теме «Массивы на графическом процессоре» обнаружено содержательное расхождение. Какую замену следует принять после проверки?

Xg = gpu(X); y=collect(sum(sin(Xg).^2));

Заменить исходный блок этой реализацией. Перед принятием проверить предпосылки операции, форму результата и один численный инвариант. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки.Xg = gpuArray(X); y=sum(sin(gather(Xg)).^2,"all"); Использовать показанный вариант вместо дефектного фрагмента. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. Допуск и критерий принятия зафиксировать до просмотра результата.Xg = gather(X); y=sum(sin(Xg).^2,"all"); Переписать вычислительный шаг следующим образом. Добавить регрессионный пример, на котором исходная версия расходится с требованием по значению или размерности. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит.

Xg = gpuArray(X);
y = sum(sin(Xg).^2,"all");
y = gather(y);

Внести показанную замену без изменения входного контракта. Сравнить результат с формулой на двух входах, где меняются ориентация данных и масштаб величин. В журнале проверки сохранить вход, ожидаемый результат и фактическое расхождение.Xg = gpu(X); y=collect(sum(sin(Xg).^2)); Принять эту редакцию как полную замену текущего блока. После замены проверить обычный и граничный входы, заранее вычислив ожидаемый результат. Контрольный пример должен воспроизводиться на чистом запуске проекта. Для темы «Массивы на графическом процессоре» также сверить класс данных и сохранение ожидаемой структуры выхода.y = gpuArray(sum(sin(X).^2,"all"));

Вопрос 3 из 30

Код по теме «Массивы на графическом процессоре» проходит обычный пример. Какая проверка покажет, что вычислительный договор сохраняется и на неудобном входе?

y=\sum_{ij}\sin^2(X_{ij})

Xg = gpuArray(X);
y = sum(sin(Xg).^2,"all");
y = gather(y);

Повторить вычисление в отдельной функции, сохранив ту же формулу, и сравнить два полученных ответа по теме «Массивы на графическом процессоре». Сравнить ответ с сохранённым выводом предыдущей версии на рабочем наборе данных по теме «Массивы на графическом процессоре». Сравнить два близких входа и убедиться, что результат меняется плавно и без предупреждений в задаче по теме «Массивы на графическом процессоре». На одном типичном наборе сверить размер, класс и отсутствие `NaN` или `Inf` в результате по теме «Массивы на графическом процессоре». Отметьте для каждой строки конвейера, где находятся данные; удалите лишние переходы CPU↔GPU и повторно измерьте.

Вопрос 4 из 30

Для действия «перенести числовой массив X на GPU, выполнить поэлементную операцию и вернуть компактный результат на CPU» нужен независимый математический эталон. Какая запись подходит?

y=\sum_{ji}\sin^2(X_{ij})

y=\sum_{ij}\cos^2(X_{ij})

y=\sum_{ij}\sin^4(X_{ij})

y=\sum_{ij}\sin^2(X_{ij})

y=\sum_{ij}\sin^2(Y_{ij})

Вопрос 5 из 30

Код копирует массив на GPU, сразу делает `gather`, а затем выполняет всю работу на CPU. Какое действие даст проверяемый результат?

Снизить расход памяти текущего варианта и сравнить его с прежним результатом на сохранённых данных по теме «Массивы на графическом процессоре». Увеличить число случайных запусков и оценивать устойчивость среднего результата в задаче по теме «Массивы на графическом процессоре». Свести передачи к границам конвейера, держать промежуточные данные на устройстве и собирать только необходимый итог. Проверить форму, класс и конечность результата; при совпадении этих признаков продолжить расчёт по теме «Массивы на графическом процессоре». Сохранить результат текущей версии как регрессионный эталон и расширить набор входов того же типа для темы «Массивы на графическом процессоре».

Вопрос 6 из 30

В расчёте требуется проверить поддержку пользовательской функции на gpuArray до большого запуска. Какой вариант выполняет его без подмены операции?

gpuDevice; customTransform(X); Yg = arrayfun(@customTransform,gpuArray(X));

Xg = gpuArray(single(rand(32)));
try
    Yg = customTransform(Xg);
    wait(gpuDevice);
catch ME
    error("GPU path unsupported: %s",ME.message);
end

Yg = customTransform(gpuArray(X)); assert(isa(customTransform(X),"gpuArray"));

Вопрос 7 из 30

Ниже приведена неудачная реализация из темы «Поддерживаемые операции». Какая редакция возвращает требуемый результат и оставляет независимый контроль?

gpuDevice; customTransform(X);

Заменить исходный блок этой реализацией. Сравнить результат с формулой на двух входах, где меняются ориентация данных и масштаб величин. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит. Для темы «Поддерживаемые операции» также сверить класс данных и сохранение ожидаемой структуры выхода.assert(isa(customTransform(X),"gpuArray")); Переписать вычислительный шаг следующим образом. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. В журнале проверки сохранить вход, ожидаемый результат и фактическое расхождение. Для темы «Поддерживаемые операции» также сверить класс данных и сохранение ожидаемой структуры выхода.Yg = arrayfun(@customTransform,gpuArray(X)); Использовать показанный вариант вместо дефектного фрагмента. Перед принятием проверить предпосылки операции, форму результата и один численный инвариант. Контрольный пример должен воспроизводиться на чистом запуске проекта. Для темы «Поддерживаемые операции» также сверить класс данных и сохранение ожидаемой структуры выхода.gpuDevice; customTransform(X); Принять эту редакцию как полную замену текущего блока. Добавить регрессионный пример, на котором исходная версия расходится с требованием по значению или размерности. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки. Для темы «Поддерживаемые операции» также сверить класс данных и сохранение ожидаемой структуры выхода.Yg = customTransform(gpuArray(X)); Внести показанную замену без изменения входного контракта. После замены проверить обычный и граничный входы, заранее вычислив ожидаемый результат. Допуск и критерий принятия зафиксировать до просмотра результата.

Xg = gpuArray(single(rand(32)));
try
    Yg = customTransform(Xg);
    wait(gpuDevice);
catch ME
    error("GPU path unsupported: %s",ME.message);
end

Вопрос 8 из 30

Перед рецензентом рабочий фрагмент по теме «Поддерживаемые операции». Как проверить его так, чтобы близкая подмена не прошла вместе с ним?

customTransform:\ gpuArray\to gpuArray

Xg = gpuArray(single(rand(32)));
try
    Yg = customTransform(Xg);
    wait(gpuDevice);
catch ME
    error("GPU path unsupported: %s",ME.message);
end

На одном типичном наборе сверить размер, класс и отсутствие `NaN` или `Inf` в результате по теме «Поддерживаемые операции». Соберите минимальный набор функций конвейера и протестируйте каждую на маленьком gpuArray перед интеграционным запуском. Выполнить расчёт с повышенной численной точностью и использовать совпадение округлённых значений как контроль темы «Поддерживаемые операции». Запустить несколько случайных наборов одинакового масштаба и сопоставить время выполнения и форму результата для темы «Поддерживаемые операции». Увеличить размер входа и проверить ожидаемый рост времени и памяти, сохранив исходный способ вычисления по теме «Поддерживаемые операции».

Вопрос 9 из 30

Нужно формализовать операцию «проверить поддержку пользовательской функции на gpuArray до большого запуска». Какая запись подходит?

customTransform:\ gpuArray\to cpuArray

customTransform:\ cpuArray\to gpuArray

customTransform:\ gpuArray\to\left( gpuArray\right)^2

customTransform:\ gpuArray\to double

customTransform:\ gpuArray\to gpuArray

Вопрос 10 из 30

Ночная задача падает через час: редкая ветвь вызывает функцию, которая не поддерживает gpuArray. Какой порядок работы не скроет причину ошибки?

Сравнить две реализации на одном типичном наборе и принять вариант с меньшим разбросом времени по теме «Поддерживаемые операции». Увеличить число случайных запусков и оценивать устойчивость среднего результата в задаче по теме «Поддерживаемые операции». Сначала выбрать более быстрый вариант на рабочем наборе, после чего закрепить его вывод автоматическим тестом по теме «Поддерживаемые операции». Ослабить допуск до уровня, при котором рабочий пример проходит, и использовать тот же порог для остальных данных по теме «Поддерживаемые операции». Иметь контракт поддерживаемых типов и операций, smoke-тест GPU-пути и явную CPU-альтернативу там, где она допустима.

Вопрос 11 из 30

На рецензию вынесена операция: избежать повторной передачи одной матрицы коэффициентов A на GPU внутри цикла. Какой вариант выполняет его без подмены операции?

Ag=gpuArray(A);
for k=1:K, X(:,k)=gather(Ag) \ B(:,k); end

Ag = gpuArray(A);
Bg = gpuArray(B);
Xg = zeros(size(B),"like",Ag);
for k=1:K
    Xg(:,k) = Ag \ Bg(:,k);
end
X = gather(Xg);

for k=1:K
    X(:,k)=gather(gpuArray(A) \ gpuArray(B(:,k)));
end

for k=1:K
    X(:,k)=A \ gather(gpuArray(B(:,k)));
end

for k=1:K, Xg(:,k)=gpuArray(A\B(:,k)); end

Вопрос 12 из 30

В тесте «Вычисления на GPU» показанный фрагмент нарушает правило из темы «Передача памяти». Какая редакция исправляет причину, а не только её проявление?

for k=1:K, Xg(:,k)=gpuArray(A\B(:,k)); end

Принять эту редакцию как полную замену текущего блока. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит. Для темы «Передача памяти» также сверить класс данных и сохранение ожидаемой структуры выхода.for k=1:K, Xg(:,k)=gpuArray(A\B(:,k)); end Использовать показанный вариант вместо дефектного фрагмента. Сравнить результат с формулой на двух входах, где меняются ориентация данных и масштаб величин. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки. Для темы «Передача памяти» также сверить класс данных и сохранение ожидаемой структуры выхода.

for k=1:K
    X(:,k)=A \ gather(gpuArray(B(:,k)));
end

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

Ag=gpuArray(A);
for k=1:K, X(:,k)=gather(Ag) \ B(:,k); end

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

Ag = gpuArray(A);
Bg = gpuArray(B);
Xg = zeros(size(B),"like",Ag);
for k=1:K
    Xg(:,k) = Ag \ Bg(:,k);
end
X = gather(Xg);

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

for k=1:K
    X(:,k)=gather(gpuArray(A) \ gpuArray(B(:,k)));
end

Вопрос 13 из 30

Фрагмент по теме «Передача памяти» выглядит правдоподобно. Какая проверка действительно подтвердит заявленное свойство, а не только отсутствие сбоя?

D_{transfer}=|A|+|B|+|X|\quad\text{вместо}\quad K|A|

Ag = gpuArray(A);
Bg = gpuArray(B);
Xg = zeros(size(B),"like",Ag);
for k=1:K
    Xg(:,k) = Ag \ Bg(:,k);
end
X = gather(Xg);

Сравните поэлементный цикл, блочное решение и повторные передачи; отдельно измерьте compute и transfer. Сравнить два близких входа и убедиться, что результат меняется плавно и без предупреждений в задаче по теме «Передача памяти». Сравнить ответ с сохранённым выводом предыдущей версии на рабочем наборе данных по теме «Передача памяти». Увеличить размер входа и проверить ожидаемый рост времени и памяти, сохранив исходный способ вычисления по теме «Передача памяти». Проверить только один сводный показатель результата — сумму, среднее или норму — на двух обычных входах из темы «Передача памяти».

Вопрос 14 из 30

Перед реализацией требования «избежать повторной передачи одной матрицы коэффициентов A на GPU внутри цикла» записывают модель. Какая запись подходит?

D_{transfer}=|A|+|B|+|Y|\quad\text{вместо}\quad K|A|

D_{transfer}=|B|+|B|+|X|\quad\text{вместо}\quad K|A|

D_{transfer}=|A|+|B|+|X|\quad\text{вместо}\quad K|B|

D_{transfer}=|A|+|C|+|X|\quad\text{вместо}\quad K|A|

D_{transfer}=|A|+|B|+|X|\quad\text{вместо}\quad K|A|

Вопрос 15 из 30

Профилировщик GPU показывает, что ядра быстры, но время доминирует копирование A для каждого столбца. Что следует сделать до принятия расчёта?

Проверить форму, класс и конечность результата; при совпадении этих признаков продолжить расчёт по теме «Передача памяти». Снизить расход памяти текущего варианта и сравнить его с прежним результатом на сохранённых данных по теме «Передача памяти». Сравнить две реализации на одном типичном наборе и принять вариант с меньшим разбросом времени по теме «Передача памяти». Перенести A и B на устройство до цикла, заранее выделить Xg, выполнять решения на GPU и вызвать `gather` один раз после расчёта. Привести входные данные к ожидаемой форме и классу, затем повторить исходный фрагмент по теме «Передача памяти».

Вопрос 16 из 30

Условие задачи — корректно измерить время асинхронной GPU-операции. Какой вариант выполняет его без подмены операции?

g = gpuDevice;
wait(g);
t = tic;
Yg = fft(Xg);
wait(g);
elapsed = toc(t);

t=tic; gather(Xg); Yg=fft(Xg); elapsed=toc(t); elapsed=timeit(@() fft(Xg)); elapsed=toc(fft(Xg)); t=tic; Yg=fft(Xg); elapsed=toc(t);

Вопрос 17 из 30

Для темы «Измерение ускорения» в тесте «Вычисления на GPU» приведён дефектный блок. Какое замечание рецензента можно принять?

elapsed=timeit(@() fft(Xg));

Принять эту редакцию как полную замену текущего блока. Перед принятием проверить предпосылки операции, форму результата и один численный инвариант. В журнале проверки сохранить вход, ожидаемый результат и фактическое расхождение.t=tic; Yg=fft(Xg); elapsed=toc(t); Переписать вычислительный шаг следующим образом. Сравнить результат с формулой на двух входах, где меняются ориентация данных и масштаб величин. Контрольный пример должен воспроизводиться на чистом запуске проекта.

g = gpuDevice;
wait(g);
t = tic;
Yg = fft(Xg);
wait(g);
elapsed = toc(t);

Использовать показанный вариант вместо дефектного фрагмента. После замены проверить обычный и граничный входы, заранее вычислив ожидаемый результат. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит.elapsed=toc(fft(Xg)); Внести показанную замену без изменения входного контракта. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки.elapsed=timeit(@() fft(Xg)); Заменить исходный блок этой реализацией. Добавить регрессионный пример, на котором исходная версия расходится с требованием по значению или размерности. Допуск и критерий принятия зафиксировать до просмотра результата.t=tic; gather(Xg); Yg=fft(Xg); elapsed=toc(t);

Вопрос 18 из 30

Ниже показано решение из темы «Измерение ускорения». Какой контроль отличит его от ближайшей ошибочной реализации?

T_{measured}=T_{kernel}+T_{sync}

g = gpuDevice;
wait(g);
t = tic;
Yg = fft(Xg);
wait(g);
elapsed = toc(t);

Выполнить расчёт с повышенной численной точностью и использовать совпадение округлённых значений как контроль темы «Измерение ускорения». На одном типичном наборе сверить размер, класс и отсутствие `NaN` или `Inf` в результате по теме «Измерение ускорения». Сравните на одном ядре наивный `tic/toc`, синхронизацию и `gputimeit`; объясните различия. Сравнить два близких входа и убедиться, что результат меняется плавно и без предупреждений в задаче по теме «Измерение ускорения». Повторить вычисление в отдельной функции, сохранив ту же формулу, и сравнить два полученных ответа по теме «Измерение ускорения».

Вопрос 19 из 30

Проверка кода для задачи «корректно измерить время асинхронной GPU-операции» опирается на формулу. Какая запись подходит?

T_{measured}\approxT_{kernel}+T_{sync}

T^{-1}_{measured}=T_{kernel}+T_{sync}

T_{measured}=T_{kernel}+T_{sync}

S_{measured}=T_{kernel}+T_{sync}

T_{measured}=T_{kernel}-T_{sync}

Вопрос 20 из 30

Отчёт показывает микросекунды для тяжёлого FFT, потому что таймер остановлен до фактического выполнения на устройстве. Какое решение оставит независимый критерий проверки?

Сначала выбрать более быстрый вариант на рабочем наборе, после чего закрепить его вывод автоматическим тестом по теме «Измерение ускорения». Синхронизировать устройство или использовать подходящий измеритель, прогреть ядро и повторять на репрезентативных размерах. Увеличить число случайных запусков и оценивать устойчивость среднего результата в задаче по теме «Измерение ускорения». Проверить форму, класс и конечность результата; при совпадении этих признаков продолжить расчёт по теме «Измерение ускорения». Сохранить результат текущей версии как регрессионный эталон и расширить набор входов того же типа для темы «Измерение ускорения».

Вопрос 21 из 30

Фрагмент должен сохранить переносимость алгоритма между CPU и GPU без проверки класса в каждой математической строке. Какой вариант выполняет его без подмены операции?

prototype = input;
Z = zeros(size(input),"like",prototype);
Z = coreAlgorithm(input,Z);

input=gather(input); Z=coreAlgorithm(input,zeros(size(input))); if isa(input,"gpuArray"), Z=gpuArray.zeros(size(input)); else, Z=zeros(size(input)); end Z=zeros(size(input)); Z=coreAlgorithm(input,Z); input=gpuArray(input); Z=coreAlgorithm(input,gpuArray.zeros(size(input)));

Вопрос 22 из 30

Показанный код из темы «Совместимость и переносимость» не соответствует постановке. Какая редакция восстанавливает вычислительный договор?

if isa(input,"gpuArray"), Z=gpuArray.zeros(size(input)); else, Z=zeros(size(input)); end

Использовать показанный вариант вместо дефектного фрагмента. Добавить регрессионный пример, на котором исходная версия расходится с требованием по значению или размерности. В журнале проверки сохранить вход, ожидаемый результат и фактическое расхождение.Z=zeros(size(input)); Z=coreAlgorithm(input,Z); Переписать вычислительный шаг следующим образом. После замены проверить обычный и граничный входы, заранее вычислив ожидаемый результат. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки.input=gather(input); Z=coreAlgorithm(input,zeros(size(input))); Принять эту редакцию как полную замену текущего блока. Сравнить результат с формулой на двух входах, где меняются ориентация данных и масштаб величин. Допуск и критерий принятия зафиксировать до просмотра результата.input=gpuArray(input); Z=coreAlgorithm(input,gpuArray.zeros(size(input))); Заменить исходный блок этой реализацией. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. Контрольный пример должен воспроизводиться на чистом запуске проекта.

prototype = input;
Z = zeros(size(input),"like",prototype);
Z = coreAlgorithm(input,Z);

Внести показанную замену без изменения входного контракта. Перед принятием проверить предпосылки операции, форму результата и один численный инвариант. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит.if isa(input,"gpuArray"), Z=gpuArray.zeros(size(input)); else, Z=zeros(size(input)); end

Вопрос 23 из 30

Результат фрагмента по теме «Совместимость и переносимость» нужно принять перед включением в расчёт. Какая проверка даст независимое основание?

type(Z)=type(input)

prototype = input;
Z = zeros(size(input),"like",prototype);
Z = coreAlgorithm(input,Z);

Проверить только один сводный показатель результата — сумму, среднее или норму — на двух обычных входах из темы «Совместимость и переносимость». Увеличить размер входа и проверить ожидаемый рост времени и памяти, сохранив исходный способ вычисления по теме «Совместимость и переносимость». Перепишите выделение временных массивов через `like` и запустите ядро на double, single и gpuArray single. Выполнить расчёт с повышенной численной точностью и использовать совпадение округлённых значений как контроль темы «Совместимость и переносимость». Запустить несколько случайных наборов одинакового масштаба и сопоставить время выполнения и форму результата для темы «Совместимость и переносимость».

Вопрос 24 из 30

Математическая запись должна описывать действие «сохранить переносимость алгоритма между CPU и GPU без проверки класса в каждой математической строке». Какая запись подходит?

type(Z^{\mathrm T})=type(input)

type(Z)=type(output)

type(Z)\approxtype(input)

type(Z)=type(input)

type(Z^{-1})=type(input)

Вопрос 25 из 30

CPU-путь проходит, а GPU-путь падает при присваивании результата в заранее выделенный double на CPU. Какой вариант переносится на граничные данные?

Сравнить две реализации на одном типичном наборе и принять вариант с меньшим разбросом времени по теме «Совместимость и переносимость». Привести входные данные к ожидаемой форме и классу, затем повторить исходный фрагмент по теме «Совместимость и переносимость». Использовать `like`, отделить неподдерживаемые операции адаптерами и тестировать оба пути одной батареей контрактов. Ослабить допуск до уровня, при котором рабочий пример проходит, и использовать тот же порог для остальных данных по теме «Совместимость и переносимость». Сначала выбрать более быстрый вариант на рабочем наборе, после чего закрепить его вывод автоматическим тестом по теме «Совместимость и переносимость».

Вопрос 26 из 30

Разработчик переносит в MATLAB требование: проверить численную эквивалентность CPU- и GPU-результатов с учётом класса single. Какой вариант выполняет его без подмены операции?

assert(max(Ycpu-Ygpu)<eps);

Ycpu = core(single(X));
Ygpu = gather(core(gpuArray(single(X))));
rel = norm(double(Ycpu-Ygpu),"fro")/max(1,norm(double(Ycpu),"fro"));
assert(rel < 1e-5);

assert(all(size(Ycpu)==size(Ygpu))); assert(isequal(Ycpu,Ygpu)); assert(norm(Ycpu)==norm(Ygpu));

Вопрос 27 из 30

Рецензент разбирает фрагмент по теме «Стратегия тестирования» в тесте «Вычисления на GPU». Какой вариант исправляет саму операцию?

assert(norm(Ycpu)==norm(Ygpu));

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

Ycpu = core(single(X));
Ygpu = gather(core(gpuArray(single(X))));
rel = norm(double(Ycpu-Ygpu),"fro")/max(1,norm(double(Ycpu),"fro"));
assert(rel < 1e-5);

Использовать показанный вариант вместо дефектного фрагмента. На минимальном примере сопоставить форму выхода и два контрольных значения с независимым эталоном. Допуск и критерий принятия зафиксировать до просмотра результата. Для темы «Стратегия тестирования» также сверить класс данных и сохранение ожидаемой структуры выхода.assert(isequal(Ycpu,Ygpu)); Принять эту редакцию как полную замену текущего блока. После замены проверить обычный и граничный входы, заранее вычислив ожидаемый результат. Контрольный пример должен воспроизводиться на чистом запуске проекта. Для темы «Стратегия тестирования» также сверить класс данных и сохранение ожидаемой структуры выхода.assert(norm(Ycpu)==norm(Ygpu)); Переписать вычислительный шаг следующим образом. Добавить регрессионный пример, на котором исходная версия расходится с требованием по значению или размерности. Отдельно убедиться, что ближайшая неверная реализация этот контроль не проходит. Для темы «Стратегия тестирования» также сверить класс данных и сохранение ожидаемой структуры выхода.assert(max(Ycpu-Ygpu)<eps); Заменить исходный блок этой реализацией. Перед принятием проверить предпосылки операции, форму результата и один численный инвариант. Результат проверки оформить так, чтобы его можно было повторить без ручной подгонки. Для темы «Стратегия тестирования» также сверить класс данных и сохранение ожидаемой структуры выхода.assert(all(size(Ycpu)==size(Ygpu)));

Вопрос 28 из 30

Для решения по теме «Стратегия тестирования» выбирают контрольный опыт. Какой вариант проверяет смысл операции, а не внешние признаки результата?

\delta=\frac{\|Y_{cpu}-Y_{gpu}\|}{\max(1,\|Y_{cpu}\|)}<10^{-5}

Ycpu = core(single(X));
Ygpu = gather(core(gpuArray(single(X))));
rel = norm(double(Ycpu-Ygpu),"fro")/max(1,norm(double(Ycpu),"fro"));
assert(rel < 1e-5);

Сравнить два близких входа и убедиться, что результат меняется плавно и без предупреждений в задаче по теме «Стратегия тестирования». Проверить только один сводный показатель результата — сумму, среднее или норму — на двух обычных входах из темы «Стратегия тестирования». Сравнить ответ с сохранённым выводом предыдущей версии на рабочем наборе данных по теме «Стратегия тестирования». Сравните CPU и GPU на спокойных и плохо обусловленных данных; установите допуск из наблюдаемой и допустимой ошибки. Повторить вычисление в отдельной функции, сохранив ту же формулу, и сравнить два полученных ответа по теме «Стратегия тестирования».

Вопрос 29 из 30

Для операции «проверить численную эквивалентность CPU- и GPU-результатов с учётом класса single» фиксируют вычислительный договор. Какая запись подходит?

\delta=\frac{\|Y_{cpu}-Y_{gpu}\|}{\max(2,\|Y_{cpu}\|)}<10^{-5}

\delta=\frac{\|X_{cpu}-Y_{gpu}\|}{\max(1,\|Y_{cpu}\|)}<10^{-5}

\delta=\frac{\|Y_{cpu}-Y_{gpu}\|}{\max(1,\|Y_{cpu}\|)}<10^{-5}

\delta=\frac{\|Y_{cpu}-Y_{gpu}\|}{\max(1,\|Y_{cpu}\|)}>10^{-5}

\delta=\frac{\|Y_{cpu}-Y_{gpu}\|}{\min(1,\|Y_{cpu}\|)}<10^{-5}

Вопрос 30 из 30

Побитовое сравнение падает после обновления драйвера, хотя инженерные показатели не изменились. Что уменьшит риск повторения дефекта?

Проверить форму, класс и конечность результата; при совпадении этих признаков продолжить расчёт по теме «Стратегия тестирования». Сохранить результат текущей версии как регрессионный эталон и расширить набор входов того же типа для темы «Стратегия тестирования». Снизить расход памяти текущего варианта и сравнить его с прежним результатом на сохранённых данных по теме «Стратегия тестирования». Зафиксировать метрику и допуск, добавить инварианты и хранить сведения об устройстве/драйвере для расследования. Привести входные данные к ожидаемой форме и классу, затем повторить исходный фрагмент по теме «Стратегия тестирования».