Alink's Talk (12): Общий дизайн алгоритма онлайн-обучения FTRL

машинное обучение

0x00 сводка

Alink — это платформа алгоритмов машинного обучения нового поколения, разработанная Alibaba на основе вычислительного движка реального времени Flink, и первая в отрасли платформа машинного обучения, которая поддерживает как пакетные, так и потоковые алгоритмы. В этой и последующих статьях будет рассказано, как алгоритм онлайн-обучения FTRL реализован в Alink, и мы надеемся, что они будут полезны всем.

0x01 Концепция

Поскольку Alink реализует LR + FTRL, нам нужно начать с логистической регрессии LR.

1.1 Логистическая регрессия

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

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

1.1.1 Процесс получения

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

Итак, давайте сделаем две вещи:

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

Во-первых, мы используем функцию sigmod дляФункция регрессии для изгиба.

Для задач бинарной классификации 1 представляет собой положительный пример, а 0 представляет отрицательный пример. Логистическая регрессия заключается в поиске гипотетической функции h_θ(x) = g(θ, x) на основе выходных данных линейной функции, предсказывающей фактическое значение, которое отображает фактическое значение в диапазоне от 0 до 1. В логистической регрессии в качестве функции активации выбирается логарифмическая функция, а логарифмическая функция является важным представителем сигмовидной функции (функции формы S).

Во-вторых, мы выбрали порог 0,5.

Это означает, что когда я выбираю пороговое значение равным 0,5, тогда все, что меньше 0,5, должно быть отрицательным примером, даже если оно равно 0,49. В этот момент должны ли мы быть точными в оценке образца как отрицательного примера? Не обязательно, потому что вероятность того, что это положительный пример, все еще составляет 49%. Однако, даже если вероятность того, что это положительный пример, равна 0,1, если мы случайным образом выберем 1w выборок для прогнозирования, все равно будет около 100 ошибок в предсказании того, что это отрицательный пример, а на самом деле это положительный пример. Независимо от того, как вы выберете, ошибка будет существовать, поэтому мы выбираем порог, чтобы выбрать приемлемую степень ошибки.

1.1.2 Решение

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

h(z)=11+e−x,z=WTXh(z) = \frac{1}{1+e^{-x}},z = W^TX

Как решить логистическую регрессию? То есть, как найти набор W, который может сделать так, чтобы все h(z) предсказывали максимальную вероятность того, что они будут правильными.

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

Градиентный спуск заключается в поиске направления спуска через первую производную J(w) по w и итеративном обновлении параметров.

Основная идея метода Ньютона состоит в том, чтобы выполнить разложение Тейлора второго порядка J(w) в окрестности существующей минимальной оценки точки, а затем найти следующую оценку минимальной точки.

1.1.3 Стохастический градиентный спуск

Когда N в выборочных данных велико, обычно используется метод стохастического градиентного спуска, и алгоритм выглядит следующим образом:

while {
    for i in range(0,m):
        w_j = w_j + a * g_j
}

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

  1. На каждой итерации определенная доля выборок случайным образом отбирается в качестве расчетных выборок текущей итерации.
  2. Для каждой выборки в расчетных выборках расчетные градиенты различных признаков рассчитываются отдельно.
  3. С помощью функции агрегирования градиенты признаков всех рассчитанных выборок накапливаются для получения кумулятивного градиента и потери каждого признака.
  4. Наконец, параметры обновляются в соответствии с последним градиентом и предыдущими параметрами.
  5. Рассчитайте значение ошибки функции потерь в соответствии с обновленными параметрами.Если значение ошибки функции потерь достигает допустимого диапазона, то остановите итерацию, в противном случае повторите шаг 1

1.2 Параллельные вычисления LR

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

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

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

Если матрица выборки разбита на строки, собственные векторы выборки распределены по разным вычислительным узлам, и каждый вычислительный узел выполняет точечное умножение и вычисление суммы выборок, за которые он отвечает, а затем объединяет результаты вычислений, то параллельно по ряду». LR».

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

