【連載】評価関数を作ってみよう！その10

前回の続き。今回は、王様にとって安全な場所(升)を探します。

このソフト、実は、すでにたけわらべより強いんですけど…

計測してみると、前回の評価関数で、すでにたけわらべよりR70～R100ぐらい強いです。

たけわらべ、マシンによっては(かなりハイエンドPCでは)、floodgateでR3000近くあるようで、ギリギリ、プロレベルと言えるのだそうです。

ウォーズの3切れや10秒/手のような短持ち時間帯なら、たけわらべはプロ棋士にも十分脅威になりうる感じですかね？
他の方がたけわらべを別条件で放流されてますが、
TW(TR3990X): R2946 ※まだ6勝11敗
TW(i9-9960X): R2906 ※定跡あり
TW(i5-7200U): R2642
ある程度以上でやっぱり打ち止め感ある
— W@nderERの中の人 (@ihme_vaeltaa) November 28, 2020

ということは、それより+R70～+R100も強ければ、プロレベルであると言っても批判は殺到しませんね。(←何に怯えてるんだ)

亀仙人「この連載は、もうちょっとだけ続くんじゃ」

数十行程度で、プロ棋士レベルの将棋ソフトの評価関数を作るという連載の目的自体は達成しました。←　意図せず達成していました

わりと短いコードで評価関数が1から書けるというのがわかっていただけたかと思います。また、それと同時に、評価関数を設計する時に、どんな特徴量を持たせると効果が高いかが理解していただけたかと思います。

「将棋の形勢判断は簡単な計算式で導き出せる」というのは私が小学校に入学したころに漠然と思い描いた大予想です。それを実証するのには科学技術の進歩を待たなければならなかったので、実に40年もの歳月がかかってしまいました。

それに、今回の評価関数によってプロ棋士の棋力に匹敵する将棋ソフトが作れたとは言っても、最新の将棋ソフトとは棋力に大きな隔たりがあります。それは、まだこの連載では明らかにされていない大切な特徴量が欠けているからです。それは一体、何なのでしょうか。

ここからは、行数制限を取り払って、もう少しだけ強い評価関数を作っていきます。

王様の段ごとのボーナス

「居玉は避けよ」とよく言われますが、この連載の評価関数、居玉のまま戦いがちです。
どうせ入玉した時の王様の段に対して加点するので、まずは玉の段ごとのボーナスを求めて加算してみました。

optimizerによると、玉の段ごとのボーナスは以下のようになりました。1段目から3段目(入玉)はそれぞれ600点、400点、375点の価値があるということです。

// 玉の段ごとのBonus (9段目を0とする)
//int king_rank_bonus&#91;] = { 600,400,375,320,120,280,100,130,0 };

(中略)

    // 玉の段に対する加点(入玉対策)
    //score += color_of(pc) == BLACK ? king_rank_bonus&#91;rank_of(sq)] : -king_rank_bonus&#91;rank_of(Inv(sq))];

// 玉の段ごとのBonus (9段目を0とする)

//int king_rank_bonus[] = { 600,400,375,320,120,280,100,130,0 };

(中略)

// 玉の段に対する加点(入玉対策)

//score += color_of(pc) == BLACK ? king_rank_bonus[rank_of(sq)] : -king_rank_bonus[rank_of(Inv(sq))];

興味深いことに8段目の玉に130点の点数がつきました。9段目よりは寄せにくそうなので、それくらいつくのかな、というところですが。

実際に対局させると、初手58玉とか指してきます。

うーん。そうじゃないんだよな…。

確かに59と58とでは130点増えます。130点増えるので初手58玉！そりゃそうなるでしょう。59よりは58のほうが寄せにくいでしょうから、勝率も以前よりは悪くないです。そりゃoptimizerが8段目の玉に対して130点の点数をつけるのも無理はありません。

でも、そうじゃないんだよな…。

王様の升ごとのボーナス

