Медленный почему 2 нн: «Медленный» или «медленый» — как правильно пишется?

- Оптимизация или реструктуризация отношений n-n Запросы Neo4j, вызывающие очень медленное время отклика

Мне нужна помощь с одним из моих графиков Neo4j. Мои узлы и отношения выглядят примерно так:

Это пример одного сквозного отношения в графе.

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

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

  MATCH (s: app) - [: HAS_GEOZONE] -> (g: geozone) - [: HAS_ENGAGEMENTZONE] -> (e: Engage_zone) - [: HAS_STORE] -> (st: store) - [: HAS_NOTIFICATION] - > (nt: уведомление), shortPath ((nt) - [r: HAS_NOTIFICATION_TYPE] -> (ntt: notification_type)), shorttestPath ((nt) - [ra: HAS_NOTIFICATION_ACTION_TYPE] -> (ntta: notification_action_type)), (st) - [: HAS_ATTRIBUTE] -> (sta: store_attribute) ГДЕ s.uuid = {app_id} AND sta.key = 'name' ДОПОЛНИТЕЛЬНОЕ СООТВЕТСТВИЕ (nt) - [: HAS_BRAND] -> (br: brand) ДОПОЛНИТЕЛЬНОЕ СООТВЕТСТВИЕ (nt) - [: HAS_LABEL] -> (l: лояльность) RETURN nt. uuid как nt_id, COLLECT (DISTINCT st.uuid) как st_ids, COLLECT (DISTINCT sta.value) как store_names, COLLECT (DISTINCT properties (br)) как notification_brands, COLLECT (DISTINCT properties (l)) как notification_labels, COLLECT (DISTINCT properties (nt)) как уведомление, COLLECT (DISTINCT properties (ntt)) как notification_type, COLLECT (DISTINCT properties (ntta)) как notification_action_type ORDER BY nt_id
  

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

например ответа одной записи исходного запроса -

И json выглядит так, как показано ниже, где имена столбцов являются узлами на графике

  [
  {
    "nt_id": "002a3ba0-2584-11ea-93de-118eb121a0f8",
    "st_ids": [
      "e5fb2cc0-2246-11ea-a327-c1a6ac2ca4a0"
    ],
    "store_names": [
      "А ТАКЖЕ"
    ],
    "notification_brands": [],
    "notification_labels": [],
    "уведомление": [
      {
        "sub_text": "Удачных покупок !!",
        "action_url": "https: // www.tatacliq.com/and/c-mbh21a00015 ",
        "URL изображения": "",
        "notification_match_type": "ОБЩЕЕ",
        "validity_start": 1,
        "text": "Добро пожаловать в {{store_name}}",
        "inventory_request_params": "",
        "isActive": правда,
        "validity_end": 1,
        "uuid": "002a3ba0-2584-11ea-93de-118eb121a0f8",
        "активные_дни": "{\" ВОСКРЕСЕНЬЕ \ ": \" 1100-2100 \ ", \" ПОНЕДЕЛЬНИК \ ": \" 1100-2100 \ ", \" ВТОРНИК \ ": \" 1100-2100 \ ", \" СРЕДА \ ": \" 1100-2100 \ ", \" ЧЕТВЕРГ \ ": \" 1100-2100 \ ", \" ПЯТНИЦА \ ": \" 1100-2100 \ ", \" СУББОТА \ ": \" 1100- 2100 \ "}"
      }
    ],
    "notification_type": [
      {
        "name": "Сделки и предложения",
        "uuid": "2fdc2b20-4faf-11e9-bfff-47192e1"
      }
    ],
    "notification_action_type": [
      {
        "name": "В магазине",
        "uuid": "ce78fc50-4fae-11e9-b974-7995b4e2b93d"
      }
    ]
  }
]
  

• версия neo4j: neo4j: 3.5.12-enterprise и работает в Docker на машине AWS m5.xlarge с кучей 12 ГБ и настроенным размером кеша

• какой API / драйвер вы используете: Rest API на ECS и Node JS на отдельных экземплярах

• снимок экрана [ПРОФИЛЬ или ОБЪЯСНЕНИЕ]

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

