Эта страница была переведа с помощью Cloud Translation API.
Switch to English

Федеративное обучение

обзор

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

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

  • Модели . Классы и вспомогательные функции, которые позволяют вам обернуть ваши существующие модели для использования с TFF. Обтекание модели может быть простым вызовом отдельной функции обтекания (например, tff.learning.from_keras_model ) или определением подкласса интерфейса tff.learning.Model для полной настройки.

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

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

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

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

модели

Архитектурные предположения

Сериализация

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

Вы можете (и должны) по-прежнему разрабатывать свой код TF, следуя последним рекомендациям, таким как использование активного режима. Однако окончательный код должен быть сериализуемым (например, может быть упакован как tf.function для кода режима tf.function ). Это гарантирует, что любое состояние Python или поток управления, необходимый во время выполнения, может быть сериализован (возможно, с помощью Autograph ).

В настоящее время TensorFlow не полностью поддерживает сериализацию и десериализацию активного режима TensorFlow. Таким образом, сериализация в TFF в настоящее время следует шаблону TF 1.0, где весь код должен быть создан внутри tf.Graph которым управляет TFF. Это означает, что в настоящее время TFF не может использовать уже построенную модель; вместо этого логика определения модели упакована в функцию без аргументов, которая возвращает tff.learning.Model . Затем эта функция вызывается TFF, чтобы обеспечить сериализацию всех компонентов модели. Кроме того, будучи строго типизированной средой, TFF потребует немного дополнительных метаданных , таких как спецификация типа ввода вашей модели.

агрегирование

Мы настоятельно рекомендуем большинству пользователей создавать модели с использованием Keras, см. Раздел « Конвертеры для Keras » ниже. Эти оболочки обрабатывают обновления модели, а также любые метрики, определенные для модели автоматически. Тем не менее, все еще может быть полезно понять, как агрегация обрабатывается для общего tff.learning.Model .

В федеративном обучении всегда есть как минимум два уровня агрегации: локальная агрегация на устройстве и агрегация между устройствами (или федерация):

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

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

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

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

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

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

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

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

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

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

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

    • TFF запускает протокол распределенной агрегации, чтобы накапливать и агрегировать параметры модели и локально экспортируемые показатели по всей системе. Эта логика выражается декларативным способом с использованием собственного федеративного языка вычислений TFF (не в TensorFlow) в модели federated_output_computation. модели federated_output_computation. См. Учебник по пользовательским алгоритмам для получения дополнительной информации об API агрегирования.

Абстрактные интерфейсы

Этот базовый интерфейс конструктора + метаданных представлен интерфейсом tff.learning.Model следующим образом:

  • forward_pass constructor, forward_pass и report_local_outputs должны конструировать переменные модели, прямой проход и статистику, о которой вы хотите сообщить, соответственно. TensorFlow, созданный этими методами, должен быть сериализуемым, как обсуждалось выше.

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

Кроме того, абстрактный интерфейс tff.learning.Model предоставляет свойство federated_output_computation , что вместе с report_local_outputs свойство упоминалось ранее, позволяет контролировать процесс объединения итоговой статистики.

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

Конвертеры для Keras

Почти вся информация, которая требуется для TFF, может быть получена путем вызова интерфейсов tf.keras , поэтому, если у вас есть модель tff.learning.from_keras_model , вы можете положиться на tff.learning.from_keras_model для создания tff.learning.Model .

Обратите внимание, что TFF все еще хочет, чтобы вы предоставили конструктор - функцию модели без аргументов, такую ​​как следующее:

 def model_fn():
  keras_model = ...
  return tff.learning.from_keras_model(keras_model, sample_batch, loss=...)
 

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

Использование оболочек Keras иллюстрируется в наших уроках классификации изображений и генерации текста .

Построители федеративных вычислений

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

Архитектурные предположения

выполнение

Есть два разных этапа запуска федеративных вычислений.

  • Компилировать : TFF сначала компилирует алгоритмы федеративного обучения в абстрактное сериализованное представление всего распределенного вычисления. Это происходит, когда происходит сериализация TensorFlow, но могут выполняться и другие преобразования для поддержки более эффективного выполнения. Мы ссылаемся на сериализованное представление, испускаемое компилятором как объединенное вычисление .

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

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

  • Сериализованная форма кода модели, а также дополнительный код TensorFlow, созданный инфраструктурой Federated Learning для управления циклом обучения / оценки модели (например, создание оптимизаторов, применение обновлений модели, итерации по tf.data.Dataset s и вычислительные метрики, и применение агрегированного обновления на сервере, чтобы назвать несколько).

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

Федеративные вычисления, представленные в этой сериализованной форме, выражаются на независимом от платформы внутреннем языке, отличном от Python, но для использования API федеративного обучения вам не нужно заботиться о деталях этого представления. Вычисления представлены в вашем коде Python как объекты типа tff.Computation , которые по большей части вы можете рассматривать как непрозрачные callable tff.Computation Python.

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

Состояние моделирования

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

Поскольку TFF является функциональным, процессы с сохранением состояния моделируются в TFF как вычисления, которые принимают текущее состояние в качестве входных данных, а затем предоставляют обновленное состояние в качестве выходных данных. Чтобы полностью определить процесс с состоянием, нужно также указать, откуда исходит исходное состояние (иначе мы не сможем запустить процесс). Это tff.templates.IterativeProcess в определении вспомогательного класса tff.templates.IterativeProcess , где 2 свойства initialize и next соответствуют инициализации и итерации, соответственно.

Доступные строители

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

Datasets

Архитектурные предположения

Выбор клиента

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

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

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

 trainer = tff.learning.build_federated_averaging_process(...)
state = trainer.initialize()
federated_training_data = ...

def sample(federate_data):
  return ...

while True:
  data_for_this_round = sample(federated_training_data)
  state, metrics = trainer.next(state, data_for_this_round)
 

Чтобы облегчить это, при использовании TFF в симуляциях федеративные данные принимаются как list Python с одним элементом на каждое участвующее клиентское устройство для представления локального tf.data.Dataset этого устройства.

Абстрактные интерфейсы

Для стандартизации работы с имитированными федеративными наборами данных TFF предоставляет абстрактный интерфейс tff.simulation.ClientData , который позволяет перечислять набор клиентов и создавать набор tf.data.Dataset , содержащий данные конкретного клиента. Эти tf.data.Dataset могут быть переданы непосредственно в качестве входных данных для сгенерированных интегрированных вычислений в активном режиме.

Следует отметить, что возможность доступа к идентификаторам клиентов - это функция, которая предоставляется только наборами данных для использования в симуляциях, где может потребоваться возможность обучения данным из определенных подмножеств клиентов (например, для моделирования суточной доступности различных типы клиентов). Скомпилированные вычисления и базовая среда выполнения не предполагают какого-либо представления об идентичности клиента. Как только данные из определенного подмножества клиентов были выбраны в качестве входных данных, например, при вызове tff.templates.IterativeProcess.next , идентификаторы клиентов больше не появляются в нем.

Доступные наборы данных

Мы tff.simulation.datasets пространство имен tff.simulation.datasets для наборов данных, которые реализуют интерфейс tff.simulation.ClientData для использования в симуляциях, и tff.simulation.ClientData в него 2 набора данных для поддержки учебников по классификации изображений и генерации текста . Мы хотели бы призвать вас предоставить свои собственные наборы данных для платформы.