そんなわけでして、王様の段ごとのテーブルでは初手58玉になってしまう(なりがち)という問題があることがわかりました。

きちんと玉を囲うソフトにするにはどうすれば良いでしょうか？

盤上で、王手がかかりにくい場所とか、囲いやすい場所が存在してしまうのは、初期陣形とか駒の特性とかから考えて、仕方がないことなので考えるのを諦めて、升ごとにどれだけボーナスを加算すれば良いのかoptimizerに尋ねてみました。

59の升のボーナスを0点として考えるとマイナスの升があったので、59の升を200点としました。

そのマイナスの升とは、どこなのか…。

王様には居玉よりまだ悪い場所がある

optimizerが返してきた、王様のいる升ごとのボーナスは以下のようになりました。

// 玉の升ごとにBonus(盤面の1段目9筋から9段目1筋の順)
int king_pos_bonus&#91;] = {
    875, 655, 830, 680, 770, 815, 720, 945, 755,
    605, 455, 610, 595, 730, 610, 600, 590, 615,
    565, 640, 555, 525, 635, 565, 440, 600, 575,
    520, 515, 580, 420, 640, 535, 565, 500, 510,
    220, 355, 240, 375, 340, 335, 305, 275, 320,
    500, 530, 560, 445, 510, 395, 455, 490, 410,
    345, 275, 250, 355, 295, 280, 420, 235, 135,
    335, 370, 385, 255, 295, 200, 265, 305, 305,
    255, 225, 245, 295, 200, 320, 275,  70, 200
};

// 玉の升ごとにBonus(盤面の1段目9筋から9段目1筋の順)

int king_pos_bonus[] = {

875, 655, 830, 680, 770, 815, 720, 945, 755,

605, 455, 610, 595, 730, 610, 600, 590, 615,

565, 640, 555, 525, 635, 565, 440, 600, 575,

520, 515, 580, 420, 640, 535, 565, 500, 510,

220, 355, 240, 375, 340, 335, 305, 275, 320,

500, 530, 560, 445, 510, 395, 455, 490, 410,

345, 275, 250, 355, 295, 280, 420, 235, 135,

335, 370, 385, 255, 295, 200, 265, 305, 305,

255, 225, 245, 295, 200, 320, 275, 70, 200

};

盤面、左上(91)が875点、右上(11)が755点、左下(99)が255点、右下(19)が200点というわけです。

29とか居玉(200点)より悪い点数(70点)がついてますけど、まあ、振り飛車にしているとは限らないので居飛車のままここに持って行けばそりゃひどいことになるわな、ぐらいの感じではあります。

これで実際に囲うの？

68の升が255点、78の升が385点なので、78の升をめがけて一目散に囲うようになりました。これでは、どう見ても棒銀の餌食です。しかし、前バージョンの評価関数のソフトは短い時間だと棒銀をしてきません。Oh..

そんなわけで、optimizerは勝率を最大化するパラメーターを発見してくれるのではありますが、その対戦相手がきちんと咎めにきてくれないと話にならない感じではあります。
かと言って、あまり強いソフトを対戦相手に持ってくるとほとんど勝てなくなってしまい勝率が最大化するところを発見しづらくなります。オールラウンダーで、どんな戦型も指しこなす大局観のとても優れた弱いソフトが必要です。(わりと難しい注文です)

とりあえず、玉をうまく囲うかどうかはともかく、入玉に対しては上のテーブルでそこそこうまく加点できているので、入玉模様の将棋での勝率は上がりました。

+R30ぐらい強くなりました。

王様は、58と88、どちらが安全か？

58は295点、88は370点なので88のほうが良いと出ました。これは、正しいのでしょうか？
下段玉(9段目の玉)が良くない位置であるというのは、
・将棋には前に利く駒が多いので下段玉は攻められやすい(つかまりやすい)
・王様の下側が壁(盤外)なのでそれ以上、下に逃げられない
からだと思われます。

