sparse_accessor.cc 11.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "paddle/fluid/distributed/ps/table/sparse_accessor.h"
#include <gflags/gflags.h>
#include "glog/logging.h"
#include "paddle/fluid/string/string_helper.h"

namespace paddle {
namespace distributed {

23
int SparseAccessor::Initialize() {
24 25
  auto name = _config.embed_sgd_param().name();
  _embed_sgd_rule = CREATE_PSCORE_CLASS(SparseValueSGDRule, name);
26
  _embed_sgd_rule->LoadConfig(_config.embed_sgd_param(), 1);
27 28 29

  name = _config.embedx_sgd_param().name();
  _embedx_sgd_rule = CREATE_PSCORE_CLASS(SparseValueSGDRule, name);
30 31
  _embedx_sgd_rule->LoadConfig(_config.embedx_sgd_param(),
                               _config.embedx_dim());
32

33
  sparse_feature_value.embed_sgd_dim = _embed_sgd_rule->Dim();
34
  sparse_feature_value.embedx_dim = _config.embedx_dim();
35
  sparse_feature_value.embedx_sgd_dim = _embedx_sgd_rule->Dim();
36 37
  _show_click_decay_rate = _config.ctr_accessor_param().show_click_decay_rate();

38
  InitAccessorInfo();
39 40 41
  return 0;
}

42 43 44
void SparseAccessor::InitAccessorInfo() {
  _accessor_info.dim = sparse_feature_value.Dim();
  _accessor_info.size = sparse_feature_value.Size();
45
  auto embedx_dim = _config.embedx_dim();
46 47 48 49 50 51 52
  _accessor_info.select_dim = 1 + embedx_dim;
  _accessor_info.select_size = _accessor_info.select_dim * sizeof(float);
  ;
  _accessor_info.update_dim = 4 + embedx_dim;
  _accessor_info.update_size = _accessor_info.update_dim * sizeof(float);
  _accessor_info.mf_size =
      (embedx_dim + sparse_feature_value.embedx_sgd_dim) * sizeof(float);
53 54
}

55
bool SparseAccessor::Shrink(float* value) {
56 57 58 59 60 61 62
  auto base_threshold = _config.ctr_accessor_param().base_threshold();
  auto delta_threshold = _config.ctr_accessor_param().delta_threshold();
  auto delete_after_unseen_days =
      _config.ctr_accessor_param().delete_after_unseen_days();
  auto delete_threshold = _config.ctr_accessor_param().delete_threshold();

  // time_decay first
63 64
  sparse_feature_value.Show(value) *= _show_click_decay_rate;
  sparse_feature_value.Click(value) *= _show_click_decay_rate;
65 66

  // shrink after
67 68 69
  auto score = ShowClickScore(sparse_feature_value.Show(value),
                              sparse_feature_value.Click(value));
  auto unseen_days = sparse_feature_value.UnseenDays(value);
70 71 72 73 74 75
  if (score < delete_threshold || unseen_days > delete_after_unseen_days) {
    return true;
  }
  return false;
}

76
bool SparseAccessor::Save(float* value, int param) {
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
  auto base_threshold = _config.ctr_accessor_param().base_threshold();
  auto delta_threshold = _config.ctr_accessor_param().delta_threshold();
  auto delta_keep_days = _config.ctr_accessor_param().delta_keep_days();
  if (param == 2) {
    delta_threshold = 0;
  }
  switch (param) {
    // save all
    case 0: {
      return true;
    }
    // save xbox delta
    case 1:
    // save xbox base
    case 2: {
92 93 94 95
      if (ShowClickScore(sparse_feature_value.Show(value),
                         sparse_feature_value.Click(value)) >= base_threshold &&
          sparse_feature_value.DeltaScore(value) >= delta_threshold &&
          sparse_feature_value.UnseenDays(value) <= delta_keep_days) {
96 97
        // do this after save, because it must not be modified when retry
        if (param == 2) {
98
          sparse_feature_value.DeltaScore(value) = 0;
99 100 101 102 103 104 105 106 107
        }
        return true;
      } else {
        return false;
      }
    }
    // already decayed in shrink
    case 3: {
      // do this after save, because it must not be modified when retry
108
      // sparse_feature_value.UnseenDays(value)++;
109 110 111 112 113 114 115 116 117 118 119
      return true;
    }
    // save revert batch_model
    case 5: {
      return true;
    }
    default:
      return true;
  }
}

120
void SparseAccessor::UpdateStatAfterSave(float* value, int param) {
121 122 123 124 125 126 127 128
  auto base_threshold = _config.ctr_accessor_param().base_threshold();
  auto delta_threshold = _config.ctr_accessor_param().delta_threshold();
  auto delta_keep_days = _config.ctr_accessor_param().delta_keep_days();
  if (param == 2) {
    delta_threshold = 0;
  }
  switch (param) {
    case 1: {
129 130 131 132 133
      if (ShowClickScore(sparse_feature_value.Show(value),
                         sparse_feature_value.Click(value)) >= base_threshold &&
          sparse_feature_value.DeltaScore(value) >= delta_threshold &&
          sparse_feature_value.UnseenDays(value) <= delta_keep_days) {
        sparse_feature_value.DeltaScore(value) = 0;
134 135 136 137
      }
    }
      return;
    case 3: {
138
      sparse_feature_value.UnseenDays(value)++;
139 140 141 142 143 144 145
    }
      return;
    default:
      return;
  }
}

146
int32_t SparseAccessor::Create(float** values, size_t num) {
147 148 149
  auto embedx_dim = _config.embedx_dim();
  for (size_t value_item = 0; value_item < num; ++value_item) {
    float* value = values[value_item];
150 151
    value[sparse_feature_value.UnseenDaysIndex()] = 0;
    value[sparse_feature_value.DeltaScoreIndex()] = 0;
152 153 154
    value[sparse_feature_value.ShowIndex()] = 0;
    value[sparse_feature_value.ClickIndex()] = 0;
    value[sparse_feature_value.SlotIndex()] = -1;
155 156 157 158 159
    _embed_sgd_rule->InitValue(value + sparse_feature_value.EmbedWIndex(),
                               value + sparse_feature_value.EmbedG2SumIndex());
    _embedx_sgd_rule->InitValue(value + sparse_feature_value.EmbedxWIndex(),
                                value + sparse_feature_value.EmbedxG2SumIndex(),
                                false);
160 161 162 163
  }
  return 0;
}

164 165 166
bool SparseAccessor::NeedExtendMF(float* value) {
  float show = value[sparse_feature_value.ShowIndex()];
  float click = value[sparse_feature_value.ClickIndex()];
167 168 169 170 171
  float score = (show - click) * _config.ctr_accessor_param().nonclk_coeff() +
                click * _config.ctr_accessor_param().click_coeff();
  return score >= _config.embedx_threshold();
}

172
bool SparseAccessor::HasMF(size_t size) {
173
  return size > sparse_feature_value.EmbedxG2SumIndex();
174 175 176
}

// from SparseFeatureValue to SparsePullValue
177
int32_t SparseAccessor::Select(float** select_values, const float** values,
178 179 180 181 182
                               size_t num) {
  auto embedx_dim = _config.embedx_dim();
  for (size_t value_item = 0; value_item < num; ++value_item) {
    float* select_value = select_values[value_item];
    const float* value = values[value_item];
183 184 185 186
    select_value[SparsePullValue::EmbedWIndex()] =
        value[sparse_feature_value.EmbedWIndex()];
    memcpy(select_value + SparsePullValue::EmbedxWIndex(),
           value + sparse_feature_value.EmbedxWIndex(),
187 188 189 190 191 192 193 194
           embedx_dim * sizeof(float));
  }
  return 0;
}

// from SparsePushValue to SparsePushValue
// first dim: item
// second dim: field num
195
int32_t SparseAccessor::Merge(float** update_values,
196 197
                              const float** other_update_values, size_t num) {
  auto embedx_dim = _config.embedx_dim();
198
  size_t total_dim = SparsePushValue::Dim(embedx_dim);
199 200 201 202
  for (size_t value_item = 0; value_item < num; ++value_item) {
    float* update_value = update_values[value_item];
    const float* other_update_value = other_update_values[value_item];
    for (auto i = 0u; i < total_dim; ++i) {
203
      if (i != SparsePushValue::SlotIndex()) {
204 205 206 207 208 209 210 211 212 213
        update_value[i] += other_update_value[i];
      }
    }
  }
  return 0;
}

// from SparsePushValue to SparseFeatureValue
// first dim: item
// second dim: field num
214
int32_t SparseAccessor::Update(float** update_values, const float** push_values,
215 216 217 218 219
                               size_t num) {
  auto embedx_dim = _config.embedx_dim();
  for (size_t value_item = 0; value_item < num; ++value_item) {
    float* update_value = update_values[value_item];
    const float* push_value = push_values[value_item];
220 221 222 223 224 225
    float push_show = push_value[SparsePushValue::ShowIndex()];
    float push_click = push_value[SparsePushValue::ClickIndex()];
    float slot = push_value[SparsePushValue::SlotIndex()];
    update_value[sparse_feature_value.ShowIndex()] += push_show;
    update_value[sparse_feature_value.ClickIndex()] += push_click;
    update_value[sparse_feature_value.SlotIndex()] = slot;
226
    update_value[sparse_feature_value.DeltaScoreIndex()] +=
227 228
        (push_show - push_click) * _config.ctr_accessor_param().nonclk_coeff() +
        push_click * _config.ctr_accessor_param().click_coeff();
229 230 231 232 233 234 235 236 237
    update_value[sparse_feature_value.UnseenDaysIndex()] = 0;
    _embed_sgd_rule->UpdateValue(
        update_value + sparse_feature_value.EmbedWIndex(),
        update_value + sparse_feature_value.EmbedG2SumIndex(),
        push_value + SparsePushValue::EmbedGIndex());
    _embedx_sgd_rule->UpdateValue(
        update_value + sparse_feature_value.EmbedxWIndex(),
        update_value + sparse_feature_value.EmbedxG2SumIndex(),
        push_value + SparsePushValue::EmbedxGIndex());
238 239 240 241
  }
  return 0;
}

242
bool SparseAccessor::CreateValue(int stage, const float* value) {
243 244 245 246 247 248
  // stage == 0, pull
  // stage == 1, push
  if (stage == 0) {
    return true;
  } else if (stage == 1) {
    // operation
249 250
    auto show = SparsePushValue::Show(const_cast<float*>(value));
    auto click = SparsePushValue::Click(const_cast<float*>(value));
251
    auto score = ShowClickScore(show, click);
252 253 254 255 256 257 258 259 260 261 262 263 264
    if (score <= 0) {
      return false;
    }
    if (score >= 1) {
      return true;
    }
    return local_uniform_real_distribution<float>()(local_random_engine()) <
           score;
  } else {
    return true;
  }
}

265
float SparseAccessor::ShowClickScore(float show, float click) {
266 267 268 269 270
  auto nonclk_coeff = _config.ctr_accessor_param().nonclk_coeff();
  auto click_coeff = _config.ctr_accessor_param().click_coeff();
  return (show - click) * nonclk_coeff + click * click_coeff;
}

271
std::string SparseAccessor::ParseToString(const float* v, int param) {
272 273 274 275 276
  thread_local std::ostringstream os;
  os.clear();
  os.str("");
  os << v[0] << " " << v[1] << " " << v[2] << " " << v[3] << " " << v[4] << " "
     << v[5];
277 278
  for (int i = sparse_feature_value.EmbedG2SumIndex();
       i < sparse_feature_value.EmbedxWIndex(); i++) {
279 280
    os << " " << v[i];
  }
281 282
  auto show = sparse_feature_value.Show(const_cast<float*>(v));
  auto click = sparse_feature_value.Click(const_cast<float*>(v));
283
  auto score = ShowClickScore(show, click);
284
  if (score >= _config.embedx_threshold() &&
285 286
      param > sparse_feature_value.EmbedxWIndex()) {
    for (auto i = sparse_feature_value.EmbedxWIndex();
287
         i < sparse_feature_value.Dim(); ++i) {
288 289 290 291 292 293
      os << " " << v[i];
    }
  }
  return os.str();
}

294
int SparseAccessor::ParseFromString(const std::string& str, float* value) {
295 296
  int embedx_dim = _config.embedx_dim();

297 298
  _embedx_sgd_rule->InitValue(value + sparse_feature_value.EmbedxWIndex(),
                              value + sparse_feature_value.EmbedxG2SumIndex());
299 300 301 302 303 304 305
  auto ret = paddle::string::str_to_float(str.data(), value);
  CHECK(ret >= 6) << "expect more than 6 real:" << ret;
  return ret;
}

}  // namespace distributed
}  // namespace paddle