tf.contrib.factorization.WALSModel

Модель для факторизации матриц методом взвешенных чередующихся наименьших квадратов.

tf.contrib.factorization.WALSModel(
    input_rows, input_cols, n_components, unobserved_weight=0.1,
    regularization=None, row_init='random', col_init='random', num_row_shards=1,
    num_col_shards=1, row_weights=1, col_weights=1, use_factors_weights_cache=True,
    use_gramian_cache=True, use_scoped_vars=False
)

Минимизирует следующую функцию потерь по U, V:

где, A: входная матрица, W: весовая матрица. Обратите внимание, что квадратный корень от весов используется в целевой функции. U, V: матрицы row_factors и columnfactors, \(\lambda)\: регуляризация. Также предполагается, что W имеет следующий специальный вид: \( W{ij} = W_0 + R_i * Cj \) если \(A{ij} \ne 0\), \(W_{ij} = W_0\) в противном случае. где, \(W_0\): unobserved_weight, \(R_i\): row_weights, \(C_j\): col_weights.

Обратите внимание, что текущая реализация поддерживает два режима работы: По умолчанию, row_factors и col_factors помещаются в память каждого узла и кэшируются. Если это условие не выполняется, установка use_factors_weights_cache в False позволяет обрабатывать более крупные объемы данных с незначительной потерей производительности, так как это предотвращает создание кэшей на узлах, и вместо этого соответствующие значения весов и факторов извлекаются из серверов параметров на каждом шаге.

Вычисление потерь: Потери можно эффективно вычислить, разложив их на слагаемое для разреженных данных и слагаемое Грама, см. wals.md. Потери возвращаются функцией update_{col, row}_factors(sp_input), и нормализуются следующим образом: _, _, unregularized_loss, regularization, sum_weights = update_row_factors(sp_input) если sp_input содержит строки \({A_i, i \in I}\), и входная матрица A имеет n строк в целом, то потери на мини-партшн = unregularized_loss + regularization равны

Тензор sum_weights содержит нормализованную сумму весов \(sum(W_I) * n / |I|\).

Пример типичного использования (псевдокод):

with tf.Graph().as_default(): # Настройка объекта модели. model = tf.contrib.factorization.WALSModel(....)

# To be run only once as part of session initialization. In distributed
# training setting, this should only be run by the chief trainer and all
# other trainers should block until this is done.
model_init_op = model.initialize_op

# To be run once per worker after session is available, prior to
# the prep_gramian_op for row(column) can be run.
worker_init_op = model.worker_init

# To be run once per iteration sweep before the row(column) update
# initialize ops can be run. Note that in the distributed training
# situations, this should only be run by the chief trainer. All other
# trainers need to block until this is done.
row_update_prep_gramian_op = model.row_update_prep_gramian_op
col_update_prep_gramian_op = model.col_update_prep_gramian_op

# To be run once per worker per iteration sweep. Must be run before
# any actual update ops can be run.
init_row_update_op = model.initialize_row_update_op
init_col_update_op = model.initialize_col_update_op

# Ops to update row(column). This can either take the entire sparse
# tensor or slices of sparse tensor. For distributed trainer, each
# trainer handles just part of the matrix.
_, row_update_op, unreg_row_loss, row_reg, _ = model.update_row_factors(
     sp_input=matrix_slices_from_queue_for_worker_shard)
row_loss = unreg_row_loss + row_reg
_, col_update_op, unreg_col_loss, col_reg, _ = model.update_col_factors(
     sp_input=transposed_matrix_slices_from_queue_for_worker_shard,
     transpose_input=True)
col_loss = unreg_col_loss + col_reg

...

# model_init_op is passed to Supervisor. Chief trainer runs it. Other
# trainers wait.
sv = tf.compat.v1.train.Supervisor(is_chief=is_chief,
                   ...,
                   init_op=tf.group(..., model_init_op, ...), ...)
...

with sv.managed_session(...) as sess:
  # All workers/trainers run it after session becomes available.
  worker_init_op.run(session=sess)

  ...

  while i in iterations:

    # All trainers need to sync up here.
    while not_all_ready:
      wait

    # Row update sweep.
    if is_chief:
      row_update_prep_gramian_op.run(session=sess)
    else:
      wait_for_chief

    # All workers run upate initialization.
    init_row_update_op.run(session=sess)

    # Go through the matrix.
    reset_matrix_slices_queue_for_worker_shard
    while_matrix_slices:
      row_update_op.run(session=sess)

    # All trainers need to sync up here.
    while not_all_ready:
      wait

    # Column update sweep.
    if is_chief:
      col_update_prep_gramian_op.run(session=sess)
    else:
      wait_for_chief

    # All workers run upate initialization.
    init_col_update_op.run(session=sess)

    # Go through the matrix.
    reset_transposed_matrix_slices_queue_for_worker_shard
    while_transposed_matrix_slices:
      col_update_op.run(session=sess)

Методы

project_col_factors

Просмотреть исходный код

project_col_factors(
    sp_input=None, transpose_input=False, projection_weights=None
)

Проецирует факторы столбцов.

Вычисляет вложения столбцов (v_j) для наблюдаемого столбца (a_j) путём решения одной итерации уравнений обновления.

project_row_factors

Просмотреть исходный код

project_row_factors(
    sp_input=None, transpose_input=False, projection_weights=None
)

Проецирует факторы строк.

Вычисляет вложения строк (u_i) для наблюдаемой строки (a_i) путём решения одной итерации уравнений обновления.

scatter_update

Просмотреть исходный код

@classmethod
scatter_update(
    factor, indices, values, sharding_func, name=None
)

Вспомогательная функция для выполнения разбиения scatter update.

update_col_factors

Просмотреть исходный код

update_col_factors(
    sp_input=None, transpose_input=False
)

Обновляет факторы столбцов.

update_row_factors

Посмотреть исходный код

update_row_factors(
    sp_input=None, transpose_input=False
)

Обновляет строковые факторы.