gtp_example.cfg

# 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

# ------------------------------
# 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

# ===========================================================================
# 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 = ...