Посетите симпозиум «Женщины в машинном обучении» 7 декабря Зарегистрируйтесь сейчас

Федеративное ядро

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

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

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

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

Обзор

Цели, предполагаемое использование и область применения

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

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

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

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

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

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

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

Следовательно, в то время как распределенные платформы общего назначения могут предлагать такие операции, как отправка и получение , в качестве строительных блоков, FC предоставляет такие строительные блоки, как tff.federated_sum , tff.federated_reduce или tff.federated_broadcast , которые инкапсулируют простые распределенные протоколы.

Язык

Интерфейс Python

TFF использует внутренний язык для представления федеративных вычислений, синтаксис которого определяется сериализуемым представлением в computing.proto . Однако пользователям FC API, как правило, не нужно напрямую взаимодействовать с этим языком. Вместо этого мы предоставляем Python API (пространство имен tff ), который охватывает его как способ определения вычислений.

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

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

@tff.federated_computation(tff.type_at_clients(tf.float32))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)

Читатели, знакомые с TensorFlow без энтузиазма, сочтут этот подход аналогом написания кода Python, использующего такие функции, как tf.add или tf.reduce_sum , в разделе кода Python, определяющем граф TensorFlow. Хотя код технически выражен на Python, его целью является создание сериализуемого представления tf.Graph внизу, и именно граф, а не код Python, выполняется внутри среды выполнения TensorFlow. Точно так же можно думать о tff.federated_mean как о вставке объединенной операции в объединенное вычисление, представленное get_average_temperature .

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

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

Система типов

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

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

  • Типы тензоров ( tff.TensorType ). Как и в TensorFlow, у них есть dtype и shape . Единственное отличие состоит в том, что объекты этого типа не ограничиваются экземплярами tf.Tensor в Python, которые представляют выходные данные операций TensorFlow в графе TensorFlow, но могут также включать единицы данных, которые могут быть созданы, например, как выходные данные распределенного протокол агрегации. Таким образом, тензорный тип TFF — это просто абстрактная версия конкретного физического представления такого типа в Python или TensorFlow.

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

    Компактное обозначение тензорных типов — dtype или dtype[shape] . Например, int32 и int32[10] — это типы целых чисел и векторов int соответственно.

  • Типы последовательностей ( tff.SequenceType ). Это абстрактный эквивалент TFF конкретной концепции tf.data.Dataset s. Элементы последовательностей могут использоваться последовательно и могут включать сложные типы.

    Компактное представление типов последовательностей — T* , где T — тип элементов. Например int32* представляет целочисленную последовательность.

  • Именованные типы кортежей ( tff.StructType ). Это способ TFF построения кортежей и структур, подобных словарям, которые имеют предопределенное количество элементов с определенными типами, именованными или безымянными. Важно отметить, что концепция именованных кортежей в TFF охватывает абстрактный эквивалент кортежей аргументов Python, то есть наборы элементов, некоторые из которых, но не все, именованы, а некоторые являются позиционными.

    Компактная запись для именованных кортежей — <n_1=T_1, ..., n_k=T_k> , где n_k — необязательные имена элементов, а T_k — типы элементов. Например, <int32,int32> — это компактная запись для пары безымянных целых чисел, а <X=float32,Y=float32> — это компактная запись для пары чисел с плавающей запятой с именами X и Y , которые могут представлять точку на плоскости. . Кортежи могут быть вложенными, а также смешиваться с другими типами, например, <X=float32,Y=float32>* будет компактной записью для последовательности точек.

  • Типы функций ( tff.FunctionType ). TFF — это инфраструктура функционального программирования, в которой функции рассматриваются как первоклассные значения . Функции имеют не более одного аргумента и ровно один результат.

    Компактная запись для функций: (T -> U) , где T — тип аргумента, а U — тип результата, или ( -> U) , если нет аргумента (хотя функции без аргументов являются вырожденными). концепция, которая существует в основном только на уровне Python). Например (int32* -> int32) — это нотация для типа функций, которые сводят целочисленную последовательность к одному целочисленному значению.

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

  • Тип размещения . Этот тип еще не представлен в общедоступном API, кроме как в форме двух литералов tff.SERVER и tff.CLIENTS , которые можно рассматривать как константы этого типа. Однако он используется для внутренних целей и будет представлен в общедоступном API в будущих выпусках. Компактное представление этого типа — placement .

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

    Основной целью определения понятия размещения является создание основы для определения федеративных типов .

  • Федеративные типы ( tff.FederatedType ). Значение федеративного типа — это значение, размещенное группой участников системы, определенной определенным размещением (например, tff.SERVER или tff.CLIENTS ). Федеративный тип определяется значением размещения (таким образом, это зависимый тип ), типом составляющих членов (какой контент каждый из участников размещает локально) и дополнительным битом all_equal , который указывает, все ли участники находятся локально. размещение одного и того же элемента.

    Компактная запись для федеративного типа значений, которые включают в себя элементы (элементы-члены) типа T , каждый из которых размещается в группе (размещении) G , представляет собой T@G или {T}@G с установленным или не установленным битом all_equal соответственно.

    Например:

    • {int32}@CLIENTS представляет объединенное значение , состоящее из набора потенциально различных целых чисел, по одному на клиентское устройство. Обратите внимание, что мы говорим об одном федеративном значении как охватывающем несколько элементов данных, которые появляются в нескольких местах в сети. Один из способов представить это как своего рода тензор с «сетевым» измерением, хотя эта аналогия не идеальна, поскольку TFF не разрешает произвольный доступ к элементам, составляющим федеративное значение.

    • {<X=float32,Y=float32>*}@CLIENTS представляет объединенный набор данных , значение, состоящее из нескольких последовательностей координат XY , по одной последовательности на клиентское устройство.

    • <weights=float32[10,5],bias=float32[5]>@SERVER представляет именованный кортеж тензоров веса и смещения на сервере. Поскольку мы опустили фигурные скобки, это означает, что бит all_equal установлен, т. е. существует только один кортеж (независимо от того, сколько серверных реплик может быть в кластере, содержащем это значение).

