# Configuration for KataGo C++ GTP engine

# Run the program using: `./katago.exe gtp`

# In this example config, when a parameter is given as a commented out value,

# that value also is the default value, unless described otherwise. You can

# uncomment it (remove the pound sign) and change it if you want.

# ===========================================================================

# Running on an online server or in a real tournament or match

# ===========================================================================

# If you plan to run online or in a tournament, read through the "Rules"

# section below for proper handling of komi, handicaps, end-of-game cleanup,

# and other details.

# ===========================================================================

# Notes about performance and memory usage

# ===========================================================================

# Important: For good performance, you will very likely want to tune the

# "numSearchThreads" parameter in the Search limits section below! Run

# "./katago benchmark" to test KataGo and to suggest a reasonable value

# of this parameter.

# For multi-GPU systems, read "OpenCL GPU settings" or "CUDA GPU settings".

#

# When using OpenCL, verify that KataGo picks the correct device! Some systems

# may have both an Intel CPU OpenCL and GPU OpenCL. If # KataGo picks the wrong

# one, correct this by specifying "openclGpuToUse".

#

# Consider adjusting "maxVisits", "ponderingEnabled", "resignThreshold", and

# other parameters depending on your intended usage.

# ===========================================================================

# Command-line usage

# ===========================================================================

# All of the below values may be set or overridden via command-line arguments:

#

# -override-config KEY=VALUE,KEY=VALUE,...

# ===========================================================================

# Logs and files

# ===========================================================================

# This section defines where and what logging information is produced.

# Each run of KataGo will log to a separate file in this dir.

# This is the default.

logDir = gtp_logs

# Uncomment and specify this instead of logDir to write separate dated subdirs

# logDirDated = gtp_logs

# Uncomment and specify this instead of logDir to log to only a single file

# logFile = gtp.log

# Logging options

logAllGTPCommunication = true

logSearchInfo = true

logSearchInfoForChosenMove = false

logToStderr = false

# KataGo will display some info to stderr on GTP startup

# Uncomment the next line and set it to false to suppress that and remain silent

# startupPrintMessageToStderr = true

# Write information to stderr, for use in things like malkovich chat to OGS.

# ogsChatToStderr = false

# Uncomment and set this to a directory to override where openCLTuner files

# and other cached data is written. By default it saves into a subdir of the

# current directory on windows, and a subdir of ~/.katago on Linux.

# homeDataDir = PATH_TO_DIRECTORY

# ===========================================================================

# Analysis

# ===========================================================================

# This section configures analysis settings.

#

# The maximum number of moves after the first move displayed in variations

# from analysis commands like kata-analyze or lz-analyze.

# analysisPVLen = 15

# Report winrates for chat and analysis as (BLACK|WHITE|SIDETOMOVE).

# Most GUIs and analysis tools will expect SIDETOMOVE.

# reportAnalysisWinratesAs = SIDETOMOVE

# Extra noise for wider exploration. Large values will force KataGo to

# analyze a greater variety of moves than it normally would.

# An extreme value like 1 distributes playouts across every move on the board,

# even very bad moves.

# Affects analysis only, does not affect play.

# analysisWideRootNoise = 0.04

# Try to limit the effect of possible bad or bogus move sequences in the

# history leading to this position from affecting KataGo's move predictions.

# analysisIgnorePreRootHistory = true

# ===========================================================================

# Rules

# ===========================================================================

# This section configures the scoring and playing rules. Rules can also be

# changed mid-run by issuing custom GTP commands.

#

# See https://lightvector.github.io/KataGo/rules.html for rules details.

#

# See https://github.com/lightvector/KataGo/blob/master/docs/GTP_Extensions.md

# for GTP commands.

# Specify the rules as a string.

# Some legal values include:

# chinese, japanese, korean, aga, chinese-ogs, new-zealand, stone-scoring,

# ancient-territory, bga, aga-button

#

# For some human rulesets that require complex adjudication in tricky cases

# (e.g. japanese, korean) KataGo may not precisely match the ruleset in such

# cases but will do its best.

rules = tromp-taylor

# By default, the "rules" parameter is used, but if you comment it out and

