goshape 0.1.0__py3-none-any.whl

goshape-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: goshape
+Version: 0.1.0
+Summary: Shape Habits Analysis and Personalized Evaluation
+Author: Sander Land
+License-File: LICENSE
+Requires-Python: <3.14,>=3.10
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: numpy>=2.1.2
+Requires-Dist: pyqtgraph>=0.13.7
+Requires-Dist: pysgf>=0.9.0
+Requires-Dist: pyside6>=6.5.0
+Description-Content-Type: text/markdown
+
+# SHAPE: Shape Habits Analysis and Personalized Evaluation
+
+SHAPE is an app to play Go with AI feedback, specifically designed to point out typical bad habits for your current skill level.
+
+This is an experimental project, and is unlikely to ever become very polished.
+
+## Quick Start
+
+Run the application directly using `uvx`:
+
+```bash
+uvx goshape
+```
+
+The first time you run this, `uv` will automatically download the package, create a virtual environment, and install all dependencies.
+
+When the application starts for the first time, it will check for the required KataGo models in `~/.katrain/`. If they are not found, a dialog will appear to guide you through downloading them.
+
+## Manual
+
+The most important settings are:
+
+- Current Rank: Your current Go skill level, which determines which mistakes are considered "typical" for your level.
+- Target Rank: The skill level you want to aim for. Even if a move is a huge mistake, if it was a mistake still common at that level, it won't be considered relevant.
+- Opponent: The type and level of the AI opponent. 
+  - This supports modern, pre-alphago style, and historical professional style. 
+  - Like the feedback, it is likely to be somewhat weaker than actual professionals or high-dan players.
+
+The game will automatically halt when a typical mistake is made by you, allowing you to analyze, undo, or just continue.
+
+Keep in mind that the techniques used are more likely to be helpful up to low-dan levels, and may not be helpful at all at high levels.
+
+### Heatmap
+
+The policy heatmap shows the probability of the top moves being made for your current rank, target rank, and AI.
+Note that a move being probable does not mean it is a good move.
+You can select multiple heatmaps to get a blended view, where size/number is the average probability, and the color is the average rank (current, target, AI).
+
+
+## TODO list from Gemini
+
+Based on a code review, here are some suggested areas for improvement:
+
+### High Impact
+- **User-Friendly Errors (`main.py`):** Show GUI dialogs for errors instead of crashing the application.
+
+### Medium Impact
+- **Refactor `GameNode` (`game_logic.py`):** Extract board state and rule logic into a separate `Board` class to simplify `GameNode` and improve modularity.
+
+### Low Impact
+- **Code Clarity (`game_logic.py`):** Improve code readability.
+

goshape-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+shape/game_logic.py,sha256=oJDMmOubsotVwybN-2zx2lOFVofxqGzDddQk9FV5TX0,10092
+shape/main.py,sha256=evEBAUwIk479yVqsmE4w696-DHzicR_e9rF8bw_ruDs,1050
+shape/utils.py,sha256=Of8J3dY12H_iyYnpxNPUUZoicNkcxW7GsZvlawgLp-M,190
+shape/katago/analysis.cfg,sha256=1HrXtB74A4LK-prJOr4c5iwewv21CAlypE27A4lKnN0,11958
+shape/katago/downloader.py,sha256=WfZsXx_ljYtcYgBb1vjC-_JnAl36GPmwhyafkjEEyD0,16430
+shape/katago/engine.py,sha256=wQerIFLI4s0jd1SPQCmLs5f-2-uCwS8bNbHw90K-MGo,6913
+shape/ui/board_view.py,sha256=VIcJQp_z3Gax4hA89T71PF3uzw1P04jgEZ8h0jm0TtE,12958
+shape/ui/main_window.py,sha256=PRAY6kFnfaVNNkUynAQ9na1SdisjAluDx8ct2TRn078,13655
+shape/ui/tab_analysis.py,sha256=oEG3SdyYkphqXzv-Z49yLPbUSzRiH47L7P2Codz5qng,4316
+shape/ui/tab_config.py,sha256=jfGbQ6M_guMNF1jj7VMnJS2CBCOi7AoswnviASyNgss,2896
+shape/ui/tab_main_control.py,sha256=Pv4S0IPwvOMIlaWp-Zolk5X8er8rKKQLAZBBfFB-R8Q,13170
+shape/ui/ui_utils.py,sha256=kBV5F7lX-uV8RZRaVs3PCoundC77ZE_vW2Sc8fiUzI8,2872
+goshape-0.1.0.dist-info/METADATA,sha256=x4QqTkOCRlJ7VQ5DaxgrlzPneQv9mET_y0vpfUJpgsI,2712
+goshape-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+goshape-0.1.0.dist-info/entry_points.txt,sha256=Aal5yaSsJF01WZpewmQDCat4APe3DSz2hsXbtCSPjko,44
+goshape-0.1.0.dist-info/licenses/LICENSE,sha256=7vQREz1XrvLQyCJl_0rF5nh51cx9Wv5UkPuuXjyAGQU,2556
+goshape-0.1.0.dist-info/RECORD,,