Строительные блоки

Язык Federated Core представляет собой форму лямбда-исчисления с несколькими дополнительными элементами.

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

  • Вычисления TensorFlow ( tff.tf_computation ). Это разделы кода TensorFlow, обернутые как повторно используемые компоненты в TFF с помощью декоратора tff.tf_computation . У них всегда есть функциональные типы, и, в отличие от функций в TensorFlow, они могут принимать структурированные параметры или возвращать структурированные результаты типа последовательности.

    Вот один пример, вычисление TF типа (int32* -> int) , которое использует оператор tf.data.Dataset.reduce для вычисления суммы целых чисел:

    @tff.tf_computation(tff.SequenceType(tf.int32))
    def add_up_integers(x):
      return x.reduce(np.int32(0), lambda x, y: x + y)
    
  • Внутренние или объединенные операторы ( tff.federated_... ). Это библиотека функций, таких как tff.federated_sum или tff.federated_broadcast , которые составляют основную часть FC API, большинство из которых представляют операторы распределенной связи для использования с TFF.

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

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

    Например, tff.federated_broadcast можно рассматривать как шаблонный оператор функционального типа T@SERVER -> T@CLIENTS .

  • Лямбда-выражения ( tff.federated_computation ). Лямбда-выражение в TFF эквивалентно lambda -выражению или def в Python; он состоит из имени параметра и тела (выражения), содержащего ссылки на этот параметр.

    В коде Python их можно создать, украсив функции Python с помощью tff.federated_computation и определив аргумент.

    Вот пример лямбда-выражения, о котором мы уже упоминали ранее:

    @tff.federated_computation(tff.type_at_clients(tf.float32))
    def get_average_temperature(sensor_readings):
      return tff.federated_mean(sensor_readings)
    
  • Литералы размещения . На данный момент только tff.SERVER и tff.CLIENTS позволяют определять простые вычисления клиент-сервер.

  • Вызовы функций ( __call__ ). Все, что имеет функциональный тип, может быть вызвано с использованием стандартного синтаксиса Python __call__ . Вызов — это выражение, тип которого совпадает с типом результата вызываемой функции.

    Например:

    • add_up_integers(x) представляет собой вызов вычисления TensorFlow, определенного ранее для аргумента x . Тип этого выражения — int32 .

    • tff.federated_mean(sensor_readings) представляет собой вызов оператора федеративного усреднения для sensor_readings . Тип этого выражения — float32@SERVER (при условии контекста из приведенного выше примера).

  • Формирование кортежей и выделение их элементов. Выражения Python в форме [x, y] , x[y] или xy , которые появляются в телах функций, украшенных tff.federated_computation .