Содержание

Резиновая петля тренировочная XS (1,3 см) длинная MD Buddy MD1353 красная

Резиновая петля тренировочная XS (1,3 см) длинная MD Buddy MD1353 красная |. Спортивный инвентарь

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

0.0121100307 c

700 р

588 р

Защита покупателя Нашли дешевле?

Shop

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

Артикул: 12774d42-7f22-11e8-9c34-b8aeedb7d51d

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

В отличие от аптечных резиновых жгутов и тонких лент для фитнеса, резиновые петли предназначены для серьезных силовых тренировок.
Длина: 208 см.
Ширина: 1,3 см.
Толщина: 4,5 мм.
Вес: 116 г.
Сопротивление: 9-12 кг. 

Материал: ПВХ. Диаметр: 7,5 см. Вес: 70 г.
Мяч массажный MD Buddy MD1279 используется для самомассажа во время разминки до и после физической… Резиновые петли или резинки для фитнеса — это новый спортивный тренажер, набирающий… Резиновые петли или резинки для фитнеса — это новый спортивный тренажер, набирающий попул… Массажный цилиндр MD Buddy MDF061 — сочетает преимущества массажного ролика и отличного тренажера д…
Гантель виниловая — это литые эргономичные и яркие гантели, которые покрыты мягким приятным на ощуп…

Татьяна 14. 5

04.03.2022

Ольга 11.7

20.02.2022

Полина 13.3

10.02.2022

Елена 14.

9

06.02.2022

Ирина 12.1

04.02.2022

Ольга 15.7

20.01.2022

Елена 16. 0

16.01.2022

Ольга 14.3

10.01.2022

Тамара 14.0

30.12.2021

Смородина 6. 9

28.12.2021

Евгения 13.6

21.12.2021

Ольга 16.1

06. 12.2021

Наталья 14.9

30.11.2021

Мария 12.1

29.11.2021

Елена 13. 4

28.11.2021

Наталья 11.6

26.11.2021

Участник

23.11.2021

Елена 11. 5

14.11.2021

Марина 17.0

09.11.2021

Любовь 15.6

31.10.2021

Олеся 14. 1

08.03.2022

Показать все отзывы

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

500 р 420 р

Мяч массажный MD Buddy MD1279 используется для самомассажа во время разминки до и после физической…

1922 р 1615 р

Благодаря особой технологии плотности, массажный ролик сохраняет свои способности на протяжении дли…

840 р 706 р

Неопрен – это искусственный каучук. Материал обладает рядом положительных свойств. Он водонепроница…

300 р 252 р

Материал: ПВХ. Диаметр: 7,5 см. Вес: 70 г.

630 р 530 р

Неопрен – это искусственный каучук. Материал обладает рядом положительных свойств. Он водонепроница…

400 р 336 р

Материал: ПВХ. Диаметр: 7,5 см. Вес: 70 г.

1400 р 1176 р

Коврик для йоги из ПВХ — самый распространенный вид ковриков. Подходит для большинства по цене и по…

200 р 168 р

Резиновые петли или резинки для фитнеса — это новый спортивный тренажер, набирающий попул…

1547 р 1300 р

Диаметр: 34 см. Вес: 1 кг. Материал: ПВХ. Изготовлен из профессионального противовзрывного ПВХ, кот…

3339 р 2805 р

Массажный цилиндр — сочетает преимущества массажного ролика и отличного тренажера для мышц-стабилиз…

420 р 353 р

Мяч массажный MD Buddy MD1224 используется для самомассажа во время разминки до и после физической…

571 р 480 р

Блоки MD Buddy MD1219 применяются во время занятий йогой для того, чтобы найти опору между полом и…

1760 р 1479 р

Удобный и крайне полезный аксессуар для йоги – массажный ролик, способен разнообразить занятия, сде…

1292 р 1086 р

Массажный цилиндр MD Buddy MDF061 — сочетает преимущества массажного ролика и отличного тренажера д…

1100 р 924 р

Массажный мяч двойной MD Buddy MD1278 используется для самомассажа во время разминки до и после физ…

525 р 441 р

Блоки OKPRO OK1235 применяются во время занятий йогой для того, чтобы найти опору между полом и час…

925 р 777 р

Массажный мяч двойной OKPRO OK1213B используется для самомассажа во время разминки до и после физич…

1838 р 1544 р

Кольцо для пилатеса называют ещё изотоническим. Оно изготовлено из эластичного материала, достаточн…

166 р 140 р

Скакалка гимнастическая OKPRO OK1362 изготовлена из качественных безопасных для здоровья материалов…

1800 р 1512 р

440 р 370 р

Резиновые петли или резинки для фитнеса — это новый спортивный тренажер, набирающий попул…

300 р 252 р

Резиновые петли или резинки для фитнеса — это новый спортивный тренажер, набирающий популярность во…

840 р 706 р

Гантель виниловая — это литые эргономичные и яркие гантели, которые покрыты мягким приятным на ощуп…

467 р 393 р

Скакалка гимнастическая OKPRO OK1362 изготовлена из качественных безопасных для здоровья материалов…

900 р 759 р

Диски для скольжения или глайдинг диски — это новый вид тренировок в фитнесе. Одна сторона сделана…

400 р 336 р

Эспандеры резиновые – разновидность спортивного снаряжения, предназначенная для тренировки одной ил…

1680 р 1412 р

Неопрен – это искусственный каучук. Материал обладает рядом положительных свойств. Он водонепроница…

2341 р 1967 р

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

1000 р 840 р

1570 р 1319 р

Этот компактный тренажер способен обеспечить максимум полезной нагрузки на мышцы пресса, спины, пле…

13 843 р 11 630 р

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

1386 р 1165 р

Массажный мяч OKPRO OK1213J-2 используется для самомассажа во время разминки до и после физической…

1400 р 1176 р

Петли латексные для занятий пилатесом или резинки для фитнеса, для укрепления мышц в домашних услов…

2300 р 1932 р

MD Buddy MD1225 75 cm — Прочный резиновый упругий мяч, который применяется для физических и оздоров…

500 р 420 р

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

1400 р 1176 р

Пластиковая балансировочная платформа. Размер: 39*6,5 см. Угол поворота 360 градусов, угол наклона…

700 р 588 р

Резиновые петли — это новый спортивный тренажер, набирающий популярность во всем мире благодар…

1000 р 840 р

2321 р 1950 р

Массажный мяч двойной OKPRO OK1213K используется для самомассажа во время разминки до и после физич…

1778 р 1494 р

Для занятий пилатесом, укрепления мышц, реабилитации и выполнения упражнений на растяжку в домашних…

прошли ежегодные занятия по повышению квалификации руководителей пожарно-спасательных отрядов и поисково-спасательных станций

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

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

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

руководитель Департамента ГОЧСиПБ Юрий Акимов

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

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

Далее — тренировочный комплекс «Оксид». Руководители подразделений ликвидировали условную аварию и ее последствия на промышленном объекте.

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

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