query.log query.log.1

Мы будем благодарны за любую помощь в этом вопросе!

Спасибо, Арнаб

Медленные колебания в двух парах дофаминергических нейронов обеспечивают формирование долговременной памяти у дрозофилы

Замедление назад с использованием nn.Conv2d в качестве замены для nn.Linear - autograd

Я пытаюсь самостоятельно реализовать более быстрый RCNN.Для roi_head я использовал nn.Conv2d с ядром 7 * 7 в качестве замены для nn.Linear. Однако я обнаружил, что с nn.Conv2d обратный ход выполняется очень медленно. На 100 итераций с nn.Conv2d ушло около 15 секунд назад, а на 100 итераций с nn.Linear - 3,7 секунды. (Обратное время предназначено для всей более быстрой сети rcnn, поскольку трудно просто отсчитать время обратного распространения модуля).

Почему разница во времени такая большая?

Здесь перечислены два кода

  класс FastRCNNHead (nn.Модуль):
    def __init __ (self, cfg):
        супер () .__ init __ ()
        self.class_num = cfg.class_num
        class_num = cfg.class_num
        self.cfg = cfg
        feature_num = 1024
        pool_h = cfg.roi_pool.pool_h
        pool_w = cfg.roi_pool.pool_w
        self.feature_head = nn.Sequential (
            nn.Linear (cfg.out_feature_num * pool_h * pool_w, feature_num),
            nn.ReLU (inplace = True),
            nn.Linear (feature_num, feature_num),
            nn.ReLU (inplace = Истина)
        )
        себя.label_head = nn.Linear (номер_функции, номер_класса + 1)
        self.bbox_head = nn.Linear (feature_num, 4 * (class_num + 1))

        для m в self.modules ():
            если isinstance (m, nn.Linear):
                nn.init.normal_ (средний вес, стандартное значение = 0,01)
                nn.init.constant_ (m.bias, 0)

    def вперед (self, rois):

        rois = rois.flatten (start_dim = 1)
        features = self.feature_head (rois)
        label_pre = self.label_head (функции)
        bbox_pre = self.bbox_head (функции)

        вернуть label_pre, bbox_pre
  

  класс FastRCNNHeadConv (nn.Модуль):
    def __init __ (self, cfg):
        супер () .__ init __ ()
        self.class_num = cfg.class_num
        class_num = cfg.class_num
        self.cfg = cfg
        feature_num = 1024
        pool_h = cfg.roi_pool.pool_h
        pool_w = cfg.roi_pool.pool_w
        self.feature_head = nn.Sequential (
            nn.Conv2d (in_channels = cfg.out_feature_num, out_channels = feature_num, kernel_size = (pool_h, pool_w), padding = 0),
            nn.ReLU (inplace = True),
            nn.Conv2d (in_channels = feature_num, out_channels = feature_num, kernel_size = 1, padding = 0),
            nn.ReLU (inplace = True)
        )
        self.label_head = nn.Conv2d (in_channels = feature_num, out_channels = class_num + 1, kernel_size = 1, padding = 0)
        self.bbox_head = nn.Conv2d (in_channels = feature_num, out_channels = 4 * (class_num + 1), kernel_size = 1, padding = 0)

        для m в self.modules ():
            если isinstance (m, nn.Conv2d):
                nn.init.normal_ (средний вес, стандартное значение = 0,01)
                nn.init.constant_ (m.bias, 0)

    def вперед (self, rois):

        features = self.feature_head (rois)
        label_pre = self.label_head (функции)
        label_pre = label_pre.view (label_pre.shape [: 2])
        bbox_pre = self.bbox_head (функции)
        bbox_pre = bbox_pre.view (bbox_pre.shape [: 2])

        вернуть label_pre, bbox_pre
  

Pace Взаимодействие для улучшения понимания

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

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

