TRX упражнения. Подборка Лучших.

✅ Приседания trx.

Это одно из самых распространенных упражнений на ноги на trx.

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

✅ Выпады в trx петлях.

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

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

✅ Выпады в trx сторону.

Еще одно упражнение, которое отлично подойдет для новичков.

Включает в работу все мышцы ног и ягодицы.

✅ Конькобежец.

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

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

✅ Выпады назад с подъемом бедра.

Очередное упражнение, которое отлично впишется в комплекс trx для новичков.

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

✅ Выпады с выпрыгиванием.

Это еще одно комплексное упражнение на ноги на trx.

Учтите, что с большим лишним весом, его лучше исключить.

✅ Выпады с разножкой.

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

✅ Приседания с выпрыгиванием.

✅ Выпады с ногой в петле.

Это уже более сложный вариант, для более опытных спортсменов.

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

✅ Приседания на одной ноге в trx.

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

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

упражнения и программа тренировок (комплексы)

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

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

Стоит отметить, что сегодня направление TRX (Total Body Resistance Exercise) это не только разнообразие инвентаря, но и целая система разнообразных тренировочных программ, объединенных идеей функционального тренинга.

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

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

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

Total Body Resistance Exercise

Тренировки на TRX (Total Body Resistance Exercise) по своей специализации и принципам относятся к направлению функционального тренинга. В современном фитнесе функциональный тренинг уже занял прочное лидирующее место среди тренировочных методик. Однажды привнесенный в любительский спорт из профессионального (на спортивно-методическом языке называется «скоростно-силовой»), функциональный тренинг успешно научился решать те задачи, которые ставит перед собой большая часть атлетов любителей.

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

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

Цели и задачи тренировочных петель TRX

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

Коррекция веса

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

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

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

Коррекция веса и TRX

Укрепление мышц и опорно-двигательного аппарата

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

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

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

Укрепление мышечного корсета на петлях TRX

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

Топ 60 лучших упражнений с TRX: подборка в гифках!

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

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

Топ-60 упражнений с TRX

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

ПЕТЛИ TRX: вся полезная информация

Плюсы тренировок с TRX:

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

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

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

Упражнения с TRX для верхней части тела

1. Сгибание рук на бицепс (Bicep Curl)

2. Разгибание рук на трицепс (Tricep extension)

3. TRX-отжимания (Push up)

4. Отжимания на трицепс (Tricep press)

Если немного изменить угол и положение рук, нагрузка изменится.

5. Отжимания-паук (Mountain Climber Pushup)

6. Повороты с подтягиванием (TRX Twist)

7. Тяга стоя (TRX Row)

8. Верхняя тяга (High row)

9. Разведение рук в стороны (Reverse Fly)

10. Тяга в положении стола (Table Row)

11. Обратные отжимания (Dips)

12. TRX-пуловер (Pullover)

13. Подтягивание (Pull up)

14. Наклоны с TRX (Good Morning)

15. Раскручивания вперед (Roll up)

Упражнения с TRX для кора (живот, спина)

1. Статическая планка (Plank basic)

2. Планка вверх-вниз (Plank Up & Down)

3. Опускание на локти (Ripper)

4. Альпинист с поворотом (Crisscross climber)

5. Подтягивание колен (Tuck knee)

6. Подъем ягодиц (Pike)

Или вот такой вариант:

7. Статическая планка на локтях (Forearm Plank)

8. Планка «Пила» (Plank saw)

9. Альпинист в планке на локтях (Forearm Plank Climber)

10. Боковая планка (Side Plank)

11. Боковая планка на локтях (Forearm Side Plank)

12. Поворот корпуса в боковой планке (Side Plank Reach)

13. Подъем ягодиц в боковой планке (Side Plank Thrust)

14. Скручивания в боковой планке (Side Plank Crunch)

15. Сгибание ног (Leg Curl)

16. Велосипед (Bicycle)

17. Повороты корпуса стоя (Russian Twist)

Упражнения для бедер и ягодиц

1. Приседание (Squat)

2. Приседание с выпрыгиванием (Plyo Squat)

3. Пистолет-приседание (Pistol squat)

4. Выпад с подвешенной ногой (Suspended Lunge)

5. Выпады (Alternative Lunges)