であれば、88の玉も、背(左と下)を壁にしている分だけ58より少ない駒で捕まるはずです。これ自体は正しい(と思う)のですが、実際はその周りに城壁を築くことができます。前回書いたように、88の玉に対してその左上、左と左下、下、右下から遠方駒を離しての王手はできませんから、必然的に、それ以外(上、右上、右)からの攻撃となります。守る方角が3方向だけで済むので、そこに城壁を築くならば、城壁を築くための資源(駒)が58の時よりも節約できます。

つまり、88の玉は58より少ない駒で捕まるというのは正しい(と思う)のですが、城壁を築きやすいというメリットがあるので、一般的には88のほうが58より守りやすいと考えられます。(対して、58玉型は、守りよりは、王様の広さ、捕まりにくさを主張する囲いです。)

初心者は矢倉囲いなどで88玉に入城するほうが安全と思ってしまいますが、安全なのではなく、守りやすいだけであって、58よりも少ない駒で捕まりやすい升であることは忘れてはなりません。

この連載で作った将棋ソフトで遊んでみたい人へ

この連載で作ったソフトの実行ファイルは以下のところからダウンロードできます。

実行ファイル名に”Material”とついているのがそれで、MaterialLv1は単純な駒得のみの評価関数。そこからLv2,Lv3,…とLevelが上がるごとに強くなっていきます。良かったら遊んでみてくださいね。

https://github.com/yaneurao/YaneuraOu/releases

また、このLevelと連載の第何回目が対応するかについては以下のソースコードにあります。

https://github.com/yaneurao/YaneuraOu/blob/master/source/eval/material/evaluate_material.cpp

今回のソースコード

// KKPEEテーブル。Eが3通りなのでKKPEE9と呼ぶ。
// 利きの価値を合算した値を求めるテーブル
// &#91;先手玉の升]&#91;後手玉の升]&#91;対象升]&#91;その升の先手の利きの数(最大2)]&#91;その升の後手の利きの数(最大2)]&#91;駒(先後区別あり)]
// 81*81*81*3*3*size_of(int16_t)*32 = 306MB
// 1つの升にある利きは、2つ以上の利きは同一視。
int16_t KKPEE&#91;SQ_NB]&#91;SQ_NB]&#91;SQ_NB]&#91;3]&#91;3]&#91;PIECE_NB];

// ↑のテーブルに格納されている値の倍率
constexpr int FV_SCALE = 32;

void init() {

    // 王様からの距離に応じたある升の利きの価値。

    int our_effect_value&#91;9];
    int their_effect_value&#91;9];

    for (int d = 0; d &lt; 9; ++d)
    {
        // 利きには、王様からの距離に反比例する価値がある。
        our_effect_value&#91;d]   = 83 * 1024  / (d + 1);
        their_effect_value&#91;d] = 92 * 1024  / (d + 1);
    }

    // 利きが1つの升にm個ある時に、our_effect_value(their_effect_value)の価値は何倍されるのか？
    // 利きは最大で10個のことがある。格納されている値は1024を1.0とみなす固定小数。
    // optimizerの答えは、{ 0 , 1024/* == 1.0 */ , 1800, 2300 , 2900,3500,3900,4300,4650,5000,5300 }
    //   6365 - pow(0.8525,m-1)*5341 　みたいな感じ？

    int multi_effect_value&#91;11];

    for (int m = 0; m &lt; 11; ++m)
        multi_effect_value&#91;m] = m == 0 ? 0 : int(6365 - std::pow(0.8525, m - 1) * 5341);

    // 利きを評価するテーブル
    //    &#91;自玉の位置]&#91;対象となる升]&#91;利きの数(0～10)]
    double our_effect_table  &#91;SQ_NB]&#91;SQ_NB]&#91;11];
    double their_effect_table&#91;SQ_NB]&#91;SQ_NB]&#91;11];

    for(auto king_sq : SQ)
        for (auto sq : SQ)
            for(int m = 0 ; m &lt; 3 ; ++m) // 利きの数
            {
                // 筋と段でたくさん離れているほうの数をその距離とする。
                int d = dist(sq, king_sq);

                our_effect_table  &#91;king_sq]&#91;sq]&#91;m] = double(multi_effect_value&#91;m] * our_effect_value  &#91;d]) / (1024 * 1024);
                their_effect_table&#91;king_sq]&#91;sq]&#91;m] = double(multi_effect_value&#91;m] * their_effect_value&#91;d]) / (1024 * 1024);
            }

    // 駒に味方/相手の利きがn個ある時の価値(この係数×駒の価値/4096が上乗せされる)
    int our_effect_to_our_piece&#91;3]   = { 0,  33 ,  43 };
    int their_effect_to_our_piece&#91;3] = { 0, 113 , 122 };

    // 玉の段ごとのBonus (9段目を0とする)
    //int king_rank_bonus&#91;] = { 600,400,375,320,120,280,100,130,0 };

    // 玉の升ごとにBonus(盤面の1段目9筋から9段目1筋の順)
    int king_pos_bonus&#91;] = {
        875, 655, 830, 680, 770, 815, 720, 945, 755,
        605, 455, 610, 595, 730, 610, 600, 590, 615,
        565, 640, 555, 525, 635, 565, 440, 600, 575,
        520, 515, 580, 420, 640, 535, 565, 500, 510,
        220, 355, 240, 375, 340, 335, 305, 275, 320,
        500, 530, 560, 445, 510, 395, 455, 490, 410,
        345, 275, 250, 355, 295, 280, 420, 235, 135,
        335, 370, 385, 255, 295, 200, 265, 305, 305,
        255, 225, 245, 295, 200, 320, 275,  70, 200
    };

    // ある升の利きの価値のテーブルの初期化。
    // 対象升には駒がない時の価値をまず求める。(駒がある時の価値を計算する時にこの値を用いるため)
    // そのため、Pieceのループを一番外側にしてある。
    for (Piece pc = NO_PIECE; pc &lt; PIECE_NB; ++pc) // 駒(先後の区別あり)
        for (auto king_black : SQ)
            for (auto king_white : SQ)
                for (auto sq : SQ)
                    for(int m1 = 0; m1&lt;3;++m1) // 先手の利きの数
                        for (int m2 = 0; m2 &lt;3; ++m2) // 後手の利きの数
                        {
                            // いまから、先手から見たスコアを計算する。
                            double score = 0;

                            // 対象升(sq)の利きの価値。
                            // これは双方の王様から対象升への距離に反比例する価値。

                            score += our_effect_table  &#91;    king_black ]&#91;    sq ]&#91;m1];
                            score -= their_effect_table&#91;    king_black ]&#91;    sq ]&#91;m2];
                            score -= our_effect_table  &#91;Inv(king_white)]&#91;Inv(sq)]&#91;m2];
                            score += their_effect_table&#91;Inv(king_white)]&#91;Inv(sq)]&#91;m1];

                            // 玉の8近傍に玉以外の味方の利きがなくて駒があるなら、ペナルティ(実は、加点。利きがなくとも駒があることはプラスであった) (+R15)
                            // 玉の8近傍で玉以外の味方の利きがなくて空いている(or 相手の駒)なら、ペナルティ。(+R20)
                            for (auto color : COLOR) // 両方の玉に対して
                            {
                                auto king_sq = color == BLACK ? king_black : king_white;

                                // 玉の8近傍
                                if (dist(sq, king_sq) == 1)
                                {
                                    int effect_us = color == BLACK ? m1 : m2;
                                    if (effect_us &lt;= 1)
                                        // 自玉以外の利きがない。この時、そこが空きか敵駒なら、減点。さもなくば加点。
                                        score -= double((pc == NO_PIECE || color_of(pc) != color) ? 11 : -20) * (color == BLACK ? 1 : -1);
                                    else
                                        // 自玉以外の利きがある。この時、そこが空きか敵駒なら、減点なし。さもなくば9点加点。
                                        score -= double((pc == NO_PIECE || color_of(pc) != color) ? 0 : - 11 ) * (color == BLACK ? 1 : -1);
                                }
                            }

                            if (pc == NO_PIECE)
                            {
                                // 1) 駒がない対象升

                            } else if (type_of(pc) == KING) {

                                // 2) 玉がいる対象升

                                // 敵陣にいる玉の段に対する加点(入玉対策)
                                //score += color_of(pc) == BLACK ? king_rank_bonus&#91;rank_of(sq)] : -king_rank_bonus&#91;rank_of(Inv(sq))];

                                // 玉のいる升に対する加点
                                // テーブル、わかりやすいように段の順番で並べたので、やねうら王はSquareは筋の順で並んでいるから、転置する。
                                score += color_of(pc) == BLACK ? king_pos_bonus&#91;(FILE_9-file_of(    sq )) + int(rank_of(    sq )*9)] :
                                                                -king_pos_bonus&#91;(FILE_9-file_of(Inv(sq))) + int(rank_of(Inv(sq))*9)];

                            } else  {

                                // 3) 玉以外の駒がいる対象升

                                // 盤上の駒に対しては、その価値を1/10ほど減ずる。
                                // 玉に∞の価値があるので、PieceValueを求めてその何%かを加点しようとすると発散するから玉はここから除く。

                                double piece_value = PieceValue&#91;pc];
                                score -= piece_value * 104 / 1024;

                                // さらにこの駒に利きがある時は、その利きの価値を上乗せする。
                                // 味方の利き(紐がついてる)         = 加点
                                // 相手の利き(質(しち)に入っている) = 減点
                                // piece_valueは、後手の駒だと負の値になっている。
                                // scoreはいま先手から見たスコアを計算しているのでこれで辻褄は合う。

                                int effect_us = color_of(pc) == BLACK ? m1 : m2;
                                int effect_them = color_of(pc) == BLACK ? m2 : m1;
                                score += piece_value * our_effect_to_our_piece  &#91;effect_us]   / 4096;
                                score -= piece_value * their_effect_to_our_piece&#91;effect_them] / 4096;
                            }

                            // 先手から見たスコア
                            KKPEE&#91;king_black]&#91;king_white]&#91;sq]&#91;m1]&#91;m2]&#91;pc] = int16_t(score * FV_SCALE);
                        }
}