goshape-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

goshape-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+goshape = shape.main:main

goshape-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,40 @@
+This repository includes:
+
+1. Binaries for 'KataGo', which is Copyright David J Wu et al.
+For on related licenses for these binaries and libraries see https://github.com/lightvector/KataGo
+
+2. Icons from www.flaticon.com, used with permission with the following attributions:
+- Equalize icon and Thrash Icon: derived from work by bqlqn from www.flaticon.com
+- Other Menu icons, Finish, Collaboration and Flag icons: derived from work by Freepik from www.flaticon.com
+- Collapse branch icon: derived from work by Kirill Kazachek from www.flaticon.com
+- Prune icon: derived from work by Pixelmeetup from www.flaticon.com
+- Reset icon: derived from work by Pixel Perfect from www.flaticon.com
+- Rotate icon:  derived from work by Frey Wazza from www.flaticon.com
+
+3. The True Type Font DIGITAL-7 version 1.02 by Sizenko Alexander, which is free for non-commercial use.
+
+4. The Noto Sans fonts from google which are covered by the SIL open font license v1.1 included in the katrain/fonts directory.
+
+-----------------------------------------------------------------------------------------
+Aside from the above, the license for all other content in this repository is as follows:
+-----------------------------------------------------------------------------------------
+
+Copyright 2020 Sander Land and/or other authors of the content in this repository.
+(See 'CONTRIBUTIONS.md' file for a list of authors as well as other indirect contributors).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+-----------------------------------------------------------------------------------------

shape/game_logic.py

