параметры NULL MOVE

вот как я делаю

Code:

value = -quiesce(-beta, -alpha);    // value = -search(-beta, -alpha , depth/3); - первичный вариант
        takeback();    
        if (value > alpha) 
        {                     
            if (_value >= beta)
                break;    
            {ход такой-то}[i].score += (value<<20); // near *=1000 000

и все это в цикле от первого до посл. хода в позиции

А причем Тут IID?

IID - это не метод получения оценки для каждого хода, а метод относительно быстрого получения лучшего хода в позиции (без получения оценки, обычно ОДНОГО лучшего хода)

так IID - это перебор на меньшую глубину с целью выявить возможно более хороший ход ,чтобы рассмотреть его первым?
просто я далее сортирую ходы по score и рассматриваю , начиная с наилучшего

только IID тут не при чем, и такой метод будет работать хуже, чем IID.
Метод IID, в случае если в Хеше нет лучшего хода - находит этот лучший ход, и он (один лучший ход) просто вытягивается на самый верх списка ходов (всегда рассматривается первым)

А ты используешь совсем непонятный метод, и непонятно зачем Ты к оценке полученной при помощи ФВ вообще что-то прибавляешь...

тогда я сделаю так

Code:

besvalue = -100000 ;
if(depth > N)
    for( ... /*ходы от m до n*/)
    {
         makemove(...)
         value = -search(-beta, -alpha , depth/ R);     
         takeback();            
         if (value > bestvalue) 
              bestvalue = value;
    }
//return bestvalue;

какие должны быть N и R

Бред какой-то...
Это не IID
IID в общем случае, в текущей позиции вообще не все ходы рассматривает...
Откуда у тебя в IID появился R?
R это параметр метода пустого хода

вообще - так как ты пишешь - N=2,
а value = -search(-beta, -alpha , (depth/ 2)-1);

И если Достиг значения >=beta, то опровергающий ход найден, дальше продолжать перебирать ходы нет смысла.
Потом лучший ход вытягиваешь в начало, и запускаешь нормальный перебор.

какие именно он не рассматривает ходы?

В предыдущем посте ведь написано.
IID находит опровергающий ход, и на этом перебор заканчивается.
Перебор всех ходов - только если не найден опровергающий ход.

У Меня IID прибавляет прилично, но у меня более гибкая схема.
Если Брать ход с другого уровня - то наверно толку быть и не может

Насчет того, что IID прибавляет мало - это устаревшая информация (это действительно так, но при низком быстродействии, и низкой глубине перебора)
Схема с newDepth=depth-IIDRed - тоже устарела, и тоже нормально работает только при небольшой глубине перебора.

Я тестирую IID при отключенном LMR - на тестовых наборах позиций время обдумывания уменьшается в 2-3-4 раза, в зависимости от типа позиций (может упасть с 2 минут до 30 секунд, и даже сильнее) Кроме выиграша на быстродействии, IID прибавляет за счет получения доп. информации о опровергающих ходах - мы не сокращаем на них в cхеме LMR, и можно давать на них небольшую прибавку к глубине (так-же как и на ходах из Хеша) - но это уже после настройки.
С помощью тестовых матчей настраивать IID очень тяжело - так как сказывается эффект от метода на длинных контролях, и у него слишком много параметров. (у меня - четыре функции пересчета глубины, и Четыре значения IID_Depth)

Так что проще взять несколько тестовых позиций, и посмотреть время обдумывания и количество просмотренных позиций при заданной глубине.

Как лучше организовать дебютную библиотеку (формат файла, метод хранения позиций и ходов, как задавать приоритет ходов и т.д.)? Все, наверное, делают по-своему. Интересно было бы узнать различные подходы

А зачем она нужна? Оболочки поддерживают дебютные библиотеки, и они-же занимаются самообучением (Дебютным)
Обсуждение формата ДБ было на этом форуме, но особой надобности в ней нет.

Это уже слишком

Решил прикрутить к своему движку Null Move. Есть мнение, что это дает прибавку в силе пунктов 200 и прибавку примерно плюс 2...3 полухода за 10...15 секунд
У меня результаты пока такие (перебор на глубину 8 из начальной позиции)
- с Null Move 6,53 сек
- без Null Move 5,65 сек

По результатам тестирования (около 100 партий) Null Move силы не прибавляет

Вот псевдокод моей реализации
do
{
//если глубина не достаточная, чтобы не вылететь в форсированный вариант - не делать пустой ход
if (depth<4*DEPTH_INC)
{
break;
}

//если мы внутри пустого хода - не делать пустой ход
if (null_search)
{
break;
}

//если бета бесконечность - не делать пустой ход
if (beta>100*PAWN_VALUE)
{
break;
}

//если на доске нет фигуры - не делать пустой ход
if (!IsFigure())
{
break;
}

//если одна из сторон под шахом - не делать пустой ход
if (in_check(wtm) || in_check(!wtm))
{
break;
}

//вычислить сокращение глубины
int R_NM = (depth > 5*DEPTH_INC) ? DEPTH_INC*3 : DEPTH_INC*2;

DoNullMove();

int null_eval = -Search(-beta, -beta+1, depth-DEPTH_INC-R_NM, ply+1, !wtm, 1);

UnDoNullMove();

if (null_eval >= beta)
{
return beta;
}
}
while (0);

Различий между PV и не-PV узлами не делаю
Отсечку (null_eval >= beta) в среднем дает один раз из трех попыток

Что я делаю неправильно?

Пробуй так:

do
{
if (depth<2*DEPTH_INC)
{
break;
}

//если на доске нет фигуры - не делать пустой ход
if (!IsFigure())
{
break;
}

//если одна из сторон под шахом - не делать пустой ход
if (in_check(wtm) || in_check(!wtm))
{
break;
}

//вычислить сокращение глубины
int R_NM = DEPTH_INC*2;

DoNullMove();

int null_eval = -Search(-beta, -beta+1, depth-DEPTH_INC-R_NM, ply+1, !wtm, 1);

UnDoNullMove();

if (null_eval >= beta)
{
return beta;
}
}
while (0);

самое простое, без верификации:
if (!check && do_null && depth >= null_depth && num_pieces > 5)
{
donull;
score = -search (-beta, -beta + 1, depth - null_red - 1, false);
undonull;
if (score >= beta) return beta;
}

Кто-нибудь в шахматах испльзует MultiCut в позициях с малым материалом? (там где не используется Null-Move)

NS я понял вашу мысль.
Очевидно что эвристика нулевого хода не завязана на альфу-бету и нулевой ход не волнует упорядоченность ходов.

Но меня смущает один момент из за чего я и написал:
"Другой вопрос – даст ли нулевой ход прирост при идеальной альфа бете."

Они ведь режут одно и то же множество ходов и при эффективной а-б нулевому ходу просто не будет работы так как а-б справиться и без него.
Поясню свою мысль допустим при полном переборе нулевой ход режет ветку но ведь дело в том что при а-б мы до нее просто не дойдем так как она где то в конце.

Хотелось бы это обсудить.

P.S. Я буду только рад если окажется что даже при идеальной а-б нулевой ход столь же эффективен как и при полном переборе

"Поясню свою мысль допустим при полном переборе нулевой ход режет ветку но ведь дело в том что при а-б мы до нее просто не дойдем так как она где то в конце."

При идеальной Альфа-бете не осталось ни одного узла???

Нарисуйте дерево идеальной альфа-беты, и посмотрите режет ли Null-Move. Нарисуйте максимальные отсечения по Null-Move, посмотрите каким стал размер дерева.

Отлично работает Null-Move при идеальной Альфа-бете.

Я обдумаю это.

NS а вы в своей программе не сравнивали эффективность нулевого хода совместно с нормальной а-б и допустим с а-б без сортировки.
Для меня это бы стало решающим аргументом.

1. Бренчинг фактор только с одним методом отсечений - Null-Move - меньше трех... Какой он при идеальной Альфа-бете? Корень из 40-ка? больше шести?
2. Рассмотри перебор на глубину 5. На каждый не первый ход из корня будет рассмотрено n^2 позиций при идеальной альфа-бете. (при 40-ка возможных ходах - 1600 позиций)
3. Если-же этот ход опровергается Null-Move с R=3, то будет рассмотрена ровно одна позиция.

Прибавки силы от Null-Move порядка 200-300 пунктов Эло с короткими контролями. Более точно тестировать нет смысла, так как и так понятно что прибавка очень большая.

Альфа-бету без сортировок мне тестировать не приходило в голову - зачем????