«Учебные занятия с начальниками отрядов Центра проводится для совершенствования их теоретических знаний в области охраны труда и оперативно-служебной деятельности. Также руководители подразделений улучшили навыки руководства проведением аварийно-спасательных работ при ликвидации происшествий в различных условиях», — рассказал начальник отдела профессиональной подготовки Пожарно-спасательного центра Москвы Игорь Зиновьев.

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

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

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

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

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

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

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

На протяжении трех дней теоретические и практические занятия с начальниками и заместителями начальников подразделений спасателей на воде проходили на поисково-спасательных станциях «Строгино», «Центральная», «Кожухово», «Мещерская и «Косино».

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

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

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

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

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

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

В Пожарно-спасательном центре Москвы и в Московской городской поисково-спасательной службе на водных объектах трудятся более 4,6 тысячи специалистов, на вооружении которых находится около 600 единиц современной пожарно-спасательной и специальной техники. В 2021 году на пожарах и происшествиях на воде на территории столицы ими спасено более тысячи человек.

какие бывают и как правильно выбрать?

© Photographee.eu — stock.adobe.com

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

Что такое резиновые петли и для чего они нужны?

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

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

© Diana Vyshniakova — stock.adobe.com

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

  1. Заниматься в походных условиях, когда доступа к железу нет.
  2. Увеличить эффективность занятий с отягощениями и собственным весом.
  3. Прорабатывать взрывную силу и ударную технику.
  4. Развивать силу предплечий без риска получения травмы.
  5. Снизить нагрузку в базовых воркаут-движениях за счет поддерживающей нагрузки.
  6. Увеличить силовые показатели и проработать тело, не забивая его молочной кислотой.
  7. Увеличить скоростно-силовые показатели.
  8. Увеличить координационную выносливость.

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

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

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

Характеристики

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

ХарактеристикаЧто означает?
ЦветОбычно цветом производится маркировка петель по жесткости. Соотношение расцветки к жесткости определяется исключительно производителем. Нет особых стандартов.
Прочность к деформацииОпределяет то, насколько изменяется жесткость петли в случае её растяжения. Важно при использовании петель в качестве дополнения к базовым упражнениям.
Устойчивость к перепадам температурыПетли выполнены из латекса или резины, поэтому важно узнавать у производителя устойчивость петель к холоду. Это позволит тренироваться с петлями на улице в зимний период, что важно для воркаут-спортсменов.
ИзносоустойчивостьОпределяет то, сколько прослужит петля и как изменится её коэффициент жесткости со временем.
Гибкость лентыВ зависимости от материала отличается и гибкость. Гибкость влияет на возможность использования узлов для закрепления петель между собой или прикрепления к снарядам.
Предел растяженияВажная характеристика для легких петель. Определяет то, насколько может растянутся петля до разрыва.

В случае работы на турнике определяющими характеристиками являются:

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

Рекомендации к использованию

Для уменьшения травмоопасности занятий и увеличения эффективности резиновых петель рекомендуется следовать простым правилам:

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

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

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

Лайфхак

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

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

© snaptitude — stock.adobe.com

Резюмируя

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

Оцените материал

Эксперт проекта. Стаж тренировок — 12 лет. Хорошая теоретическая база по процессу тренировок и правильному питанию, которую с удовольствием применяю на практике. Нужна рекомендация? Это ко мне 🙂

Редакция cross.expert

циклов базовой тренировки  | Ядро TensorFlow

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

TensorFlow также включает tf.Keras API, высокоуровневый API нейронной сети, который предоставляет полезные абстракции для сокращения шаблонов. Однако в этом руководстве вы будете использовать базовые классы.

Настройка

  импортировать тензорный поток как tf

импортировать матплотлиб.pyplot как plt

цвета = plt.rcParams['axes.prop_cycle'].by_key()['color']
  

Решение задач машинного обучения

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

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

В целях иллюстрации в этом руководстве вы разработаете простую линейную модель \(f(x) = x * W + b\), которая имеет две переменные: \(W\) (веса) и \(b \) (предвзятость).

Это самая основная задача машинного обучения: при заданных \(x\) и \(y\) попытаться найти наклон и смещение линии с помощью простой линейной регрессии.

Данные

Контролируемое обучение использует входных данных (обычно обозначаемых как x ) и выходных данных (обозначаемых y , часто называемых метками ).Цель состоит в том, чтобы учиться на парных входных и выходных данных, чтобы вы могли предсказать значение выходных данных на основе входных данных.

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

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

  # Фактическая строка
ИСТИНА_W = 3,0
ИСТИНА_B = 2,0

NUM_EXAMPLES = 201

# Вектор случайных значений x
х = тс.linspace(-2,2, NUM_EXAMPLES)
х = tf.cast(x, tf.float32)

защита f(x):
  вернуть x * TRUE_W + TRUE_B

# Создадим немного шума
шум = tf.random.normal (форма = [NUM_EXAMPLES])

# Вычислить у
у = f (х) + шум
  
  # Отображение всех данных
plt.plot(х, у, '.')
plt.show()
  

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

Определить модель

Используйте tf. Variable для представления всех весов в модели. tf.Variable хранит значение и предоставляет его в тензорной форме по мере необходимости. Подробнее см. в руководстве по переменным.

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

Здесь вы определяете как w , так и b переменные.

  класс MyModel(tf.Module):
  def __init__(я, **kwargs):
    super().__init__(**kwargs)
    # Инициализируйте веса равными 5.0 и смещением равными 0.0.
    # На практике они должны быть случайным образом инициализированы
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  защита __call__(я, х):
    вернуть self.w * x + self.b

модель = МояМодель()

# Перечислите переменные встроенной агрегации переменных tf.modules. 
print("Переменные:", model.variables)

# Убедитесь, что модель работает
утвердить модель (3.0).numpy() == 15.0
  
Переменные&двоеточие; (, )
2022-02-26 02:24:37.733773: W tensorflow/python/util/util.cc:368] Наборы в настоящее время не считаются последовательностями, но это может измениться в будущем, поэтому рассмотрите возможность их использования.
 

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

Определение функции потерь

Функция потерь измеряет, насколько хорошо выходные данные модели для заданных входных данных совпадают с целевыми выходными данными. Цель состоит в том, чтобы свести к минимуму эту разницу во время тренировки. Определите стандартные потери L2, также известные как «среднеквадратичная» ошибка:

  # Это вычисляет одно значение потерь для всей партии
потеря защиты (target_y, предсказанный_y):
  вернуть tf.reduce_mean (tf.square (target_y - предсказанный_y))
  

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

  пл.график (х, у, '.', метка = "Данные")
plt.plot(x, f(x), label="Основная правда")
plt.plot(x, модель(x), метка = "Предсказания")
plt.legend()
plt.show()

print("Текущие потери: %1.6f" % потерь(y, модель(x)).numpy())
  

Текущие потери&колон; 10.059709
 

Определение цикла обучения

Цикл обучения состоит из многократного выполнения трех задач по порядку:

  • Отправка пакета входных данных через модель для создания выходных данных
  • Расчет потерь путем сравнения выходов с выходом (или меткой)
  • Использование градиентной ленты для поиска градиентов
  • Оптимизация переменных с этими градиентами

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