@@ -0,0 +1,265 @@
+import copy
+
+import numpy as np
+from pysgf import SGF, Move, SGFNode
+
+from shape.utils import setup_logging
+
+logger = setup_logging()
+
+
+class PolicyData:
+    @staticmethod
+    def grid_from_data(policy_data: list[float] | np.ndarray):
+        size = int(len(policy_data) ** 0.5)
+        return np.reshape(policy_data[:-1], (size, size))[::-1]
+
+    def __init__(self, policy_data: list[float] | np.ndarray):
+        self.data = np.array(policy_data)
+        self.grid = self.grid_from_data(self.data)
+        self.pass_prob = self.data[-1]
+        self.max_prob = np.max(self.data)
+
+    def at(self, move: Move) -> tuple[float, float]:
+        if move.is_pass:
+            return self.pass_prob, self.pass_prob / self.max_prob
+        col, row = move.coords
+        return self.grid[row][col], self.grid[row][col] / self.max_prob
+
+    def sample(
+        self,
+        top_k: int = 10000,
+        top_p: float = 1e9,
+        min_p: float = 0.0,
+        exclude_pass: bool = True,
+        secondary_data: np.ndarray | None = None,
+    ) -> tuple[list[tuple[Move, float, float]], str]:
+        secondary_data_data = secondary_data if secondary_data is not None else self.grid
+        moves = [
+            (Move(coords=(col, row)), prob, d)
+            for row, (policy_row, secondary_data_row) in enumerate(zip(self.grid, secondary_data_data, strict=False))
+            for col, (prob, d) in enumerate(zip(policy_row, secondary_data_row, strict=False))
+            if prob > 0
+        ]
+        if self.pass_prob > 0 and not exclude_pass:
+            moves.append(("pass", self.pass_prob, None))
+        moves.sort(key=lambda x: x[1], reverse=True)
+        highest_prob = moves[0][1]
+        top_moves = []
+        total_prob = 0
+        for i, (move, prob, *data) in enumerate(moves, 1):
+            if prob < min_p * highest_prob:
+                return top_moves, "min_p"
+            top_moves.append((move, prob, *data))
+            total_prob += prob
+
+            if i == top_k:
+                return top_moves, "top_k"
+            if total_prob >= top_p:
+                return top_moves, "top_p"
+
+        return top_moves, "all"
+
+
+class Analysis:
+    REQUESTED = object()
+
+    def __init__(self, key: str | None, data: dict):
+        self.key = key
+        self.data = data
+        self.ai_policy = PolicyData(data.pop("policy"))
+        if "humanPolicy" in data:
+            self.human_policy = PolicyData(data.pop("humanPolicy"))
+        else:
+            assert key is None, f"Expected human policy for key {key}"
+            self.human_policy = self.ai_policy
+
+    @property
+    def root_info(self) -> dict:
+        return self.data.get("rootInfo", {})
+
+    def ai_score(self) -> float | None:
+        return self.root_info.get("scoreLead")
+
+    def win_rate(self) -> float | None:
+        return self.root_info.get("winrate")
+
+    def visit_count(self) -> int:
+        return self.root_info.get("visits", 0)
+
+    def ai_moves(self) -> list:
+        return self.data.get("moveInfos", [])
+
+
+class GameNode(SGFNode):
+    def __init__(self, parent: "GameNode | None" = None, properties=None, move=None):
+        super().__init__(parent, properties, move)
+        if parent:
+            assert move is not None
+            self.board_state = self._board_state_after_move(parent.board_state, move)
+        else:
+            bx, by = self.board_size
+            self.board_state: list[list[str | None]] = [[None for _ in range(bx)] for _ in range(by)]
+        self.analyses = {}
+        self.ai_move_requested = False  # flag to indicate if ai move was manually requested
+        self.autoplay_halted_reason: str | None = None  # flag to indicate if autoplay was automatically halted
+
+    @property
+    def square_board_size(self) -> int:
+        bx, by = self.board_size
+        assert bx == by, "Non-square board size not supported"
+        return bx
+
+    def game_ended(self) -> bool:
+        return self.is_pass and self.parent.is_pass
+
+    def delete_child(self, child: "GameNode"):
+        self.children = [c for c in self.children if c is not child]
+
+    def _board_state_after_move(self, board_state: list[list[str | None]], move: Move) -> list[list[str | None]]:
+        new_board_state = copy.deepcopy(board_state)
+        if move.is_pass:
+            return new_board_state
+        col, row = move.coords
+        new_board_state[row][col] = move.player
+        captured = self._remove_captured_stones(new_board_state, col, row, move.opponent)
+        if captured:
+            self._remove_group(new_board_state, captured)
+        else:
+            group = self._get_group(new_board_state, col, row)
+            if not self._group_has_liberties(new_board_state, group):
+                self._remove_group(new_board_state, group)  # allow suicide
+        return new_board_state
+
+    def _is_valid_move(self, move: Move):
+        if move.is_pass:
+            return True
+        col, row = move.coords
+        if not (0 <= row < len(self.board_state) and 0 <= col < len(self.board_state[0])):
+            logger.error("Point is out of bounds")
+            return False
+        if self.board_state[row][col] is not None:
+            logger.error("Point is already occupied")
+            return False
+        return True
+
+    def _remove_captured_stones(self, board_state, col, row, opponent):
+        captured = []
+        for dcol, drow in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
+            ncol, nrow = col + dcol, row + drow
+            if 0 <= nrow < len(board_state) and 0 <= ncol < len(board_state[0]) and board_state[nrow][ncol] == opponent:
+                group = self._get_group(board_state, ncol, nrow)
+                if not self._group_has_liberties(board_state, group):
+                    self._remove_group(board_state, group)
+                    captured.extend(group)
+        return captured
+
+    def _get_group(self, board_state, col, row):
+        color = board_state[row][col]
+        group = set()
+        stack = [(col, row)]
+        while stack:
+            ccol, crow = stack.pop()
+            if (ccol, crow) not in group:
+                group.add((ccol, crow))
+                for dcol, drow in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
+                    ncol, nrow = ccol + dcol, crow + drow
+                    if (
+                        0 <= nrow < len(board_state)
+                        and 0 <= ncol < len(board_state[0])
+                        and board_state[nrow][ncol] == color
+                    ):
+                        stack.append((ncol, nrow))
+        return group
+
+    def _has_liberties(self, board_state, col, row):
+        for dcol, drow in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
+            ncol, nrow = col + dcol, row + drow
+            if 0 <= nrow < len(board_state) and 0 <= ncol < len(board_state[0]) and board_state[nrow][ncol] is None:
+                return True
+        return False
+
+    def _remove_group(self, board_state, group):
+        for col, row in group:
+            board_state[row][col] = None
+
+    def _group_has_liberties(self, board_state, group):
+        return any(self._has_liberties(board_state, col, row) for col, row in group)
+
+    def store_analysis(self, analysis: dict, key: str | None):
+        current_analysis = self.get_analysis(key)
+        parsed_analysis = Analysis(key, analysis)
+        if current_analysis and current_analysis.visit_count() >= parsed_analysis.visit_count():
+            return  # ignore if we already have a better analysis
+        self.analyses[key] = parsed_analysis
+
+    def mark_analysis_requested(self, key: str | None):
+        if key not in self.analyses:
+            self.analyses[key] = Analysis.REQUESTED  # requested but not yet received
+
+    def analysis_requested(self, key: str | None):
+        return key in self.analyses  # None means requested but not yet received
+
+    def get_analysis(self, key: str | None, parent: bool = False) -> Analysis | None:
+        if parent:
+            return self.parent.get_analysis(key) if self.parent else None
+        analysis = self.analyses.get(key)
+        return None if analysis is Analysis.REQUESTED else analysis
+
+    def mistake_size(self) -> float | None:
+        current_analysis = self.get_analysis(None)
+        parent_analysis = None
+        if self.parent:
+            parent_analysis = self.parent.get_analysis(None)
+
+        if not current_analysis or not parent_analysis:
+            return None
+
+        current_score = current_analysis.ai_score()
+        parent_score = parent_analysis.ai_score()
+        if current_score is None or parent_score is None:
+            return None
+
+        score_diff = current_score - parent_score
+        return score_diff if self.player == "W" else -score_diff
+
+
+class ShapeSGF(SGF):
+    _NODE_CLASS = GameNode
+
+
+class GameLogic:
+    def __init__(self):
+        self.new_game()
+
+    def new_game(self, board_size=19, **rules):
+        self.current_node = GameNode(properties={"RU": "JP", "KM": 6.5, "SZ": board_size, **rules})
+
+    def __getattr__(self, attr):
+        if not hasattr(self.current_node, attr):
+            raise AttributeError(f"'GameLogic' object has no attribute '{attr}'")
+        return getattr(self.current_node, attr)
+
+    def make_move(self, move: Move) -> bool:
+        if not self.current_node._is_valid_move(move):
+            return False
+        self.current_node = self.current_node.play(move)
+        return True
+
+    def undo_move(self, n: int = 1):
+        while (n := n - 1) >= 0 and self.current_node.parent:
+            self.current_node = self.current_node.parent
+
+    def redo_move(self, n: int = 1):
+        while (n := n - 1) >= 0 and self.current_node.children:
+            self.current_node = self.current_node.children[0]
+
+    def get_score_history(self) -> list[tuple[int, float]]:
+        nodes = self.current_node.nodes_from_root
+        return [(node.depth, ai_analysis.ai_score()) for node in nodes if (ai_analysis := node.get_analysis(None))]
+
+    def export_sgf(self, player_names):
+        return self.current_node.root.sgf()
+
+    def import_sgf(self, sgf_data: str):
+        self.current_node = ShapeSGF.parse(sgf_data)