Сегодня я здесь, чтобы сказать вам, что замедлит . Благодаря закону Мура компьютеры стали в миллиард раз быстрее с тех пор, как я начал пользоваться компьютерами в 1974 году, а благодаря закону Нильсена скорость подключения к Интернету равна 1.В 2 миллиона раз быстрее, чем когда я впервые вышел в Интернет в 1984 году. Технический прогресс, да, но человеческий прогресс? Не так много. Мы часто видим, что желание пользователей спешить с пользовательскими интерфейсами ухудшает понимание и снижает вероятность успеха.

Медленное чтение

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

В среднем пользователи проводят на веб-странице достаточно времени, чтобы прочитать 28% ее слов.

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

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

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

Медленная навигация

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

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

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

Мы должны заставить пользователей делать то же самое.

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

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

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

Медленные виджеты

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

Допустим, у нас есть интернет-магазин, где продаются зеленые, желтые и синие футболки размеров S, M, L и XL. Замечательно, если мы сделаем навигацию достаточно медленной, чтобы пользователи могли найти страницу с футболкой. И будет здорово, если мы заставим пользователей читать достаточно медленно, чтобы понять, что это футболки разных цветов и размеров. Но поскольку пользователям все равно придется указывать их предпочтительный цвет и размер, все будет идти не так, как бы хорошо мы ни создавали страницу с информацией о футболках.Шанс найти правильное сочетание цвета и размера составляет всего 8%, если пользователи слишком спешат. 92% возврата из-за ошибочно заказанных футболок убьют любой бизнес.

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

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

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

Спецификация размера может выполняться еще медленнее, при этом соблюдается эвристика № 2 - соответствие между системой и реальным миром. Рекомендуемый виджет для изменения размера - это изображение, похожее на воздушный шарик, которое раздувается многократным нажатием кнопки с надписью Надуть .(Хотя пользовательское тестирование должно быть проведено, чтобы убедиться, что упрощенный словарь, такой как Сделать больше , будет более понятным.) Когда пользователь нажимает кнопку Надуть , контур рубашки становится все больше и больше, реалистично совпадая с рисунком. размер желаемой футболки. Пользователь просто перестанет нажимать Надуть в тот момент, когда контур воздушного шара будет выглядеть достаточно большим, чтобы соответствовать желаемому размеру футболки. (Если пользователь перескакивает и слишком сильно раздувает контур, команда сдува, похожая на булавку, «проткнет» воздушный шар и сбросит изображение до его наименьшего размера, с которого пользователь может снова начать надувание.Это должно быть достаточно медленным, чтобы в следующий раз научить пользователя быть более осторожным.)

Прелесть этой конструкции в том, что ее можно произвольно замедлять. Возможно, потребуется 5 кликов по кнопке надуть , прежде чем контур воздушного шара вырастет до следующего размера футболки. Или, может быть, нам потребуется 10 или даже 20. Правильное количество кликов можно определить с помощью простого A / B-теста.

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

(И между прочим: С Днем первоапрельского.)

Другие первоапрельские статьи

: статья Якоба Нильсена

Выдержка из главы 5 моей книги «Юзабилити-инжиниринг» , с 1993 г ​​.:

Основные советы относительно времени отклика были примерно одинаковы в течение тридцати лет [Miller 1968; Card et al. 1991]:

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

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

В случаях, когда компьютер не может обеспечить достаточно немедленную реакцию, пользователю следует предоставлять непрерывную обратную связь в виде индикатора процентов выполнения [Myers 1985]. Как правило, индикаторы выполнения в процентах следует использовать для операций, которые занимают более 10 секунд. Индикаторы прогресса имеют три основных преимущества: они убеждают пользователя, что система не разбилась, но работает над его или ее проблемой; они указывают приблизительно, как долго пользователь может ожидать ожидания, таким образом позволяя пользователю выполнять другие действия во время длительного ожидания; и они, наконец, предоставляют пользователю что-то, на что он может взглянуть, что делает ожидание менее болезненным.Это последнее преимущество не следует недооценивать, и это одна из причин для рекомендации графического индикатора выполнения вместо простого указания ожидаемого оставшегося времени в цифрах.

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

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

См. Также:
Статья о времени отклика веб-сайта и способах его улучшения.

Время отклика веб-приложения

Обновление добавлено в 2014 г .: Мне продолжают приходить подобные вопросы, поэтому я решил ответить на них здесь.