// KKPEE9 評価関数本体(わずか8行)
// 変数名短くするなどすれば１ツイート(140文字)に収まる。
Value compute_eval(const Position&amp; pos) {

    Value score = VALUE_ZERO;
    for (auto sq : SQ)
        score += KKPEE&#91;pos.king_square(BLACK)]&#91;pos.king_square(WHITE)]&#91;sq]
            &#91;std::min(int(pos.board_effect&#91;BLACK].effect(sq)),2)]&#91;std::min(int(pos.board_effect&#91;WHITE].effect(sq)),2)]&#91;pos.piece_on(sq)];

    // KKPEE配列はFV_SCALE倍されているのでこれで割ってから駒割を加算する。
    score = score / FV_SCALE + pos.state()->materialValue;

    return pos.side_to_move() == BLACK ? score : -score;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

// KKPEEテーブル。Eが3通りなのでKKPEE9と呼ぶ。

// 利きの価値を合算した値を求めるテーブル

// [先手玉の升][後手玉の升][対象升][その升の先手の利きの数(最大2)][その升の後手の利きの数(最大2)][駒(先後区別あり)]

// 81*81*81*3*3*size_of(int16_t)*32 = 306MB

// 1つの升にある利きは、2つ以上の利きは同一視。

int16_t KKPEE[SQ_NB][SQ_NB][SQ_NB][3][3][PIECE_NB];

// ↑のテーブルに格納されている値の倍率

constexpr int FV_SCALE = 32;

void init() {

// 王様からの距離に応じたある升の利きの価値。

int our_effect_value[9];

int their_effect_value[9];

for (int d = 0; d < 9; ++d)

{

// 利きには、王様からの距離に反比例する価値がある。

our_effect_value[d] = 83 * 1024 / (d + 1);

their_effect_value[d] = 92 * 1024 / (d + 1);

}

// 利きが1つの升にm個ある時に、our_effect_value(their_effect_value)の価値は何倍されるのか？

// 利きは最大で10個のことがある。格納されている値は1024を1.0とみなす固定小数。

// optimizerの答えは、{ 0 , 1024/* == 1.0 */ , 1800, 2300 , 2900,3500,3900,4300,4650,5000,5300 }

// 6365 - pow(0.8525,m-1)*5341 　みたいな感じ？

int multi_effect_value[11];

for (int m = 0; m < 11; ++m)

multi_effect_value[m] = m == 0 ? 0 : int(6365 - std::pow(0.8525, m - 1) * 5341);

// 利きを評価するテーブル

// [自玉の位置][対象となる升][利きの数(0～10)]

double our_effect_table [SQ_NB][SQ_NB][11];

double their_effect_table[SQ_NB][SQ_NB][11];

for(auto king_sq : SQ)

for (auto sq : SQ)

for(int m = 0 ; m < 3 ; ++m) // 利きの数

{

// 筋と段でたくさん離れているほうの数をその距離とする。

int d = dist(sq, king_sq);

our_effect_table [king_sq][sq][m] = double(multi_effect_value[m] * our_effect_value [d]) / (1024 * 1024);

their_effect_table[king_sq][sq][m] = double(multi_effect_value[m] * their_effect_value[d]) / (1024 * 1024);

}

// 駒に味方/相手の利きがn個ある時の価値(この係数×駒の価値/4096が上乗せされる)

int our_effect_to_our_piece[3] = { 0, 33 , 43 };

int their_effect_to_our_piece[3] = { 0, 113 , 122 };

// 玉の段ごとのBonus (9段目を0とする)

//int king_rank_bonus[] = { 600,400,375,320,120,280,100,130,0 };

// 玉の升ごとにBonus(盤面の1段目9筋から9段目1筋の順)

int king_pos_bonus[] = {

875, 655, 830, 680, 770, 815, 720, 945, 755,

605, 455, 610, 595, 730, 610, 600, 590, 615,

565, 640, 555, 525, 635, 565, 440, 600, 575,

520, 515, 580, 420, 640, 535, 565, 500, 510,

220, 355, 240, 375, 340, 335, 305, 275, 320,

500, 530, 560, 445, 510, 395, 455, 490, 410,

345, 275, 250, 355, 295, 280, 420, 235, 135,

335, 370, 385, 255, 295, 200, 265, 305, 305,

255, 225, 245, 295, 200, 320, 275, 70, 200

};

// ある升の利きの価値のテーブルの初期化。

// 対象升には駒がない時の価値をまず求める。(駒がある時の価値を計算する時にこの値を用いるため)

// そのため、Pieceのループを一番外側にしてある。

for (Piece pc = NO_PIECE; pc < PIECE_NB; ++pc) // 駒(先後の区別あり)

for (auto king_black : SQ)

for (auto king_white : SQ)

for (auto sq : SQ)

for(int m1 = 0; m1<3;++m1) // 先手の利きの数

for (int m2 = 0; m2 <3; ++m2) // 後手の利きの数

{

// いまから、先手から見たスコアを計算する。

double score = 0;

// 対象升(sq)の利きの価値。

// これは双方の王様から対象升への距離に反比例する価値。

score += our_effect_table [ king_black ][ sq ][m1];

score -= their_effect_table[ king_black ][ sq ][m2];

score -= our_effect_table [Inv(king_white)][Inv(sq)][m2];

score += their_effect_table[Inv(king_white)][Inv(sq)][m1];

// 玉の8近傍に玉以外の味方の利きがなくて駒があるなら、ペナルティ(実は、加点。利きがなくとも駒があることはプラスであった) (+R15)

// 玉の8近傍で玉以外の味方の利きがなくて空いている(or 相手の駒)なら、ペナルティ。(+R20)

for (auto color : COLOR) // 両方の玉に対して

{

auto king_sq = color == BLACK ? king_black : king_white;

// 玉の8近傍

if (dist(sq, king_sq) == 1)

{

int effect_us = color == BLACK ? m1 : m2;

if (effect_us <= 1)

// 自玉以外の利きがない。この時、そこが空きか敵駒なら、減点。さもなくば加点。

score -= double((pc == NO_PIECE || color_of(pc) != color) ? 11 : -20) * (color == BLACK ? 1 : -1);

else

// 自玉以外の利きがある。この時、そこが空きか敵駒なら、減点なし。さもなくば9点加点。

score -= double((pc == NO_PIECE || color_of(pc) != color) ? 0 : - 11 ) * (color == BLACK ? 1 : -1);

}

if (pc == NO_PIECE)

{

// 1) 駒がない対象升

} else if (type_of(pc) == KING) {

// 2) 玉がいる対象升

// 敵陣にいる玉の段に対する加点(入玉対策)

//score += color_of(pc) == BLACK ? king_rank_bonus[rank_of(sq)] : -king_rank_bonus[rank_of(Inv(sq))];

// 玉のいる升に対する加点

// テーブル、わかりやすいように段の順番で並べたので、やねうら王はSquareは筋の順で並んでいるから、転置する。

score += color_of(pc) == BLACK ? king_pos_bonus[(FILE_9-file_of( sq )) + int(rank_of( sq )*9)] :

-king_pos_bonus[(FILE_9-file_of(Inv(sq))) + int(rank_of(Inv(sq))*9)];

} else {

// 3) 玉以外の駒がいる対象升

// 盤上の駒に対しては、その価値を1/10ほど減ずる。

// 玉に∞の価値があるので、PieceValueを求めてその何%かを加点しようとすると発散するから玉はここから除く。

double piece_value = PieceValue[pc];

score -= piece_value * 104 / 1024;

// さらにこの駒に利きがある時は、その利きの価値を上乗せする。

// 味方の利き(紐がついてる) = 加点

// 相手の利き(質(しち)に入っている) = 減点

// piece_valueは、後手の駒だと負の値になっている。

// scoreはいま先手から見たスコアを計算しているのでこれで辻褄は合う。

int effect_us = color_of(pc) == BLACK ? m1 : m2;

int effect_them = color_of(pc) == BLACK ? m2 : m1;

score += piece_value * our_effect_to_our_piece [effect_us] / 4096;

score -= piece_value * their_effect_to_our_piece[effect_them] / 4096;

}

// 先手から見たスコア

KKPEE[king_black][king_white][sq][m1][m2][pc] = int16_t(score * FV_SCALE);

}

// KKPEE9 評価関数本体(わずか8行)

// 変数名短くするなどすれば１ツイート(140文字)に収まる。

Value compute_eval(const Position& pos) {

Value score = VALUE_ZERO;

for (auto sq : SQ)

score += KKPEE[pos.king_square(BLACK)][pos.king_square(WHITE)][sq]

[std::min(int(pos.board_effect[BLACK].effect(sq)),2)][std::min(int(pos.board_effect[WHITE].effect(sq)),2)][pos.piece_on(sq)];

// KKPEE配列はFV_SCALE倍されているのでこれで割ってから駒割を加算する。

score = score / FV_SCALE + pos.state()->materialValue;

return pos.side_to_move() == BLACK ? score : -score;

}

次回予告

次回「将棋は上からの攻めと横からの攻め、どちらが受けにくい？」です。お楽しみに！

つづく