# uncomment one option in each of the sections below, you can specify an

# arbitrary combination of individual rules.

# koRule = SIMPLE # Simple ko rules (triple ko = no result)

# koRule = POSITIONAL # Positional superko

# koRule = SITUATIONAL # Situational superko

# scoringRule = AREA # Area scoring

# scoringRule = TERRITORY # Territory scoring (special computer-friendly territory rules)

# taxRule = NONE # All surrounded empty points are scored

# taxRule = SEKI # Eyes in seki do NOT count as points

# taxRule = ALL # All groups are taxed up to 2 points for the two eyes needed to live

# Is multiple-stone suicide legal? (Single-stone suicide is always illegal).

# multiStoneSuicideLegal = false

# multiStoneSuicideLegal = true

# "Button go" - the first pass when area scoring awards 0.5 points and does

# not count for ending the game.

# Allows area scoring rulesets that have far simpler rules to achieve the same

# final scoring precision and reward for precise play as territory scoring.

# hasButton = false

# hasButton = true

# Is this a human ruleset where it's okay to pass before having physically

# captured and removed all dead stones?

# friendlyPassOk = false

# friendlyPassOk = true

# How handicap stones in handicap games are compensated

# whiteHandicapBonus = 0 # White gets no compensation for black's handicap stones (Tromp-taylor, NZ, JP)

# whiteHandicapBonus = N-1 # White gets N-1 points for black's N handicap stones (AGA)

# whiteHandicapBonus = N # White gets N points for black's N handicap stones (Chinese)

# ------------------------------

# Other rules hacks

# ------------------------------

# Uncomment and change to adjust what board size KataGo uses upon startup

# by default when GTP doesn't specify.

# defaultBoardSize = 19

# By default, Katago will use the komi that the GUI or GTP controller tries to set.

# Uncomment and set this to have KataGo ignore the controller and always use this komi.

# ignoreGTPAndForceKomi = 7

# ===========================================================================

# Bot behavior

# ===========================================================================

# ------------------------------

# Resignation

# ------------------------------

# Resignation occurs if for at least resignConsecTurns in a row, the

# winLossUtility (on a [-1,1] scale) is below resignThreshold.

allowResignation = true

resignThreshold = -0.90

resignConsecTurns = 3

# By default, KataGo may resign games that it is confidently losing even if they

# are very close in score. Uncomment and set this to avoid resigning games

# if the estimated difference is points is less than or equal to this.

# resignMinScoreDifference = 10

# Disallow resignation if turn number < resignMinMovesPerBoardArea * area of board.

# e.g 0.25 would prohibit resignation on 19x19 until after turn 361 * 0.25 ~= 90.

# resignMinMovesPerBoardArea = 0.00

# ------------------------------

# Handicap

# ------------------------------

# Assume that if black makes many moves in a row right at the start of the

# game, then the game is a handicap game. This is necessary on some servers

# and for some GUIs and also when initializing from many SGF files, which may

# set up a handicap game using repeated GTP "play" commands for black rather

# than GTP "place_free_handicap" commands; however, it may also lead to

# incorrect understanding of komi if whiteHandicapBonus is used and a server

# does not have such a practice. Uncomment and set to false to disable.

# assumeMultipleStartingBlackMovesAreHandicap = true

# Makes katago dynamically adjust in handicap or altered-komi games to assume

# based on those game settings that it must be stronger or weaker than the

# opponent and to play accordingly. Greatly improves handicap strength by

# biasing winrates and scores to favor appropriate safe/aggressive play.

# Does NOT affect analysis (lz-analyze, kata-analyze, used by programs like

# Lizzie) so analysis remains unbiased. Uncomment and set this to 0 to disable

# this and make KataGo play the same always.

# dynamicPlayoutDoublingAdvantageCapPerOppLead = 0.045

# Instead of "dynamicPlayoutDoublingAdvantageCapPerOppLead", you can comment

# that out and uncomment and set "playoutDoublingAdvantage" to a fixed value

# from -3.0 to 3.0 that will not change dynamically.

# ALSO affects analysis tools (lz-analyze, kata-analyze, used by e.g. Lizzie).