6. Плиометрические выпады (Plyo lunge)

7. Прыжки по-лягушачьи (TRX Forg)

8. Выпад по-диагонали (Cross Floating Lunge)

9. Широкие прыжки в сторону (Wide Jump)

10. Выпад с балансом (Floating Lunge)

11. Плиометрический выпад с балансом (Floating Lunge Jump)

12. Спринтер (Sprinter Start)

13. Выпады в сторону (Side lunge)

14. Выпад с подвешенной ногой (Suspended Side Lunges)

15. Мертвая тяга (Deadlift)

16. TRX-мост (Bridge)

17. Подъем ягодиц (Hip Raise)

18. Подъем ноги в боковой планке (Adductors)

19. Разведение ног на спине (Suspended aductors)

20. Разведение ног в планке (Reverse Suspended abductors)

Упражнения для верхней и нижней части тела

1. Бурпи (Burpee)

2. Приседание с касанием (Touch and Reach)

3. Альпинист (Mountain Climber)

4. Горизонтальный бег (Hamstring Runner)

5. Подъем одной ноги в обратной планке (Reverse Plank Leg Raise)

6. Отжимание + подтягивание колен (Push up + Tuck Knee)

7. Отжимание + подъем ягодиц (Push up + Peak)

8. Ходьба в планке (Walk Plank)

За гифки спасибо youtube-каналам: Shortcircuits with Marsha, Bcntraining, Max’s Best Bootcamp, Alex Porter, Tony Cress.

Планка: как выполнять + 45 вариантов

Готовый план тренировок с TRX

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

Топ-10 тренировок с TRX на youtube

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

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

План упражнений с TRX для начинающих

Первый раунд:

• Сгибание ног (Leg Curl)
• Статическая планка на локтях (Forearm Plank)
• Приседание (Squat)
• Повороты корпуса стоя (Russian Twist)
• Подъем ягодиц в боковой планке (Side Plank Thrust)

Второй раунд:

• Горизонтальный бег (Hamstring Runner)
• Разведение рук в стороны (Reverse Fly)
• TRX-мост (Bridge)
• Боковая планка (Side Plank)
• Выпад с подвешенной ногой (Suspended Lunge)

Как выполнять эту тренировку с TRX для начинающих?

• Каждое упражнение выполняем 30 секунд, перерыв 15 секунд
• Выполняем каждый раунд по 2 круга
• Отдых между кругами 1 минута
• Общая продолжительность одного круга 3,5 минуты
• Общая продолжительность тренировки: ~17 минут

План упражнений с TRX для среднего уровня

Первый раунд:

• Плиометрический выпад с балансом (Floating Lunge Jump)
• Сгибание рук на бицепс (Bicep Curl)
• Альпинист (Mountain Climber)
• Разведение ног на спине (Suspended aductors)
• Планка «Пила» (Plank saw)

Второй раунд:

• Приседание с выпрыгиванием (Plyo Squat)
• Планка вверх-вниз (Plank Up & Down)
• Разгибание рук на трицепс (Tricep extension)
• Велосипед (Bicycle)
• Подъем одной ноги в обратной планке (Reverse Plank Leg Raise)

Третий раунд:

• Выпад по-диагонали (Cross Floating Lunge)
• Поворот корпуса в боковой планке (Side Plank Reach)
• Тяга стоя (TRX Row)
• Приседание с касанием (Touch and Reach)
• Подтягивание колен (Tuck knee)

Как выполнять эту тренировку с TRX для среднего уровня?

• Каждое упражнение выполняем 30 секунд, перерыв 15 секунд
• Выполняем каждый раунд по 2 круга
• Отдых между кругами 1 минута
• Общая продолжительность одного круга ~3,5 минуты
• Общая продолжительность тренировки: ~ 26 минут

План упражнений с TRX для продвинутых

Первый раунд:

• Отжимание + подтягивание колен (Push up + Tuck Knee)
• Плиометрические выпады (Plyo lunge)
• Альпинист в планке на локтях (Forearm Plank Climber)
• Выпад с подвешенной ногой (Suspended Side Lunges)
• Скручивания в боковой планке (Side Plank Crunch)
• Подъем ягодиц (Pike)
• Ходьба в планке (Walk Plank)

Второй раунд:

• Прыжки по-лягушачьи (TRX Forg)
• Отжимания на трицепс (Tricep press)
• Разведение ног в планке (Reverse Suspended abductors)
• Опускание на локти (Ripper)
• Спринтер (Sprinter Start)
• Подтягивание (Pull up)
• Пистолет-приседание (Pistol squat)

Третий раунд:

• Бурпи (Burpee)
• TRX-пуловер (Pullover)
• Подъем ноги в боковой планке (Adductors)
• Отжимание + подъем ягодиц (Push up + Peak)
• Широкие прыжки в сторону (Wide Jump)
• Альпинист с поворотом (Crisscross climber)
• Обратные отжимания (Dips)

Как выполнять эту тренировку с TRX для продвинутых?

• Каждое упражнение выполняем 45 секунд, перерыв 15 секунд
• Выполняем каждый раунд по 2 круга
• Отдых между кругами 1 минута
• Общая продолжительность одного круга ~7 минут
• Общая продолжительность тренировки: ~ 45 минут

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

Читайте также:

Официальный сайт TRX в России

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

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

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

Тренировочные петли TRX были разработаны американскими «котиками» — спецназом морской пехоты США и после нескольких этапов усовершенствований были представлены мировому фитнес-сообществу. Компактный и эффективный, TRX тренажер с самого начала был великолепно принят и любителями фитнеса и спортивными профессионалами элитарного уровня. Сегодня петли TRX используются ВСЕМИ командами NHL, NFL, NBA и во многих других видах спорта, а также лежат в рюкзаке каждого четвертого солдата США во время выполнения операций за пределами страны.

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

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

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

Многие фитнес-клубы стремятся активно применять функциональные петли TRX в работе со своими клиентами в рамках функциональных тренировок, в пилатесе и реабилитационных программах. Особую популярность в последнее время приобрело outdoor-направление.

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

Крепеж оборудования может осуществляться:
— на турник
— на крюки для боксерских мешков
— на любой столб
— на ветку дерева
— на любую дверь (при помощи специального анкера)

Благодаря малому весу (менее 1 кг) и компактности тренажера, TRX всегда можно взять с собой, чтобы не прерывать график тренировок во время командировки или отпуска.
Многие звезды спорта, кино и шоу-бизнеса считают петли TRX незаменимым оборудованием для своих регулярных тренировок. Функциональные петли также широко используются профессиональными спортсменами с целью повышения результативности своих тренировок в таких видах спорта как бокс, тяжелая атлетика, боевые искусства, хоккей, гольф, теннис и многих других. ФК Ливерпуль признает, что именно использование TRX позволило им добиться небывало низкого уровня травмируемости футболистов.
Тренажер TRX Suspension Professional Trainer состоит из нейлоновых ремней, создающих сопротивление с помощью двух источников: веса вашего тела и силы гравитации. Для начала занятий вам нужно просто зафиксировать ремни TRX на каком-либо приспособлении, находящемся над землей (например, на перекладине, двери, ветке дерева). Упражнения с TRX позволят вам по-новому взглянуть на возможности своего организма и изменят ваш взгляд на привычные функциональные тренировки. Любой компонент оригинального функционального тренажера TRX гарантированно выдерживает нагрузку до 160 кг. Обратите внимание, что подделки не рассчитаны на использование с такими нагрузками и тренировки на них опасны! Подробнее об отличиях оригинальных тренировочных петель TRX и подделок.

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

Тысячи людей по всему миру уже смогли оценить высочайшую эффективность тренировок с функциональными петлями TRX.

В чем же преимущество тренировочных петель TRX?

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

Преимущества функциональных тренировок с TRX

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

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

Цикл обучения модели глубокого обучения

| Илья Зайцев

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loss

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

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

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

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

Точность

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

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

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

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

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

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

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

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

Полупериод смещенной и масштабированной функции косинуса

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

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

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

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

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

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

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

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

Stream Logger

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

Итак, мы готовы начать использовать наш цикл обучения!

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

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

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

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

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

 Эпоха: 1 | train_loss = 0.8907, train_accuracy = 0.6387, valid_loss = 0.1027, valid_accuracy = 0.9695poch: 2 | train_loss = 0.4990, train_accuracy = 0.8822, valid_loss = 0.0828, valid_accuracy = 0.9794Epoch: 3 | train_loss = 0.3639, train_accuracy = 0.9086, valid_loss = 0.0723, valid_accuracy = 0.9823 

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

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

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

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

