Как написать ии на c

Нейронные сети: распознавание образов и изображений c помощью ИИ

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

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

Что такое нейронная сеть: кратко

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

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

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

Сверточные нейронные сети

Сверточная НС имеет специальную архитектуру, которая позволяет ей максимально эффективно распознавать образы. Сама идея СНС основывается на чередовании сверточных и субдискретизирующих слоев (pooling), а структура является однонаправленной. СНС получила свое название от операции свертки, которая предполагает, что каждый фрагмент изображения будет умножен на ядро свертки поэлементно, при этом полученный результат должен суммироваться и записаться в похожую позицию выходного изображения. Такая архитектура обеспечивает инвариантность распознавания относительно сдвига объекта, постепенно укрупняя «окно», на которое «смотрит» свёртка, выявляя всё более и более крупные структуры и паттерны в изображении.

Применение нейронной сети в распознавании изображений

Работа с изображениями — важная сфера применения технологий Deep Learning. Глобально все изображения со всех камер мира составляют библиотеку неструктурированных данных. Задействовав нейросети, машинное обучение и искусственный интеллект, эти данные структурируют и используют для выполнения различных задач: бытовых, социальных, профессиональных и государственных, в частности, обеспечения безопасности.

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

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

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

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

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

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

В какой-то момент увеличение числа слоёв приводит к просто запоминанию выборки, а не обучению. Далее — за счёт хитрых архитектур.

Как нейросеть решает задачи по распознаванию образов

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

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

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

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

В целом создание нейронной сети для распознавания изображений включает в себя:

6 инструментов с искусственным интеллектом, помогающие писать код

Искусственный интеллект не только сочиняет тексты и рисует картинки, но и помогает писать код. Современные AI-инструменты на основе больших языковых моделей в действительности могут генерировать практически что угодно — от музыкальных треков до полноценных финансовых моделей. Чем код хуже?

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

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

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

OpenAI Codex + GitHub Copilot

Ребята из OpenAI подарили нам не только ChatGPT, но и другие полезные штуки — например, DALL·E, инструмент для генерации изображений. А еще из-под их пальцев вышел OpenAI Codex — основанная на GPT-3 модель машинного обучения, которая способна писать код на самых востребованных языках программирования: JavaScript и TypeScript, PHP, Perl, Ruby и других. Обучена модель на миллионах строчек кода из репозиториев GitHub и других открытых источников.

На OpenAI Codex основан GitHub Copilot — готовый генератор кода, который есть в виде плагина к VSCode и другим средам разработки. Он создает код, основываясь на заявках, написанных простым человеческим языком, и неплохо с этим справляется, по сути заменяя Google и Stack Overflow. Если научиться составлять грамотные промты, он сэкономит часы кодинга.

Polycoder

Polycoder — это как OpenAI Codex, но с открытым исходным кодом. Он основан на языковой модели OpenAI GPT-2, обучен на 249 Гб данных, способен генерировать код на 12 языках программирования, включая JavaScript, TypeScript, C, C# и C++, Python, и тоже готов заменить начинающим и опытным кодерам Stack Overflow, только совершенно бесплатно и с возможностью развернуть его локально. Разработчики Polycoder уверяют, что на C их искусственный интеллект пишет лучше, чем Codex.

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

Tabnine

Тогда как GitHub Copilot и Polycoder генерирует код на основе заявок, Tabnine его дописывает. И не только отдельные теги, но и полноценные строчки кода и функции. Причем, будучи моделью машинного обучения, Tabnine работает с контекстом и даже копирует стиль программирования конкретного разработчика.

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

Есть и недостаток — в бесплатной версии Tabnine будет дописывать только слова. Полный функционал начинается с платных тарифов от $12 в месяц.

Mintlify

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

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

CodeT5

В инструментарии разработчиков есть модели машинного обучения, которые позволяют переводить человеческий язык в программный. Значимая среди них фигура — CodeT5 от команды SalesForce, инструмент с открытым исходным кодом, основанный на фреймворке T5 от Google.

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