# Negative makes KataGo behave as if it is much weaker than the opponent.

# Positive makes KataGo behave as if it is much stronger than the opponent.

# KataGo will adjust to favor safe/aggressive play as appropriate based on

# the combination of who is ahead and how much stronger/weaker it thinks it is,

# and report winrates and scores taking the strength difference into account.

#

# If this and "dynamicPlayoutDoublingAdvantageCapPerOppLead" are both set

# then dynamic will be used for all games and this fixed value will be used

# for analysis tools.

# playoutDoublingAdvantage = 0.0

# Uncomment one of these when using "playoutDoublingAdvantage" to enforce

# that it will only apply when KataGo plays as the specified color and will be

# negated when playing as the opposite color.

# playoutDoublingAdvantagePla = BLACK

# playoutDoublingAdvantagePla = WHITE

# ------------------------------

# Passing and cleanup

# ------------------------------

# Make the bot never assume that its pass will end the game, even if passing

# would end and "win" under Tromp-Taylor rules. Usually this is a good idea

# when using it for analysis or playing on servers where scoring may be

# implemented non-tromp-taylorly. Uncomment and set to false to disable.

# conservativePass = true

# When using territory scoring, self-play games continue beyond two passes

# with special cleanup rules that may be confusing for human players. This

# option prevents the special cleanup phases from being reachable when using

# the bot for GTP play. Uncomment and set to false to enable entering special

# cleanup. For example, if you are testing it against itself, or against

# another bot that has precisely implemented the rules documented at

# https://lightvector.github.io/KataGo/rules.html

# preventCleanupPhase = true

# ------------------------------

# Miscellaneous behavior

# ------------------------------

# If the board is symmetric, search only one copy of each equivalent move.

# Attempts to also account for ko/superko, will not theoretically perfect for

# superko. Uncomment and set to false to disable.

# rootSymmetryPruning = true

# Uncomment and set to true to avoid a particular joseki that some networks

# misevaluate, and also to improve opening diversity versus some particular

# other bots that like to play it all the time.

# avoidMYTDaggerHack = false

# Prefer to avoid playing the same joseki in every corner of the board.

# Uncomment to set to a specific value. See "Avoid SGF patterns" section.

# By default: 0 (even games), 0.005 (handicap games)

# avoidRepeatedPatternUtility = 0.0

# Experimental logic to fight against mirror Go even with unfavorable komi.

# Uncomment to set to a specific value to use for both playing and analysis.

# By default: true when playing via GTP, but false when analyzing.

# antiMirror = true

# Enable some hacks that mitigate rare instances when passing messes up deeper searches.

# enablePassingHacks = true

# Uncomment and set this to true to prevent bad or bogus move sequences

# in the history leading to this position from affecting KataGo's move choices.

# Same as analysisIgnorePreRootHistory (see above) but applies to actual play.

# You can enable this if KataGo is being asked to play from positions that it did not

# choose the moves to reach.

# ignorePreRootHistory = false

# ===========================================================================

# Search limits

# ===========================================================================

# Terminology:

# "Playouts" is the number of new playouts of search performed each turn.

# "Visits" is the same as "Playouts" but also counts search performed on

# previous turns that is still applicable to this turn.

# "Time" is the time in seconds.

# For example, if KataGo searched 200 nodes on the previous turn, and then

# after the opponent's reply, 50 nodes of its search tree was still valid,

# then a visit limit of 200 would allow KataGo to search 150 new nodes

# (for a final tree size of 200 nodes), whereas a playout limit of of 200

# would allow KataGo to search 200 nodes (for a final tree size of 250 nodes).

# Additionally, KataGo may also move before than the limit in order to

# obey time controls (e.g. byo-yomi, etc) if the GTP controller has

# told KataGo that the game has is being played with a given time control.

# Limits for search on the current turn.

# If commented out or unspecified, the default is to have no limit.

maxVisits = 500

# maxPlayouts = 300

# maxTime = 10.0

# Ponder on the opponent's turn?

ponderingEnabled = false

# Limits for search when pondering on the opponent's turn.

# If commented out or unspecified, the default is to have no limit.

