evaluate loose pieces

[Gerd Isenberg]

A bonus for attacks on loose pieces (or up-attacks) is quite standard. I introduced it in Rybka, it was duplicated in Ippolit, and of course is in Komodo. Since the Ippolit code is open-source, there is nothing secret about how this was done.

I was not aware by the term loose piece, and used "hanging piece" for undefended pieces (but not pawns) instead (cpw), even if not immediate exposed to capture. In English does the term "hanging piece" always imply it might be captured immediately? Or is it synonym to loose piece?

However, I understand loose pawns avoids the ambiguity with hanging pawns.

[Eelco de Groot]

Here is the code in SF:

Hi Marco,

I think the change you propose is not really what Lucas means with "loose pieces" the usual term, I don't use it myself much though, is as Gerd says "hanging pieces" The definition on Wikipedia for hanging pieces, hanging pawns are another matter, from http://en.wikipedia.org/wiki/Glossary_of_chess

Hanging
Unprotected and exposed to capture. It is not the same as en prise since a piece en prise may be protected. To "hang a piece" is to lose it by failing to move or protect it

So if a pice is not defended by a pawn and there is already a bonus given for attacking it, the extra effort to see if there are non-pawn material defenders is not so great anymore, and in that case the piece really is "hanging". My own version of that code in Stockfish is a bit experimental and not very streamlined code (if the indents are wrong; I tried to fix them for about forty minutes, it probably has to do with original Stockfish code made in Unix and modified under Windows and some conflicting line endings still there):

Code: Select all

  template<Color Us>
  Score evaluate_threats(const Position& pos, EvalInfo& ei) {

    const Color Them = (Us == WHITE ? BLACK : WHITE);

    Bitboard b;
    Score score = SCORE_ZERO;

    // Enemy pieces not defended by a pawn and under our attack
    Bitboard weakEnemies =  pos.pieces(Them)
                          & ~ei.attackedBy[Them][PAWN]
                          & ei.attackedBy[Us][0];
    if (!weakEnemies)
        return SCORE_ZERO;

    // Add bonus according to type of attacked enemy piece [pt2] and to the
    // type of attacking piece [pt1], from knights to queens. Kings are not
    // considered under pt2 because that is already handled in king evaluation.
    for (PieceType pt1 = KNIGHT; pt1 <= KING; pt1++)
    {
        b = ei.attackedBy[Us][pt1] & weakEnemies;
        if (b)
            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
            {
                Bitboard bb = b & pos.pieces(pt2);
                if (bb)
                {
                   score += ThreatBonus[pt1][pt2];
                   do { // Is the piece undefended? 
                         Square s = pop_1st_bit(&bb);
                         if (!(ei.attackedBy[Them][0] & s))
                         {
                            score += ThreatBonus[pt1][pt2];
                            if (pt2 == PAWN && (!pos.square_is_empty(s + pawn_push(Them)) || (ei.attackedBy[Us][0] & s + pawn_push(Them))))
                            {
                               score += make_score(5, 10);
                               // Nearing a pawn ending and the pawn may become a candidate pawn or a passed pawn?
                               File f = file_of(s);
                               if (ei.pi->file_is_half_open(Us, f) && !pos.non_pawn_material(Them))
                                   score += make_score(0, 2*relative_rank(Them, s));
                            }
                          }
                          // Does the piece attack our king?
                          if ((ei.kingAttackersBB[Us] & s))
                              score += make_score(25, 0);
                   } while (bb);
                }
             }
    }
    return score;
  }

Some of the extra bonuses introduced are just small and may not make much of a difference.

Eelco

[lucasart]

Here is the code in SF:

Code: Select all

  // evaluate_threats<>() assigns bonuses according to the type of attacking piece
  // and the type of attacked one.

  template<Color Us>
  Score evaluate_threats(const Position& pos, EvalInfo& ei) {

    const Color Them = (Us == WHITE ? BLACK : WHITE);

    Bitboard b;
    Score score = SCORE_ZERO;

    // Enemy pieces not defended by a pawn and under our attack
    Bitboard weakEnemies =  pos.pieces(Them)
                          & ~ei.attackedBy[Them][PAWN]
                          & ei.attackedBy[Us][0];
    if (!weakEnemies)
        return SCORE_ZERO;

    // Add bonus according to type of attacked enemy piece and to the
    // type of attacking piece, from knights to queens. Kings are not
    // considered because are already handled in king evaluation.
    for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
    {
        b = ei.attackedBy[Us][pt1] & weakEnemies;
        if (b)
            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
                if (b & pos.pieces(pt2))
                    score += ThreatBonus[pt1][pt2];
    }
    return score;
  }