CodeT5 обучили на более чем 8 миллионах строчек кода из публичных репозиториев GitHub. Он знает JavaScript, Python, C и C#, PHP и другие языки программирования.

Cogram

Cogram — еще один no-code инструмент для генерации кода, только заточен он под дата сайентистов и разработчиков на Python, использующих SQL-запросы и интерактивные блокноты Jupyter.

Cogram берет составленный простым человеческим языком запрос и переводит его на язык баз данных — то есть SQL. Он поддерживает такие БД как MySQL, PostgreSQL, SQLite и Amazon Redshift.

Инструмент интегрируется со средой разработки Jupyter и генерирует код, реагируя в том числе на контекст в зависимости от комментариев. И даже умеет делать визуализации при помощи Seaborn, Plotly или Matplotlib — полезная фича для дата сайентистов.

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

Пример простой нейросети на С/C++

Решил поделиться простым и ёмким на мой взгляд решением нейронной сети на С++.

Почему эта информация должна быть интересна?

Ответ: я старался в минимальном наборе запрограммировать работу многослойного перцептрона, да так, чтобы его можно было настраивать как душе угодно всего в нескольких строчках кода, а реализация основных алгоритмов работы на «С» позволит с лёгкостью переносить на «С» ориентированные языки(в прочем и на любые другие) без использования сторонних библиотек!

Прошу взглянуть на то, что из этого вышло

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

Исходный код вы найдёте в конце статьи, а пока по порядку.

Начнём разбор

1) Архитектура и технические подробности

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

пример конфигурации

myNeuero.cpp

 inputNeurons = 100; //ширина входного слоя outputNeurons =2; //ширина выходного слоя nlCount = 4; //количество слоёв ( по факту их 3, указываемое число намеренно увеличено на 1 list = (nnLay*) malloc((nlCount)*sizeof(nnLay)); inputs = (float*) malloc((inputNeurons)*sizeof(float)); targets = (float*) malloc((outputNeurons)*sizeof(float)); list[0].setIO(100,20); //установка ширины INPUTS/OUTPUTS для каждого слоя list[1].setIO(20,6); // -//- list[2].setIO(6,3); // -//- list[3].setIO(3,2); // -//- выходной слой 

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

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

— реализация механизма обратного распространения ошибки с возможностью задания скорости обучения

 #define learnRate 0.1 

— установка начальных весов

 #define randWeight (( ((float)qrand() / (float)RAND_MAX) - 0.5)* pow(out,-0.5)) 

Примечание: если слоёв больше трёх (nlCount > 4), то pow(out,-0.5) необходимо увеличивать, чтобы при прямом прохождении сигнала его энергия не сводилась к 0. Пример pow(out,-0.2)

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

Структура слоя

 struct nnLay < int in; int out; float** matrix; float* hidden; float* errors; int getInCount()int getOutCount() float **getMatrix() void updMatrix(float *enteredVal) < for(int ou =0; ou < out; ou++) < for(int hid =0; hid < in; hid++) < matrix[hid][ou] += (learnRate * errors[ou] * enteredVal[hid]); >matrix[in][ou] += (learnRate * errors[ou]); > >; void setIO(int inputs, int outputs) < in=inputs; out=outputs; hidden = (float*) malloc((out)*sizeof(float)); matrix = (float**) malloc((in+1)*sizeof(float)); for(int inp =0; inp < in+1; inp++) < matrix[inp] = (float*) malloc(out*sizeof(float)); >for(int inp =0; inp < in+1; inp++) < for(int outp =0; outp < out; outp++) < matrix[inp][outp] = randWeight; >> > void makeHidden(float *inputs) < for(int hid =0; hid < out; hid++) < float tmpS = 0.0; for(int inp =0; inp < in; inp++) < tmpS += inputs[inp] * matrix[inp][hid]; >tmpS += matrix[in][hid]; hidden[hid] = sigmoida(tmpS); > >; float* getHidden() < return hidden; >; void calcOutError(float *targets) < errors = (float*) malloc((out)*sizeof(float)); for(int ou =0; ou < out; ou++) < errors[ou] = (targets[ou] - hidden[ou]) * sigmoidasDerivate(hidden[ou]); >>; void calcHidError(float *targets,float **outWeights,int inS, int outS) < errors = (float*) malloc((inS)*sizeof(float)); for(int hid =0; hid < inS; hid++) < errors[hid] = 0.0; for(int ou =0; ou < outS; ou++) < errors[hid] += targets[ou] * outWeights[hid][ou]; >errors[hid] *= sigmoidasDerivate(hidden[hid]); > >; float* getErrors() < return errors; >; float sigmoida(float val) < return (1.0 / (1.0 + exp(-val))); >float sigmoidasDerivate(float val) < return (val * (1.0 - val)); >; >; 