.Цикл индивидуального обучения

Keras. Как создать собственный цикл обучения в… | автор: Javier

Удивительное фото Дэна Мейерса на Unsplash

Как создать собственный цикл обучения на более низком уровне абстракции, использование K.function, opt.get_updates и другие вещи под капотом движка Keras

Keras — это высокий уровень библиотека, среди всех других библиотек глубокого обучения, и мы все любим ее за это. Он абстрагирует большую часть боли, которую, не менее любимый нами, Tensorflow приносит с собой для очень эффективной обработки данных на GPU.

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

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

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

Однако одна из вещей, с которой я боролся больше всего, — это создание пользовательского цикла обучения. Но почему, черт возьми, вы вообще хотите создать собственный цикл обучения? Разве не весь смысл Кераса в том, чтобы абстрагироваться от таких нюансов, чтобы вы могли сосредоточиться на модели? Что ж, это совершенно верно, но есть некоторые угловые случаи, в которых вы захотите испачкать руки: когда ваша модель имеет несколько входов и выходов разной формы (не объединяемых) и уникальную функцию потерь, когда вам нужен доступ к градиенты оптимизации во время обучения … или, если вам нужны конкретные приложения: GAN и обучение с подкреплением, в основном, насколько мне известно (дайте мне знать в комментариях, если вы найдете другие, чтобы я тоже мог учиться).Основная причина написать этот пост — прояснить (или задокументировать, если хотите) использование определенных инструментов в движке Keras для создания настраиваемого цикла обучения без строгих ограничений рамкой.

Ну хватит скучно, покажи код!

Вот он, так что вы можете взглянуть:

Вы можете разбить это на несколько частей:

• Создание набора данных: фиктивный набор данных для нашего примера.
• Рабочий процесс Keras по умолчанию: который включает модель, функцию потерь и определение оптимизатора.
• Создание графа: построение вычислительного графа и связывание всех его частей. Этот раздел отличается от рабочего процесса Keras по умолчанию, потому что он выполняется внутри движка Keras.
• K. function Использование: это сложная часть, K.function , это не очень хорошо документировано, поэтому я попытаюсь пролить свет на эту проблему.
• Цикл обучения: здесь ничего особенного, только циклы for и некоторая печать для отслеживания эволюции обучения (и, конечно, тестирования).

Dataset

Фиктивный набор данных для нашего случая. Если дано 2 числа в диапазоне [0, 9], сеть должна предсказать их сумму. Итак:

• Samples = [100 x 2], поэтому 100 выборок из 2 функций (2 числа для суммирования)
• Targets = [100], результат суммы этих 100 выборок, в идеале, я бы хотел это должно быть [100 x 1], но все мы знакомы с тем, как Numpy работает при уменьшении размеров.

Также был создан небольшой тестовый набор данных с 10 образцами.

 # Обучающие образцы 
 samples = np.random.randint (0, 9, size = (100,2)) target = np.sum (samples, axis = -1) # Образцы для тестирования 
 samples_test = np.random. randint (0, 9, size = (10,2)) target_test = np.sum (samples_test, axis = -1) 

Рабочий процесс Keras

Вы уже это знаете, поэтому:

 # Модель 
 x = Input (shape = [2]) 
 y = Dense (units = 1) (x) 
 model = Model (x, y) 
 # Loss 
 def loss_fn (y_true, y_pred): 
 # Вы можете получить все сумасшедшие и запутанные 
 # на этот раз не хочу никаких ограничений Keras :) 
 loss_value = K.sum (K.pow ((y_true - y_pred), 2)) 
 return loss_value 
 # Оптимизатор для запуска градиентов 
 optimizer = Adam (lr = 1e-4) 

Единственное, что здесь — это то, что вы можете понести убыток работают настолько безумно и запутанно, как вы хотите, поскольку движок Keras не остановит вас своим _standarize_user_data (ссылка) и не будет жаловаться. Вы можете использовать несколько входов, настраиваемую функцию потерь по аргументам … Я реализовал простую сумму квадратов ошибок (SSE) для этой демонстрации.

Создание и связывание графиков

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

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

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

 y_true = Input (shape = [0]) 
 y_pred = model (x) 
 loss = loss_fn (y_true, y_pred) 

Если вы обратите на это пристальное внимание, вы обнаружите, что единственными входными данными для этого графика являются x и y_true (я знаю, вы догадались, потому что есть единственные переменные, которым назначен вызов Input , но на всякий случай…).

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

Осталось только определить график для вычисления градиентов потерь по отношению к весам модели и обновить эти веса в соответствии со скоростью обучения. Легко, правда? Что ж, это именно то, что делает optimizer.get_updates . Учитывая некоторые параметры и потери, зависящие от этих параметров, он возвращает вычислительный граф для вычисления градиентов (с использованием печально известного K.градиенты) и обновление весов.

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

Это делается путем вызова optimizer.get_updates с потеря , как мы ее определили, и параметры или обучаемые веса модели для оптимизации.

 # Операция по получению 
 # градиентов и обновлений весов 
 updates_op = optimizer.get_updates (
 params = model.trainable_weights, 
 loss = loss) 

Использование K.function

Сейчас у нас есть график. На самом деле у нас есть два графика:

• График 1: Входы = [x, y_true], Выходы = [потери]
• График 2: Входы = [потери, веса], Выходы = [веса обновлены]

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

Итак, теперь у нас есть 2 графика, которые должны быть очень эффективно запущены на GPU, так что хорошо, как нам их запустить? В этом нам поможет функция K. Функция .

Использование K.function (или keras.backend.function для полноты) аналогично использованию Tensorflow (этот был законным) tf.Session для создания экземпляра графа и session.run для его запуска , Таким образом, описание функции K. будет:

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

Имея это в виду, мы создаем 2 функции для выполнения графиков, определенных ранее:

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

 поезд = K.function (
 входов = [x, y_true], 
 выходов = [потеря], 
 обновления = updates_op) 

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

 test = K.function (
 input = [x, y_true], 
 output = [loss]) 

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

В нашем случае вызов будет выполнен как: loss = train ([sample, target]) , а затем список потерь будет таким: loss = loss [0] . Но вы можете проверить это в коде, чтобы увидеть его в контексте.

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

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

Дьявол кроется в деталях, поэтому:

• tqdm это просто библиотека, которая реализует индикатор выполнения, который будет информировать о прогрессе тренировки в течение одной эпохи.
• Поскольку мы берем по одному образцу за раз, batch_size = 1 , Numpy сжимает размер партии, но модель ожидает ввода с двумя измерениями, партиями и функциями, поэтому нам нужно добавить размер партии вручную с np ,Расширять_димс .
• График работает с тензорами, поэтому нам нужно преобразовать входные данные в график в тензоры с константой К. .
• Был реализован накопитель потерь при обучении для вычисления среднего значения на каждом шаге в loss_train_mean , этот показатель печатается на индикаторе выполнения на каждом временном шаге, чтобы отслеживать развитие обучения.

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

Убедитесь, что размеры должны совпадать для каждого входного тензора, это выполняется движком Keras по умолчанию, но здесь мы стремимся взять на себя управление. Итак, когда мы вызываем train ([sample, target]) , образец должен иметь те же размеры, что и x = Input (shape = [2]) , поэтому 2, размер партии и элемента, и target должны имеют те же размеры, что и y_true = Input (shape = [0]) , который представляет собой тензор нулевой размерности или одно число (скаляр).

Если вы запустите код, вы увидите что-то вроде этого:

Эволюция обучения с медленным графическим процессором ноутбука

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

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

Другие подходы

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

Но что, если я хочу работать на низком уровне абстракции? (может быть, вы занимаетесь оптимизацией и пишете новый оптимизатор, или, может быть, вы занимаетесь алгеброй для научных вычислений… кто знает?) В этом случае вы могли бы спросить себя: есть ли другой альтернативный способ создания циклов обучения, если я действительно хотите взять все под контроль?

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

• Tensor Layer: широко упускаемый из виду проект Google, который направлен на обеспечение основных строительных блоков моделей глубокого обучения, не отказываясь от низкого уровня. специфика.
• Пользовательский цикл обучения TensorFlow 2.0: с интеграцией Keras в версию 2.0 Tensorflow у вас есть лучшее из обоих миров, высокоуровневые строительные блоки Keras с низкоуровневым управлением потоком Tensorflow.

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

.

Написание обучающего цикла с нуля

Автор: fchollet
Дата создания: 2019/03/01
Последнее изменение: 2020/04/15
Описание: Полное руководство по написанию низкоуровневых циклов обучения и оценки.

Просмотреть в Colab • Исходный код GitHub

Настройка

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

Введение

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

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

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

Использование GradientTape : первый сквозной пример

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

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

  входов = keras.Input (shape = (784,), name = "digits")
x1 = Layers.Dense (64, Activation = "relu") (входы)
x2 = слои. Dense (64, активация = "relu") (x1)
output = Layers.Dense (10, name = "прогнозы") (x2)
model = keras.Model (входы = входы, выходы = выходы)
  

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

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

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

# Подготовить обучающий набор данных.
batch_size = 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))
train_dataset = tf.data.Dataset.from_tensor_slices ((x_train, y_train))
train_dataset = train_dataset.shuffle (размер_буфера = 1024) .batch (размер_пакета)
  

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

• Мы открываем цикл для , который повторяется по эпохам
• Для каждой эпохи мы открываем цикл для , который выполняет итерацию по набору данных партиями
• Для каждой партии открываем GradientTape () scope
• Внутри этой области мы вызываем модель (прямой проход) и вычисляем потери
• За пределами области действия извлекаем градиенты весов
модели с учетом убытка
• Наконец, мы используем оптимизатор для обновления весов модели на основе
градиенты

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

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

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

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

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

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

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

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

  Начало эпохи 0
Потеря обучения (для одной партии) на шаге 0: 97,3328
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 1,3363
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 1,2435
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 0,9772
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0.6763
На данный момент просмотрено: 51264 образца
  

  Начало эпохи 1
Потеря обучения (для одной партии) на шаге 0: 0,6312
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 0,4847
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 0,5155
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 0,3894
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0,4914
На данный момент просмотрено: 51264 образца
  

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

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

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

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

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

  # Получить модель
входы = керас.Ввод (shape = (784,), name = "digits")
x = Layers.Dense (64, Activation = "relu", name = "density_1") (входные данные)
x = Layers.Dense (64, Activation = "relu", name = "density_2") (x)
output = Layers.Dense (10, name = "прогнозы") (x)
model = keras.Model (входы = входы, выходы = выходы)

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

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

# Подготовить обучающий набор данных.
batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices ((x_train, y_train))
train_dataset = train_dataset.shuffle (размер_буфера = 1024) .batch (размер_пакета)

# Подготовить набор данных для проверки.
# Зарезервировать 10 000 образцов для проверки.
x_val = x_train [-10000:]
y_val = y_train [-10000:]
x_train = x_train [: - 10000]
y_train = y_train [: - 10000]
val_dataset = tf.data.Dataset.from_tensor_slices ((x_val, y_val))
val_dataset = val_dataset.партия (64)
  

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

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

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

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

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

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

    # Отображение показателей в конце каждой эпохи.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, обучение = False)
        # Обновить показатели 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: 83.1239
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 2,4446
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 1,3355
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 1,0067
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0.5941
На данный момент просмотрено: 51264 образца
Эпоха обучения: 0,7184
Проверка в соответствии с: 0.8099
Затраченное время: 3,99 с
  

  Начало эпохи 1
Потеря обучения (для одной партии) на шаге 0: 0,6010
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 0,8994
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 0,3894
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 0,9923
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0.3522
На данный момент просмотрено: 51264 образца
Эпоха обучения: 0,8205
Соответствие валидации: 0.8681
Затраченное время: 4.00 сек.
  

Ускорение тренировочного процесса с помощью функции тс

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

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

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

  @ tf.function
def train_step (x, y):
    с tf.GradientTape () в качестве ленты:
        logits = модель (x, обучение = True)
        loss_value = loss_fn (y, логиты)
    grads = tape.gradient (loss_value, model.trainable_weights)
    optimizer.apply_gradients (zip (grads, model.trainable_weights))
    train_acc_metric.update_state (y, логиты)
    возврат loss_value
  

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

  @ tf.function
