ByteDance Seed и Tsinghua AIR представили CUDA Agent: крупномасштабную агентную систему обучения с подкреплением для генерации ядер CUDA
ByteDance Seed и Tsinghua AIR выпустили CUDA Agent — агентную систему обучения с подкреплением, которая обучает большую языковую модель писать GPU-ядра, превосходящие компилятор. Целевой разрыв узок, но устойчив: передовые модели уже создают корректный CUDA-код, просто этот CUDA-код работает медленно. В KernelBench базовая модель Seed1.6 проходит 74,0% задач, но опережает torch.compile только в 27,2% случаев, показывая геометрическое среднее ускорения 0,69×, то есть в среднем её ядра работают медленнее тех, которые компилятор генерирует самостоятельно. CUDA Agent сокращает этот разрыв, помещая модель в настоящую среду разработки CUDA с профилированием, проверками корректности и песочницей с ограниченными разрешениями, а затем обучая её с помощью PPO в течение 150 шагов с контекстом в 131 072 токена. В результате на бенчмарке из 250 задач достигнуты показатель прохождения 98,8% и доля случаев, когда решение быстрее torch.compile, 96,8%, при геометрическом среднем 2,11× относительно компиляции — примерно на 40 процентных пунктов выше, чем у Claude Opus 4.5 и Gemini 3 Pro, на самом сложном разбиении Level 3.
Можно ли внедрять систему?
Частично, но обученный агент не опубликован. Он построен на базе Seed1.6 — проприетарной MoE-модели с 23 млрд активных и 230 млрд общих параметров, — и статья не содержит весов. В открытом доступе находятся: датасет CUDA-Agent-Ops-6K, спецификация SKILL.md, а также рецепты вознаграждения и предварительного разогрева.
Какие компании: Одна только песочница для профилирования использовала 128 GPU NVIDIA H20, поэтому полное воспроизведение системы доступно передовым исследовательским лабораториям, GPU-облакам и крупным инфраструктурным командам. Команды среднего размера всё же могут использовать отдельные компоненты — датасет, поощрение за достижение этапов, ограничения против взлома системы вознаграждений и спецификацию навыков — поверх открытой базовой модели.
Отрасли и применения: ИИ-инфраструктура и обслуживание инференса, GPU-облака, автономное вождение, количественная торговля, медицинская визуализация и рекомендательные системы — везде, где объединённые ядра находятся на критичном для задержки пути. Применения включают объединение последовательностей операторов, с которыми torch.compile справляется плохо, снижение стоимости одного токена и повторную настройку ядер для разных поколений GPU.
Синтез данных
Исследовательская команда извлекает эталонные операторы из библиотек torch и transformers. Затем LLM выбирает до пяти классов операторов torch и объединяет их в один слитый слой. Фильтр оставляет только операторы, которые выполняются и в режимах eager, и в режиме compile, являются детерминированными, создают неконстантные выходные данные и выполняются от 1 до 100 мс в режиме eager. Образцы с AST-сходством выше 0,9 с любой задачей KernelBench удаляются. Так получается CUDA-Agent-Ops-6K: 6 000 образцов, 83,77% из которых являются композициями из двух операторов.
Среда и вознаграждение
Цикл работы агента повторяет инструменты OpenHands — Bash, Read/Write, Edit/MultiEdit, Glob, Grep, NotebookEdit, BashOutput, KillBash — в рамках паттерна ReAct. Инструкции CUDA поставляются в формате Agent Skills. Файл SKILL.md сообщает модели, что нужно профилировать модель PyTorch, переписать model_new.py с пользовательскими ядрами, скомпилировать его в GPU-песочнице и повторять процесс, пока ядро не станет как минимум на 5% быстрее torch.compile при atol=1e-2, rtol=1e-2.
Для предотвращения взлома системы вознаграждений используются пять контрмер: скрипты проверки и профилирования с ограниченными разрешениями, контекстные менеджеры, запрещающие откаты к torch.nn.functional, проверки на пяти случайных входных данных, профилирование с синхронизацией устройства и предварительным разогревом, а также отсутствие инструмента веб-поиска.
Вознаграждение является дискретным, а не равным исходному коэффициенту ускорения. r ∈ {−1, 1, 2, 3}: −1 при ошибке корректности, 3 — если ядро превосходит и eager, и torch.compile более чем на 5%, 2 — если оно превосходит только eager, 1 — в остальных случаях.
Результаты
Таблица 1, общие результаты: показатель прохождения 98,8%, 98,4% решений быстрее eager и 96,8% решений быстрее torch.compile, при геометрическом среднем 2,60× и 2,11× соответственно. Level 2 (последовательности операторов) является самым сильным разбиением: 100% прохождения, 100% более быстрых решений и 2,80× относительно torch.compile. На Level 3 показатели составляют 94,0% прохождения, 90,0% более быстрых решений и 1,52× — примерно на 40 процентных пунктов выше, чем у Claude Opus 4.5 (50,0%) и Gemini 3 Pro (52,0%) по доле решений, более быстрых относительно компиляции.
Есть одна несогласованность: в аннотации и введении указаны показатели более быстрых решений 100% / 100% / 92% для уровней 1–3, тогда как в таблице 1 приведены значения 97,0% / 100,0% / 90,0%. Таблица 1 является основной таблицей результатов.
Абляции дают однозначную картину. Удаление агентного цикла снижает долю решений, более быстрых относительно компиляции, с 96,8% до 14,1%. Использование исходного вознаграждения за ускорение даёт 60,4%, отказ от RFT — 49,8% и коллапс вознаграждения, а отказ от предварительного обучения ценности — 50,9% и неконтролируемое увеличение траекторий.
Примеры показывают, чему обучается политика. Диагональное матричное умножение переписано в виде построчного масштабирования: 73,31× относительно torch.compile. Цепочка matmul-divide-sum-scale переупорядочена и объединена: 24,04×. В ResNet BasicBlock BatchNorm объединён со свёрткой, а также использован cudnnConvolutionBiasActivationForward: 3,59×.
Запустить цикл</button><button class="btn ghost" id="l-stop">Пауза</button></div>
<div class="loop">
<div class="node" id="n0"><div class="ic">
</div><div class="nm">SKILL.md</div><div class="sub">Профилирование → написание ядра → компиляция → итерации</div></div>
<div class="node" id="n1"><div class="ic">
</div><div class="nm">CUDA Agent</div><div class="sub">Bash, Read/Write, Edit/MultiEdit, Glob, Grep</div></div>
<div class="node" id="n2"><div class="ic">
</div><div class="nm">CPU-песочница</div><div class="sub">Компиляция .cu + binding.cpp в Docker</div></div>
<div class="node" id="n3"><div class="ic">
</div><div class="nm">Пул GPU</div><div class="sub">Проверка корректности и профилирование на 128 H20</div></div>
</div>
<div class="gauge">
<div class="g"><div class="k">Шаг</div><div class="v" id="g-turn">0</div></div>
<div class="g"><div class="k">Torch eager</div><div class="v warn" id="g-eager">2.30 мс</div></div>
<div class="g"><div class="k">torch.compile</div><div class="v warn" id="g-comp">1.80 мс</div></div>
<div class="g"><div class="k">Сгенерированное</div><div class="v good" id="g-gen">— мс</div></div>
</div>
<div class="note">Иллюстрация: пошаговое снижение времени работы сгенерированного ядра является симуляцией цикла. Три итоговых значения времени (2,30 мс для eager, 1,80 мс для compile и 1,26 мс для сгенерированного ядра) в точности соответствуют значениям на рисунке 2 статьи.</div>
<div class="ref">Меры против взлома системы вознаграждений: скрипты проверки и профилирования имеют ограниченные разрешения, контекстные менеджеры запрещают откаты к <span class="mono">torch.nn.functional</span>, выходные данные проверяются на пяти случайных входах, профилирование использует синхронизацию устройства, предварительный разогрев и повторные измерения, а агент не получает инструмента веб-поиска.</div>
</section>
<!-- 03 -->
<section class="mod" id="m3">
<h3>Почему вознаграждение дискретное, а не является коэффициентом ускорения</h3>
<p class="lede">Исходные вознаграждения за ускорение смещают политику в сторону простых ядер и дают нестабильные результаты на выбросах. Вместо этого CUDA Agent использует этапы. Перемещайте ползунок, чтобы задать время работы вашего ядра и увидеть изменение вознаграждения.</p>
<div class="ctrl">
<label>Время работы сгенерированного ядра <span class="mono" id="rt-lab">1.26 мс</span></label>
<input type="range" id="rt" min="20" max="320" step="1" value="126">
</div>
<div class="row"><button class="btn ghost" id="ok-tog">Проверка корректности: <b id="ok-lab">ПРОЙДЕНА</b></button></div>
<div class="bars3" id="bars3"></div>
<div class="verdict" id="verdict">
<div class="r" id="v-r">3</div>
<div class="why" id="v-why"></div>
</div>
<div class="ref">Точное правило из уравнения 1: r = −1 при провале проверки корректности; 3 — если ядро быстрее и eager, и <span class="mono">torch.compile</span>; 2 — если оно быстрее только eager; в остальных случаях 1. «Быстрее» означает b(t, t₀) = 𝟙[(t₀ − t)/t₀ > 5%]. Базовые значения зафиксированы на уровне, показанном на рисунке 2.</div>
</section>
<!-- 04 -->
<section class="mod" id="m4">
<h3>Результаты KernelBench, таблица 1</h3>
<p class="lede">250 задач в рамках трёх уровней, взвешенных как 100 / 100 / 50. Переключайте разбиение и метрику — столбцы перерисуются с использованием опубликованных в статье чисел.</p>
<div class="selrow">
<div class="seg" id="lvl">
<button data-k="ov" class="on">Общие</button><button data-k="l1">Уровень 1</button><button data-k="l2">Уровень 2</button><button data-k="l3">Уровень 3</button>
</div>
<div class="seg" id="met">
<button data-k="pass">Доля пройденных</button><button data-k="fe">Быстрее eager</button><button data-k="fc" class="on">Быстрее compile</button><button data-k="se">Ускорение относительно eager</button><button data-k="sc">Ускорение относительно compile</button>
</div>
</div>
<div id="chart"></div>
<div class="ref" id="chart-note"></div>
<div class="note">В аннотации и введении указана доля решений, более быстрых относительно <span class="mono">torch.compile</span>, равная 100% / 100% / 92% для уровней 1 / 2 / 3, тогда как в таблице 1 приведены значения 97,0% / 100,0% / 90,0%. Этот виджет использует таблицу 1 — основную таблицу результатов статьи.</div>
</section>
<!-- 05 -->
<section class="mod" id="m5">
<h3>Что ломается при удалении отдельных компонентов</h3>
<p class="lede">Варианты с поочерёдным удалением компонентов, общее разбиение, доля решений, более быстрых относительно <span class="mono">torch.compile</span>. Агентный цикл важнее всего; два этапа предварительного разогрева не дают обучению разрушиться.</p>
<div id="abl"></div>
<div class="row" style="margin-top:14px"><button class="btn" id="st-run"> Повторить кривую обучения</button></div>
<svg class="spark" id="spark" viewBox="0 0 600 150" preserveAspectRatio="none"></svg>
<div class="legend"><span><i style="background:#4D9BFF"></i>PPO с RFT + предварительным обучением ценности</span><span><i style="background:#f5a623"></i>PPO без предварительного разогрева</span></div>
<div class="note">Схематическая перерисовка рисунка 4a, иллюстрация. Указанные в статье факты: первая попытка обучения с подкреплением оставалась стабильной в течение 17 шагов, после чего произошёл коллапс; с RFT актёра и предварительным обучением ценности критика обучение продолжалось 150 шагов с устойчивым ростом вознаграждения.</div>
<div class="ref">Причина, указанная в статье: CUDA-код составляет менее 0,01% данных предварительного обучения, поэтому маловероятные токены в выборке заставляют коэффициент важности PPO колебаться или взрываться из-за расхождения точности обучения и инференса.</div>
</section>
<div class="foot">
<span>Источник: Dai, Wu, Yu и др., arXiv 2602.24286 · ByteDance Seed × Tsinghua AIR</span>
<span><b>Marktechpost</b> · интерактивное объяснение</span>
</div>
</div>
<script>
(function(){
var $=function(s){return document.querySelector(s)};
var $$=function(s){return Array.prototype.slice.call(document.querySelectorAll(s))};
/* ---- изменение размера ---- */
var wrap=document.getElementById('ca-wrap');
var lastH=0;
function ping(){
var h=wrap.offsetHeight+40;
if(h===lastH)return; lastH=h;
try{ parent.postMessage({type:'mtpEmbedHeight',id:'cuda-agent-explainer',height:h},'*'); }catch(e){}
}
setInterval(ping,600); window.addEventListener('load',ping); ping();
/* ---- навигация ---- */
$$('nav.ca-nav button').forEach(function(b){
b.addEventListener('click',function(){
$$('nav.ca-nav button').forEach(function(x){x.classList.remove('active')});
$$('section.mod').forEach(function(x){x.classList.remove('show')});
b.classList.add('active');
var m=b.getAttribute('data-m');
document.getElementById(m).classList.add('show');
if(m==='m5'){ setTimeout(drawSpark,30); }
ping();
});
});
/* ---- 01 конвейер ---- */
var comp=[['torch ops ×2',83.77],['torch ops ×3',7.62],['torch ops ×1',3.40],
['torch ops ×4',2.80],['torch ops ×5',1.23],['transformers',1.18]];
var compHTML='';
comp.forEach(function(c,i){
compHTML+='<div class="cb"><div class="lab">'+c[0]+'</div><div class="track"><div class="fill" data-w="'+
(c[1]/83.77*100)+'"></div></div><div class="val">'+c[1].toFixed(2)+'%</div></div>';
});
$('#comp').innerHTML=compHTML;
function tick(el,to,ms,suffix){
var t0=null;
function step(ts){ if(!t0)t0=ts; var p=Math.min((ts-t0)/ms,1);
el.textContent=Math.round(to*(1-Math.pow(1-p,3))).toLocaleString()+(suffix||'');
if(p<1)requestAnimationFrame(step); }
requestAnimationFrame(step);
}
function runPipe(){
resetPipe();
setTimeout(function(){$('#s1').classList.add('lit'); $('#c1').textContent='torch + transformers';},80);
setTimeout(function(){$('#s2').classList.add('lit'); $('#c2').textContent='\u2264 5 ops / task';},1100);
setTimeout(function(){$('#s3').classList.add('lit'); tick($('#c3'),6000,1000,' samples kept');},2200);
setTimeout(function(){$$('#comp .fill').forEach(function(f,i){
setTimeout(function(){f.style.width=f.getAttribute('data-w')+'%'},i*110)});},2900);
}
function resetPipe(){
['s1','s2','s3'].forEach(function(id){$('#'+id).classList.remove('lit')});
['c1','c2','c3'].forEach(function(id){$('#'+id).textContent='—'});
$$('#comp .fill').forEach(function(f){f.style.width='0%'});
}
$('#p-run').addEventListener('click',runPipe);
$('#p-reset').addEventListener('click',resetPipe);
/* ---- 02 цикл агента ---- */
var lt=null, li=0, turn=0, gen=2.90;
function loopStep(){
['n0','n1','n2','n3'].forEach(function(id){$('#'+id).classList.remove('act')});
$('#n'+(li%4)).classList.add('act');
if(li%4===3){
turn++; gen=Math.max(1.26, gen-(gen-1.26)*0.42);
$('#g-turn').textContent=turn;
$('#g-gen').textContent=gen.toFixed(2)+' мс';
$('#g-gen').className='v '+(gen<1.71?'good':'warn');
}
li++;
}
function loopStart(){ if(lt)return; loopStep(); lt=setInterval(loopStep,460); }
function loopStop(){ clearInterval(lt); lt=null; }
$('#l-run').addEventListener('click',function(){ if(turn>=6){turn=0;gen=2.90;} loopStart(); });
$('#l-stop').addEventListener('click',loopStop);
/* ---- 03 вознаграждение ---- */
var EAGER=2.30, COMP=1.80, ok=true;
function b(t,t0){ return (t0-t)/t0 > 0.05; }
function drawReward(){
var t=parseInt($('#rt').value,10)/100;
$('#rt-lab').textContent=t.toFixed(2)+' мс';
var max=3.4;
var rows=[['torch eager',EAGER,'#f5a623'],['torch.compile',COMP,'#4D9BFF'],['ваше ядро',t,'#5BE1F5']];
var h='';
rows.forEach(function(r){
h+='<div class="b3"><div class="lab">'+r[0]+'</div><div class="track"><div class="fill" style="width:'+
(r[1]/max*100)+'%;background:linear-gradient(90deg,'+r[2]+'55,'+r[2]+')"></div></div><div class="val">'+
r[1].toFixed(2)+' мс</div></div>';
});
$('#bars3').innerHTML=h;
var be=b(t,EAGER), bc=b(t,COMP), r, why, col;
if(!ok){ r=-1; why='Проверка корректности не пройдена. Время работы не имеет значения — траектория штрафуется.'; col='#f5a623'; }
else if(be&&bc){ r=3; why='Более чем на 5% быстрее eager И torch.compile. Высший этап.'; col='#3ddc97'; }
else if(be){ r=2; why='Более чем на 5% быстрее eager, но не torch.compile.'; col='#5BE1F5'; }
else { r=1; why='Корректно, но без существенного ускорения относительно базовых вариантов.'; col='#8fa3c0'; }
$('#v-r').textContent=(r>0?'+':'')+r; $('#v-r').style.color=col;
$('#v-why').textContent=why;
$('#verdict').style.borderColor=col;
}
$('#rt').addEventListener('input',drawReward);
$('#ok-tog').addEventListener('click',function(){
ok=!ok; $('#ok-lab').textContent=ok?'ПРОЙДЕНА':'НЕ ПРОЙДЕНА'; drawReward();
});
drawReward();
/* ---- 04 график (таблица 1) ---- */
var MODELS=['Seed1.6 (базовая)','GLM 4.6','Kimi K2','Gemini 3 Pro','Claude Opus 4.5','CUDA Agent'];
var D={
ov:{pass:[74.0,75.6,66.8,91.2,95.2,98.8],fe:[43.6,44.8,40.8,87.6,90.4,98.4],
fc:[27.2,19.2,22.8,69.6,66.4,96.8],se:[0.95,0.78,0.93,1.92,1.99,2.60],
sc:[0.69,0.57,0.66,1.42,1.46,2.11]},
l1:{pass:[90.0,86.0,85.0,95.0,96.0,100.0],fe:[63.0,57.0,56.0,90.0,88.0,99.0],
fc:[51.0,32.0,39.0,72.0,72.0,97.0],se:[1.65,0.99,1.43,1.99,2.03,2.48],
sc:[1.25,0.73,1.00,1.51,1.54,1.87]},
l2:{pass:[74.0,76.0,65.0,93.0,98.0,100.0],fe:[40.0,43.0,40.0,91.0,97.0,100.0],
fc:[16.0,11.0,15.0,76.0,69.0,100.0],se:[0.68,0.60,0.93,2.03,2.24,3.27],
sc:[0.50,0.42,0.65,1.46,1.60,2.80]},
l3:{pass:[42.0,54.0,34.0,80.0,88.0,94.0],fe:[12.0,24.0,12.0,76.0,82.0,94.0],
fc:[2.0,10.0,6.0,52.0,50.0,90.0],se:[0.60,0.83,0.40,1.58,1.52,1.80],
sc:[0.40,0.62,0.29,1.17,1.10,1.52]}
};
var NOTES={ov:'Общие результаты = взвешивание по числу задач на каждом уровне (уровень 1: 100, уровень 2: 100, уровень 3: 50).',
l1:'Уровень 1 = отдельные операции.', l2:'Уровень 2 = последовательности операторов, где объединение даёт наибольший эффект.',
l3:'Уровень 3 = реалистичные блоки нейросетей, самое сложное разбиение.'};
var lvl='ov', met='fc';
function drawChart(){
var vals=D[lvl][met], pct=(met==='se'||met==='sc')?false:true;
var max=Math.max.apply(null,vals)*1.06;
var h='';
MODELS.forEach(function(m,i){
var v=vals[i];
h+='<div class="brow'+(i===5?' ours':'')+'"><div class="lab">'+m+'</div><div class="track"><div class="fill" data-w="'+
(v/max*100)+'"></div></div><div class="val">'+(pct?v.toFixed(1)+'%':v.toFixed(2)+'×')+'</div></div>';
});
$('#chart').innerHTML=h;
$('#chart-note').textContent=NOTES[lvl]+' Все показатели взяты из таблицы 1 статьи.';
setTimeout(function(){$$('#chart .fill').forEach(function(f,i){
setTimeout(function(){f.style.width=f.getAttribute('data-w')+'%'},i*70)})},30);
}
$$('#lvl button').forEach(function(b2){b2.addEventListener('click',function(){
$$('#lvl button').forEach(function(x){x.classList.remove('on')});b2.classList.add('on');
lvl=b2.getAttribute('data-k');drawChart();})});
$$('#met button').forEach(function(b2){b2.addEventListener('click',function(){
$$('#met button').forEach(function(x){x.classList.remove('on')});b2.classList.add('on');
met=b2.getAttribute('data-k');drawChart();})});
drawChart();
/* ---- 05 абляция ---- */
var ABL=[['без агентного цикла',14.1],['без устойчивого вознаграждения',60.4],['без RFT',49.8],
['без предварительного обучения ценности',50.9],['CUDA Agent (полная версия)',96.8]];
var ah='';
ABL.forEach(function(a,i){
ah+='<div class="brow'+(i===4?' ours':'')+'"><div class="lab">'+a[0]+
'</div><div class="track"><div class="fill" data-w="'+a[1]+'"></div></div><div class="val">'+
a[1].toFixed(1)+'%</div></div>';
});
$('#abl').innerHTML=ah;
setTimeout(function(){$$('#abl .fill').forEach(function(f,i){
setTimeout(function(){f.style.width=f.getAttribute('data-w')+'%'},i*90)})},250);
/* ---- 05 график ---- */
var good=[0.35,0.62,0.95,1.10,1.02,1.28,1.20,1.44,1.35,1.52,1.41,1.63,1.55,1.72,1.66,1.80,1.74,1.88,1.82,1.95];
var bad =[0.32,0.58,0.88,1.05,1.18,1.30,1.22,1.05,0.86,0.62,0.40,0.22,0.12,0.06,0.03,0.02,0.02,0.01,0.01,0.01];
function pts(a){ return a.map(function(v,i){
return (30+i*(555/(a.length-1))).toFixed(1)+','+(130-v/2.1*112).toFixed(1); }).join(' '); }
function drawSpark(){
var s=$('#spark');
s.innerHTML='<line x1="30" y1="130" x2="588" y2="130" stroke="#1c2942" stroke-width="1"/>'+
'<line x1="30" y1="18" x2="30" y2="130" stroke="#1c2942" stroke-width="1"/>'+
'<line x1="200" y1="18" x2="200" y2="130" stroke="#f5a62355" stroke-width="1" stroke-dasharray="4 4"/>'+
'<text x="205" y="30" fill="#8fa3c0" font-size="10" font-family="monospace">шаг 17: коллапс</text>'+
'<text x="4" y="24" fill="#8fa3c0" font-size="9" font-family="monospace">вознаграждение</text>'+
'<polyline id="pl-bad" points="'+pts(bad)+'" fill="none" stroke="#f5a623" stroke-width="2"/>'+
'<polyline id="pl-good" points="'+pts(good)+'" fill="none" stroke="#4D9BFF" stroke-width="2"/>';
['pl-bad','pl-good'].forEach(function(id){
var p=document.getElementById(id), L=0;
try{ L=p.getTotalLength(); }catch(e){ return; }
if(!L) return;
p.style.strokeDasharray=L; p.style.strokeDashoffset=L;
p.style.transition='stroke-dashoffset 1.8s ease';
setTimeout(function(){p.style.strokeDashoffset=0},60);
});
}
$('#st-run').addEventListener('click',drawSpark);
drawSpark();
})();
</script>
</body>
</html>
">
Главные выводы
- CUDA Agent достигает показателя прохождения 98,8% и доли решений, более быстрых, чем
torch.compile, 96,8% на KernelBench, при геометрическом среднем 2,11×. - Объединение на Level 2 даёт лучший результат: 100% более быстрых решений и 2,80× относительно
torch.compile. - Дискретное поощрение за достижение этапов превосходит исходное соотношение ускорения на 36,4 процентного пункта по доле более быстрых решений.
- Именно RFT вместе с предварительным обучением ценности превращает коллапс после 17 шагов в 150 стабильных шагов.
- Веса закрыты; датасет из 6 000 образцов,
SKILL.mdи рецепт опубликованы.
Ознакомьтесь со статьёй, страницей проекта и датасетом. Также подписывайтесь на нас в Twitter и не забудьте присоединиться к нашему сабреддиту о машинном обучении с аудиторией более 150 тыс. участников и подписаться на нашу рассылку. Постойте! Вы есть в Telegram? Теперь к нам можно присоединиться и в Telegram.
Хотите сотрудничать с нами для продвижения своего репозитория GitHub, страницы Hugging Face, выпуска продукта, вебинара и т. д.? Свяжитесь с нами
Переведено автоматически с английского. Оригинал статьи — по ссылке ниже.