1.3 Традиционное машинное обучение

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

  1. Слияние данных для получения обучающих и оценочных наборов данных.
  2. Особенности инженерии.
  3. Построить модели, такие как LR, FM и т. д.
  4. Обучите модель, чтобы получить оптимальное решение.
  5. Оцените производительность модели.
  6. Сохраните модель и обучите ее онлайн с помощью обученной действительной модели.

В этом подходе есть два основных узких места:

  1. Цикл обновления моделей является медленным и не может эффективно отражать онлайн-изменения. Самый быстрый уровень часа обычно является выходным уровнем или даже еженедельным уровнем.
  2. Параметров модели немного, а эффект прогнозирования плохой; когда параметры модели прогнозируются в режиме онлайн, требуется большой объем памяти, а число запросов в секунду не может быть гарантировано.

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

Вообще говоря, есть два решения этих проблем:

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

1.4 Онлайн-обучение

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

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

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

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

Характеристики алгоритма онлайн-обучения таковы: каждый раз, когда поступает обучающая выборка, модель повторяется один раз с потерями и градиентом, генерируемыми выборкой, и обучение выполняется одно за другим, поэтому он может обрабатывать большие объемы данных и онлайн-обучение. обучение. Обычно используются онлайн-градиентный спуск (OGD) и стохастический градиентный спуск (SGD) **Поскольку направление каждого шага не является глобально оптимальным, общее представление будет выглядеть как случайный маршрут спуска.

1.5 FTRL

FTR является предшественником FTRL, Идея состоит в том, чтобы найти параметр, который каждый раз минимизирует сумму функций потерь всех предыдущих выборок.

FTRL, то есть Follow The Regularized Leader, был создан в нескольких предыдущих работах.Главной отправной точкой является улучшение разреженности и соблюдение требований к точности. Основываясь на цели оптимизации FTL, FTRL добавляет регуляризацию для предотвращения переобучения.

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

Функция суррогатных потерь должна удовлетворять следующим условиям:

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

Чтобы измерить разрыв между двумя решениями в условии 2, вводится понятие регрессии.

1.5.1 regret & sparsity

Для онлайн-обучения в целом мы стремимся решить две проблемы:Уменьшите сожаление и улучшите разреженность. Что определяется как сожаление:

Regret=∑t=1Tlt(wt)−minw∑t=1Tlt(w)Сожаление=\sum_{t=1}^Tl_t(w_t)−min_w\sum_{t=1}^Tl_t(w)

где t — это t-я итерация из общего числа T раундов, ℓt — функция потерь, а w — параметр, который необходимо изучить. Сожаление представляет собой разрыв потерь между «решением, полученным прокси-функцией» и «решением, полученным реальной функцией потерь».

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

Теоретически можно показать, что если алгоритм онлайн-обучения может гарантировать, что его сожаление является сублинейной функцией от t, то:

lim⁡t→∞Regret(t)t=0\lim_{t→∞}\frac{Сожаление(t)}{t}=0

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

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

1.5.2 Псевдокод для FTRL

Per-Coordinate означает, что FTRL обучается и обновляется отдельно для каждого измерения w, и каждое измерение использует разную скорость обучения, которая является элементом перед lamda2 в приведенном выше коде. По сравнению с использованием единой скорости обучения для всех размерностей признаков w этот метод учитывает неравномерное распределение обучающих выборок по разным признакам Если имеется несколько обучающих выборок, содержащих признаки определенной размерности w, каждая выборка очень ценна. , тогда скорость обучения, соответствующая размерности признака, может поддерживать относительно большое значение в одиночку, и каждый раз, когда приходит образец, содержащий этот признак, он может делать большой шаг вперед по градиенту образца, не заставляя его продвигаться вперед по другому признаку. размеры быть последовательными.

1.5.3 Краткое понимание

Давайте в следующий раз взглянем на формулу обновления веса функции, увеличим понимание (лично мне кажется, что это объяснение относительно легко понять):

в формулепервый пункт- оценка вклада в функцию потерь,второй разделОн заключается в том, чтобы контролировать w (то есть модель), чтобы не изменять слишком много на каждой итерации,третий пунктПредставляет канонический L1 (получает разреженные решения).

