NegaScout mit Zobrist-Transpositionstabellen im Schach

Ich versuche, Transpositionstabellen in meinen Alpha-Beta-Scout zu integrieren. Ich sehe einen inkrementellen Geschwindigkeitsschub, den ich gegen Mitte oder Ende des Spiels denke, aber selbst bei einer Tischgröße von 1-2 GB kann er langsamer sein oder auch nicht, als nur überhaupt nicht aus der Transponiertabelle zu lesen. Ich bemerke auch einige weniger effiziente Züge, wenn ich genau das gleiche Spiel ohne die Tische spielen würde.

Ich habe mein Zobrist-Schlüssel-Hashing getestet und sie kommen auch nach dem Ausführen und Rückgängigmachen von Bewegungen richtig heraus. Ich glaube nicht, dass sie das Problem sind. Ich habe versucht, den Ratschlägen dieser Artikel beim Entwerfen des Alpha / Beta-Schnittes zu folgen. http://web.archive.org/web/20070809015843/http://www.seanet.com/~brucemo/topics/hashing.htm http://mediocrechess.blogspot.com/2007/01/guide-transposition- tables.html

Kann mir jemand helfen, einen Fehler zu identifizieren? Vielleicht verstehe ich die Bewertung der Überprüfung von Alpha und Beta anhand des Hash nicht. Oder sind 1-2 GB zu klein, um etwas zu bewirken? Ich kann bei Bedarf mehr vom Transpositionstabellencode posten.

 public int alphaBetaScout(Board board, int depth, int alpha, int beta, bool color, bool 
quiscence)
{
    // !!!! With or without this specific section, and any other Transpose.Insert, doesn't make the game play or evaluate any faster.
    HashType type = HashType.AlphaPrune;
    HashEntry h = Transpose.GetInstance().Get(board.zobristKey);
    if (h != null)
    {
        if (h.depth >= depth)
        {
            if (h.flag == HashType.ExactPrune)
            {
                return h.scored;
            }
            if (h.flag == HashType.AlphaPrune)
            {
                if(h.scoredState > alpha)
                {
                    alpha = h.scored;
                }
            }
            if (h.flag == HashType.BetaPrune)
            {
                if(h.scoredState < beta)
                {
                    beta = h.scored;
                }
            }
            if (alpha >= beta)
            {
                return alpha;
            }
        }
    }

    if (board.terminal)
    {
        int scoredState = board.Evaluate(color);
        Table.GetInstance().Add(board.zobristKey, depth, Entry.EXACT, scoredState);
        return scoredState;
    }

    //May do Quescience search here if necessary && depth = 0

    Stack movesGenerated = GeneratePossibleMoves();
    while(!movesGenerated.isEmpty())
    {
        int scoredState = MAXNEGASCOUT;

        board.MakeMove(movesGenerated.pop());
        int newAlpha = -(alpha +1)
        scoredState = -alphaBetaScout(board, depth - 1, newAlpha, -alpha, !color, quiscence);

        if (scoredState < beta && alpha < scoredState)
        {
            scoredState = -alphaBetaScout(board, depth - 1, -beta, -scoredState, !color, quiscence);
        }

        board.UndoMove();

        if (scoredState >= beta)
        {
            Table.GetInstance().Add(key, depth, Entry.BETA, beta);
            return scoredState;
        }

        if (scoredState > alpha)
        {
            type = HashType.ExactPrune;
            alpha = scoredState;
        }
    }
    Table.GetInstance().Add(key, depth, type, alpha);
    return alpha;
}

Der Code scheint auf den ersten Blick in Ordnung zu sein. Ich würde vorschlagen, die Transpositionstabelle zu profilieren. Vielleicht ist Ihre eigentliche Implementierung nur zu langsam beim Speichern und Abrufen der Einträge. Das würde auch erklären, warum Sie mit Transpositionen bessere Bewegungen erzielen, obwohl Sie keinen Geschwindigkeitsvorteil erhalten.

Nicht in die Transpositionstabelle am Blattknoten einfügen.

Kommentieren Sie also den Befehl "Hinzufügen" in diesem Block "if (board.terminal)".