2) Применение

Тестирование проекта с набором mnist произошло удачно, удалось добиться условной вероятности распознавания рукописного текста 0,9795 (nlCount = 4, learnRate = 0.03 и несколько эпох). Основная цель теста была в проверке работоспособности нейронной сети, с чем она справилась.

Ниже мы рассмотрим работу на «условной задаче».

Исходные данные:

-2 случайных входных вектора размером в 100 значений
-нейросеть со случайной генерацией весов
-2 заданные цели

Код в функции main()

 < //. ________ ДЛЯ ВЫВОДА ВМЕСТО qDebug() можете использовать std::cout или std::cerr myNeuro *bb = new myNeuro(); //----------------------------------INPUTS----GENERATOR------------- /! создаём 2 случайнозаполненных входных вектора qsrand((QTime::currentTime().second())); float *abc = new float[100]; for(int i=0; i<100;i++) < abc[i] =(qrand()%98)*0.01+0.01; >float *cba = new float[100]; for(int i=0; i <100;i++) < cba[i] =(qrand()%98)*0.01+0.01; >//---------------------------------TARGETS----GENERATOR------------- // создаем 2 цели обучения float *tar1 = new float[2]; tar1[0] =0.01; tar1[1] =0.99; float *tar2 = new float[2]; tar2[0] =0.99; tar2[1] =0.01; //--------------------------------NN---------WORKING--------------- // первичный опрос сети bb->query(abc); qDebug()query(cba); // обучение int i=0; while(i<100000) < bb->train(abc,tar1); bb->train(cba,tar2); i++; > //просмотр результатов обучения (опрос сети второй раз) qDebug()query(abc); qDebug()query(cba); >

Результат работы нейронной сети

Итоги

Как вы видите, вызов функции query(inputs) до обучения для каждого из векторов не даёт нам судить об их отличиях. Далее, вызывая функцию train(input, target), для обучения с целью расстановки весовых коэффициентов так, чтобы нейросеть в последующем могла различать входные вектора.

После завершения обучения наблюдаем, что попытка сопоставить вектору «abc» — «tar1», а «cba» — «tar2» удалась.

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

P.S.: данный код писался из QtCreator, надеюсь «заменить вывод» вам не составит труда, оставляйте свои замечания и комментарии.

P.P.S.: если кому интересен детальный разбор работы struct nnLay<> пишите, будет новый пост.

P.P.P.S.: надеюсь кому нибудь пригодится «С» ориентированный код для переноса на другие инструменты.

Исходники

#include #include #include #include "myneuro.h" int main(int argc, char *argv[]) < QCoreApplication a(argc, argv); myNeuro *bb = new myNeuro(); //----------------------------------INPUTS----GENERATOR------------- qsrand((QTime::currentTime().second())); float *abc = new float[100]; for(int i=0; i<100;i++) < abc[i] =(qrand()%98)*0.01+0.01; >float *cba = new float[100]; for(int i=0; i <100;i++) < cba[i] =(qrand()%98)*0.01+0.01; >//---------------------------------TARGETS----GENERATOR------------- float *tar1 = new float[2]; tar1[0] =0.01; tar1[1] =0.99; float *tar2 = new float[2]; tar2[0] =0.99; tar2[1] =0.01; //--------------------------------NN---------WORKING--------------- bb->query(abc); qDebug()query(cba); int i=0; while(i<100000) < bb->train(abc,tar1); bb->train(cba,tar2); i++; > qDebug()query(abc); qDebug()query(cba); qDebug()