Существует много вариантов схемы градиентного спуска, которые захвачены в tf.keras.optimizers . Но в духе построения из первых принципов здесь вы сами реализуете базовую математику с помощью tf.GradientTape для автоматического дифференцирования и tf.assign_sub для уменьшения значения (которое объединяет tf.assign и tf.sub ):

  # Учитывая вызываемую модель, входы, выходы и скорость обучения...
def train (модель, x, y, learning_rate):

  с tf.GradientTape() как t:
    # Обучаемые переменные автоматически отслеживаются GradientTape
    current_loss = убыток (y, модель (x))

  # Используйте GradientTape для расчета градиентов относительно W и b
  dw, db = t.gradient(current_loss, [model.w, model.b])

  # Вычесть градиент, масштабированный по скорости обучения
  model. w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)
  

Чтобы посмотреть на обучение, вы можете отправить ту же партию x и y через цикл обучения и посмотреть, как эволюционируют W и b .

  модель = МояМодель()

# Соберите историю W-значений и b-значений, чтобы построить график позже
веса = []
предубеждения = []
эпохи = диапазон (10)

# Определяем тренировочный цикл
отчет о защите (модель, потеря):
  return f"W = {model.w.numpy():1.2f}, b = {model.b.numpy():1.2f}, loss={loss:2.5f}"


def training_loop (модель, x, y):

  для эпохи в эпохах:
    # Обновите модель одной гигантской партией
    поезд (модель, x, y, learning_rate = 0,1)

    # Отследить это, прежде чем я обновлю
    weights.append(model.w.numpy())
    предубеждения.добавить (модель.b.numpy())
    current_loss = убыток (y, модель (x))

    print(f"Эпоха {эпоха:2d}:")
    print(" ", отчет(модель, current_loss))
  

Пройти обучение

  текущая_потеря = потеря (у, модель (х))

печать(f"Начало:")
print(" ", отчет(модель, current_loss))

training_loop (модель, х, у)
  
Запуск&двоеточие;
     W = 5,00, b = 0,00, потеря = 10,05971
Эпоха 0:
     W = 4,47, b = 0,39, потеря = 6,20847
Эпоха 1:
     W = 4,08, b = 0. 71, потеря=4,00421
Эпоха 2:
     W = 3,79, b = 0,96, потеря = 2,73257
Эпоха 3:
     W = 3,59, b = 1,16, потеря = 1,99297.
Эпоха 4:
     W = 3,43, b = 1,32, потеря = 1,55927
Эпоха 5:
     W = 3,32, b = 1,45, потеря = 1,30287.
Эпоха 6:
     W = 3,24, b = 1,56, потеря = 1,15007
Эпоха 7:
     W = 3,18, b = 1,64, потеря = 1,05831
Эпоха 8:
     W = 3,14, b = 1,71, потеря = 1,00281
Эпоха 9:
     W = 3,11, b = 1,76, потеря = 0,96900
 

График эволюции весов во времени:

  пл.график (эпохи, веса, метка = 'Веса', цвет = цвета [0])
plt.plot(эпохи, [TRUE_W] * len(эпохи), '--',
         label = "Истинный вес", color=colors[0])

plt.plot (эпохи, предубеждения, метка = 'предвзятость', цвет = цвета [1])
plt.plot(эпохи, [TRUE_B] * len(эпохи), "--",
         label="Истинное смещение", color=colors[1])

plt.legend()
plt.show()
  

Визуализируйте, как работает обученная модель

  plt. plot(x, y, '.', метка = "Данные")
plt.plot(x, f(x), label="Основная правда")
пл.сюжет (х, модель (х), метка = "Предсказания")
plt.legend()
plt.show()

print("Текущие потери: %1.6f" % потерь(модель(x), y).numpy())
  

Текущие потери&колон; 0,969002
 

То же решение, но с Keras

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

Определение модели выглядит точно так же, если вы подкласс tf.keras.Model . Помните, что модели Keras в конечном итоге наследуются от модуля.

  класс MyModelKeras(tf.Керас.Модель):
  def __init__(я, **kwargs):
    super().__init__(**kwargs)
    # Инициализируйте веса равными 5.0 и смещением равными 0.0.
    # На практике они должны быть случайным образом инициализированы
    self.w = tf.Variable(5.0)
    self.b = tf. Variable(0.0)

  деф вызов(я, х):
    вернуть self.w * x + self.b

keras_model = МояМодельKeras()

# Повторное использование цикла обучения с моделью Keras
training_loop (keras_model, x, y)

# Вы также можете сохранить контрольную точку, используя встроенную поддержку Keras
keras_model.save_weights("my_checkpoint")
  
Эпоха 0:
     Вт = 4.47, б = 0,39, потеря = 6,20847
Эпоха 1:
     W = 4,08, b = 0,71, потеря = 4,00421
Эпоха 2:
     W = 3,79, b = 0,96, потеря = 2,73257
Эпоха 3:
     W = 3,59, b = 1,16, потеря = 1,99297.
Эпоха 4:
     W = 3,43, b = 1,32, потеря = 1,55927
Эпоха 5:
     W = 3,32, b = 1,45, потеря = 1,30287.
Эпоха 6:
     W = 3,24, b = 1,56, потеря = 1,15007
Эпоха 7:
     W = 3,18, b = 1,64, потеря = 1,05831
Эпоха 8:
     W = 3,14, b = 1,71, потеря = 1,00281
Эпоха 9:
     Вт = 3.11, б = 1,76, потеря = 0,96900
 

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

Если вы это сделаете, вам нужно будет использовать model.compile() для установки параметров и model.fit() для обучения. Может быть меньше кода, чтобы использовать реализации Keras потерь L2 и градиентного спуска, опять же в качестве ярлыка. Потери и оптимизаторы Keras также могут использоваться вне этих удобных функций, и в предыдущем примере они могли использоваться.

  keras_model = МояМодельKeras()

# compile устанавливает параметры обучения
keras_model.compile(
    # По умолчанию fit() использует tf.function(). Ты сможешь
    # отключите его для отладки, но сейчас он включен.
    run_eagerly = Ложь,

    # Использование встроенного оптимизатора, настройка как объекта
    оптимизатор = tf.keras.optimizers.SGD (learning_rate = 0,1),

    # Keras поставляется со встроенной ошибкой MSE
    # Однако вы можете использовать функцию потерь
    # определено выше
    потеря = tf. keras.losses.mean_squared_error,
)
  

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

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

  печать (x.shape [0])
keras_model.fit(x, y, эпохи=10, batch_size=1000)
  
201
Эпоха 1/10
1/1 [===============================] - 0 с 261 мс/шаг - потеря&двоеточие; 10.0597
Эпоха 2/10
1/1 [==============================] - 0 с 4 мс/шаг - потеря&двоеточие; 6.2085
Эпоха 3/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 4.0042
Эпоха 4/10
1/1 [==============================] - 0 с 4 мс/шаг - потеря&двоеточие; 2,7326
Эпоха 5/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 1,9930
Эпоха 6/10
1/1 [==============================] - 0 с 4 мс/шаг - потеря&двоеточие; 1,5593
Эпоха 7/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 1. 3029
Эпоха 8/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 1.1501
Эпоха 9/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 1,0583
Эпоха 10/10
1/1 [===============================] - 0 с 3 мс/шаг - потеря&двоеточие; 1.0028

 

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

