Помогают защитить Большой Барьерный Риф с TensorFlow на Kaggle Присоединяйтесь вызов

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

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

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

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

Обзор

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

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

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

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

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

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

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

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

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

Язык

Интерфейс Python

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

В частности, ПТФ обеспечивает Python функции декораторы , такие как tff.federated_computation , что след тела украшенных функций и производить сериализованы представления федеративного логики вычислений на языке ПТФ в. Функция украшено 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 граф. Albeit код технически выражается в 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 может быть строже их (статический) обработки форм , чем TensorFlow. Например, ПТФ в обращается с системой типов тензорным с неизвестным рангом, ASSIGNABLE из любого другого тензора же dtype , но не назначаемые для любого тензора с фиксированным рангом. Эта обработка предотвращает определенные сбои во время выполнения (например, попытку изменить форму тензора неизвестного ранга в форму с неправильным числом элементов) за счет большей строгости в том, какие вычисления TFF принимает как действительные.

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

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

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

  • Названные типы кортежей ( tff.StructType ). Это путь ПТФА о построении кортежей и словарь-подобные структурам, имеющей заданное число элементов с типами конкретными, названным или неназванными. Важно отметить, что концепция именованных кортежей 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 ). ПТФ является функциональной основой программирования, с функциями , рассматриваемыми как значения первого класса . Функции имеют не более одного аргумента и только один результат.

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

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

  • Тип размещения. Этот тип еще не подвергается в общественном API , кроме как в виде 2 -х литералов 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 представляет собой федеративное значение , которое состоит из множества потенциально различных целых чисел, по одному на клиентское устройство. Обратите внимание , что мы говорим о едином федеративном ценности как охватывающие несколько элементов данных , которые появляются в нескольких местах по всей сети. Один из способов думать об этом как своем роде тензор с «сетевым» измерением, хотя эта аналогия не является совершенной , потому что ПТФ не допускает произвольный доступ трехсторонний членов федеративного значения.

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

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

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

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

Он предоставляет следующие программные абстракции, которые в настоящее время доступны в общедоступном 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)
    
  • Intrinsics или федеративные операторы ( 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 .