Как научиться программировать микроконтроллеры с нуля


Советы начинающим программистам микроконтроллеров / Хабр

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

1. Многие начинающие электронщики не знают с чего начать, поэтому спрашивают совета. Большинство бывалых радиолюбителей ответят, что начни собирать какую нибудь схему. Естественно в голове любого начинающего сразу мелькает LCD дисплей с jpeg картинками, какой нибудь mp3 плеер или часы, без малейшей мысли о том, что не имея базовых знаний это неподъемная задача.

Я категорически против такого подхода. Обычно это все заканчивается — либо ничем, либо забитые форумы с мольбами помочь. Даже если кому то помогают, то в 90% он больше никогда не всплывет на сайтах по электронике. В остальных 10% он так и продолжает заливать форумы мольбами, его будут сначала пинать, затем поливать грязью. Из этих 10% отсеивается еще 9%. Далее два варианта: либо таки до глупой головы доходит и все же происходит goto к началу, либо в особо запущенных вариантах, его удел копировать чужие конструкции, без единой мысли о том как это работает. Из последних зачастую рождаются ардуинщики.

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

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

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

2. Перед решением задачи, дробите ее до абсурда вплоть до «припаять резистор», это помогает, проверено. Мелкие задачи решать куда проще. Когда большая задача разбита на кучу мелких действий, то все что остается — это выполнить их. Могу привести еще один годный совет, хоть он вам и покажется бредовым — заведите блокнотик и пишите в него все что собираетесь сделать. Вы думаете, итак запомню, но нет. Допустим сегодня у меня хорошее настроение и думаю о том, как собрать плату. Запиши план действий: сходить купить резистор, подготовить провода, сделать крепление дисплея. Потом все забудешь, откроешь блокнотик и смотришь — ага сегодня настроение попилить и построгать, сделаю крепление. Или собираешь ты плату и уже осталось допаять последний компонент, но не тут то было резисторы кончились, вот записал бы перед тем как паять, то вспомнил.

3. Не пользуйтесь кодогенераторами, нестандартными фичами и прочими упрощалками, хотя бы на первых этапах. Могу привести свой личный пример. Во времена активного использования AVR я пользовался кодогеном CAVR. Меня он полностью устраивал, хотя все говорили, что он кака. Звоночки звенели постоянно, были проблемы с библиотеками, с синтаксисом, с портированием, но было тяжело от этого отказаться. Я не разбирался как это работает, просто знал где и как поставить галочки.

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

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

4. Изучайте язык Си. Эх, как же часто я слышу, как начинающие радиолюбители хвалятся, что хорошо знают сишку. Для меня это стало кормом, всегда люблю проконсультироваться у таких собеседников. Обычно сразу выясняется, что язык они совершенно не знают. Могу сказать, что не смотря на кажущуюся простоту, людей которые действительно хорошо бы его знали, встречал не так много. В основном все его знают на столько, на сколько требуется для решения задач.

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

Очень многие начинающие брезгуют изучением языка, поэтому если вы не будете как все, то сразу станете на две ступени выше остальных новичков. Так же не никакой разницы, где изучать язык. На мой взгляд, микроконтроллер для этого не очень подходит. Гораздо проще поставить какую нибудь Visual studio или Qt Creator и порешать задачки в командной строке.

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

5. Изучение ассемблера? Бояться его не нужно, равно как и боготворить. Не нужно думать, что умея написать программу на ассемблере, вы сразу станете гуру микроконтроллеров, почему то это частое заблуждение. В первую очередь это инструмент. Даже если вы не планируете использовать его, то все равно я бы настоятельно рекомендовал написать хотя бы пару программ. Это сильно упростит понимание работы микроконтроллера и внутреннего устройства программ.

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

7. Часто народ просит прислать даташит на русском. Даташит — это то, что должно восприниматься как истина, самая верная информация. Даже там не исключены ошибки. Если к этому добавятся ошибки переводчика, он ведь тоже человек, может даже не нарочно, просто опечататься. Либо у него свое видение, может что-то упустить, на его взгляд не важное, но возможно крайне важное для вас. Особенно смешной становится ситуация, когда нужно найти документацию на не сильно популярные компоненты.

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

Мною был проведен эксперимент: в наличии был студент, даташит и гугл переводчик. Эксперимент №1: студенту вручен даташит и дано задание самостоятельно найти нужные значения, результат — «да как я смогу», «да я не знаю английский», «я ничего не нашел/я не понял» типичные фразы, говорящие о том, что он даже не пытался. Эксперимент №2: тому же студенту, вручен все тот же даташит и тоже задание, с той разницей, что я сел рядом. Результат — через 5 минут он сам нашел все нужные значения, абсолютно без моего участия, без знания английского.