# Limiting the maximum time is recommended so that KataGo won't burn CPU/GPU

# forever and/or run out of RAM if left unattended while pondering is enabled.

# maxVisitsPondering = 5000

# maxPlayoutsPondering = 3000

maxTimePondering = 60.0

# ------------------------------

# Other search limits and behavior

# ------------------------------

# Approx number of seconds to buffer for lag for GTP time controls - will

# move a bit faster assuming there is this much lag per move.

lagBuffer = 1.0

# YOU PROBABLY WANT TO TUNE THIS PARAMETER!

# The number of threads to use when searching. On powerful GPUs the optimal

# threads may be much higher than the number of CPU cores you have because

# many threads are needed to feed efficient large batches to the GPU.

#

# Run "./katago benchmark" to tune this parameter and test the effect

# of changes to any of other parameters.

numSearchThreads = 6

# Play a little faster if the opponent is passing, for human-friendliness.

# Comment these out to disable them, such as if running a controlled match

# where you are testing KataGo with fixed compute per move vs other bots.

searchFactorAfterOnePass = 0.50

searchFactorAfterTwoPass = 0.25

# Play a little faster if super-winning, for human-friendliness.

# Comment these out to disable them, such as if running a controlled match

# where you are testing KataGo with fixed compute per move vs other bots.

searchFactorWhenWinning = 0.40

searchFactorWhenWinningThreshold = 0.95

# ===========================================================================

# GPU settings

# ===========================================================================

# This section configures GPU settings.

#

# Maximum number of positions to send to a single GPU at once. The default

# value is roughly equal to numSearchThreads, but can be specified manually

# if running out of memory, or using multiple GPUs that expect to share work.

# nnMaxBatchSize = <integer>

# Controls the neural network cache size, which is the primary RAM/memory use.

# KataGo will cache up to (2 ** nnCacheSizePowerOfTwo) many neural net

# evaluations in case of transpositions in the tree.

# Increase this to improve performance for searches with tens of thousands

# of visits or more. Decrease this to limit memory usage.

# If you're happy to do some math - each neural net entry takes roughly

# 1.5KB, except when using whole-board ownership/territory

# visualizations, where each entry will take roughly 3KB. The number of

# entries is (2 ** nnCacheSizePowerOfTwo). (E.g. 2 ** 18 = 262144.)

# You can compute roughly how much memory the cache will use based on this.

# nnCacheSizePowerOfTwo = 20

# Size of mutex pool for nnCache is (2 ** this).

# nnMutexPoolSizePowerOfTwo = 16

# Randomize board orientation when running neural net evals? Uncomment and

# set to false to disable.

# nnRandomize = true

# If provided, force usage of a specific seed for nnRandomize.

# The default is to use a randomly generated seed.

# nnRandSeed = abcdefg

# Uncomment and set to true to force GTP to use the maximum board size for

# internal buffers for the neural net. This will make KataGo slower when

# evaluating small boards, but will avoid a lengthy initialization time on every

# change of board size due to having to re-size the neural net buffers on the GPU.

# This can be useful for example, for OGS's persistent bot mode that uses a single

# bot instance to handle multiple games and may thrash between different board sizes

# if there are concurrent games of multiple sizes.

# gtpForceMaxNNSize = false

# ------------------------------

# Multiple GPUs

# ------------------------------

# Set this to the number of GPUs to use or that are available.

# IMPORTANT: If more than 1, also uncomment the appropriate TensorRT

# or CUDA or OpenCL section.

# numNNServerThreadsPerModel = 1

# ------------------------------

# TENSORRT GPU settings

# ------------------------------

# These only apply when using the TENSORRT version of KataGo.

# For one GPU: optionally uncomment this option and change if the GPU to

# use is not device 0.

# trtDeviceToUse = 0

# For two GPUs: Uncomment these options, AND set numNNServerThreadsPerModel above.

# Also, change their values if the devices you want to use are not 0 and 1.

# trtDeviceToUseThread0 = 0

# trtDeviceToUseThread1 = 1

# For three GPUs: Uncomment these options, AND set numNNServerThreadsPerModel above.

# Also, change their values if the devices you want to use are not 0 and 1 and 2.