If I have understood correctly the idea of Lucas, it could be implemented changing weakEnemies definition to:

Code: Select all

// Enemy pieces not defended by a pawn and under our attack
Bitboard weakEnemies =  pos.pieces(Them)
                      & ~ei.attackedBy[Them][PAWN]
                      & ei.attackedBy[Us][0];

// Add enemy non-pawns attacked by our pawns, even if defended by a pawn
weakEnemies |= (pos.pieces(Them) ^ pos.pieces(PAWN, Them)) & ei.attackedBy[Us][PAWN];

But it seems to be redundant with this piece of code in evaluate_piecs() that already does the same thing.

Code: Select all

        // Decrease score if we are attacked by an enemy pawn. Remaining part
        // of threat evaluation must be done later when we have full attack info.
        if (ei.attackedBy[Them][PAWN] & s)
            score -= ThreatenedByPawnPenalty[Piece];

I wasn't advocating to make any changes to SF. Just curious to know what refinments I could bring to my implementation. And indeed I use almost the same definition as SF for loose pieces. The scoring however is where SF is more clever.

[lucasart]

I think you are right. I have a vague recollection that it was in some of the engines of around 1990, perhaps in RexChess and/or in various Fidelity machines and others of that time. But perhaps it was just for pieces attacked by the last-moved piece, I don't remember this detail.

Yes, and I did it in my first engine Pawniac, I think that was either 1989 or 1990. Basically, like many things, the idea that "attacking loose pieces is good" is a pretty intuitive concept, and it seems silly to try to identify an origination of it, though the specific conditions and weights are always interesting.

-Sam

And I'm sure Bob did it in the 70s, in the first assembly versions of Cray Blitz

[BubbaTough]

I think you are right. I have a vague recollection that it was in some of the engines of around 1990, perhaps in RexChess and/or in various Fidelity machines and others of that time. But perhaps it was just for pieces attacked by the last-moved piece, I don't remember this detail.

Yes, and I did it in my first engine Pawniac, I think that was either 1989 or 1990. Basically, like many things, the idea that "attacking loose pieces is good" is a pretty intuitive concept, and it seems silly to try to identify an origination of it, though the specific conditions and weights are always interesting.

-Sam

And I'm sure Bob did it in the 70s, in the first assembly versions of Cray Blitz

Exactly .

-Sam

[mcostalba]

I think the change you propose is not really what Lucas means with "loose pieces" the usual term,

I have looked at his code, not how it is called.

My own version of that code in Stockfish is a bit experimental and not very streamlined code

Your code is too complicated to work

You are attacking 3 concepts (loose pieces, passed pawns and king attacks) in a single piece of code: it doesn't work like this. I'd suggest a more orthogonal approach, one different function for each concept. A possible implementation of your idea that seems an acceptable compromise between speed and accuracy could be:

Code: Select all

  template<Color Us>
  Score evaluate_threats(const Position& pos, EvalInfo& ei) {

    const Color Them = (Us == WHITE ? BLACK : WHITE);

    Bitboard b, bb;
    Score score = SCORE_ZERO;

    // Enemy pieces not defended by a pawn and under our attack
    Bitboard weakEnemies =  pos.pieces(Them)
                          & ~ei.attackedBy[Them][PAWN]
                          & ei.attackedBy[Us][0];
    if (!weakEnemies)
        return SCORE_ZERO;

    Bitboard undefended = weakEnemies & ~ei.attackedBy[Them][0];

    // Add bonus according to type of attacked enemy piece and to the
    // type of attacking piece, from knights to queens. Kings are not
    // considered because are already handled in king evaluation.
    for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
    {
        b = ei.attackedBy[Us][pt1] & weakEnemies;
        if (b)
            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
                if (bb = b & pos.pieces(pt2), bb)
                    score += bb & undefended ? 2 * ThreatBonus[pt1][pt2]
                                             : 1 * ThreatBonus[pt1][pt2];
    }
    return score;
  }

[lucasart]

A possible implementation of your idea that seems an acceptable compromise between speed and accuracy could be:

Code: Select all

...
                    score += bb & undefended ? 2 * ThreatBonus[pt1][pt2]
                                             : 1 * ThreatBonus[pt1][pt2];
...

seems like a reasonable compromise indeed. i'll go ahead and try this in DoubleCheck.

[BubbaTough]

A possible implementation of your idea that seems an acceptable compromise between speed and accuracy could be:

Code: Select all

...
                    score += bb & undefended ? 2 * ThreatBonus[pt1][pt2]
                                             : 1 * ThreatBonus[pt1][pt2];