8. Изобретайте велосипед. Например, изучаете какую то новую штуку, допустим транзистор, дядька Хоровиц со страниц своей книги авторитетно заявляет, что транзистор усиливает, всегда говорите — НЕ ВЕРЮ. Берем в руки транзистор включаем его в схему и убеждаемся что это действительно так. Есть целый пласт проблем и тонкостей, которые не описываются в книгах. Прочувствовать их можно только, когда возьмешь в руки и попробуешь собрать. При этом получаем кучу попутных знаний, узнаем тонкости. Кроме того, любая теория без практики забудется намного быстрее.

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

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

9. А как бы я сделал это, если бы находился на месте разработчиков? Могу ли я сделать лучше? Каждый раз задавайте себе эти вопросы, это очень хорошо помогает продвигаться в обучении. Например, изучите интерфейсы 1wire, i2c, spi, uart, а потом подумайте чем они отличаются, можно ли было сделать лучше, это поможет осознать почему все именно так, а не иначе. Так же вы будете осознавать, когда и какой лучше применить.

10. Не ограничивайтесь в технологиях. Важно что этот совет имеет очень тонкую грань. Был этап в жизни, когда из каждой подворотни доносилось «надо бы знать ПЛИС», «а вот на ПЛИС то можно сделать». Формально у меня не было целей изучать ПЛИСины, но и пройти мимо было никак нельзя. Этому вопросу было выделено немного времени на ознакомление. Время не прошло зря, у меня был целый ряд вопросов, касаемых внутреннего устройства микроконтроллеров, именно после общения с плисинами я получил ответы на них. Подобных примеров много, все знания, которые я приобретал в том или ином виде, рано или поздно пригодились. У меня нет ни единого бесполезного примера.

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

11. Если спросить начинающего радиолюбителя, что ему больше нравится программирование или схемотехника, то с вероятностью 99% ответ будет программирование. При этом большую часть времени эти программисты тратят на изготовление плат ЛУТом/фоторезистом. Причины в общем то понятны, но довольно часто это переходит в некий маразм, который состоит в изготовлении плат ради изготовления плат.

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

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

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

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

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

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

Еще в самом начале, когда микроконтроллеры были для меня хобби, я много помогал с курсовыми и дипломами разных вузов, просто чтобы оценить свой уровень. Могу сказать уверенно, что уровень в целом невысок вне зависимости от имени вуза. Учиться несколько лет, для того чтобы написать такой диплом, совершенно необязательно. Достигнуть этого можно самостоятельно за весьма короткий срок. И все же зачастую бывали моменты, когда студенты знали какой то предмет, который они проходили на 2-3 курсе, а я этого не знал. Хоть все эти знания и компенсировались самообразованием, но все же лучше было бы не тратить на это время.

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

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

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

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

16. Поздно ли начинать программировать в 20, 30, 40, 50 лет? Практика других людей показывает, что возраст вообще не помеха. Многие почему то не учитывают то, что есть целый пласт работы, которую молодые в силу своих амбиций не хотят делать. Поэтому работодатели предпочитают брать тех, кто будет ее тащить. Это ваш шанс зацепиться, а дальше все зависит только от вас.

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

Как программировать / записывать микроконтроллер

Как программировать микроконтроллер PIC18 на C. Пошаговое руководство (графические изображения)

Как программировать микроконтроллер?

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

В этом руководстве мы запрограммируем или напишем простой код для микроконтроллера PIC18 на языке C, где «C» - широко используемый компьютерный язык, и это единственный поддерживаемый язык (кроме ассемблера) в настоящее время для 8- битовые и 16-битные микроконтроллеры PIC.

PIC10, PIC12, PIC16, PIC18 - серия 8-битных MCU.

PIC24, dsPIC30, dsPIC33 - это серия 16-битных MCU

PIC32 - серия 32-битных MCU.

Как записать закодированную программу в микроконтроллер?

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

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

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

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

Программирование микроконтроллера PIC18 на C.

Microchip Technology - вторая по величине отрасль производства электроники и ИС. Microchip Technology продает микроконтроллеры в 6-контактных корпусах (серия PIC10F2xx), 100-контактных корпусах (dsPIC33EP512MU810) и даже 144-контактных корпусах (некоторые устройства PIC32). Также есть много предыдущих серий, таких как PIC12, PIC16, PIC18.

Введение в целевой контроллер:

Мы собираемся обсудить здесь серию PIC18. Распространенным микроконтроллером этой серии является PIC18f452.Этот контроллер представляет собой 8-битный микроконтроллер с 40 выводами, 32 Кбайт программной памяти и может работать с частотой кристалла до 40 МГц, поэтому этот контроллер подходит для многих приложений.