#include "myneuro.h" #include myNeuro::myNeuro() < //--------многослойный inputNeurons = 100; outputNeurons =2; nlCount = 4; list = (nnLay*) malloc((nlCount)*sizeof(nnLay)); inputs = (float*) malloc((inputNeurons)*sizeof(float)); targets = (float*) malloc((outputNeurons)*sizeof(float)); list[0].setIO(100,20); list[1].setIO(20,6); list[2].setIO(6,3); list[3].setIO(3,2); //--------однослойный--------- // inputNeurons = 100; // outputNeurons =2; // nlCount = 2; // list = (nnLay*) malloc((nlCount)*sizeof(nnLay)); // inputs = (float*) malloc((inputNeurons)*sizeof(float)); // targets = (float*) malloc((outputNeurons)*sizeof(float)); // list[0].setIO(100,10); // list[1].setIO(10,2); >void myNeuro::feedForwarding(bool ok) < list[0].makeHidden(inputs); for (int i =1; ireturn; > else < // printArray(list[3].getErrors(),list[3].getOutCount()); backPropagate(); >> void myNeuro::backPropagate() < //-------------------------------ERRORS-----CALC--------- list[nlCount-1].calcOutError(targets); for (int i =nlCount-2; i>=0; i--) list[i].calcHidError(list[i+1].getErrors(),list[i+1].getMatrix(), list[i+1].getInCount(),list[i+1].getOutCount()); //-------------------------------UPD-----WEIGHT--------- for (int i =nlCount-1; i>0; i--) list[i].updMatrix(list[i-1].getHidden()); list[0].updMatrix(inputs); > void myNeuro::train(float *in, float *targ) < inputs = in; targets = targ; feedForwarding(true); >void myNeuro::query(float *in) < inputs=in; feedForwarding(false); >void myNeuro::printArray(float *arr, int s) < qDebug()>

#ifndef MYNEURO_H #define MYNEURO_H #include #include #include #include #define learnRate 0.1 #define randWeight (( ((float)qrand() / (float)RAND_MAX) - 0.5)* pow(out,-0.5)) class myNeuro < public: myNeuro(); struct nnLay< int in; int out; float** matrix; float* hidden; float* errors; int getInCount()int getOutCount() float **getMatrix() void updMatrix(float *enteredVal) < for(int ou =0; ou < out; ou++) < for(int hid =0; hid < in; hid++) < matrix[hid][ou] += (learnRate * errors[ou] * enteredVal[hid]); >matrix[in][ou] += (learnRate * errors[ou]); > >; void setIO(int inputs, int outputs) < in=inputs; out=outputs; hidden = (float*) malloc((out)*sizeof(float)); matrix = (float**) malloc((in+1)*sizeof(float)); for(int inp =0; inp < in+1; inp++) < matrix[inp] = (float*) malloc(out*sizeof(float)); >for(int inp =0; inp < in+1; inp++) < for(int outp =0; outp < out; outp++) < matrix[inp][outp] = randWeight; >> > void makeHidden(float *inputs) < for(int hid =0; hid < out; hid++) < float tmpS = 0.0; for(int inp =0; inp < in; inp++) < tmpS += inputs[inp] * matrix[inp][hid]; >tmpS += matrix[in][hid]; hidden[hid] = sigmoida(tmpS); > >; float* getHidden() < return hidden; >; void calcOutError(float *targets) < errors = (float*) malloc((out)*sizeof(float)); for(int ou =0; ou < out; ou++) < errors[ou] = (targets[ou] - hidden[ou]) * sigmoidasDerivate(hidden[ou]); >>; void calcHidError(float *targets,float **outWeights,int inS, int outS) < errors = (float*) malloc((inS)*sizeof(float)); for(int hid =0; hid < inS; hid++) < errors[hid] = 0.0; for(int ou =0; ou < outS; ou++) < errors[hid] += targets[ou] * outWeights[hid][ou]; >errors[hid] *= sigmoidasDerivate(hidden[hid]); > >; float* getErrors() < return errors; >; float sigmoida(float val) < return (1.0 / (1.0 + exp(-val))); >float sigmoidasDerivate(float val) < return (val * (1.0 - val)); >; >; void feedForwarding(bool ok); void backPropagate(); void train(float *in, float *targ); void query(float *in); void printArray(float *arr,int s); private: struct nnLay *list; int inputNeurons; int outputNeurons; int nlCount; float *inputs; float *targets; >; #endif // MYNEURO_H