0x02 Образец кода

Мы используем официальный образец кода Alink. Мы можем видеть примерно разделить на несколько частей:

Как вы, наверное, видите, я заранее проделал большую работу, чтобы проанализировать FTRL...

public class FTRLExample {

    public static void main(String[] args) throws Exception {
        ......
        // setup feature engineering pipeline
        Pipeline featurePipeline = new Pipeline()
                .add(
                        new StandardScaler() // 标准缩放
                                .setSelectedCols(numericalColNames)
                )
                .add(
                        new FeatureHasher() // 特征哈希
                                .setSelectedCols(selectedColNames)
                                .setCategoricalCols(categoryColNames)
                                .setOutputCol(vecColName)
                                .setNumFeatures(numHashFeatures)
                );
        // 构建特征工程流水线
        // fit feature pipeline model
        PipelineModel featurePipelineModel = featurePipeline.fit(trainBatchData);
      
        // prepare stream train data
        CsvSourceStreamOp data = new CsvSourceStreamOp()
                .setFilePath("http://alink-release.oss-cn-beijing.aliyuncs.com/data-files/avazu-ctr-train-8M.csv")
                .setSchemaStr(schemaStr)
                .setIgnoreFirstLine(true);
      
        // 对于流数据源进行实时切分得到原始训练数据和原始预测数据
        // split stream to train and eval data
        SplitStreamOp splitter = new SplitStreamOp().setFraction(0.5).linkFrom(data);
      
        // 训练出一个逻辑回归模型作为FTRL算法的初始模型，这是为了系统冷启动的需要。
        // train initial batch model
        LogisticRegressionTrainBatchOp lr = new LogisticRegressionTrainBatchOp()
                .setVectorCol(vecColName)
                .setLabelCol(labelColName)
                .setWithIntercept(true)
                .setMaxIter(10);
        BatchOperator<?> initModel = featurePipelineModel.transform(trainBatchData).link(lr);

        // 在初始模型基础上进行FTRL在线训练
        // ftrl train
        FtrlTrainStreamOp model = new FtrlTrainStreamOp(initModel)
                .setVectorCol(vecColName)
                .setLabelCol(labelColName)
                .setWithIntercept(true)
                .setAlpha(0.1)
                .setBeta(0.1)
                .setL1(0.01)
                .setL2(0.01)
                .setTimeInterval(10)
                .setVectorSize(numHashFeatures)
                .linkFrom(featurePipelineModel.transform(splitter));
      
        // 在FTRL在线模型的基础上，连接预测数据进行预测
        // ftrl predict
        FtrlPredictStreamOp predictResult = new FtrlPredictStreamOp(initModel)
                .setVectorCol(vecColName)
                .setPredictionCol("pred")
                .setReservedCols(new String[]{labelColName})
                .setPredictionDetailCol("details")
                .linkFrom(model, featurePipelineModel.transform(splitter.getSideOutput(0)));
      
        // 对预测结果流进行评估
        // ftrl eval
        predictResult
                .link(
                        new EvalBinaryClassStreamOp()
                                .setLabelCol(labelColName)
                                .setPredictionCol("pred")
                                .setPredictionDetailCol("details")
                                .setTimeInterval(10)
                )
                .link(
                        new JsonValueStreamOp()
                                .setSelectedCol("Data")
                                .setReservedCols(new String[]{"Statistics"})
                                .setOutputCols(new String[]{"Accuracy", "AUC", "ConfusionMatrix"})
                                .setJsonPath(new String[]{"$.Accuracy", "$.AUC", "$.ConfusionMatrix"})
                )
                .print();
      
        StreamOperator.execute();
    }
}

0x03 проблема

Для направления анализа лучше использовать вопросы Вот некоторые из вопросов, над которыми мы склонны думать.

  • Существуют ли готовые модели для фаз обучения и прогнозирования для работы с «холодными пусками»?
  • Как связаны этап обучения и этап прогнозирования?
  • Как передать обученную модель на стадию прогнозирования?
  • Что делать при экспорте модели, если модель слишком большая?
  • Какой механизм используется для обновления модели, обученной онлайн? Это обычное обновление драйверов?
  • Можете ли вы по-прежнему предсказать, когда модель будет загружена на этапе прогнозирования? Существует ли механизм, гарантирующий, что этот период времени также можно предсказать?
  • Какие этапы обучения и прогнозирования используют параллельную обработку?
  • Как работать с многомерными векторами? Разрезать его?