Этот контроллер может потреблять и обеспечивать ток до 25 мА, поэтому нет необходимости использовать транзистор для управления светодиодом и подключения его к другому оборудованию. Есть 3 внешних контакта прерывания и два 16-битных таймера, один 8-битный таймер. Этот контроллер оснащен модулем захвата и модулем компаратора. Этот контроллер имеет аналогово-цифровой преобразователь, поэтому нет необходимости подключать внешний АЦП к этому устройству.

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

Введение в среду программирования:

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

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

Это определенно сократит время программирования, и вам не придется создавать общие функции с нуля, такие как задержка, чтение и запись с ЖК-дисплея, протокол RS232 и многие другие.

Обратите внимание, что MikroC не является бесплатным программным обеспечением, в то время как MPLAB X IDE и компилятор XC8 от Microchip бесплатны и предлагают множество бесплатных библиотек.

Начнем с примера.

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

Создание нового проекта в MikroC:

Шаг 1:

Дважды щелкните значок MikroC на рабочем столе или в том месте, где вы установили это программное обеспечение (как показано ниже).

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

Шаг 2:
Теперь перейдите к кнопке «Проект» в правом верхнем углу и нажмите «Проект».

Шаг 3:

Теперь нажмите «Сейчас проект», и появится новое окно, показанное ниже.

Шаг 4.

Теперь нажмите «Далее» и выберите нужную тактовую частоту MCU, а также имя проекта и каталог, в котором вы хотите его сохранить.

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

Теперь вы настроили программное обеспечение. Следующий шаг - написание кода.

Запись кода для микроконтроллера PIC18:

PIC18f452 имеет 5 портов. Четыре порта - 8-битные, а один порт - 4-битный. В этом уроке мы будем использовать 8-битный порт.При написании кода для PIC18 вы должны помнить несколько вещей. (Код приведен ниже )

Создание порта как ввода или вывода:

Каждый порт имеет регистр TRISX, который определяет, что вы используете этот порт для ввода или вывода. Где X может быть, A, B, C, D, E, F, например TRISB.

Для вывода вы должны поместить 0x00 в TRISB, а для ввода вы должны поместить в него 0xFF. но это не всегда так, потому что каждый вывод может быть независимо выбран как вход или выход.вы можете записать 0x09 в TRISB, который выберет RB0 и RB3 для входов, а остальные контакты для выходов.

Функция задержки:

В mikroC я выбрал библиотеку задержки, поэтому мне не нужно создавать здесь функции задержки, я могу просто использовать функцию Delay_ms (). В этой функции вы должны указать желаемую задержку в миллисекундах, если вы хотите задержку в 1000 миллисекунд, вы можете записать ее как Delay_ms (1000).