Как создать нейросеть с помощью chatGPT

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

erid: LjN8KTEeS
ООО «ИТ Медиа»

erid: LjN8KFUsG
ООО «ИТ Медиа»

Многие слышали о нашумевшей нейронной сети chatGPT от OpenAI, которая способна решать множество текстовых задач: отвечать на вопросы, генерировать идеи и т. д. ChatGPT успешно используется для программирования, так как умеет писать код, находить ошибки в коде, комментировать код и многое другое. Логично, что мы, как Университет искусственного интеллекта, специализируемся на искусственном интеллекте и, естественно, решили попробовать использовать chatGPT для генерации и обучения нейронных сетей и проведения экспериментов. У нас это получилось: chatGPT не только применима, но и значительно упрощает работу по генерации архитектуры нейронных сетей и проведению экспериментов. Ниже приводен пример решения задачи классификации водителей на внимательных, засыпающих, отвлекающихся на телефон и т. п. — классификация изображений на 10 классов. Типовая задача, решать ее мы будем комплексно, начиная с подготовки датасета, который необходим для обучения нейронных сетей. В нашем случае это zip-архив, который надо скачать, подготовить, превратить в обучающие выборки, нормировать и преобразовать перед тем, как подать в нейронную сеть. Часто это гораздо больший рутинный труд для разработчика, чем само обучение нейронной сети. Мы сделаем и то, и другое исключительно с помощью запросов к chatGPT — вся статья представляет собой только запросы в chatGPT, без единой строчки рукописного кода – это был важный критерий. Приводим успешные запросы и пару ошибок для примера. При работе с chatGPT важно уметь правильно задать системе запрос. Она умная и отлично понимает даже сложные комплексные запросы, но иногда человек формулирует запрос так, что системе он не понятен. Поэтому важный скил программирования с помощью chatGPT – промт-инжиниринг, умение правильно поставить задачу. Вообще работа с chatGPT похожа на работу с очень умным junior’ом, который знает всё, что только можно знать в Интернете, но некоторые задачи понимает не так, как нужно. И, повторяю, результат зависит от умения правильно поставить ему задачу. Важный момент: мы будем обсуждать машинное обучение, создание нейронных сетей, поэтому аудитория может разделиться на две части. Первая – те, кто разбирается в машинном обучении и в библиотеке Keras. Для них будут интересны и сами запросы к chatGPT, которые мы сформулировали, и код, который она создает. Вторая часть аудитории – это разработчики, которые не разбираются в машинном обучении и Keras. Скорее всего, им будет не совсем понятно, что происходит (что такое слои, что такое эпохи, что такое батчи), но будет интересен сам формат запросов к chatGPT и то, как мы их формулируем. Возможно, в дальнейшем вы захотите либо изучать машинное обучение, либо программировать с помощью chatGPT, и тогда вам будет полезно посмотреть, какие бывают запросы, как мы их переструктурируем в случае ошибки, даже если вы не до конца будете понимать код созданной нейронной сети на Keras. Рассказываем, как устроены наши данные и как их нужно подготовить для подачи в сеть.

Запрос № 1 к chatGPT:

Напиши подготовку тренировочных данных для нейронной сети по классификации изображений, для чего напиши код скачивания датасета при помощи gdown по этой ссылке и код разархивации датасета из zip-формата в директорию ‘content/cars’. Датасет не поделен на train и test. Он состоит из 10 папок (название каждой соответствует названию категории), каждый файл необходимо открыть при помощи Image.open, не используй генератор. Добавь в код масштабирование данных и приведи y_train к формату one hot encoding. Используй LabelEncoder для кодирования строковых меток в целые числа. Определи список названий классов и количество классов. Создай простую keras-модель на получившихся данных. Ответ chatGPT: import os import gdown import zipfile from PIL import Image from sklearn.preprocessing import LabelEncoder from sklearn.utils import shuffle from sklearn.model_selection import train_test_split import numpy as np from keras.utils import to_categorical from keras.models import Sequential from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D # Скачиваем датасет url = ‘ https://storage.yandexcloud.net/aiueducation/marketing/datasets/reality.zip&#39 ; gdown.download(url, ‘reality.zip’, quiet= False ) # Распаковываем набор данных with zipfile.ZipFile( «reality.zip»,»r» ) as zip_ref: zip_ref.extractall( «content/cars» ) # Загружаем изображения и ярлыки X = [] y = [] classes = os.listdir( «content/cars» ) for i, class_name in enumerate ( classes ): for image_name in os.listdir( «content/cars/» + class_name): image = Image. open ( «content/cars/» + class_name + «/» + image_name) image = image.resize(( 64, 64 )) X.append(np.array(image)) y.append(class_name) # Масштабируем данные X = np.array(X) / 255.0 # Кодируем ярлыки label_encoder = LabelEncoder() y = label_encoder.fit_transform(y) # Приводим ярлыки к формату One-hot encoding num_classes = len(np.unique(y)) y = to_categorical(y, num_classes) # Перемешиваем данные X, y = shuffle(X, y) # Делим набор данных на тренировочную и тестовую выборки X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Создаем простую модель keras model = Sequential() model.add(Conv2D( 32 , ( 3, 3 ), activation= ‘relu’ , input_shape=( 64, 64, 3 ))) model.add(MaxPooling2D(( 2, 2 ))) model.add(Flatten()) model.add(Dense(num_classes, activation= ‘softmax’ )) model. compile (optimizer= ‘adam’ , loss= ‘categorical_crossentropy’ ,
metrics=[ ‘accuracy’ ])

Запрос № 2 к chatGPT:

Теперь напиши, как дополнить этот код, чтобы запустить обучение модели на 10 эпохах, построй график точности по эпохам. Ответ chatGPT: import matplotlib.pyplot as plt # Обучаем модель history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test)) # Рисуем график точности по эпохам обучения plt.plot(history.history[ ‘accuracy’ ]) plt.plot(history.history[ ‘val_accuracy’ ]) plt.title( ‘Model accuracy’ ) plt.ylabel( ‘Accuracy’ ) plt.xlabel( ‘Epoch’ ) plt.legend([ ‘Train’ , ‘Test’ ], loc= ‘upper left’ ) plt.show()
Текстовый комментарий chatGPT: «Добавив этот код, мы запускаем обучение модели на 10 эпохах. Мы сохраняем результат обучения в переменной history, чтобы построить график точности модели по эпохам. Мы используем plt.plot() для отображения истории обучения из history.history[‘accuracy’] (точность на обучающем наборе) и history.history[‘val_accuracy’] (точность на тестовом наборе). И далее добавляем легенду и отображаем график».

Запрос № 3 к сhatGPT:

Это слишком простая модель. Создай более мощную модель, код запуска обучения, график точности, проверь в цикле различные batch_size (32, 64, 128). Ответ chatGPT: from keras.layers import Dropout, BatchNormalization # Создаем более мощную модель model = Sequential() model.add(Conv2D(32, (3, 3), activation= ‘relu’ , input_shape=( 64, 64, 3 ))) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Conv2D( 64 , ( 3, 3 ), activation= ‘relu’ )) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Conv2D( 128 , ( 3, 3 ), activation= ‘relu’ )) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Flatten()) model.add(Dropout( 0.5 )) model.add(Dense(num_classes, activation= ‘softmax ‘ )) model. compile (optimizer= ‘adam’ , loss= ‘categorical_crossentropy’ ,
metrics=[ ‘accuracy’ ]) batch_sizes = [ 32, 64, 128 ] for batch_size in batch_sizes: # Обучаем модель history = model.fit(X_train, y_train, epochs=10, batch_size=batch_size,
validation_data=(X_test, y_test)) # Рисуем график точности по эпохам обучения plt.plot(history.history[ ‘accuracy’ ]) plt.plot(history.history[ ‘val_accuracy’ ]) plt.title( f ‘Model accuracy with batch size ‘) plt.ylabel( ‘Accuracy’ ) plt.xlabel( ‘Epoch’ ) plt.legend([ ‘Train’ , ‘Test’ ], loc= ‘upper left’ ) plt.show()
Получилось не совсем то, что мы хотели: код, созданный chatGPT, не проверяет точность при разных batch_size, а дообучает модель на их разных размерах. Необходимо было более точно составить запрос.

Запрос № 4 к chatGPT:

Сделай код запуска этой модели в цикле с разными размерами batch_size (32, 64, 128), выведи график точности по каждому запуску. Ответ chatGPT: batch_size_list = [ 32, 64, 128 ] for batch_size in batch_size_list: # Создаем более мощную модель model = Sequential() model.add(Conv2D( 32 , ( 3, 3 ), activation= ‘relu’ , input_shape=( 64, 64, 3 ))) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Conv2D(64, ( 3, 3 ), activation= ‘relu’ )) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Conv2D( 128 , ( 3, 3 ), activation= ‘relu’ )) model.add(BatchNormalization()) model.add(MaxPooling2D(( 2, 2 ))) model.add(Flatten()) model.add(Dropout( 0.5 )) model.add(Dense(num_classes, activation= ‘softmax’ )) model. compile (optimizer=’adam’, loss= ‘categorical_crossentropy’ , metrics=[ ‘accuracy’ ]) # Обучаем модель history = model.fit(X_train, y_train, epochs=10, batch_size=batch_size,
validation_data=(X_test, y_test))
# Рисуем график точности по эпохам обучения plt.plot(history.history[‘accuracy’], label= f ‘batch size : ‘ ) plt.title( ‘Model accuracy with different batch sizes’ ) plt.ylabel( ‘Accuracy’ ) plt.xlabel( ‘Epoch’ ) plt.legend(loc= ‘upper left’ ) plt.show()
Таким образом, мы получили (хоть и не с первого раза) то, что хотели (почти). Стоило добавить, что графики нужно было отрисовывать по точности на проверочной выборке.

Запрос № 5 к chatGPT:

1. Использование более мощной модели: использование большего количества сверточных слоев, нейронов и слоев связи.
2. Использование более большого датасета: использование большего количества данных для обучения модели может увеличить точность.
3. Дополнительная аугментация данных: использование аугментации данных, такой как повороты, масштабирование и другие, может помочь модели обобщаться на новые данные.
4. Использование сверточных сетей, предварительно обученных (Transfer Learning): использование предварительно обученных сверточных сетей может существенно увеличить точность модели.
5. Использование другой оптимизации и другой функции потерь для обучения модели: использование более эффективных алгоритмов оптимизации, таких как Adam, RMSprop или Adagrad и использование более подходящей функции потерь для задачи классификации, такой как categorical_crossentropy или sparse_categorical_crossentropy, может помочь улучшить точность модели.
6. Использование регуляризации: использование регуляризации, такой как L1 и L2, может помочь предотвратить переобучение модели.
7. Использование стандартизации данных: использование стандартизации данных может помочь сделать данные более однородными и улучшить точность модели.

Запрос № 6

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

Ответ chatGPT:

from keras import optimizers

optimizer_list = [ ‘adam’, ‘sgd’, ‘rmsprop’, ‘adagrad’ ]

for optimizer in optimizer_list: