Обыденное представление о Deep Learning состоит в том, что для достижения успеха нужно хорошо знать математику и уметь программировать на Python. Но все становится немного сложнее, как только мы начинаем говорить о реализации нейросетевых решений в железе, где критична производительность. Мы пообщались с руководителем направления российского Исследовательского центра Samsung Вячеславом Гарбузовым, чтобы понять, как ускоряют работу нейросетей на аппаратном уровне, при чем тут компиляторы и какие знания требуются в этой редкой профессии. И самое интересное - какие вакансии в его подразделении открыты в настоящий момент.

Слава, привет! Расскажи о себе, чем занимается твоя команда сейчас.

Привет! Я руковожу управлением разработки ПО для систем на кристалле Исследовательского центра Samsung. Мы занимаемся разработкой SDK для ускорения исполнения моделей глубинного обучения (Deep Learning)на процессорах Exynos.

Кто твои непосредственные заказчики?

Наша работа связана с компонентным бизнесом и нашим заказчиком является Samsung Semiconductor. Мы ближе к земле.

Правильно ли я понимаю, чтомобильныйпроцессор Exynosв основном используется в телефонах Samsung и больше нигде?

Вовсе нет. Exynos используется в смартфонах других производителей. Кроме того, Exynos - это не только мобильные системы на кристалле (SoC). Есть микроконтроллеры, компоненты Интернета вещей. Крупные игроки на автомобильном рынке тоже заинтересованы в наших продуктах.

Расскажи про новый Exynos и AI-ускоритель в нем

Разработкой Exynos SoCи SDK к нему занимается подразделение Samsung System LSI (large-scale integration - высокоинтегрированные чипы). Узнать подробнее про новый Exynos 2100 можно извидеопрезентации. В разделе AI and Camera кратко рассказывается, что такое AI-ускоритель. Это железо для ускорения работы нейросетей. Обучение сети производится заранее, а исполнением (inference) как раз занимается это железо.

Что такое inference, что значит выполнить сеть на устройстве? Есть нейросеть, она уже натренирована. На вход готовой нейросети мы подаем картинку с собачкой или кошечкой, а на выходе это устройство дает 0 или 1. То есть наш сопроцессор не занимается обучением нейросети самостоятельно, его задача просто отработать готовую сеть.

Для работы нейросетевого сопроцессора нужен программный инструментарий. Такой инструмент есть, он называется Samsung Neural SDK.

Для каких задач это всё используется?

Применения в телефоне в основном связаны с камерой: живой фокус, ночная съемка, Bixby Vision, обнаружение лиц, улучшающее картинку.

Здесь забавно, что в этом году в S21 добавили фичу для детектирования домашних животных. Раньше алгоритмы не узнавали собак и кошек и не могли их обработать красиво. И вот эта проблема теперь решена.

Расскажи, как устроен этот AI-ускоритель.

Он состоит из двух частей:

1. NPU (Neural Processing Unit - обработчик нейросетей). Фактически это ускоритель операций с тензорами. Он умеет быстро делать свертки (convolution), пулинги (pooling) - набор операций, популярных в глубинном обучении.

2. DSP (digital signal processor - цифровой обработчик сигналов).Это процессор, специализированный под выполнение определенных задач. Его разрабатывают изначально под конкретные алгоритмы. Ребята проектируют этот DSP под распознавание лиц или под более широкий круг задач.

Это единый кластер в составе одной системы на кристалле. Для него мы и разрабатываемSDK. У нас две команды, одна работает над NPU, другая, соответственно, над DSP.

Какие компиляторные задачи у вас с NPU?

Компилятор для NPU - это та штука, которая превращает граф на выходе Deep Learning-фреймворка в последовательность процессорных команд. Отличие от обычного компилятора в том, что мы генерируем код не для CPU, а для нейросетевого ускорителя. Это другой процессор со своим языком. И чтобы вся система работала быстрее, мы оптимизируем ее на уровне компилятора.

В чем суть оптимизации? По большей части это memory allocation (оптимизация работы с памятью) и instruction scheduling (параллелизм на уровне инструкций). Наш процессор может несколько инструкций выполнять одновременно, например, считать ту же самую свертку и загружать данные для свертки. Мы должны сгенерировать код для этого процессора так, чтобы оптимизировать работу с памятью и максимизировать параллелизм.

А что с DSP? Какие задачи там?

Это уже более-менее похоже на традиционный процессор. Если свертку наш NPU умеет делать на уровне железа, то здесь мы должны эту свертку описать на языке C++ и исполнить на DSP. Зачем нужен отдельный сопроцессор, чтобы выполнять ту же самую свертку? Например, NPU занят в какой-то момент, и мы хотим параллельно решать другую задачу. Некоторые операции мы в принципе на NPU выполнить не можем.

У нас достаточно простой DSP, основанный на VLIW-архитектуре (very long instruction word очень длинная машинная команда). Особенность нашего DSP в том, что он аппаратно достаточно простой, и от компилятора требуется серьезная оптимизация.Мы делаем на базе LLVM компилятор для этого DSP.

Поговорим о других вещах. Где ты работал до Samsung?

Непосредственно до Samsung я работал в Topcon Positioning Systems и в Lynx Software Technologies. Занимался разработкой RTOS и инструментов.

Где и на кого ты учился?

Учился в МГУ на физика. Занимался ускорителями элементарных частиц, электронов в частности. Занимался автоматизацией физического эксперимента, системой управления для промышленного ускорителя.

Как помогает образование физика в твоей профессии?

В профессии руководителя это очень сильно помогает, позволяет смотреть на вещи широко.

Работая в твоем отделе, насколько важно хорошо разбираться в железе?

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

А в глубинном обучении?

Базовое представление надо иметь. Я полагаю, что современные выпускники вузов это всё уже знают на определенном уровне. Это всегда хорошо иметь в бэкграунде. Например, курс Нейронные сети и компьютерное зрение Samsung Research Russia на Stepik я добавил в закладки, но пока не прошел. И кстати, вчера в рамках этого курса былалекцияна YouTube про Embedded Inference как раз на эту тему - "Мобильные архитектуры нейросетей и фреймворки для их запуска".

Когда мы начинали этот проект в 2018 году, мне сказали: нужен компилятор для Deep Learning. Нам потребовалось найти людей, которые одновременно умеют и в Deep Learning, и в железо, и в компиляторы. И это сложно, потому что таких людей очень мало. Потом мы поняли, что требование знания Deep Learning не столь критично, всё-таки заказчики от нас просили только компилятор.

С выпускниками каких вузов тебе интересно работать?

Мне приятно работать с выпускниками МФТИ, особенно с теми, которые прошли через базовые кафедры ИСП РАН или Intel. У нас в отделе достаточно много ребят из Intel. По факультетам - ФУПМ, ФРКТ. Если говорить о других вузах, то это и МГУ - забавно, что много моих знакомых компиляторщиков заканчивали физфак. Также это ВШЭ, где есть МИЭМ, там учат проектировать железо, FPGA. А компиляторы можно условно рассматривать как часть железа в принципе.

В нашем Исследовательском центре мы проводили вечернюю школуSamsung Compiler Bootcamp, и , в основном, в ней учились студенты из Бауманки, МГУ и Вышки.

На тему FPGA - полезно ли это изучать?

Как бэкграунд - да, это правильно.

А вообще, много ли таких центров в Москве, где занимаются компиляторами?

Intel, JetBrains, Positive Technologies, Huawei. Из российских - МЦСТ, которые Эльбрус, они тоже компиляторы делают. Например, Роман Русяев, наш коллега из Исследовательского центра Samsung и разработчик компиляторов, как раз оттуда пришел (см. егостатьюна Хабре о Concept-Based Polymorphism), он часто выступает на конференциях и пишет статьи.Он активный участник C++ Community. Например, вот пара его выступлений где затрагивается тема оптимизации при помощи компилятора :"Исключения C++ через призму компиляторных оптимизаций","Настоящее и будущее copy elision".

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

О каких мировых трендах в компиляторов можно сейчас говорить?

Можно выделить такие тренды:

1. Доминирование проекта LLVM

2. Обобщение компилятора для различных предметных областей посредством универсального промежуточного представления (MLIR)

3. Объединение различных инструментов для анализа и преобразования кода (компиляторов, анализаторов, performance estimators, линтеров и пр.) в рамках одного проекта

4. Активные попытки использования высокой науки в промышленных компиляторах (formal verification, polyhedral optimizations, более подробно встатье)

Какие требования к соискателям, будущим разработчикам компиляторов, ты бы озвучил?

Обязательные требования: знание С/С++ на хорошем уровне. Понимание того, как устроены компиляторы, опыт их разработки. Понимание устройства операционной системы. Умение разбираться в больших объемах чужого кода. Навыки отладки embedded-устройств. Знание практик программной инженерии - непрерывная интеграция, ревизия кода, отслеживание задач. Владение скриптовыми языками - Bash или Python.

Помимо технических требований, важно умение работы в команде, быть адекватным человеком. Нужно иметь широкий кругозор, быть профессионалом. Уметь быстро адаптироваться - мы работаем на крайне конкурентном рынке, требования заказчиков меняютсячасто и неожиданно. Хорошо знать английский язык. Уметьвежливо общаться. Понимать, что мы предоставляем сервис. Кому-то это не нравится, а кому-то вполне нормально. Не нужно быть токсичным.

Работая в международной компании, как складывается коммуникация с иностранными коллегами? Как вы решаете вопросы взаимодействия с коллегами в пандемию?

Мы активно взаимодействуем с командами из других стран Корея, Китай, Индия, Израиль, США. До карантина они частенько приезжали к нам в гости, а мы к ним.

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

Какие книжки о компиляторах ты бы посоветовал?

Коллеги рекомендуют начинать с "Modern Compiler Implementation in ML", автор Andrew W. Appel.

Какие твои любимые книги о программировании вообще?

Керниган и Ричи Язык программирования С. Они классные. Еще Керниган и Пайк, Практика программирования. Там настолько все четко сделано.

Что скажешь об онлайн-курсах?

Если говорить о курсах по смежным темам, то по глубинному обучению это курс Samsung о нейронных сетях в компьютерном зрении, и известный курс Эндрю на (Andrew Ng). Полезенкурс по С++от Яндекса.

LLVM или GCC - что полезнее изучать?

LLVM. Он более распространенный, и порог вхождения считается ниже.Кроме того, в этом проекте активно используются последние нововведения языка C++ и современные практики программирования. Мы, кстати, сейчас ищем разработчика, который знает LLVM.

Какие инструменты командной работы используете?

Используемgit, точнее корпоративный github. Важно сказать, что мы делаем Code Review, и это неотъемлемая часть работы наших инженеров. Здорово, что все друг другу помогают и делятся знаниями. Также мы делимся знаниями с помощью Confluence, у нас есть вики-портал с внутренней документацией по нашим разработкам. Есть Jira для отслеживания задач. И есть свой чат на основе Mattermost, то есть практически Slack - без него на удаленке мы бы вообще не выжили. Исповедуем ContinuousIntegration, а также автоматизируем все, что можно автоматизировать.

А что насчет методов Agile?

Мы не привязаны к какой-то конкретной методологии. Берем полезные практики, которые подходят нашему проекту, из разных методологий. Например, из скрама мы берем Daily Scrum - ежедневные собрания. У нас есть итеративное планирование. И так далее.

Не могу не спросить. А вот во время пандемии, когда все по видео общались, вы все равно Daily Scrum стоя проводили?

Ну нет, всё-таки все сидели.

Сколько у вас длится Daily Scrum?

От 15 минут до часа, потому что иногда он перетекает в технические дискуссии.

Что еще интересного бывает?

Регулярно проходят онлайн-семинары. Коллеги из разных центров компании рассказывают о своих задачах, обсуждаются технические решения. Мы тоже участвуем, конечно. Также проводим внутренние семинары для сотрудников московской команды. Обмениваемся знаниями, изучаем опыт других. Например, в настоящий момент у нас в Исследовательском центре проходит серия семинаров про алгоритмы аллокации памяти.

----

А сейчас самое интересное: ВАКАНСИИ!

У нас открыты две вакансии, соответственно поNPUи поDSP. Если вас заинтересовало, откликайтесь на вакансию прямо на HeadHunter, и возможно, мы с вами встретимся на собеседовании.

Вопросы задавала: Татьяна Волкова, куратор трека по Интернету вещей социально-образовательной программы для вузов IT Академия Samsung

Отвечал: Вячеслав Гарбузов, руководитель направления, российский Исследовательский центр Samsung

В предыдущей части статьи мы написали реализацию простейшей нейросети в виде JS класса. Теперь давайте попробуем дать ей настоящее задание. Сценарий будет следующим: пользователь будет рисовать в определенном блоке веб-страницы смайл, а наша нейросеть попробует определить грустный он или веселый. Давайте приступим.

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

<!doctype html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport"       content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <script src="NeuralNetwork.js"></script> <title>Sad Or Happy?</title></head><body> <div id="wrapper">   <canvas width="400" height="400" id="paintField"></canvas>   <div id="controls">     <button class="control" id="happy"></button>     <button class="control" id="sad"></button>     <button class="control" id="clear">       Clear     </button>     <button class="control" id="train">       Train     </button>     <button class="control" disabled id="predict">       Predict     </button>   </div> </div></body><style>   #wrapper {       width: 400px;       margin: 0 auto;   }   #paintField {       height: 400px;       width: 100%;       border: 1px solid black;   }   #controls {       display: grid;       grid-gap: 10px;       grid-template-columns: 1fr 1fr;       margin-top: 30px;   }   #clear, #train, #predict {       grid-column: 1 / -1;   }   .control {       font-size: 20px;       padding: 4px;       cursor: pointer;   }</style><script></script></html>

Коротко пройдемся по элементам управления.

Canvas с id paintField - это канва размером 10 на 10 блоков по 40 пикселей каждый. На ней пользователь с помощью мыши будет рисовать смайл для обучения сети или предсказания от нее.

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

Кнопка Clear будет очищать поле ввода. Вдруг нам не понравилось то, что мы нарисовали.

Кнопка Train будет запускать процесс обучения.

И, наконец, кнопка Predict будет показывать что думает нейросеть по поводу нашего рисунка. Она станет доступной после обучения.

Теперь переходим в пустой тег <script> и начинаем шаг за шагом его заполнять.

const canvas = document.querySelector('#paintField');const clearBtn = document.querySelector('#clear');const sadBtn = document.querySelector('#sad');const happyBtn = document.querySelector('#happy');const trainBtn = document.querySelector('#train');const predictBtn = document.querySelector('#predict');const ctx = canvas.getContext('2d');const paintField = new Array(100);const trainData = [];const NN = new Network(100, 2);let mouseDown = false;let happyCount = 0;let sadCount = 0;NN.learningRate = 0.8;

Здесь мы записали в переменные ссылки на элементы управления для более удобного доступа к ним и объявили несколько ключевых вещей:

paintField - плоский массив для хранения состояния нашего рисунка. Он состоит из 100 элементов, каждый элемент соответствует одному из блоков на нашей канве.

trainData - сюда мы будем складывать данные для обучения сети.

NN - собственно наша нейросеть. У нее будет 100 нейронов во входном слое - по одному на каждый элемент массива paintField и 2 нейрона в выходном слое. Первый будет говорить нам о вероятности того, что это веселый смайл, второй - что грустный.

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

Теперь добавим несколько функций.

function drawGrid() { ctx.strokeStyle = '#CCC' for (let i = 1; i < 10; i++) {   ctx.moveTo(0, i * 40);   ctx.lineTo(400, i * 40);   ctx.moveTo(i * 40, 0);   ctx.lineTo(i * 40, 400); } ctx.stroke();}function clearCanvas() { ctx.fillStyle = '#FFF'; ctx.fillRect(0, 0, 400, 400); drawGrid();}function drawSquare(row, column, color) { ctx.fillStyle = color; ctx.fillRect(column * 40 + 1, row * 40 + 1, 38, 38);}function draw(event) { const rowIndex = Math.floor(event.offsetY / 40); const columnIndex = Math.floor(event.offsetX / 40); const arrayIndex = rowIndex * 10 + columnIndex; paintField[arrayIndex] = 1; const color = paintField[arrayIndex] ? 'green' : 'white'; drawSquare(rowIndex, columnIndex, color);}function clearField() { paintField.fill(false); clearCanvas(ctx)}function updateInterface() { happyBtn.innerText = `=) ${happyCount}`; sadBtn.innerText = `=( ${sadCount}`;}function storeResult(value) { trainData.push([[...paintField], value]); updateInterface()}

drawGrid - рисует сетку на канве.

clearCanvas - очищает канву от наших художеств.

drawSquare - рисует цветной блок по заданным координатам сетки.

draw - функция, в которую мы будем передавать событие мыши. Она по координатам курсора определит номер блока, запишет в массив единицу под соответствующим индексом, и покрасит соответствующий блок в зеленый цвет.

clearField - очищает массив данных и канву.

updateInterface - обновляет надписи на кнопках, в соответствии с тем, сколько грустных и веселых смайлов мы уже показали нашей нейросети.

storeResult - добавляет текущий рисунок в массив данных для обучения.

И, наконец, навесим обработчики на элементы управления и выполним начальную инициализацию.

document.addEventListener('mousedown', (e) => { mouseDown = true;});document.addEventListener('mouseup', (e) => { mouseDown = false;});canvas.addEventListener('mousemove', (e) => { if (!mouseDown) {   return; } draw(e);});clearBtn.addEventListener('click', () => { clearField();});happyBtn.addEventListener('click', () => { happyCount += 1; storeResult([1, 0]); clearField();});sadBtn.addEventListener('click', () => { sadCount += 1; storeResult([0, 1]); clearField();});predictBtn.addEventListener('click', () => { NN.input = [...paintField]; const [happiness, sadness] = NN.prediction; alert(`I think it's a ${happiness > sadness ? 'happy' : 'sad'} face!\n  Happiness: ${Math.round(happiness * 100)}% Sadness: ${Math.round(sadness * 100)}%`);});trainBtn.addEventListener('click', () => { NN.train(trainData, 1000).then(() => {   predictBtn.disabled = false;   alert('Trained!'); })});clearField();updateInterface();

Теперь точно все. Можем открывать страницу в браузере и начинать экспериментировать. Нарисовали грустный или веселый смайл, нажали соответствующую кнопку, повторили. Старайтесь добавлять примерно одинаковое количество кейсов, и добавляйте их не слишком мало - так сеть ничему не научится, и не слишком много - так обучение будет идти слишком долго. Когда решите что уже достаточно, жмите Train и ожидайте соответствующее сообщение. Появилось? Все! теперь наша сеть обучена и мы можем нарисовать смайл и спросить на что он похож с помощью кнопки Predict.

Thats all, Folks!

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

Посмотреть на результат в деле вы можете по ссылке

Весь код можно найти в репозитории

Спасибо за внимание.

Как я говорил во вступлении к первой части, я frontend-разработчик, и мой родной язык - JavaScript, реализовывать нашу нейросеть в рамках данной статьи мы будем именно на нем. Для начала несколько слов о структуре. За исключением различных вычисляемых свойств и методов, объект нейросети будет содержать в себе массив слоев layers, каждый слой будет содержать массив нейронов neurons, а каждый нейрон, в свою очередь, будет содержать массив входов - связей с нейронами предыдущего слоя inputs. Также, так как у нас есть вещи общие для всей сети, такие как активационная функция, ее производная и learning rate, а получать доступ до них нужно из каждого нейрона, условимся, что в нейроне будет ссылка _layer на слой, которому он принадлежит, а у слоя будет _network - ссылка на саму сеть.

Давайте пойдем от частного к общему и сначала опишем класс входа для нейрона.

class Input { constructor(neuron, weight) {   this.neuron = neuron;   this.weight = weight; }}

Тут все довольно просто. У каждого входа есть числовой вес и ссылка на нейрон предыдущего слоя. Идем далее. Опишем класс самого нейрона.

class Neuron { constructor(layer, previousLayer) {   this._layer = layer;   this.inputs = previousLayer     ? previousLayer.neurons.map((neuron) => new Input(neuron, Math.random() - 0.5))     : [0]; } get $isFirstLayerNeuron() {   return !(this.inputs[0] instanceof Input) } get inputSum() {   return this.inputs.reduce((sum, input) => {     return sum + input.neuron.value * input.weight;   }, 0); } get value() {   return this.$isFirstLayerNeuron     ? this.inputs[0]     : this._layer._network.activationFunction(this.inputSum); } set input(val) {   if (!this.$isFirstLayerNeuron) {     return;   }   this.inputs[0] = val; } set error(error) {   if (this.$isFirstLayerNeuron) {     return;   }   const wDelta = error * this._layer._network.derivativeFunction(this.inputSum);   this.inputs.forEach((input) => {     input.weight -= input.neuron.value * wDelta * this._layer._network.learningRate;     input.neuron.error = input.weight * wDelta;   }); }}

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

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

$isFirstLayerNeuron - вычисляемый флаг, который будет говорить нам о том, что это нейрон входного слоя. Некоторые операции производятся во всех слоях, кроме входного, так что он пригодится нам в дальнейшем.

inputSum - readonly свойство, которое предоставляет нам сумму всех входных сигналов (значений, на выходе нейронов предыдущего слоя) с примененными к ним весами.

value - выходное значение нейрона. Для всех слоев, кроме входного, это значение активационной функции от inputSum.

Также мы объявим два сеттера:

input - нужен для того, чтобы устанавливать входные значения для нейронов первого слоя.

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

Теперь давайте посмотрим на класс слоя нейросети. Тут все намного проще.

class Layer { constructor(neuronsCount, previousLayer, network) {   this._network = network;   this.neurons = [];   for (let i = 0; i < neuronsCount; i++) {     this.neurons.push(new Neuron(this, previousLayer));   } } get $isFirstLayer() {   return this.neurons[0].$isFirstLayerNeuron; } set input(val) {   if (!this.$isFirstLayer) {     return;   }   if (!Array.isArray(val)) {     return;   }   if (val.length !== this.neurons.length) {     return;   }   val.forEach((v, i) => this.neurons[i].input = v); }}

В конструктор передается число - количество нейронов, в соответствии с ним мы заполним массив neurons слоя, ссылка на предыдущий слой, чтобы передать ее в конструктор нейрона, и ссылка на саму сеть.

Также у нас есть $isFirstLayer - вычисляемый флаг, который говорит нам о том, входной ли это слой, и сеттер input, который после проверок на то, что мы вызываем его на входном слое и на вход получаем массив нужной длины, устанавливает входные данные. Он нужен для того, чтобы заполнить значениями входной слой.

И, наконец, опишем класс самой нейросети

class Network { static  sigmoid(x) {   return 1 / (1 + Math.exp(-x)); } static sigmoidDerivative(x) {   return Network.sigmoid(x) * (1 - Network.sigmoid(x)); } constructor(inputSize, outputSize, hiddenLayersCount = 1, learningRate = 0.5) {   this.activationFunction = Network.sigmoid;   this.derivativeFunction = Network.sigmoidDerivative;   this.learningRate = learningRate;   this.layers = [new Layer(inputSize, null, this)];   for (let i = 0; i < hiddenLayersCount; i++) {     const layerSize = Math.min(inputSize * 2 - 1, Math.ceil((inputSize * 2 / 3) + outputSize));     this.layers.push(new Layer(layerSize, this.layers[this.layers.length - 1], this));   }   this.layers.push(new Layer(outputSize, this.layers[this.layers.length - 1], this)); } set input(val) {   this.layers[0].input = val; } get prediction() {   return this.layers[this.layers.length - 1].neurons.map((neuron) => neuron.value); } trainOnce(dataSet) {   if (!Array.isArray(dataSet)) {     return;   }   dataSet.forEach((dataCase) => {     const [input, expected] = dataCase;     this.input = input;     this.prediction.forEach((r, i) => {       this.layers[this.layers.length - 1].neurons[i].error = r - expected[i];     });   }); } train(dataSet, epochs = 100000) {   return new Promise(resolve => {     for (let i = 0; i < epochs; i++) {       this.trainOnce(dataSet);     }     resolve();   }); }}

В конструктор мы передаем размер входного и выходного слоев, количество скрытых слоев и learning rate.

Сеттер input - просто сахар, по сути вызывает одноименный сеттер входного слоя.

Вычисляемое свойство prediction - то, ради чего все это делалось. Выдает нам предсказание нейросети в виде массива значений нейронов выходного слоя на основе установленных входных данных.

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

Метод train - производит необходимое количество итераций обучения сети, так называемых эпох. Оформлен в виде промиса просто для красивого синтаксиса. Для того, чтобы иметь возможность знать когда обучение завершено с помощью .then, хоть весь наш код и так будет выполняться в main thread.

Теперь у нас есть все, чтобы проверить нашу нейросеть в деле. Давайте сделаем это на классическом примере - попытаемся обучить сеть выполнять операцию XOR.

Для начала создадим инстанс сети с двумя входными нейронами и одним выходным.

const network = new Network(2, 1);

Зададим набор данных для обучения:

const data = [ [[0, 0], [0]], [[0, 1], [1]], [[1, 0], [1]], [[1, 1], [0]],];

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

network.train(data).then(() => { const testData = [   [0, 0],   [0, 1],   [1, 0],   [1, 1], ]; testData.forEach((input, index) => {   network.input = input;   console.log(`${input[0]} XOR ${input[1]} = ${network.prediction}`) });});

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

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

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

Джеффри Хинтон начал с шутки: Итак, около года назад я пришёл домой на обед и сказал: Думаю, я наконец понял, как работает мозг, а моя 15-летняя дочь сказала: Ох, папа, опять это.... Публика засмеялась. Хинтон продолжил: Итак, вот как он работает. Раздалось ещё больше смеха.

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

Но маловероятно, что биологический мозг работает по алгоритму обратного распространения. Дело не только в том, что мозг способен обобщать и учиться лучше и быстрее современных систем искусственного интеллекта, рассказывает Йошуа Бенжио, учёный в области компьютерных наук из Монреальского университета и директор Квебекского института искусственного интеллекта, а также один из организаторов семинара 2007 года.По ряду причин обратное распространение несовместимо с анатомией и физиологией мозга, особенно мозга с корой.

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

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

Мозг огромная загадка. Создаётся общее впечатление, что, если мы раскроем некоторые из его принципов, это может оказаться полезным для ИИ, рассказывает Бенжио, но разрешение загадок мозга также имеет самостоятельную ценность.

Обучение через обратное распространение

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

Срабатывающие вместе нейроны соединены.

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

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

Правило Хебба это очень узкий, специфический и не очень чувствительный метод работы с информацией об ошибках, рассказывает Дэниел Яминс, компьютерный нейробиолог и учёный в области компьютерных наук из Стэнфордского университета.

Тем не менее, это правило было лучшим правилом обучения в нейробиологии, и оно вдохновило на разработку первых искусственных нейронных сетей в конце 1950-х годов, ещё до того, как стало доминировать в этой науке.

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

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

Однако даже в 1960-х годах было очевидно: чтобы решать задачи сложнее, между входным и выходным слоями требуется один или несколько скрытых слоёв нейронов. Никто не знал, как эффективно обучать искусственные нейронные сети со скрытыми слоями до 1986 года, когда Джеффри Хинтон, Дэвид Румелхарт (ныне покойный) и Рональд Уильямс (сегодня работающий в Северо-Восточном университете) опубликовали алгоритм обратного распространения ошибки.

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

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

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

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

Чего не может мозг?

Изобретение обратного распространения ошибки мгновенно вызвало протест некоторых нейробиологов, заявивших, что в биологическом мозге оно не будет работать никогда. Самым известным скептиком был лауреат Нобелевской премии Фрэнсис Крик, один из первооткрывателей структуры ДНК, позже ставший нейробиологом. В 1989 году Крик писал: Что касается процесса обучения, маловероятно, что мозг в самом деле использует обратного распространения.

Обратное распространение считается биологически неправдоподобным по нескольким основным причинам.

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

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

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

Любое биологически правдоподобное правило обучения также должно подчиняться ограничению: нейроны получают доступ к информации только от соседних нейронов; в случае обратного распространения может потребоваться информация от более удалённых нейронов. Итак, если вы возьмёте обратное распространение и букву, мозг не сможет ничего вычислить, рассказывает Бенжио.

Тем не менее, Хинтон и ещё несколько учёных немедленно взялись за работу над биологически правдоподобными вариациями обратного распространения.

Первая статья, в которой утверждается, что мозг выполняет [что-то вроде] обратного распространения, примерно так же стара, как само обратное распространение, рассказывает Конрад Кординг, компьютерный нейробиолог из Университета Пенсильвании.

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

Биологическая реалистичность алгоритма

Возьмём, к примеру, одно из самых странных решений проблемы переноса веса, в 2016 году любезно предоставленное Тимоти Лилликрэпом из Google DeepMind в Лондоне и его коллегами.

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

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

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

Оказалось, подход не так плох, как вы могли подумать, рассказывает Яминс, по крайней мере в простых задачах.

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

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

Обратное распространение можно рассматривать как один набор нейронов, выполняющих логический вывод, и другой набор нейронов, выполняющих вычисления, чтобы обновить синаптические веса. Идея Хинтона заключалась в том, чтобы работать над алгоритмами, в которых каждый нейрон выполнял бы оба набора вычислений. Именно об этом [и] говорил Джефф в 2007 году, рассказал Бенжио.

Основываясь на работе Хинтона, в 2017 году команда Бенжио предложила правило обучения, которое требует нейронной сети с повторяющимися связями (то есть если нейрон A активирует нейрон B, то нейрон B, в свою очередь, активирует нейрон A. Если в такую сеть поступает какой-либо ввод, вызывая вибрацию сети, поскольку каждый нейрон реагирует на толчки и притяжение своих непосредственных соседей.

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

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

Прогнозирование восприятия

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

Берен Миллидж, докторант Эдинбургского университета и приглашённый научный сотрудник в Университете Сассекса, а также его коллеги согласовывали новый взгляд на восприятие прогнозное кодирование, с требованиями обратного распространения ошибки.

Прогнозное кодирование, если оно настроено определённым образом, даст вам биологически правдоподобное правило обучения, рассказывает Миллидж.

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

Правило Хебба это очень узкий, специфический и не очень чувствительный способ работать с информацией об ошибках. Дэниел Яминс, Стэнфордский университет

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

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

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

Непохоже, что мозг думает так: На меня прыгнул тигр, позволь мне сделать 100 повторений назад и вперёд, вверх и вниз по моему мозгу, рассуждает Миллидж. Тем не менее, если допустима некоторая неточность, прогнозное кодирование может быстро давать полезные ответы.

Пирамидальные нейроны

Некоторые учёные взялись за самую суть дела: построения моделей, подобных обратному распространению, на основе известных свойств отдельных нейронов. Обычные нейроны имеют дендриты, собирающие информацию от аксонов других нейронов. Дендриты передают сигналы телу клетки нейрона, там сигналы интегрируются. Это приводит (или не приводит) к спайку или потенциалу действия, выходящему из аксона нейрона на дендриты постсинаптических нейронов.

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

Модели, независимо разработанные Кордингом в 2001 году, а недавно Блейком Ричардсом и его коллегами из Университета Макгилла и Квебекским институтом искусственного интеллекта, показали, что пирамидальные нейроны могут формировать базовые единицы сети глубокого обучения, одновременно выполняя вычисления прямого и обратного проходов.

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

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

Роль внимания

Неявное требование к использующей обратное распространение глубокой сети это учитель, то есть что-то, что вычисляет допущенную сетью нейронов ошибку. Но в мозгу нет учителя, который говорит каждому нейрону в моторной коре: Ты должен быть включён, а ты должен быть выключен, рассказывает Питер Роэльфсема из Нидерландского института нейробиологии в Амстердаме.

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

Это очень избирательный сигнал обратной связи, рассказывает Роэльфсема. Это не сигнал об ошибке. Он просто говорит всем этим нейронам: вы в ответе [за действие].

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

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

Такие действия наполняют мозг нейронными модуляторами, рассказывает Роэльсема. Уровни дофамина действуют как глобальный сигнал подкрепления.

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

Оказывается, вы получаете обратное распространение ошибки. По сути, вы получаете то же уравнение, рассказывает он, но теперь оно биологически правдоподобно.

Команда представила эту работу на онлайн-конференции Neural Information Processing Systems в декабре. Мы можем обучать глубокие сети, рассказал Роэльфсема.

Это всего в два-три раза медленнее обратного распространения.

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

Тем не менее конкретные эмпирические доказательства того, что биологический мозг использует эти механизмы, остаются неуловимыми. Я думаю, что нам всё ещё чего-то не хватает, рассказал Бенжио. По моему опыту, это может быть мелочь, может быть, несколько изменений в одном из существующих методов, действительно важных изменений.

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

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

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

Если вас привлекает построение нейросетей, то у нас в SkillFactory как раз скоро стартует новый набор на продвинутый курсMachine Learning и Deep Learning, где вы сможете научиться работать с нейросетями, под руководствомопытных менторов.

Узнайте, как прокачаться в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

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

Neural Shit Bot

Телеграм-бот @NeuralShit помогает придумать дегенератские поздравления c 8 марта с помощью нейросетей StyleGAN2 и AiTextgen. Каждое поздравление сопровождается не менее креативной картинкой. Например, вот:

Генератор открыток с8 Марта

Более культурный сервис генератор открыток на 8 Марта разработали Work Solutions: worksolutions.ru/neuro-march. "Мы обучили нейросеть на тысячах фотографий с цветочками, а также научили ее генерировать поздравительный текст. Теперь она может создавать новые уникальные нейро-открытки!" - говорится в тексте на сайте. После создания открытки можно тут же отправить её адресату в соцсетях.

Яндексовский генератор открыток

Сервис поможет придумать более-менее персональное поздравление, не похожее на эти все здоровья, счастья, любви. Норм вариант, чтобы придумать массовую открытку для рассылки в Ватсапе: yandex.ru/lab/postcard

Первые два поздравления получились логичными, а на третий раз получилась открытка-угроза:

Всем уникальности, эксклюзивности и милых открыток! Да пребудет с нами нейронка.

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

Сетап

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

Зачем вообще оно нужно? Если вы все знаете, то переходите сразу к фазе описания выбора мной компонентов. Или читайте дальше! Сервер такой же компьютер, как тот, что стоит у вас на столе, но рассчитанный на долгую нагрузку и собирают его обычно из других деталей. Разница примерно как с автомобилем массового автопрома и спецтехникой вроде грузовика. Он может не быть быстрее, но должен выдерживать большую нагрузку (количество пользователей) и дистанции (время работы под нагрузкой для серверов это могут быть годы). Зачем оно нам? Мы создаем высокополигональные (~1 млн) 3D модели для игр и кино на основе фото, и сейчас занимаемся разработкой инновационных алгоритмов на основе машинного обучения для этой задачи.

Изучив референс, который показал мне мой коллега, я понял, что человек там собрал не сервер, а просто мощный игровой компьютер (какой и вы можете завтра собрать или купить в магазине), но зачем-то вставил туда процессор для сервера. В общем дальше больше. Пока я думал, какая сборка была бы оптимальна, выяснилось, что неплохо бы вставить в наш будущий комп не одну, не две, а ВОСЕМЬ высокопроизводительных видеокарт. Такое обычно геймерам даже не снилось. Почти что майнинг ферма.

Что за задачи хотели мы решать, и каковы вообще требования к компьютеру для машинного обучения? Если обычный компьютер собирается вокруг процессора: главного и универсального вычислительного блока в нем, то для машинного обучения первостепенна видеокарта. Это такой еще один компьютер, который вставляется в ваш компьютер, чтобы помогать процессору решать специфические задачи. Например, строить красивую графику для современных компьютерных игр. Поэтому о видеокарте сейчас мечтает любой подросток (спросите, если у вас есть дети). Но также видеокарта может помогать процессору очень быстро умножать матрицы. Да, прямо как вы на первом курсе технического вуза, видеокарта на самом перемножает матрицы, только не 10 в час, а миллиарды в секунду. В этом плане процессор, как и вы, пользуется правилом строка на столбец, а видеокарта умеет выдавать ответ, как человек дождя, сразу. Если кто не помнит, там у героя талант выполнять мгновенные вычисления (спойлер). Но, как и герою фильма, все остальное дается видеокарте с трудом, и это делает процессор.

В общем, обычно в компьютере может не быть выделенной видеокарты, но тут их должно было быть несколько. Причем именно RTX 3090!? Это не такая простая задача, как кажется.

Изучив вопрос, я пришел к выводу, что невпихуемые восемь прожорливых видеокарт можно впихнуть только на серверной платформе (http://personeltest.ru/aways/www.gigabyte.com/Enterprise/GPU-Server) для GPU. Но даже если такие вообще можно будет найти в России, то стоить это будет ровно полмиллиона, просто за корпус и материнку (без карт и процессоров). Тогда я пораскинул мозгами и предложил три варианта, каждый содержал решение своей задачи.

Первая опция

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

Была выбрана такая связка процессор плюс материнка, а сама сборка вышла на 100 тысяч рублей, без учета цены видеокарты.

Прежде чем я опишу более сложные варианты, нужно сказать об особенностях процессора. Для подключения видеокарты мы используем линию PCI Express. По сути это такой же интерфейс как USB, с которым все знакомы, но только высокоскоростной и внутри самого компьютера. Причем устроен он весьма забавно. Представьте себе автотрассу. У нее есть полосы и ограничение скорости. Вот линии PCI это один в один, как трасса, где количество машин, проезжающих в секунду, определяет скорость передачи информации. Если мы возьмем трассу в четыре полосы, то машин проедет в два раза быстрее, но то же самое произойдет, если мы сделаем каждую полосу ровно в два раза быстрее. За количество полос у PCI отвечает так называемое количество шин (проводников), а за скорость поколение PCI.

Таким образом фразу: PCI-E 3.0 4x написанную на устройстве нужно читать как данное устройство займет четыре полосы трассы с максимальной скоростью 3. Видеокарты могут занимать до 16 линий PCI, причем это число может быть и меньше. То есть чисто технически видеокарта может работать и от одной линии. Именно так поступают майнеры, когда подключают 16 видеокарт к одному слоту. Они просто разбивают огромную трассу на 16 полос, жертвуя скоростью, зато не приходится покупать 16 компов. Для их приложений скорость не так нужна. В целом, правило пальца такое. Допустим, если карта подключена в 16 линий то это 100% производительности, тогда как показывает практика, например, для игр, при использовании восьми линий, она теряет 5% производительности, а при использовании четырех уже около 20-30% или больше. Для разных приложений эти цифры немного отличаются. У предложенного процессора AMD Ryzen 7 Vermeer 5800X всего 24 линий PCI, что является стандартным числом для даже очень дорогих процессоров для настольных ПК. 24 линий более чем достаточно для подключения одной-двух видеокарт и еще какой-то периферии вроде звуковой карты и NVME накопителя. Сложно представить, чтобы их не хватило. Но вот воткнуть в него 4 видеокарты без особых потерь уже не получится. Машины просто начнут стоять в пробках. Тут на ум приходит вторая опция.

Вторая опция

Собрать компьютер вокруг серверного процессора. Теперь уже это кажется оправданным. У него количество линий PCI может измеряться не десятками, а сотнями (обычные смертные этим не пользуются, а вот серверное железо да). Таким образом, если найти подходящую материнскую плату, то можно будет гарантированно разместить туда много видеокарт. Был выбран пограничный вариант: AMD Ryzen Threadripper 2 2920X c аж 64 линиями PCI 3.0. Причем он так и позиционируется производителем как серверный процессор, но адаптированный для простых нормизов, которым нужна какая-то специфика промышленного железа. Например, для высокопроизводительных станций для видеомонтажа, где должно работать несколько человек и т. д. в материнскую плату, подобранную для него (ASRock X399 Taichi), влезало 4 видеокарты без адаптеров. Что уже лучше, чем обычный игровой комп, при стоимости такой сборки всего на 50 тысяч дороже обычной игровой (150 вместо примерно 100). Но и процессор тут уже совсем другой ценовой категории, пусть и довольно дешевый среди своих напарников по цеху. При цене в 60-70 тысяч этот монстр выдает аж 24 потока, что кажется и немного для его цены, но если добавить поддержку ECC памяти, много шин PCI, большой кэш, получается приятно, если учитывать то, ради чего мы его берем.

Третий и последний вариант

Купить сервер вроде такого. Отдать один раз 500 тысяч и доставлять в него карты до восьми максимальных. (Предыдущий вариант при достойной процессорной нагрузке оперирует до четырех видеокартразумеется, если постараться и обеспечить нормальное охлаждение).

Выбор

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

Итоговая сборка

Ниже приведу итоговую сборку как мы ее заказали:

Итого: 164 тысячи рублей. Вроде неплохо, учитывая что цена на RTX 3090 на этот момент стоили уже 220 тысяч, и я убедил, что, возможно, 4х видеокарт может и хватить. Теперь по компонентам отдельно, как я думал о них до сборки:

Процессор

2920X обычно не востребованный из-за разницы со своими старшими братьями постепенно вытеснялся 3м поколением тредрипперов как раз упал в цене, это был хороший выбор (как показалось). Отдельная тема это установка процессора "Threadripper". Самые важные моменты: отвертка, которая идет в комплекте не обычная, а заряженная пружиной, чтобы контролировать натяжение, поэтому вскрывать сокет и устанавливать процессор нужно ТОЛЬКО ей. И только в порядке, предписанном на крышке розетки процессора (сокета). На рисунке видно порядок установки.

Материнская плата

ASRock X399 Taichi, средний выбор для такого железа обладала всеми необходимыми приятностями: 8 слотов для памяти, зачем-то встроенный wifi...

Но с материнской платой вышло больше всего проблем. Представьте ваше лицо, когда вы на стенде собираете компоненты стоимостью 150К включаете их, а они не дают признаки жизни Но я не растерялся, понял что блок питания не подает питание на материнку. На плате работало служебное 3В питание, была исправна батарейка. Сброс CMOS не помог. Коротких замыканий ни на какой линии питания не было. Меня сбил сначала тот факт, что от служебного питания на ней запитывалась подсветка. Начал грешить на блок питания, но нет. Проверив его по методике ниже, оказалось, что материнская плата все же не подает сигнал на исправный блок питания. Моя интуиция подсказала, что скорее всего это неправильное поведение. В гарантийном отделе KNS меня стали уверять что дело в неправильной версии BIOS материнской платы, и я, не заметив на самой плате наклейку, утверждающую, что BIOS последний, поехал искать где его обновить. Возле гарантийного центра меня встретили только очень пугающие ребята. Один немолодой человек, увидев у меня материнскую плату с символикой AMD, начал буквально кричать на весь ТЦ: AMD для нас не компьютер, а другие предложили обновить его за 3000р., но при условии что у меня будет подходящий процессор. Как будто был бы у меня процессор, я бы не смог обновить его сам, при условии, что для таких плат для этого просто нужно вставить флешку с кодом. Кто не знает, код BIOS (базовая система ввода вывода) отвечает за процесс запуска и первичную настройку и тест процессора, еще до старта любой операционной системы. Проблема, что если версия биоса старая, то компьютер просто не понимает, что в него вообще вставлен процессор. Тогда самый простой вариант вставить процессор более старой серии и обновить BIOS. Проблема в том, что процессоров Ryzen Threadripper первого поколения в москве в сервисных центрах почти не найти, что добавляло сложность моим изысканиям. Была ли это попытка, чтобы я пролетел с двухнедельным сроком возврата бракованного товара или нет, я не знаю. В определенном сервисе на Савеловской мне совершенно бесплатно подтвердили, что BIOS на плате самый свежайший, и там повторно оно не завелось уже на их стенде, но с моим процессором. И вот в самый последний день я отвез это в KNS и, уже уверив их, что их гипотеза не верна (и было бы странно, ибо плата вообще не стартовала блок питания), я отдал плату на гарантию. Через две недели они дождались свой процессор, и оказалось, что моя теория верна и плата мертва. Еще через день мы получили новую и продолжили сборку!

Охлаждение процессора

Охлаждать процессор, выделяющий тепла почти как четверть бытового обогревателя, предложено было кулером Be quiet Dark Rock Pro TR4, специально созданного для такого горячего процессора. Из особенностей скажу, что обычно элитная фирма Be quiet!, в этот раз немного разочаровала: установка кулера очень не эргономична для того, чтобы его закрепить или снять, нужно сначала вынуть центральный кулер (у него их три), потом особой комплектной длинной отверткой через особые отверстия отвинтить болты, только после этого отпустит клемму, которая и держит процессор. Вы можете посмотреть про этот кулер тут.

Блок питания

Выбор блока питания. Самая мистифицированная деталь компьютера, а так же самая частая ошибка: экономия на блоке питания. Причем, как правило, людям либо кажется, что больше мощности равно лучше, кому-то кажется, что много мощности плохо предлагаю разобраться. Блок питания берет переменный ток из розетки и преобразовывает его в набор постоянных напряжений (3.3,5,12,-12 Вольт). Все эти стандарты питания важны для разных компонентов, но самая важная линия это 12 Вольт. Именно от нее будут питаться все самые прожорливые компоненты. Именно от 12В питается процессор и видеокарта. Что же такое амперы на блоке питания? Ну, вы можете думать, что вольты это просто тип питания, примерно, как октановое число бензина. Вы приезжаете на бензоколонку и ожидаете увидеть 92,95 бензин. Точно так же работает и блок питания. Он предоставляет разное топливо. Причем напряжение, как и бензин, может быть плохим. Например, если под нагрузкой 12 Вольт превратились в 11, (а карета в тыкву), то это сродни тому, как если бы в тяжелые дни на заправке из-за нехватки 95го бензина его начинают бадяжить водой. А вот ток или мощность можно сравнить с литрами в минуту, которые заправка может выдавать. То есть, если на зарядке вашего телефона написано 5В 2А, это значит, что она может выдать не больше 2А по линии 5В. При этом при приближении к этим 2А качество напряжения может начать портиться, а зарядка греться и потеть. Именно поэтому все так любят брать блоки питания пожирнее. Например, кто-то скажет что и 1000 Ватт мало для RTX3090, что очевидно неверно, ибо сама по себе RTX 3090 потребляет по заявлению производителя 350 Ватт. Откуда же требование к блоку питания в более чем 750 Ватт? Давайте посчитаем! Дабы узнать сколько ест компонент, достаточно посмотреть на его тепловыделение, оно же энергопотребление. Грубо говоря, каждый компонент потребляющий ток, похож на ту же лампочку накаливания: пропустить ток греется. Например, если написано, что TDP процессора 60Ватт, значит, он будет выделять это тепло потребляя амперы по 12В линии. Чтобы получить ватты, нужно умножить ток на напряжение (IU=P). Или же, чтобы найти ток, нужно поделить 60 на 12. То есть 60-ти ваттный процессор потребляет 5А по 12В линии. Наш процессор потребляет целых 250 Ватт и видеокарта 350. Итого: по 12ти вольтовой линии блок питания должен выдать аж 600 Ватт.

Требование на 750 появляется из двух соображений, во-первых, многие производители льстят себе и пишут значения, при которых их продукции становится уже очень плохо, а во-вторых, из-за потерь в тепло везде, кроме потребителей, сколько-то съедят вентиляторы (по 2 Ватта каждый), сколько-то диски. В общем, мощности в 860 Ватт при условии выбора хорошего блока питания должно было хватить с головой. Я взял Fractal Design Ion+ Platinum FD-PSU-IONP-860P-BK. Не самый дорогой, но и не дешевый модульный блок питания от известного бренда. Характеристики его максимальных токов указаны на обратной части. Вы спросите, почему же ты не взял сразу блок питания с запасом на 4 видеокарты? Ну, когда я посмотрел цены на качественные блоки питания от 1000 Ватт, оказалось, что цена на них соизмерима с ценой всего компьютера. Сисоник на 1000 Ватт стоил аж 80К рублей. Но я, будучи электронщиком, понимал, что мне ничего не мешает вставить туда еще один блок питания специально для остальных видеокарт. Можно даже использовать компактный серверный блок, важно только сделать систему, которая бы включала блок питания одновременно с первым, но это несложно. Блоки питания включаются, как только напряжение на контакте PS_ON (см. рисунок) падает до нуля. То есть если вам хочется самим проверить блок питания без материнской платы, достаточно булавкой или скрепкой замкнуть контакты PS_ON и COM, и на остальных линиях появятся напряжения (Хоть все блоки питания и оборудованы защитами, но соблюдайте осторожность при работе с питанием, не допускайте попадание металлических компонентов на контакты, не вскрывайте блок питания). До этого момента включения не работает. Именно эти контакты замыкает материнская плата. То есть нужно было просто спаять плату, чтобы замыкать один контакт с другим, и можно сэкономить более 50ти тысяч рублей и подключать сколько хочешь мощных видеокарт. Теперь переходим к корпусу, который позволил все это безумие.

Корпус

Fractal Design MESHIFY S2, один из самых удобных корпусов, что я видел. Огромный, все быстро снимается. Внутри есть разветвитель PWM, чтобы можно было натыкать десятки вентиляторов, при этом заняв один слот на материнской плате. Оптимистично в него можно вставить до 6ти карт. Реалистично около четырех полноразмерных турбовинтовых карт. И то, если убрать нижнюю корзину для дисков, и разместить одну карту боком. Но иначе есть смысл брать только серверный корпус с переходником PCI, но такие в России найти вообще в продаже мне не удалось, только если заказывать на сайте DELL в США. Поэтому по факту взяли самый удобный корпус для большой рабочей или игровой системы. Из минусов могу выделить только встроенные очень слабые вентиляторы, которых тут установлено аж 3. Для высокопроизводительной системы советую вынуть их и заменить на высоко оборотистые управляемые 4 pin кулеры. У стоковых фиксированная скорость в 1000 оборотов, что хорошо для тихого ПК, но не очень для корпуса, которому предстоит рассеивать 800 Ватт тепла.

Память

Как вы могли заметить в сборке нет памяти, потому, что у нас уже было закуплено 64 GB не ECC памяти, и в принципе раз мы не играем в игры, то кроме желательного ECC у нас не было требований. Можно использовать любую. Если бы я докупал бы память, то выбрал бы что, то такое.

Цели

Прежде всего нужно понимать, что собирался такой компьютер не для игр. Я работаю в компании Twin3D, и такой компьютер нужен для построения автоматической сборки 3D модели человека на основе десятков-сотен фото. Если вам интересно, вы можете уже завтра приехать к нам и сделать 3D модель своего лица и тела. В свою очередь мы сейчас работаем над более сложными алгоритмами о которых вы могли читать тут.

Тесты

Про производительность отдельных компонентов системы вы можете найти много информации в Интернете. Поскольку нас интересует продолжительная работа, не было смысла заниматься овеклоком (разгонять процессор или видеокарту), по крайней мере по началу этой производительности точно хватало. К тому же почти любой разгон не только сильно повышает нагрев системы, но и влияет на вероятность вылетов вследствие случайных повреждений памяти, а к серверу предъявляются, наоборот, двойные стандарты по надежности. Поэтому в первую очередь нас интересуют температурные характеристики. Тест проводился с одной видеокартой Gigabyte GeForce RTX 3090 TURBO 24G, которая показала отличные температурные характеристики. При работе в стресс тесте видеокарты и 12 ядер процессора на неделю, температура видеокарты не поднималась выше 63 градусов, а процессора выше 59, что достойный показатель для игровых и умеренный для серверных систем. Ниже тест sysbench, для сравнения на моем домашнем ryzen 2600X total number of events: 121178. Когда тут, как на скриншоте ниже, 259501. Что более чем в два раза больше. При ровно в два раза большем количестве потоков. Причем стоящий дома ryzen еще и быстрее.

Что касается производительности RTX3090, пока еще рано говорить о ее рабочем потенциале, ибо наш суперский код, который создаст ваших 3D аватаров по фотографиям из instagram, еще не дописан. Однако если кому интересно она выдает где-то 110 Мега Хешей в секунду, что смешно по сравнению с любым асиком при ее стоимости на момент покупки она окупилась бы в майне за 314 дней (в день приносила бы почти 700р). Мораль не покупайте карты, чтобы майнить. Покупайте карты, чтобы играть, или учить искусственный интеллект. Чтобы он был умнее и посоветовал вам купить для майна ASIC.

Выводы

Собирай я сейчас бы тот же компьютер, наверное, поменял бы не так много. Советовал бы, как я писал выше, немного другую память, ибо когда мы выбирали свою еще было непонятно, какой будет процессор в конечной машине. Поменял бы скорее всего кулер, может, есть какие-то более удобные варианты. Хотя и качеством охлаждения я доволен. В будущих статьях возможно расскажу про настройку сервера. И удаленный GUI для нескольких пользователей. У вас есть предложения и замечания? Делитесь в комментариях!

Первое, что нам понадобится это датасет (выборка фотографий) людей с масками и без для дообучения нейросети MobileNetV2, которая находится в открытом доступе. У меня был датасет в количестве 981 фотографий людей в масках и столько же без, одних и тех же людей.

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

Итак, разместим наш датасет из 1962 фотографий в двух каталогах в папке dataset в масках в WithMask и без маски в Withoutmask соответственно. В каждой по 981 фотографии. Ещё одно важное замечание, это то, что дообучаем мы именно на лицах, а не просто, что человек на изображении в маске или без, хотя можно было и так.

Далее импортируем необходимые библиотеки:

from tensorflow.keras.preprocessing.image import ImageDataGeneratorfrom tensorflow.keras.applications import MobileNetV2from tensorflow.keras.layers import AveragePooling2Dfrom tensorflow.keras.layers import Dropoutfrom tensorflow.keras.layers import Flattenfrom tensorflow.keras.layers import Densefrom tensorflow.keras.layers import Inputfrom tensorflow.keras.models import Modelfrom tensorflow.keras.optimizers import Adamfrom tensorflow.keras.applications.mobilenet_v2 import preprocess_inputfrom tensorflow.keras.preprocessing.image import img_to_arrayfrom tensorflow.keras.preprocessing.image import load_imgfrom tensorflow.keras.utils import to_categoricalfrom sklearn.preprocessing import LabelBinarizerfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom imutils import pathsimport matplotlib.pyplot as pltimport numpy as npimport argparseimport os

# Указываем начальные гиперпараметры

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

INIT_LR = 0,004

Второй это количество эпох, одна эпоха это один проход обучения на всем наборе данных

EPOCHS = 20

Третий это размер пакета или батча, означает количество данных в одной партии.

BS = 32

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

imagePaths = list(paths.list_images (r'C:\dataset'))  # В этой папке хранятся два каталога с масками и безdata , labels = [] , []for imagePath in imagePaths:# Извлечение класса из директории (с маской или без)label = imagePath.split(os.path.sep)[-2]# Загружам входное изображение 224х224 и обрабатываем егоimage = load_img(imagePath, target_size = (224, 224))image = img_to_array(image)image = preprocess_input(image)# Обновляем список файлов и классовdata.append(image)labels.append(label)# Переводим в NumPy массивdata = np.array(data, dtype="float32")labels = np.array(labels)# Переводим классы в бинарный вид, т.е. 0 без маски 1 с маскойlb = LabelBinarizer()labels = lb.fit_transform(labels)labels = to_categorical(labels)# Разобьём датасет  на тренировочный и тестовый 80% на 20%;(trainX, testX, trainY, testY) = train_test_split(data, labels,  test_size = 0.20, stratify = labels, random_state = 42)# Аугментация датасета путем поворота изображенийaug = ImageDataGenerator(rotation_range = 20, zoom_range = 0.15,width_shift_range = 0.2, height_shift_range = 0.2, shear_range=0.15, horizontal_flip = True, fill_mode = "nearest")# Загружаем базовую модель c предварительно обученными весамиpath_weights = mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5'    baseModel = MobileNetV2(weights=path_weights, include_top=False, input_tensor=Input(shape=(224, 224, 3))Запишем в нашу модель внешний слой из базовой моделиheadModel = baseModel.outputheadModel = AveragePooling2D(pool_size = (7, 7))(headModel)headModel = Flatten(name = "flatten")(headModel)headModel = Dense(128, activation = "relu")(headModel)headModel = Dropout(0.5)(headModel)headModel = Dense(2, activation = "softmax")(headModel)model = Model(inputs = baseModel.input, outputs = headModel)# Заморозка слоев базовой модели for layer in baseModel.layers:layer.trainable = False# Скомпилируем нашу модельopt = Adam(lr = INIT_LR, decay = INIT_LR / EPOCHS)model.compile(loss = "binary_crossentropy", optimizer = opt, metrics = ["accuracy"])# Тренируем нашу сетьH = model.fit( aug.flow(trainX, trainY, batch_size = BS), steps_per_epoch = len(trainX) // BS,validation_data = (testX, testY), validation_steps = len(testX) // BS, epochs = EPOCHS)# Делаем предсказание на тестовой выборкеpredIdxs = model.predict(testX, batch_size = BS)#  Для каждого изображения в тестовом наборе, ищем максимальную вероятностьpredIdxs = np.argmax(predIdxs, axis=1)# Показать отчет обучения print(classification_report(testY.argmax(axis = 1), predIdxs, target_names = lb.classes_))

# Сохраняем модель на диск и загружаем её

model.save('model_mask_FACE', save_format = "h5")model_mask = tf.keras.models.load_model('model_mask_FACE)

Поиск маски на лице, на примере

# Найдем лицо на изображении, используя библиотеку MTCNN

frame = cv2.cvtColor(cv2.imread(house.png'), cv2.COLOR_BGR2RGB)frame_image = Image.fromarray(frame)boxes, probs, landmarks = mtcnn.detect(frame_image, landmarks = True)x1, y1, x2, y2 = [int(bx) for bx in boxes[0]]image = Image.fromarray(frame[y1:y2, x1:x2]).resize((224,224))face = img_to_array(image)

# Обработка изображения для загрузки в модель

face = preprocess_input(face)face = np.expand_dims(face, axis=0)

# Загрузка лица в нашу модель

(mask, withoutMask) = model_mask.predict(face)[0]image = cv2.imread(house.png)

# Прорисовка рамки и вероятности

if mask > withoutMask and max(mask, withoutMask) > 0.8: # уверенность    label = "Mask" if mask > withoutMask else "No Mask"    color = (0, 122, 0) if label == "Mask" else (0, 0, 122)    label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)    cv2.putText(image, label, (x1, y1 - 10),cv2.FONT_HERSHEY_SIMPLEX, 2, color, 5)    cv2.rectangle(image, (x1, y1), (x2, y2), color, 5)     y = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

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

Все мы уверенно можем сказать, красив ли человек, на котором остановился наш взгляд во время прогулки. И точно определим самую симпатичную женщину-кошку всех времен и народов. Но что движет нами при выявлении своих предпочтений?

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

Генеративно-состязательная нейронная сеть (Generative adversarial network, сокращенно GAN) научилась выявлять индивидуальные стандарты красоты при помощи ЭЭГ участников эксперимента. Статья об этом опубликована в журнале IEEE Transactions in Affective Computing.

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

До эксперимента финских ученых нейросети уже многому успели научиться. Например, при помощи PG GAN от nVidia можно создать потрясающе реалистичные изображения людей, которых на самом деле не существует на свете:

А алгоритм Everybody Dance Now позволяет на основе видео с танцором сгенерировать фейковую запись, на которой другой человек будет повторять те же движения.

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

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

Авторы исследования из Хельсинкского университета считают, что субъективно привлекательность зависит от неявной обработки определенных черт. Причем, у каждого человека они свои. По их мнению, генеративно-состязательные нейронные сети потенциально способны смоделировать субъективные предпочтения, не опираясь на заранее заданные параметры.

Мы представляем генеративные интерфейсы мозг-компьютер (GBCI). GBCI сначала представляет подборку изображений и фиксирует индивидуальные реакции привлекательности на них с помощью электроэнцефалографии. Затем эти реакции используются для управления моделью GAN. Нейросеть находит представление, которое соответствует характеристикам привлекательного для человека образа, говорится в аннотации к статье, которую мы перевели на русский.

Как сообщает N+1, в исследовании финских ученых, объединяющем информатику и психологию, приняли участие 30 сотрудников и студентов Хельсинкского университета.

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

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

Спустя два месяца люди, принимавшие участие в эксперименте, пришли, чтобы оценить его результаты. Пришедшим продемонстрировали матрицу из двух рядов по 12 картинок. Среди изображений, созданных нейросетью, были непривлекательные и нейтральные лица, а также лица предположительно симпатичные определённому человеку. Участникам предложили нажимать на изображения, которые они считали красивыми, а также оценить их по шкале от 1 (очень непривлекательное) до 5 (очень привлекательное).

Эксперимент оказался успешным! 86,7% созданных нейросетью привлекательных изображений изображений, подтвердились предпочтениями людей. Однако, участникам понравились 20% изображений, которые GAN создала в качестве непривлекательных. То есть по результатам исследования, появились ложноотрицательные результаты.

Более высокие рейтинги получили изображения, которые нейросеть создала как привлекательные, в сравнении с нейтральными и непривлекательными. То есть была найдена такая структура данных, которая позволяет разделять реакции мозга на привлекательные и непривлекательные лица. Причем, речь идет о высокой точности совпадений с реальными реакциями людей (83,33%).

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

Эксперимент доказал, что использование данных ЭЭГ для управления генеративно-состязательными нейронными сетями действенный инструмент для интерактивного генерирования информации.

Возможно, в недалеком будущем в каждом доме появится свой Джарвис эмпатичный и с чувством юмора. Но уже сейчас можно создать чат-бота, понимающего обычную письменную речь, а не отдельные команды. Мы говорили об этом еще в доковидные времена на сибирском HighLoad++.

КонференцияHighLoad++ 2021пройдет уже 17 и 18 мая в Москве, в Крокус-экспо. У нас готоворасписание, и вы уже сегодня можете запланировать активности!

Билеты можно купитьздесь. С 1 мая цена на них станет выше.

Хотите бесплатно получить материалы мини-конференции Saint HighLoad++ 2020?Подписывайтесьна нашу рассылку.

Нейросеть GTP-3 самый совершенный алгоритм, имитирующий естественный человеческий язык. Возможно, в ближайшем будущем он оставит копирайтеров и журналистов без работы. Да?

Быть такого не может, подумал я и протестировал решения на основе данного алгоритма, ruGTP-3 и Copy.AI.

Так ли хороша нейронка, как о ней говорят? Вот и посмотрим. Заодно и поговорим о том, как ее появление скажется на работе копирайтеров...

Про GTP-3

Принцип работы (из материала РБК.Тренды)

Нейросеть GPT-3 Generative Pre-trained Transformer разработана некоммерческой организацией OpenAI, которую основали глава SpaceX Илон Маск и экс-президент акселератора YCombinator Сэм Альтман. Третье поколение программы обработки естественного языка представили публике в мае 2020 года. Сегодня это самая сложная и объемная языковая модель из всех существующих.

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

Ее характеристики:

• 175 млрд параметров, Для сравнения в предыдущей версии было 1,5 млрд.

• 600 Гб датасета (вся англоязычная Википедия, книги и стихи, материалы из СМИ и GitHub, путеводители и рецепты). У предшественницы только 40 Гб.

• архитектура трансформер (работает по принципу автодополнения, как Т9). В принципе, как и у предшественников.

Оценить качество работы новой нейросети можно по следующим материалам.

Интервью с нейросетью в РБК.Тренды

Эссе нейросети в The Guardian (на английском)

Сегодня доступ к нейросети открыт ограниченному кругу лиц. Но все же открыт, поэтому...

Русскоязычная версия ruGTP-3

Поэтому российские умельцы разработали аналогичный алгоритм ruGTP-3 Large. Видимо, они просто взяли GTP-3 и натянули на нее русскоязычный интерфейс.

Согласно статье с портала Cnews, это прообраз общего, или сильного, искусственного интеллекта (Artificial General Intelligence, AGI), способного решать разноплановые задачи в различных сферах деятельности.

Она обладает следующими функциями:

• пишет новости, романы, стихи, пародии, техническую документацию и др,

• исправляет грамматические ошибки,

• ведет диалоги,

• кодит (только я так и не понял, на каких языках).

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

Ну вот, а я-то думал...

Все интересующиеся могут найти ее >> здесь << .

Собственно, я интересуюсь и попробовал работать с ней (смотрите результаты ниже).

Что я делал? Вводил незаконченный текст в интерфейс, в поле ruGPT-3 (760M) -> нажимал Дополнить -> и нейросеть дополняла -> я получал текст.

В результате я получил несколько куч словесного мусора. Ну, наверное, примерно то же пишут горе-авторы на биржах контента по 20 /килознак, подумал я.

Но, говорят, ruGTP-3 занимает лидирующее место в рейтинге нейросетей, и она отлично справляется с задачами на логику, здравый смысл, понимание текста.

Странно... может для затравки ей нужен более осознанный текст (с большим количествчом исходных данных)....

Мои ожидания были обмануты на 100%! Да если бы я такое написал, то был бы осмеян и опозорен (как заказчиками, так и другими райтерами).

Поэтому я оставил ruGTP-3 с ее доеданиями животных и перешел к другой разработке с GTP-3. Честно говоря, я не надеялся увидеть что-то более-менее адекватное. Оправдались ли мои ожидания? Читайте и узнаете...

COPY.AI

Впервые я прочитал о нем на портале фрилансеров. Узнал, что его создали Крис Лу и Паул Якобян (явно не русские парни), поэтому он должен сильно отличаться от ruGTP-3...

Посмотрим, что там.

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

Далее. С ней можно писать 18 видов текстов: тексты объявлений, посты, контент для сайтов, тексты для интернет-магазинов, тексты для блогов, тексты для отделов продаж. О!

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

Удивило: она выдает умопомрачительные идеи (brainstorming ideas).

Ну я улыбнулся -> Запустил триал -> Зарегистрировался -> Перешел в рабочий кабинет -> и вот...

Что меня порадовало

1. Огромное количество видов текста (в левой части кабинета, под надписью Select tool). Как я понял, в зависимости от выбранного вида текста меняется структура контента.

2. Работа с несколькими языками (вкладки Input Language и Output Language). Программа работает с немецким, британским английским, американским английским, французским, итальянским, испанским, японским, китайским, польским, португальским, бразильским и русским языками. Как пишет, так и переводит (Вау!)

3. Можно таргетировать текст на специфичную аудиторию (для этого нужно поставить галочку в поле Need help targeting a more specific audience?). Можно выбрать аудиторию по роду занятий и геолокации, выбрать особый инфоповод, выбрать предмет продвижения.

Что расстроило

• англоязычный интерфейс. Хотя мне не важно (и с современными переводчиками юзерам тоже должно быть не важно). Однако некоторым не англоговорящим постоянные переводы будут не удобны.

Ну я заполнил поля снова ввел историю о продаже цветов в Хабаровске.

И вот что получилось в результате. Честно: результат превзошел мои ожидания...

Оцениваю результат

Текст довольно связный, но с ошибками как будто переведенный через Google Translate.

+ Короткий. Такое ощущение, что просто подготовлен анонс текста в 3-4 предложениях.

То есть текст в результате нужно:

• отредактировать (добавить идей),

• откорректировать (убрать стилистические ошибки, добавить связки, форматировать, дописать).

Но. сервис обозначен, как сервис для копирайтеров чего ж я ожидал (дописывать придется). Другой разговор, что заменить копирайтера у него явно не получится.

Вывод и разговоры о будущем...

Что ruGTP-3, что Copy.AI явно не смогут заменить пишущих людей: у первой это не получится, а вторая создана не для этого.

Но что произойдет из-за появления этих программ? Однозначно, ничего страшного. Конечно, я не футуролог и не могу дать обоснованный прогноз с точностью 100%, но попытаться можно...

Пессимистичный прогноз

Бизнес ринется использовать нейронки для создания текстов. Она научится писать адекватные тексты и составит конкуренцию пишущим людям.

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

Почему так может случиться:

• потому что бизнесменам нужны тексты дешево и качественно,

• и потому что есть тенденция к ускорению медиапотребления, то есть народ меньше читает (а нейросеть как раз меньше пишет).

Однако я предпочитаю ждать лучшего и строить позитивные прогнозы.

Оптимистичный прогноз

Бизнес сразу поймет, что нейросеть не генерирует нормальные тексты и призовет на помощь копирайтеров. То есть ситуация в мире останется без изменений.

Это может случится при условии, что явных потрясений в мире не произойдет (то есть не выйдет еще более усовершенствованная сеть GTP-4 или какой-нибудь Skynet не сотрет все тексты в мире).

Вероятностный прогноз

От нескольких людей слышал, что за рубежом проблема с качеством контента. И с появлением GTP-3 ситуация не сильно изменится.

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

Хотя кому-то может и понравится. Ретрограды вроде меня будут продолжать писать и читать лонгриды. А вот представителям поколения Z вполне может хватить 3-4 предложений в тексте.

То есть, скорее всего, обе разработки с GTP-3 конечно найдут своих пользователей.

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

Надеюсь, материал получился интересный и полезный.

Спасибо!

Обучение нейронной сети

В данной части статьи по разработке простейшей нейронной сети мы научимся обучать нейронные сети.

Мы обучим нейросеть решать задачу по нахождении закономерности в ряде чисел. Для простоты это будут числа 0 и 1.

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

Данные для обучения выглядят так

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

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

Решение этой задачи это первое введённое число.

В качестве условия задачи которую должна решить нейронная сеть выглядит так

Обучение нейронной сети это уменьшение потерь.

Чем меньше потерь тем лучше и правильнее результат.

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

Для обучения нам понадобится производнаясигмоиды.

Что такое производная вы сможете посмотреть в википедии, а производнаясигмоидывыглядит так:

Реализация на Python выглядит так:

def deriv_sig(x):    return sig(x) * (1 - sig(x))

Запишем этот код в файл Math.py

Так же для обучения нам нужно 2 константы:

rate - скорость обучения
count_learn - количество повторений обучения

Чем больше count_learn тем лучше обучится нейронная сеть, но потребуется больше времени на обучение. А с rate все понятно.

Присвоим константам значения:

rate = 0.1
count_learn = 10000

После объявления констант, запускаем цикл от 0 до count_learn, внутри цикла запустим еще один цикл который будет выполняться столько раз, сколько входных данных для обучения у нас есть.

После этого будет сложная математика, поэтому дам вам просто код:

def learn(self, inputs, answers):                rate = 0.1        count_learn = 10000        for o in range(count_learn):            for inputt, answer in zip(inputs, answers):                sum_n1 = self.n[0].w[0] * inputt[0] + self.n[0].w[1] * inputt[1] + self.n[0].b                n1 = sig(sum_n1)                sum_n2 = self.n[1].w[0] * inputt[0] + self.n[1].w[1] * inputt[1] + self.n[1].b                n2 = sig(sum_n2)                sum_n3 = self.n[2].w[0] * n1 + self.n[2].w[1] * n2 + self.n[2].b                n3 = sig(sum_n3)                out_res = n3                err = -2 * (answer - out_res)                err_rate = rate * err                deriv_sig_n1 = deriv_sig(sum_n1)                deriv_sig_n2 = deriv_sig(sum_n2)                deriv_sig_n3 = deriv_sig(sum_n3)                self.n[0].w[0] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[0] * deriv_sig_n1                self.n[0].w[1] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[1] * deriv_sig_n1                self.n[0].b -= err_rate * self.n[2].w[0] * deriv_sig_n3 * deriv_sig_n1                self.n[1].w[0] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[0] * deriv_sig_n2                self.n[1].w[1] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[1] * deriv_sig_n2                self.n[1].b -= err_rate * self.n[2].w[1] * deriv_sig_n3 * deriv_sig_n2                self.n[2].w[0] -= err_rate * n1 * deriv_sig_n3                self.n[2].w[1] -= err_rate * n2 * deriv_sig_n3                self.n[2].b -= err_rate * deriv_sig_n3

Запишем эту функцию в класс NeuronNet.

В итоге файл NeuronNet.py выглядит так:

from Neuron import *class NeuronNet:    def __init__(self):        self.n = []        for i in range(3):            self.n.append(Neuron(2))    def activate(self, inputs):        return self.n[2].activate(np.array([self.n[0].activate(inputs), self.n[1].activate(inputs)]))    def learn(self, inputs, answers):                rate = 0.1        count_learn = 10000        for o in range(count_learn):            for inputt, answer in zip(inputs, answers):                sum_n1 = self.n[0].w[0] * inputt[0] + self.n[0].w[1] * inputt[1] + self.n[0].b                n1 = sig(sum_n1)                sum_n2 = self.n[1].w[0] * inputt[0] + self.n[1].w[1] * inputt[1] + self.n[1].b                n2 = sig(sum_n2)                sum_n3 = self.n[2].w[0] * n1 + self.n[2].w[1] * n2 + self.n[2].b                n3 = sig(sum_n3)                out_res = n3                err = -2 * (answer - out_res)                err_rate = rate * err                deriv_sig_n1 = deriv_sig(sum_n1)                deriv_sig_n2 = deriv_sig(sum_n2)                deriv_sig_n3 = deriv_sig(sum_n3)                self.n[0].w[0] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[0] * deriv_sig_n1                self.n[0].w[1] -= err_rate * self.n[2].w[0] * deriv_sig_n3 * inputt[1] * deriv_sig_n1                self.n[0].b -= err_rate * self.n[2].w[0] * deriv_sig_n3 * deriv_sig_n1                self.n[1].w[0] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[0] * deriv_sig_n2                self.n[1].w[1] -= err_rate * self.n[2].w[1] * deriv_sig_n3 * inputt[1] * deriv_sig_n2                self.n[1].b -= err_rate * self.n[2].w[1] * deriv_sig_n3 * deriv_sig_n2                self.n[2].w[0] -= err_rate * n1 * deriv_sig_n3                self.n[2].w[1] -= err_rate * n2 * deriv_sig_n3                self.n[2].b -= err_rate * deriv_sig_n3

А Math.py выглядит так:

import numpy as npdef sig(x):    return 1 / (1 + np.exp(-x)) def deriv_sig(x):    return sig(x) * (1 - sig(x))    

Теперь запустим нашу нейронную сеть и обучение.

Допишем в файл main.py массив с данными для обучения и правильными ответами:

learn_inputs = np.array([[1, 0], [0, 0], [0, 1]])learn_answers = np.array([1, 0, 0])

Далее запустим обучение:

net.learn(learn_inputs, learn_answers)

И запустим нашу нейронную сеть подав ей задачу которую надо решить:

x = np.array([1, 1])if (net.activate(x) < 0.5):    print("0")else:    print("1")

В итоге main.py выглядит так:

import numpy as npfrom NeuronNet import *net = NeuronNet()learn_inputs = np.array([[1, 0], [0, 0], [0, 1]])learn_answers = np.array([1, 0, 0])net.learn(learn_inputs, learn_answers)x = np.array([1, 1])if (net.activate(x) < 0.5):    print("0")else:    print("1")

Теперь запустим программу введя в консоль:

python main.py

после запуска нейронная сеть выводит

Теперь обновим входные данные, вместо

Зададим другую задачу

При изменении входных данных результат программы выглядит так

Теперь подведем итоги.

В серии статей по искусственным нейронным сетям мы изучили

1. Принципы работы искусственных нейронов

2. Принципы работы нейронных сетей

3. Принципы обучения нейронных сетей

4. Написали свою нейронную сеть

Эта часть статьи была последней.

Итоговый код нейронной сети вы сможете найти на моей странице в github: https://github.com/AndreiShalupaey/PyNeuronNet

Если вы хотите изучить математические формулы для обучения нейронных сетей, прочитайте данную статью: https://proglib.io/p/pishem-neyroset-na-python-s-nulya-2020-10-07

Разработка прогнозной модели нейронной сети для нового набора данных может оказаться сложной задачей.

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

Этот процесс можно использовать для разработки эффективных моделей нейронных сетей для задач классификации и регрессионного прогнозного моделирования.

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

После прохождения этого урока вы будете знать:

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

• как изучить динамику обучения простых моделей MLP в наборе данных;

• как разработать надежные оценки производительности модели, настроить производительность модели и сделать прогнозы на основе новых данных.

Давайте начнём.

Набор данных классификации банкнот

Первый шаг определить и изучить набор данных.

Мы будем работать со стандартным набором данных двоичной классификации Банкнота.

Набор данных банкноты включает в себя прогнозирование подлинности данной банкноты с учётом ряда мер, взятых из фотографии.

Набор данных содержит 1372 строки с 5 числовыми переменными. Это проблема классификации с двумя классами (двоичная классификация).

Ниже представлен список пяти переменных в наборе данных:

• дисперсия Вейвлет-преобразованного изображения (непрерывная);

• асимметрия Вейвлет-преобразованного изображения (непрерывная);

• эксцесс Вейвлет-преобразованного изображения (непрерывный);

• энтропия изображения (непрерывная);

• класс (целое число).

Ниже приведён образец первых 5 строк набора данных.

3.6216,8.6661,-2.8073,-0.44699,04.5459,8.1674,-2.4586,-1.4621,03.866,-2.6383,1.9242,0.10645,03.4566,9.5228,-4.0112,-3.5944,00.32924,-4.4552,4.5718,-0.9888,04.3684,9.6718,-3.9606,-3.1625,0...

Вы можете посмотреть весь набор данных здесь:

• Banknote Dataset (banknote_authentication.csv);

• Banknote Dataset Details (banknote_authentication.names)

Мы можем загрузить набор данных как DataFrame pandas прямо из URL-адреса.

Например:

# load the banknote dataset and summarize the shapefrom pandas import read_csv# define the location of the dataseturl = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'# load the datasetdf = read_csv(url, header=None)# summarize shapeprint(df.shape)

При выполнении кода набор данных загружается непосредственно из URL-адреса и выводится форма набора данных.

В этом случае мы можем подтвердить, что набор данных имеет 5 переменных (4 входных и одна для вывода) и что набор содержит 1372 строки.

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

Это также предполагает, что использование перекрёстной проверки в k-кратном размере было бы хорошей идеей, потому что она даст более надёжную оценку производительности модели, чем разделение на обучение/тест, и потому что одна модель будет соответствовать секундам, а не часам или дням обучения.

(1372, 5)

Затем мы можем узнать больше о наборе данных, просмотрев сводную статистику и график данных.

# show summary statistics and plots of the banknote datasetfrom pandas import read_csvfrom matplotlib import pyplot# define the location of the dataseturl = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'# load the datasetdf = read_csv(url, header=None)# show summary statisticsprint(df.describe())# plot histogramsdf.hist()pyplot.show()

При выполнении примера сначала загружаются данные, а затем выводится сводная статистика для каждой переменной.

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

                 0            1            2            3            4count  1372.000000  1372.000000  1372.000000  1372.000000  1372.000000mean      0.433735     1.922353     1.397627    -1.191657     0.444606std       2.842763     5.869047     4.310030     2.101013     0.497103min      -7.042100   -13.773100    -5.286100    -8.548200     0.00000025%      -1.773000    -1.708200    -1.574975    -2.413450     0.00000050%       0.496180     2.319650     0.616630    -0.586650     0.00000075%       2.821475     6.814625     3.179250     0.394810     1.000000max       6.824800    12.951600    17.927400     2.449500     1.000000

Затем для каждой переменной создаётся гистограмма.

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

У нас может быть некоторая выгода от использования степенного преобразования для каждой переменной, чтобы сделать распределение вероятностей менее искажённым, что, возможно, улучшит производительность модели.

Теперь, когда мы знакомы с набором данных, давайте посмотрим, как можно разработать модель нейронной сети.

Динамика обучения нейронной сети

Мы разработаем модель многослойного персептрона (MLP) для набора данных, используя TensorFlow.

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

С учётом того, что набор данных невелик, небольшой размер пакета, вероятно, является хорошей идеей, например, 16 или 32 строки. Использование Адамовской версии стохастического градиентного спуска хорошая идея для начала работы, так как она автоматически адаптирует скорость обучения и хорошо работает на большинстве наборов данных.

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

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

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

...# ensure all data are floating point valuesX = X.astype('float32')# encode strings to integery = LabelEncoder().fit_transform(y)

Затем мы можем разделить набор данных на переменные входа и выхода, а затем на наборы для обучения и тестирования 67/33.

...# split into input and output columnsX, y = df.values[:, :-1], df.values[:, -1]# split into train and test datasetsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)

Мы можем определить минимальную модель MLP. В этом случае мы будем использовать один скрытый слой с 10 узлами и один выходной слой (выбранный произвольно). Мы будем использовать функцию активации ReLU в скрытом слое и инициализацию веса he_normal, поскольку их совместное использование является хорошей практикой.

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

...# determine the number of input featuresn_features = X.shape[1]# define modelmodel = Sequential()model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))model.add(Dense(1, activation='sigmoid'))# compile the modelmodel.compile(optimizer='adam', loss='binary_crossentropy')

Мы подгоним модель для 50 тренировочных эпох (выбранных произвольно) с размером пакета 32, потому что это небольшой набор данных.

Мы подгоняем модель под необработанные данные, что, по нашему мнению, может быть хорошей идеей, и это важная отправная точка.

...# fit the modelhistory = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0, validation_data=(X_test,y_test))

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

...# predict test setyhat = model.predict_classes(X_test)# evaluate predictionsscore = accuracy_score(y_test, yhat)print('Accuracy: %.3f' % score)

Наконец, мы построим кривые обучения кросс-энтропийных потерь для наборов обучения и тестовых наборов во время обучения.

...# plot learning curvespyplot.title('Learning Curves')pyplot.xlabel('Epoch')pyplot.ylabel('Cross Entropy')pyplot.plot(history.history['loss'], label='train')pyplot.plot(history.history['val_loss'], label='val')pyplot.legend()pyplot.show()

Если связать всё это вместе, полный пример оценки нашего первого MLP в наборе данных банкнот приведён ниже.

# fit a simple mlp model on the banknote and review learning curvesfrom pandas import read_csvfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import LabelEncoderfrom sklearn.metrics import accuracy_scorefrom tensorflow.keras import Sequentialfrom tensorflow.keras.layers import Densefrom matplotlib import pyplot# load the datasetpath = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'df = read_csv(path, header=None)# split into input and output columnsX, y = df.values[:, :-1], df.values[:, -1]# ensure all data are floating point valuesX = X.astype('float32')# encode strings to integery = LabelEncoder().fit_transform(y)# split into train and test datasetsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)# determine the number of input featuresn_features = X.shape[1]# define modelmodel = Sequential()model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))model.add(Dense(1, activation='sigmoid'))# compile the modelmodel.compile(optimizer='adam', loss='binary_crossentropy')# fit the modelhistory = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0, validation_data=(X_test,y_test))# predict test setyhat = model.predict_classes(X_test)# evaluate predictionsscore = accuracy_score(y_test, yhat)print('Accuracy: %.3f' % score)# plot learning curvespyplot.title('Learning Curves')pyplot.xlabel('Epoch')pyplot.ylabel('Cross Entropy')pyplot.plot(history.history['loss'], label='train')pyplot.plot(history.history['val_loss'], label='val')pyplot.legend()pyplot.show()

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

Примечание: ваши результаты могут различаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Подумайте о том, чтобы запустить пример несколько раз и сравнить средние результаты.

В этом случае мы видим, что модель достигла идеальной точности в 100 % процентов. Это может означать, что задача прогнозирования проста и/или что нейронные сети хорошо подходят для этой задачи.

Accuracy: 1.000

#

Мы видим, что модель хорошо сходится и не показывает никаких признаков переобучения или неполного соответствия.

С первой попытки у нас всё получилось на удивление хорошо.

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

Оценка робастной модели

K-кратная процедура перекрёстной проверки может обеспечить более надёжную оценку производительности MLP, хотя она может быть очень медленной.

Это связано с тем, что необходимо подобрать и оценить k моделей. Это не проблема, если размер набора данных невелик, например наш набор данных.

Мы можем использовать класс StratifiedKFold и вручную пронумеровать каждую, подогнать модель, оценить её, а затем сообщить среднее значение оценок в конце процедуры.

...# prepare cross validationkfold = KFold(10)# enumerate splitsscores = list()for train_ix, test_ix in kfold.split(X, y):# fit and evaluate the model.........# summarize all scoresprint('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

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

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

Если мы снова внесём в модель большие изменения, рекомендуется вернуться назад и убедиться, что модель сходится надлежащим образом.

Полный пример этой структуры для оценки базовой модели MLP из предыдущего раздела приведён ниже.

# k-fold cross-validation of base model for the banknote datasetfrom numpy import meanfrom numpy import stdfrom pandas import read_csvfrom sklearn.model_selection import StratifiedKFoldfrom sklearn.preprocessing import LabelEncoderfrom sklearn.metrics import accuracy_scorefrom tensorflow.keras import Sequentialfrom tensorflow.keras.layers import Densefrom matplotlib import pyplot# load the datasetpath = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'df = read_csv(path, header=None)# split into input and output columnsX, y = df.values[:, :-1], df.values[:, -1]# ensure all data are floating point valuesX = X.astype('float32')# encode strings to integery = LabelEncoder().fit_transform(y)# prepare cross validationkfold = StratifiedKFold(10)# enumerate splitsscores = list()for train_ix, test_ix in kfold.split(X, y):# split dataX_train, X_test, y_train, y_test = X[train_ix], X[test_ix], y[train_ix], y[test_ix]# determine the number of input featuresn_features = X.shape[1]# define modelmodel = Sequential()model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))model.add(Dense(1, activation='sigmoid'))# compile the modelmodel.compile(optimizer='adam', loss='binary_crossentropy')# fit the modelmodel.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0)# predict test setyhat = model.predict_classes(X_test)# evaluate predictionsscore = accuracy_score(y_test, yhat)print('>%.3f' % score)scores.append(score)# summarize all scoresprint('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

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

Примечание: ваши результаты могут различаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Подумайте о том, чтобы запустить пример несколько раз и сравнить средний результат.

В этом случае мы видим, что модель MLP достигла средней точности около 99,9 %.

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

Это удивительно (для меня), потому что я ожидал, что потребуется некоторое масштабирование данных и, возможно, преобразование мощности.

>1.000>1.000>1.000>1.000>0.993>1.000>1.000>1.000>1.000>1.000Mean Accuracy: 0.999 (0.002)

Затем давайте посмотрим, как мы можем подогнать окончательную модель и использовать её для прогнозов.

Окончательная модель и прогнозы

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

В этом случае мы будем использовать модель с отсевом и небольшим размером в качестве нашей окончательной модели.

Мы можем подготовить данные и подогнать модель, как и раньше, но для всего набора данных, а не на обучающее подмножество.

...# split into input and output columnsX, y = df.values[:, :-1], df.values[:, -1]# ensure all data are floating point valuesX = X.astype('float32')# encode strings to integerle = LabelEncoder()y = le.fit_transform(y)# determine the number of input featuresn_features = X.shape[1]# define modelmodel = Sequential()model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))model.add(Dense(1, activation='sigmoid'))# compile the modelmodel.compile(optimizer='adam', loss='binary_crossentropy')

Затем мы можем использовать эту модель для прогнозирования новых данных.

Во-первых, мы можем определить ряд новых данных.

...# define a row of new datarow = [3.6216,8.6661,-2.8073,-0.44699]

Примечание: я взял эту строку из первой строки набора данных, и ожидаемая метка "0".

Затем мы можем сделать прогноз.

...# make predictionyhat = model.predict_classes([row])

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

...# invert transform to get label for classyhat = le.inverse_transform(yhat)

И в этом случае мы просто выведем прогноз.

...# report predictionprint('Predicted: %s' % (yhat[0]))

Если связать всё это вместе, полный пример подгонки окончательной модели для набора данных банкноты и её использования для прогнозирования новых данных приведён ниже.

# fit a final model and make predictions on new data for the banknote datasetfrom pandas import read_csvfrom sklearn.preprocessing import LabelEncoderfrom sklearn.metrics import accuracy_scorefrom tensorflow.keras import Sequentialfrom tensorflow.keras.layers import Densefrom tensorflow.keras.layers import Dropout# load the datasetpath = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/banknote_authentication.csv'df = read_csv(path, header=None)# split into input and output columnsX, y = df.values[:, :-1], df.values[:, -1]# ensure all data are floating point valuesX = X.astype('float32')# encode strings to integerle = LabelEncoder()y = le.fit_transform(y)# determine the number of input featuresn_features = X.shape[1]# define modelmodel = Sequential()model.add(Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(n_features,)))model.add(Dense(1, activation='sigmoid'))# compile the modelmodel.compile(optimizer='adam', loss='binary_crossentropy')# fit the modelmodel.fit(X, y, epochs=50, batch_size=32, verbose=0)# define a row of new datarow = [3.6216,8.6661,-2.8073,-0.44699]# make predictionyhat = model.predict_classes([row])# invert transform to get label for classyhat = le.inverse_transform(yhat)# report predictionprint('Predicted: %s' % (yhat[0]))

Выполнение примера соответствует модели для всего набора данных и делает прогноз для одной строки новых данных.

Примечание: ваши результаты могут различаться из-за стохастической природы алгоритма или процедуры оценки или различий в числовой точности. Попробуйте запустить пример несколько раз и сравните средние результаты.

В этом случае мы видим, что модель предсказала метку 0 для входной строки.

Predicted: 0.0

Дальнейшее чтение

В этом разделе представлены дополнительные ресурсы по теме, если вы хотите углубиться в тему.

• How to Develop a Neural Net for Predicting Disturbances in the Ionosphere.

• Best Results for Standard Machine Learning Datasets.

• TensorFlow 2 Tutorial: Get Started in Deep Learning With tf.keras.

• A Gentle Introduction to k-fold Cross-Validation.

Вывод

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

В частности, вы узнали:

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

• как изучить динамику обучения простых моделей MLP в наборе данных;

• как разработать надёжные оценки производительности модели, настроить производительность модели и сделать прогнозы на основе новых данных.

Узнайте, как прокачаться в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

Компания Dragon Tree Labs объединяет индивидуальных разработчиков и команды робототехников для общей цели создать робота-аватара, который стал бы продолжением человека, который им управляет, расширил бы возможности телеприсутствия и дистанционного физического взаимодействия с объектами реального мира.

Это совпадает с целями международного конкурса $10M ANA Avatar XPRIZE, который был инициирован, чтобы поддержать развитие технологий в этой области. Конкурс стартовал в марте 2018 года и рассчитан на четыре года. В июне 2022 года будут объявлены победители соревнования, которые разделят приз в $10 млн.

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

Для выхода в полуфинал $10M ANA Avatar XPRIZE команда Dragon Tree Labs создала робота Джонни

Для выхода в полуфинал команда Dragon Tree Labs создала робота Джонни, который прошёл соответствие всем требованиям. На данный момент это единственная российская команда, которая продолжает бороться за победу и главный приз.

Оператор может управлять Джонни дистанционно, наблюдая за происходящим вокруг робота через VR-очки. Аватар оснащён колёсами и может свободно передвигаться по помещению, позволяет взаимодействовать с объектами посредством манипулятора. На данном этапе у робота одна активная рука, которой можно управлять, в будущем появится вторая. Аватар оснащён системой распознавания объектов для помощи оператору в захвате предметов.

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

Робот Джонни результат интеграции нескольких прорывных технологий, в том числе инновационного компьютерного вычислителя для одновременного запуска нескольких нейронных сетей, который был создан специально для мобильных роботов командой Fast Sense. Именно благодаря этому компоненту, Джонни может одновременно выполнять несколько задач с задействованием ML-алгоритмов параллельно. Также, исследователи из МФТИ участвовали в реализации тестового сценария управления манипулятором.

На данный момент робот обладает рядом ограничений, которые объединённая команда Dragon Tree Labs планирует устранить в будущем для повышения шансов на победу, в том числе за счёт привлечения новых участников в проект. В следующей модификации Аватар Джонни обзаведётся второй управляемой рукой, разными типами хватов, научится распознавать другие объекты, помимо бумажных стаканчиков. Также команде необходимо будет обеспечить быструю передачу сигналов для управления устройством из любого места земного шара через интернет. Важный аспект для дальнейшей проработки то, как аватар обеспечивает иммерсивность, передаёт ощущение присутствия и полноту обратной связи от объектов.

Для работы над этой частью задачи команда стремится привлечь дополнительных участников и приглашает на оплачиваемую стажировку на лето 2021 года. Все, кто хотят присоединиться к проекту, могут писать на hello@dtlabs.tech

"Мы считаем, что такие аватары следующий эволюционный уровень развития телекоммуникаций и человеческого взаимодействия. Когда-то мы отправляли письма почтой, затем начали звонить по домашним телефонам, то есть в коммуникации включилась ещё одна система органов чувств. Интернет позволил обмениваться идеями и переживаниями моментально, а не ждать письма месяцами. Теперь у нас есть возможность видеть друг друга во время звонка и общаться в любое время в любом месте так, как если бы мы физически находились рядом. Технологии VR делают этот опыт ещё более реальным для восприятия. Следующий шаг возможность физического контакта на расстоянии. Именно для этого нужен мобильный робот-аватар, оснащённый манипуляторами, которыми можно управлять дистанционно. Даже простая возможность передвинуть предмет, скажем, шахматную фигуру на доске, за которой сидит соперник или ваш сын на другом континенте, создаёт ощущение физического присутствия на месте событий, создавая единый контекст. Возможность обнять бабушку, к которой нельзя приехать, ощущается через аватар практически реальной".

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

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

В рамках соревнования Альфа-Баттл 2.0 на boosters.pro участникам предлагалось решить задачу кредитного скоринга, используя только транзакционные данные клиента за предшествующий год. После соревнования была организована песочница, являющаяся копией соревнования, но без ограничения по времени и без денежных призов. Датасет соревнования можно использовать в научных публикациях, дипломных и курсовых работах.

Описание данных

Участникам соревнования был предоставлен датасет по 1.5 миллионам выдач кредитных продуктов. К каждому объекту выборки было подтянуто признаковое описание в виде истории клиентских транзакций глубиной в год. Дополнительно был представлен тип выданного продукта. Обучающая выборка состоит из выдач за период в N дней, тестовая выборка содержит выдачи за последующий период в K дней. Всего в датасете содержалось 450 миллионов транзакций, объемом порядка 6 гигабайт в формате parquet. Понимая, что такой объем данных может стать серьезным порогом для входа, мы разбили датасет на 120 файлов и реализовали методы пакетной предобработки данных, что позволило решать задачу соревнования с личного ноутбука.

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

Целевой переменной в соревновании была бинарная величина, соответствующая флагу дефолта по кредитному продукту. Метрикой для оценки качества решений была выбрана AUC ROC.

Базовый подход к решению задачи

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

В случае категориальных признаков можно использовать счетчики вхождений каждого значения каждой категориальной переменной или пойти дальше и использовать вектора из матричных разложений или основанных на них методах: LDA, BigARTM. Последний из которых позволяет получить векторное представление сразу для всех категориальных признаков за счет поддержи мультимодальности. Признаки можно отобрать на основе важности, полученной популярным методом permutaion importance или менее популярным target permutation. С базовым подходом, приносящим 0.752 AUC ROC на public LB, можно ознакомиться на git.

Архитектура нейронной сети

Решать задачу классификации многомерных временных рядов можно методами, используемыми в классификации текстов, если мысленно заменить каждое слово текста набором категориальных признаков. В области обработки естественного языка принято ставить каждому слову в соответствие числовой вектор, размерности сильно меньше, чем размера словаря. Обычно вектора слов предобучают на огромном корпусе текстовых документов методами обучения без учителя: word2vec, FastText, BERT, GPT-3. Основной мотивацией предобучения являются огромное количество параметров, которое нужно выучить в виду большого размера словаря и обычно небольшого размеченного датасета для решения прикладной задачи. В данной задаче ситуация обратная: менее 200 уникальных значений для каждой категориальной переменной и большой размеченный датасет.

Резюмируя вышесказанное, векторного представление для каждого категориального признака можно получить, используя стандартный Embedding Layer, работающий по следующему алгоритму: в начале задается желаемый размер векторного представления, затем инициализируется LookUp матрица из некоторого распределения, далее ее веса учатся вместе с остальной сетью методом backpropagation. Размер эмбеддинга обычно выбирается равным или меньше половины числа уникальных значений категориального признака. Любой вещественный признак можно перевести в категориальный операцией бинаризации. Вектор для каждой транзакции получается из конкатенации эмбеддингов, соответствующих значениям ее категориальных признаков.

Далее последовательность векторов транзакций отправим в BiLSTM для моделирования временных зависимостей. Затем избавимся от пространственной размерности при помощи конкатенации GlobalMaxPool1D и GlobalAveragePool1D для последовательностей векторов из рекуррентного и эмбеддинг-слоев. В итоге, предварительно пропустив полученный вектор через промежуточный полносвязный слой, остается добавить полносвязный слой с sigmoid для решения задачи бинарной классификации.

Обучение нейронной сети

Рассмотрим архитектуру нейронной сети, предложенную участникам соревнования в качестве продвинутого бейзлайна. Она несущественно отличается от вышеописанной и содержит сотни тысяч обучаемых параметров. Тяжелые модели склонны переобучаться, запоминая обучающую выборку и показывая низкое качество на новых объектах. На курсах по машинному обучению учат использовать L1 и L2 регуляризацию в контексте логистической регрессии для борьбы с переобучением, будем использовать это знание и установим коэффициенты регуляризации для всех параметров нейронной сети. Не забудем использовать Dropout перед полносвязным слоем и SpatialDropout1D после эмбеддинг-слоя, также стоит помнить что всегда можно облегчить сеть, уменьшив размеры скрытых слоев.

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

Из графика видно, что распределение находится в семействе экспоненциальных, это приводит при стратегии паддинга до максимальной длины к увеличению объема входных данных в нейронную сеть на три порядка. Простым решением данной проблемы, ускоряющим обучение в 3 раза, является подход Sequence Bucketing, предлагающий нарезать датасет на группы-бакеты в зависимости от их длины и семплировать батчи из одного бакета. При обучении рекуррентных слоев рекомендуется задавать такой набор параметров сети, при котором поддерживается cudnn-реализация, ускоряющая обучение в этой задаче в пять раз.

Допустим, ваша сеть одновременно учится быстро и не переобучается. Предлагаем проверить, что вы используете все идеи из следующего списка, для получения наилучшего качества:

1. Cyclical Learning Rate благодаря стратегии изменения LR позволяет не переобучаться на первой эпохе за счет низкого базового LR и не застревать в локальных минимумах за счет пилообразной-затухающей стратегии. Гиперпараметры base_lr и max_lr можно задать при помощи алгоритма LRFinder. Дополнительно стоит обратить внимание на One Cycle Policy и Super-Convergence.

   

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

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

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

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

Продакшн

Транзакции в hadoop обновляются раз в день, поэтому online-обработка не требуется, в худшем случае нужно успевать прогонять pipeline за 24 часа. Pipeline реализован в виде DAG на airflow, состоящем из следующих этапов:

1. Дозагрузка и агрегация новых данных на pyspasrk. В модели используется история транзакции по каждому пользователю за предыдущий год. Оптимальным сценарием является поддержание исторических предобработанных данных на момент предыдущего запуска модели с добавлением новых данных. На выходе: относительно-компактный parquet-датафрейм.

2. Предсказание на python с использованием одного из фреймворка: tensorfow, pytorch. На выходе: tsv-таблица, содержащая id и множество полей с предсказаниями моделей.

3. Выгрузка предсказаний в hadoop и на вход финальной модели.

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

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

Полезные ссылки и материалы

Впрошлой статьебыла попытка показать весь процесс обучения, отбора и тестирования моделей на торговой паре EUR/USD. В Google Colab работала схема:обучаем модели->тестируем->рисуем на графике. Попытка оказалась неудачной. Стремление не тащить в Colab тонну кода, а максимально все упростить привело к очень низкому качеству обучения. Сигналы выглядели неубедительно и кучковались в очевидных местах.

С тех пор утекло много воды, исследования продолжались. Об этом и расскажу + очередной Colab, на этот раз проще и нагляднее.

Двигаемся дальше

По итогам предыдущего этапа разработки, нейросеть таки стала что то предсказывать. На графиках появился более-менее адекватный прогноз, по качеству напоминающий средний индикатор. Практического толку немного, но достаточно, что бы дальше заниматься этим направлением. Основными недостатками было низкое качество прогнозирования и группировка сигналов в очевидных местах.

В прошлой статье об этом было подробно, а здесь просто напомню, что нейросеть отвечает на вопрос куда пойдет цена "вверх" или "вниз" и не отвечает на вопрос насколько сильно будет движение. Ответ бинарный: 1 - вверх, 0 - вниз. Т.е. если после опроса вернулся ответ [0.8, 0.2] это значит "пойдет вверх", а [0.4, 0.6] "наверно пойдет вниз, но это не точно". Разница внутри этих бинарных ответов характеризует степень уверенности сети, +0.6 в первом случае и -0.2 во втором. Чем больше эта разница стремится к 1 (или -1), тем выше качество прогноза.

"Степень уверенности" при которой ответ можно считать сигналом, индивидуальна для каждой модели и определяется при прогоне на тестовых данных. Более того, этот порог различен для сигналов "вверх" и "вниз". Модели, которые будут загружены в колаб, имеют название файла типа BTCUSD_M6_0.66_0.75.h5
Последние два значения и есть эти лимиты. Перед опросом модели из ее названия вынимаются значения срабатывания и сравниваются с ее ответом.

На практике, такой подход привел к тому, что нейросеть оказалась хитрым и ленивым созданием. Она может долго молчать не давая внятных ответов, а потом в очевидном месте выдать десяток сигналов подряд как бы говоря"вы хотели много сигналов? вы их имеете!", а то, что по сути это один сигнал ее не волнует. Такое поведение как раз и объясняется тем, что "сигналом" является переход вышеупомянутого порога. Поэтому, подряд идущие ответы со значениями выше порога дают кучу точек в одном месте на графике.

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

Когда эта задачка решилась, возникла необходимость всю эту красоту нарисовать и выставить напоказ. Сегодня браузер является самым массовым средством доставки. Беру открытую библиотеку которая рисует свечи а-ля TradingView, добавляю туда свои сигналы, быстро все это собираю "на коленке" и готово... таков был первоначальный наивный план. На практике, после питона вникать в JavaScript + Vue + NodeJS оказалось погружением в ад. В итоге,сайтзаработал, но тормозит и периодически подвисает, зато график BTC/USD на свечах 5m похож на новогоднюю елку.

Google Colab

В колабе к этой статье будет следующее:

1. установим/подключим все нужные библиотеки

2. загрузим уже обученные модели

3. скачаем данные по паре BTC/USD за последние две недели, в данных будет время, цена и вектор для опроса моделей (подробнее было в предыдущей статье).

4. нарисуем графики с прогнозами, каждый прогноз на, примерно, 1 час вперед.

"Муть какая-то..."скажет внимательный читатель."Ты даешь нам готовые модели + данные из истории. А может модели переобучены на этих данных? Поэтому и прогнозируют".

Читатель был бы прав если бы не одно "но". Модели не меняются, а вот данные подгружаются с биржи самые последние разбитые на свечи 6м, т.е. каждые 6 минут добавляется новый блок данных, всего 3000 блоков. Через сутки график обновится примерно на 10%, а через две недели на 100%. Последний раздел колаба дает возможность скачать архив моделей. Потом архив можно вернуть обратно и проверить результат спустя сутки или более.

Google Colab можно найти поэтой ссылке. Не забудьте сначала залогиниться в свою учетную запись на Google (или Gmail).

Копируйте ноутбук себе.

Если выпрыгнет предупреждение типа
Warning: This notebook was not authored by Google
соглашайтесь и продолжайте, никакие данные не собираются, весь код открыт.

Теперь нужно последовательно запускать блоки сверху вниз...
На этом все.

P.S. Не пытайтесь заработать на реальном рынке, 97% начинающих теряют депозит. Цель исследования - решить интересную задачу.

Background Cleaner API полностью бесплатный API для удаления фона с изображений с помощью нейросети. Его можно назвать бесплатным аналогом известного remove.bg.

Данный API, в отличии от вышеупомянутого remove.bg, не накладывает никаких ограничений на число запросов. Нейросеть вернёт обрезанное изображение в исходном качестве.

Адрес API-сервиса:http://roughs.ru/api/remove-bg
Поддерживаются как GET, так и POST запросы.

Для обрезки фона изображения необходимо передать параметрurl, содержащий адрес изображения в сети. Форматы изображений: JPEG, PNG.

Пример запроса:

http://roughs.ru/api/remove-bg?url=https://cdn.wallpapersafari.com/43/39/Vih9G5.jpg

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