Следующие шаги

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

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

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

Написание обучающего цикла с нуля  | Ядро TensorFlow

Настройка

  импортировать тензорный поток как tf
из тензорного потока импортировать керас
из тензорного потока.слои импорта keras
импортировать numpy как np
  

Введение

Keras предоставляет циклы обучения и оценки по умолчанию, fit() и Assessment() . Их использование описано в руководстве Обучение и оценка с помощью встроенных методов.

Если вы хотите настроить алгоритм обучения вашей модели, используя удобство fit() (например, чтобы обучить GAN с помощью fit() ), вы можете создать подкласс класса Model и реализовать свой собственный метод train_step() , который вызывается неоднократно в течение fit() . Это описано в руководстве Настройка того, что происходит в fit() .

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

Использование ленты GradientTape

: первый сквозной пример

Вызов модели внутри области GradientTape позволяет получить градиенты обучаемые веса слоя по отношению к значению потерь.Использование оптимизатора Например, вы можете использовать эти градиенты для обновления этих переменных (которые вы можете получить с помощью model.trainable_weights ).

Рассмотрим простую модель MNIST:

  входы = keras.Input(shape=(784,), name="digits")
x1 = слои.  Плотность (64, активация = "relu") (входы)
x2 = слои. Плотность (64, активация = "relu") (x1)
выходы = слои.Dense(10, name="predictions")(x2)
модель = keras.Model (входы = входы, выходы = выходы)
  

Давайте обучим его с помощью мини-пакетного градиента с пользовательским циклом обучения.

Во-первых, нам понадобится оптимизатор, функция потерь и набор данных:

  # Создать оптимизатор.
оптимизатор = keras.optimizers.SGD (learning_rate = 1e-3)
# Создать экземпляр функции потерь.
loss_fn = keras.losses.SparseCategoricalCrossentropy (from_logits = True)

# Подготовьте обучающий набор данных.
размер партии = 64
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = np.reshape (x_train, (-1, 784))
x_test = np.reshape (x_test, (-1, 784))

# Зарезервируйте 10 000 образцов для проверки.x_val = x_train[-10000:]
y_val = y_train[-10000:]
х_поезд = х_поезд[:-10000]
у_поезд = у_поезд[:-10000]