Q: «Вы много раз упоминали, что время отклика важно, и существует множество инструментов для измерения времени отклика, но каково приемлемое время отклика веб-приложения? Какова терпимость пользователя, а не для покупок, а для интерактивного приложения? "

A: Хотелось бы, чтобы мы искоренили термин «веб-приложение», потому что он отвлекает от реальной проблемы, которая связана с дизайном пользовательского интерфейса приложения (у нас есть несколько полнодневных курсов по этой теме).У нас нет специальных рекомендаций для приложений, реализованных на C ++, по сравнению с приложениями, реализованными на JavaScript. Основные рекомендации по удобству использования одинаковы, независимо от реализации, поскольку мы обсуждаем взаимодействие с пользователем, а не кодирование.

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

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

1 секунда: Предел для пользователей, которые считают, что они свободно перемещаются по командному пространству, не дожидаясь ненужного ожидания компьютера. Задержка в 0,2–1,0 секунды означает, что пользователи замечают задержку и, таким образом, чувствуют, что компьютер «работает» над командой, в отличие от того, что команда является прямым следствием действий пользователей. Пример: если сортировка таблицы в соответствии с выбранным столбцом не может быть выполнена за 0,1 секунды, это, безусловно, должно быть выполнено за 1 секунду, иначе пользователи почувствуют, что пользовательский интерфейс вялый, и потеряют ощущение «потока» при выполнении. их задача.В случае задержек более 1 секунды сообщите пользователю, что компьютер работает над проблемой, например, изменяя форму курсора.

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

См. Также:
Статья о временных масштабах в пользовательском опыте.

Список литературы

Кард, С. К., Робертсон, Г. Г., и Маккинли, Дж. Д. (1991). Визуализатор информации: информационное рабочее пространство. Proc. ACM CHI'91 Conf. (Новый Орлеан, Луизиана, 28 апреля - 2 мая), 181–188.

Миллер Р. Б. (1968). Время отклика в диалоговых транзакциях человек-компьютер. Proc. AFIPS Fall Joint Computer Conference Vol. 33 , 267-277.

Майерс, Б.А. (1985). Важность индикаторов прогресса в процентах для взаимодействия компьютера с человеком. Proc. ACM CHI'85 Conf. (Сан-Франциско, Калифорния, 14-18 апреля), 11-17.

Медленная сходимость - обзор

6 УЛУЧШЕННЫЙ ПРОЦЕСС ОБУЧЕНИЯ

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

Первоначально для сетевого обучения была принята постоянная скорость обучения на всех циклах обучения; то есть предполагалось, что скорость не меняется в течение всего процесса обучения сети. В улучшенных методах обучения переменная скорость, т. Е. была предложена адаптивная скорость обучения , в основном основанная на теории адаптивных фильтров [70].

Как правило, скорость обучения сети сильно зависит от символа решаемой проблемы и от внутренних сетевых факторов, таких как архитектура сети, функции активации и используемые соединения [16].Например, обучение сети на большом количестве классов шаблонов занимает больше времени, чем обучение сети на меньшем количестве классов шаблонов. Поскольку характер решаемой проблемы не может быть изменен таким образом, чтобы ускорить процесс обучения, необходимо соответствующим образом выбрать внутренние сетевые факторы и используемый закон обучения [77, 78].

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

J (W) = 12∑k = 1NeT (k) e (k)

для обновления весовых параметров сети, где N - количество тренировочных шаблонов, e ( k ) = Y _k - Y ( X _k , W ) - это ошибка вывода сети, Y ( X _k , W ) - вектор вывода сети, а W - строка вектор сетевых параметров.Обновление выполняется с использованием соотношения

Wnew = W − η∂J (W) ∂W

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

∂J (W) ∂W = 12∑k = 1N∂eT (k) e (k) ∂W

Вышеупомянутое обновление, основанное на векторе градиента J ( W ) перемещает вектор весовых параметров W в направлении наискорейшего спуска J ( W ), так что чем больше норма градиента ∂eT ( k) e (k) / ∂W, тем сильнее его влияние на размер шага перемещения вектора параметров W .Однако это не обязательно оптимально. Например, было бы лучше, если бы выполнялось следующее правило: чем больше ошибка e ^T ( k ) e ( k ), тем сильнее влияние ее градиента. ∂eT (k) e (k) / ∂W от размера шага перемещения вектора параметров W . Однако из того, что если для ошибки e ^T ( k ) e ( k ), то соотношение

eT (i) e (i)> eT (j) e (j)

, не гарантируется, что соотношение

‖∂eT (i) e (i) ∂W‖> ‖∂eT (j) e (j) ∂W‖

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

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

Δf (Xi, Xj) = f (Xi) −f (Xj)

, а скорость изменения выхода для нейронной сети как

ΔY (i, j) = ΔY (Xi, Xj, W) = Y (Xi, W) −Y (Xj, W)

, так что модифицированный индекс ошибки определяется как

E (W) = 12∑k = 1NeT (k) e (k) + μ12∑k = 1N∑h = kN (Δf (k, h) −ΔY (k, h)) T (Δf (k, h) −ΔY (k, h))

с e ( k ) = Y _k - Y ( X _k , W ).Здесь μ - параметр, который оценивает влияние второго члена в приведенном выше уравнении на измерение расширенной ошибки. Как правило, μ> 1 и, следовательно, модифицированный закон обновления дельты с расширенным измерением ошибки принимает вид

Wnew = W − η∂E (W) ∂W

Теперь, учитывая, что

e * (k) = Yk − Yn (Xk, W)

мы можем записать

e * (k, h) = Δf (Wk, Xh, W) −ΔY (Xk, Xh, W) = e * (k) −e * ( h)

и

(Δf (k, h) −ΔY (k, h)) T (Δf (k, h) −ΔY (k, h) = e * T (k, h) e * (k , h)

, так что новый индекс ошибки E ( W ) можно выразить как

E (W) = 12∑k = 1NeT (k) e (k) + μ12∑k = 1N∑h = kNe * T (k, h) e * T (k, h) e * (k, h)

Соответственно градиент ∂ E ( W ) / ∂ W принимает форма

∂E (W) ∂W = ∑k = 1NeT (k) ∂e (k) ∂W + μ∑k = 1N∑h = kN (e (k) −e (h)) T (∂e (k) ∂W − ∂e (h) ∂W)

, которое может быть преобразовано в

∂E (W) ∂W = ∑k = 1N (e (k) + μN (e (k) −e˜ )) T∂e (k) ∂W

, где e˜ = (1 / N) ∑k = 1Ne (k) - среднее значение ошибки e ( k ) на N данные обучения сети.

Наконец, модифицированный закон обновления принимает вид

Wnew = W − η∑k = 1N (e (k) + μN (e (k) −e˜)) ∂e (k) ∂W

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

−η∑k = 1Ne (k) ∂e (k) ∂W и −η∑k = 1NμN (e (k) −e˜) T∂ e (k) ∂W

второй член представляет собой градиент индекса ошибки

Em (W) = μN12∑k = 1N (e (k) −e˜) T (e (k) −e˜)

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

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

y (k) = y2 (k − 1) 1 + y2 (k − 1) + u2 (k − 1)

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

J = ∑k = nknk + 100 | e (k) | 2

, где период обучения n _k = 1, 2, 3,…, имея только один скрытый слой с 6 нейронов на структуре 2–6–1 сеть обучалась как со стандартным, так и с новым индексом ошибки обучения. Его обучающие характеристики показаны на Рис. 19 и Рис. 20, где N - количество обучающих данных, которые были взяты на каждом этапе обучения. Входные данные для обучения системы и ( k - 1) были случайно выбраны в диапазоне [0, 1].

РИСУНОК 19. Эффективность обучения со стандартным алгоритмом, (a) η = 0,05 и N = 4. (b) η = 0,02, и N = 30.

РИСУНОК 20. Эффективность обучения с новым алгоритмом, (а) η = 0,02, μ = 9 и N = 4. (б) η = 0,001, μ = 10 и N = 30.

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

•

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

•

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

•

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