name string | code string | asm string | file string |
|---|---|---|---|
void INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<true, false, 1ul, 0ul, 2ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xab3fd
jmp 0xab477
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::update<false, true, true, false, false, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb0210
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xafee9
jp 0xafee9
jmp 0xafefe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, true, true, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xb0740
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
unsigned long GD::set_learn<false, false, true, false, 1ul, 0ul, 2ul, 3ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0xb1770
movq -0x18(%rsp), %rax
leaq 0x7cf(%rip), %rcx # 0xb1f10
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x80f(%rip), %rcx # 0xb1f60
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, true, false, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xb1f60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, true, true, false, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xbac20
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb2c29
jp 0xb2c29
jmp 0xb2c3e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::get_pred_per_update<true, true, true, 0ul, 1ul, 2ul, false>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 0ul, 1ul, 2ul, false>(GD::norm_data&, float, float&)>(vw&, example&, GD::norm_data&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0xb3686
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 0ul, 1ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<true, true, 0ul, 1ul, 2ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__c... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::get_pred_per_update<true, false, true, 0ul, 1ul, 2ul, false>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::pred_per_update_feature<true, false, 0ul, 1ul, 2ul, false>(GD::norm_data&, float, float&) | inline void pred_per_update_feature(norm_data& nd, float x, float& fw)
{
if (feature_mask_off || fw != 0.)
{
weight* w = &fw;
float x2 = x * x;
if (x2 < x2_min)
{
x = (x > 0) ? x_min : -x_min;
x2 = x2_min;
}
if (x2 > x2_max)
THROW("your features have too much magnitude");
... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movss %xmm0, 0x1ec(%rsp)
movq %rsi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbbba0
jp 0xbbba0
jmp 0xbbe36
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movss 0x1ec(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 0ul, 1ul, 2ul, false>(GD::norm_data&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xbc04b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 0ul, 1ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::b... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xbd25d
jmp 0xbd2d7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<true, false, 0ul, 1ul, 2ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
unsigned long GD::set_learn<false, true, true, true, 0ul, 1ul, 2ul, 3ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x1, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0xc3bd0
movq -0x18(%rsp), %rax
leaq 0x10f(%rip), %rcx # 0xc3cb0
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x14f(%rip), %rcx # 0xc3d00
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, true, true, true, true, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xc3d00
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, false, true, true, true, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc4f70
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc4e19
jp 0xc4e19
jmp 0xc4e2e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, true, true, false, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xc4ed0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, true, true, true, 0ul, 1ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, true, true, false, 0ul, 1ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, true, false, false, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xc5690
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, true, false, false, 0ul, 1ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, true, true, false, 0ul, 1ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, true, false, true, 0ul, 1ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc6790
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc6639
jp 0xc6639
jmp 0xc664e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, true, false, false, 0ul, 1ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, true, true, true, false, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xc71b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, true, true, false, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc9bf0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc71e9
jp 0xc71e9
jmp 0xc71fe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<float, float&, &void GD::update_feature<true, true, 0ul, 0ul, 0ul>(float&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_trai... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xc7a4b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<true, true, 0ul, 0ul, 0ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xc9aed
jmp 0xc9b67
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<true, false, 0ul, 0ul, 0ul>(float&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_tra... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xca98b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
unsigned long GD::set_learn<false, true, true, true, 0ul, 0ul, 0ul, 1ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0xcced0
movq -0x18(%rsp), %rax
leaq 0x10f(%rip), %rcx # 0xccfb0
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x14f(%rip), %rcx # 0xcd000
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, true, true, false, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcd450
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcd129
jp 0xcd129
jmp 0xcd13e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, true, false, false, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcdbb0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcd889
jp 0xcd889
jmp 0xcd89e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, true, false, true, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xcf900
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, true, false, true, 0ul, 0ul, 0ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xcfa90
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcf939
jp 0xcf939
jmp 0xcf94e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, true, false, true, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xd0670
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, true, false, true, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xd86b0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd06a9
jp 0xd06a9
jmp 0xd06be
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&)>(vw&, example&, GD::norm_data&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0xd10b6
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::_... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, true, 1ul, 2ul, 3ul>(float&, float, float&)>(vw&, example&, float&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0xd3716
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11:... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xd635b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::learn<true, true, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xd8e30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&) | inline void pred_per_update_feature(norm_data& nd, float x, float& fw)
{
if (feature_mask_off || fw != 0.)
{
weight* w = &fw;
float x2 = x * x;
if (x2 < x2_min)
{
x = (x > 0) ? x_min : -x_min;
x2 = x2_min;
}
if (x2 > x2_max)
THROW("your features have too much magnitude");
... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movss %xmm0, 0x1ec(%rsp)
movq %rsi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd9630
jp 0xd9630
jmp 0xd9907
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movss 0x1ec(%rsp), %... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11:... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xd9ceb
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xdad2d
jmp 0xdada7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 1ul, 2ul, 3ul>(float&, float, float&)>(vw&, example&, float&) | inline void foreach_feature(vw& all, example& ec, R& dat)
{
return all.weights.sparse
? foreach_feature<R, S, T, sparse_parameters>(all.weights.sparse_weights, all.ignore_some_linear,
all.ignore_linear, all.interactions, all.permutations, ec, dat)
: foreach_feature<R, S, T, dense_parameters>(a... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x3590(%rax)
je 0xdbf96
movq 0x20(%rsp), %rdi
addq $0x3590, %rdi # imm = 0x3590
addq $0x20, %rdi
movq 0x20(%rsp), %rax
movb 0x4b1(%rax), %sil
movq 0x20(%rsp), %rdx
addq $0x4b2, %rdx ... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 1ul, 2ul, 3ul>(float&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xdc10b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xdedcb
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 2ul, 3ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::_... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::update<false, true, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe2100
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe1fa9
jp 0xe1fa9
jmp 0xe1fbe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, false, false, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
unsigned long GD::set_learn<true, false, false, false, 1ul, 2ul, 3ul, 4ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x2, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0xe2860
movq -0x18(%rsp), %rax
leaq 0x82f(%rip), %rcx # 0xe3060
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x86f(%rip), %rcx # 0xe30b0
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, true, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe28f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, false, false, true, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe2a80
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe2929
jp 0xe2929
jmp 0xe293e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, false, false, true, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe2d70
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe2a19
jp 0xe2a19
jmp 0xe2a2e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, false, false, true, false, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe30b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, false, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe31a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<true, false, false, false, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe3530
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe31d9
jp 0xe31d9
jmp 0xe31ee
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, true, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe3b40
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe39e9
jp 0xe39e9
jmp 0xe39fe
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, false, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe4110
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe42a0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe4149
jp 0xe4149
jmp 0xe415e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, false, false, false, false, 1ul, 2ul, 3ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe4560
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe4239
jp 0xe4239
jmp 0xe424e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, false, false, false, true, 1ul, 2ul, 3ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, true, false, true, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe4b70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, true, false, true, false, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xe4cc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::get_pred_per_update<false, true, true, 1ul, 0ul, 2ul, false>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::pred_per_update_feature<false, true, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&) | inline void pred_per_update_feature(norm_data& nd, float x, float& fw)
{
if (feature_mask_off || fw != 0.)
{
weight* w = &fw;
float x2 = x * x;
if (x2 < x2_min)
{
x = (x > 0) ? x_min : -x_min;
x2 = x2_min;
}
if (x2 > x2_max)
THROW("your features have too much magnitude");
... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1f0(%rsp)
movss %xmm0, 0x1ec(%rsp)
movq %rsi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movss 0x1ec(%rsp), %xmm0
mulss 0x1ec(%rsp), %xmm0
movss %xmm0, 0x1d4(%rsp)
movss 0x2118e5(%rip), %xmm0 # 0x2f6bb8
ucomiss 0x1d4(%rsp), %xmm0
jbe 0xe5324
movss... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_rate_decay<false, 1ul, 0ul>(GD::power_data&, float&) | inline float compute_rate_decay(power_data& s, float& fw)
{
weight* w = &fw;
float rate_decay = 1.f;
if (adaptive)
{
if (sqrt_rate)
rate_decay = InvSqrt(w[adaptive]);
else
rate_decay = powf(w[adaptive], s.minus_power_t);
}
if (normalized)
{
if (sqrt_rate)
{
float inv_norm... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x20e0f4(%rip), %xmm0 # 0x2f36c4
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x20(%rsp), %rax
movss (%rax), %xmm1
callq 0x16f60
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
addq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::b... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xe797d
jmp 0xe79f7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, true, 1ul, 0ul, 2ul>(float&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_t... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xe7ceb
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, true, 1ul, 0ul, 2ul>(float&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_tra... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xe7ebb
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<float, float&, &void GD::update_feature<false, true, 1ul, 0ul, 2ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<false, true, 1ul, 0ul, 2ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xe8efd
jmp 0xe8f77
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::get_pred_per_update<false, true, true, 1ul, 0ul, 2ul, true>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 0ul, 2ul, true>(GD::norm_data&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11:... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xea65b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, true, 1ul, 0ul, 2ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::ba... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xeb86d
jmp 0xeb8e7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::compute_update<true, true, false, true, false, 1ul, 0ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::get_pred_per_update<false, true, false, 1ul, 0ul, 2ul, false>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x3548... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<true, true, false, false, true, 1ul, 0ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::foreach_feature<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), dense_parameters>(dense_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11:... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xedd3b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::generate_interactions<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::... | inline void generate_interactions(std::vector<std::string>& interactions, bool permutations, example_predict& ec,
R& dat,
W& weights) // default value removed to eliminate ambiguity in old complers
{
features* features_data = ec.feature_space;
// often used values
const uint64_t offset = ec.ft_offset;
... | subq $0x308, %rsp # imm = 0x308
movb %sil, %al
movq %rdi, 0x300(%rsp)
andb $0x1, %al
movb %al, 0x2ff(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq 0x2f0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x2d0(%rsp)
l... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 0ul, 2ul, false>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xefddd
jmp 0xefe57
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
void GD::foreach_feature<float, float&, &void GD::update_feature<false, false, 1ul, 0ul, 2ul>(float&, float, float&), sparse_parameters>(sparse_parameters&, bool, bool*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_... | inline void foreach_feature(W& weights, bool ignore_some_linear, bool ignore_linear[256],
std::vector<std::string>& interactions, bool permutations, example_predict& ec, R& dat)
{
uint64_t offset = ec.ft_offset;
if (ignore_some_linear)
for (example_predict::iterator i = ec.begin(); i != ec.end(); ++i)
{... | subq $0x98, %rsp
movb %r8b, %al
movq 0xa0(%rsp), %r8
movq %rdi, 0x90(%rsp)
andb $0x1, %sil
movb %sil, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq %r9, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x6820(%rax), %rax
movq %rax, 0x60(%rsp)
testb $0x1, 0x8f(%rsp)
je 0xf015b
movq... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd_predict.h |
void INTERACTIONS::inner_kernel<float, float&, &void GD::update_feature<false, false, 1ul, 0ul, 2ul>(float&, float, float&), false, &void GD::dummy_func<float>(float&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xf136d
jmp 0xf13e7
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::get_pred_per_update<false, false, true, 1ul, 0ul, 2ul, true>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm0
xorps %xm... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void INTERACTIONS::inner_kernel<GD::norm_data, float&, &void GD::pred_per_update_feature<false, false, 1ul, 0ul, 2ul, true>(GD::norm_data&, float, float&), false, &void GD::dummy_func<GD::norm_data>(GD::norm_data&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::b... | inline void inner_kernel(R& dat, features::iterator_all& begin, features::iterator_all& end, const uint64_t offset,
W& weights, feature_value ft_value, feature_index halfhash)
{
if (audit)
{
for (; begin != end; ++begin)
{
audit_func(dat, begin.audit().get());
call_T<R, T>(dat, weights, INTE... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x6e150
testb $0x1, %al
jne 0xf3cfd
jmp 0xf3d77
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x3... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/interactions_predict.h |
float GD::compute_update<true, true, false, false, false, 1ul, 0ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::get_pred_per_update<false, false, false, 1ul, 0ul, 2ul, true>(GD::gd&, example&) | float get_pred_per_update(gd& g, example& ec)
{
// We must traverse the features in _precisely_ the same order as during training.
label_data& ld = ec.l.simple;
vw& all = *g.all;
float grad_squared = ec.weight;
if (!adax)
grad_squared *= all.loss->getSquareGrad(ec.pred.scalar, ld.label);
if (grad_squa... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movss 0x6870(%rax), %xmm0
movss %xmm0, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0x3548... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
unsigned long GD::set_learn<false, true, false, true, 1ul, 0ul, 2ul, 3ul>(vw&, GD::gd&) | uint64_t set_learn(vw& all, gd& g)
{
all.normalized_idx = normalized;
if (g.adax)
{
g.learn = learn<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.update = update<sparse_l2, invariant, sqrt_rate, feature_mask_off, true, adaptive, normalized, spare>;
g.sensitiv... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x3470(%rax)
movq -0x18(%rsp), %rax
testb $0x1, 0x5a(%rax)
je 0xf54a0
movq -0x18(%rsp), %rax
leaq 0x10f(%rip), %rcx # 0xf5580
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
leaq 0x14f(%rip), %rcx # 0xf55d0
movq %rcx, 0x40(%rax)
mo... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<false, true, false, true, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xf55d0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, true, true, 1ul, 0ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::update<false, true, false, false, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void update(gd& g, base_learner&, example& ec)
{
// invariant: not a test label, importance weight > 0
float update;
if ((update = compute_update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(
g, ec)) != 0.)
train<sqrt_rate, feature_mask_off, adaptive, normal... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf5ec0
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xf5d69
jp 0xf5d69
jmp 0xf5d7e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movss 0xc(%rsp)... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
float GD::compute_update<false, true, false, false, true, 1ul, 0ul, 2ul>(GD::gd&, example&) | float compute_update(gd& g, example& ec)
{
// invariant: not a test label, importance weight > 0
label_data& ld = ec.l.simple;
vw& all = *g.all;
float update = 0.;
ec.updated_prediction = ec.pred.scalar;
if (all.loss->getLoss(all.sd, ec.pred.scalar, ld.label) > 0.)
{
float pred_per_update = sensitivi... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x6828, %rax # imm = 0x6828
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x38(%rsp), %rax
movss 0x6850(%rax), %xmm0
movq 0x38(%rsp... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, true, true, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xf66b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
void GD::learn<true, false, false, true, false, 1ul, 0ul, 2ul>(GD::gd&, LEARNER::learner<char, char>&, example&) | void learn(gd& g, base_learner& base, example& ec)
{
// invariant: not a test label, importance weight > 0
assert(ec.in_use);
assert(ec.l.simple.label != FLT_MAX);
assert(ec.weight > 0.);
g.predict(g, base, ec);
update<sparse_l2, invariant, sqrt_rate, feature_mask_off, adax, adaptive, normalized, spare>(g, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xf67a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%... | /LAIRLAB[P]vowpal_wabbit/vowpalwabbit/gd.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.