def test_step (x, y):
    val_logits = модель (x, обучение = False)
    val_acc_metric.update_state (y, val_logits)
  

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

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

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

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

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

    # Отображение показателей в конце каждой эпохи.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.time () - start_time))
  

  Начало эпохи 0
Потери обучения (для одной партии) на шаге 0: 0,7456
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 0,4579
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 0,5318
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 0,9282
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0,4210
На данный момент просмотрено: 51264 образца
Эпоха обучения: 0.8569
Соответствие валидации: 0.8882
Затраченное время: 1,20 с
  

  Начало эпохи 1
Потери обучения (для одной партии) на шаге 0: 0,2207
На данный момент просмотрено: 64 образца
Потеря обучения (для одной партии) на шаге 200: 0,2255
На данный момент просмотрено: 12864 образца
Потеря обучения (для одной партии) на шаге 400: 0,3687
На данный момент просмотрено: 25664 образца
Потеря обучения (для одной партии) на шаге 600: 0,4691
На данный момент просмотрено: 38464 образца
Потеря обучения (для одной партии) на шаге 800: 0,4616
На данный момент просмотрено: 51264 образца
Эпоха обучения: 0,8776
Соответствие валидации: 0.9027
Затраченное время: 0,70 с
  

Намного быстрее, не правда ли?

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

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

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

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

  класс ActivityRegularizationLayer (Layer.Layer):
    def call (self, input):
        self.add_loss (1e-2 * tf.reduce_sum (входы))
        возврат входов
  

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

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

model = keras.Model (входы = входы, выходы = выходы)
  

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

  @ tf.function
def train_step (x, y):
    с tf.GradientTape () в качестве ленты:
        logits = модель (x, обучение = True)
        loss_value = loss_fn (y, логиты)
        # Добавьте любые дополнительные потери, возникшие во время прямого прохода.
        loss_value + = сумма (model.losses)
    грады = лента.градиент (loss_value, model.trainable_weights)
    optimizer.apply_gradients (zip (grads, 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 (shape = (28, 28, 1)),
        Layers.Conv2D (64, (3, 3), strides = (2, 2), padding = "same"),
        layers.LeakyReLU (альфа = 0,2),
        Layers.Conv2D (128, (3, 3), strides = (2, 2), padding = "same"),
        слои.LeakyReLU (альфа = 0,2),
        layers.GlobalMaxPooling2D (),
        layers.Dense (1),
    ],
    имя = «дискриминатор»,
)
discriminator.summary ()
  

  Модель: «Дискриминатор»
_________________________________________________________________
Слой (тип) Параметр формы вывода #
================================================== ===============
conv2d (Conv2D) (Нет, 14, 14, 64) 640
_________________________________________________________________
утечка_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) (представляющие
Цифры MNIST):

  latent_dim = 128

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

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

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

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


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

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

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

    # Выборка случайных точек в скрытом пространстве
    random_latent_vectors = tf.random.normal (форма = (размер_пакции, латент_размер))
    # Соберите ярлыки, на которых написано "все настоящие изображения"
    misleading_labels = tf.нули ((размер_пакции, 1))

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

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

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

  импорт ОС

# Подготовить набор данных. Мы используем как обучающие, так и тестовые цифры MNIST.
batch_size = 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) Пакетный (batch_size)

epochs = 1 # На практике вам нужно как минимум 20 эпох для генерации хороших цифр.
save_dir = "./"

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

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

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

            # Сохранить одно сгенерированное изображение
            img = tf.keras.preprocessing.image.array_to_img (
                created_images [0] * 255.0, scale = False
            )
            img.save (os.path.join (save_dir, "created_img" + str (шаг) + ".png"))

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

  Начало эпохи 0
потеря дискриминатора на шаге 0: 0.69
состязательный проигрыш на шаге 0: 0,66
  

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

,

python - Tensorboard для пользовательского цикла обучения в Tensorflow 2

Переполнение стека

1. Товары

2. Клиенты
3. Случаи использования

1. Переполнение стека
Общественные вопросы и ответы

2. Команды
Частные вопросы и ответы для вашей команды

3. предприятие
Частные вопросы и ответы для вашего предприятия

4. работы
Программирование и связанные с ним возможности технической карьеры

5. Талант
Нанять технических талантов

6. реклама
Обратитесь к разработчикам по всему миру

,