# trtDeviceToUseThread0 = 0

# trtDeviceToUseThread1 = 1

# trtDeviceToUseThread2 = 2

# The pattern continues for additional GPUs.

# ------------------------------

# CUDA GPU settings

# ------------------------------

# These only apply when using the CUDA version of KataGo.

# For one GPU: optionally uncomment and change this if the GPU you want to

# use is not device 0

# cudaDeviceToUse = 0

# For two GPUs: Uncomment these options, AND set numNNServerThreadsPerModel above.

# Also, change their values if the devices you want to use are not 0 and 1.

# cudaDeviceToUseThread0 = 0

# cudaDeviceToUseThread1 = 1

# For three GPUs: Uncomment these options, AND set numNNServerThreadsPerModel above.

# Also, change their values if the devices you want to use are not 0 and 1 and 2.

# cudaDeviceToUseThread0 = 0

# cudaDeviceToUseThread1 = 1

# cudaDeviceToUseThread2 = 2

# The pattern continues for additional GPUs.

# KataGo will automatically use FP16 or not based on the compute capability

# of your NVIDIA GPU. If you want to try to force a particular behavior

# you can uncomment these lines and change them to "true" or "false".

# cudaUseFP16 = auto

# cudaUseNHWC = auto

# ------------------------------

# OpenCL GPU settings

# ------------------------------

# These only apply when using the OpenCL version of KataGo.

# Uncomment and set to true to tune OpenCL for every board size separately,

# rather than only the largest possible size.

# openclReTunePerBoardSize = false

# For one GPU: optionally uncomment and change this if the best device to use is guessed incorrectly.

# The default behavior tries to guess the 'best' GPU or device on your system to use, usually it will be a good guess.

# openclDeviceToUse = 0

# For two GPUs: Uncomment these two lines and replace X and Y with the device ids of the devices you want to use.

# It might NOT be 0 and 1, some computers will have many OpenCL devices. You can see what the devices are when

# KataGo starts up - it should print or log all the devices it finds.

# (AND also set numNNServerThreadsPerModel above)

# openclDeviceToUseThread0 = X

# openclDeviceToUseThread1 = Y

# For three GPUs: Uncomment these three lines and replace X and Y and Z with the device ids of the devices you want to use.

# It might NOT be 0 and 1 and 2, some computers will have many OpenCL devices. You can see what the devices are when

# KataGo starts up - it should print or log all the devices it finds.

# (AND also set numNNServerThreadsPerModel above)

# openclDeviceToUseThread0 = X

# openclDeviceToUseThread1 = Y

# openclDeviceToUseThread2 = Z

# The pattern continues for additional GPUs.

# KataGo will automatically use FP16 or not based on testing your GPU during

# tuning. If you want to try to force a particular behavior though you can

# uncomment this option and change it to "true" or "false". This is a fairly

# blunt setting - more detailed settings are testable by rerunning the tuner

# with various arguments (./katago tuner).

# openclUseFP16 = auto

# ------------------------------

# Eigen-specific settings

# ------------------------------

# These only apply when using the Eigen (pure CPU) version of KataGo.

# Number of CPU threads for evaluating the neural net on the Eigen backend.

#

# Default: numSearchThreads

# numEigenThreadsPerModel = X

# ===========================================================================

# Root move selection and biases

# ===========================================================================

# Uncomment and edit any of the below values to change them from their default.

# If provided, force usage of a specific seed for various random things in

# the search. The default is to use a random seed.

# searchRandSeed = hijklmn

# Temperature for the early game, randomize between chosen moves with

# this temperature

# chosenMoveTemperatureEarly = 0.5

# Decay temperature for the early game by 0.5 every this many moves,

# scaled with board size.

# chosenMoveTemperatureHalflife = 19

# At the end of search after the early game, randomize between chosen

# moves with this temperature

# chosenMoveTemperature = 0.10

# Subtract this many visits from each move prior to applying

# chosenMoveTemperature (unless all moves have too few visits) to downweight

# unlikely moves

# chosenMoveSubtract = 0

# The same as chosenMoveSubtract but only prunes moves that fall below

# the threshold. This setting does not affect chosenMoveSubtract.