...

seems like a reasonable compromise indeed. i'll go ahead and try this in DoubleCheck.

I would adjust this a bit...I doubt when a bishop attacks a queen it is half as valuable when the queen is guarded.

-Sam

[Rebel]

A bonus for attacks on loose pieces (or up-attacks) is quite standard. I introduced it in Rybka, it was duplicated in Ippolit, and of course is in Komodo. Since the Ippolit code is open-source, there is nothing secret about how this was done.

And it has been in Gaviota for at least 10 years, which makes me think that it must be in many other engines, long before all those.

Miguel
EDIT: Should not this be widespread?

Since day one.

http://www.top-5000.nl/authors/rebel/ch ... htm#ATTACK

Last time I checked (a couple of months ago) even at nowadays deep depths still good for 30+ elo. Amazing because one would expect a diminishing return effect.

[lucasart]

I think the change you propose is not really what Lucas means with "loose pieces" the usual term,

I have looked at his code, not how it is called.

My own version of that code in Stockfish is a bit experimental and not very streamlined code

Your code is too complicated to work

You are attacking 3 concepts (loose pieces, passed pawns and king attacks) in a single piece of code: it doesn't work like this. I'd suggest a more orthogonal approach, one different function for each concept. A possible implementation of your idea that seems an acceptable compromise between speed and accuracy could be:

Code: Select all

  template<Color Us>
  Score evaluate_threats(const Position& pos, EvalInfo& ei) {

    const Color Them = (Us == WHITE ? BLACK : WHITE);

    Bitboard b, bb;
    Score score = SCORE_ZERO;

    // Enemy pieces not defended by a pawn and under our attack
    Bitboard weakEnemies =  pos.pieces(Them)
                          & ~ei.attackedBy[Them][PAWN]
                          & ei.attackedBy[Us][0];
    if (!weakEnemies)
        return SCORE_ZERO;

    Bitboard undefended = weakEnemies & ~ei.attackedBy[Them][0];

    // Add bonus according to type of attacked enemy piece and to the
    // type of attacking piece, from knights to queens. Kings are not
    // considered because are already handled in king evaluation.
    for (PieceType pt1 = KNIGHT; pt1 < KING; pt1++)
    {
        b = ei.attackedBy[Us][pt1] & weakEnemies;
        if (b)
            for (PieceType pt2 = PAWN; pt2 < KING; pt2++)
                if (bb = b & pos.pieces(pt2), bb)
                    score += bb & undefended ? 2 * ThreatBonus[pt1][pt2]
                                             : 1 * ThreatBonus[pt1][pt2];
    }
    return score;
  }

I think I've found another compromise that (in my testing) performs better. The idea is to make the bonus non linear, in the same logic as king safety. After all the reason why these bonus for attacking hanging pieces are small, are because the hanging pieces can be defended and it's hard to know whether we'll end up losing a piece or not. But one thing is sure, the more undefended hanging pieces, the more probability we won't be able to defend all of them.

Code: Select all

static void eval_loose(const Board *B, eval_t *e)
// detect loose pieces and attribute small bonuses for attacking them
{
	assert(B->initialized && e);

	for (unsigned color = White; color <= Black; color++) {
		const unsigned us = color, them = opp_color(us);
		
		// loose pawns = undefended pawns
		const uint64_t loose_pawns = B->b[them][Pawn] & ~B->st->attacks[them][NoPiece];
		
		// loose pieces = pieces either attacked by a pawn or not defended by a pawn
		const uint64_t enemy_pieces = B->all[them] & ~B->b[them][Pawn];
		const uint64_t loose_pieces = enemy_pieces & (~B->st->attacks[them][Pawn] | B->st->attacks[us][Pawn]);
		
		// hanging = loose and attacked
		uint64_t hanging = (loose_pawns | loose_pieces) & B->st->attacks[us][NoPiece];
		
		// scoring (non linear)
		unsigned weighted_bonus[NB_PHASE] = {0, 0}, risk = 1;
		while (hanging) {
			const unsigned sq = next_bit(&hanging), victim = B->piece_on[sq];
			weighted_bonus[Opening] += 5 + Material[Opening][victim]/32;
			weighted_bonus[EndGame] += 10 + Material[EndGame][victim]/32;
			if (!test_bit(B->st->attacks[them][NoPiece], sq))
				risk++;
		}
		e->op[us] += weighted_bonus[Opening] * risk;
		e->eg[us] += weighted_bonus[EndGame] * risk;
	}
}

You might want to try something like this in SF, although you'll need to modify it somehow as SF separates clearly the case of pawn attacks from the rest (I mix it all together here)