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

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

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

Для подробного ознакомления с 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 использует внутренний язык для представления федеративных вычислений, синтаксис которых определяется сериализуемым представлением в computation.proto . Тем не менее, пользователям FC API обычно не нужно напрямую взаимодействовать с этим языком. Скорее, мы предоставляем Python API (пространство имен tff ), которое оборачивает его как способ определения вычислений.

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

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

 @tff.federated_computation(tff.FederatedType(tf.float32, tff.CLIENTS))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)
 

Читатели, знакомые с tf.add tf.reduce_sum найдут этот подход аналогичным написанию кода 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.

    Компактная запись для тензорных типов - dtype или dtype[shape] . Например, int32 и int32[10] являются типами целых чисел и векторов int соответственно.

  • Типы последовательностей ( tff.SequenceType ). Это абстрактный эквивалент TFF конкретной концепции tf.data.Dataset для 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 .

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

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

  • Федеративные типы ( 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 фигурные скобки, это означает, что all_equal бит all_equal , т. 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.FederatedType(tf.float32, tff.CLIENTS))
def get_average_temperature(sensor_readings):
  return tff.federated_mean(sensor_readings)
 
  • Размещение литералов . На данный момент только tff.SERVER и tff.CLIENTS позволяют определять простые вычисления клиент-сервер.

  • __call__ функций ( __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 .