shape/katago/analysis.cfg

@@ -0,0 +1,215 @@
+# Example config for C++ (non-python) gtp bot
+
+# 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?
+# 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.
+# logSearchInfo = false   # Log debug info for every search performed
+
+# Controls the number of moves after the first move in a variation.
+# analysisPVLen = 15
+
+# Report winrates for analysis as (BLACK|WHITE|SIDETOMOVE).
+reportAnalysisWinratesAs = BLACK
+
+# 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 games using repeated GTP "play" commands for black rather than GTP "place_free_handicap" commands.
+# However, it may also lead to incorrect undersanding of komi if whiteBonusPerHandicapStone = 1 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
+
+
+# numSearchThreads is the number of threads to use in each MCTS tree search in parallel for any individual position.
+# But NOTE: Analysis engine also specifies max number of POSITIONS to be able to search in parallel via command line
+# argument, -num-analysis-threads.
+
+# Parallelization across positions is more efficient since the threads on different positions operate
+# on different MCTS trees so they don't have to synchronize with each other. Also, multiple threads on the same MCTS
+# tree weakens the search (holding playouts fixed) due to out of date statistics on nodes and suboptimal exploration,
+# although the loss is still quite small for only 2,4,8 threads. So you often want to keep numSearchThreads small,
+# unlike in GTP.
+
+# But obviously you only get the benefit of parallelization across positions when you actually have lots of positions
+# that you are querying at once.
+
+# Therefore:
+# * If you plan to use the analysis engine only for batch processing large numbers of positions,
+#   it's preferable to set this to only a small number (e.g. 1,2,4) and use a higher -num-analysis-threads.
+# * 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 this to a larger number and use somewhat fewer analysis threads,
+#   That way, individual searches complete faster due to having more threads on each one and doing fewer other ones at a time.
+
+# For 19x19 boards, weaker GPUs probably want a TOTAL number of threads (numSearchThreads * num-analysis-threads)
+# 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 doesn't necessarily have much to do with how many cores you
+# have on your system, and could easily exceed the number of cores. GPU batching is (usually) the dominant consideration.
+numAnalysisThreads = 12
+numSearchThreads = 4
+
+# 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 = 96
+
+# 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
+
+# Uncomment and set these smaller if you ONLY are going to use the analysis engine 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
+
+# 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 = 20
+# Size of mutex pool for nnCache is 2 ** this
+nnMutexPoolSizePowerOfTwo = 16
+# Randomize board orientation when running neural net evals?
+nnRandomize = true
+
+# 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
+
+
+# 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
+
+# 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.
+
+
+# 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 (WITH 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
+# Policy temperature to use for move selection
+# policyTemperature = 1.0
+
+# ROOT POSITIONAL BIASES--------------
+# Uncomment to have KataGo apply small biases to the root search results
+# This can help reduce the "flat" evaluation of equal positions, but the bias applied is small.
+# Per-channel parameters that control the impact on the root node evaluation of various aspects:
+# Board edge proximity, areas next to already-played stones, corner proximity, etc.
+# positionalityTuneX1 = 0.2
+# positionalityTuneX2 = 0.0
+# positionalityTuneY1 = 1.0
+# positionalityTuneY2 = 0.15
+# positionalityTuneCenterDistance = 0.4
+# positionalityTuneOwnStoneProximity = 0.25
+# positionalityTuneOppStoneProximity = 0.0