Her e является первым простым переключением кода битов PORT.

  void main () { TRISB = 0x00;  // Определить как выход  While (1)  // Бесконечный цикл  { PORTB = 0x00; Delay_ms (500);  // задержка 500 миллисекунд  PORTB = 0xFF; Delay_ms (500); } }  

После того, как вы напишете этот код, вам придется его скомпилировать.

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

После создания шестнадцатеричного изображения вы можете записать его в свой PIC18f452 с помощью оборудования PICKIT или протестировать его с помощью Proteus.

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

Похожие сообщения:

.

6 шагов для написания любого алгоритма машинного обучения с нуля: пример использования Perceptron | Джон Салливан

Написание алгоритма машинного обучения с нуля - чрезвычайно полезный опыт обучения.

Он дает вам это «ах-ха!» момент, когда он наконец щелкает, и вы понимаете, что на самом деле происходит под капотом.

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

Я проведу вас через следующий 6-этапный процесс написания алгоритмов с нуля, используя Perceptron в качестве примера:

  1. Получите общее представление об алгоритме
  2. Найдите несколько разных источников обучения
  3. Разбейте алгоритм на фрагменты
  4. Начните с простого примера
  5. Подтвердите с помощью надежной реализации
  6. Напишите свой процесс

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

По крайней мере, вы должны быть в состоянии ответить на следующие вопросы:

  • Что это?
  • Для чего он обычно используется?
  • Когда я НЕ МОГУ этим пользоваться?

Что касается персептрона, давайте продолжим и ответим на следующие вопросы:

  • Однослойный персептрон - это самая простая нейронная сеть. Обычно он используется для задач двоичной классификации (1 или 0, «да» или «нет»).
  • Некоторыми простыми применениями могут быть анализ настроений (положительный или отрицательный ответ) или прогнозирование дефолта по ссуде («дефолт», «не дефолт»).В обоих случаях граница принятия решения должна быть линейной.
  • Если граница принятия решения нелинейна, вы действительно не можете использовать персептрон. Для этих задач вам нужно будет использовать что-то другое.

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

Кто-то лучше учится по учебникам, кто-то - по видео.

Лично я люблю прыгать и использовать различные типы источников.

Что касается математических деталей, то учебники отлично справляются с задачей, но для более практических примеров я предпочитаю сообщения в блогах и видео на YouTube.

Вот несколько замечательных источников для персептрона:

Учебники

Блоги

Видео

Теперь, когда мы собрали наши источники, пора приступить к обучению.

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

Запишите пункты списка и попытайтесь обрисовать алгоритм.

Пройдя по источникам, я разбил Персептрон на следующие 5 частей:

  1. Инициализирую веса
  2. Умножьте веса на входные и просуммируйте их
  3. Сравните результат с порогом для вычисления вывода (1 или 0)
  4. Обновить веса
  5. Повторить

Давайте подробно рассмотрим каждый.

1. Инициализируйте веса

Для начала мы инициализируем вектор весов.

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

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

Затем мы умножим веса на входные данные, а затем просуммируем их.

Чтобы упростить работу, я раскрасил веса и соответствующие им элементы в первой строке.

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

Окончательный результат - 0. Я буду обозначать этот временный результат как «f».

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

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

Поскольку скалярное произведение «f», которое мы вычислили (0), не превышает нашего порогового значения (0), наша оценка равна нулю.

Я обозначил оценку как y со шляпой (также известной как «y hat»), с нижним индексом 0, чтобы соответствовать первой строке. Вместо этого вы могли бы использовать 1 для первой строки, это не имеет значения. Я просто решил начать с 0.

Если мы сравним этот результат с фактическим значением, мы увидим, что наши текущие веса неверно предсказывают фактический результат.

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

Теперь мы обновим веса.Вот уравнение, которое мы собираемся использовать:

Основная идея заключается в том, что мы корректируем текущий вес на итерации «n», чтобы получить новый вес для использования в следующей итерации, «n + 1».

Чтобы настроить вес, нам нужно установить «скорость обучения». Обозначается это греческой буквой «эта».

Я выбрал 0,1 для скорости обучения, но вы можете поэкспериментировать с другими числами, как и с порогом.

Вот краткое изложение того, что у нас есть на данный момент:

А теперь давайте посчитаем новые веса для итерации n = 2.

Мы успешно завершили первую итерацию алгоритма персептрона.

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

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

Один полный просмотр набора данных известен как «эпоха».

Поскольку наш набор данных состоит из 3 строк, нам потребуется три итерации, чтобы завершить 1 эпоху.

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

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

На следующей итерации мы переходим ко второй строке функций.

Я не буду повторять каждый шаг снова, но вот следующий расчет скалярного произведения:

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

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

Для простоты я всегда люблю начинать с очень небольшого «игрушечного набора данных».

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

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

Я собираюсь добавить фиктивный объект «x0», который представляет собой столбец из единиц.Я сделал это для того, чтобы наша модель рассчитала член смещения.

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

Вот код для ввода данных:

 # Импорт библиотек 
# NAND Gate
# Примечание: x0 - фиктивная переменная для члена смещения
# x0 x1 x2
x = [[1., 0., 0 .],
[1., 0., 1.],
[1., 1., 0.],
[1., 1., 1.]] y = [1.,
1.,
1.,
0.]

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

Первым шагом является инициализация весов.

 # Инициализировать веса 
import numpy as np
w = np.zeros (len (x [0])) Out:
[0. 0. 0.]

Имейте в виду, что длина вектора весов должна чтобы соответствовать количеству функций. В этом примере логического элемента И-НЕ эта длина равна 3.

Далее мы умножим веса на входные данные, а затем просуммируем их.

Другое название для этого - «скалярное произведение».

Опять же, мы можем использовать Numpy, чтобы легко выполнить эту операцию.Мы будем использовать метод .dot () .

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

 # Точечный продукт 
f = np.dot (w, x [0])
print fOut:
0,0

Как и ожидалось, результат равен 0.

Чтобы соответствовать нашим примечаниям в предыдущем разделе, я назначил скалярное произведение на переменную «f».

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

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

Я собираюсь сделать порог «z» равным 0. Если скалярное произведение «f» больше 0, наш прогноз будет 1. В противном случае он будет равен нулю.

Имейте в виду, что прогноз обычно обозначается с отметкой в ​​каратах сверху, также известной как «шляпа». Переменная, которой я назначу прогноз, - yhat .

 # Функция активации 
z = 0,0
, если f> z:
yhat = 1.
else:
yhat = 0.

print yhat

Out:
0.0

Как и ожидалось, прогноз равен 0.

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

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

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

Нам нужно будет установить скорость обучения, прежде чем мы сможем это сделать. Чтобы соответствовать нашему предыдущему примеру, я присвою скорости обучения «eta» значение 0,1.

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

 # Обновить веса 
eta = 0,1
w [0] = w [0] + eta * (y [0] - yhat) * x [0] [0]
w [1] = w [1] + eta * (y [0] - yhat) * x [0] [1]
w [2] = w [2] + eta * (y [0] - yhat) * x [0] [2]

напечатать w

Out:
[0.1 0. 0.]

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

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

Последняя часть, которую мы не обсуждали, - это наша функция потерь. Это функция, которую мы пытаемся минимизировать, в нашем случае это ошибка суммы квадратов (SSE).

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

Объединив все вместе, вот как выглядит полная функция:

 import numpy as np 

# Perceptron function
def perceptron (x, y, z, eta, t):
'' '
Input Parameters:
x : набор данных входных характеристик
y: фактические выходы
z: порог функции активации
eta: скорость обучения
t: количество итераций
'' '

# инициализация весов
w = np.zeros (len (x [0]))
n = 0

# инициализация дополнительных параметров для вычисления суммы квадратов ошибок
yhat_vec = np.ones (len (y)) # вектор для прогнозов
errors = np.ones (len (y)) # вектор ошибок (фактический - прогнозы)
J = [] # вектор для функции затрат SSE

while n = z:
yhat = 1.
else:
yhat = 0.
yhat_vec [i] = yhat

# обновление весов
для j в xrange (0, len (w)):
w [j] = w [j] + eta * (y [i] -yhat) * x [i] [j]

n + = 1
# вычисление суммы квадратов ошибок
для i в xrange (0, len (y)):
errors [i] = (y [i] -yhat_vec [i]) ** 2
J.append (0,5 * np.sum (errors))

return w, J

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

 # x0 x1 x2 
x = [[1., 0., 0.],
[1., 0., 1.],
[1., 1., 0.],
[1., 1., 1.]]

y = [1. ,
1.,
1.,
0.]

z = 0,0
eta = 0,1
t = 50

print "Веса:"
print perceptron (x, y, z, eta, t) [ 0]

print "Ошибки:"
print perceptron (x, y, z, eta, t) [0]

Out:
Веса:
[0,2 -0,2 -0,1]
Ошибки:
[0,5, 1,5, 1,5, 1,0, 0,5, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0.0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0]

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

Когда ошибка переходит в 0 и остается на этом уровне, мы знаем, что наша модель сходится. Это говорит нам о том, что наша модель правильно «выучила» соответствующие веса.

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

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

Пришло время сравнить наши результаты с проверенной реализацией. Для сравнения воспользуемся перцептроном из scikit-learn.

Мы проведем это сравнение, выполнив следующие шаги:

  1. Импорт данных
  2. Разделение данных на наборы для обучения / тестирования
  3. Обучите наш Perceptron
  4. Протестируйте Perceptron
  5. Сравните с Perceptron
  6. scikit-learn

Начнем с импорта данных.Вы можете получить копию набора данных здесь.

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

 import pandas as pd 
import numpy as np
import matplotlib.pyplot as plt

df = pd.read_csv ("dataset.csv")
plt.scatter (df.values ​​[:, 1], df.values ​​[: , 2], c = df ['3'], alpha = 0.8)

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

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

Я использовал Pandas для импорта csv, который автоматически помещает данные в фрейм данных.

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

Характеристики находятся в столбцах 1 и 2, поэтому я использовал их в функции диаграммы рассеяния. Столбец 0 - это фиктивная функция единиц, которую я включил, чтобы вычислить точку пересечения. Это должно быть знакомо тому, что мы делали с вентилем NAND в предыдущем разделе.

Наконец, я раскрасил два класса, используя c = df ['3'], alpha = 0.8 в функции диаграммы рассеяния. Результатом являются данные в столбце 3 (0 или 1), поэтому я сказал функции раскрасить два класса, используя столбец «3».

Дополнительную информацию о функции диаграммы рассеяния Matplotlib можно найти здесь.

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

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

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

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

 df = df.values ​​

np.random.seed (5)
np.random.shuffle (df)

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

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

Далее я разделю 70% моих данных на обучающий набор и 30% на тестовый набор.

 поезд = df [0: int (0.7 * len (df))] 
test = df [int (0.7 * len (df)): int (len (df))]

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

 x_train = train [:, 0: 3] 
y_train = train [:, 3]

x_test = test [:, 0: 3]
y_test = test [:, 3]

Я выбрал 70% / 30 % для моих наборов поездов / тестов только для этого примера, но я рекомендую вам изучить другие методы, такие как перекрестная проверка в k-кратном размере.

Далее мы обучим нашего персептрона.

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

 def perceptron_train (x, y, z, eta, t): 
''
Входные параметры:
x: набор данных входных функций
y: фактические выходы
z: порог функции активации
eta: скорость обучения
t : количество итераций
'' '

# инициализация весов
w = np.zeros (len (x [0]))
n = 0

# инициализация дополнительных параметров для вычисления суммы квадратов ошибок
yhat_vec = np .ones (len (y)) # вектор для прогнозов
errors = np.ones (len (y)) # вектор для ошибок (фактическое - прогнозы)
J = [] # вектор для функции стоимости SSE

при n = z:
yhat = 1.
else:
yhat = 0.
yhat_vec [i] = yhat

# обновление весов
для j в xrange (0, len (w)):
w [j] = w [j] + eta * (y [i] -yhat) * x [i] [j]

n + = 1
# вычисление суммы квадратов ошибок
для i в xrange (0, len (y)):
errors [i] = (y [i] -yhat_vec [ i]) ** 2
J.append (0,5 * np.sum (errors))

return w, J

z = 0,0
eta = 0,1
t = 50

perceptron_train (x_train, y_train, z, eta , t)

Давайте продолжим и посмотрим на веса и ошибку суммы квадратов.

 w = perceptron_train (x_train, y_train, z, eta, t) [0] 
J = perceptron_train (x_train, y_train, z, eta, t) [1]

print w
print J

Out:
[-0.5 -0,29850122 0,35054929]
[4,5, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0]

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

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

Пришло время протестировать наш персептрон. Для этого мы создадим небольшую функцию perceptron_test .

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

Единственная деталь, которую мы не видели, - это precision_score . Это метрическая функция оценки от scikit-learn. Вы можете узнать об этом подробнее здесь.

Собирая все это вместе, вот как выглядит код:

 из sklearn.metrics import precision_score 

w = perceptron_train (x_train, y_train, z, eta, t) [0]

def perceptron_test (x, w, z, eta, t):
y_pred = []
для i в xrange (0, len (x-1)):
f = np.dot (x [i], w)

# функция активации
if f > z:
yhat = 1
else:
yhat = 0
y_pred.append (yhat)
return y_pred

y_pred = perceptron_test (x_test, w, z, eta, t)

print "Оценка точности:"
print precision_score (y_test, y_pred)

Out:
Оценка точности:
1,0

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

Последний шаг - сравнить наши результаты с Perceptron из scikit-learn. Вот код этой модели:

 от sklearn.linear_model import Perceptron 

# обучение sklearn Perceptron
clf = Perceptron (random_state = None, eta0 = 0.1, shuffle = False, fit_intercept = False)
clf.fit (x_train, y_train)
y_predict = clf_179000 (x_predict = clf_179) 9

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

 Out: 
Вес склеарна:
[-0,5 -0,29850122 0,35054929]
Вес моего персептрона:
[-0,5 -0,29850122 0,35054929]

Вес из модели scikit-learn идентичен нашему весу.Это означает, что наша модель работает правильно, и это отличная новость.

Прежде чем мы подведем итоги, нужно остановиться на нескольких незначительных моментах. В модели scikit-learn нам нужно было установить случайное состояние на «None» и выключить перемешивание. Мы уже установили случайное начальное число и перетасовали данные, поэтому нам не нужно было делать это снова.

Нам также пришлось установить скорость обучения «eta0» на 0,1, чтобы она была идентична нашей модели.

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

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

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

Этот последний шаг в процессе, вероятно, самый важный.

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

Описание процесса важно по двум причинам:

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

c - Какой язык выучить для программирования микроконтроллеров?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и родственная техническая карьера
.

Как разработать модель машинного обучения с нуля | Виктор Роман

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

Конкретно в статье будет рассмотрено, как:

  • Определить адекватно нашу проблему (цель, желаемые результаты…).
  • Соберите данные.
  • Выберите меру успеха.
  • Установите протокол оценки и различные доступные протоколы.
  • Подготовьте данные (имея дело с пропущенными значениями, с категориальными значениями…).
  • Спилите правильно данные.
  • Проведите различие между переоборудованием и недостаточным соответствием, определив, что это такое, и объяснив, как их избежать.
  • Обзор того, как модель учится.
  • Что такое регуляризация и когда целесообразно ее использовать.
  • Разработайте эталонную модель.
  • Выберите подходящую модель и настройте ее на максимальную производительность.

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

  • Какова основная цель? Что мы пытаемся предсказать?
  • Каковы целевые функции?
  • Какие входные данные? Это доступно?
  • С какими проблемами мы сталкиваемся? Бинарная классификация? Кластеризация?
  • Какое улучшение ожидается?
  • Каков текущий статус целевой функции?
  • Как будет измеряться целевой объект?

Не каждую проблему можно решить, пока у нас не будет работающей модели, мы просто сможем сформулировать определенную гипотезу:

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

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

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

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

Обычно наши данные будут иметь следующую форму:

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

Питер Друкер, преподаватель Гарвардского университета и автор книги «Эффективный руководитель и управление собой», сказал знаменитую поговорку:

«Если вы не можете измерить это, вы не сможете улучшить это».

Если вы хотите контролировать что-то, это должно быть наблюдаемым, и для достижения успеха важно определить, что считается успехом: Может быть, точность? точность? Уровень удержания клиентов?

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

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

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

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

4.1 Поддержание набора проверки удержания

Этот метод заключается в выделении некоторой части данных в качестве набора для тестирования.

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

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

4.2 Проверка K-Fold

K-Fold состоит в разбиении данных на K разделов равного размера. Для каждого раздела i модель обучается с оставшимися разделами K-1 и оценивается на разделе i.

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

4.3 Итерационная проверка K-Fold с перетасовкой

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

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

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

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

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

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

5.1 Работа с отсутствующими данными

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

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

  1. Удаление образцов или объектов с пропущенными значениями. (мы рискуем удалить релевантную информацию или слишком много выборок)
  2. Ввод недостающих значений с помощью некоторых встроенных оценщиков, таких как класс Imputer из scikit learn. Мы сопоставим наши данные, а затем преобразуем их, чтобы оценить их. Один из распространенных подходов - установить пропущенные значения как среднее значение для остальных образцов.

5.2 Работа с категориальными данными

При работе с категориальными данными мы работаем с порядковыми и номинальными признаками. Порядковые признаки - это категориальные признаки, которые можно сортировать (размер ткани : L ). А по номиналу не подразумевается какой-либо заказ ( цвет ткани: желтый, зеленый, красный ).

Методы работы с порядковыми и номинальными признаками:

  • Отображение порядковых признаков : чтобы убедиться, что алгоритм правильно интерпретирует порядковые признаки, нам необходимо преобразовать категориальные строковые значения в целые числа.Часто мы делаем это сопоставление вручную. Пример: L: 2, M: 1, S: 0.
  • Кодирование меток номинального класса : Наиболее распространенным подходом является выполнение однократного кодирования, которое заключается в создании нового фиктивного объекта для каждого уникального значения в столбце номинального признака. Пример: в столбце цвета, если у нас есть три класса: желтый, красный, зеленый и выполняется одноразовое кодирование, мы получим три новых столбца, по одному для каждого уникального класса. Тогда, если у нас есть желтая рубашка, она будет выбрана как: желтый = 1, зеленый = 0, красный = 0.Это сделано для обеспечения хорошей производительности алгоритма, поскольку они намного более эффективны при работе с разреженной матрицей (матрицы с низкой плотностью, с большим количеством значений 0).

5.3 Масштабирование функций

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

  • Нормализация: это изменение масштаба функций в диапазоне [0,1], что является частным случаем масштабирования min-max.Чтобы нормализовать наши данные, нам просто нужно применить метод масштабирования min-max к каждому столбцу функций.
  • Стандартизация: она заключается в центрировании столбцов признаков по среднему значению 0 со стандартным отклонением 1, чтобы столбцы признаков имели те же параметры, что и стандартное нормальное распределение (нулевое среднее и единичная дисперсия). Это значительно упрощает алгоритмам обучения определение весов параметров. Кроме того, он сохраняет полезную информацию о выбросах и делает алгоритмы менее чувствительными к ним.

5.4 Выбор значимых функций

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

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

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

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

5.5 Разделение данных на подмножества

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

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

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

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

а) Процесс обучения

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

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

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

Формула прямой: y = B0 + B1x + u . Где x - входные данные, B1 - наклон, B0 - точка пересечения по оси Y, u - остаток и y - значение линии в позиции x .

Доступные для обучения значения: B0 и B1 , которые являются значениями, которые влияют на положение строки, поскольку единственными другими переменными являются x (вход и y, выход (остаток не учитывается). ).Эти значения ( B0 и B1 ) являются «весами» функции прогнозирования.

Эти веса и другие, называемые смещениями, представляют собой параметры, которые будут организованы вместе в виде матриц ( W, для весов и b для смещений).

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

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

b) Переоснащение и недостаточное оснащение

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

  • Оптимизация - это процесс настройки модели для получения максимальной производительности на обучающих данных (процесс обучения).
  • Обобщение - насколько хорошо модель работает с невидимыми данными.Цель состоит в том, чтобы получить наилучшую способность к обобщению.

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

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

Есть два способа избежать этого переобучения: получение дополнительных данных и регуляризация.

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

Регуляризация выполняется в основном следующими методами:

  1. Уменьшение размера модели: уменьшение количества обучаемых параметров в модели, а вместе с ними и ее способности к обучению. Цель состоит в том, чтобы найти золотую середину между слишком большой и недостаточной способностью к обучению. К сожалению, нет никаких волшебных формул для определения этого баланса, его нужно проверять и оценивать, задав различное количество параметров и наблюдая за его работой.
  2. Добавление регуляризации веса: В целом, чем проще модель, тем лучше. Пока она может хорошо учиться, более простая модель вряд ли переобучится. Обычный способ добиться этого - ограничить сложность сети, заставив ее веса принимать только небольшие значения, упорядочивая распределение значений весов. Это делается путем добавления к функции потерь сети стоимости, связанной с большими весами. Стоимость возникает двумя способами:
  • Регуляризация L1: Стоимость пропорциональна абсолютному значению весовых коэффициентов (норма весов L1).
  • Регуляризация L2: Стоимость пропорциональна квадрату значения весовых коэффициентов (норма весов l2)

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

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

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

Как показано на «https://blog.dominodatalab.com/benchmarking-predictive-models/»

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

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

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

7.1 Поиск хорошей модели

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

  • Количество складок, по которым мы разделим наши данные.
  • Метод подсчета баллов (зависит от природы проблемы - регрессия, классификация…).
  • Некоторые подходящие алгоритмы, которые мы хотим проверить.

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

  # Параметры тестирования и метрики оценки  
num_folds = 10
scoring = "neg_mean_squared_error" # Алгоритмы выборочной проверки
models = []
models.append (('LR', LinearRegression ()))
models.append (('LASSO', Lasso ()))
models.append (('EN', ElasticNet ()))
models.append (('KNN ', KNeighborsRegressor ()))
models.append ((' CART ', DecisionTreeRegressor ()))
models.append ((' SVR ', SVR ()))

results = []
names = []
для имени , модель в моделях:
kfold = KFold (n_splits = num_folds, random_state = seed)
cv_results = cross_val_score (model, X_train, y_train, cv = kfold, scoring = scoring)
results.append (cv_results)
имен.append (name)
msg = "% s:% f (% f)"% (name, cv_results.mean (), cv_results.std ())
print (msg)

   # Сравнить алгоритмы   
fig = pyplot.figure ()
fig.suptitle ('Сравнение алгоритмов')
ax = fig.add_subplot (111)
pyplot.boxplot (результаты)
ax.set_xticklabels (имена)
pyplot.show ()

7.2 Настройка Гиперпараметры модели

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

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

Процесс будет следующим:

  • Установите сетку параметров, которую мы будем оценивать. Мы сделаем это, создав словарь всех параметров и соответствующих им наборов значений, которые вы хотите протестировать на лучшую производительность.
  • Задайте количество складок, случайное состояние и метод оценки.
  • Постройте объект K-Fold с выбранным количеством складок.
  • Создайте объект поиска по сетке с выбранной моделью и подогнайте его.
  # Построить масштабатор  
scaler = StandardScaler (). Fit (X_train)
rescaled X = scaler.transform (X_train) # Построить сетку параметров
c_values ​​= [0,1, 0,3, 0,5, 0,7, 0,9, 1,0 , 1.3, 1.5, 1.7, 2.0]
kernel_values ​​= ['linear', 'poly', 'rbf', 'sigmoid']
param_grid = dict (C = c_values, kernel = kernel_values) # Построить модель
model = SVC ()
kfold = KFold (n_splits = num_folds, random_state = seed)
grid = GridSearchCV (оценка = модель, param_grid = param_grid, scoring = scoring, cv = kfold)
grid_result = grid.fit (rescaledX, y_train) # Показать результаты
print ("Best:% f using% s"% (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results _ ['mean_test_score']
stds = grid .cv_results _ ['std_test_score']
params = grid_result.cv_results _ ['params']
для среднего, stdev, param в zip (означает, stds, params):
print ("% f (% f) with:% r" % (mean, stdev, param))

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

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

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

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

Спасибо за чтение и следите за обновлениями!

.

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