# Подготовьте обучающий набор данных. 
train_dataset = tf.data.Dataset.from_tensor_slice((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)

# Подготовьте набор данных проверки.
val_dataset = tf.data.Dataset.from_tensor_slice((x_val, y_val))
val_dataset = val_dataset.batch (размер_пакета)
  
Загрузка данных из https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/114

[==============================] - 1 с 0 мкс/шаг 11501568/114

[=============================] - 1 с 0 мкс/шаг

Вот наш тренировочный цикл:

  • Мы открываем цикл for , который повторяется в течение эпох
  • Для каждой эпохи мы открываем цикл на , который перебирает набор данных пакетами
  • Для каждой партии мы открываем область GradientTape()
  • Внутри этой области мы вызываем модель (прямой проход) и вычисляем потери
  • Вне области мы получаем градиенты весов модели с учетом убытка
  • Наконец, мы используем оптимизатор для обновления весов модели на основе градиенты
  эпох = 2
для эпохи в диапазоне (эпохи):
    print("\nНачало эпохи %d" % (эпоха))

    # Перебираем пакеты набора данных. для шага (x_batch_train, y_batch_train) в перечислении (train_dataset):

        # Откройте GradientTape для записи выполняемых операций
        # во время прямого прохода, который включает автодифференциацию.
        с tf.GradientTape() в качестве ленты:

            # Запустить прямой проход слоя.
            # Операции, которые применяет слой
            # на его входы будут записываться
            # на GradientTape.
            logits = model(x_batch_train, training=True) # Логиты для этого минипакета

            # Вычислить значение потерь для этой мини-партии.loss_value = loss_fn (y_batch_train, логиты)

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

        # Запустить один шаг градиентного спуска, обновив
        # значение переменных для минимизации потерь.
        оптимизатор.apply_gradients(zip(выпуски, model.trainable_weights))

        # Записывать каждые 200 пакетов. 
        если шаг % 200 == 0:
            Распечатать(
                «Потери при обучении (для одной партии) на шаге %d: %.4ф"
                % (шаг, число с плавающей запятой (loss_value))
            )
            print("На данный момент просмотрено: %s образцов" % ((шаг + 1) * размер_пакета))
  
Начало эпохи 0
Потери при обучении (для одной партии) на шаге 0: 68,7478
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 1,9448
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 1.1859
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0.6914
Видно до сих пор & двоеточие; 38464 образца

Начало эпохи 1
Потери при обучении (для одной партии) на шаге 0: 0,9113
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 0,9550
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 0,5139
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0,7227
Видно до сих пор & двоеточие; 38464 образца
 

Низкоуровневая обработка метрик

Добавим к этому базовому циклу мониторинг метрик.

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

  • Создание экземпляра метрики в начале цикла
  • Вызов metric.update_state() после каждой партии
  • Вызовите metric.result() , когда вам нужно отобразить текущее значение метрики
  • Вызовите metric.reset_states() , когда вам нужно очистить состояние метрики (обычно в конце эпохи)

Давайте используем эти знания для вычисления SparseCategoricalAccuracy для данных проверки в конец каждой эпохи:

  # Получить модель
входы = керас.Ввод (форма = (784,), имя = "цифры")
x = слои.Dense(64, активация="relu", name="dense_1")(входы)
x = слои.Dense(64, активация = "relu", name = "dense_2") (x)
выходы = слои. Dense(10, name="predictions")(x)
модель = keras.Model (входы = входы, выходы = выходы)

# Создайте оптимизатор для обучения модели.
оптимизатор = keras.optimizers.SGD (learning_rate = 1e-3)
# Создать экземпляр функции потерь.
loss_fn = keras.losses.SparseCategoricalCrossentropy (from_logits = True)

# Подготовьте метрики.
train_acc_metric = Керас.metrics.SparseCategoricalAccuracy()
val_acc_metric = keras.metrics.SparseCategoricalAccuracy()
  

Вот наш цикл обучения и оценки:

  время импорта

эпохи = 2
для эпохи в диапазоне (эпохи):
    print("\nНачало эпохи %d" % (эпоха))
    start_time = время.время()

    # Перебираем пакеты набора данных.
    для шага (x_batch_train, y_batch_train) в перечислении (train_dataset):
        с tf.GradientTape() в качестве ленты:
            логиты = модель (x_batch_train, обучение = Истина)
            loss_value = loss_fn (y_batch_train, логиты)
        грады = лента.градиент (loss_value, model. trainable_weights)
        оптимизатор.apply_gradients(zip(выпуски, model.trainable_weights))

        # Обновить показатель обучения.
        train_acc_metric.update_state (y_batch_train, логиты)

        # Записывать каждые 200 пакетов.
        если шаг % 200 == 0:
            Распечатать(
                «Потеря при обучении (для одной партии) на шаге %d: %.4f»
                % (шаг, число с плавающей запятой (loss_value))
            )
            print("На данный момент просмотрено: %d образцов" % ((шаг + 1) * размер_пакета))

    # Отображение метрик в конце каждой эпохи.train_acc = train_acc_metric.result()
    print("Обучение по эпохе: %.4f" % (float(train_acc),))

    # Сбрасывать показатели обучения в конце каждой эпохи
    train_acc_metric.reset_states()

    # Запускать цикл проверки в конце каждой эпохи.
    для x_batch_val, y_batch_val в val_dataset:
        val_logits = модель (x_batch_val, обучение = ложь)
        # Обновить валовые метрики
        val_acc_metric.update_state(y_batch_val, val_logits)
    val_acc = val_acc_metric. result()
    val_acc_metric.reset_states()
    print("Проверка в соотв.: %.4f" % (float(val_acc),))
    print("Затраченное время: %.2fs" % (time.time() - start_time))
  
Начало эпохи 0
Потери при обучении (для одной партии) на шаге 0: 88,9958
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 2.2214
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 1.3083
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0.8282
Видно до сих пор & двоеточие; 38464 образца
Обучение согласно эпохе: 0,7406
Валидация со&колон; 0,8201
Затраченное время&двоеточие; 6,31 с

Начало эпохи 1
Потери при обучении (для одной партии) на шаге 0: 0,3276
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 0,4819
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 0,5971
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0. 5862
Видно до сих пор & двоеточие; 38464 образца
Обучение согласно эпохе: 0,8474
Валидация со&колон; 0,8676
Затраченное время&двоеточие; 5,98 с
 

Ускорение обучения с помощью

tf.function

Время выполнения по умолчанию в TensorFlow 2: страстное исполнение. Таким образом, наш тренировочный цикл выше выполняется с нетерпением.

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

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

  @tf. функция
def train_step (x, y):
    с tf.GradientTape() в качестве ленты:
        логиты = модель (х, обучение = Истина)
        loss_value = loss_fn(y, логиты)
    grads = лента.градиент(значение_потери, модель.обучаемые_веса)
    оптимизатор.apply_gradients(zip(выпуски, model.trainable_weights))
    train_acc_metric.update_state(y, логиты)
    вернуть loss_value
  

Проделаем то же самое с этапом оценки:

  @tf.функция
деф test_step (х, у):
    val_logits = модель (х, обучение = ложь)
    val_acc_metric.update_state(y, val_logits)
  

Теперь давайте повторно запустим наш обучающий цикл с этим скомпилированным обучающим шагом:

  время импорта

эпохи = 2
для эпохи в диапазоне (эпохи):
    print("\nНачало эпохи %d" % (эпоха))
    время_начала = время.время()

    # Перебираем пакеты набора данных.
    для шага (x_batch_train, y_batch_train) в перечислении (train_dataset):
        loss_value = train_step (x_batch_train, y_batch_train)

        # Записывать каждые 200 пакетов. 
        если шаг % 200 == 0:
            Распечатать(
                «Потеря при обучении (для одной партии) на шаге %d: %.4f»
                % (шаг, число с плавающей запятой (loss_value))
            )
            print("На данный момент просмотрено: %d образцов" % ((шаг + 1) * размер_пакета))

    # Отображение метрик в конце каждой эпохи.train_acc = train_acc_metric.result()
    print("Обучение по эпохе: %.4f" % (float(train_acc),))

    # Сбрасывать показатели обучения в конце каждой эпохи
    train_acc_metric.reset_states()

    # Запускать цикл проверки в конце каждой эпохи.
    для x_batch_val, y_batch_val в val_dataset:
        test_step (x_batch_val, y_batch_val)

    val_acc = val_acc_metric.result()
    val_acc_metric.reset_states()
    print("Проверка в соотв.: %.4f" % (float(val_acc),))
    print("Затраченное время: %.2fs" % (time.время() - время_начала))
  
Начало эпохи 0
Потери при обучении (для одной партии) на шаге 0: 0,7921
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 0,7755
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 0,1564
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0,3181
Видно до сих пор & двоеточие; 38464 образца
Обучение согласно эпохе: 0,8788
Валидация со&колон; 0. 8866
Затраченное время&двоеточие; 1,59 с

Начало эпохи 1
Потери при обучении (для одной партии) на шаге 0: 0,5222
Видно до сих пор & двоеточие; 64 образца
Потери при обучении (для одной партии) на шаге 200: 0,4574
Видно до сих пор & двоеточие; 12864 образца
Потери при обучении (для одной партии) на шаге 400: 0,4035
Видно до сих пор & двоеточие; 25664 образца
Потери при обучении (для одной партии) на шаге 600: 0,7561
Видно до сих пор & двоеточие; 38464 образца
Обучение согласно эпохе: 0,8959
Валидация со&колон; 0.9028
Затраченное время&двоеточие; 1,27 с
 

Гораздо быстрее, не правда ли?

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

Слои и модели рекурсивно отслеживают любые потери, возникающие во время прямого прохода слоями, которые вызывают self.add_loss(value) . Полученный список скалярных потерь значения доступны через свойство model. losses в конце прямого прохода.

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

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

  класс ActivityRegularizationLayer (layers.Layer):
    деф вызов(я, входы):
        self.add_loss (1e-2 * tf.reduce_sum (входы))
        возврат входных данных
  

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

  входы = keras.Input(shape=(784,), name="digits")
x = слои. Плотность (64, активация = "relu") (входы)
# Вставить регуляризацию активности как слой
x = ActivityRegularizationLayer () (x)
х = слои.Плотный (64, активация = "релу") (x)
выходы = слои.Dense(10, name="predictions")(x)

модель = keras.Model (входы = входы, выходы = выходы)
  

Вот как теперь должен выглядеть наш шаг обучения:

  @tf. функция
def train_step (x, y):
    с tf.GradientTape() в качестве ленты:
        логиты = модель (х, обучение = Истина)
        loss_value = loss_fn(y, логиты)
        # Добавьте любые дополнительные потери, возникшие во время прямого прохода.
        loss_value += сумма(модель.потери)
    грады = лента.градиент (loss_value, model.trainable_weights)
    оптимизатор.apply_gradients(zip(выпуски, model.trainable_weights))
    train_acc_metric.update_state(y, логиты)
    вернуть loss_value
  

Резюме

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

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

Сквозной пример: цикл обучения GAN с нуля

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

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

Цикл обучения GAN выглядит следующим образом:

1) Обучить дискриминатор.- Образец партии случайных точек в скрытом пространстве. — Превратите точки в поддельные изображения с помощью модели «генератор». — Получите пакет реальных изображений и объедините их со сгенерированными изображениями. — Обучите модель «дискриминатора» для классификации сгенерированных и реальных изображений.

2) Обучить генератор. — Выборка случайных точек в скрытом пространстве. — Превратите точки в поддельные изображения через сеть «генератор». — Получите пакет реальных изображений и объедините их со сгенерированными изображениями. — Обучите модель «генератора», чтобы «обмануть» дискриминатор и классифицировать поддельные изображения. как настоящий.

Более подробный обзор того, как работает GAN, см. Глубокое обучение с Python.

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

  дискриминатор = keras.Sequential(
    [
        keras.Input (форма = (28, 28, 1)),
        слои.Conv2D (64, (3, 3), шаги = (2, 2), отступ = "то же самое"),
        слои.LeakyReLU (альфа = 0,2),
        слои.Conv2D (128, (3, 3), шаги = (2, 2), отступ = "то же самое"),
        слои.Утечка ReLU (альфа = 0,2),
        слои.GlobalMaxPooling2D(),
        слои.Dense(1),
    ],
    имя="дискриминатор",
)
дискриминатор.summary()
  
Модель&двоеточие; "дискриминатор"
_________________________________________________________________
Слой (тип) Выходная форма Параметр #
================================================== ===============
conv2d (Conv2D) (Нет, 14, 14, 64) 640
_________________________________________________________________
Leaky_re_lu (LeakyReLU) (Нет, 14, 14, 64) 0
_________________________________________________________________
conv2d_1 (Conv2D) (нет, 7, 7, 128) 73856
_________________________________________________________________
утечка_re_lu_1 (LeakyReLU) (Нет, 7, 7, 128) 0
_________________________________________________________________
global_max_pooling2d (Глобальный (Нет, 128) 0
_________________________________________________________________
плотности_4 (Плотные) (Нет, 1) 129
================================================== ===============
Всего параметров & двоеточие; 74 625
Обучаемые параметры & двоеточие; 74 625
Необучаемые параметры & двоеточие; 0
_________________________________________________________________
 

Тогда давайте создадим генераторную сеть, который превращает скрытые векторы в выходные данные формы (28, 28, 1) (представляющие цифры МНИСТ):

  скрытый_дим = 128

генератор = керас. Последовательный(
    [
        keras.Input (форма = (latent_dim,)),
        # Мы хотим сгенерировать 128 коэффициентов для преобразования в карту 7x7x128
        слои. Плотность (7 * 7 * 128),
        слои.LeakyReLU (альфа = 0,2),
        слои.Изменить форму((7, 7, 128)),
        слои.Conv2DTranspose (128, (4, 4), шаги = (2, 2), отступ = "то же самое"),
        слои.LeakyReLU (альфа = 0,2),
        слои.Conv2DTranspose (128, (4, 4), шаги = (2, 2), отступ = "то же самое"),
        слои.LeakyReLU (альфа = 0,2),
        слои.Conv2D (1, (7, 7), отступ = «то же», активация = «сигмоид»),
    ],
    имя="генератор",
)
  

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

  # Создать один оптимизатор для дискриминатора и другой для генератора.
d_optimizer = keras.optimizers.Adam (learning_rate = 0,0003)
g_optimizer = keras.optimizers. Adam (learning_rate = 0,0004)

# Создать экземпляр функции потерь.
loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)


@tf.function
определение train_step (реальные_изображения):
    # Выборка случайных точек в скрытом пространстве
    random_latent_vectors = tf.random.normal (форма = (batch_size, скрытое_dim))
    # Декодировать их в поддельные изображения
    сгенерированные_изображения = генератор (случайные_латентные_векторы)
    # Объедините их с реальными изображениями
    комбинированные_изображения = tf.concat ([сгенерированные_изображения, реальные_изображения], ось = 0)

    # Соберите ярлыки, отличающие настоящие изображения от поддельных
    метки = tf.concat(
        [tf.ones((batch_size, 1)), tf.zeros((real_images.shape[0], 1))], ось=0
    )
    # Добавляем к меткам случайный шум - важный трюк!
    метки += 0,05 * tf.random.униформа (этикетки. форма)

    # Обучаем дискриминатор
    с tf.GradientTape() в качестве ленты:
        прогнозы = дискриминатор (combined_images)
        d_loss = loss_fn (метки, прогнозы)
    grads = лента. градиент(d_loss, dishibitor.trainable_weights)
    d_optimizer.apply_gradients (zip (градусы, дискриминатор.trainable_weights))

    # Выборка случайных точек в скрытом пространстве
    random_latent_vectors = tf.random.normal (форма = (размер_пакета, латентный_дим))
    # Соберите этикетки с надписью «все настоящие изображения».
    вводящие в заблуждение_метки = tf.нули ((batch_size, 1))

    # Обучить генератор (обратите внимание, что мы *не* должны обновлять веса
    № дискриминатора)!
    с tf.GradientTape() в качестве ленты:
        прогнозы = дискриминатор (генератор (random_latent_vectors))
        g_loss = loss_fn (вводящие в заблуждение метки, прогнозы)
    grads = лента.градиент(g_loss, генератор.trainable_weights)
    g_optimizer.apply_gradients(zip(градусы, генератор.trainable_weights))
    вернуть d_loss, g_loss, сгенерированные_изображения
  

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

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

  импорт ОС

# Подготовьте набор данных. Мы используем как обучающие, так и тестовые цифры MNIST.
размер партии = 64
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test])
all_digits = all_digits.astype("float32") / 255,0
all_digits = np.reshape (all_digits, (-1, 28, 28, 1))
набор данных = tf.data.Dataset.from_tensor_slices(all_digits)
набор данных = набор данных.перемешивание (buffer_size = 1024). партия (размер_пакета)

epochs = 1 # На практике вам нужно как минимум 20 эпох, чтобы генерировать хорошие цифры.
save_dir = "./"

для эпохи в диапазоне (эпохи):
    print("\nНачальная эпоха", эпоха)

    для шага, real_images в перечислении (набор данных):
        # Обучить дискриминатор и генератор на одной партии реальных изображений.
        d_loss, g_loss, сгенерированные_изображения = train_step (реальные_изображения)

        # Логирование. 
        если шаг % 200 == 0:
            # Печать метрик
            print("Потеря дискриминатора на шаге %d: %.2f" % (шаг, d_loss))
            print("Проигрыш противника на шаге %d: %.2f" % (шаг, g_loss))

            # Сохраняем одно сгенерированное изображение
            img = tf.keras.preprocessing.image.array_to_img(
                сгенерированные_изображения [0] * 255,0, масштаб = Ложь
            )
            img.save(os.path.join(save_dir, "generated_img" + str(step) + ".png"))

        # Чтобы ограничить время выполнения, мы останавливаемся после 10 шагов.
        # Удалите строки ниже, чтобы на самом деле обучить модель!
        если шаг > 10:
            перерыв
  
Начальная эпоха 0
потеря дискриминатора на шаге 0: 0.69
состязательная потеря на шаге 0: 0,69
 

Вот оно! Вы получите красиво выглядящие поддельные цифры MNIST всего через ~ 30 секунд обучения на Графический процессор Колаб.

Цикл обучения PyTorch.

Узнайте обо всем, что PyTorch делает для вас… | by Dipam Vasani

Настройка

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

А затем определить очень простую модель.

Мы выберем CrossEntropy в качестве функции потерь и точность в качестве метрики.

Для начала мы также установим скорость обучения и количество эпох.

Теперь мы напишем обучающий цикл с нуля.

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

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

В этой модели мы используем специальный метод дандера Python под названием __setattr__. Этот метод будет вызываться каждый раз, когда мы устанавливаем атрибут, например. self.l1 = nn.Linear(n_in, nh) .

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

Это то, что PyTorch делает для нас за кулисами, когда мы наследуем от nn.Module , и поэтому мы должны сначала вызвать super().__init__() .

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

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

Понимание nn.Sequential

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

PyTorch делает то же самое, используя nn.ModuleList . Вместо этого мы можем сделать:

Однако это все еще неуклюже, поэтому мы можем сделать напрямую:

Теперь мы знаем, как реализуется nn.Sequential .

Понимание оптимизатора

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

только к

. Для этого мы определим класс Optimizer и поместим в него эти функции.

Наш тренировочный цикл теперь выглядит намного чище.

Понимание наборов данных и загрузчиков данных

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

Это изменяет наш цикл следующим образом:

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

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

Это будет все для этой статьи.

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

~счастливого обучения

Ссылка:

Глубокое обучение от основ, fast.ai

Цикл обучения модели глубокого обучения | Илья Зайцев

Реализация простого цикла обучения нейронной сети с помощью Python, PyTorch и TorchVision.

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

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

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

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

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

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

  1. Ignite — официальный высокоуровневый интерфейс для PyTorch
  2. Torchsample — Keras-подобная обертка с обратными вызовами, аугментацией и удобными утилитами
  3. Skorch — scikit библиотека нейросетей, совместимая с -learn
  4. fastai — мощное комплексное решение для обучения моделей Deep Learning различной сложности с высокой точностью и скоростью вычислений

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

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

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

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

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

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

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

Шаблон известен под разными именами, отражающими различные особенности реализации: наблюдатель, диспетчер событий/сигналов, обратный вызов. В нашем случае мы идем с обратными вызовами, подход, представленный в библиотеках Keras и (особенно) fastai . Решение авторов пакета ignite немного отличается, но по сути сводится к той же идее.Взгляните на картинку ниже. Он показывает схематическую организацию нашего улучшенного тренировочного цикла.

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

Следующий фрагмент показывает реализацию этой идеи на Python.

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

Есть много полезных обратных вызовов (см. keras.io и docs.fast.ai для вдохновения), которые мы могли бы реализовать. Чтобы пост был кратким, мы собираемся описать только пару из них, а остальные переместим в блокнот Jupyter.

Потери

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

В конце каждой партии мы вычисляем текущий убыток. Вычисления могут показаться немного сложными, но основная цель — сгладить кривую потерь, которая в противном случае была бы ухабистой.Формула а*х + (1 — а)*у представляет собой линейную интерполяцию между старыми и новыми значениями.

Геометрическая интерпретация линейной интерполяции между векторами A и B

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

Точность

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

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

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

Где b(i) — размер пакета на итерации i, a(i) — точность, вычисленная на пакете b(i) , N — общее количество выборок. Как показывает последняя формула, наш код вычисляет выборочное среднее значение точности. Проверьте эти полезные ссылки, чтобы узнать больше об итеративных вычислениях метрик:

  1. Метрики как обратные вызовы из fastai
  2. Метрика точности из пакета ignite

Планировщик параметров

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

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

Полупериод сдвинутого и масштабированного косинуса

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

Косинусный отжиг с планировщиком перезапусков

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

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

Планировщик политик с одним циклом

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

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

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

Stream Logger

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

Наконец-то мы готовы начать использовать наш тренировочный цикл!

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

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

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

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

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

 Эпоха: 1 | train_loss=0,8907, train_accuracy=0,6387, valid_loss=0,1027, valid_accuracy=0,9695Эпоха: 2 | train_loss=0,4990, train_accuracy=0,8822, valid_loss=0,0828, valid_accuracy=0,9794Эпоха: 3 | train_loss=0,3639, train_accuracy=0,9086, valid_loss=0,0723, valid_accuracy=0,9823 

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

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

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

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

Как создать пользовательский цикл обучения глубокому обучению в Tensorflow с нуля

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

В этой статье мы продолжаем серию «Глубокое обучение в производстве», создавая обучающую модель для нашего примера сегментации , который мы использовали до сих пор.Я подумал, что было бы неплохо на этот раз вместо того, чтобы обрисовывать в общих чертах основные темы и принципы разработки программного обеспечения, шаг за шагом пройти весь жизненный цикл разработки. Итак, мы запрограммируем весь класс Trainer так, как мы это делаем в нашей повседневной работе. Также это отличная возможность применить все лучшие практики, о которых мы говорили в серии. Мы собираемся изучить, как мы можем создавать высокопроизводительное и простое в сопровождении программное обеспечение в режиме реального времени.

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

Построение тренировочного цикла в Tensorflow

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

 

self.model.compile(optimizer=self.config.train.optimizer.type,

loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),

metrics=self.config.train.metrics)

LOG.info('Начало обучения')

model_history = self.model.fit(self.train_dataset, epochs=self.epoches,

steps_per_epoch=self.steps_per_epoch,

validation_steps=self .validation_steps,

validation_data=self. test_dataset)

return model_history.history['loss'], model_history.history['val_loss']

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

Также обратите внимание, что я использую Python 3.7 и Tensorflow 2.0. Чтобы увидеть мою полную настройку и следовать ей, вы можете пересмотреть первую статью серии, в которой мы настроили наш ноутбук и кратко изложили нашу проблему и конечную цель.

Для простоты я думаю, что мы можем заменить приведенный выше код в функции обучения внутри нашего класса модели кодом ниже: loss.SparseCategoricalCrossentropy(from_logits=True)

metrics = tf.keras.metrics.SparseCategoricalAccuracy()

Trainer = Trainer(self. model, self.train_dataset, loss, optimizer, metrics, self.epoches)

Trainer.train ()

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

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

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

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

 

класс Trainer:

def __init__(self, model, input, loss_fn, оптимизатор, метрика, эпохи):

self.model = model

self.input = input

self.loss_fn = loss_fn

self.optimizer = оптимизатор

self.metric = metric

self.epoches = epoches

Здесь, как видите, ничего особенного. Внутри класса Trainer нам также нужна функция обучения , , которая будет иметь общую функциональность обучения, и функция train_step , которая будет содержать только один шаг обучения.

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

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

 

trainable_variables = self.model.trainable_variables

входные данные, метки = пакет

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

 

с tf.GradientTape() в качестве ленты:

прогнозы = self.model(inputs)

step_loss = self.loss_fn(метки, прогнозы)

Мы используем «tf.GradientTape()» из Tensorflow для захвата градиентов на этом этапе. Затем мы можем применить их в оптимизаторе и изменить веса соответственно.

 

grads = tape.gradient(step_loss, trainable_variables)

self.optimizer.apply_gradients(zip(grads, trainable_variables))

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

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

 

