Add scale factor based on pawns

src/eval_types.hpp

@@ -101,6 +101,13 @@ class PScore {
         return static_cast<Value>((mg() * alpha + eg() * (max - alpha)) / max);
     }
 
+    // Eg scaling
+    template<i32 max>
+    PScore scale_eg(i32 alpha) const {
+        assert(0 <= alpha && alpha <= max);
+        return PScore{mg(), static_cast<i16>(eg() * alpha / max)};
+    }
+
     // complexity_add
     PScore complexity_add(Score val) {
         const Score e = eg();

src/evaluation.cpp

@@ -495,6 +495,16 @@ PScore apply_winnable(const Position& pos, PScore& score, usize phase) {
     return score.complexity_add(winnable);
 }
 
+PScore apply_eg_scale(const Position& pos, PScore& eval) {
+    // Strong pawn scaling
+    const Color strong_side = eval.eg() > 0 ? Color::White : Color::Black;
+
+    const isize strong_pawn_count = pos.ipiece_count(strong_side, PieceType::Pawn);
+    const isize pcmul             = 8 - strong_pawn_count;
+
+    return eval.scale_eg<128>(static_cast<i32>(128 - pcmul * pcmul));  // 64 - 128
+}
+
 Score evaluate_white_pov(const Position& pos, const PsqtState& psqt_state) {
     const Color us    = pos.active_color();
     usize       phase = pos.piece_count(Color::White, PieceType::Knight)
@@ -542,6 +552,9 @@ Score evaluate_white_pov(const Position& pos, const PsqtState& psqt_state) {
     // Winnable
     eval = apply_winnable(pos, eval, phase);
 
+    // Eg scaling
+    eval = apply_eg_scale(pos, eval);
+
     return static_cast<Score>(eval.phase<24>(static_cast<i32>(phase)));
 };
 

src/tuning/graph.cpp

@@ -165,6 +165,9 @@ PairHandle Graph::record_pair_scalar(OpType op, PairHandle lhs, f64 scalar) {
     case OpType::ScalarDivPair:
         res = f64x2::scalar_div(scalar, l);
         break;
+    case OpType::ScaleEg:
+        res = f64x2::make(l.first(), l.second() * scalar);
+        break;
     default:
         break;
     }
@@ -474,6 +477,12 @@ void Graph::backward() {
             pair_grads[node.lhs()] = f64x2::add(pair_grads[node.lhs()], update);
             break;
         }
+        case OpType::ScaleEg: {
+            const f64x2 grad_out = pair_grads[out_idx];
+            f64x2       update   = f64x2::make(grad_out.first(), grad_out.second() * node.scalar());
+            pair_grads[node.lhs()] = f64x2::add(pair_grads[node.lhs()], update);
+            break;
+        }
         case OpType::PairMulValue:
         case OpType::ValueMulPair: {
             const f64x2 grad_out = pair_grads[out_idx];

src/tuning/operations.hpp

@@ -51,6 +51,7 @@ enum class OpType : u32 {
     PairDivValue,
     ValueDivPair,
     PairAddClampedSecond,  // For complexity
+    ScaleEg,               // For eg scaling
 
     // Pair-Pair Ops
     PairMulPair,

src/tuning/value.cpp

@@ -331,4 +331,8 @@ PairHandle PairHandle::complexity_add(ValueHandle value) const {
     return Graph::get().record_pair_value(OpType::PairAddClampedSecond, *this, value);
 }
 
+PairHandle PairHandle::scale_eg_impl(f64 ratio) const {
+    return Graph::get().record_pair_scalar(OpType::ScaleEg, *this, ratio);
+}
+
 }  // namespace Clockwork::Autograd

src/tuning/value.hpp

@@ -77,6 +77,14 @@ struct PairHandle {
     PairHandle sigmoid() const;
 
     PairHandle complexity_add(ValueHandle value) const;
+
+    template<i32 max>
+    PairHandle scale_eg(f64 alpha) const {
+        return scale_eg_impl(alpha / static_cast<f64>(max));
+    }
+
+private:
+    PairHandle scale_eg_impl(f64 ratio) const;
 };
 
 // Operation decls