成功用上新引擎

katrain/config.json

@@ -1,19 +1,19 @@
-{
+  {
     "engine": {
-        "katago": "",
-        "altcommand": "",
-        "model": "katrain/models/kata1-b18c384nbt-s9996604416-d4316597426.bin.gz",
-        "humanlike_model": "",
-        "config": "katrain/KataGo/analysis_config.cfg",
-        "max_visits": 500,
-        "fast_visits": 25,
-        "max_time": 8.0,
-        "wide_root_noise": 0.04,
-        "_enable_ownership": true
-    },
-    "contribute": {
-        "katago": "",
-        "config": "katrain/KataGo/contribute_config.cfg",
+          "katago": "katrain/KataGo2/katago.exe",
+          "altcommand": "",
+          "model": "katrain/models2/kata1-b28c512nbt-s10544735488-d5229296520.bin.gz",
+          "humanlike_model": "",
+          "config": "katrain/KataGo2/analysis_config.cfg",
+          "max_visits": 500,
+          "fast_visits": 25,
+          "max_time": 8.0,
+          "wide_root_noise": 0.04,
+          "_enable_ownership": true
+      },
+      "contribute": {
+          "katago": "",
+          "config": "katrain/KataGo2/contribute_config.cfg",
         "ownership": false,
         "maxgames": 6,
         "movespeed": 2,

katrain/kataGO2/README.txt

@@ -0,0 +1,119 @@
+KataGo v1.16.3
+https://github.com/lightvector/KataGo
+
+For neural nets from the latest run, download from here: 
+https://katagotraining.org/
+For nets from earlier runs, see:
+https://katagoarchive.org/
+
+For the human SL net (b18c384nbt-humanv0.bin.gz), it was released with:
+https://github.com/lightvector/KataGo/releases/tag/v1.15.0
+
+For differences between this version and older versions, see releases page at
+https://github.com/lightvector/KataGo/releases/
+
+-----------------------------------------------------
+USAGE:
+-----------------------------------------------------
+KataGo is just an engine and does not have its own graphical interface. So generally you will want to use KataGo along with a GUI or analysis program.
+(https://github.com/lightvector/KataGo#guis)
+
+FIRST: Run a command like this to make sure KataGo is working, with the neural net file you downloaded. On OpenCL, it will also tune for your GPU.
+
+./katago.exe benchmark                                                   # if you have default_gtp.cfg and default_model.bin.gz
+./katago.exe benchmark -model <NEURALNET>.bin.gz                         # if you have default_gtp.cfg
+./katago.exe benchmark -model <NEURALNET>.bin.gz -config gtp_custom.cfg  # use this .bin.gz neural net and this .cfg file
+
+It will tell you a good number of threads. Edit your .cfg file and set "numSearchThreads" to that many to get best performance.
+
+OR: Run this command to have KataGo generate a custom gtp config for you based on answering some questions:
+
+./katago.exe genconfig -model <NEURALNET>.bin.gz -output gtp_custom.cfg
+
+NEXT: A command like this will run KataGo's engine. This is the command to give to your [GUI or analysis program](#guis) so that it can run KataGo.
+
+./katago.exe gtp                                                   # if you have default_gtp.cfg and default_model.bin.gz
+./katago.exe gtp -model <NEURALNET>.bin.gz                         # if you have default_gtp.cfg
+./katago.exe gtp -model <NEURALNET>.bin.gz -config gtp_custom.cfg  # use this .bin.gz neural net and this .cfg file
+
+You may need to specify different paths when entering KataGo's command for a GUI program, e.g.:
+
+path/to/katago.exe gtp -model path/to/<NEURALNET>.bin.gz
+path/to/katago.exe gtp -model path/to/<NEURALNET>.bin.gz -config path/to/gtp_custom.cfg
+
+KataGo should be able to work with any GUI program that supports GTP, as well as any analysis program that supports Leela Zero's `lz-analyze` command, such as Lizzie (https://github.com/featurecat/lizzie) or Sabaki (https://sabaki.yichuanshen.de/).
+
+NOTE for Windows users:
+If you encounter errors due to a missing "msvcp140.dll" or "msvcp140_1.dll" or "msvcp140_2.dll" or "vcruntime140.dll" or similar, you need to download and install the Microsoft Visual C++ Redistributable, here:
+https://www.microsoft.com/en-us/download/details.aspx?id=48145
+If this is for a 64-bit Windows version of KataGo, these dll files have already been included for you, otherwise you will need to install them yourself. On a 64-bit Windows version, there is a rare chance that you may need to delete them if you already have it installed yourself separately and the pre-included files are actually causing problems running KataGo.
+
+-----------------------------------------------------
+HUMAN-STYLE PLAY AND ANALYSIS:
+-----------------------------------------------------
+
+You can also have KataGo imitate human play if you download the human SL model b18c384nbt-humanv0.bin.gz from https://github.com/lightvector/KataGo/releases/tag/v1.15.0, and run a command like the following, providing both a model and the human SL model:
+
+./katago.exe gtp -model <NEURALNET>.bin.gz -human-model b18c384nbt-humanv0.bin.gz -config gtp_human5k_example.cfg
+
+The gtp_human5k_example.cfg configures KataGo to imitate 5-kyu-level players. You can change it to imitate other ranks too, as well as to do many more things, including making KataGo play in a human style but still at a strong level or analyze in interesting ways. Read the config file itself for documentation on some of these possibilities! 
+
+And see also this guide to using the human SL model, which is written from the perspective of the JSON-based analysis engine mentioned below, but is also applicable to gtp as well.
+https://github.com/lightvector/KataGo/blob/master/docs/Analysis_Engine.md#human-sl-analysis-guide
+
+-----------------------------------------------------
+OTHER THINGS YOU CAN DO:
+-----------------------------------------------------
+
+Run a JSON-based analysis engine (https://github.com/lightvector/KataGo/blob/master/docs/Analysis_Engine.md) that can do efficient batched evaluations for a backend Go service:
+
+./katago.exe analysis -model <NEURALNET>.gz -config <ANALYSIS_CONFIG>.cfg
+
+Run a high-performance match engine that will play a pool of bots against each other sharing the same GPU batches and CPUs with each other:
+
+./katago.exe match -config <MATCH_CONFIG>.cfg -log-file match.log -sgf-output-dir <DIR TO WRITE THE SGFS>
+
+Force OpenCL tuner to re-tune:
+
+./katago.exe tuner -config <GTP_CONFIG>.cfg
+
+Print version:
+
+./katago.exe version
+
+
+-----------------------------------------------------
+OPENCL VS CUDA VS EIGEN VS METAL:
+-----------------------------------------------------
+Explanation of the various versions available at https://github.com/lightvector/KataGo/releases
+
+OpenCL - Use this if you have a modern GPU and want the easiest setup.
+
+TensorRT, CUDA11 - Try one of these if you have a top-end NVIDIA GPU, are willing to do some more technical setup work, and care about getting every bit of performance. It MIGHT OR MIGHT NOT be faster than OpenCL! You have to test it on your specific GPU. TensorRT requires CUDA11 as well, and is likely to be the fastest.
+
+Eigen AVX2 - Use this if you have no good GPU, but you have an Intel or AMD CPU from the last several years. This is a pure CPU version of KataGo.
+
+Eigen - Use this if you don't have a GPU or your GPU is too old to work, and your CPU turns out not to support AVX2 or FMA. This is a pure CPU version for KataGo for 
+This is the pure CPU version of KataGo, with no special instructions, which should hopefully run just about anywhere.
+
+Metal - Specific to MacOS, try this with Apple system gpus/accelerators.
+
+-----------------------------------------------------
+TUNING FOR PERFORMANCE:
+-----------------------------------------------------
+You will very likely want to tune some of the parameters in `default_gtp.cfg` for your system for good performance, including the number of threads, fp16 usage, NN cache size, pondering settings, and so on. You can also adjust things like KataGo's resign threshold or utility function. Most of the relevant parameters should be be reasonably well documented directly inline in that config.
+
+There are other a few notes about usage and performance at : https://github.com/lightvector/KataGo
+
+-----------------------------------------------------
+TROUBLESHOOTING:
+-----------------------------------------------------
+Some common issues are described here:
+https://github.com/lightvector/KataGo#common-causes-of-errors
+
+Or, feel free to hop into the Leela Zero discord chat, which has become a general chatroom for a variety of computer Go hobbyists and users, and which you can often find people willing to help.
+https://discord.gg/fhDHgfk
+
+
+
+

katrain/kataGO2/analysis_config.cfg

@@ -0,0 +1,418 @@
+# Config for KataGo C++ Analysis engine, i.e. "./katago.exe analysis"
+
+# Example config for C++ (non-python) analysis engine
+
+# SEE NOTES ABOUT PERFORMANCE AND MEMORY USAGE IN gtp_example.cfg
+# SEE NOTES ABOUT numSearchThreads AND OTHER IMPORTANT PARAMS BELOW!
+
+# Logs------------------------------------------------------------------------------------
+
+# Where to output log?
+logDir = analysis_logs  # Each run of KataGo will log to a separate file in this dir
+# logDirDated = analysis_logs  # Use this instead of logDir to also write separate dated subdirs
+# logFile = analysis.log  # Use this instead of logDir to just specify a single file directly
+# logToStderr = true      # Echo everything output to log file to stderr as well
+# logAllRequests = false  # Log all input lines received to the analysis engine.
+# logAllResponses = false # Log all lines output to stdout from the analysis engine.
+# logErrorsAndWarnings = true # Log all lines output to stdout from the analysis engine that are errors and warnings
+# logSearchInfo = false   # Log debug info for every search performed
+
+# Report a warning whenever a query contains a field that is unused. Helps to guard against
+# typos when writing code that queries the analysis engine.
+# warnUnusedFields = true
+
+# Analysis------------------------------------------------------------------------------------
+
+# Controls the number of moves after the first move in a variation.
+# analysisPVLen = 15
+
+# Report winrates for analysis as (BLACK|WHITE|SIDETOMOVE).
+reportAnalysisWinratesAs = BLACK
+
+# Larger values will make KataGo explore the top move(s) less deeply and accurately,
+# but explore and give evaluations to a greater variety of moves.
+# An extreme value like 1 will distribute many playouts across every move on the board, even very bad moves.
+# NOTE: defaults to 0.04, under the presumption that the analysis engine will be used mainly for analysis.
+# If you are intending to use the analysis engine to also play games and you want to maximize playing strength,
+# set this to 0.0 either in this config or in the overrides.
+# wideRootNoise = 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.
+# ignorePreRootHistory = true
+
+# Bot behavior---------------------------------------------------------------------------------------
+
+# 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.
+# Defaults to true! Uncomment and set to false to disable this behavior.
+# assumeMultipleStartingBlackMovesAreHandicap = true
+
+# 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.
+# Defaults to true! Uncomment and set to false to disable this.
+# 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.
+# Defaults to true! Uncomment and set to false if you want KataGo to be able to enter 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
+
+# Search limits-----------------------------------------------------------------------------------
+
+# By default, if NOT specified in an individual request, limit maximum number of root visits per search to this much
+maxVisits = 500
+# If provided, cap search time at this many seconds
+# maxTime = 60
+
+# Search threads, batching, GPUs--------------------------------------------------------------------------
+
+# Try a configuration like this if you only expect the engine to be handling a few queries at a time and you want
+# individual queries to return more quickly, and are okay with the results being a bit lower-quality and the overall
+# peak throughput on queries to be lower.
+numAnalysisThreads = 2
+numSearchThreadsPerAnalysisThread = 16
+
+# Try a configuration like this if you expect to be sending large numbers of queries at a time, and want to maximize
+# total throughput and also the evaluation quality of all the queries and you never care about the response latency
+# of the individual queries, only the throughput as a whole.
+# numAnalysisThreads = 32
+# numSearchThreadsPerAnalysisThread = 1
+
+# You will want to increase one or both numbers if you have a powerful GPU, and possibly decrease one or both if you
+# have a very weak GPU, and play with the balance between them depending on your use case.
+# Read the explanation below to understand how to set these parameters:
+
+# EXPLANATION:
+# numAnalysisThreads:                 the number of POSITIONS to be able to search in parallel.
+# numSearchThreadsPerAnalysisThread:  the number of threads to use in the tree search for EACH position.
+# (older analysis configs might just have 'numSearchThreads', this is an alias for 'numSearchThreadsPerAnalysisThread')
+
+# Therefore, the total number of search threads that may be active at a given time could be as large as the product:
+# numAnalysisThreads * numSearchThreadsPerAnalysisThread
+
+# Searching more positions in parallel is more efficient since the different threads aren't conflicting with each
+# other on the same MCTS search tree. Using multiple threads on the same search will both make things slower
+# and weaken the search (holding playouts fixed) due to out of date statistics on nodes and suboptimal exploration,
+# although the cost is minor for only 2,4,8 threads.
+
+# So unlike in GTP, which only ever searches one position at a time and where therefore you might as well make
+# numSearchThreads as large as possible, in the analysis engine you often want you often want to keep numSearchThreads small,
+# and instead parallelize across positions, so you can reduce conflict between threads and improve the overall throughput
+# and strength of the search.
+
+# But obviously you only get the benefit of parallelization across positions when you actually have lots of positions
+# that you are querying at once! For example, setting numAnalysisThreads = 8 is useless if you only ever send one or two
+# queries at a time!
+
+# Therefore:
+# * If you plan to use the analysis engine only for batch processing large numbers of positions,
+#   it's preferable to numSearchThreadsPerAnalysisThread to only a small number (e.g. 1,2,4) and use a higher numAnalysisThreads.
+# * But if you sometimes plan to query the analysis engine for single positions, or otherwise in smaller quantities
+#   than -num-analysis-threads, or if you plan to be user-interactive such that the response time on some individual
+#   analysis requests is important to keep low, then set numSearchThreadsPerAnalysisThread to a larger number and use
+#   a lower numAnalysisThreads. That way, individual searches complete faster due to having more threads on each one.
+
+# For 19x19 boards, weaker GPUs probably want a TOTAL number of threads (numAnalysisThreads * numSearchThreadsPerAnalysisThread)
+# between 4 and 32. Mid-tier GPUs probably between 16 and 64. Strong GPUs probably between 32 and 256.
+# But there's no substitute for experimenting and seeing what's best for your hardware and your usage case.
+
+# Keep in mind that the number of threads you want does NOT necessarily have much to do with how many cores you have on your
+# system. The optimal may easily exceed the number of cores! GPU batching is (usually) the dominant consideration.
+
+# -------------
+
+# nnMaxBatchSize is the max number of positions to send to a single GPU at once. Generally, it should be the case that:
+# (number of GPUs you will use * nnMaxBatchSize) >= (numSearchThreads * num-analysis-threads)
+# That way, when each threads tries to request a GPU eval, your batch size summed across GPUs is large enough to handle them
+# all at once. However, it can be sensible to set this a little smaller if you are limited on GPU memory,
+# too large a number may fail if the GPU doesn't have enough memory.
+nnMaxBatchSize = 64
+
+# Uncomment and set these smaller if you are going to use the analysis engine EXCLUSIVELY for smaller boards (or plan to
+# run multiple instances, with some instances only handling smaller boards). It should improve performance.
+# It may also mean you can use more threads profitably.
+# maxBoardXSizeForNNBuffer = 19
+# maxBoardYSizeForNNBuffer = 19
+
+# Uncomment and set this to true if you are going to use the analysis engine EXCLUSIVELY for exactly the board size
+# specified by maxBoardXSizeForNNBuffer and maxBoardYSizeForNNBuffer. It may slightly improve performance on some GPUs.
+# requireMaxBoardSize = true
+
+# TO USE MULTIPLE GPUS:
+# Uncomment and set this to the number of GPUs you have and/or would like to use...
+# AND if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+# Other General GPU Settings-------------------------------------------------------------------------------
+
+# Cache up to 2 ** this many neural net evaluations in case of transpositions in the tree.
+nnCacheSizePowerOfTwo = 23
+# Size of mutex pool for nnCache is 2 ** this
+nnMutexPoolSizePowerOfTwo = 17
+# Randomize board orientation when running neural net evals?
+nnRandomize = true
+
+
+# TENSORRT GPU settings--------------------------------------
+# These only apply when using the TENSORRT version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# trtDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# CUDA-specific GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. 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 though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+
+# OpenCL-specific GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING 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
+
+# IF USING 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
+
+# IF USING 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
+
+# You can probably guess the pattern if you have four, five, etc. 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 lines 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.
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to min(numAnalysisThreads * numSearchThreadsPerAnalysisThread, numCPUCores).
+# numEigenThreadsPerModel = X
+
+
+# Misc 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 this.
+# rootSymmetryPruning = true
+
+# Uncomment and set to true to make KataGo avoid a particular joseki that some KataGo nets misevaluate,
+# and also to improve opening diversity versus some particular other bots that like to play it all the time.
+# avoidMYTDaggerHack = false
+
+# Have KataGo mildly prefer to avoid playing the same joseki in every corner of the board.
+# Uncomment to set to a specific value. A small value like 0.005 should produce already a noticeable behavior change.
+# avoidRepeatedPatternUtility = 0.0
+
+# Enable some hacks that mitigate rare instances when passing messes up deeper searches.
+# enablePassingHacks = true
+
+# Root move selection and biases------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+# Not all of these parameters are applicable to analysis, some are only used for actual play
+
+# 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, does not affect moves above
+# 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
+
+
+# Avoid SGF Patterns ------------------------------------------------------------------------------
+# The parameters in this section provide a powerful way to customize KataGo to avoid moves that follow specific patterns
+# based on a set of provided SGF files loaded upon startup. 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 make KataGo favor the SGF patterns instead of penalizing it!
+# This number does not need to be large, even 0.001 will make a difference. Too-large values 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 that were made by players with this name.
+# For example you can 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 any 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 = ...
+
+
+
+

katrain/kataGO2/analysis_example.cfg

@@ -0,0 +1,418 @@
+# Config for KataGo C++ Analysis engine, i.e. "./katago.exe analysis"
+
+# Example config for C++ (non-python) analysis engine
+
+# SEE NOTES ABOUT PERFORMANCE AND MEMORY USAGE IN gtp_example.cfg
+# SEE NOTES ABOUT numSearchThreads AND OTHER IMPORTANT PARAMS BELOW!
+
+# Logs------------------------------------------------------------------------------------
+
+# Where to output log?
+logDir = analysis_logs  # Each run of KataGo will log to a separate file in this dir
+# logDirDated = analysis_logs  # Use this instead of logDir to also write separate dated subdirs
+# logFile = analysis.log  # Use this instead of logDir to just specify a single file directly
+# logToStderr = true      # Echo everything output to log file to stderr as well
+# logAllRequests = false  # Log all input lines received to the analysis engine.
+# logAllResponses = false # Log all lines output to stdout from the analysis engine.
+# logErrorsAndWarnings = true # Log all lines output to stdout from the analysis engine that are errors and warnings
+# logSearchInfo = false   # Log debug info for every search performed
+
+# Report a warning whenever a query contains a field that is unused. Helps to guard against
+# typos when writing code that queries the analysis engine.
+# warnUnusedFields = true
+
+# Analysis------------------------------------------------------------------------------------
+
+# Controls the number of moves after the first move in a variation.
+# analysisPVLen = 15
+
+# Report winrates for analysis as (BLACK|WHITE|SIDETOMOVE).
+reportAnalysisWinratesAs = BLACK
+
+# Larger values will make KataGo explore the top move(s) less deeply and accurately,
+# but explore and give evaluations to a greater variety of moves.
+# An extreme value like 1 will distribute many playouts across every move on the board, even very bad moves.
+# NOTE: defaults to 0.04, under the presumption that the analysis engine will be used mainly for analysis.
+# If you are intending to use the analysis engine to also play games and you want to maximize playing strength,
+# set this to 0.0 either in this config or in the overrides.
+# wideRootNoise = 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.
+# ignorePreRootHistory = true
+
+# Bot behavior---------------------------------------------------------------------------------------
+
+# 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.
+# Defaults to true! Uncomment and set to false to disable this behavior.
+# assumeMultipleStartingBlackMovesAreHandicap = true
+
+# 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.
+# Defaults to true! Uncomment and set to false to disable this.
+# 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.
+# Defaults to true! Uncomment and set to false if you want KataGo to be able to enter 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
+
+# Search limits-----------------------------------------------------------------------------------
+
+# By default, if NOT specified in an individual request, limit maximum number of root visits per search to this much
+maxVisits = 500
+# If provided, cap search time at this many seconds
+# maxTime = 60
+
+# Search threads, batching, GPUs--------------------------------------------------------------------------
+
+# Try a configuration like this if you only expect the engine to be handling a few queries at a time and you want
+# individual queries to return more quickly, and are okay with the results being a bit lower-quality and the overall
+# peak throughput on queries to be lower.
+numAnalysisThreads = 2
+numSearchThreadsPerAnalysisThread = 16
+
+# Try a configuration like this if you expect to be sending large numbers of queries at a time, and want to maximize
+# total throughput and also the evaluation quality of all the queries and you never care about the response latency
+# of the individual queries, only the throughput as a whole.
+# numAnalysisThreads = 32
+# numSearchThreadsPerAnalysisThread = 1
+
+# You will want to increase one or both numbers if you have a powerful GPU, and possibly decrease one or both if you
+# have a very weak GPU, and play with the balance between them depending on your use case.
+# Read the explanation below to understand how to set these parameters:
+
+# EXPLANATION:
+# numAnalysisThreads:                 the number of POSITIONS to be able to search in parallel.
+# numSearchThreadsPerAnalysisThread:  the number of threads to use in the tree search for EACH position.
+# (older analysis configs might just have 'numSearchThreads', this is an alias for 'numSearchThreadsPerAnalysisThread')
+
+# Therefore, the total number of search threads that may be active at a given time could be as large as the product:
+# numAnalysisThreads * numSearchThreadsPerAnalysisThread
+
+# Searching more positions in parallel is more efficient since the different threads aren't conflicting with each
+# other on the same MCTS search tree. Using multiple threads on the same search will both make things slower
+# and weaken the search (holding playouts fixed) due to out of date statistics on nodes and suboptimal exploration,
+# although the cost is minor for only 2,4,8 threads.
+
+# So unlike in GTP, which only ever searches one position at a time and where therefore you might as well make
+# numSearchThreads as large as possible, in the analysis engine you often want you often want to keep numSearchThreads small,
+# and instead parallelize across positions, so you can reduce conflict between threads and improve the overall throughput
+# and strength of the search.
+
+# But obviously you only get the benefit of parallelization across positions when you actually have lots of positions
+# that you are querying at once! For example, setting numAnalysisThreads = 8 is useless if you only ever send one or two
+# queries at a time!
+
+# Therefore:
+# * If you plan to use the analysis engine only for batch processing large numbers of positions,
+#   it's preferable to numSearchThreadsPerAnalysisThread to only a small number (e.g. 1,2,4) and use a higher numAnalysisThreads.
+# * But if you sometimes plan to query the analysis engine for single positions, or otherwise in smaller quantities
+#   than -num-analysis-threads, or if you plan to be user-interactive such that the response time on some individual
+#   analysis requests is important to keep low, then set numSearchThreadsPerAnalysisThread to a larger number and use
+#   a lower numAnalysisThreads. That way, individual searches complete faster due to having more threads on each one.
+
+# For 19x19 boards, weaker GPUs probably want a TOTAL number of threads (numAnalysisThreads * numSearchThreadsPerAnalysisThread)
+# between 4 and 32. Mid-tier GPUs probably between 16 and 64. Strong GPUs probably between 32 and 256.
+# But there's no substitute for experimenting and seeing what's best for your hardware and your usage case.
+
+# Keep in mind that the number of threads you want does NOT necessarily have much to do with how many cores you have on your
+# system. The optimal may easily exceed the number of cores! GPU batching is (usually) the dominant consideration.
+
+# -------------
+
+# nnMaxBatchSize is the max number of positions to send to a single GPU at once. Generally, it should be the case that:
+# (number of GPUs you will use * nnMaxBatchSize) >= (numSearchThreads * num-analysis-threads)
+# That way, when each threads tries to request a GPU eval, your batch size summed across GPUs is large enough to handle them
+# all at once. However, it can be sensible to set this a little smaller if you are limited on GPU memory,
+# too large a number may fail if the GPU doesn't have enough memory.
+nnMaxBatchSize = 64
+
+# Uncomment and set these smaller if you are going to use the analysis engine EXCLUSIVELY for smaller boards (or plan to
+# run multiple instances, with some instances only handling smaller boards). It should improve performance.
+# It may also mean you can use more threads profitably.
+# maxBoardXSizeForNNBuffer = 19
+# maxBoardYSizeForNNBuffer = 19
+
+# Uncomment and set this to true if you are going to use the analysis engine EXCLUSIVELY for exactly the board size
+# specified by maxBoardXSizeForNNBuffer and maxBoardYSizeForNNBuffer. It may slightly improve performance on some GPUs.
+# requireMaxBoardSize = true
+
+# TO USE MULTIPLE GPUS:
+# Uncomment and set this to the number of GPUs you have and/or would like to use...
+# AND if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+# Other General GPU Settings-------------------------------------------------------------------------------
+
+# Cache up to 2 ** this many neural net evaluations in case of transpositions in the tree.
+nnCacheSizePowerOfTwo = 23
+# Size of mutex pool for nnCache is 2 ** this
+nnMutexPoolSizePowerOfTwo = 17
+# Randomize board orientation when running neural net evals?
+nnRandomize = true
+
+
+# TENSORRT GPU settings--------------------------------------
+# These only apply when using the TENSORRT version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# trtDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# CUDA-specific GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. 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 though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+
+# OpenCL-specific GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING 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
+
+# IF USING 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
+
+# IF USING 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
+
+# You can probably guess the pattern if you have four, five, etc. 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 lines 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.
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to min(numAnalysisThreads * numSearchThreadsPerAnalysisThread, numCPUCores).
+# numEigenThreadsPerModel = X
+
+
+# Misc 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 this.
+# rootSymmetryPruning = true
+
+# Uncomment and set to true to make KataGo avoid a particular joseki that some KataGo nets misevaluate,
+# and also to improve opening diversity versus some particular other bots that like to play it all the time.
+# avoidMYTDaggerHack = false
+
+# Have KataGo mildly prefer to avoid playing the same joseki in every corner of the board.
+# Uncomment to set to a specific value. A small value like 0.005 should produce already a noticeable behavior change.
+# avoidRepeatedPatternUtility = 0.0
+
+# Enable some hacks that mitigate rare instances when passing messes up deeper searches.
+# enablePassingHacks = true
+
+# Root move selection and biases------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+# Not all of these parameters are applicable to analysis, some are only used for actual play
+
+# 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, does not affect moves above
+# 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
+
+
+# Avoid SGF Patterns ------------------------------------------------------------------------------
+# The parameters in this section provide a powerful way to customize KataGo to avoid moves that follow specific patterns
+# based on a set of provided SGF files loaded upon startup. 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 make KataGo favor the SGF patterns instead of penalizing it!
+# This number does not need to be large, even 0.001 will make a difference. Too-large values 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 that were made by players with this name.
+# For example you can 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 any 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 = ...
+
+
+
+

katrain/kataGO2/contribute_config.cfg

@@ -0,0 +1,141 @@
+
+# Be careful not to share any config files where you have entered your password.
+
+serverUrl = https://katagotraining.org/
+username = Fill in your username here
+password = Fill in your password here
+# If your password has hash signs or trailing spaces, you can also surround the password with double quotes, like this.
+# Within double quotes, backslashes are escape characters.
+# password = "Fill in your password here"
+
+# How many games should KataGo play at once? For good GPUs, putting too small a number here will be *very* inefficient.
+# For absolute-top-tier GPUs, try numbers like 32, 40, 64, etc.
+# For modern good middle-tier GPUs, you can try numbers like 8 or 16.
+# For very old or weak GPUs, or if you want KataGo to put less load on your system, try 4.
+maxSimultaneousGames = Fill in a number here
+
+# Set to true if you want one of KataGo's games to be streamed to a text file, so you can watch.
+# Follow in a separate shell with a command like the following:
+# Linux: "tail -f watchgame.txt"
+# Windows Powershell: "Get-Content .\watchgame.txt -Tail 50 -Wait"
+watchOngoingGameInFile = false
+watchOngoingGameInFileName = watchgame.txt
+
+# If you use an https proxy to connect to the internet, set these to the host and port of your proxy.
+# proxyHost = HOSTNAME
+# proxyPort = 1234
+
+# Special-purpose options. Most users should not need to adjust these.
+# onlyPlayRatingMatches = false
+# maxRatingMatches = 1
+# disablePredownloadLoop = false
+# warnTaskUnusedKeys = false
+
+# KataGo will only use one GPU by default. You can edit the below if you have multiple GPUs and want to use them all.
+
+
+# TO USE MULTIPLE GPUS:
+# Set this to the number of GPUs you have and/or would like to use.
+# **AND** if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+
+# TENSORRT GPU settings--------------------------------------
+# These only apply when using the TENSORRT version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# trtDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# CUDA GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. 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 though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+
+# OpenCL GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING 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
+
+# IF USING 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
+
+# IF USING 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
+
+# You can probably guess the pattern if you have four, five, etc. 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 lines 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.
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to numSearchThreads.
+# numEigenThreadsPerModel = X

katrain/kataGO2/contribute_example.cfg

@@ -0,0 +1,141 @@
+
+# Be careful not to share any config files where you have entered your password.
+
+serverUrl = https://katagotraining.org/
+username = Fill in your username here
+password = Fill in your password here
+# If your password has hash signs or trailing spaces, you can also surround the password with double quotes, like this.
+# Within double quotes, backslashes are escape characters.
+# password = "Fill in your password here"
+
+# How many games should KataGo play at once? For good GPUs, putting too small a number here will be *very* inefficient.
+# For absolute-top-tier GPUs, try numbers like 32, 40, 64, etc.
+# For modern good middle-tier GPUs, you can try numbers like 8 or 16.
+# For very old or weak GPUs, or if you want KataGo to put less load on your system, try 4.
+maxSimultaneousGames = Fill in a number here
+
+# Set to true if you want one of KataGo's games to be streamed to a text file, so you can watch.
+# Follow in a separate shell with a command like the following:
+# Linux: "tail -f watchgame.txt"
+# Windows Powershell: "Get-Content .\watchgame.txt -Tail 50 -Wait"
+watchOngoingGameInFile = false
+watchOngoingGameInFileName = watchgame.txt
+
+# If you use an https proxy to connect to the internet, set these to the host and port of your proxy.
+# proxyHost = HOSTNAME
+# proxyPort = 1234
+
+# Special-purpose options. Most users should not need to adjust these.
+# onlyPlayRatingMatches = false
+# maxRatingMatches = 1
+# disablePredownloadLoop = false
+# warnTaskUnusedKeys = false
+
+# KataGo will only use one GPU by default. You can edit the below if you have multiple GPUs and want to use them all.
+
+
+# TO USE MULTIPLE GPUS:
+# Set this to the number of GPUs you have and/or would like to use.
+# **AND** if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
+# numNNServerThreadsPerModel = 1
+
+
+# TENSORRT GPU settings--------------------------------------
+# These only apply when using the TENSORRT version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# trtDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# CUDA GPU settings--------------------------------------
+# These only apply when using the CUDA version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# cudaDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. 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 though you can uncomment these lines and change them
+# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
+# FP16 but you think it should.
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+
+# OpenCL GPU settings--------------------------------------
+# These only apply when using the OpenCL version of KataGo.
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# IF USING 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
+
+# IF USING 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
+
+# IF USING 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
+
+# You can probably guess the pattern if you have four, five, etc. 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 lines 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.
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to numSearchThreads.
+# numEigenThreadsPerModel = X

katrain/kataGO2/default_gtp.cfg

@@ -0,0 +1,740 @@
+# 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
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+# ------------------------------
+# 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 = ...
+

katrain/kataGO2/gtp_human5k_example.cfg

@@ -0,0 +1,194 @@
+
+# This is an example config for configuring KataGo to attempt to imitate a weaker human player.
+# Running with this config requires giving a human SL model b18c384nbt-humanv0.bin.gz
+# on the command line such as:
+# ./katago gtp -config gtp_human5k_example.cfg -model your_favorite_normal_model_for_katago.bin.gz -human-model b18c384nbt-humanv0.bin.gz
+# You can obtain the human model at https://github.com/lightvector/KataGo/releases/tag/v1.15.0
+
+# Below, the most important parts of the config for human-like play are commented.
+# See the original gtp_example for comments on other parameters.
+
+# For another useful guide on human-style analysis, see here:
+# https://github.com/lightvector/KataGo/blob/master/docs/Analysis_Engine.md#human-sl-analysis-guide
+
+# It is ALSO possible to pass in simply '-model b18c384nbt-humanv0.bin.gz' and NOT
+# pass in -human-model, i.e. use the human model as if it were KataGo's normal neural net.
+# If you do that, you need to use a config more like the normal gtp_example.cfg, not this config!
+# Keep in mind that if using the model normally, or if using -human-model but also altering
+# parameters below to blend in some of KataGo's search, KataGo's play might NOT be very human-like,
+# or might be human-like but play at a strength very different than the humanSLProfile.
+# You can experiment, some of the comments below hopefully will help illustrate things too.
+
+logDir = gtp_logs
+logAllGTPCommunication = true
+logSearchInfo = true
+logSearchInfoForChosenMove = false
+logToStderr = false
+
+# Use these rules by default, but a GUI or GTP controller might override this.
+rules = japanese
+
+# When using -human-model, we only resign when far behind since a weaker player
+# might continue to fight much longer than a strong bot normally would.
+allowResignation = true
+resignThreshold = -0.99
+resignConsecTurns = 20
+resignMinScoreDifference = 40
+resignMinMovesPerBoardArea = 0.4
+
+# Note: unless you change other parameters too, by default increasing visits won't do much.
+# If humanSLChosenMoveProp = 1.0 AND humanSLChosenMovePiklLambda is a large number,
+# then KataGo's normal search is ignored except for possibly choosing whether to pass/resign,
+# so more visits will have no effect on play. Only the raw model is used for move selection.
+# Still, having some visits is good for ensuring good pass/resign judgment, this is what the 40 visits
+# are used for unless you change other parameters to make use of them for move choice too.
+maxVisits = 40
+numSearchThreads = 1
+lagBuffer = 1.0
+
+# Rough scale in seconds to randomly delay moving, so as not to respond instantly.
+# Some moves will delay longer, some moves will delay a little less.
+delayMoveScale = 2.0
+delayMoveMax = 10.0
+
+# ===========================================================================
+# HUMAN SL PARAMETERS
+# ===========================================================================
+
+# The most important parameter for human-like play configuration!
+# Choose the "profile" of players that the human SL model will imitate.
+# Available options are:
+# preaz_{RANK from 20k to 9d} - imitate player of given rank, before AlphaZero opening style became popular
+# rank_{RANK from 20k to 9d} - imitate player of given rank, after human openings changed due to AlphaZero.
+# preaz_{BRANK}_{WRANK} or rank_{BRANK}_{WRANK} - same, but imitate how black with the rank BR and white
+#   with the rank WR would play against each other, knowing that the other player is stronger/weaker than them.
+#   Warning: for rank differences > 9 ranks, or drastically mis-matched to the handicap used in the game,
+#   this may be out of distribution due to lack of training data and the model might not behave well! Experiment with care.
+# proyear_{YEAR from 1800 to 2023} - imitate historical pros or insei from given year.
+# NOTE: for pros or high-dan ranks the raw human SL model is NOT expected to match the *strength* of the players imitated
+# because it does no search! Go AI reaching high-dan/pro ranks virtually always requires search.
+# To increase strength and make use of the visits in the search, adjust values like humanSLChosenMovePiklLambda and temperature. See:
+# https://github.com/lightvector/KataGo/blob/master/docs/Analysis_Engine.md#how-to-get-stronger-human-style-play
+humanSLProfile = preaz_5k
+
+# The probability that we should play a HUMAN-like move, rather than playing KataGo's move.
+# Applies BEFORE temperature.
+humanSLChosenMoveProp = 1.0
+
+# If true, ignore the human SL model's choice of when to pass, and still use KataGo to determine that.
+# The human SL model, in theory, is not guaranteed to be reliable at when to pass for all profiles,
+# since e.g. some historical games omit passes.
+humanSLChosenMoveIgnorePass = true
+
+# By default humanSLChosenMovePiklLambda is a large number which effectively disables it.
+# Setting it to a smaller number will "suppress" human-like moves that KataGo disapproves of.
+# In particular, if set to, for example, 0.4 when KataGo judges a human SL move to lose 0.4 utility,
+# it will substantially suppress the chance of playing that move (in particular, by a factor of exp(1)).
+# Less-bad moves will also be suppressed, but not by as much, e.g. a move losing 0.2 would get lowered
+# by a factor of exp(0.5).
+# As configured lower down, utilities by default range from -1.0 (loss) to +1.0 (win), plus up to +/- 0.3 for score.
+# WARNING: ONLY moves that KataGo actually searches will get suppressed! If a move is so bad that KataGo
+# rejects it without searching it, it will NOT get suppressed.
+# Therefore, to use humanSLChosenMovePiklLambda, it is STRONGLY recommended that you also use something
+# like humanSLRootExploreProbWeightless to ensure most human moves including bad moves get searched,
+# and ALSO use at least hundreds and ideally thousands of maxVisits, to ensure enough visits.
+humanSLChosenMovePiklLambda = 100000000
+
+# These parameters tell KataGo to use the human SL policy for exploration during search.
+# Each of these specifies the probability that KataGo will perform PUCT using the Human SL policy to
+# explore different moves, rather than using KataGo's normal policy, after a certain minimal number of visits.
+# "Root": applies only at the root of the search
+# "Pla": applies during non-root nodes of the search where it is katago's turn.
+# "Opp": applies during non-root nodes of the search where it is the opponent's turn.
+# "Weightless": search the move to evaluate it, but do NOT allow this visit to affect the parent's average utility.
+# "Weightful": search the move to evaluate it, and DO allow this visit to affect the parent's average utility.
+# For example, humanSLRootExploreProbWeightless = 0.5 would tell KataGo at the root of the search to spend
+# 50% of its visits to judge different possible human moves, but NOT to use those visits for determining the
+# value of the position (avoiding biasing the utility if some human SL moves are very bad).
+# If you don't understand these well, ask for help or look up some online explainers for MCTS (Monte-Carlo Tree Search).
+humanSLRootExploreProbWeightless = 0.0
+humanSLRootExploreProbWeightful = 0.0
+humanSLPlaExploreProbWeightless = 0.0
+humanSLPlaExploreProbWeightful = 0.0
+humanSLOppExploreProbWeightless = 0.0
+humanSLOppExploreProbWeightful = 0.0
+
+# When using the human SL policy for exploration during search, use this cPUCT.
+# This only has an effect if at least one of humanSL{Root,Pla,Opp}ExploreProbWeight{less,ful} is nonzero.
+humanSLCpuctExploration = 0.50
+
+# Same as humanSLCpuctExploration, but NEVER diminshes its exploration no matter how many visits are used.
+# Normally, PUCT will sharpen with visits and spend a diminishing proportion of visits on moves with lower utility.
+# This is the coefficient for a term that does NOT diminish, i.e. if this is 0.2, then roughly moves within
+# 0.2 utility (about 10% winrate) of the best move will forever continue getting a decent fraction of visits,
+# smoothly falling off for greater utility differences.
+# Note that in combination with Weightful exploration above, if used for Opp exploration, this could be used
+# to model an opponent that will always have some chance to make small mistakes no matter how deep they search.
+# If further this was increased to a very large value, it would model an opponent that always played according
+# to the human SL raw policy. These might be interesting to experiment with for handicap play.
+humanSLCpuctPermanent = 0.2
+
+
+# ===========================================================================
+# OTHER USEFUL PARAMETERS FOR HUMAN PLAY ADJUSTMENT
+# ===========================================================================
+
+# Choosing temperature near 1, and restricting it to only affect moves already below 1% chance,
+# so that we sample close to the full range of human play.
+# You can also reduce the temperature to settings more like the plain gtp_example.cfg.
+# Then, rather than imitating a realistic human player, it will be more like imitating the
+# *majority vote* of players at that rank. For example it would avoid a lot of blunders
+# that players of that level would make, because even if players often blunder, the *majority vote*
+# of players would be much less likely to select any given blunder that an individual player would.
+chosenMoveTemperatureEarly = 0.85
+chosenMoveTemperature = 0.70
+chosenMoveTemperatureHalflife = 80
+chosenMoveTemperatureOnlyBelowProb = 0.01  # temperature only starts to dampen moves below this
+chosenMoveSubtract = 0
+chosenMovePrune = 0
+
+# Use a small NN cache to save memory since we're using very low visits anyways. You can increase
+# these back to more like the plain gtp_example.cfg if you are doing more extensive searches to
+# improve performance.
+nnCacheSizePowerOfTwo = 17
+nnMutexPoolSizePowerOfTwo = 14
+
+# ===========================================================================
+# PARAMETERS CHANGED FROM DEFAULT TO MAKE SURE HUMAN SL USAGE WORKS WELL
+# ===========================================================================
+
+# Make sure to take into account the recent moves in the game, don't ignore history.
+# This will produce the best imitation/prediction, since humans definitely do play differently based on where the
+# most recent moves in the game were, rather than coming fresh to the board position on every turn.
+ignorePreRootHistory = false
+analysisIgnorePreRootHistory = false
+
+# Average 2 neural net samples at the root - ensures a bit smoother probabilities and results in
+# 8 * 7 / 2 = 28 possible policies instead of 8 possibilities.
+rootNumSymmetriesToSample = 2
+# LCB improves strength for KataGo, but we disable it so it doesn't mess up move selection when blending human play.
+useLcbForSelection = false
+
+# We disable dynamicScoreUtilityFactor - the human SL model can make score predictions that are a bit swingy, so
+# if we do want to do a search that blends human SL values in (TODO there isn't a way to do this anyways yet), using
+# static score utility might be a bit more stable.
+winLossUtilityFactor = 1.0
+staticScoreUtilityFactor = 0.30
+dynamicScoreUtilityFactor = 0.00
+
+# Uncertainty improves strength for KataGo normally, but messes with the weights of playouts in complicated ways,
+# so lets turn it off when doing human SL stuff.
+useUncertainty = false
+
+# Subtree value bias improves strength for KataGo normally, but messes with the values of nodes in complicated ways,
+# so let's turn it off when doing human SL stuff.
+subtreeValueBiasFactor = 0.0
+
+# Noise pruning prunes out weight from moves that KataGo thinks are bad, but if we are doing human SL we might actively
+# want to be playing or exploring and weighting "bad" but human-like moves. So disable this.
+# Warning: when this is false, there is much less protection against the search severely misbehaving when you use too many threads.
+# Make sure not to set numSearchThreads to be too large - at a minimum, keep at least a 20x buffer between
+# the number of visits you use and the number of threads you use.
+# (as an aside, ideally, you want to have visits be a sufficient factor larger than threads EVEN when
+# useNoisePruning is true, this parameter just blunts the worst effects but doesn't entirely fix the badness).
+useNoisePruning = false

katrain/kataGO2/gtp_human9d_search_example.cfg

@@ -0,0 +1,117 @@
+
+# This is an example config for configuring KataGo to attempt to imitate a 9d player and then
+# further improving the strength (to possibly modestly superhuman) using KataGo's evaluations and search.
+
+# By contrast, gtp_human5k_example.cfg uses only the raw neural net. Raw neural nets like the
+# HumanSL net without search do NOT play accurately enough to reach top human levels.
+# If you were to take gtp_human5k_example.cfg and swap out preaz_5k -> preaz_9d,
+# despite *attempting* to imitate a 9d player, it would not actually achieve that strength.
+
+# Due to the use of search, this config plays significantly stronger, and depending on how
+# you adjust visits and parameters and what `-model` you use for KataGo's model, can probably
+# reach 9d strength or higher.
+
+# Using the search greatly reduces the "humanness" of the play in exchange for strength,
+# but still retains noticeable bias from the human SL policy and may still play somewhat
+# "human-style" openings and moves.
+
+# Running with this config requires giving a human SL model b18c384nbt-humanv0.bin.gz
+# on the command line such as:
+# ./katago gtp -config gtp_human5k_example.cfg -model your_favorite_normal_model_for_katago.bin.gz -human-model b18c384nbt-humanv0.bin.gz
+# You can obtain the human model at https://github.com/lightvector/KataGo/releases/tag/v1.15.0
+
+# You can compare the config parameters here with gtp_human5k_example.cfg and see the differences
+# and how they were achieved.
+# gtp_human5k_example.cfg also has a bit more explanation on many of the parameters.
+
+logDir = gtp_logs
+logAllGTPCommunication = true
+logSearchInfo = true
+logSearchInfoForChosenMove = false
+logToStderr = false
+
+rules = japanese
+
+# Adjusted resignation settings compared to gtp_human5k_example.cfg, to resign a bit more easily.
+allowResignation = true
+resignThreshold = -0.98  # was -0.99 in gtp_human5k_example.cfg
+resignConsecTurns = 10   # was 20 in gtp_human5k_example.cfg
+resignMinScoreDifference = 20      # was 40 in gtp_human5k_example.cfg
+resignMinMovesPerBoardArea = 0.40
+
+# maxVisits: With a config like this, more visits *will* make it stronger and fewer visits will make it weaker.
+# But strength will NOT scale indefinitely upward with visits unlike KataGo's normal config without human SL.
+# This is due to the strong bias of the human SL network.
+# You can reduce this number if you are on weaker hardware. It may reduce strength a bit but will still
+# provide a huge strength boost over using the humanSL network alone as in gtp_human5k_example.cfg
+# It's NOT recommended to reduce this below about 30-40 visits, since that will result in too few explorations of a variety of moves.
+# If you want to adjust strength, see humanSLChosenMovePiklLambda instead.
+maxVisits = 400   # 40 in gtp_human5k_example.cfg.
+
+# Having more than one thread speeds up search when visits are larger.
+# Make sure the number of threads is much smaller than the number of visits, however.
+numSearchThreads = 8  # 1 in gtp_human5k_example.cfg.
+lagBuffer = 1.0
+
+# Rough scale in seconds to randomly delay moving, so as not to respond instantly.
+# Some moves will delay longer, some moves will delay a little less.
+delayMoveScale = 2.0
+delayMoveMax = 10.0
+
+# Imitate human amateur 9d players (roughly based on ~KGS ranks)
+humanSLProfile = preaz_9d    # was preaz_5k in gtp_human5k_example.cfg
+humanSLChosenMoveProp = 1.0
+humanSLChosenMoveIgnorePass = true
+
+# When a move starts to lose more than 0.08 utility (several percent winrate), downweight it.
+# Increase this number to reduce the strength and use the human SL policy more and KataGo's evaluations less.
+# Decrease this number a little more to improve strength even further and play less human-like.
+#   (although below 0.02 you probably are better off going back to a normal KataGo config and scaling visits).
+# Since this uses KataGo's judgment, even at large values and with a weak-ranked humanSLProfile
+# this may still produce a very strong player.
+# To calibrate for some but less strength gain, it will take experimentation.
+# In addition to increasing this value a lot, e.g. (0.2, 0.5, 1.0, 2.0,...)
+# you can also try using old/small KataGo nets (e.g. b6c96, b10c128), reducing visits (though reducing below about 30-40
+# is NOT recommended), or using the humanSLModel itself as the main "-model".
+humanSLChosenMovePiklLambda = 0.08  # was 100000000 in gtp_human5k_example.cfg.
+
+# Spend 80% of visits to explore humanSL moves to ensure they get evaluations to use with humanSLChosenMovePiklLambda
+humanSLRootExploreProbWeightless = 0.8  # was 0 in gtp_human5k_example.cfg.
+humanSLRootExploreProbWeightful = 0.0
+humanSLPlaExploreProbWeightless = 0.0
+humanSLPlaExploreProbWeightful = 0.0
+humanSLOppExploreProbWeightless = 0.0
+humanSLOppExploreProbWeightful = 0.0
+
+humanSLCpuctExploration = 0.50
+# Explore moves very widely according to the human SL policy even if they lose up to about 2.0 utility.
+# This is not the largest this value can go, you increase it further to do even less filtering based on winrates
+# as far as move exploration goes.
+humanSLCpuctPermanent = 2.0  # was 0.2 in gtp_human5k_example.cfg.
+
+# Reduced temperature settings - reduce the chance of picking unlikely low policy or low-value moves.
+chosenMoveTemperatureEarly = 0.70  # was 0.85 in gtp_human5k_example.cfg.
+chosenMoveTemperature = 0.25       # was 0.70 in gtp_human5k_example.cfg.
+chosenMoveTemperatureHalflife = 30         # was 80 in gtp_human5k_example.cfg.
+chosenMoveTemperatureOnlyBelowProb = 1.0   # was 0.01 in gtp_human5k_example.cfg.
+chosenMoveSubtract = 0
+chosenMovePrune = 0
+
+# Since we're doing more search, increase size of neural net cache a bit for performance.
+nnCacheSizePowerOfTwo = 20    # was 17 in gtp_human5k_example.cfg.
+nnMutexPoolSizePowerOfTwo = 14
+
+ignorePreRootHistory = false
+analysisIgnorePreRootHistory = false
+
+rootNumSymmetriesToSample = 2
+useLcbForSelection = false
+
+# Make score utility count a bit more
+winLossUtilityFactor = 1.0
+staticScoreUtilityFactor = 0.5    # was 0.3 in gtp_human5k_example.cfg.
+dynamicScoreUtilityFactor = 0.5   # was 0.0 in gtp_human5k_example.cfg.
+
+useUncertainty = false
+subtreeValueBiasFactor = 0.0
+useNoisePruning = false

katrain/kataGO2/katago.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:911a375bf182288c769d8a24b8e43d0a6b42487ce0b5e93c7391f4e929e35ba2
+size 4812800

katrain/kataGO2/libcrypto-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f6560dc57d177417932d04295fcb5f5b9b3414bd3baa75897d8e8bb49e904b7
+size 5148672

katrain/kataGO2/libssl-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45434db8a17a9ddf3953d85de7e2e4d0c22866593c490e18128ee5c7931db6d1
+size 776704

katrain/kataGO2/libz.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f41b06ae70e84ce4215e657a9fed61b71b590423d0b19687dced8f95d759b319
+size 95232

katrain/kataGO2/libzip.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c3151e9eab8bddffffd0cd180a5258b0de6cb8e780e47f7bd61b48875c1522f
+size 184832

katrain/kataGO2/match_example.cfg

@@ -0,0 +1,244 @@
+# Example config for C++ match runner
+# This is an example template config for the "match" subcommand of KataGo. e.g:
+# ./katago match -config-file configs/match_example.cfg -log-file match.log -sgf-output-dir match_sgfs/
+#
+# On a good GPU, the match subcommand enables testing of KataGo nets against each other
+# or a net against itself with different parameters vastly faster than anything
+# else, because multiple games can share GPU batching.
+#
+# Beware however of using this to test differing numbers of threads or test time-based search limits.
+# Because many games will be run simultaneously, they will compete from each other for compute power,
+# and although the total will run much faster than if you had run them one by one, you might also get
+# substantially different results not reflective of the strength of a configuration when run in a real
+# match setting, on a machine by itself. For fixed numbers of visits or playouts instead of fixed time,
+# and with numSearchThreads = 1, there should be no problem though, because then the compute time has
+# no influence on the result of the computation.
+#
+# See gtp config for descriptions of most of these params.
+#
+# For almost any parameter in this config that is related to a bot, rather than to the match as a whole
+# (so, visits, search parameters, model files, etc. but NOT the rules, max games, log info, etc)
+# you can specify them differentially between different bots by appending the index of the bot.
+# For example, if you were testing different numbers of visits, you could try:
+#
+# numBots = 3
+# botName0 = lowVisits
+# botName1 = midVisits
+# botName2 = highVisits
+#
+# maxVisits0 = 100
+# maxVisits1 = 300
+# maxVisits2 = 1000
+#
+# Or, if you were testing different neural nets, with different search configurations, you could do:
+#
+# nnModelFile0 = path/to/first/model/file.bin.gz
+# nnModelFile1 = path/to/second/model/file.bin.gz
+#
+# And specify different search parameters for them if you wanted:
+# cpuctExploration0 = 1.5
+# cpuctExploration1 = 1.3
+
+# Logs------------------------------------------------------------------------------------
+
+logSearchInfo = false
+logMoves = false
+logGamesEvery = 50
+logToStdout = true
+
+# Bots-------------------------------------------------------------------------------------
+# For multiple bots, you can specify their names as botName0,botName1, etc.
+# If the bots are using different models, specify nnModelFile0, nnModelFile1, etc.
+
+numBots=1
+botName=FOO
+nnModelFile=PATH_TO_MODEL
+
+# These bots will not play each other, but will still be opponents for other bots
+# secondaryBots = 0,1,3
+# Only these bots will actually play games. Useful if you have a config file with many more
+# bots defined but you want to only selectively enable a few.
+# includeBots = 0,2,6
+
+# Specify extra pairings of bots to play.
+# extraPairs = 0-4,1-4
+# Uncomment and set this to true if you don't want extraPairs to be mirrored by color.
+# (i.e. 0-4 should mean 0 plays black and 4 plays white only, rather than having two games with swapped colors).
+# extraPairsAreOneSidedBW = false
+
+# Match-----------------------------------------------------------------------------------
+numGameThreads=8 # How many games to run in parallel at a time?
+
+numGamesTotal=1000000
+maxMovesPerGame=1200
+
+allowResignation = true
+resignThreshold = -0.95
+resignConsecTurns = 6
+
+# Rules------------------------------------------------------------------------------------
+# See https://lightvector.github.io/KataGo/rules.html for a description of the rules.
+
+koRules = SIMPLE,POSITIONAL,SITUATIONAL
+scoringRules = AREA,TERRITORY
+taxRules = NONE,SEKI,ALL
+multiStoneSuicideLegals = false,true
+hasButtons = false,true
+
+bSizes = 19,13,9
+bSizeRelProbs = 90,5,5
+
+# If you want to specify exact distributions of boards, including rectangles, specify this instead
+# of bSizes. E.g. to randomize between a 7x5, a 9x12, and a 10x10 board with probabilities 25%, 25%, 50%:
+# bSizesXY=7-5,9-12,10-10
+# bSizeRelProbs = 1,1,2
+
+komiAuto = True   # Automatically adjust komi to what the neural nets think are fair
+# komiMean = 7.5  # Specify explicit komi
+# policyInitAreaProp = 0
+# compensateAfterPolicyInitProb = 1.0  # Additionally make komi fair this often after the high-temperature moves.
+# policyInitAreaTemperature = 1
+handicapProb = 0.0
+handicapCompensateKomiProb = 1.0
+# numExtraBlackFixed = 3  # When playing handicap games, always use exactly this many extra black moves
+
+# Search limits-----------------------------------------------------------------------------------
+
+maxVisits = 500
+# maxPlayouts = 300
+# maxTime = 60
+
+numSearchThreads = 1
+
+# GPU Settings-------------------------------------------------------------------------------
+
+nnMaxBatchSize = 32
+nnCacheSizePowerOfTwo = 21
+nnMutexPoolSizePowerOfTwo = 17
+nnRandomize = true
+
+
+# How many threads should there be to feed positions to the neural net?
+# Server threads are indexed 0,1,...(n-1) for the purposes of the below GPU settings arguments
+# that specify which threads should use which GPUs.
+# NOTE: This parameter is probably ONLY useful if you have multiple GPUs, since each GPU will need a thread.
+# If you're tuning single-GPU performance, use numSearchThreads instead.
+numNNServerThreadsPerModel = 1
+
+
+# TENSORRT GPU settings--------------------------------------
+# These only apply when using the TENSORRT version of KataGo.
+
+# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
+# trtDeviceToUse = 0
+
+# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+
+# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
+# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
+# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
+# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2
+
+# You can probably guess the pattern if you have four, five, etc. GPUs.
+
+
+# CUDA GPU settings--------------------------------------
+# For the below, "model" refers to a neural net, from the nnModelFile parameter(s) above.
+# cudaGpuToUse = 0 #use gpu 0 for all server threads (numNNServerThreadsPerModel) unless otherwise specified per-model or per-thread-per-model
+# cudaGpuToUseModel0 = 3 #use gpu 3 for model 0 for all threads unless otherwise specified per-thread for this model
+# cudaGpuToUseModel1 = 2 #use gpu 2 for model 1 for all threads unless otherwise specified per-thread for this model
+# cudaGpuToUseModel0Thread0 = 3 #use gpu 3 for model 0, server thread 0
+# cudaGpuToUseModel0Thread1 = 2 #use gpu 2 for model 0, server thread 1
+
+# cudaUseFP16 = auto
+# cudaUseNHWC = auto
+
+
+# ------------------------------
+# Metal GPU settings
+# ------------------------------
+# These only apply when using the METAL version of KataGo.
+
+# For one Metal instance: KataGo will automatically use the default device.
+# metalDeviceToUse = 0
+
+# For two Metal instance: Uncomment these options, AND set numNNServerThreadsPerModel = 2 above.
+# This will create two Metal instances, best overlapping the GPU and CPU execution.
+# metalDeviceToUseThread0 = 0
+# metalDeviceToUseThread1 = 1
+
+# The pattern continues for additional Metal instances.
+
+
+# OpenCL GPU settings--------------------------------------
+# These only apply when using OpenCL as the backend for inference.
+# (For GTP, we only ever have one model, when playing matches, we might have more than one, see match_example.cfg)
+
+# Default behavior is just to always use gpu 0, you will want to uncomment and adjust one or more of these lines
+# to take advantage of a multi-gpu machine
+# openclGpuToUse = 0 #use gpu 0 for all server threads (numNNServerThreadsPerModel) unless otherwise specified per-model or per-thread-per-model
+# openclGpuToUseModel0 = 3 #use gpu 3 for model 0 for all threads unless otherwise specified per-thread for this model
+# openclGpuToUseModel1 = 2 #use gpu 2 for model 1 for all threads unless otherwise specified per-thread for this model
+# openclGpuToUseModel0Thread0 = 3 #use gpu 3 for model 0, server thread 0
+# openclGpuToUseModel0Thread1 = 2 #use gpu 2 for model 0, server thread 1
+
+# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
+# openclReTunePerBoardSize = true
+
+# openclUseFP16 = auto
+
+
+# Eigen-specific settings--------------------------------------
+# These only apply when using the Eigen (pure CPU) version of KataGo.
+
+# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
+# It defaults to numSearchThreads.
+# numEigenThreadsPerModel = X
+
+
+# Root move selection and biases------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+# Values in this section can be specified per-bot as well
+
+chosenMoveTemperatureEarly = 0.60
+# chosenMoveTemperatureHalflife = 19
+chosenMoveTemperature = 0.20
+# chosenMoveSubtract = 0
+# chosenMovePrune = 1
+
+# rootNumSymmetriesToSample = 1
+
+# useLcbForSelection = true
+# lcbStdevs = 5.0
+# minVisitPropForLCB = 0.15
+
+# Internal params------------------------------------------------------------------------------
+# Uncomment and edit any of the below values to change them from their default.
+# Values in this section can be specified per-bot as well
+
+# winLossUtilityFactor = 1.0
+# staticScoreUtilityFactor = 0.10
+# dynamicScoreUtilityFactor = 0.30
+# dynamicScoreCenterZeroWeight = 0.20
+# dynamicScoreCenterScale = 0.75
+# noResultUtilityForWhite = 0.0
+# drawEquivalentWinsForWhite = 0.5
+
+# cpuctExploration = 0.9
+# cpuctExplorationLog = 0.4
+# fpuReductionMax = 0.2
+# rootFpuReductionMax = 0.1
+# fpuParentWeightByVisitedPolicy = true
+# valueWeightExponent = 0.25
+# rootEndingBonusPoints = 0.5
+# rootPruneUselessMoves = true
+# subtreeValueBiasFactor = 0.45
+# subtreeValueBiasWeightExponent = 0.85
+# useGraphSearch = true
+# rootPolicyOptimism = 0.2
+# policyOptimism = 1.0
+
+# nodeTableShardsPowerOfTwo = 16
+# numVirtualLossesPerThread = 1

katrain/kataGO2/msvcp140.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:003da4807acdc912e67edba49be574daa5238bb7acff871d8666d16f8072ff89
+size 579920

katrain/kataGO2/msvcp140_1.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a61901a4d719a3e1cc4fa8f629218571330331e8dde2ef1f05c34845b180928e
+size 35664

katrain/kataGO2/msvcp140_2.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d15cfe238ac1863bbe65501f05d561162f28032b80f2c8d9a1fc7b22f8445a2
+size 197488

katrain/kataGO2/msvcp140_atomic_wait.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fcf613254644c2ea451a693d7737741b8041f11decb8feffd3b34e00220620a
+size 50032

katrain/kataGO2/msvcp140_codecvt_ids.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a714b498ab7b4b0508e69f66ca15196df605844d4d6d5e43969a5f1fd7d7e9e4
+size 31600

katrain/kataGO2/vcruntime140.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8f950b4357ec12cfccddc9094cca56a3d5244b95e09ea6e9a746489f2d58736
+size 109392

katrain/kataGO2/vcruntime140_1.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4b533a94e02c574780e4b333fcf0889f65ed00d39e32c0fbbda2116f185873f
+size 49520

katrain/models2/kata1-b28c512nbt-s10544735488-d5229296520.bin.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87a9a8cefad1bbdcda9b63089ff03d88fefff692d78217daab9d32ec9bb7a301
+size 271439386

readme.txt

@@ -26,26 +26,32 @@ katrain\katrain\core\engine.py
 
 # 默认配置文件
 C:/Users/i/.katrain/config.json
-  {
-      "engine": {
-          "katago": ""katrain/KataGo2/katago.exe"",
-          "altcommand": "",
-          "model": "katrain/models2/kata1-b28c512nbt-s10544735488-d5229296520.bin.gz",
-          "humanlike_model": "",
-          "config": "katrain/KataGo2/analysis_config.cfg",
-          "max_visits": 500,
-          "fast_visits": 25,
-          "max_time": 8.0,
-          "wide_root_noise": 0.04,
-          "_enable_ownership": true
-      },
-      "contribute": {
-          "katago": "",
-          "config": "katrain/KataGo2/contribute_config.cfg",
 
+
+# 先删掉 C:/Users/i/.katrain/config.json
+vi katrain\katrain\config.json
+{
+    "engine": {
+        "katago": "katrain/KataGo2/katago.exe",
+        "altcommand": "",
+        "model": "katrain/models2/kata1-b28c512nbt-s10544735488-d5229296520.bin.gz",
+        "humanlike_model": "",
+        "config": "katrain/KataGo2/analysis_config.cfg",
+        "max_visits": 500,
+        "fast_visits": 25,
+        "max_time": 8.0,
+        "wide_root_noise": 0.04,
+        "_enable_ownership": true
+    },
+    "contribute": {
+        "katago": "",
+        "config": "katrain/KataGo2/contribute_config.cfg",
+  
   # 改成这样
 
 
+
+
 katrain\katrain\core\engine.py
   class KataGoEngine(BaseEngine):
         model = find_package_resource(config["model"])