def train_step(self, batch):

trainable_variables = self.model.trainable_variables

входные данные, метки = пакет

с tf.GradientTape() в качестве ленты:

прогнозы = self.model (входные данные)

step_loss = self.loss_fn (метки, прогнозы)

грады = лента.градиент (step_loss, trainable_variables)

self.optimizer.apply_gradients(zip(grads, trainable_variables))

self.metric.update_state(метки, прогнозы)

return step_loss, прогнозы

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

 

def train(self):

для эпохи в диапазоне(self.epoches):

LOG.info(f'Start epoch {epoch}')

для шага, training_batch в перечислении(self. input):

step_loss, прогнозы = self.train_step(training_batch)

LOG.info("Потери на шаге %d: %.2f" % (step, step_loss))

train_acc = self.metric.result()

LOG.info(f'Сохраненная контрольная точка: {save_path}')

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

 

LOG = get_logger('trainer')

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

Несколько замечаний, прежде чем мы продолжим: Прежде всего, входными данными является набор данных tensorflow (tf. data), и, как вы можете видеть, мы можем перебирать его, как мы делаем для обычного массива или списка. Мы также рассмотрели это в предыдущей статье о предварительной обработке данных.Во-вторых, я уверен, вы заметили, что мы фиксируем как потери, так и точность на протяжении всей программы. Это нужно не только для предоставления журналов, но и для визуализации нашего обучения с использованием Tensorboard. Подробнее об этом чуть позже.

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

Книга «Глубокое обучение в производстве» 📖

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

Тренировочные контрольные точки

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

 

self.checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)

self.checkpoint_manager = tf.train.CheckpointManager(self.checkpoint, '. /tf_ckpts')

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

 

save_path = self.checkpoint_manager.save()

LOG.info(f'Сохраненная контрольная точка: {save_path}')

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

Сохранение обученной модели

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

 

self.model_save_path = 'saved_models/'

save_path = os.path.join(self.model_save_path, "unet/1/")

tf.saved_model.save(self.model, save_path)

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

 

model = tf.saved_model.load(save_path)

Визуализация обучения с помощью Tensorboard

Если вы визуал, как и я, журналы — не самая простая вещь для просмотра, когда вы пытаетесь понять, как проходит ваше обучение. продолжается . Было бы намного лучше иметь способ визуализировать процесс и смотреть на графики, а не на строки и строки журналов.Если вы не знаете о таком инструменте, Tensorboard — это способ отображать метрики, полученные во время обучения, и создавать для них красивые графики. Это также очень хороший способ увидеть вычислительный граф и получить общее представление о всей нашей архитектуре. И это также легко использовать (удивительно, да?)

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

 

self.train_log_dir = 'logs/gradient_tape/'

self.train_summary_writer = tf.summary.create_file_writer(self.train_log_dir)

И в конце каждой эпохи мы можем использовать этот модуль записи для сохранения текущих метрик, как в примере ниже:

 

def _write_summary(я, потеря, эпоха):

с self.train_summary_writer.as_default():

tf.summary.scalar('потеря', потеря, шаг=эпоха)

tf.summary.scalar( «точность», сел.метрика.result(), step=epoch)

Вот некоторые вещи, на которые следует обратить внимание:

  • tf.summary. scalar создает файл и записывает метрики под капотом

  • Журналы фактически сохраняются в двоичном формате, поэтому мы не можем их прочитать

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

Для последнего мы можем обновить метрику внутри графика, используя

 

self.metric.update_state(метки, прогнозы)

А затем получить текущее состояние:

 

self.metric.result()

где:

 

self.metric = tf.keras.metrics.SparseCategoricalAccuracy()

После того, как мы напишем сводку, мы можем запустить Tensorboard на нашем локальном хосте, выполнив следующую команду:

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

Прежде чем мы закончим эту статью, я хотел бы упомянуть одну вещь, которую мы не затронули. И это проверка. В большинстве случаев после того, как мы проводим какое-либо обучение, мы применяем процедуру проверки, чтобы быть уверенными, что наши результаты верны, а их модель не переобучена.Здесь применяются точно такие же принципы, о которых мы говорили до сих пор. У нас по-прежнему будут тест и функция test_step, и мы по-прежнему будем использовать tf.metrics, журналы и Tensorboard. На самом деле, в 90% случаев это мало чем отличается от тренировки. Единственная разница в том, что нам не нужно вычислять градиенты.

Заключение

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

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

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

А пока получайте удовольствие от изучения ИИ.

Книга «Глубокое обучение в производстве» 📖

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

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

Обучение — документация поDetectron2 0.6

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

Пользовательский цикл обучения

Когда модель и загрузчик данных готовы, все остальное, необходимое для написания цикла обучения, можно можно найти в PyTorch, и вы можете сами написать цикл обучения. Этот стиль позволяет исследователям более четко управлять всей логикой обучения и иметь полный контроль. Один из таких примеров приведен в tools/plain_train_net.py.

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

Абстракция тренера

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

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

  • DefaultTrainer — это SimpleTrainer , инициализированный из конфигурация yacs, используемая инструменты/train_net.py и множество скриптов. Он включает в себя больше стандартных поведений по умолчанию, которые можно выбрать, включая конфигурации по умолчанию для оптимизатора, график скорости обучения, регистрация, оценка, контрольные точки и т. д.

Для настройки DefaultTrainer :

  1. Для простых настроек (например, изменения оптимизатора, оценщика, планировщика LR, загрузчика данных и т. д.) перезапишите его методы в подклассе, как tools/train_net.py.

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

    Например, для вывода приветствия во время обучения:

     класс HelloHook (HookBase):
      определение after_step(я):
        если self.trainer.iter% 100 == 0:
          print(f"Привет на итерации {self.trainer.iter}!")
     
  3. Использование системы трейнер+крючок означает, что всегда будет какое-то нестандартное поведение, которое нельзя поддерживать, особенно в исследованиях. По этой причине мы намеренно сделали систему тренера и крючка минимальной, а не мощной. Если с такой системой ничего не получается, проще начать с tools/plain_train_net.py для реализации пользовательской логики обучения вручную.

Регистрация показателей

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

 из Dettron2. utils.events import get_event_storage

# внутри модели:
если самообучение:
  value = # вычислить значение из входных данных
  хранилище = get_event_storage()
  storage.put_scalar("some_accuracy", значение)
 

Дополнительные сведения см. в документации.

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

диплизард — Не найдено

  • YouTube
  • Создать вопрос викторины
  • Демонстрация конв.
  • Демонстрация максимального пула
  • Премиум-курс GAN НОВИНКА
  • Профиль
  • Выйти
  • Авторизоваться
ДЕПЛИЗАРД
  • Курсы
  • Код
  • коллективный разум
  • Влог

ФАЙЛ НЕ НАЙДЕН

  • ©deeplizard
  • YouTube
  • Влог
  • коллективный разум
  • Код
  • Конфиденциальность
  • Условия

клавиатура_стрелка_вверх

.

Добавить комментарий

Ваш адрес email не будет опубликован.