АВТО БЛОГ YAMAHA-VOLGA.RU

Статьи / Авто с пробегом 5 причин покупать и не покупать Infiniti FX II / Infiniti QX70 Вы молоды душой и телом, пока что не обременены большой семьей, неплохо зарабатываете и хотите ездить на мощной, яркой, дерзкой машине. Только вот беда: те же BMW X6 и Mercedes GLC AMG вам в… 1445 6 3 11.09.2022

Статьи / История Тюнинг суперкаров по-немецки: самые яркие проекты ателье Koenig Specials Не так давно мы вспоминали тюнинговые ателье, прославившиеся тюнингом автомобилей Mercedes. И если сейчас он превратился в мощную индустрию, в которой тон уже задают не только (и не столько… 2079 1 23 10. 09.2022

Популярные тест-драйвы

Тест-драйвы / Тест-драйв Полный привод, самый мощный мотор и силы в запасе: первый тест Chery Tiggo 8 PRO MAX Появление в российской линейке Chery модели Tiggo 8 PRO MAX можно назвать знаковым для бренда. Почему? Да хотя бы потому, что это первый с 2014 года полноприводный кроссовер Chery, приехавши… 17691 12 44 29.04.2022

Тест-драйвы / Тест-драйв Компактный, доналоговый, с V8 и 16 лет без ремонтов: опыт владения Ford Explorer III Принято считать, что «ездить долго и счастливо» – это не про 15-летние машины. Тем не менее чудеса случаются, и иногда безупречный по техническому состоянию классический рамный внедорожник м. .. 13016 6 20 14.04.2022

Тест-драйвы / Тест-драйв Мотор от Mercedes, эмблема от Renault, сборка от Dacia: тест-драйв европейского Logan 1,0 Казалось бы, что нового можно рассказать про Renault Logan второго поколения, известный каждому российскому таксисту, что называется, вдоль и поперёк? Однако конкретно в этом автомобиле есть… 9255 10 41 13.08.2022

Когда нужно делать развал схождение колёс?

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

ЧТО ТАКОЕ СХОД-РАЗВАЛ КОЛЕС АВТОМОБИЛЯ 

Развал-схождение (распространены также такие названия сервисной операции  как сход-развал и регулировка углов установки колес или же сокращённо РУУК) – это процедура,  направленная на регулировку колёс относительно кузова. Если сход-развал не выполнен или сделан неграмотно, это чревато для транспортного средства и его владельца рядом проблем:

• Нарушается курсовая устойчивость.
• Машину начинает «заносить».
• Теряется маневренность.
• Транспортное средство начинает «съедать» увеличенное количество топлива. Особенно это ощутимо на коммерческом транспорте: грузовиках, тягачах, автобусах.
• Шины приобретают желание быстро «лететь». Если со сходом-развалом всё из рук вон плохо, то даже, если пройдено всего пятьсот километров дороги, новая покрышка будет стерта полностью.

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

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

Развал-схождение: геометрические показатели

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

Главные геометрические показатели – это:

• угол схождения,
• угол развала, 
• угол наклона колеса,
• расстановка колёс и осей.

Угол схождения

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

Средние значения углов схождения:

• для переднеприводных: 0±10′.
• для заднеприводных: +15’±10′.

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

Если схождение левого и правого колеса равны, это половинчатое схождение.

Допуск в отклонениях схождения на каждое колесо на автосервисах составляет ±5′. 

Угол развала

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

Средние значения угла развала: 

• для задней колесной базы – не превышает 0°40′-1°00′.
• для передней колесной базы – не превышает 0°15′-0°40′.

Конструктивно транспортные средства разнятся и исходные углы развала разнятся.  Бывает нулевой, отрицательный и положительный угол.

Теория:

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

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

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

Практика:

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

• Чуть для меньшего количества транспортных средств характерен отрицательный развал.  Это в основном – гоночные машины. Отрицательное значение угла получает максимальный контакт колес с дорогой. Для гонщиков это приоритет №1. Правда, износ шин – колоссальный. Из-за этого это не вариант для «рядовых» автомобилей. Непрактично. Но в соревнованиях, когда важна, в первую очередь, скорость, нужный эффект легко получить. Для дрифта идеальней не придумать.

• Положительный развал уходит в прошлое. В 21-м веке автомобили с такими геометрическими параметрами не выпускаются, хотя в 80-е годы 20-го века с такими параметрами с конвееров сходил даже коммерческий транспорт. Яркий пример – знаменитые грузовики Tatra 815 с хребтовой рамой. Но в восторге от них часто были не автопарки, а…опять-таки шиномонтажники. Износ резины у них был предельно неравномерным, и для мастеров всегда находились заказы.

Угол наклона оси (кастер)  

Существуют  продольные углы наклона оси поворота. Они регулируемы. Могут менять значение под воздействием веса груза в багажнике транспортного средства. Допуск для левой и правой стороны не может превышать значение 0°15′-0°40′.

Также существуют поперечные углы наклона оси поворота. Они нерегулируемы.

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

Расстановка осей и колёс

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

Под расстановкой колёс подразумевают интервал между серединами колес конкретной оси.

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

Нужно ли делать балансировку после сход-развала?

Как таковые сервисные операции, касающиеся развала схождения и балансировки, не взаимосвязаны. Поэтому нет чёткого правила: сделали РУУК – приступите к балансировке.

Важно понимать, что цели у этих процедур совершенно разные:

1. РУУК направлена на обеспечение колёсам геометрически правильного положения.
2. Балансировка колес избавляет от такой процедуры как биения колес при движении.

Но на практике при техническом обслуживании РУУК действительно делают часто в тандеме с балансировкой.  И здесь есть две причины:

Обе процедуры для профилактики рекомендуется выполнять каждые 7 00 000 –  8 000 км пробега, для старых автомобилей при езде по плохим дорогам и каждые 15 000 – 20 000 км.

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

Так «показанием» к РУУК выступает смена покрышек, монтаж новых дисков, регулярная езда с пробуксовкой. Балансировку же делают, если покрышки повреждены с одной стороны, беспокоит работа подвески (чувствуются удары), выполнялся ремонт ходовой.

Правда, если выполняется ремонт ходовой, не нужно сразу «пороть горячку». Необходимость проведения РУУК зависит от того, что конкретно меняли, и диагностических мероприятий. Если была демонтирована рулевая рейка с целью регулировки прижима или замены пыльника, то высока вероятность, что диагностика покажет: параметры не сбиты.

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

Замена сайлентблоков: нужен ли сход развал?

У ряда автомобилистов возникает вопрос: а нужен ли РУУК при замене сайлентблоков.

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

Порой возникает такая ситуация, что РУУК автомобилист выполняет регулярно, а с заменой сайлентблоков медлит. Это недопустимо. РУУК в том случае «адаптивен» не под норму, а под деформации, которые неизбежны из-за состарившихся сайлентблоков.

Что в итоге? Выброшенные деньги на ветер. Ведь сайлентблоки всё-равно придётся менять, а развал-сход делать повторно.

Нужно ли делать развал-схождение при замене шаровых опор? 

РУУК – очень полезная для “здоровья” транспортного средства и обеспечения уровня безопасности процедура при замене шаровых опор.

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

Нужно ли делать развал схождение после замены амортизаторов?

А вот после замены амортизаторов  РУУК – необязательная процедура, хотя автовладельцы как-раз часто воспринимают замену амортизаторов в качестве прямого стимула отправиться сделать сход-развал.

Дело в том, что хоть эти автозапчасти не оказывают прямого влияния на рулевое управление. У них нет «власти» над рулевыми тягами. 

Как регулируется развал схождение?

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

• Поднимите автомобиль на домкрате.
• Проверьте геометрию подвески. 
• В случае проблем с подвеской – замените «нездоровые» детали, то есть осмотрите подвеску на предмет износа и трещин. Если никаких патологий не обнаружили идем дальше, если обнаружили, замените износившийся элемент, иначе наши усилия пройдут зря.
• Для ослабления развала вращайте эксцентрик и ослабьте контргайку (приём актуален для большинства современных транспортных средств).
• Измерьте результат развала.
• Для настройки схождения ослабьте тягу контргайки. 
• Измените длину контргайки путем её вращения
• Затяните крепления.
• Опустите авто.

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

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

Если же используются 3D-стенды, то важно понимать, тут механизм следующий:

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

Чем SENSYS Engineering полезен в освоении технологий РУУК?

SENSYS Engineering предлагает своим слушателям базовый электронный тренинг и система проверки знаний «Шины, диски и шиномонтаж». Это 16 интерактивных модулей и система тестов, которые «заточены» на освоение таких вопросов, связанных с устройством колёс автомобилей, дисков и шин транспортных средств, маркировкой, системой контроля давления в них.

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

Общее (ориентировочное) время изучения материала: 10 часов. При этом так как продукт электронный, слушатели могут изучать материал в наиболее удобном для себя ритме.

На прохождение же тестов отводится 3 часа.

Зачем нужно делать развал-схождение?

Развал-схождение необходимо делать по нескольким причинам:

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

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

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

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

Что лучше перекачать или не докачать давление в колесах?

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

Почему руль стоит криво при движении по прямой?

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

Возможные причины:
1. Повышенный свободный ход в рулевом механизме.
2. Автомобиль имеет некоторое смещение заднего моста (задней оси) или деформации задней балки. Особенно, когда одно колесо имеет положительный развал, а другое — отрицательный.
3. Неисправность гидро- или электро- усилителя руля
4. Большая разница в давлении колес на одной оси.
5. Имеются скрытые дефекты ходовой части, которые по какой-либо причине не были обнаружены перед регулировкой «сход-развала».
6. Возможны дефекты резины. Нужно поменять местами правое и левое колеса, если руль изменил свое
7. положение в зеркальном отображении — перевернуть покрышку на одном из передних колес.

Машину уводит в сторону, а регулировка развала не предусмотрена, можно ли что-то сделать?

Регулировка развала-схождения колес на автомобилях с подвеской МакФерсон (Macpherson) осуществляется стойками. Если на стойках отверстия овальные, то ослабляются болты и поворотный кулак вместе в колесом перемещается на заданный угол. Но на многих автомобилях (Mitsubishi, Nissan, Hyundai, Kia и др.) угол развала не регулируется, так как отверстия на стойках круглые, а не овальные. В этом случае нужно расточить отверстия и отрегулировать развал.

Как правило, эту проблему приходится решать таким способом на автомобилях с правым рулем, угол развала на которых «установлен» под левый уклон дороги, или на автомобилях с деформированными поворотными кулаками. К сожалению, на opel vectra, ford, peugeot и некоторых других автомобилях такой возможности нет. На таких автомобилях стойка и кулак — одно целое.

Почему при торможении машину уводит в сторону вправо или влево?

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

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

Почему при разгоне машину тянет (уводит) вправо?

Увод переднеприводной машины может быть если стоят проставки на передних пружинах (или на 2109 стойки от 2110), причем тянуть будет в сторону более длинного привода ( полуоси начинают работать под углом, а на длинном приводе вектор центробежной силы будет больше). В этом случае увод ощущается при разгоне, а при прямолинейном равномерном движении — нет. На отечественных ВАЗ 2108 — ВАЗ 2115 увод вправо заложен «по умолчанию». Повлиять на это можно путем изменения продольного наклона стойки (кастра). Т.е. справа нужно вытащить одну, а иногда и две шайбы или вложить столько же слева. На многих иномарках (VW, Mazda, Ford) для компенсации этого эффекта на полуоси производитель ставит демпфер.

Почему автомобиль уводит в сторону после развала-схождения?

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

2. Повышенный дисбаланс колес. Кривизна колесных дисков — сделайте балансировку или замените диски.

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

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

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

Скорее всего причина в резине (см. пункт выше). Автомобиль раньше ехал ровно потому, что увод создаваемый резиной был уравновешен уводом создаваемым неправильными углами «развала» в др. сторону. Устранили эту причину — появился увод.

Машину не ведет и протектор не «жрет», но автомобиль туговат в управлении («тугой» руль).

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

2. Неправильно отрегулирован «развал» (углы развала одинаковы, но слишком большие).

3. Ширина шин не соответствует рекомендованной изготовителем, вследствие чего пятно контакта с дорогой увеличиваетя и увеличивается трение.

4. Низкое давление воздуха в шинах (давление меньше 1 атмосферы).

Проблемы 2,3,4 — увеличение пятна контакта с дорогой — как следствие «тугой руль».

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

1. Наверно, всем известно, что углы установки колес напрямую зависят от клиренса автомобиля (дорожного просвета) А клиренс, в свою очередь, имеет особенность уменьшаться с возрастом автомобиля. Это происходит из-за просадки упругих элементов подвески: пружины, резинки, элементы кузова.

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

3. Естественное старение кузова (для автомобилей с несущим кузовом), ввиду того, что он испытывает в процессе эксплуатации постоянные изгибающие и крутящие моменты ,что приводит к постепенному изменению его «геометрии» и в свою очередь — к изменению углов развала-схождения. Например, на новых Жигулях продольный наклон шкворня (кастер) устанавливается 3,5-4°, но уже через 2-3 года этот показатель будет составлять 2-2,5°. Кстати, такая же тенденция видна на всех автомобилях, независимо от производителя, разница только в величине углов.

Как проверить и отрегулировать развал? Схождение и развал колес что за развал колес колеса

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

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

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

Когда и для чего нужно производить развал

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

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

Что дает правильная установка схода развала и кастора?

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

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

Как сделать сход-развал

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

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

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

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

Видео про развал фото

выводы

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

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

Что такое коллапс?

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

Что нужно для работы?

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

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

Что такое крах расклада?

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

Почему он сбит?

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

Как выполнить настройку?

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

Необходимость

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

Проверка сбора

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

Как часто делать развал-схождение?

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

• проведение некоторых видов ремонтных работ, замена расходных материалов;
• нарушение нормальной эксплуатации автомобиля (увод в сторону, смещение руля, задержки в управлении, «плавание» в колее;
• разный радиус поворота вправо/влево, невозврат автомобиля при выходе из поворота.

Что будет, если не делать?

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

Развал автомобиля схождение на фото
Регулировка развала схождения колес своими руками

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

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

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

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

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

В случае автомобиля с подвеской большинства типов, за исключением МакФерсон, развал для передних управляемых колес, как правило, имеет незначительное положительное значение (колеса наклонены наружу) — в пределах от 0′ до 45′ , местами до 2°.
Это его значение позволяет уменьшить усилия на управляемых колесах и уменьшить передачу на рулевое управление рывков, возникающих при движении по неровностям дороги.
Большой отрицательный развал («Колеса Домича») является признаком износа подвески или неправильной ее регулировки и приводит к быстрому износу шин, ухудшению сцепных свойств на ровной дороге и нарушению устойчивости автомобиля.

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

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

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

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

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

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

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

Выравнивание измеряется в градусах/минутах (знаки ° и ‘) и в миллиметрах.
Схождение в миллиметрах — это расстояние между задними кромками колеса минус расстояние между передними кромками колеса (в справочниках обычно приводятся данные по стандартным колесам, при произвольном диаметре колеса требуется перерасчет). Это определение верно только в случае целых, правильно установленных колес.
В противном случае применяется процедура Ran-Out (RUN OUT), которая вычитает колесо колеса из величины сходимости.

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

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

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

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

Угол пересечения оси наклона колес

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

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

Зачем нужен развал-схождение на машине?

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

Автомобиль с нормальным развалом схождения колес имеет:
1. Хорошая курсовая устойчивость (отклонения от прямолинейного движения должны быть минимальными).
2. Легкое обращение.
3. Маневренность.
4. Меньшая склонность к заносу и опрокидыванию в экстремальных ситуациях.
5. Хорошая прокатка.
6. Экономия топлива.
7. Максимальный ресурс шин на износ и тд.

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

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

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

Развал-схождение

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

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

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

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

Разрезное колесо

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

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

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

Когда делать?

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

Как правильно?

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

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

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

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

Развал

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

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

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

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

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

Схождение

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

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

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

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

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

Коллапс-схождение — что это? Сделать развал-схождение

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

Определение

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

Крошащийся

Часто для регулировки подвески используют термин «столкновение-схождение». Что такое коллапс? Это угол между плоскостью, в которой вращается колесо, и вертикалью. Отрицательным считается такой развал, когда колеса верхнего борта наклонены внутрь. Положительный развал — это когда верхняя сторона колес наклонена наружу. Развал обеспечивает правильное положение колеса при работе подвески. С изменением наклона автомобиля меняется и развал. Если развал равен нулю, то шины изнашиваются минимально. Если отрицательный, то улучшается устойчивость автомобиля на поворотах. По размеру правый и левый развал должны быть максимально приближены друг к другу. В противном случае это может привести к уводу автомобиля с прямой траектории хода, а также к одностороннему износу рисунка протектора. Это только одна часть термина «коллапс-конвергенция».

Конвергенция

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

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

Кастер

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

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

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

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

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

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

Рулевое колесо на прямой неровно

Эта проблема может быть вызвана несколькими причинами:

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

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

Машину ведет в сторону, хотя развал

Что это может быть в таком случае?

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

2. Дисбаланс колес можно увеличить. Колеса скручены.

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

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

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

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

Тугой руль

Причин этой проблемы может быть несколько:

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

Какова процедура свертывания-схождения?

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

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

Автомобиль, у которого правильно отрегулированы углы установки колес, имеет:

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

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

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

Когда проверять развал-схождение

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

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

3. Если произошло увод машины в сторону или руль изменил свое положение при прямолинейном движении.

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

5. Шины очень быстро изнашиваются.

6. Автомобиль уводит в сторону при торможении.

7. Плохое самовращение при выходе из поворота.

8. После процесса обкатки нового автомобиля или в случае покупки подержанного автомобиля.

9. Если пробег после последней регулировки больше 15 тысяч километров.

10. После смены шин по сезонам.

Цена

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

Режимы отказа GAN: как их идентифицировать и контролировать

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

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

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

В этой статье:

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

Я тренировал GAN в течение последних нескольких лет и заметил, что обычные режимы отказа в GAN — Mode Collapse и Convergence Failure , о которых мы поговорим в этой статье.

Пропустите раздел обучения и перейдите к разделу режимов отказа ->

Обучение стабильной сети GAN

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

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

Я взял скорость обучения 0,0002 для оптимизатора Адама и 0,5 в качестве импульса для оптимизатора Адама.

Давайте посмотрим на код нашей стабильной сети GAN. Во-первых, давайте сделаем необходимый импорт.

 импортная горелка
импортировать torch.nn как nn
импортировать torchvision.transforms как преобразования
импортировать torch. optim как optim
импортировать torchvision.datasets как наборы данных
импортировать numpy как np
из torchvision.utils импортировать make_grid
из torch.utils.data импортировать DataLoader
из tqdm импортировать tqdm
импортировать neptune.new как neptune
из файла импорта neptune.new.types 

Обратите внимание, что в этом упражнении мы будем использовать PyTorch для обучения нашей модели и панель инструментов neptune.ai для отслеживания экспериментов. Вот ссылка на все мои эксперименты. Я запускал сценарии в colab, и Neptune упростил отслеживание всех экспериментов.

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

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

 запуск = neptune.init(
   проект="имя проекта",
   api_token="Ваш токен API",
) 

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

 размер_пакета = 1024
эпохи = 100
размер_образца = 64
скрытый_дим = 128
к = 1
устройство = torch.device('cuda', если torch.cuda.is_available() иначе 'процессор')
преобразование = преобразование.Составить([
                               преобразовывает.ToTensor(),
                               преобразовывает. Нормализовать ((0,5,), (0,5,)),
           ])
 

Теперь мы загружаем данные MNIST и создаем объект Dataloader.

 train_data = наборы данных.MNIST(
   корень='../ввод/данные',
   поезд = правда,
   скачать = Верно,
   трансформировать = трансформировать
)
train_loader = DataLoader (train_data, batch_size=batch_size, shuffle=True) 

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

 параметров = {"learning_rate": 0,0002,
         "оптимизатор": "Адам",
         "оптимизатор_бетас": (0,5, 0,999),
         "латентный_дим": латентный_дим}
run["parameters"] = params 

Здесь мы определяем сети генератора и дискриминатора.

Генераторная сеть

• Генераторная модель использует в качестве входных данных скрытое пространство, которое является случайным шумом.
• В первом слое мы меняем скрытое пространство (размерность 128) на функциональное пространство из 128 каналов и каждого канала высотой и шириной 7×7.
• Следуя двум слоям деконволюции, увеличьте высоту и ширину нашего пространства признаков.
• Затем следует слой свертки с активацией tanh для создания изображения с одним каналом и высотой и шириной 28×28.

 Генератор класса (nn.Module):
   def __init__(я, скрытое_пространство):
       супер(Генератор, сам).__init__()
       self.latent_space = скрытое_пространство
       self.fcn = nn.Sequential(
           nn. Linear(in_features=self.latent_space, out_features=128*7*7),
           nn.LeakyReLU(0.2),
       )
       self.deconv = nn.Sequential(
           nn.ConvTranspose2d (in_channels = 128, out_channels = 128, kernel_size = (4, 4), stride = (2, 2), padding = (1, 1)),
           nn.LeakyReLU(0.2),
           nn.ConvTranspose2d (in_channels = 128, out_channels = 128, kernel_size = (4, 4), stride = (2, 2), padding = (1, 1)),
           nn.LeakyReLU(0.2),
           nn.Conv2d (in_channels = 128, out_channels = 1, kernel_size = (3, 3), padding = (1, 1)),
           nn.Tanh()
       )
   защита вперед (я, х):
       х = self.fcn(x)
       х = х.вид (-1, 128, 7, 7)
       х = саморазвитие (х)
       возврат х 

См. также

➡️ 6 архитектур GAN, которые вы действительно должны знать

Сеть дискриминатора

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

 Дискриминатор класса (nn.Module):
   защита __init__(сам):
       супер(Дискриминатор, я).__init__()
       self.conv = nn.Sequential(
           nn.Conv2d (in_channels = 1, out_channels = 64, kernel_size = (4, 4), шаг = (2, 2), заполнение = (1, 1)),
           nn.LeakyReLU(0.2),
           nn.Conv2d (in_channels = 64, out_channels = 64, kernel_size = (4, 4), шаг = (2, 2), заполнение = (1, 1)),
           nn.LeakyReLU(0.2)
       )
       self.classifier = nn.Sequential(
           nn.Linear(in_features=3136, out_features=1),
           nn.Сигмоид()
       )
   защита вперед (я, х):
       х = самоутверждение (х)
       х = х.вид (х.размер (0), -1)
       х = самоклассификатор (х)
       возврат х 

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

И у нас есть несколько вспомогательных функций для создания меток для поддельных и реальных изображений (где size — это размер пакета) и функция create_noise для ввода генератора.

 генератор = Генератор (latent_dim).to (устройство)
дискриминатор = дискриминатор().к(устройство)
optim_g = optim.Adam (параметры генератора (), lr = 0,0002, бета = (0,5, 0,999))
optim_d = optim.Adam (дискриминатор. параметры (), lr = 0,0002, бета = (0,5, 0,999))
критерий = nn.BCELoss()
def label_real (размер):
   labels = torch.ones(размер, 1)
   вернуть labels.to(устройство)
определение label_fake (размер):
   labels = torch.zeros(размер, 1)
   вернуть labels.to(устройство)
def create_noise (sample_size, hidden_dim):
   return torch.randn(sample_size, hidden_dim).to(device) 

Функция обучения генератора

Теперь мы обучим генератор:

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

 def train_generator (оптимизатор, data_fake):
   b_size = data_fake.size (0)
   реальная_метка = реальная_метка(b_size)
   оптимизатор.zero_grad()
   вывод = дискриминатор (data_fake)
   потеря = критерий (выход, реальная_метка)
   потеря.назад()
   оптимизатор.шаг()
   обратная потеря 

Функция обучения дискриминатора

Мы создаем функцию train_discriminator:

• Эта сеть, как мы знаем, получает входные данные от наземной истины (т.е. реальных изображений) и генераторной сети (т.е. поддельных изображений) во время обучения.
• Одно за другим мы передаем поддельное и реальное изображение, вычисляем потери и обратное распространение. Мы будем наблюдать две потери дискриминатора; потери на реальных изображениях (loss_real) и потери на поддельных изображениях (loss_fake).

 def train_distributor (оптимизатор, data_real, data_fake):
   b_size = data_real.size (0)
   реальная_метка = реальная_метка(b_size)
   поддельная_метка = метка_поддельная (b_size)
   оптимизатор. zero_grad()
   output_real = дискриминатор (data_real)
   loss_real = критерий (output_real, real_label)
   output_fake = дискриминатор (data_fake)
   loss_fake = критерий (output_fake, fake_label)
   loss_real.backward()
   loss_fake.backward()
   оптимизатор.шаг()
   возврат loss_real, loss_fake 

Обучение модели GAN

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

• Шум в первой строке будет использоваться для вывода промежуточных изображений после каждой эпохи. Мы сохраняем шум одинаковым, чтобы мы могли сравнивать изображения в разные эпохи.
• Теперь для каждой эпохи мы обучаем дискриминатор k раз (один раз в данном случае, поскольку k=1), за каждый раз обучается генератор.
• Все потери регистрируются и отправляются на панель управления Neptune для построения графика. Нам не нужно добавлять их в список, используя панель инструментов Neptune, мы можем строить графики потерь на лету. Он также будет записывать потери на каждом этапе в файле .csv.
• Я сохранил сгенерированные изображения после каждой эпохи в метаданных Neptune, используя функцию [dot]upload.

 шум = создать_шум (размер выборки, скрытый_тусклый)
генератор.поезд()
дискриминатор.train()
для эпохи в диапазоне (эпохи):
   потеря_г = 0,0
   loss_d_real = 0,0
   loss_d_fake = 0,0
   # подготовка
   для bi данные в tqdm(enumerate(train_loader), total=int(len(train_data)/train_loader.batch_size)):
       изображение, _ = данные
       изображение = изображение.на(устройство)
       b_size = длина (изображение)
       для шага в диапазоне (k):
           data_fake = генератор (создать_шум (b_size, скрытый_дим)). отсоединить ()
           data_real = изображение
           loss_d_fake_real = train_distributor (optim_d, data_real, data_fake)
           loss_d_real += loss_d_fake_real[0]
           loss_d_fake += loss_d_fake_real[1]
       data_fake = генератор (создать_шум (b_size, скрытый_дим))
       loss_g += train_generator(optim_g, data_fake)
   # вывод и наблюдения
   сгенерированный_img = генератор (шум).  процессор (). отсоединить ()
   сгенерированный_img = make_grid (сгенерированный_img)
   сгенерированный_img = np.moveaxis (сгенерированный_img.numpy (), 0, -1)
   run[f'generated_img/{эпоха}'].upload(File.as_image(generated_img))
   epoch_loss_g = loss_g / би
   epoch_loss_d_real = loss_d_real/bi
   epoch_loss_d_fake = loss_d_fake/bi
   run["train/loss_generator"].log(epoch_loss_g)
   run["поезд/убыток_дискриминатор_реальный"].log(epoch_loss_d_real)
   run["поезд/потеря_дискриминатора_фальшивка"].log(epoch_loss_d_fake)
   print(f"Эпоха {эпоха} из {эпох}")
   print(f"Потеря генератора: {epoch_loss_g:.8f}, Ложная потеря дискриминатора: {epoch_loss_d_fake:.8f}, Реальная потеря дискриминатора: {epoch_loss_d_real:.8f}") 

Посмотрим на промежуточные изображения.

Эпоха 10

Это 64 цифры, сгенерированные в эпоху 10.

Эпоха 100

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

Графики убытков

Вы можете легко перейти в «Добавить новую панель мониторинга» на панели мониторинга Neptune и объединить различные графики потерь в один.

На рис. 3 вы можете наблюдать стабилизацию потерь после эпохи 40. Потери дискриминатора для реального и поддельного изображений остаются около 0,6, тогда как для генератора они составляют около 0,8. Приведенный выше график является ожидаемым графиком для стабильной тренировки. Мы можем рассматривать это как базовый уровень и экспериментировать с изменением k (шаги обучения для дискриминатора), увеличением количества эпох и т. д.

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

Связанные

➡️ Понимание функций потери GAN

Режимы отказа GAN

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

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

Как определить режимы отказа GAN? Как мы узнаем, есть ли режим отказа:

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

Что вызывает сбой режима в GAN? Причины режимов отказа:

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

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

Оценка режимов отказа

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

Глядя на промежуточные изображения

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

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

Давайте рассмотрим несколько лучших методов.

По графикам потерь

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

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

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

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

Количество статистически различных интервалов (показатель NDB)

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

Давайте разберемся, как работает оценка NDB:

• У нас есть два набора, обучающий набор (на котором обучается модель) и тестовый набор (поддельные изображения, сгенерированные генератором на случайном шуме после обучения).
• Теперь разделите обучающую выборку на K кластеров, используя кластеризацию K-средних. Это будут наши K разных бункеров.
• Теперь распределите тестовые данные по этим K интервалам на основе евклидова расстояния между точками тестовых данных и центроидами K кластеров.
• Теперь проведите тест с двумя выборками между обучающей и тестовой выборками для каждого бина и рассчитайте Z-показатель. Если Z-оценка меньше порогового значения (в статье используется 0,05), пометьте ячейку как статистически отличающуюся.
• Подсчитайте количество статистически различных бинов и разделите их на K.  
• Полученное значение будет находиться в диапазоне от 0 до 1.

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

Метод оценки NDB взят из статьи О GAN и GMM.

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

Решение режимов отказа

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

Функции затрат

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

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

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

Скрытое пространство

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

На рис. 9 вы видите столько одинаковых восьмерок и семерок? Отсюда и коллапс режима.

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

Скорость обучения

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

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

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

Оптимизатор

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

В Adam Optimizer бета — это гиперпараметры, используемые для вычисления скользящего среднего значения градиента и его квадрата. Мы изначально (в стабильном обучении) использовали значение 0,5 для бета1. Меняем на 0.9(значение по умолчанию) увеличивает агрессивность оптимизатора.

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

Сопоставление признаков

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

Для реального изображения и фальшивого изображения векторы признаков (f(x) на рис. 15) вычисляются на промежуточном слое в мини-пакетах, и измеряется расстояние L2 по средним значениям этих векторов признаков.

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

Историческое усреднение

Мы сохраняем скользящее среднее значение параметров (θ) предыдущего t моделей. Теперь мы штрафуем модель, добавляя стоимость L2 к функции стоимости, используя предыдущие параметры.

Здесь θ[i] — значение параметра на i ^-м -м прогоне.

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

Заключение

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

Читать далее

• https://arxiv.org/pdf/1606.03498v1.pdf
• https://towardsdatascience.com/10-lessons-i-learned-training-generative-adversarial-networks-gans-for-a-year-c

  59628

• https://towardsdatascience.com/gan- way-to-improve-gan-performance-acf37f9f59b
• https://arxiv. org/pdf/1805.12462.pdf

ЧИТАТЬ СЛЕДУЮЩИЙ

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

10 минут чтения | Автор Самадрита Гош | Обновлено 16 июля 2021 г.

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

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

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

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

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

Здесь в игру вступают выбор и оценка модели!

В этой статье мы поговорим о:

• Что такое выбор модели и оценка модели?
• Эффективные методы выбора модели (повторная выборка и вероятностные подходы)
• Популярные методы оценки модели
• Важные недостатки модели машинного обучения

Читать далее ->

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

Автор Джейсон Браунли, , 8 июля 2019 г. , , Генеративно-состязательные сети,

Последнее обновление: 21 января 2021 г.

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

GAN сложно обучать.

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

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

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

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

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

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

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

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

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

Начнем.

• Обновлено в августе 2020 г. : исправлена ​​метка на линейном графике.
• Обновлено, январь 2021 г. : обновлено, чтобы замораживание слоев работало с пакетной нормой.
• Обновлено в январе 2021 г. : Упрощенная архитектура модели, чтобы гарантировать, что мы видим сбои.

Практическое руководство по режимам отказа генеративно-состязательной сети
Фото Джейсона Хивнера, некоторые права защищены.

Обзор учебника

Это руководство разделено на три части; они:

1. Как определить стабильную генеративно-состязательную сеть
2. Как определить сбой режима в генеративно-состязательной сети
3. Как определить сбой конвергенции в генеративно-состязательной сети

Как обучить стабильную генеративно-состязательную сеть

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

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

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

Первым шагом является определение моделей.

Модель дискриминатора принимает в качестве входных данных одно изображение в градациях серого 28×28 и выводит двоичный прогноз того, является ли изображение реальным ( класс=1 ) или подделка ( класс=0 ). Он реализован как скромная сверточная нейронная сеть с использованием лучших практик проектирования GAN, таких как использование функции активации LeakyReLU с наклоном 0,2, шагом 2 × 2 для понижения дискретизации и адамовой версией стохастического градиентного спуска со скоростью обучения 0,0002. и импульс 0,5

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

# определить автономную модель дискриминатора def определить_дискриминатор (in_shape = (28,28,1)): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # понизить разрешение до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU (альфа = 0,2)) # понизить разрешение до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # классификатор model.add(Свести()) model.add (плотный (1, активация = ‘сигмоид’)) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция, метрики = [‘точность’]) вернуть модель

Модель генератора принимает в качестве входных данных точку в скрытом пространстве и выводит одно изображение в градациях серого 28×28. Это достигается за счет использования полносвязного слоя для интерпретации точки в скрытом пространстве и обеспечения достаточного количества активаций, которые могут быть преобразованы во множество копий (в данном случае 128) версии выходного изображения с низким разрешением (например, 7×7). ). Затем это дважды подвергается повышающей дискретизации, удваивая размер и увеличивая в четыре раза площадь активаций каждый раз с использованием транспонированных сверточных слоев. В модели используются передовые методы, такие как активация LeakyReLU, размер ядра, зависящий от размера шага, и функция активации гиперболического тангенса (tanh) в выходном слое.

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

# определить автономную модель генератора def определить_генератор (скрытый_дим): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # основа для изображения 7×7 n_узлов = 128 * 7 * 7 model. add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add (LeakyReLU (альфа = 0,2)) model.add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # вывод 28x28x1 model.add (Conv2D (1, (7,7), активация = ‘tanh’, заполнение = ‘то же’, kernel_initializer = init)) вернуть модель

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

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

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

# определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (генератор, дискриминатор): # делаем веса в дискриминаторе не обучаемыми дискриминатор. trainable = Ложь # соедините их модель = Последовательный() # добавить генератор model.add(генератор) # добавляем дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция) вернуть модель

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

Первым шагом является загрузка и масштабирование набора данных MNIST. Весь набор данных загружается через вызов функции load_data() Keras, затем выбирается подмножество изображений (около 5000), принадлежащих к классу 8, например. представляют собой рукописное изображение числа восемь. Затем значения пикселей должны быть масштабированы в диапазоне [-1,1], чтобы соответствовать выходным данным модели генератора.

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

# загрузить изображения mnist защита load_real_samples(): # загрузить набор данных (поездX, обучение), (_, _) = load_data() # расширить до 3D, например. добавить каналы X = expand_dims (trainX, ось = -1) # выбрать все примеры для данного класса selected_ix = обучаемый == 8 Х = Х[выбрано_ix] # преобразовать из целых чисел в числа с плавающей запятой X = X. astype(‘float32’) # шкала от [0,255] до [-1,1] Х = (Х — 127,5) / 127,5 возврат X

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

9Функция 0396 generate_real_samples() ниже реализует это, принимая подготовленный набор данных в качестве аргумента, выбирая и возвращая случайную выборку изображений лиц и соответствующую им метку класса для дискриминатора, в частности class=1, указывающую, что они являются реальными изображениями.

# выбрать реальные образцы def generate_real_samples (набор данных, n_samples): # выбираем случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выберите изображения X = набор данных[ix] # генерируем метки классов y = единицы ((n_samples, 1)) вернуть Х, у

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

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

# генерировать точки в скрытом пространстве в качестве входных данных для генератора def generate_latent_points (latent_dim, n_samples): # генерируем точки в скрытом пространстве x_input = randn (latent_dim * n_samples) # преобразовать в пакет входных данных для сети x_input = x_input.reshape (n_samples, скрытый_дим) вернуть x_input

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

Функция generate_fake_samples() ниже реализует это, принимая модель генератора и размер скрытого пространства в качестве аргументов, затем генерируя точки в скрытом пространстве и используя их в качестве входных данных для модели генератора. Функция возвращает сгенерированные изображения и соответствующую им метку класса для модели дискриминатора, в частности class=0, чтобы указать, что они поддельные или сгенерированные.

# использовать генератор для создания n поддельных примеров с метками классов def generate_fake_samples (генератор, латентный_дим, n_samples): # генерируем точки в скрытом пространстве x_input = generate_latent_points (latent_dim, n_samples) # прогнозировать выходные данные X = генератор.прогноз(x_input) # создаем метки классов у = нули ((n_samples, 1)) возврат Х, у

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

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

# сгенерировать образцы и сохранить как график и сохранить модель defsummary_performance(шаг,g_model,latent_dim,n_samples=100): # подготовить поддельные примеры X, _ = generate_fake_samples (g_model, hidden_dim, n_samples) # шкала от [-1,1] до [0,1] Х = (Х + 1) / 2,0 # сюжетные изображения для я в диапазоне (10 * 10): # определить подсюжет pyplot. subplot(10, 10, 1 + я) # отключить ось pyplot.axis(‘выкл’) # отображать необработанные пиксельные данные pyplot.imshow(X[i,:,:, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_baseline/generated_plot_%03d.png’% (шаг+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_baseline/model_%03d.h5’ % (шаг+1))

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

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

Функция plot_history() ниже реализует это и сохраняет результаты в файл.

# создаем линейный график потерь для гана и сохраняем в файл def plot_history (d1_hist, d2_hist, g_hist, a1_hist, a2_hist): # сюжетная потеря pyplot.subplot(2, 1, 1) pyplot.plot(d1_hist, label=’d-real’) pyplot.plot(d2_hist, label=’d-fake’) pyplot.plot (g_hist, метка = ‘ген’) pyplot.легенда() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot (a2_hist, метка = ‘acc-fake’) pyplot.легенда() # сохранить график в файл pyplot.savefig(‘results_baseline/plot_line_plot_loss.png’) pyplot.close()

Теперь мы готовы установить модель GAN.

Модель подходит для 10 обучающих эпох, что является произвольным, поскольку модель начинает генерировать правдоподобное число-8 цифр, возможно, после первых нескольких эпох. Используется размер пакета из 128 образцов, и каждая эпоха обучения включает 5851/128 или около 45 пакетов реальных и поддельных образцов и обновлений модели. Таким образом, модель обучается в течение 10 эпох по 45 пакетов или 450 итераций.

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

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

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

# обучаем генератор и дискриминатор def train (g_model, d_model, gan_model, набор данных, hidden_dim, n_epochs = 10, n_batch = 128): # вычисляем количество батчей за эпоху bat_per_epo = int(dataset.shape[0]/n_batch) # рассчитать общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество образцов в половине партии half_batch = int (n_batch / 2) # готовим списки для хранения статистики каждую итерацию d1_hist, d2_hist, g_hist, a1_hist, a2_hist = список(), список(), список(), список(), список() # вручную перечисляем эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» сэмплы X_real, y_real = generate_real_samples (набор данных, полупакет) # обновить вес модели дискриминатора d_loss1, d_acc1 = d_model. train_on_batch(X_real, y_real) # генерировать «поддельные» примеры X_fake, y_fake = generate_fake_samples (g_model, hidden_dim, half_batch) # обновить вес модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points (latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = единицы ((n_batch, 1)) # обновить генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммируем потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # запись истории d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) a1_hist.append(d_acc1) a2_hist.append(d_acc2) # оцениваем производительность модели каждую «эпоху» если (i+1) % bat_per_epo == 0: суммарная_производительность (я, g_model, латентный_дим) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist)

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

# создаем папку для результатов makedirs(‘results_baseline’, exists_ok=Истина) # размер скрытого пространства скрытый_дим = 50 # создаем дискриминатор дискриминатор = определить_дискриминатор() # создаем генератор генератор = определить_генератор (латентный_тусклый) # создаем ган gan_model = define_gan (генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() печать (набор данных. форма) # модель поезда поезд (генератор, дискриминатор, модель_гана, набор данных, латентный_дим)

Связывая все это вместе, полный пример приведен ниже.

# пример обучения стабильного гана для генерации рукописной цифры из ОС импортировать makedirs из numpy импорта expand_dims из нулей импорта numpy из пустых импортных из numpy. random импортировать randn из numpy.random импортировать randint из keras.datasets.mnist импортировать load_data из keras.optimizers импорт Адама из keras.models импорт последовательный из keras.layers импорт плотный из keras.layers импортировать изменение формы из keras.layers импортировать Flatten из keras.layers импортировать Conv2D из keras.layers импортировать Conv2DTranspose из keras.layers импортировать LeakyReLU из keras.initializers импортировать RandomNormal из matplotlib импортировать pyplot # определить автономную модель дискриминатора def определить_дискриминатор (in_shape = (28,28,1)): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # понизить разрешение до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU (альфа = 0,2)) # понизить разрешение до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model. add (LeakyReLU (альфа = 0,2)) # классификатор model.add(Свести()) model.add (плотный (1, активация = ‘сигмоид’)) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция, метрики = [‘точность’]) модель возврата # определить автономную модель генератора def определить_генератор (скрытый_дим): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # основа для изображения 7×7 n_узлов = 128 * 7 * 7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add (LeakyReLU (альфа = 0,2)) model.add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model. add (LeakyReLU (альфа = 0,2)) # вывод 28x28x1 model.add (Conv2D (1, (7,7), активация = ‘tanh’, заполнение = ‘то же’, kernel_initializer = init)) модель возврата # определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (генератор, дискриминатор): # делаем веса в дискриминаторе не обучаемыми дискриминатор.trainable = Ложь # соедините их модель = Последовательный() # добавляем генератор model.add(генератор) # добавляем дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция) модель возврата # загрузить изображения mnist защита load_real_samples(): # загрузить набор данных (поездX, обучение), (_, _) = load_data() # расширить до 3D, например. добавить каналы X = expand_dims (trainX, ось = -1) # выбрать все примеры для данного класса selected_ix = обучаемый == 8 Х = Х[выбрано_ix] # преобразовать из целых чисел в числа с плавающей запятой X = X. astype(‘float32’) # шкала от [0,255] до [-1,1] Х = (Х — 127,5) / 127,5 вернуть Х # выбрать реальные образцы def generate_real_samples (набор данных, n_samples): # выбираем случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выберите изображения X = набор данных[ix] # генерируем метки классов y = единицы ((n_samples, 1)) вернуть х, у # генерировать точки в скрытом пространстве в качестве входных данных для генератора def generate_latent_points (latent_dim, n_samples): # генерируем точки в скрытом пространстве x_input = randn (latent_dim * n_samples) # преобразовать в пакет входных данных для сети x_input = x_input.reshape (n_samples, скрытый_дим) вернуть x_input # использовать генератор для создания n поддельных примеров с метками классов def generate_fake_samples (генератор, латентный_дим, n_samples): # генерируем точки в скрытом пространстве x_input = generate_latent_points (latent_dim, n_samples) # прогнозировать выходные данные X = генератор. прогноз(x_input) # создаем метки классов у = нули ((n_samples, 1)) вернуть х, у # сгенерировать образцы и сохранить как график и сохранить модель defsummary_performance(шаг,g_model,latent_dim,n_samples=100): # подготовить поддельные примеры X, _ = generate_fake_samples (g_model, hidden_dim, n_samples) # шкала от [-1,1] до [0,1] Х = (Х + 1) / 2,0 # сюжетные изображения для я в диапазоне (10 * 10): # определить подсюжет pyplot.subplot(10, 10, 1 + я) # отключить ось pyplot.axis(‘выкл’) # отображать необработанные пиксельные данные pyplot.imshow(X[i,:,:, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_baseline/generated_plot_%03d.png’% (шаг+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_baseline/model_%03d.h5′ % (шаг+1)) # создаем линейный график потерь для гана и сохраняем в файл def plot_history (d1_hist, d2_hist, g_hist, a1_hist, a2_hist): # сюжетная потеря pyplot.subplot(2, 1, 1) pyplot.plot(d1_hist, label=’d-real’) pyplot. plot(d2_hist, label=’d-fake’) pyplot.plot (g_hist, метка = ‘ген’) pyplot.легенда() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot (a2_hist, метка = ‘acc-fake’) pyplot.легенда() # сохранить график в файл pyplot.savefig(‘results_baseline/plot_line_plot_loss.png’) pyplot.close() # обучаем генератор и дискриминатор def train (g_model, d_model, gan_model, набор данных, hidden_dim, n_epochs = 10, n_batch = 128): # вычисляем количество батчей за эпоху bat_per_epo = int(dataset.shape[0]/n_batch) # рассчитать общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество образцов в половине партии half_batch = int (n_batch / 2) # готовим списки для хранения статистики каждую итерацию d1_hist, d2_hist, g_hist, a1_hist, a2_hist = список(), список(), список(), список(), список() # вручную перечисляем эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» сэмплы X_real, y_real = generate_real_samples (набор данных, полупакет) # обновить вес модели дискриминатора d_loss1, d_acc1 = d_model. train_on_batch(X_real, y_real) # генерировать «поддельные» примеры X_fake, y_fake = generate_fake_samples (g_model, hidden_dim, half_batch) # обновить вес модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points (latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = единицы ((n_batch, 1)) # обновить генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммируем потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # запись истории d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) a1_hist.append(d_acc1) a2_hist.append(d_acc2) # оцениваем производительность модели каждую «эпоху» если (i+1) % bat_per_epo == 0: суммарная_производительность (я, g_model, латентный_дим) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist) # создаем папку для результатов makedirs(‘results_baseline’, exists_ok=Истина) # размер скрытого пространства скрытый_дим = 50 # создаем дискриминатор дискриминатор = определить_дискриминатор() # создаем генератор генератор = определить_генератор (латентный_тусклый) # создаем ган gan_model = define_gan (генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() печать (набор данных. форма) # модель поезда поезд (генератор, дискриминатор, модель_гана, набор данных, латентный_дим)

1 2 3 4 5 6 7 8 10 110003 12 13 14 1999 0001 9000 2 14 9000 3 9000 3 9000 3 9000 2 9000 2 14 9000 3 9000 3 9000 2 9000 3 9000 3 9000 3 18 19 20 21 22 23 24 25 26 27 28 29 30 28 29 30 0002 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 13 121 122 13 0002 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 151 152 9000 3 0003 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 7000 183 9000 181 1821 183 183 9000 9000 . 0003 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

# пример обучения стабильного гана для генерации рукописной цифры от OS Import MakedIrs из Numpy Import Expand_dims от Numpy Import Zeros от Numpy Import One от Numpy.random Importnd Randn из Numpy.random Importint из Keras.datasets.m.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manit. из keras.optimizers import Adam из keras.models import Sequential из keras.layers import Dense из keras.layers import Reshape из keras.layers import Flatten from keras. layers import Conv2D from keras.layers import Conv2DTranspose from keras.layers import LeakyReLU from keras.initializers import RandomNormal from matplotlib import pyplot   # define the standalone discriminator model def Define_Distributor(in_shape=(28,28,1)): # инициализация веса init = RandomNormal(stddev=0.02) # определение модели model = Sequential() # уменьшение разрешения до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU(alpha=0.2)) # понижение разрешения до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # классификатор model.add(Flatten()) model.add(Dense(1, активация=’sigmoid’)) # скомпилировать модель opt = Adam(lr=0.0002, beta_1=0. 5) model.compile(loss=’binary_crossentropy’, optimizer=opt, metrics=[‘accuracy’]) return model   # определение автономной Модель генератора DEF DEFINE_GENERATOR (LATENT_DIM): # Инициализация веса init = случайный (stddev = 0,02) # Define Model Модель = 1288 * 10003 # Фонд для 7×7 Изображение n_nodes = 1288 * 7*7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(Reshape((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2) )) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # вывод 28x28x1 model.add(Conv2D(1, (7,7), активация=’tanh’, padding=’same’, kernel_initializer=init)) return model   # определить комбинированную модель генератора и дискриминатора для обновления генератора # соедините их model = Sequential() # добавить генератор model. add(generator) # добавить дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Adam(lr=0.0002, beta 0.5) model.compile(loss=’binary_crossentropy’, optimizer=opt) модель возврата   # загрузить изображения mnist def load_real_samples(): # загрузить набор данных (train ) # загрузить набор данных # загрузить набор данных (_, _) = load_data() # расширить до 3d, например. добавить каналы X = expand_dims(trainX, axis=-1) # выбрать все примеры для данного класса float X = X.astype(‘float32’) # масштаб от [0,255] до [-1,1] X = (X — 127,5) / 127,5 return X # select real образцы def generate_real_samples (набор данных, n_samples): # выбрать случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выбрать изображения X = набор данных[ix] # создать метки классов y = one((n_samples) , 1)) return X, y   # генерировать точки в скрытом пространстве в качестве входных данных для генератора скрытый_дим * n_samples) # преобразование в пакет входных данных для сети x_input = x_input. reshape(n_samples,latent_dim) return x_input   # использование генератора для создания n поддельных примеров с метками классов 3 генератор, скрытое_дим, n_samples): # генерировать точки в скрытом пространстве x_input = generate_latent_points(latent_dim, n_samples) # прогнозировать выходные данные X = генератор.предсказать(x_input) # создать метки классов y = zeros((n_samples, 1)) return X, y   # создать образцы и сохранить их как график и сохранить модель , n_samples=100) 1) / 2.0 # изображения графика для i в диапазоне (10 * 10): # определить подзаголовок pyplot.subplot(10, 10, 1 + i) # выключить ось pyplot.axis(‘off’) # построить необработанные пиксельные данные pyXplot.imshow(pyXplot.imshow(pyXplot.imshow) i, :, :, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_baseline/generated_plot_%03d. png’ % (шаг+1)) pyplot.close( ) # сохранить модель генератора g_model.save(‘results_baseline/model_%03d.h5’ % (шаг+1))   # создать линейный график потерь для гана и сохранить его в файл pyplot.plot(d1_hist, label=’d-real’) pyplot.plot(d2_hist, label=’d-fake’) pyplot.plot(g_hist, label=’gen’) pyplot.legend( ) # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot(a2_hist, label=’acc-fake’) pyplot.legend() # сохранить график в файл pyplot.savefig(‘results_baseline/plot_line_plot_loss.png’) )   # обучение генератора и дискриминатора def train(g_model, d_model, gan_model, dataset, hidden_dim, n_epochs=10, n_batch=128): # вычисление количества пакетов в эпоху _batch=900 (dataset.shape[0] / n_batch) # вычислить общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество выборок в половине партии d1_hist, d2_hist, g_hist, a1_hist, a2_hist = list(), list(), list(), list(), list() # вручную перечислить эпохи for i in range(n_steps): # получить случайно выбранные «настоящие» образцы x_real, y_real = generate_real_samples (набор данных, Half_batch) # Обновление модели дискриминатора D_LOSS1, D_ACC1 = D_MODEL. TRAIN_ON_BATCH (X_REAL, Y_REAL) # GENERATE ‘FAKE_BATCH (X_REAL, Y_REAL) # GENERATE’ FAKE_BATCH. ,latent_dim,half_batch) # обновить веса модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points(latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = one((n_batch, 1)) # обновляем генератор через ошибку дискриминатора g_loss( X_gan, y_gan) # суммировать потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # история записи D1_HIST.Append (D_LOSS1) D2_HIST.Append (D_LOSS2) G_HIST.Append (G_LOSS) A1_HIST.APPEND (D_ACC1) A2_HIST.Append (D_ACC2) # ENSEALCHIUTE. ‘ if (i+1) % bat_per_epo == 0: summarize_performance(i, g_model, latent_dim) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist)   # make folder for results makedirs(‘results_baseline’, exists_ok=True) # Размер скрытого пространства Latent_DIM = 50 # Создать Discinator Discinator = Define_Discriminator () # Создать генератор Генератор = Define_generator (Latent_DIM) # Create Gan ganeran. dataset = load_real_samples() print(dataset.shape) # модель поезда0003

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

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

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

Это важно. Стабильная GAN будет иметь потери на дискриминаторе около 0,5, обычно от 0,5 до 0,7 или 0,8. Потери генератора обычно выше и могут колебаться в пределах 1,0, 1,5, 2,0 или даже выше.

Точность дискриминатора как для реальных, так и для сгенерированных (фальшивых) изображений не будет составлять 50 %, но обычно должна колебаться в пределах от 70 % до 80 %.

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

>1, d1=0,859, d2=0,664 г=0,872, а1=37, а2=59 >2, d1=0,190, d2=1,429 г=0,555, а1=100, а2=10 >3, d1=0,094, d2=1,467 г=0,597, а1=100, а2=4 >4, d1=0,097, d2=1,315 г=0,686, а1=100, а2=9 >5, d1=0,100, d2=1,241 г=0,714, а1=100, а2=9 … >446, d1=0,593, d2=0,546 г=1,330, а1=76, а2=82 >447, d1=0,551, d2=0,739 г=0,981, а1=82, а2=39 >448, d1=0,628, d2=0,505 г=1,420, а1=79, а2=89 >449, d1=0,641, d2=0,533 г=1,381, а1=60, а2=85 >450, d1=0,550, d2=0,731 g=1,100, a1=76, a2=42

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

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

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

Это пример нормальной или ожидаемой потери во время обучения. А именно, потери дискриминатора для реальных и поддельных образцов примерно одинаковы и составляют около 0,5, а потери для генератора немного выше между 0,5 и 2,0. Если модель генератора способна генерировать правдоподобные изображения, то ожидается, что эти изображения были бы созданы между эпохами 100 и 300, а также, вероятно, между эпохами 300 и 450.

Нижний подграфик показывает линейный график точности дискриминатора на реальных (синих) и поддельных (оранжевых) изображениях во время обучения. Мы видим аналогичную структуру в качестве подграфика потерь, а именно то, что точность начинается совершенно по-разному между двумя типами изображений, затем стабилизируется между эпохами 100 и 300 на уровне от 70% до 80% и остается стабильной после этого, хотя и с повышенной дисперсией.

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

Линейные графики потерь и точности для стабильной генеративно-состязательной сети

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

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

Образец из 100 сгенерированных изображений рукописного числа 8 в эпоху 45 из стабильной GAN.

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

Образец из 100 сгенерированных изображений рукописного номера 8 в эпоху 180 из стабильной GAN.

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

Образец из 100 сгенерированных изображений рукописного номера 8 в эпоху 450 из стабильной GAN.

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

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

Мы можем обобщить эти наблюдения для стабильной тренировки GAN следующим образом:

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

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

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

Как определить сбой режима в генеративно-состязательной сети

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

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

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

— Учебное пособие по NIPS 2016: Генеративно-состязательные сети, 2016.

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

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

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

В частности, переменная ‘ lant_dim ’ может быть изменена со 100 на 1, и эксперимент будет повторен.

# размер скрытого пространства скрытый_дим = 1

Полный список кодов приведен ниже для полноты картины.

# пример обучения нестабильного гана для генерации рукописной цифры из ОС импортировать makedirs из numpy импорта expand_dims из нулей импорта numpy из пустых импортных из numpy. random импортировать randn из numpy.random импортировать randint из keras.datasets.mnist импортировать load_data из keras.optimizers импорт Адама из keras.models импорт последовательный из keras.layers импорт плотный из keras.layers импортировать изменение формы из keras.layers импортировать Flatten из keras.layers импортировать Conv2D из keras.layers импортировать Conv2DTranspose из keras.layers импортировать LeakyReLU из keras.initializers импортировать RandomNormal из matplotlib импортировать pyplot # определить автономную модель дискриминатора def определить_дискриминатор (in_shape = (28,28,1)): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # понизить разрешение до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU (альфа = 0,2)) # понизить разрешение до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model. add (LeakyReLU (альфа = 0,2)) # классификатор model.add(Свести()) model.add (плотный (1, активация = ‘сигмоид’)) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция, метрики = [‘точность’]) модель возврата # определить автономную модель генератора def определить_генератор (скрытый_дим): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # основа для изображения 7×7 n_узлов = 128 * 7 * 7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add (LeakyReLU (альфа = 0,2)) model.add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model. add (LeakyReLU (альфа = 0,2)) # вывод 28x28x1 model.add (Conv2D (1, (7,7), активация = ‘tanh’, заполнение = ‘то же’, kernel_initializer = init)) модель возврата # определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (генератор, дискриминатор): # делаем веса в дискриминаторе не обучаемыми дискриминатор.trainable = Ложь # соедините их модель = Последовательный() # добавляем генератор model.add(генератор) # добавляем дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция) модель возврата # загрузить изображения mnist защита load_real_samples(): # загрузить набор данных (поездX, обучение), (_, _) = load_data() # расширить до 3D, например. добавить каналы X = expand_dims (trainX, ось = -1) # выбрать все примеры для данного класса selected_ix = обучаемый == 8 Х = Х[выбрано_ix] # преобразовать из целых чисел в числа с плавающей запятой X = X. astype(‘float32’) # шкала от [0,255] до [-1,1] Х = (Х — 127,5) / 127,5 вернуть Х # # выбрать реальные образцы def generate_real_samples (набор данных, n_samples): # выбираем случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выберите изображения X = набор данных[ix] # генерируем метки классов y = единицы ((n_samples, 1)) вернуть х, у # генерировать точки в скрытом пространстве в качестве входных данных для генератора def generate_latent_points (latent_dim, n_samples): # генерируем точки в скрытом пространстве x_input = randn (latent_dim * n_samples) # преобразовать в пакет входных данных для сети x_input = x_input.reshape (n_samples, скрытый_дим) вернуть x_input # использовать генератор для создания n поддельных примеров с метками классов def generate_fake_samples (генератор, латентный_дим, n_samples): # генерируем точки в скрытом пространстве x_input = generate_latent_points (latent_dim, n_samples) # прогнозировать выходные данные X = генератор. прогноз(x_input) # создаем метки классов у = нули ((n_samples, 1)) вернуть х, у # сгенерировать образцы и сохранить как график и сохранить модель defsummary_performance(шаг,g_model,latent_dim,n_samples=100): # подготовить поддельные примеры X, _ = generate_fake_samples (g_model, hidden_dim, n_samples) # шкала от [-1,1] до [0,1] Х = (Х + 1) / 2,0 # сюжетные изображения для я в диапазоне (10 * 10): # определить подсюжет pyplot.subplot(10, 10, 1 + я) # отключить ось pyplot.axis(‘выкл’) # отображать необработанные пиксельные данные pyplot.imshow(X[i,:,:, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_collapse/generated_plot_%03d.png’% (шаг+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_collapse/model_%03d.h5′ % (шаг+1)) # создаем линейный график потерь для гана и сохраняем в файл def plot_history (d1_hist, d2_hist, g_hist, a1_hist, a2_hist): # сюжетная потеря pyplot.subplot(2, 1, 1) pyplot.plot(d1_hist, label=’d-real’) pyplot. plot(d2_hist, label=’d-fake’) pyplot.plot (g_hist, метка = ‘ген’) pyplot.легенда() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot (a2_hist, метка = ‘acc-fake’) pyplot.легенда() # сохранить график в файл pyplot.savefig(‘results_collapse/plot_line_plot_loss.png’) pyplot.close() # обучаем генератор и дискриминатор def train (g_model, d_model, gan_model, набор данных, hidden_dim, n_epochs = 10, n_batch = 128): # вычисляем количество батчей за эпоху bat_per_epo = int(dataset.shape[0]/n_batch) # рассчитать общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество образцов в половине партии half_batch = int (n_batch / 2) # готовим списки для хранения статистики каждую итерацию d1_hist, d2_hist, g_hist, a1_hist, a2_hist = список(), список(), список(), список(), список() # вручную перечисляем эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» сэмплы X_real, y_real = generate_real_samples (набор данных, полупакет) # обновить вес модели дискриминатора d_loss1, d_acc1 = d_model. train_on_batch(X_real, y_real) # генерировать «поддельные» примеры X_fake, y_fake = generate_fake_samples (g_model, hidden_dim, half_batch) # обновить вес модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points (latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = единицы ((n_batch, 1)) # обновить генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммируем потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # запись истории d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) a1_hist.append(d_acc1) a2_hist.append(d_acc2) # оцениваем производительность модели каждую «эпоху» если (i+1) % bat_per_epo == 0: суммарная_производительность (я, g_model, латентный_дим) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist) # создаем папку для результатов makedirs(‘results_collapse’, exists_ok=True) # размер скрытого пространства скрытый_дим = 1 # создаем дискриминатор дискриминатор = определить_дискриминатор() # создаем генератор генератор = определить_генератор (латентный_тусклый) # создаем ган gan_model = define_gan (генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() печать (набор данных. форма) # модель поезда поезд (генератор, дискриминатор, модель_гана, набор данных, латентный_дим)

1 2 3 4 5 6 7 8 10 110003 12 13 14 1999 0001 9000 2 14 9000 3 9000 3 9000 3 9000 2 9000 2 14 9000 3 9000 3 9000 2 9000 3 9000 3 9000 3 18 19 20 21 22 23 24 25 26 27 28 29 30 28 29 30 0002 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 13 121 122 13 0002 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 151 152 9000 3 0003 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 7000 183 9000 181 1821 183 183 9000 9000 . 0003 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

# пример обучения нестабильного гана для генерации рукописной цифры от OS Import MakedIrs из Numpy Import Expand_dims от Numpy Import Zeros от Numpy Import One от Numpy.random Importnd Randn из Numpy.random Importint из Keras.datasets.m.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manit. из keras.optimizers import Adam из keras.models import Sequential из keras.layers import Dense из keras.layers import Reshape из keras.layers import Flatten from keras. layers import Conv2D from keras.layers import Conv2DTranspose from keras.layers import LeakyReLU from keras.initializers import RandomNormal from matplotlib import pyplot   # define the standalone discriminator model def Define_Distributor(in_shape=(28,28,1)): # инициализация веса init = RandomNormal(stddev=0.02) # определение модели model = Sequential() # уменьшение разрешения до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU(alpha=0.2)) # понижение разрешения до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # классификатор model.add(Flatten()) model.add(Dense(1, активация=’sigmoid’)) # скомпилировать модель opt = Adam(lr=0.0002, beta_1=0. 5) model.compile(loss=’binary_crossentropy’, optimizer=opt, metrics=[‘accuracy’]) return model   # определение автономной Модель генератора DEF DEFINE_GENERATOR (LATENT_DIM): # Инициализация веса init = случайный (stddev = 0,02) # Define Model Модель = 1288 * 10003 # Фонд для 7×7 Изображение n_nodes = 1288 * 7*7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(Reshape((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2) )) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # вывод 28x28x1 model.add(Conv2D(1, (7,7), активация=’tanh’, padding=’same’, kernel_initializer=init)) return model   # определить комбинированную модель генератора и дискриминатора для обновления генератора # соедините их model = Sequential() # добавить генератор model. add(generator) # добавить дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Adam(lr=0.0002, beta 0.5) model.compile(loss=’binary_crossentropy’, optimizer=opt) модель возврата   # загрузить изображения mnist def load_real_samples(): # загрузить набор данных (train ) # загрузить набор данных # загрузить набор данных (_, _) = load_data() # расширить до 3d, например. добавить каналы X = expand_dims(trainX, axis=-1) # выбрать все примеры для данного класса float X = X.astype(‘float32’) # масштаб от [0,255] до [-1,1] X = (X — 127,5) / 127,5 return X   # select реальные образцы def generate_real_samples (набор данных, n_samples): # выбрать случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выбрать изображения X = набор данных[ix] # создать метки классов y = one((n_samples) , 1)) return X, y   # генерировать точки в скрытом пространстве в качестве входных данных для генератора скрытый_дим * n_samples) # преобразование в пакет входных данных для сети x_input = x_input. reshape(n_samples,latent_dim) return x_input   # использование генератора для создания n поддельных примеров с метками классов 3 генератор, скрытое_дим, n_samples): # генерировать точки в скрытом пространстве x_input = generate_latent_points(latent_dim, n_samples) # прогнозировать выходные данные X = генератор.предсказать(x_input) # создать метки классов y = zeros((n_samples, 1)) return X, y   # создать образцы и сохранить их как график и сохранить модель , n_samples=100) 1) / 2.0 # изображения графика для i в диапазоне (10 * 10): # определить подзаголовок pyplot.subplot(10, 10, 1 + i) # выключить ось pyplot.axis(‘off’) # построить необработанные пиксельные данные pyXplot.imshow(pyXplot.imshow(pyXplot.imshow) i, :, :, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_collapse/generated_plot_%03d. png’ % (шаг+1)) pyplot.close( ) # сохранить модель генератора g_model.save(‘results_collapse/model_%03d.h5’ % (шаг+1))   # создать линейный график потерь для гана и сохранить его в файл pyplot.plot(d1_hist, label=’d-real’) pyplot.plot(d2_hist, label=’d-fake’) pyplot.plot(g_hist, label=’gen’) pyplot.legend( ) # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot(a2_hist, label=’acc-fake’) pyplot.legend() # сохранить график в файл pyplot.savefig(‘results_collapse/plot_line_plot_loss.png’) )   # обучение генератора и дискриминатора def train(g_model, d_model, gan_model, dataset, hidden_dim, n_epochs=10, n_batch=128): # вычисление количества пакетов в эпоху _batch=900 (dataset.shape[0] / n_batch) # вычислить общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество выборок в половине партии d1_hist, d2_hist, g_hist, a1_hist, a2_hist = list(), list(), list(), list(), list() # вручную перечислить эпохи for i in range(n_steps): # получить случайно выбранные «настоящие» образцы x_real, y_real = generate_real_samples (набор данных, Half_batch) # Обновление модели дискриминатора D_LOSS1, D_ACC1 = D_MODEL. TRAIN_ON_BATCH (X_REAL, Y_REAL) # GENERATE ‘FAKE_BATCH (X_REAL, Y_REAL) # GENERATE’ FAKE_BATCH. ,latent_dim,half_batch) # обновить веса модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points(latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = one((n_batch, 1)) # обновляем генератор через ошибку дискриминатора g_loss( X_gan, y_gan) # суммировать потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # история записи D1_HIST.Append (D_LOSS1) D2_HIST.Append (D_LOSS2) G_HIST.Append (G_LOSS) A1_HIST.APPEND (D_ACC1) A2_HIST.Append (D_ACC2) # ENSEALCHIUTE. ‘ if (i+1) % bat_per_epo == 0: summarize_performance(i, g_model, latent_dim) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist)   # make folder for results makedirs(‘results_collapse’, exists_ok=True) # Размер скрытого пространства latent_dim = 1 # Создать дискриминатор Discinator = define_discriminator () # создать генератор Генератор = Define_generator (Latent_DIM) # CREATE GAN generarator. dataset = load_real_samples() print(dataset.shape) # модель поезда0003

Запуск примера будет сообщать о потерях и точности на каждом этапе обучения, как и раньше.

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

>1, d1=0,963, d2=0,699 г=0,614, а1=28, а2=54 >2, d1=0,185, d2=5,084 g=0,097, а1=96, а2=0 >3, d1=0,088, d2=4,861 г=0,065, а1=100, а2=0 >4, d1=0,077, d2=4,202 г=0,090, а1=100, а2=0 >5, d1=0,062, d2=3,533 g=0,128, а1=100, а2=0 … >446, d1=0,277, d2=0,261 г=0,684, а1=95, а2=100 >447, d1=0,201, d2=0,247 г=0,713, а1=96, а2=100 >448, d1=0,285, d2=0,285 г=0,728, а1=89, а2=100 >449, d1=0,351, d2=0,467 г=1,184, а1=92, а2=81 >450, d1=0,492, d2=0,388 g=1,351, a1=76, a2=100

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

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

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

Линейные графики потерь и точности для генеративно-состязательной сети с коллапсом режима

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

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

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

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

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

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

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

Как определить сбой конвергенции в генеративно-состязательной сети

Пожалуй, наиболее распространенный сбой при обучении GAN — это сбой сходимости.

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

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

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

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

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

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

Это изменение так же просто, как использование функции vstack() NumPy для объединения реальных и поддельных образцов, а затем вызов функции train_on_batch() для обновления модели дискриминатора. Результатом также являются единые оценки потерь и точности, а это означает, что отчеты о производительности модели также должны быть обновлены.

Полный список кодов с этими изменениями приведен ниже для полноты картины.

# пример обучения нестабильного гана для генерации рукописной цифры из ОС импортировать makedirs из numpy импорта expand_dims из нулей импорта numpy из пустых импортных импорт из numpy vstack из numpy.random импортировать randn из numpy.random импортировать randint из keras.datasets.mnist импортировать load_data из keras.optimizers импорт Адама из keras.models импорт последовательный из keras.layers импорт плотный из keras.layers импортировать изменение формы из keras.layers импортировать Flatten из keras.layers импортировать Conv2D из keras.layers импортировать Conv2DTranspose из keras.layers импортировать LeakyReLU из keras.initializers импортировать RandomNormal из matplotlib импортировать pyplot # определить автономную модель дискриминатора def определить_дискриминатор (in_shape = (28,28,1)): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # понизить разрешение до 14×14 model. add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU (альфа = 0,2)) # понизить разрешение до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # классификатор model.add(Свести()) model.add (плотный (1, активация = ‘сигмоид’)) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция, метрики = [‘точность’]) модель возврата # определить автономную модель генератора def определить_генератор (скрытый_дим): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # основа для изображения 7×7 n_узлов = 128 * 7 * 7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add (LeakyReLU (альфа = 0,2)) model.add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model. add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # вывод 28x28x1 model.add (Conv2D (1, (7,7), активация = ‘tanh’, заполнение = ‘то же’, kernel_initializer = init)) модель возврата # определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (генератор, дискриминатор): # делаем веса в дискриминаторе не обучаемыми дискриминатор.trainable = Ложь # соедините их модель = Последовательный() # добавляем генератор model.add(генератор) # добавляем дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Адам (lr = 0,0002, beta_1 = 0,5) model.compile (потеря = ‘binary_crossentropy’, оптимизатор = опция) модель возврата # загрузить изображения mnist защита load_real_samples(): # загрузить набор данных (поездX, обучение), (_, _) = load_data() # расширить до 3D, например. добавить каналы X = expand_dims (trainX, ось = -1) # выбрать все примеры для данного класса selected_ix = обучаемый == 8 Х = Х[выбрано_ix] # преобразовать из целых чисел в числа с плавающей запятой X = X.astype(‘float32’) # шкала от [0,255] до [-1,1] Х = (Х — 127,5) / 127,5 вернуть Х # # выбрать реальные образцы def generate_real_samples (набор данных, n_samples): # выбираем случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выберите изображения X = набор данных[ix] # генерируем метки классов y = единицы ((n_samples, 1)) вернуть х, у # генерировать точки в скрытом пространстве в качестве входных данных для генератора def generate_latent_points (latent_dim, n_samples): # генерируем точки в скрытом пространстве x_input = randn (latent_dim * n_samples) # преобразовать в пакет входных данных для сети x_input = x_input.reshape (n_samples, скрытый_дим) вернуть x_input # использовать генератор для создания n поддельных примеров с метками классов def generate_fake_samples (генератор, латентный_дим, n_samples): # генерируем точки в скрытом пространстве x_input = generate_latent_points (latent_dim, n_samples) # прогнозировать выходные данные X = генератор. прогноз(x_input) # создаем метки классов у = нули ((n_samples, 1)) вернуть х, у # сгенерировать образцы и сохранить как график и сохранить модель defsummary_performance(шаг,g_model,latent_dim,n_samples=100): # подготовить поддельные примеры X, _ = generate_fake_samples (g_model, hidden_dim, n_samples) # шкала от [-1,1] до [0,1] Х = (Х + 1) / 2,0 # сюжетные изображения для я в диапазоне (10 * 10): # определить подсюжет pyplot.subplot(10, 10, 1 + я) # отключить ось pyplot.axis(‘выкл’) # отображать необработанные пиксельные данные pyplot.imshow(X[i,:,:, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_convergence/generated_plot_%03d.png’% (шаг+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_convergence/model_%03d.h5’ % (шаг+1)) # создаем линейный график потерь для гана и сохраняем в файл def plot_history (d_hist, g_hist, a_hist): # сюжетная потеря pyplot.subplot(2, 1, 1) pyplot.plot (d_hist, метка = ‘дис’) pyplot.plot (g_hist, метка = ‘ген’) pyplot. легенда() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot (a_hist, метка = ‘акк’) pyplot.легенда() # сохранить график в файл pyplot.savefig(‘results_convergence/plot_line_plot_loss.png’) pyplot.close() # обучаем генератор и дискриминатор def train (g_model, d_model, gan_model, набор данных, hidden_dim, n_epochs = 10, n_batch = 128): # вычисляем количество батчей за эпоху bat_per_epo = int(dataset.shape[0]/n_batch) # рассчитать общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество образцов в половине партии half_batch = int (n_batch / 2) # готовим списки для хранения статистики каждую итерацию d_hist, g_hist, a_hist = список(), список(), список() # вручную перечисляем эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» сэмплы X_real, y_real = generate_real_samples (набор данных, полупакет) # генерировать «поддельные» примеры X_fake, y_fake = generate_fake_samples (g_model, hidden_dim, half_batch) # объединить в одну партию X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake)) # обновить вес модели дискриминатора d_loss, d_acc = d_model. train_on_batch(X, y) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points (latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = единицы ((n_batch, 1)) # обновить генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммируем потери в этой партии print(‘>%d, d=%.3f, g=%.3f, a=%d’ % (i+1, d_loss, g_loss, int(100*d_acc))) # запись истории d_hist.append(d_loss) g_hist.append(g_loss) a_hist.append(d_acc) # оцениваем производительность модели каждую «эпоху» если (i+1) % bat_per_epo == 0: суммарная_производительность (я, g_model, латентный_дим) plot_history(d_hist, g_hist, a_hist) # создаем папку для результатов makedirs(‘results_convergence’, exists_ok=True) # размер скрытого пространства скрытый_дим = 50 # создаем дискриминатор дискриминатор = определить_дискриминатор() # создаем генератор генератор = определить_генератор (латентный_тусклый) # создаем ган gan_model = define_gan (генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() печать (набор данных. форма) # модель поезда поезд (генератор, дискриминатор, модель_гана, набор данных, латентный_дим)

1 2 3 4 5 6 7 8 10 110003 12 13 14 1999 0001 9000 2 14 9000 3 9000 3 9000 3 9000 2 9000 2 14 9000 3 9000 3 9000 2 9000 3 9000 3 9000 3 18 19 20 21 22 23 24 25 26 27 28 29 30 28 29 30 0002 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 13 121 122 13 0002 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 151 152 9000 3 0003 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 7000 183 9000 181 1821 183 183 9000 9000 . 0003 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206

# пример обучения нестабильного гана для генерации рукописной цифры от OS Import MakedIrs из Numpy Import Expand_dims от Numpy Import Zeros от Numpy Import Ones от Numpy Import VSTACK от Numpy.Random Importn от Nump. .datasets.mnist import load_data из keras.optimizers import Adam из keras.models import Sequential из keras.layers import Dense из keras.layers import Reshape from keras.layers import Flatten from keras.layers import Conv2D from keras.layers import Conv2DTranspose from keras.layers import LeakyReLU from keras. initializers import RandomNormal from matplotlib import pyplot   # определить автономную модель дискриминатора def define_distributor(in_shape=(28,28,1)): # инициализация веса init = RandomNormal(stddev=0.02) # определение модели model = Sequential() # понижение разрешения до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer= init, input_shape=in_shape)) model.add(LeakyReLU(alpha=0.2)) # понижение разрешения до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # классификатор model.add(Flatten()) model.add(Dense(1,activation=’sigmoid’)) # скомпилировать модель opt = Adam(lr=0.0002, beta_1=0.5) model.compile(loss=’binary_crossentropy’, optimizer=opt , metrics=[‘accuracy’]) модель возврата   # определение модели автономного генератора def define_generator(latent_dim): # инициализация веса модель модель = последовательная() # основа для изображения 7×7 n_nodes = 128 * 7 * 7 model. add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) 3 model.add(Reshape((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’ , kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding) =’такое же’, kernel_initializer=init)) model.add(LeakyReLU(alpha=0.2)) # вывод 28x28x1 model.add(Conv2D(1, (7,7), активация=’tanh’, padding=’same’, kernel_initializer=init) ) return model   # определить комбинированную модель генератора и дискриминатора для обновления генератора # соедините их model = Sequential() # добавить генератор model.add(generator) # добавить дискриминатор model.add(дискриминатор) # скомпилировать модель opt = Adam(10_0,0. 0. =0.5) model.compile(loss=’binary_crossentropy’, optimizer=opt) return model   # загрузить изображения mnist def load_real_samples(): # train # загрузить набор данных 900X , (_, _) = load_data() # расширить до 3d, например. добавить каналы X = expand_dims(trainX, axis=-1) # выбрать все примеры для данного класса float X = X.astype(‘float32’) # масштаб от [0,255] до [-1,1] X = (X — 127,5) / 127,5 return X   # select реальные образцы def generate_real_samples (набор данных, n_samples): # выбрать случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выбрать изображения X = набор данных[ix] # создать метки классов y = one((n_samples) , 1)) return X, y   # генерировать точки в скрытом пространстве в качестве входных данных для генератора скрытый_дим * n_samples) # преобразование в пакет входных данных для сети x_input = x_input. reshape(n_samples,latent_dim) return x_input   # использование генератора для создания n поддельных примеров с метками классов 3 генератор, скрытое_дим, n_samples): # генерировать точки в скрытом пространстве x_input = generate_latent_points(latent_dim, n_samples) # прогнозировать выходные данные X = генератор.предсказать(x_input) # создать метки классов y = zeros((n_samples, 1)) return X, y   # создать образцы и сохранить их как график и сохранить модель , n_samples=100) 1) / 2.0 # изображения графика для i в диапазоне (10 * 10): # определить подзаголовок pyplot.subplot(10, 10, 1 + i) # выключить ось pyplot.axis(‘off’) # построить необработанные пиксельные данные pyXplot.imshow(pyXplot.imshow(pyXplot.imshow) i, :, :, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_convergence/generated_plot_%03d. png’ % (step+1)) pyplot.close( ) # сохранить модель генератора g_model.save(‘results_convergence/model_%03d.h5’ % (шаг+1))   # создать линейный график потерь для гана и сохранить в файл (d_hist, label=’dis’) pyplot.plot(g_hist, label=’gen’) pyplot.legend() # Точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a_hist, label=’acc’) pyplot.legend() # сохранить график в файл pyplot.savefig(‘results_convergence/plot_line_plot_loss.png’) pyplot.close()   # обучение генератора и дискриминатора =128)0002 # вычислить количество выборок в половине партии half_batch = int(n_batch / 2) # подготовить списки для хранения статистики на каждой итерации d_hist, g_hist, a_hist = list(), list(), list() # вручную перечислить эпохи для i в диапазоне (n_steps): # получить случайным образом выбранные «настоящие» выборки y_fake = generate_fake_samples(g_model, hidden_dim, half_batch) # объединить в один пакет X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake)) # обновить веса модели дискриминатора d_loss, d_acc = d_model. train_on_batch(X, y ) # подготовить точки в скрытом пространстве в качестве входных данных для генератора генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммировать потери в этой партии print(‘>%d, d=%.3f, g=%.3f, a=%d’ % (i+ 1, d_loss, g_loss, int(100*d_acc))) # история записи d_hist.append(d_loss) g_hist.append(g_loss) a_hist.append(d_acc) # оценка производительности модели каждую «эпоху» if (i+1) % bat_per_epo == 0: summary_performance(i,g_model,latent_dim) plot_history(d_hist,g_hist,a_hist) # Сделать папку для результатов MakedIrs (‘Result_convergence’, ESIGE_OK = TRUE) # Размер латентного пространства Latent_DIM = 50 # Create the Discinator Discinator = DEFINT_DISCRIMINATO создать генератор генератор = определить_генератор(латентный_дим) # создать ган ган_модель = определить_ган(генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() print(dataset. shape) # модель поезда train(генератор, дискриминатор, gan_model, набор данных, латентный_дим)

Выполнение примера сообщает о потерях и точности для каждого обновления модели.

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

Вот что мы видим в данном случае.

>1, д=0,514, г=0,969, а=80 >2, д=0,475, г=0,395, а=74 >3, д=0,452, г=0,223, а=69>4, д=0,302, г=0,220, а=85 >5, д=0,177, г=0,195, а=100 >6, д=0,122, г=0,200, а=100 >7, д=0,088, г=0,179, а=100 >8, д=0,075, г=0,159, а=100 >9, д=0,071, г=0,167, а=100 >10, д=0,102, г=0,127, а=100 … >446, д=0,000, г=0,001, а=100 >447, д=0,000, г=0,001, а=100 >448, д=0,000, г=0,001, а=100 >449, д=0,000, г=0,001, а=100 >450, d=0,000, g=0,001, а=100

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

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

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

Линейные графики потерь и точности для генеративно-состязательной сети с ошибкой сходимости

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

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

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

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

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

Например, дискриминатор можно составить так:

… # скомпилировать модель model.compile(потеря=’binary_crossentropy’, оптимизатор=’адам’, метрики=[‘точность’])

А составную модель GAN можно составить следующим образом:

. .. # скомпилировать модель model.compile(потеря=’binary_crossentropy’, оптимизатор=’адам’)

Полный список кодов приведен ниже для полноты картины.

# пример обучения нестабильного гана для генерации рукописной цифры из ОС импортировать makedirs из numpy импорта expand_dims из нулей импорта numpy из пустых импортных из numpy.random импортировать randn из numpy.random импортировать randint из keras.datasets.mnist импортировать load_data из keras.models импорт последовательный из keras.layers импорт плотный из keras.layers импортировать изменение формы из keras.layers импортировать Flatten из keras.layers импортировать Conv2D из keras.layers импортировать Conv2DTranspose из keras.layers импортировать LeakyReLU из keras.initializers импортировать RandomNormal из matplotlib импортировать pyplot # определить автономную модель дискриминатора def определить_дискриминатор (in_shape = (28,28,1)): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # понизить разрешение до 14×14 model. add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add (LeakyReLU (альфа = 0,2)) # понизить разрешение до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # классификатор model.add(Свести()) model.add (плотный (1, активация = ‘сигмоид’)) # скомпилировать модель model.compile (потеря = ‘binary_crossentropy’, оптимизатор = ‘адам’, метрики = [‘точность’]) модель возврата # определить автономную модель генератора def определить_генератор (скрытый_дим): # инициализация веса инициализация = случайный нормальный (стандартное отклонение = 0,02) # определить модель модель = Последовательный() # основа для изображения 7×7 n_узлов = 128 * 7 * 7 model.add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add (LeakyReLU (альфа = 0,2)) model.add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model. add (LeakyReLU (альфа = 0,2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU (альфа = 0,2)) # вывод 28x28x1 model.add (Conv2D (1, (7,7), активация = ‘tanh’, заполнение = ‘то же’, kernel_initializer = init)) модель возврата # определить комбинированную модель генератора и дискриминатора для обновления генератора def define_gan (генератор, дискриминатор): # делаем веса в дискриминаторе не обучаемыми дискриминатор.trainable = Ложь # соедините их модель = Последовательный() # добавляем генератор model.add(генератор) # добавляем дискриминатор model.add(дискриминатор) # скомпилировать модель model.compile (потеря = ‘binary_crossentropy’, оптимизатор = ‘адам’) модель возврата # загрузить изображения mnist защита load_real_samples(): # загрузить набор данных (поездX, обучение), (_, _) = load_data() # расширить до 3D, например. добавить каналы X = expand_dims (trainX, ось = -1) # выбрать все примеры для данного класса selected_ix = обучаемый == 8 Х = Х[выбрано_ix] # преобразовать из целых чисел в числа с плавающей запятой X = X. astype(‘float32’) # шкала от [0,255] до [-1,1] Х = (Х — 127,5) / 127,5 вернуть Х # выбрать реальные образцы def generate_real_samples (набор данных, n_samples): # выбираем случайные экземпляры ix = randint(0, dataset.shape[0], n_samples) # выберите изображения X = набор данных[ix] # генерируем метки классов y = единицы ((n_samples, 1)) вернуть х, у # генерировать точки в скрытом пространстве в качестве входных данных для генератора def generate_latent_points (latent_dim, n_samples): # генерируем точки в скрытом пространстве x_input = randn (latent_dim * n_samples) # преобразовать в пакет входных данных для сети x_input = x_input.reshape (n_samples, скрытый_дим) вернуть x_input # использовать генератор для создания n поддельных примеров с метками классов def generate_fake_samples (генератор, латентный_дим, n_samples): # генерируем точки в скрытом пространстве x_input = generate_latent_points (latent_dim, n_samples) # прогнозировать выходные данные X = генератор. прогноз(x_input) # создаем метки классов у = нули ((n_samples, 1)) вернуть х, у # сгенерировать образцы и сохранить как график и сохранить модель defsummary_performance(шаг,g_model,latent_dim,n_samples=100): # подготовить поддельные примеры X, _ = generate_fake_samples (g_model, hidden_dim, n_samples) # шкала от [-1,1] до [0,1] Х = (Х + 1) / 2,0 # сюжетные изображения для я в диапазоне (10 * 10): # определить подсюжет pyplot.subplot(10, 10, 1 + я) # отключить ось pyplot.axis(‘выкл’) # отображать необработанные пиксельные данные pyplot.imshow(X[i,:,:, 0], cmap=’gray_r’) # сохранить график в файл pyplot.savefig(‘results_opt/generated_plot_%03d.png’% (шаг+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_opt/model_%03d.h5′ % (шаг+1)) # создаем линейный график потерь для гана и сохраняем в файл def plot_history (d1_hist, d2_hist, g_hist, a1_hist, a2_hist): # сюжетная потеря pyplot.subplot(2, 1, 1) pyplot.plot(d1_hist, label=’d-real’) pyplot. plot(d2_hist, label=’d-fake’) pyplot.plot (g_hist, метка = ‘ген’) pyplot.легенда() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’acc-real’) pyplot.plot (a2_hist, метка = ‘acc-fake’) pyplot.легенда() # сохранить график в файл pyplot.savefig(‘results_opt/plot_line_plot_loss.png’) pyplot.close() # обучаем генератор и дискриминатор def train (g_model, d_model, gan_model, набор данных, hidden_dim, n_epochs = 10, n_batch = 128): # вычисляем количество батчей за эпоху bat_per_epo = int(dataset.shape[0]/n_batch) # рассчитать общее количество итераций на основе партии и эпохи n_steps = bat_per_epo * n_epochs # вычислить количество образцов в половине партии half_batch = int (n_batch / 2) # готовим списки для хранения статистики каждую итерацию d1_hist, d2_hist, g_hist, a1_hist, a2_hist = список(), список(), список(), список(), список() # вручную перечисляем эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» сэмплы X_real, y_real = generate_real_samples (набор данных, полупакет) # обновить вес модели дискриминатора d_loss1, d_acc1 = d_model. train_on_batch(X_real, y_real) # генерировать «поддельные» примеры X_fake, y_fake = generate_fake_samples (g_model, hidden_dim, half_batch) # обновить вес модели дискриминатора d_loss2, d_acc2 = d_model.train_on_batch(X_fake, y_fake) # подготовить точки в скрытом пространстве в качестве входных данных для генератора X_gan = generate_latent_points (latent_dim, n_batch) # создаем перевернутые метки для поддельных образцов y_gan = единицы ((n_batch, 1)) # обновить генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммируем потери в этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f, a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # запись истории d1_hist.append(d_loss1) d2_hist.append(d_loss2) g_hist.append(g_loss) a1_hist.append(d_acc1) a2_hist.append(d_acc2) # оцениваем производительность модели каждую «эпоху» если (i+1) % bat_per_epo == 0: суммарная_производительность (я, g_model, латентный_дим) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist) # создаем папку для результатов makedirs(‘results_opt’, exists_ok=True) # размер скрытого пространства скрытый_дим = 50 # создаем дискриминатор дискриминатор = определить_дискриминатор() # создаем генератор генератор = определить_генератор (латентный_тусклый) # создаем ган gan_model = define_gan (генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() печать (набор данных. форма) # модель поезда поезд (генератор, дискриминатор, модель_гана, набор данных, латентный_дим)

1 2 3 4 5 6 7 8 10 110003 12 13 14 1999 0001 9000 2 14 9000 3 9000 3 9000 3 9000 2 9000 2 14 9000 3 9000 3 9000 2 9000 3 9000 3 9000 3 18 19 20 21 22 23 24 25 26 27 28 29 30 28 29 30 0002 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 13 121 122 13 0002 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 151 152 9000 3 0003 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 7000 183 9000 181 1821 183 183 9000 9000 . 0003 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207

# пример обучения нестабильного гана для генерации рукописной цифры от OS Import MakedIrs из Numpy Import Expand_dims от Numpy Import Zeros от Numpy Import One от Numpy.random Importnd Randn из Numpy.random Importint из Keras.datasets.m.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist.manist. из keras.models импортировать Sequential из keras.layers импортировать Dense из keras.layers импортировать Reshape из keras.layers импортировать Flatten из keras. layers импортировать Conv2D из Keras.layers Import Conv2dtranspose из Keras.layers Import Leakyrelu из Keras.initializers Import randomnormal из Matplotlib import # Define Определение DistraTor Model .crimaRINTATOR_FINERINTATOR 2 .CRINERINTATOR 270002.CRINERINTATOR. 28,1)): # инициализация веса init = RandomNormal(stddev=0.02) # определение модели model = Sequential() # понижение разрешения до 14×14 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init, input_shape=in_shape)) model.add(LeakyReLU(alpha=0.2) )) # понижение разрешения до 7×7 model.add(Conv2D(64, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU (alpha=0.2)) # классификатор model.add(Flatten()) model.add(Dense(1, активация=’сигмоид’)) # компилируемая модель model.compile(loss= ‘binary_crossentropy’, оптимизатор=’адам’, метрики=[‘точность’]) Возврат модели # Определите автономную модель генератора DEF DEFINE_GENERATO # основа для изображения 7×7 n_nodes = 128 * 7 * 7 model. add(Dense(n_nodes, kernel_initializer=init, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) model .add(Изменить форму((7, 7, 128))) # повысить разрешение до 14×14 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add(LeakyReLU(alpha =0.2)) # повысить разрешение до 28×28 model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding=’same’, kernel_initializer=init)) model.add (LeakyReLU(alpha=0.2)) # вывод 28x28x1 model.add(Conv2D(1, (7,7), активация=’tanh’, padding=’same’, kernel_initializer=init)) return model   # определение комбинированной модели генератора и дискриминатора для обновления генератора # соедините их model = Sequential() # добавьте генератор model.add(generator) # добавьте дискриминатор model.add(дискриминатор) # скомпилировать модель model.compile(loss=’binary_crossentropy’, Optimizer=’adam’) модель возврата   # загрузить изображения mnist def load_real_samples() (3 0 dataset 90 90 load_samples(): 30) trainX, trainy), (_, _) = load_data() # расширить до 3d, например добавить каналы X = expand_dims(trainX, axis=-1) # выбрать все примеры для данного класса selected_ix = trainy == 8 X = X[selected_ix] # преобразование из целых чисел в числа с плавающей запятой X = X. astype(‘float32’) # масштабирование от [0,255] до [-1,1] X = (X — 127,5) / 127,5 return X   # выбор реальных образцов def generate_real_samples(dataset, n_samples): # выбор случайных экземпляров ix = randint(0, dataset.shape[0], n_samples) 2 = 0 3 X dataset[ix] # генерировать метки классов y = one((n_samples, 1)) return X, y   # создание точек в скрытом пространстве в качестве входных данных для генератора # преобразование в пакет входных данных для сети x_input = x_input.reshape(n_samples,latent_dim) return x_input   # использование генератора для создания n поддельных примеров с метками классов def Generate_fake_samples (Generator, Latent_DIM, N_SAMPLES): # Сгенерируйте точки в латентном пространстве x_input = Generate_latent_points (latent_dim, n_samples) # Предупреждают выходные. labels y = zeros((n_samples, 1)) return X, y   # генерировать выборки и сохранять их как график и сохранять модель : # подготовить поддельные примеры X, _ = generate_fake_samples(g_model, hidden_dim, n_samples) # масштабировать от [-1,1] до [0,1] X = (X + 1) / 2. 0 # построить изображения для i в диапазоне (10 * 10): # определить подзаговор pyplot.subplot(10, 10, 1 + i) # выключить ось pyplot.axis(‘off’) # рисуем необработанные пиксельные данные pyplot.imshow(X[i, :, :, 0], cmap=’gray_r’) # сохраняем график в файл pyplot.savefig(‘results_opt/generated_plot_%03d.png’ % (step+1)) pyplot.close() # сохранить модель генератора g_model.save(‘results_opt/model_%03d.h5 ‘ % (шаг+1))   # создать линейный график потерь для ган и сохранить в файл def plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist): # график потерь .subplot(2, 1, 1) pyplot.plot(d1_hist, label=’d-real’) pyplot.plot(d2_hist, label=’d-fake’) pyplot.plot(g_hist, label=’gen’) pyplot.legend() # точность дискриминатора графика pyplot.subplot(2, 1, 2) pyplot.plot(a1_hist, label=’ acc-real’) pyplot. plot(a2_hist, label=’acc-fake’) pyplot.legend() # сохранить график в файл pyplot.savefig(‘results_opt/plot_line_plot_loss.png’) pyplot.close()   # обучение генератора и дискриминатора def train(g_model, d_model, gan_model, dataset,latent_dim, n_epochs=10, n_batch=128): # вычислить количество пакетов в эпоху bat_per_epo = int(dataset.shape[0] / n_batch) # вычислить общее количество итераций на основе пакета и эпохи n_steps = bat_per_epo * n_epochs 3 # вычислить число выборок в половине партии half_batch = int(n_batch / 2) # подготовка списков для хранения статистики на каждой итерации d1_hist, d2_hist, g_hist, a1_hist, a2_hist = list(), list(), list(), список(), список() # вручную перечислить эпохи для i в диапазоне (n_steps): # получить случайно выбранные «настоящие» выборки X_real, y_real = generate_real_samples(dataset, half_batch) # обновить веса модели дискриминатора d_lossc, d_model. train_on_batch (x_real, y_real) # генерировать фальшивые примеры x_fake, y_fake = generate_fake_samples (g_model, latent_dim, laf_batch) # Обновление модели дискриминатор. ) # подготовить точки в скрытом пространстве в качестве входных данных для генератора генератор через ошибку дискриминатора g_loss = gan_model.train_on_batch(X_gan, y_gan) # суммировать потери на этой партии print(‘>%d, d1=%.3f, d2=%.3f g=%.3f , a1=%d, a2=%d’ % (i+1, d_loss1, d_loss2, g_loss, int(100*d_acc1), int(100*d_acc2))) # История записи D1_HIST.Append (D_LOSS1) D2_HIST.Append (D_LOSS2) G_HIST.Append (G_LOSS) A1_HIST.APPEND (D_ACC1) A2_HIST.APPEND (D_ACC1) A2_HIST. производительность модели каждую «эпоху» if (i+1) % bat_per_epo == 0: summary_performance(i,g_model,latent_dim) plot_history(d1_hist, d2_hist, g_hist, a1_hist, a2_hist) 3 9000 make папка для результатов makedirs(‘results_opt’, exists_ok=True) # размер скрытого пространства latent_dim = 50 # создать дискриминатор compiler = define_distributor() # создать генератор 3 ) # создать ган gan_model = define_gan(генератор, дискриминатор) # загрузить данные изображения набор данных = load_real_samples() print(dataset. shape) # модель поезда поезд (генератор, дискриминатор, gan_model, набор данных, латентный_дим)

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

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

>1, d1=0,728, d2=0,902 г=0,763, а1=54, а2=12 >2, d1=0,001, d2=4,509г=0,033, а1=100, а2=0 >3, d1=0,000, d2=0,486 г=0,542, а1=100, а2=76 >4, d1=0,000, d2=0,446 г=0,733, а1=100, а2=82 >5, d1=0,002, d2=0,855 г=0,649, а1=100, а2=46 … >446, d1=0,000, d2=0,000 г=10,410, а1=100, а2=100 >447, d1=0,000, d2=0,000 г=10,414, а1=100, а2=100 >448, d1=0,000, d2=0,000 г=10,419, а1=100, а2=100 >449, d1=0,000, d2=0,000 г=10,424, а1=100, а2=100 >450, d1=0,000, d2=0,000 g=10,427, a1=100, a2=100

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

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

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

Мы можем просмотреть свойства ошибки сходимости следующим образом:

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

Дополнительная литература

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

Бумаги

• Генеративно-состязательные сети, 2014.
• Учебное пособие: Генеративные состязательные сети, NIPS, 2016 г.
• Неконтролируемое репрезентативное обучение с помощью глубоких сверточных генеративно-состязательных сетей, 2015 г.

Артикул

• Как обучить ГАН? Советы и рекомендации, как заставить GAN работать

Сводка

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

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

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

Есть вопросы?
Задавайте свои вопросы в комментариях ниже, и я постараюсь ответить.

Разработайте генеративно-состязательные сети уже сегодня!

Разработка моделей GAN за считанные минуты

… всего несколькими строками кода Python

Узнайте, как в моей новой электронной книге:
Генеративные состязательные сети с Python

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

Наконец-то используйте модели GAN в своих проектах технического зрения

Пропустите академиков. Просто Результаты.

Посмотреть, что внутри

О Джейсоне Браунли

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

Просмотреть все сообщения Джейсона Браунли →

Как разработать условную GAN (cGAN) с нуля

Обзор моделей генеративно-состязательной сети

Важность сходимости сетки

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

Эта статья непосредственно применима к анализу статического напряжения. Несмотря на то, что размер сетки важен для всех анализов, существуют и другие факторы, влияющие на выбор соответствующего размера элемента в более сложных анализах. Это относится к большинству программ «h element»; Программы «p-элемента» (например, Pro Mechanica) сходятся к результату в процессе решения и в значительной степени не зависят от размера элемента.

Как провести исследование конвергенции

Кривая конвергенции

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

Рисунок 1 – кривая сходимости по 4 точкам

Локальное уточнение сетки

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

Геометрия границы — сопутствующий эффект

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

Стратегия построения сетки

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

Использование более крупных элементов вдали от областей интереса в модели является обычной практикой, но более тонкий момент заключается в том, что они не искажают геометрию и могут быть выполнены подходящие переходы сетки; эти элементы могут быть 90 396 значительно 90 397 больше, чем в интересующих областях, без ущерба для точности. Сравните это как стратегию создания сетки с заполнением всей модели небольшими высококачественными элементами для повышения «общей» точности. Этот последний подход неэффективен и вряд ли повысит точность анализа статического напряжения с помощью неявного кода.

Резюме

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

Распространение исследования конвергенции на другие модели

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

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

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

Примеры неправильной практики

Использование размера элемента в качестве меры сходимости

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

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

Распространенный случай игнорирования сходимости

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

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

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

Сводка

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

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

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

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

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

Отслеживание хода обучения GAN и выявление распространенных режимов отказа — MATLAB & Simulink

Основное содержание

Мониторинг прогресса обучения GAN и выявление общих режимов отказа

Обучение GAN может быть сложной задачей. Это связано с тем, что генератор и дискриминаторные сети конкурируют друг с другом во время обучения. На самом деле, если один сеть обучается слишком быстро, тогда другая сеть может не обучиться. Это часто может привести в сети невозможно сойтись. Для диагностики проблем и мониторинга по шкале от 0 до 1, насколько хорошо генератор и дискриминатор достигают своих целей, которые вы можете построить их баллы. Для примера, показывающего, как обучить GAN и построить генератор и баллы дискриминатора, см. Обучение генеративно-состязательной сети (GAN). 9Real содержит выходные вероятности дискриминатора для реальных изображений и числа реальных и сгенерированных изображений, переданных дискриминатору, равны.

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

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

Ошибка сходимости

Ошибка сходимости происходит, когда генератор и дискриминатор не достигают баланс во время тренировки.

Дискриминатор доминирует

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

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

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

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

• Ухудшение работы дискриминатора путем добавления выпадающих слоев

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

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

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

Генератор доминирует

Этот сценарий происходит, когда счет генератора достигает единицы или почти единицы.

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

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

• Улучшение способности дискриминатора изучать больше функций путем увеличение количества фильтров

• Ухудшение работы генератора путем добавления отсеивающих слоев

• Ухудшение работы генератора за счет уменьшения количества фильтров

Коллапс режима

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

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

Если вы наблюдаете подобное, то попробуйте увеличить способность генератора создавать более разнообразные результаты:

• Увеличение размерности входных данных в генератор

• Увеличение количества фильтров генератора, чтобы он мог генерировать широкий выбор функций

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

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

См. также

dlnetwork | вперед | предсказать | Дларрей | длградиент | dlfeval | Адамобновление

Связанные темы

• Обучение генеративно-состязательной сети (GAN)
• Обучение условно генеративно-состязательной сети (CGAN)
• Определение пользовательских циклов обучения, функций потерь и сетей
• Обучение сети с использованием пользовательского цикла обучения
Пользовательский Указать параметры обучения в Цикл обучения
• Список слоев глубокого обучения
• Советы и рекомендации по глубокому обучению
• Фон автоматического дифференцирования

Вы щелкнули ссылку, соответствующую этой команде MATLAB:

Запустите команду, введя ее в командном окне MATLAB.

Comments |0|