# chosenMovePrune = 1

# Number of symmetries to sample (without replacement) and average at the root

# rootNumSymmetriesToSample = 1

# Using LCB for move selection?

# useLcbForSelection = true

# How many stdevs a move needs to be better than another for LCB selection

# lcbStdevs = 5.0

# Only use LCB override when a move has this proportion of visits as the

# top move.

# minVisitPropForLCB = 0.15

# ===========================================================================

# Internal params

# ===========================================================================

# Uncomment and edit any of the below values to change them from their default.

# Scales the utility of winning/losing

# winLossUtilityFactor = 1.0

# Scales the utility for trying to maximize score

# staticScoreUtilityFactor = 0.10

# dynamicScoreUtilityFactor = 0.30

# Adjust dynamic score center this proportion of the way towards zero,

# capped at a reasonable amount.

# dynamicScoreCenterZeroWeight = 0.20

# dynamicScoreCenterScale = 0.75

# The utility of getting a "no result" due to triple ko or other long cycle

# in non-superko rulesets (-1 to 1)

# noResultUtilityForWhite = 0.0

# The number of wins that a draw counts as, for white. (0 to 1)

# drawEquivalentWinsForWhite = 0.5

# Exploration constant for mcts

# cpuctExploration = 1.0

# cpuctExplorationLog = 0.45

# Parameters that control exploring more in volatile positions, exploring

# less in stable positions.

# cpuctUtilityStdevPrior = 0.40

# cpuctUtilityStdevPriorWeight = 2.0

# cpuctUtilityStdevScale = 0.85

# FPU reduction constant for mcts

# fpuReductionMax = 0.2

# rootFpuReductionMax = 0.1

# fpuParentWeightByVisitedPolicy = true

# Parameters that control weighting of evals based on the net's own

# self-reported uncertainty.

# useUncertainty = true

# uncertaintyExponent = 1.0

# uncertaintyCoeff = 0.25

# Explore using optimistic policy

# rootPolicyOptimism = 0.2

# policyOptimism = 1.0

# Amount to apply a downweighting of children with very bad values relative

# to good ones.

# valueWeightExponent = 0.25

# Slight incentive for the bot to behave human-like with regard to passing at

# the end, filling the dame, not wasting time playing in its own territory,

# etc., and not play moves that are equivalent in terms of points but a bit

# more unfriendly to humans.

# rootEndingBonusPoints = 0.5

# Make the bot prune useless moves that are just prolonging the game to

# avoid losing yet.

# rootPruneUselessMoves = true

# Apply bias correction based on local pattern keys

# subtreeValueBiasFactor = 0.45

# subtreeValueBiasWeightExponent = 0.85

# Use graph search rather than tree search - identify and share search for

# transpositions.

# useGraphSearch = true

# How much to shard the node table for search synchronization

# nodeTableShardsPowerOfTwo = 16

# How many virtual losses to add when a thread descends through a node

# numVirtualLossesPerThread = 1

# Improve the quality of evals under heavy multithreading

# useNoisePruning = true

# ===========================================================================

# Automatic avoid patterns

# ===========================================================================

# The parameters in this section provide a way to bias away from moves that match

# patterns that this instance of KataGo has played in previous games, by auto-saving

# moves to a directory and then auto-loading and biasing against them each new game.

# Uncomment them to use them. When using this feature, all parameters must be specified.

# Different board sizes are tracked separately, but all board sizes share the same

# parameters by default. Every parameter *except* for autoAvoidRepeatDir and

# autoAvoidRepeatSaveChunkSize can be overridden per board size,

# e.g. "autoAvoidRepeatMinTurnNumber13x13". You must ALSO specify the

# defaults even if you have specified board-size-specific values.

# Directory to auto-save moves KataGo plays, to avoid them in future games.

# You can create a new empty directory and put its path here.

# If you run parallel instances of KataGo, use different directories if you

# want them not to share their biases, use the same directory if you want

# all of them to bias away from past moves that any of them have played.

# KataGo will also automatically DELETE old data in this directory, so it is

# recommended that if you do share the same directory between parallel instances,