Мы рассмотрим эти вопросы один за другим позже.

0x04 Общая логика

Онлайн-обучение реализовано в классе FtrlTrainStreamOp, функция linkFrom которого реализует базовую логику.

Основная логика такова:

  • 1) Загрузите инициализированную модель в dataBridge: dataBridge = DirectReader.collect(model);
  • 2) Получить соответствующие параметры. Например, значение vectorSize по умолчанию равно 30000, независимо от наличия hasInterceptItem;
  • 3) Получить информацию о сегментации. splitInfo = getSplitInfo(featureSize, hasInterceptItem, parallelism); вскоре будет использоваться.
  • 4) Разрезать многомерные векторы. Данные инициализации хэшируются с признаками, которые будут генерировать многомерный вектор, который здесь необходимо вырезать. initData.flatMap (новый SplitVector (splitInfo, hasInterceptItem, vectorSize, vectorTrainIdx, featureIdx, labelIdx));
  • 5) Построить итерацию IterativeStream.ConnectedIterativeStreams, которая будет строить (или соединять) два потока данных: поток обратной связи и обучающий поток;
  • 6) Использовать итерацию для построения iterativeBody, состоящего из двух частей: CalcTask, ReduceTask;
    • CalcTask разделен на две части. flatMap1 — это прогноз, необходимый для итерации FTRL для распределенных вычислений, а flatMap2 — часть параметра обновления FTRL;
    • ReduceTask разделен на две функции: объединить эти прогнозные результаты расчета/объединить модель, если выполняются условия и & вывести модель нижестоящему оператору;
  • 7) результат = iterativeBody.filter, он в основном оценивается на основе временного интервала (он также может рассматриваться как управляемый по времени), данные «время не истекло и вектор имеет смысл» будут отправлены обратно в данные обратной связи поток, и итерация продолжится.Вернитесь к шагу 6), введите flatMap2;
  • 8) output = iterativeBody.filter; данные, соответствующие стандарту (время истекло), выскочат из итерации, а затем алгоритм вызовет WriteModel, чтобы преобразовать LineModelData в несколько строк и направить их нижестоящему оператору (то есть этап онлайн-прогнозирования);То есть регулярно обновлять модель до стадии онлайн-прогноза..

Фрагмент кода:

@Override
public FtrlTrainStreamOp linkFrom(StreamOperator<?>... inputs) {
    ......
    // 3)获取切分信息
    final int[] splitInfo = getSplitInfo(featureSize, hasInterceptItem, parallelism);

    DataStream<Row> initData = inputs[0].getDataStream();

    // 4)切分高维向量。
    // Tuple5<SampleId, taskId, numSubVec, SubVec, label>
    DataStream<Tuple5<Long, Integer, Integer, Vector, Object>> input
        = initData.flatMap(new SplitVector(splitInfo, hasInterceptItem, vectorSize,
        vectorTrainIdx, featureIdx, labelIdx))
        .partitionCustom(new CustomBlockPartitioner(), 1);

    // train data format = <sampleId, subSampleTaskId, subNum, SparseVector(subSample), label>
    // feedback format = Tuple7<sampleId, subSampleTaskId, subNum, SparseVector(subSample), label, wx, timeStamps>
    // 5)构建一个 IterativeStream.ConnectedIterativeStreams iteration，这样会构建（或者说连接）两个数据流：反馈流和训练流；
    IterativeStream.ConnectedIterativeStreams<Tuple5<Long, Integer, Integer, Vector, Object>,
        Tuple7<Long, Integer, Integer, Vector, Object, Double, Long>>
        iteration = input.iterate(Long.MAX_VALUE)
        .withFeedbackType(TypeInformation
            .of(new TypeHint<Tuple7<Long, Integer, Integer, Vector, Object, Double, Long>>() {}));

    // 6)用iteration来构建迭代体 iterativeBody，其包括两部分：CalcTask，ReduceTask；
    DataStream iterativeBody = iteration.flatMap(
        new CalcTask(dataBridge, splitInfo, getParams()))
        .keyBy(0)
        .flatMap(new ReduceTask(parallelism, splitInfo))
        .partitionCustom(new CustomBlockPartitioner(), 1);

    // 7)result = iterativeBody.filter；基本是以时间间隔为标准来判断（也可以认为是时间驱动），"时间未过期&向量有意义" 的数据将被发送回反馈数据流，继续迭代，回到步骤 6)，进入flatMap2；
    DataStream<Tuple7<Long, Integer, Integer, Vector, Object, Double, Long>>
        result = iterativeBody.filter(
        new FilterFunction<Tuple7<Long, Integer, Integer, Vector, Object, Double, Long>>() {
            @Override
            public boolean filter(Tuple7<Long, Integer, Integer, Vector, Object, Double, Long> t3)
                throws Exception {
                // if t3.f0 > 0 && t3.f2 > 0 then feedback
                return (t3.f0 > 0 && t3.f2 > 0);
            }
        });

    // 8)output = iterativeBody.filter；符合标准（时间过期了）的数据将跳出迭代，然后算法会调用WriteModel将LineModelData转换为多条Row，转发给下游operator（也就是在线预测阶段）；即定时把模型更新给在线预测阶段。
    DataStream<Row> output = iterativeBody.filter(
        new FilterFunction<Tuple7<Long, Integer, Integer, Vector, Object, Double, Long>>() {
            @Override
            public boolean filter(Tuple7<Long, Integer, Integer, Vector, Object, Double, Long> value)
                throws Exception {
                /* if value.f0 small than 0, then output */
                return value.f0 < 0;
            }
        }).flatMap(new WriteModel(labelType, getVectorCol(), featureCols, hasInterceptItem));
   
    // 指定了某个流将成为迭代程序的结束，并且这个流将作为输入的第二部分（second input）被反馈回迭代
    iteration.closeWith(result);

    TableSchema schema = new LinearModelDataConverter(labelType).getModelSchema();
  
    ......
    this.setOutput(output, names, types);
    return this;
}

Для удобства чтения мы даем блок-схему следующим образом (здесь опущен раздельный набор обучающих/тестовых данных):

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

--------------------------------------------------------------------------------------------
       │          初始模型训练阶段                         │
       │                                                │
┌─────────────────┐                              ┌─────────────────┐ 
│ trainBatchData  │                              │ trainStreamData │
└─────────────────┘                              └─────────────────┘ 
       │                                                │
       │                                                │ 
┌──────────────────┐                                    │ 
│ featurePipeline  │                                    │  
└──────────────────┘                                    │   
       │                                                │
       │                                                │
┌─────────────┐                                         │
│ 线性回归模型  │                                         │ 
└─────────────┘                                         │ 
       │                                                │
       │                                                │
--------------------------------------------------------------------------------------------
       │          在线训练阶段                            │
       │                                                │
┌─────────────┐                                 ┌──────────────────┐
│ dataBridge  │  加载初始化模型                   │ featurePipeline  │ 
└─────────────┘                                 └──────────────────┘
       │                                                │
       │                                                │
       │                                                │
┌─────────────┐                              ┌──────────────────────────┐ 
│ 获取切分信息  │ getSplitInfo                 │ inputs[0].getDataStream()│
└─────────────┘                              └──────────────────────────┘
       │                                                │
       │                                                │
       │                                                │
       │  SplitInfo                                     │  
       │                                                │ 
       │                                                │ 
┌──────────────────────────┐      特征向量               │ 
│ SplitVector              │ <--------------------------│ 
└──────────────────────────┘ 
       │ 
       │ 解析输入，得到DataStream<Tuple5<SampleId, taskId, numSubVec, SubVec, label>> input
       │
       │
┌───────────────────────────┐ 
│ <Tuple5,Tuple7> iteration │ 迭代构建，两个输入train data Tuple5<>，feedback data Tuple7<>
└───────────────────────────┘ 
       │ 
       │ CalcTask从逻辑上分成两个模块：flatMap1, flatMap2
       │  
       │    
┌───────────────────┐                     ┌───────────────────┐ 
│ CalcTask.flatMap1 │ 输入Tuple5<>         │CalcTask.flatMap2  │ 输入Tuple7 <--------------- 
└───────────────────┘                     └───────────────────┘                           │
       │ 分布计算FTRL算法中的predict部分            │ 分布处理反馈数据/更新参数/累积参数到期后发出  │
       │                                         │                                        │
       │                                         │                                        │
       │<-----------------------------------------                                        │
       │ 以上两个flatmap都输出到下面ReduceTask                                               │
       │                                                                                  │ 
       │                                                                                  │ 
┌──────────────────────┐                                                                  │
│ ReduceTask.flatMap   │ 1. 如果时间过期&全部收集完成，归并/输出模型(value.f0 < 0)              │
└──────────────────────┘ 2. 未过期，归并每个CalcTask计算的predict，形成一个 lable y            │ 
       │                                                                                  │ 
       │                                                                                  │ 
┌────────────────────┐                                                                    │ 
│ result = filter    │  if t3.f0 > 0 && t3.f2 > 0 or not ?                                │
└────────────────────┘                                                                    │
      │                                                                                   │ 
      │                                                                                   │ 
      │                                                                                   │
      │    if t3.f0 > 0 && t3.f2 > 0 then         ┌───────────────────┐                   │
      │------------------------------------------>│CalcTask.flatMap2  │输出Tuple7 ---------
      │   "时间未过期&向量有意义" 将送回反馈，继续迭代   └───────────────────┘
      │     
      │  
      │ 如果未形成反馈数据流，则继续过滤  
      │  
      │  
┌────────────────────┐ 
│ output = filter    │ if value.f0 small than 0 or not ?
└────────────────────┘ 
      │ 
      │       
      │    if value.f0 small than 0, then output  
      │    符合标准（时间过期了）的数据将跳出迭代，输出模型
      │ 
      │        
┌────────────┐ 
│ WriteModel │ 因为filter out，所以定期输出模型
└────────────┘ 
      │ 
      │   
--------------------------------------------------------------------------------------------
      │           在线预测阶段
      │        
      │                                      ┌─────────────────┐ 
      │                                      │ testStreamData  │
      │                                      └─────────────────┘
      │                                             │       
      │                                             │  
      │                                             │           
┌──────────────┐                              ┌──────────────────┐ 
│ FTRL Predict │ <----------------------------│ featurePipeline  │ 
└──────────────┘                              └──────────────────┘

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

ссылка 0xFF

[Машинное обучение] Логистическая регрессия (очень подробно)

логистическая регрессия

[Машинное обучение] Распределенная (параллельная) реализация LR

Параллельная логистическая регрессия

Обсуждение алгоритмов машинного обучения и их распараллеливания

Online LR — понимание алгоритма FTRL

Принцип и реализация алгоритма онлайн-оптимизации FTRL

Принцип алгоритма LR+FTRL и его инженерная реализация

Итеративный анализ API потоковой обработки Flink

Вывод формулы FTRL

Бумажные заметки FTRL

Алгоритм онлайн-машинного обучения FTRL (Follow-the-regularized-Leader) Введение

Реализация кода FTRL

LR+FTRL в бою FTRL (плотные данные, используемые кодом)

Алгоритм онлайн-обучения FTRL-проксимальный принцип

Алгоритм онлайн-прогнозирования CTR на основе FTRL

FTRL-Проксимальный алгоритм прогнозирования CTR

Подробное объяснение FTRL, алгоритма онлайн-обучения, широко используемого крупными компаниями.

Решение для онлайн-оптимизации 5: FTRL

Краткое изложение алгоритма FOLLOW THE REGULARIZED LEADER (FTRL)

★★★★★★Думая о жизни и технологиях★★★★★★

Публичный аккаунт WeChat: мысли Росси

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

Категории