# that they all use the same settings that affect data saving/deletion.

# autoAvoidRepeatDir = PATH_TO_NEW_DIRECTORY

# Penalize this much utility per matching move.

# Values that are too large may lead to bad play. The value of 0.004 is fairly large

# and might be large enough to result in some early weird/bad moves when trying

# to avoid past games' moves if enough games begin the same way. You can experiment with it.

# autoAvoidRepeatUtility = 0.004

# Per each new move saved, exponentially decay prior saved moves by this factor.

# This way, the bias against moves from many games ago is gradually phased out.

# For example, 0.9995 = 1 - 1/2000, so would be roughly 2000 prior moves worth of

# penalty weight remembered, in steady state. Depending on what turn number range

# you are saving, this might equate to a different number of games For example

# saving the first 50 moves per game would make this roughly 2000 / 50 = 40 games

# worth of memory.

# autoAvoidRepeatLambda = 0.9995

# Affects data saving/deletion.

# When the number of saved moves exceeds this, outright delete them to avoid too many

# files and disk space building up. Also may affect the speed of saving/loading on start

# of each game if this is set large and a lot of data builds up.

# autoAvoidRepeatMaxPoses = 10000

# Affects data saving/deletion.

# Only save data for moves within this turn number range of those games.

# E.g. setting autoAvoidRepeatMinTurnNumber to a number like 4 or 5 would tend to make

# KataGo not develop a bias against the initial 3-4 and 4-4 corner moves in almost every game.

# autoAvoidRepeatMinTurnNumber = 0

# autoAvoidRepeatMaxTurnNumber = 50

# Affects data saving/deletion.

# Within a single run of a program, wait to accumulate this many samples

# (possibly across multiple clear_boards/games) before saving the data.

# Can help to avoid writing too many small files to disk, especially when GTP is used

# in a way that clears the board very frequently (e.g. gtp2ogs pooled manager).

# autoAvoidRepeatSaveChunkSize = 200

# ===========================================================================

# Avoid SGF patterns

# ===========================================================================

# The parameters in this section provide a way to avoid moves that follow

# specific patterns based on a set of SGF files loaded upon startup.

# This is basically the same as the above "Automatic avoid patterns" section

# above except you supply your own SGF files to avoid moves from.

# Uncomment them to use this feature. Additionally, if the SGF file

# contains the string %SKIP% in a comment on a move, that move will be

# ignored for this purpose.

# Load SGF files from this directory when the engine is started

# (only on startup, will not reload unless engine is restarted)

# avoidSgfPatternDirs = path/to/directory/with/sgfs/

# You can also surround the file path in double quotes if the file path contains trailing spaces or hash signs.

# Within double quotes, backslashes are escape characters.

# avoidSgfPatternDirs = "path/to/directory/with/sgfs/"

# Penalize this much utility per matching move.

# Set this negative if you instead want to favor SGF patterns instead of

# penalizing them. This number does not need to be large, even 0.001 will

# make a difference. Values that are too large may lead to bad play.

# avoidSgfPatternUtility = 0.001

# Optional - load only the newest this many files

# avoidSgfPatternMaxFiles = 20

# Optional - Penalty is multiplied by this per each older SGF file, so that

# old SGF files matter less than newer ones.

# avoidSgfPatternLambda = 0.90

# Optional - pay attention only to moves made by players with this name.

# For example, set it to the name that your bot's past games will show up

# as in the SGF, so that the bot will only avoid repeating moves that itself

# made in past games, not the moves that its opponents made.

# avoidSgfPatternAllowedNames = my-ogs-bot-name1,my-ogs-bot-name2

# Optional - Ignore moves in SGF files that occurred before this turn number.

# avoidSgfPatternMinTurnNumber = 0

# For more avoid patterns:

# You can also specify a second set of parameters, and a third, fourth,

# etc. by numbering 2,3,4,...

#

# avoidSgf2PatternDirs = ...

# avoidSgf2PatternUtility = ...

# avoidSgf2PatternMaxFiles = ...

# avoidSgf2PatternLambda = ...

# avoidSgf2PatternAllowedNames = ...

# avoidSgf2PatternMinTurnNumber = ...