Delete our_visualization

our_visualization/activation_heatmap.py

@@ -1,436 +0,0 @@
-import chess
-import dash
-import plotly.graph_objs as go
-from plotly.subplots import make_subplots
-from global_data import global_data
-
-from svg_pieces import get_svg_board
-from dash import dcc, html, Input, Output, State
-
-
-import time
-
-import numpy as np
-
-from plotly.io import to_json
-
-import pickle
-
-V_GAP = 0.15
-LAYOUT_MARGIN_V = 40
-
-def heatmap_data(head):
-    data = global_data.get_head_data(head)
-    return data
-
-
-def heatmap_figure():
-    if global_data.model is None:
-        return {}
-    start = time.time()
-    fig = make_figure()
-    print('make fig:', time.time() - start)
-
-    start = time.time()
-    fig = add_heatmap_traces(fig)
-    print('add traces:', time.time() - start)
-    with open("./test_activations_starting.pkl", 'wb') as f:
-        print("saving activations")
-        pickle.dump(global_data.activations, f)
-    start = time.time()
-    fig = add_layout(fig)
-    print('add layout total:', time.time() - start)
-
-    start = time.time()
-
-    if global_data.selected_layer == 'Smolgen':
-        with open('fig_as_json_no_pieces.json', 'w') as f:
-            f.write(to_json(fig, pretty=True))
-
-    if not global_data.visualization_mode_is_64x64:# and global_data.selected_layer != 'Smolgen':
-        fig = add_pieces(fig)
-        print('add pieces:', time.time() - start)
-
-    if global_data.selected_layer == 'Smolgen':
-        with open('fig_as_json.json', 'w') as f:
-            f.write(to_json(fig, pretty=True))
-
-    return fig
-
-
-def heatmap():
-    start = time.time()
-    # We need to recalculate graph when grid size changes, other wise layout is a mess (Dash bug?). Use hidden Div's children to trigger callback for graph recalc.
-    # Otherwise, we can just recalculate figure part and frontend rendering will be much faster
-      #
-    graph = html.Div(id='graph-container', children=[heatmap_graph()],
-                     style={'height': '100%', 'width': '100%', "overflow": "auto"#, 'textAlign': 'center'#, "display": "flex", "justifyContent":"center"
-                            })
-    print('GRAPH CREATION:', time.time() - start)
-    return graph
-
-
-def heatmap_graph():
-    fig = heatmap_figure()
-
-    config = {
-        'displaylogo': False,
-        'displayModeBar': True,
-        'modeBarButtonsToRemove': ['zoom', 'pan', 'select', 'zoomIn', 'zoomOut', 'autoScale', 'resetScale'],
-        'toImageButtonOptions': {
-            'format': global_data.export_format,
-            'scale': global_data.export_scale
-        }}
-
-    style = {'height': global_data.figure_container_height, 'width': '100%'}#, 'margin': '0 auto'}
-
-    graph = dcc.Graph(figure=fig, id='graph', style=style,
-                      responsive='auto',#True,  # True,
-                      config=config
-                      )
-
-    # graph = html.Div(id='graph-container', children=[graph], style={'height': '100%', 'width': '100%', "overflow": "auto"
-    #                                                           })
-    # graph_component.children = [graph]
-
-    global_data.cache_figure(fig)
-
-    return graph
-
-
-def make_figure():
-    #print('assumed key', global_data.subplot_rows, global_data.subplot_cols, global_data.visualization_mode_is_64x64,  global_data.selected_head if not global_data.show_all_heads else -1)
-    #print('key', global_data.get_figure_cache_key())
-    #print('all keys', global_data.figure_cache.keys())
-    fig = global_data.get_cached_figure()
-    if fig is None:
-        if global_data.show_all_heads:
-            titles = [f"Head {i + 1}" for i in range(global_data.number_of_heads)]
-            print('MAKING SUBPLOTS', 'rows:', global_data.subplot_rows, 'cols:', global_data.subplot_cols)
-            print('NUMBER OF HEADS:', global_data.number_of_heads)
-            fig = make_subplots(rows=global_data.subplot_rows, cols=global_data.subplot_cols, subplot_titles=titles,
-                                horizontal_spacing=global_data.heatmap_horizontal_gap / global_data.subplot_cols,
-                                vertical_spacing=V_GAP / global_data.subplot_rows,
-                                )
-        else:
-            print('CREATING 1x1')
-            titles = [f"head {global_data.selected_head +1}"]
-            fig = make_subplots(rows=1, cols=1, subplot_titles=titles)#go.Figure()#make_subplots(rows=1, cols=1, subplot_titles=titles)
-
-    return fig
-
-
-def add_layout(fig):
-    start = time.time()
-
-    #coloraxis1 = None
-    #if global_data.visualization_mode_is_64x64:
-    #    if global_data.colorscale_mode == '3':
-    #        coloraxis1 = {'colorscale': 'Viridis'}
-
-    coloraxis = None
-    if global_data.colorscale_mode == 'mode3':
-        cmin = np.amin(global_data.activations[:, :, :])
-        cmax = np.amax(global_data.activations[:, :, :])
-        coloraxis = {'colorscale': 'Viridis', 'colorbar': {'ypad': 0} , 'cmin': cmin, 'cmax': cmax, 'showscale': global_data.show_colorscale}
-
-    if global_data.check_if_figure_is_cached():
-        print('Using existing layout')
-        fig.update_layout({'coloraxis1': coloraxis}, overwrite=True)
-        return fig
-
-    layout = go.Layout(
-        # title='Plot title goes here',
-        margin={'t': LAYOUT_MARGIN_V, 'b': LAYOUT_MARGIN_V, 'r': 40, 'l': 40},
-        coloraxis1=coloraxis,
-        modebar={'orientation': 'v'}
-        #coloraxis={'colorscale': 'Viridis'}
-        #pa
-        #plot_bgcolor='rgb(0,0,0)',
-        #paper_bgcolor="black"
-    )
-
-    fig.update_layout(layout)
-    # fig['layout'].update(layout)
-
-    print('update layout:', time.time() - start)
-
-    start = time.time()
-    fig = update_axis(fig)
-    print('update axis:', time.time() - start)
-    # print(fig)
-    return fig
-
-
-def update_axis(fig):
-    if global_data.visualization_mode_is_64x64:
-        tickvals_x = list(range(0, 64, 4))
-        tickvals_y = list(range(3, 67, 4))#list(range(0, 64, 4))#list(range(3, 67, 4))
-        if global_data.board.turn or global_data.selected_layer == 'Smolgen':
-            ticktext_x = [x + y for x, y in zip('ae' * 8, '1122334455667788')]
-        #tickvals = list(range(0, 64))
-        #ticktext_x = [x + y for x, y in zip('abcdefg' * 8, '1'*8 + '2'*8 + '3'*8 + '4'*8 + '5'*8 + '6'*8 + '7'*8 + '8'*8)]
-            ticktext_y = ticktext_x[::-1]
-        else:
-            ticktext_x = [x + y for x, y in zip('ae' * 8, '1122334455667788'[::-1])]
-            ticktext_y = ticktext_x[::-1]
-        showticklabels = True
-        #ticklabelstep = 4
-        val_range = [-0.5, 63.5]
-        ticks = 'outside'
-        title_x = {'text': "Keys ('to' square)", 'standoff': 1}
-        title_y = {'text': "Queries ('from' square)", 'standoff': 1}
-    else:
-        title_x = None
-        title_y = None
-        tickvals_x = list(range(8))  # [0, 1, 2, 3, 4, 5, 6, 7]
-        tickvals_y = tickvals_x
-        ticktext_x = [letter for letter in 'abcdefgh']
-        ticktext_y = [letter for letter in '12345678']
-        showticklabels = True
-        #ticklabelstep = 1
-        val_range = [-0.5, 7.5]
-        ticks = ''
-
-    if not global_data.show_all_heads or (global_data.subplot_cols == 1 and global_data.subplot_rows == 1):
-        constraintowards_x = 'center'
-    else:
-        constraintowards_x = 'right'
-
-
-    fig.update_xaxes(title=title_x,
-                     range=val_range,
-                     # ticklen=50,
-                     zeroline=False,
-                     showgrid=False,
-                     scaleanchor='y',
-                     constrain='domain',
-                     constraintoward=constraintowards_x,
-                     ticks=ticks,  # ticks,
-                     ticktext=ticktext_x,
-                     tickvals=tickvals_x,
-                     showticklabels=showticklabels,
-                     # mirror='ticks',
-                     fixedrange=True,
-                     #ticklabelstep=ticklabelstep,
-                     )
-
-    fig.update_yaxes(title=title_y,
-                     range=val_range,
-                     zeroline=False,
-                     showgrid=False,
-                     scaleanchor='x',
-                     constrain='domain',
-                     constraintoward='top',
-                     ticks=ticks,  # ticks,
-                     ticktext=ticktext_y,
-                     tickvals=tickvals_y,
-                     showticklabels=showticklabels,
-                     # mirror='allticks',
-                     # side='top',
-                     fixedrange=True,
-                     #ticklabelstep=ticklabelstep
-                     )
-    return fig
-
-
-def calc_colorbar(row, col):
-    row = global_data.subplot_rows - row + 1 #invert
-    #row = global_data.subplot_rows - row - 1 #invert
-
-    dy = (1/global_data.subplot_rows)
-    dx = (1/global_data.subplot_cols)
-
-    offset = 1/global_data.subplot_cols - 2*(global_data.heatmap_horizontal_gap/(global_data.subplot_cols))/4#global_data.colorscale_x_offset#(494.1125)/2239.2#1/global_data.subplot_cols - 3*(global_data.heatmap_horizontal_gap/(global_data.subplot_cols))/4
-
-    if global_data.heatmap_h == 0:
-        len = (1 - V_GAP/global_data.subplot_rows) / global_data.subplot_rows #- #V_GAP/global_data.subplot_rows
-        lenmode = 'fraction'
-        offset2 = len / 2
-    else:
-        #total_h = global_data.heatmap_fig_h * global_data.heatmap_h + (global_data.subplot_rows - 1)
-        len = global_data.heatmap_h/(global_data.heatmap_fig_h - 2*LAYOUT_MARGIN_V)
-        lenmode = 'fraction'
-        #offset2 = len / 2
-        #lenmode = 'pixels'
-        #offset2 = 1 - len/(global_data.subplot_rows*len + V_GAP) #1/global_data.subplot_rows - (V_GAP/global_data.subplot_rows)
-
-        #tot_h = global_data.heatmap_fig_h - 2*LAYOUT_MARGIN_V
-        #max_h = ((1 - V_GAP)) / global_data.subplot_rows
-        #cur_h =  len
-        offset2 = 1 - (global_data.subplot_rows-1)*(dy + (V_GAP / global_data.subplot_rows)/global_data.subplot_rows) - len/2 #0#len/2 #+ (max_h - cur_h)
-
-
-    #offset = global_data.colorscale_x_offset
-    #shift = (global_data.heatmap_w + 20 + 20 + global_data.heatmap_gap)/global_data.heatmap_fig_w
-    #cx = (col - 1) * shift + offset
-
-
-    cx = (col-1)*(dx + (global_data.heatmap_horizontal_gap / global_data.subplot_cols)/global_data.subplot_cols) + offset
-    cy = (row-1)*(dy + (V_GAP / global_data.subplot_rows)/global_data.subplot_rows) + offset2
-    #cy = (global_data.subplot_rows - 1 - row) * (dy + (V_GAP / global_data.subplot_rows) / global_data.subplot_rows) + offset2
-
-    #######################
-
-
-    colorbar=dict(len=len, y=cy, x=cx, ypad=0, xpad=0, ticklabelposition='inside', ticks='inside', ticklen=3, lenmode=lenmode,
-                  tickfont=dict(color='#7e807f'))
-
-    return colorbar
-
-def add_heatmap_trace(fig, row, col, head=None):
-    # print('ADDING heatmap', row, col)
-    if head is None:
-        head = (row - 1) * global_data.subplot_cols + (col - 1)
-    data = heatmap_data(head)
-
-    if data is None:
-        return fig
-
-    if global_data.visualization_mode_is_64x64:
-        xgap, ygap = 0, 0
-        #hovertemplate = 'Query: <b>%{y}</b> <br> Key: <b>%{x}</b> <br> value: <b>%{z}</b><extra></extra>'
-        hovertemplate = 'Query: <b>%{customdata[0]}</b> <br>Key: <b>%{customdata[1]}</b> <br>value: <b>%{z:.5f}</b><extra></extra>'
-        if global_data.board.turn or global_data.selected_layer == 'Smolgen':
-            customdata_x = [[letter + ind for ind in '12345678' for letter in 'abcdefgh'] for _ in range(64)]
-            customdata_y = [[letter + ind for _ in range(64)] for ind in '12345678'[::-1] for letter in 'abcdefgh'[::-1]]
-        else:
-            customdata_x = [[letter + ind for ind in '12345678'[::-1] for letter in 'abcdefgh'] for _ in range(64)]
-            customdata_y = [[letter + ind for _ in range(64)] for ind in '12345678' for letter in 'abcdefgh'[::-1]]
-
-        #customdata_y = [[letter + ind for _ in range(64)] for ind in '12345678' for letter in 'abcdefgh']
-        customdata = np.moveaxis([customdata_y, customdata_x], 0, -1)#[customdata_x, customdata_y]
-
-    else:
-        xgap, ygap = 2, 2
-        hovertemplate = '<b>%{x}%{y}</b>: <b>%{z}</b><extra></extra>'
-        customdata = None
-
-    coloraxis = None
-    #Colorscale
-
-    #if global_data.visualization_mode_is_64x64:
-    #    if global_data.colorscale_mode == '3':
-    #        coloraxis = 'coloraxis1'
-
-    coloraxis = None
-    colorscale = 'Viridis'
-    colorbar = None
-    #if global_data.show_colorscale and global_data.colorscale_mode == 'mode3':
-    if global_data.colorscale_mode == 'mode3':
-        coloraxis = 'coloraxis1'
-        colorscale = None
-
-    elif global_data.show_colorscale and not global_data.colorscale_mode == 'mode3' and not (not global_data.show_all_heads or (global_data.subplot_cols == 1 and global_data.subplot_rows == 1)):
-        colorbar = calc_colorbar(row, col)
-
-    zmin, zmax = None, None
-
-    if global_data.colorscale_mode == 'mode2':
-        pass
-        zmin = np.amin(global_data.activations[head, :, :])
-        zmax = np.amax(global_data.activations[head, :, :])
-        #print('ZMINMAX M2', head, zmin, zmax)
-
-    elif global_data.colorscale_mode == 'mode1':
-        zmin = np.amin(data)
-        zmax = np.amax(data)
-
-    #print('Trace data shape', data.shape)
-    trace = go.Heatmap(
-        z=data,
-        colorscale=colorscale,
-        showscale=global_data.show_colorscale,#True,
-        colorbar=colorbar,
-        #colorbar=dict(len=len, y=cy, x=cx, ypad=0, ticklabelposition='inside', ticks='inside', ticklen=3,
-        #              tickfont=dict(color='#7e807f')),
-        xgap=xgap,
-        ygap=ygap,
-        hovertemplate=hovertemplate,
-        customdata=customdata,
-        zmin=zmin,
-        zmax=zmax,
-        coloraxis=coloraxis
-        #zmin=zmin,
-        #zmax=zmax
-    )
-    fig.add_trace(trace, row=row, col=col)
-    return fig
-
-
-def add_heatmap_traces(fig):
-    print('adding traces, rows:', global_data.subplot_rows, 'cols:', global_data.subplot_cols)
-    #adding traces is quick so we don't bother using cached values. Wipe old traces and add new.
-    fig.data = []
-    if global_data.show_all_heads:
-        for row in range(global_data.subplot_rows):
-            for col in range(global_data.subplot_cols):
-                fig = add_heatmap_trace(fig, row + 1, col + 1)
-    else:
-        fig = add_heatmap_trace(fig, 1, 1, global_data.selected_head)
-    return fig
-
-
-def add_pieces(fig):
-    if global_data.selected_layer != 'Smolgen':
-        board = global_data.board
-
-    else:
-        board = chess.Board(fen=None) #Empty board, we want to draw only the focused square
-        board_svg = get_svg_board(board, global_data.focused_square_ind, True)
-
-        images = [dict(
-                source=board_svg,
-                xref="x"+str(i),
-                yref="y"+str(i),
-                x=3.5,
-                y=3.5,
-                sizex=8,
-                sizey=8,
-                xanchor='center',
-                yanchor='middle',
-                sizing="stretch",
-            )
-            for i in range(2, 2+255)
-            ]
-        images = [dict(
-                source=board_svg,
-                xref="x",
-                yref="y",
-                x=3.5,
-                y=3.5,
-                sizex=8,
-                sizey=8,
-                xanchor='center',
-                yanchor='middle',
-                sizing="stretch",
-            )] + images
-
-        fig.layout.images = images
-        return fig
-    board_svg = get_svg_board(board, global_data.focused_square_ind, True)
-    if global_data.check_if_figure_is_cached():
-        print('USING CACHED')
-        for img in fig.layout.images:
-            img['source'] = board_svg
-    else:
-        fig.add_layout_image(
-            dict(
-                source=board_svg,
-                xref="x",
-                yref="y",
-                x=3.5,
-                y=3.5,
-                sizex=8,
-                sizey=8,
-                xanchor='center',
-                yanchor='middle',
-                sizing="stretch",
-            ),
-            row='all',
-            col='all',
-            exclude_empty_subplots=True,
-        )
-
-    return fig
-

our_visualization/assets/DejaVuSans-Bold.ttf

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

our_visualization/assets/DejaVuSans.ttf

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

our_visualization/assets/DejavuSansMono-5m7L.ttf

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

our_visualization/assets/custom.css

@@ -1,59 +0,0 @@
-*[class="model-loading"][data-dash-is-loading="true"]::before{
-    content: "Loading model...";
-    display: inline-block;
-    color: red;
-    visibility: visible;
-    font-size: 16px;
-    /*transition-delay: 1s;
-    transition-property: font-size;
-    transition-duration: 200ms;*/
-}
-
-.completely-hidden{
-    display: none;
-}
-
-.hidden-but-reserve-space{
-    visibility: hidden;
-}
-
-#link{
-    text-decoration: underline;
-    cursor: pointer;
-}
-
-.header-container {
-    border-bottom: thin lightgrey solid;
-    box-sizing: border-box;
-    white-space: nowrap;
-    overflow-y: auto;
-}
-
-.header-control-container {
-    margin-left: 20px;
-    margin-right: 20px;
-}
-
-body {
-  margin: 0;
-  padding: 0;
-  font-family: 'BundledDejavuSans';
-  font-size: 14px;
-  -moz-user-select: none;
-}
-
-@font-face {
-    font-family: 'BundledDejavuSansMono';
-    src: url('DejavuSansMono-5m7L.ttf');
-}
-
-@font-face {
-    font-family: 'BundledDejavuSans';
-    src: url('DejaVuSans.ttf');
-}
-
-@font-face {
-    font-family: 'BundledDejavuSans';
-    src: url('DejaVuSans-Bold.ttf');
-    font-weight: bold;
-}

our_visualization/board2planes.py

@@ -1,97 +0,0 @@
-#Author: https://github.com/Arcturai
-
-import chess
-import numpy as np
-import re
-
-
-WPAWN = chess.Piece(chess.PAWN, chess.WHITE)
-WKNIGHT = chess.Piece(chess.KNIGHT, chess.WHITE)
-WBISHOP = chess.Piece(chess.BISHOP, chess.WHITE)
-WROOK = chess.Piece(chess.ROOK, chess.WHITE)
-WQUEEN = chess.Piece(chess.QUEEN, chess.WHITE)
-WKING = chess.Piece(chess.KING, chess.WHITE)
-BPAWN = chess.Piece(chess.PAWN, chess.BLACK)
-BKNIGHT = chess.Piece(chess.KNIGHT, chess.BLACK)
-BBISHOP = chess.Piece(chess.BISHOP, chess.BLACK)
-BROOK = chess.Piece(chess.ROOK, chess.BLACK)
-BQUEEN = chess.Piece(chess.QUEEN, chess.BLACK)
-BKING = chess.Piece(chess.KING, chess.BLACK)
-
-
-def assign_piece2(planes, piece_step, row, col):
-    planes[piece_step][row][col] = 1
-
-
-DISPATCH2 = {}
-
-DISPATCH2[str(WPAWN)] = lambda retval, row, col: assign_piece2(retval, 0, row, col)
-DISPATCH2[str(WKNIGHT)] = lambda retval, row, col: assign_piece2(retval, 1, row, col)
-DISPATCH2[str(WBISHOP)] = lambda retval, row, col: assign_piece2(retval, 2, row, col)
-DISPATCH2[str(WROOK)] = lambda retval, row, col: assign_piece2(retval, 3, row, col)
-DISPATCH2[str(WQUEEN)] = lambda retval, row, col: assign_piece2(retval, 4, row, col)
-DISPATCH2[str(WKING)] = lambda retval, row, col: assign_piece2(retval, 5, row, col)
-DISPATCH2[str(BPAWN)] = lambda retval, row, col: assign_piece2(retval, 6, row, col)
-DISPATCH2[str(BKNIGHT)] = lambda retval, row, col: assign_piece2(retval, 7, row, col)
-DISPATCH2[str(BBISHOP)] = lambda retval, row, col: assign_piece2(retval, 8, row, col)
-DISPATCH2[str(BROOK)] = lambda retval, row, col: assign_piece2(retval, 9, row, col)
-DISPATCH2[str(BQUEEN)] = lambda retval, row, col: assign_piece2(retval, 10, row, col)
-DISPATCH2[str(BKING)] = lambda retval, row, col: assign_piece2(retval, 11, row, col)
-
-
-def append_plane(planes, ones):
-    if ones:
-        return np.append(planes, np.ones((1, 8, 8), dtype=np.float), axis=0)
-    else:
-        return np.append(planes, np.zeros((1, 8, 8), dtype=np.float), axis=0)
-
-
-def fill_planes(board):
-    planes = np.zeros((12, 8, 8), dtype=np.float)
-    for row in range(8):
-        for col in range(8):
-            piece = str(board.piece_at(chess.SQUARES[row * 8 + col]))
-            if piece != "None":
-                DISPATCH2[piece](planes, row, col)
-    planes = append_plane(planes, board.is_repetition(2))
-    return planes
-
-
-def board2planes(board_):
-    if not board_.turn:
-        board = board_.mirror()
-    else:
-        board = board_
-
-    retval = fill_planes(board)
-
-    s_board = board_.copy()
-    for i in range(7):
-        if s_board.move_stack.__len__() > 0:
-            s_board.pop()
-            b = s_board.mirror() if not board_.turn else s_board.copy()
-            retval = np.append(retval, fill_planes(b), axis=0)
-        else:
-            retval = np.append(retval, np.zeros((13, 8, 8), dtype=np.float), axis=0)
-
-    retval = append_plane(retval, bool(board.castling_rights & chess.BB_H1))
-    retval = append_plane(retval, bool(board.castling_rights & chess.BB_A1))
-    retval = append_plane(retval, bool(board.castling_rights & chess.BB_H8))
-    retval = append_plane(retval, bool(board.castling_rights & chess.BB_A8))
-    retval = append_plane(retval, not board_.turn)
-    retval = np.append(retval, np.full((1, 8, 8), fill_value=board_.halfmove_clock/99., dtype=np.float), axis=0)
-    retval = append_plane(retval, False)
-    retval = append_plane(retval, True)
-
-    return np.expand_dims(retval, axis=0)
-
-
-def bulk_board2planes(boards):
-    planes = []
-    for b in boards:
-        temp = board2planes(b)
-        planes.append(temp)
-    pl = tuple(planes)
-    retval = np.concatenate(pl, axis=0)
-    return retval
-

our_visualization/constants.py

@@ -1,24 +0,0 @@
-import sys
-import os
-
-
-def root_directory():
-    if getattr(sys, 'frozen', False):
-        # The application is frozen
-        root = os.path.dirname(sys.executable)
-    else:
-        # The application is not frozen
-        root = os.path.dirname(__file__)  # os.path.dirname(os.path.abspath(__file__))#os.path.dirname(__file__)
-    return (root)
-
-
-ROOT_DIR = root_directory()
-
-LEFT_PANE_WIDTH = 90
-RIGHT_PANE_WIDTH = 100 - LEFT_PANE_WIDTH
-GRAPH_PANE_HEIGHT = 100
-HEADER_HEIGHT = 11
-CONTENT_HEIGHT = 100 - HEADER_HEIGHT
-
-EXPORT_FORMAT = 'png' #one of png, svg, jpeg, webp
-EXPORT_SCALE = 1.0 #When 1.0, the figure is exported as same size as currently in the browser. Use e.g. 0.5 to scale to half.

our_visualization/global_data.py

@@ -1,539 +0,0 @@
-import chess.engine
-from constants import ROOT_DIR, CONTENT_HEIGHT, LEFT_PANE_WIDTH, EXPORT_FORMAT, EXPORT_SCALE
-from time import sleep
-# from test_array import activations_array
-
-from copy import deepcopy
-
-from board2planes import board2planes
-
-import yaml
-
-import os
-from os.path import isdir, join
-import sys
-
-import numpy as np
-
-
-SIMULATE_TF = False #TODO: Remove this option, deprecated
-# turn off tensorflow importing and generate random data to speed up development
-DEV_MODE = False
-SIMULATED_LAYERS = 6
-SIMULATED_HEADS = 64
-FIXED_ROW = None  # 1 #None to disable
-FIXED_COL = None  # 5 #None to disable
-if DEV_MODE:
-    class DummyModel:
-        def __init__(self, layers, heads):
-            self.layers = layers
-            self.heads = heads
-
-        def __call__(self, *args, **kwargs):
-            data = [np.random.rand(1, self.heads, 64, 64) for i in range(self.layers)]
-            return [None, None, None, data]
-
-else:
-    import tensorflow as tf
-    from tensorflow.compat.v1 import ConfigProto
-    from tensorflow.compat.v1 import InteractiveSession
-
-
-# class to hold data, state and configurations
-# Dash is stateless and in general it is very bad idea to store data in global variables on server side
-# However, this application is ment to be run by single user on local machine, so it is safe to store data and state
-# information on global object
-class GlobalData:
-    def __init__(self):
-        import os
-        if not DEV_MODE:
-            # import tensorflow as tf
-            os.environ["CUDA_VISIBLE_DEVICES"] = "0"
-
-            # from tensorflow.compat.v1 import ConfigProto
-            # from tensorflow.compat.v1 import InteractiveSession
-            # import chess
-            # import matplotlib.patheffects as path_effects
-
-            #config = ConfigProto()
-            #config.gpu_options.allow_growth = True
-            #session = InteractiveSession(config=config)
-            #tf.keras.backend.clear_session()
-
-        self.tmp = 0
-        self.export_format = EXPORT_FORMAT
-        self.export_scale = EXPORT_SCALE
-        self.fen = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'  # '2kr3r/ppp2b2/2n4p/4p3/Q2Pq1pP/2P1N3/PP3PP1/R1B1KB1R w KQ - 3 18'#'6n1/1p1k4/3p4/pNp5/P1P4p/7P/1P4KP/r7 w - - 2 121'#
-        self.board = chess.Board(fen=self.fen)
-        self.focused_square_ind = 0
-        self.active_move_table_cell = None  # tuple (row_ind, col_id), e.g. (12, 'White')
-
-        self.activations = None  # activations_array
-        self.visualization_mode = 'ROW'
-        self.visualization_mode_is_64x64 = False
-        self.subplot_mode = 'big' #'fit'  # big'#'fit'#, 'big'
-        self.subplot_cols = 0
-        self.subplot_rows = 0
-        self.number_of_heads = 0
-        self.selected_head = None
-        self.show_all_heads = True
-
-        self.show_colorscale = False
-        self.colorscale_mode = 'mode1'
-
-        self.figure_container_height = '100%'  # '100%'
-
-        self.running_counter = 0  # used to pass new values to hidden indicator elements which will trigger follow-up callback
-        self.grid_has_changed = False
-
-        # self.has_subplot_grid_changed = True
-        # self.figure_layout_images = None #store layout and only recalculate when subplot grid has changed
-        # self.figure_layout_annotations = None
-        # self.need_update_axis = True
-
-        self.screen_w = 0
-        self.screen_h = 0
-        self.figure_w = 0
-        self.figure_h = 0
-        self.heatmap_w = 0
-        self.heatmap_h = 0
-        self.heatmap_fig_w = 0
-        self.heatmap_fig_h = 0
-        self.heatmap_gap = 0
-        self.colorscale_x_offset = 0
-
-        self.heatmap_horizontal_gap = 0.275
-
-        self.figure_cache = {}
-
-        self.update_grid_shape()
-
-        self.pgn_data = []  # list of boards in pgn
-        self.move_table_boards = {}  # dict of boards in pgn, key is (move_table.row_ind, move_table.column_id)
-
-        if not SIMULATE_TF:
-            self.selected_layer = None
-        else:
-            self.selected_layer = 0
-
-        self.nr_of_layers_in_body = -1
-        self.has_attention_policy = False
-
-        self.model_paths = []
-        self.model_names = []
-        self.model_yamls = {} #key = model path, value = yaml of that model
-        self.model_cache = {}
-        self.find_models2()
-        self.model_path = None#self.model_paths[0]  # '/home/jusufe/PycharmProjects/lc0-attention-visualizer/T12_saved_model_1M'
-        self.model = None
-        self.tfp = None #TensorflowProcess
-        if not SIMULATE_TF:
-            self.load_model()
-        self.activations_data = None
-
-        if self.model is not None or SIMULATE_TF:
-            self.update_activations_data()
-
-        if self.selected_layer is not None:
-            self.set_layer(self.selected_layer)
-
-        self.move_table_active_cell = None
-
-        self.force_update_graph = False
-
-    def set_subplot_mode(self, fit_to_page):
-        if fit_to_page == [True]:
-            self.subplot_mode = 'fit'
-        else:
-            self.subplot_mode = 'big'
-        self.update_grid_shape()
-
-    def set_screen_size(self, w, h):
-        self.screen_w = w
-        self.screen_h = h
-
-        self.figure_w = w*LEFT_PANE_WIDTH/100
-        self.figure_h = h*CONTENT_HEIGHT/100
-        print('GRAPH AREA', self.figure_w, self.figure_h)
-
-    def set_heatmap_size(self, size):
-        if size != '1':
-            #print('-----------------------HEATMAP SIZE', size)
-            # w, h = size
-            # print('TYETETETETEU', global_data.screen_w)
-            # global_data.set_screen_size(w, h)
-            #print('>>>>>: HEATMAP WIDTH', size[0])
-            #print('>>>>>: HEATMAP HEIGHT', size[1])
-            #print('>>>>>: FIG WIDTH', size[2])
-            #print('>>>>>: FIG HEIGHT', size[3])
-            #print('>>>>>: HEATMAP GAP', size[4])
-
-            self.heatmap_w = float(size[0])
-            self.heatmap_h = float(size[1])
-            self.heatmap_fig_w = float(size[2])
-            self.heatmap_fig_h = float(size[3])
-            self.heatmap_gap = round(float(size[4]), 2)
-
-            self.colorscale_x_offset = float(size[5])/self.heatmap_fig_w
-
-            if size[6] == 1:
-                self.force_update_graph = True
-            else:
-                self.force_update_graph = False
-
-
-            #if self.heatmap_gap < 30:
-            #    self.heatmap_horizontal_gap += 0.025
-
-            #    self.heatmap_horizontal_gap = min(0.25, self.heatmap_horizontal_gap)
-            #if self.heatmap_gap < 200:
-            #    self.heatmap_horizontal_gap += -0.025
-            #    self.heatmap_horizontal_gap = max(0.1, self.heatmap_horizontal_gap)
-
-    def set_colorscale_mode(self, mode, colorscale_mode, colorscale_mode_64x64, show):
-        if mode == '64x64':
-            self.colorscale_mode = colorscale_mode_64x64
-        else:
-            self.colorscale_mode = colorscale_mode
-        #print('SHOW value', show)
-        self.show_colorscale = show == [True]
-
-    def cache_figure(self, fig):
-        if not self.check_if_figure_is_cached() and fig != {}:
-            key = self.get_figure_cache_key()
-            cached_fig = deepcopy(fig)
-            cached_fig.update_layout({'coloraxis1': None}, overwrite=True)
-            #print('CACHING FIGURE:')
-            self.figure_cache[key] = cached_fig
-
-    def get_cached_figure(self):
-        if self.check_if_figure_is_cached():
-            key = self.get_figure_cache_key()
-            fig = deepcopy(self.figure_cache[key])
-        else:
-            fig = None
-        return fig
-
-    def check_if_figure_is_cached(self):
-        key = self.get_figure_cache_key()
-        return key in self.figure_cache
-
-    def get_figure_cache_key(self):
-        return (self.subplot_rows, self.subplot_cols, self.visualization_mode_is_64x64,
-                self.selected_head if not self.show_all_heads else -1, self.show_colorscale, self.colorscale_mode,
-                self.board.turn)
-        #return (self.subplot_rows, self.subplot_cols, self.visualization_mode_is_64x64, self.selected_head if not self.show_all_heads else -1, self.heatmap_horizontal_gap, self.heatmap_fig_h, self.heatmap_fig_w)
-        #return (self.subplot_rows, self.subplot_cols, self.visualization_mode_is_64x64, self.show_all_heads)
-
-    def get_side_to_move(self):
-        return ['Black', 'White'][self.board.turn]
-
-    def load_model(self):
-        if self.model_path in self.model_cache:
-            self.model, self.tfp = self.model_cache[self.model_path]
-
-        elif self.model_path is not None:
-            #net = '/home/jusufe/Projects/lc0/BT1024-3142c-swa-186000.pb.gz'
-            #yaml_path = '/home/jusufe/Downloads/cfg.yaml'
-            if not DEV_MODE:
-                net = self.model_path
-                yaml_path = self.model_yamls[self.model_path]
-                with open(yaml_path) as f:
-                    cfg = f.read()
-                cfg = yaml.safe_load(cfg)
-
-                if 'dropout_rate' in cfg['model']:
-                    print('Setting dropout_rate to 0.0')
-                    cfg['model']['dropout_rate'] = 0.0
-
-                tfp = tfprocess.TFProcess(cfg)
-                tfp.init_net()
-                tfp.replace_weights(net, ignore_errors=True)
-                self.model = tfp.model
-                self.tfp = tfp
-            else:
-                self.model = DummyModel(SIMULATED_LAYERS, SIMULATED_HEADS)
-                self.tfp = None
-
-        else:
-            self.model = None
-            self.tfp = None
-
-    def find_models(self):
-        root = ROOT_DIR
-        models_root_folder = os.path.join(root, 'models')
-        model_folders = [f for f in os.listdir(models_root_folder) if isdir(join(models_root_folder, f))]
-        model_paths = [os.path.relpath(join(models_root_folder, f)) for f in os.listdir(models_root_folder) if
-                       isdir(join(models_root_folder, f))]
-        self.model_names = model_folders
-        self.model_paths = model_paths
-
-        #print('MODELS:')
-        #print(self.model_names)
-        #print(self.model_paths)
-
-    def find_models2(self):
-        import os
-        from os.path import isdir, join
-        root = ROOT_DIR
-        models_root_folder = os.path.join(root, 'models')
-        model_folders = [f for f in os.listdir(models_root_folder) if isdir(join(models_root_folder, f))]
-        model_paths = [os.path.relpath(join(models_root_folder, f)) for f in os.listdir(models_root_folder) if
-                       isdir(join(models_root_folder, f))]
-
-        models = []
-        paths = []
-        yamls = []
-        for path in model_paths:
-            yaml_files = [file for file in os.listdir(path) if file.endswith(".yaml")]
-            if len(yaml_files) != 1:
-                continue
-            model_files = [file for file in os.listdir(path) if file.endswith(".pb.gz")]
-            if len(model_files) == 0:
-                continue
-
-            models += model_files
-            paths += [os.path.relpath(join(path, f)) for f in model_files]
-            yaml_file = os.path.relpath(join(path, yaml_files[0]))
-            yamls += [yaml_file]*len(model_files)
-
-        self.model_yamls = {path: yaml_file for path, yaml_file in zip(paths, yamls)}
-        self.model_names = models
-        self.model_paths = paths#model_paths
-
-
-    def update_activations_data(self):
-
-        if self.model is not None and self.selected_layer is None:
-            self.selected_layer = 0
-
-        if not SIMULATE_TF:
-            if self.selected_layer is not None and self.model is not None and self.selected_layer != 'Smolgen':
-                if not DEV_MODE:
-                    inputs = board2planes(self.board)
-                    inputs = tf.reshape(tf.convert_to_tensor(inputs, dtype=tf.float32), [-1, 112, 8, 8])
-                else:
-                    inputs = None
-
-                outputs = self.model(inputs)
-                self.activations_data = outputs[-1]
-                for i,x in enumerate(self.activations_data):
-                    print( 'LAYERS', i, x.shape)
-
-                #smolgen = self.tfp.smol_weight_gen_dense.get_weights()[0].reshape((256, 64, 64))
-                #print('Smolgen')
-                #print(type(smolgen))
-                #print(smolgen.shape)
-                #print(type(smolgen[0]))
-                #print(smolgen[0].shape)
-                #_, _, _, self.activations_data = self.model(inputs)
-            elif self.selected_layer == 'Smolgen' and self.tfp is not None and self.tfp.use_smolgen:
-                weights = self.tfp.smol_weight_gen_dense.get_weights()[0]
-                self.activations_data = weights.reshape((weights.shape[0], 64, 64))
-                print('TYPEEEEE', type(self.activations_data))
-
-        else:
-            layers = SIMULATED_LAYERS
-            heads = SIMULATED_HEADS
-            self.activations_data = [np.random.rand(1, heads, 64, 64) for i in range(layers)]
-
-        if self.model is not None:
-
-            if self.model_path not in self.model_cache:
-                self.model_cache[self.model_path] = [self.model, self.tfp]
-
-            self.update_layers_in_body_count()
-
-        #TODO: figure out better way to determine if we have policy attention weights
-        #TODO: What happens if policy vis is selected and user switches to model without policy layer? Take care of this case.
-        if self.activations_data is not None and self.activations_data[-2].shape == (1, 8, 24):
-            self.has_attention_policy = True
-        else:
-            self.has_attention_policy = False
-        # self.update_selected_activation_data()
-        # self.activations = self.activations_data[self.selected_layer]
-
-    def update_grid_shape(self):
-        # TODO: add client side callback triggered by Interval component to save window or precise container dimensions to Div
-        # TODO: Trigger server side figure update callback when dimensions are recorded and store in global_data
-        # TODO: If needed, recalculate subplot rows and cols and container scaler based on the changed dimension
-
-        def calc_cols(heads, rows):
-            if heads % rows == 0:
-                cols = int(heads / rows)
-            else:
-                cols = int(1 + heads / rows)
-            return cols
-
-        if FIXED_ROW and FIXED_COL:
-            self.subplot_cols = FIXED_COL
-            self.subplot_rows = FIXED_ROW
-            return None
-
-        heads = self.number_of_heads
-        if self.subplot_mode == 'fit':
-            max_rows_in_screen = 4
-            if heads <= 4:
-                rows = 1
-            elif heads <= 8:
-                rows = 2
-            else:
-                rows = heads // 8 + int(heads % 8 != 0)
-
-        elif self.subplot_mode == 'big':
-            #print(heads)
-
-            max_rows_in_screen = 2
-            rows = heads // 4 + int(heads % 4 != 0)
-            #print(rows)
-
-        if rows > max_rows_in_screen:
-            container_height = f'{int((rows / max_rows_in_screen) * 100)}%'
-        else:
-            container_height = '100%'
-
-        if rows != 0:
-            cols = calc_cols(heads, rows)
-        else:
-            cols = 0
-
-        if self.subplot_rows != rows or self.subplot_cols != cols:
-            self.grid_has_changed = True
-
-        self.subplot_cols = cols
-        self.subplot_rows = rows
-
-        if self.show_all_heads:
-            self.figure_container_height = container_height
-        else:
-            self.figure_container_height = '100%'
-
-    def update_selected_activation_data(self):
-        # import numpy as np
-        # self.activations = activations_array + np.random.rand(8, 64, 64)
-        if self.activations_data is not None:
-            if self.selected_layer not in ('Policy', 'Smolgen'):
-                if not DEV_MODE:
-                    activations = tf.squeeze(self.activations_data[self.selected_layer], axis=0).numpy()
-                    #self.activations = activations[:, ::-1, :] #Flip along y-axis
-                else:
-                    activations = np.squeeze(self.activations_data[self.selected_layer], axis=0)
-            elif self.selected_layer == 'Policy':
-                print('RAW POLICY SHAPE', self.activations_data[-1].shape)
-                activations = self.activations_data[-1].numpy()
-                #print('POLICY SHAPE', activations.shape)
-
-                #print('RAW POLICY SHAPE', self.activations_data[-1].shape)
-                #activations = np.squeeze(self.activations_data[-1].numpy(), axis=0) #shape 64,64
-                #promo = np.squeeze(self.activations_data[-2].numpy(), axis=0) #shape 8,24
-                #print('promo shape:', promo.shape)
-                #if self.board.turn:
-                #    pad_shape = (48, 8)
-                #else:
-                #    pad_shape = (8, 48)
-                #promo_padded = np.pad(promo, (pad_shape, (0, 0)), mode='constant', constant_values=None) #shape 64,24
-                #self.activations = np.expand_dims(np.concatenate((activations, promo_padded), axis=1), axis=0)#shape 1,64,88
-                #print('POLICY SHAPE', self.activations.shape)
-            elif self.selected_layer == 'Smolgen':
-                activations = self.tfp.smol_weight_gen_dense.get_weights()[0].reshape((256, 64, 64))
-
-            self.activations = activations[:, ::-1, :]  # Flip along y-axis
-
-    def set_visualization_mode(self, mode):
-        self.visualization_mode = mode
-        self.visualization_mode_is_64x64 = mode == '64x64'
-
-    def set_layer(self, layer):
-        self.selected_layer = layer
-        self.update_selected_activation_data()
-        if layer not in ('Policy', 'Smolgen'):
-            self.number_of_heads = self.activations_data[self.selected_layer].shape[1]
-        elif layer == 'Policy':
-            self.number_of_heads = 1
-        elif layer == 'Smolgen':
-            self.number_of_heads = self.activations.shape[0]
-            self.set_head(0)
-        self.update_grid_shape()
-
-    def set_head(self, head):
-        self.selected_head = head
-
-    def set_model(self, model):
-        if model != self.model_path:
-            self.model_path = model
-            self.load_model()
-            self.update_activations_data()
-            self.update_selected_activation_data()
-            self.number_of_heads = self.activations_data[self.selected_layer].shape[1]
-            if self.selected_head is None:
-                self.selected_head = 0
-            else:
-                self.selected_head = min(self.selected_head, self.number_of_heads - 1)
-            self.update_grid_shape()
-        if SIMULATE_TF:
-            sleep(2)
-
-    def update_layers_in_body_count(self):
-        # TODO: figure out robust way to separate attention layers in body from the rest. UPDATE: Use yaml
-        heads = self.activations_data[0].shape[1]
-        for ind, layer in enumerate(self.activations_data):
-            if layer.shape[1] != heads or len(layer.shape) != 4:
-                ind = ind - 1
-                break
-        self.nr_of_layers_in_body = ind + 1
-        if self.selected_layer not in ('Policy', 'Smolgen'):
-            self.selected_layer = min(self.selected_layer, self.nr_of_layers_in_body - 1)
-
-    def get_head_data(self, head):
-
-        if self.activations.shape[0] <= head:
-            return None
-
-        if self.visualization_mode == '64x64':
-            # print('64x64 selection')
-            data = self.activations[head, :, :]
-
-        elif self.visualization_mode == 'ROW':
-            # print('ROW selection')
-            if self.board.turn or self.selected_layer == 'Smolgen': #White turn to move
-                row = 63 - self.focused_square_ind
-                data = self.activations[head, row, :].reshape((8, 8))
-            else:
-                #row = self.focused_square_ind
-                multiples = self.focused_square_ind // 8
-                remainder = self.focused_square_ind % 8
-
-                a = 7 - remainder
-                b = multiples * 8
-                row = a + b
-                data = self.activations[head, row, :].reshape((8, 8))[::-1, :]
-        else:
-            # print('COL selection')
-            if self.board.turn or self.selected_layer == 'Smolgen': #White turn to move
-                col = self.focused_square_ind
-                data = self.activations[head, :, col].reshape((8, 8))[::-1, ::-1]
-            else:
-                focused = 63 - self.focused_square_ind
-                multiples = focused // 8
-                remainder = focused % 8
-                a = 7 - remainder
-                b = multiples * 8
-                col = a + b
-                #print('COL!!!!!!!!!!!!!!!!!', col, a, b, focused, self.focused_square_ind)
-                data = self.activations[head, :, col].reshape((8, 8))[:, ::-1]
-        return data
-
-    def set_fen(self, fen):
-        self.board.set_fen(fen)
-        self.fen = fen
-        self.update_activations_data()
-        self.update_selected_activation_data()
-
-    def set_board(self, board):
-        self.board = deepcopy(board)
-        self.update_activations_data()
-        self.update_selected_activation_data()
-
-
-global_data = GlobalData()
-print('global data created')

our_visualization/layouts/visualization_demo.slides.json

@@ -1,4 +0,0 @@
-{
-  "type": "slides",
-  "data": {}
-}

our_visualization/leela_board.py

@@ -1,617 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# uci_to_idx is a list of four dicts {uci -> NN policy index}
-# 0 = white, no-castling
-# 1 = white, castling
-# 2 = black, no-castling
-# 3 = black, castling
-# Black moves are flipped, and castling moves are mapped to the e8a8, e8h8, e1a1, e1h1 indexes
-#  from their respective UCI names
-
-uci_to_idx = []
-
-# The index-to-uci list originates from here:
-# https://github.com/glinscott/leela-chess/blob/master/lc0/src/chess/bitboard.cc
-
-# White, no-castling
-_idx_to_move_wn = [
-    'a1b1', 'a1c1', 'a1d1', 'a1e1', 'a1f1', 'a1g1', 'a1h1',
-    'a1a2', 'a1b2', 'a1c2', 'a1a3', 'a1b3', 'a1c3', 'a1a4',
-    'a1d4', 'a1a5', 'a1e5', 'a1a6', 'a1f6', 'a1a7', 'a1g7',
-    'a1a8', 'a1h8', 'b1a1', 'b1c1', 'b1d1', 'b1e1', 'b1f1',
-    'b1g1', 'b1h1', 'b1a2', 'b1b2', 'b1c2', 'b1d2', 'b1a3',
-    'b1b3', 'b1c3', 'b1d3', 'b1b4', 'b1e4', 'b1b5', 'b1f5',
-    'b1b6', 'b1g6', 'b1b7', 'b1h7', 'b1b8', 'c1a1', 'c1b1',
-    'c1d1', 'c1e1', 'c1f1', 'c1g1', 'c1h1', 'c1a2', 'c1b2',
-    'c1c2', 'c1d2', 'c1e2', 'c1a3', 'c1b3', 'c1c3', 'c1d3',
-    'c1e3', 'c1c4', 'c1f4', 'c1c5', 'c1g5', 'c1c6', 'c1h6',
-    'c1c7', 'c1c8', 'd1a1', 'd1b1', 'd1c1', 'd1e1', 'd1f1',
-    'd1g1', 'd1h1', 'd1b2', 'd1c2', 'd1d2', 'd1e2', 'd1f2',
-    'd1b3', 'd1c3', 'd1d3', 'd1e3', 'd1f3', 'd1a4', 'd1d4',
-    'd1g4', 'd1d5', 'd1h5', 'd1d6', 'd1d7', 'd1d8', 'e1a1',
-    'e1b1', 'e1c1', 'e1d1', 'e1f1', 'e1g1', 'e1h1', 'e1c2',
-    'e1d2', 'e1e2', 'e1f2', 'e1g2', 'e1c3', 'e1d3', 'e1e3',
-    'e1f3', 'e1g3', 'e1b4', 'e1e4', 'e1h4', 'e1a5', 'e1e5',
-    'e1e6', 'e1e7', 'e1e8', 'f1a1', 'f1b1', 'f1c1', 'f1d1',
-    'f1e1', 'f1g1', 'f1h1', 'f1d2', 'f1e2', 'f1f2', 'f1g2',
-    'f1h2', 'f1d3', 'f1e3', 'f1f3', 'f1g3', 'f1h3', 'f1c4',
-    'f1f4', 'f1b5', 'f1f5', 'f1a6', 'f1f6', 'f1f7', 'f1f8',
-    'g1a1', 'g1b1', 'g1c1', 'g1d1', 'g1e1', 'g1f1', 'g1h1',
-    'g1e2', 'g1f2', 'g1g2', 'g1h2', 'g1e3', 'g1f3', 'g1g3',
-    'g1h3', 'g1d4', 'g1g4', 'g1c5', 'g1g5', 'g1b6', 'g1g6',
-    'g1a7', 'g1g7', 'g1g8', 'h1a1', 'h1b1', 'h1c1', 'h1d1',
-    'h1e1', 'h1f1', 'h1g1', 'h1f2', 'h1g2', 'h1h2', 'h1f3',
-    'h1g3', 'h1h3', 'h1e4', 'h1h4', 'h1d5', 'h1h5', 'h1c6',
-    'h1h6', 'h1b7', 'h1h7', 'h1a8', 'h1h8', 'a2a1', 'a2b1',
-    'a2c1', 'a2b2', 'a2c2', 'a2d2', 'a2e2', 'a2f2', 'a2g2',
-    'a2h2', 'a2a3', 'a2b3', 'a2c3', 'a2a4', 'a2b4', 'a2c4',
-    'a2a5', 'a2d5', 'a2a6', 'a2e6', 'a2a7', 'a2f7', 'a2a8',
-    'a2g8', 'b2a1', 'b2b1', 'b2c1', 'b2d1', 'b2a2', 'b2c2',
-    'b2d2', 'b2e2', 'b2f2', 'b2g2', 'b2h2', 'b2a3', 'b2b3',
-    'b2c3', 'b2d3', 'b2a4', 'b2b4', 'b2c4', 'b2d4', 'b2b5',
-    'b2e5', 'b2b6', 'b2f6', 'b2b7', 'b2g7', 'b2b8', 'b2h8',
-    'c2a1', 'c2b1', 'c2c1', 'c2d1', 'c2e1', 'c2a2', 'c2b2',
-    'c2d2', 'c2e2', 'c2f2', 'c2g2', 'c2h2', 'c2a3', 'c2b3',
-    'c2c3', 'c2d3', 'c2e3', 'c2a4', 'c2b4', 'c2c4', 'c2d4',
-    'c2e4', 'c2c5', 'c2f5', 'c2c6', 'c2g6', 'c2c7', 'c2h7',
-    'c2c8', 'd2b1', 'd2c1', 'd2d1', 'd2e1', 'd2f1', 'd2a2',
-    'd2b2', 'd2c2', 'd2e2', 'd2f2', 'd2g2', 'd2h2', 'd2b3',
-    'd2c3', 'd2d3', 'd2e3', 'd2f3', 'd2b4', 'd2c4', 'd2d4',
-    'd2e4', 'd2f4', 'd2a5', 'd2d5', 'd2g5', 'd2d6', 'd2h6',
-    'd2d7', 'd2d8', 'e2c1', 'e2d1', 'e2e1', 'e2f1', 'e2g1',
-    'e2a2', 'e2b2', 'e2c2', 'e2d2', 'e2f2', 'e2g2', 'e2h2',
-    'e2c3', 'e2d3', 'e2e3', 'e2f3', 'e2g3', 'e2c4', 'e2d4',
-    'e2e4', 'e2f4', 'e2g4', 'e2b5', 'e2e5', 'e2h5', 'e2a6',
-    'e2e6', 'e2e7', 'e2e8', 'f2d1', 'f2e1', 'f2f1', 'f2g1',
-    'f2h1', 'f2a2', 'f2b2', 'f2c2', 'f2d2', 'f2e2', 'f2g2',
-    'f2h2', 'f2d3', 'f2e3', 'f2f3', 'f2g3', 'f2h3', 'f2d4',
-    'f2e4', 'f2f4', 'f2g4', 'f2h4', 'f2c5', 'f2f5', 'f2b6',
-    'f2f6', 'f2a7', 'f2f7', 'f2f8', 'g2e1', 'g2f1', 'g2g1',
-    'g2h1', 'g2a2', 'g2b2', 'g2c2', 'g2d2', 'g2e2', 'g2f2',
-    'g2h2', 'g2e3', 'g2f3', 'g2g3', 'g2h3', 'g2e4', 'g2f4',
-    'g2g4', 'g2h4', 'g2d5', 'g2g5', 'g2c6', 'g2g6', 'g2b7',
-    'g2g7', 'g2a8', 'g2g8', 'h2f1', 'h2g1', 'h2h1', 'h2a2',
-    'h2b2', 'h2c2', 'h2d2', 'h2e2', 'h2f2', 'h2g2', 'h2f3',
-    'h2g3', 'h2h3', 'h2f4', 'h2g4', 'h2h4', 'h2e5', 'h2h5',
-    'h2d6', 'h2h6', 'h2c7', 'h2h7', 'h2b8', 'h2h8', 'a3a1',
-    'a3b1', 'a3c1', 'a3a2', 'a3b2', 'a3c2', 'a3b3', 'a3c3',
-    'a3d3', 'a3e3', 'a3f3', 'a3g3', 'a3h3', 'a3a4', 'a3b4',
-    'a3c4', 'a3a5', 'a3b5', 'a3c5', 'a3a6', 'a3d6', 'a3a7',
-    'a3e7', 'a3a8', 'a3f8', 'b3a1', 'b3b1', 'b3c1', 'b3d1',
-    'b3a2', 'b3b2', 'b3c2', 'b3d2', 'b3a3', 'b3c3', 'b3d3',
-    'b3e3', 'b3f3', 'b3g3', 'b3h3', 'b3a4', 'b3b4', 'b3c4',
-    'b3d4', 'b3a5', 'b3b5', 'b3c5', 'b3d5', 'b3b6', 'b3e6',
-    'b3b7', 'b3f7', 'b3b8', 'b3g8', 'c3a1', 'c3b1', 'c3c1',
-    'c3d1', 'c3e1', 'c3a2', 'c3b2', 'c3c2', 'c3d2', 'c3e2',
-    'c3a3', 'c3b3', 'c3d3', 'c3e3', 'c3f3', 'c3g3', 'c3h3',
-    'c3a4', 'c3b4', 'c3c4', 'c3d4', 'c3e4', 'c3a5', 'c3b5',
-    'c3c5', 'c3d5', 'c3e5', 'c3c6', 'c3f6', 'c3c7', 'c3g7',
-    'c3c8', 'c3h8', 'd3b1', 'd3c1', 'd3d1', 'd3e1', 'd3f1',
-    'd3b2', 'd3c2', 'd3d2', 'd3e2', 'd3f2', 'd3a3', 'd3b3',
-    'd3c3', 'd3e3', 'd3f3', 'd3g3', 'd3h3', 'd3b4', 'd3c4',
-    'd3d4', 'd3e4', 'd3f4', 'd3b5', 'd3c5', 'd3d5', 'd3e5',
-    'd3f5', 'd3a6', 'd3d6', 'd3g6', 'd3d7', 'd3h7', 'd3d8',
-    'e3c1', 'e3d1', 'e3e1', 'e3f1', 'e3g1', 'e3c2', 'e3d2',
-    'e3e2', 'e3f2', 'e3g2', 'e3a3', 'e3b3', 'e3c3', 'e3d3',
-    'e3f3', 'e3g3', 'e3h3', 'e3c4', 'e3d4', 'e3e4', 'e3f4',
-    'e3g4', 'e3c5', 'e3d5', 'e3e5', 'e3f5', 'e3g5', 'e3b6',
-    'e3e6', 'e3h6', 'e3a7', 'e3e7', 'e3e8', 'f3d1', 'f3e1',
-    'f3f1', 'f3g1', 'f3h1', 'f3d2', 'f3e2', 'f3f2', 'f3g2',
-    'f3h2', 'f3a3', 'f3b3', 'f3c3', 'f3d3', 'f3e3', 'f3g3',
-    'f3h3', 'f3d4', 'f3e4', 'f3f4', 'f3g4', 'f3h4', 'f3d5',
-    'f3e5', 'f3f5', 'f3g5', 'f3h5', 'f3c6', 'f3f6', 'f3b7',
-    'f3f7', 'f3a8', 'f3f8', 'g3e1', 'g3f1', 'g3g1', 'g3h1',
-    'g3e2', 'g3f2', 'g3g2', 'g3h2', 'g3a3', 'g3b3', 'g3c3',
-    'g3d3', 'g3e3', 'g3f3', 'g3h3', 'g3e4', 'g3f4', 'g3g4',
-    'g3h4', 'g3e5', 'g3f5', 'g3g5', 'g3h5', 'g3d6', 'g3g6',
-    'g3c7', 'g3g7', 'g3b8', 'g3g8', 'h3f1', 'h3g1', 'h3h1',
-    'h3f2', 'h3g2', 'h3h2', 'h3a3', 'h3b3', 'h3c3', 'h3d3',
-    'h3e3', 'h3f3', 'h3g3', 'h3f4', 'h3g4', 'h3h4', 'h3f5',
-    'h3g5', 'h3h5', 'h3e6', 'h3h6', 'h3d7', 'h3h7', 'h3c8',
-    'h3h8', 'a4a1', 'a4d1', 'a4a2', 'a4b2', 'a4c2', 'a4a3',
-    'a4b3', 'a4c3', 'a4b4', 'a4c4', 'a4d4', 'a4e4', 'a4f4',
-    'a4g4', 'a4h4', 'a4a5', 'a4b5', 'a4c5', 'a4a6', 'a4b6',
-    'a4c6', 'a4a7', 'a4d7', 'a4a8', 'a4e8', 'b4b1', 'b4e1',
-    'b4a2', 'b4b2', 'b4c2', 'b4d2', 'b4a3', 'b4b3', 'b4c3',
-    'b4d3', 'b4a4', 'b4c4', 'b4d4', 'b4e4', 'b4f4', 'b4g4',
-    'b4h4', 'b4a5', 'b4b5', 'b4c5', 'b4d5', 'b4a6', 'b4b6',
-    'b4c6', 'b4d6', 'b4b7', 'b4e7', 'b4b8', 'b4f8', 'c4c1',
-    'c4f1', 'c4a2', 'c4b2', 'c4c2', 'c4d2', 'c4e2', 'c4a3',
-    'c4b3', 'c4c3', 'c4d3', 'c4e3', 'c4a4', 'c4b4', 'c4d4',
-    'c4e4', 'c4f4', 'c4g4', 'c4h4', 'c4a5', 'c4b5', 'c4c5',
-    'c4d5', 'c4e5', 'c4a6', 'c4b6', 'c4c6', 'c4d6', 'c4e6',
-    'c4c7', 'c4f7', 'c4c8', 'c4g8', 'd4a1', 'd4d1', 'd4g1',
-    'd4b2', 'd4c2', 'd4d2', 'd4e2', 'd4f2', 'd4b3', 'd4c3',
-    'd4d3', 'd4e3', 'd4f3', 'd4a4', 'd4b4', 'd4c4', 'd4e4',
-    'd4f4', 'd4g4', 'd4h4', 'd4b5', 'd4c5', 'd4d5', 'd4e5',
-    'd4f5', 'd4b6', 'd4c6', 'd4d6', 'd4e6', 'd4f6', 'd4a7',
-    'd4d7', 'd4g7', 'd4d8', 'd4h8', 'e4b1', 'e4e1', 'e4h1',
-    'e4c2', 'e4d2', 'e4e2', 'e4f2', 'e4g2', 'e4c3', 'e4d3',
-    'e4e3', 'e4f3', 'e4g3', 'e4a4', 'e4b4', 'e4c4', 'e4d4',
-    'e4f4', 'e4g4', 'e4h4', 'e4c5', 'e4d5', 'e4e5', 'e4f5',
-    'e4g5', 'e4c6', 'e4d6', 'e4e6', 'e4f6', 'e4g6', 'e4b7',
-    'e4e7', 'e4h7', 'e4a8', 'e4e8', 'f4c1', 'f4f1', 'f4d2',
-    'f4e2', 'f4f2', 'f4g2', 'f4h2', 'f4d3', 'f4e3', 'f4f3',
-    'f4g3', 'f4h3', 'f4a4', 'f4b4', 'f4c4', 'f4d4', 'f4e4',
-    'f4g4', 'f4h4', 'f4d5', 'f4e5', 'f4f5', 'f4g5', 'f4h5',
-    'f4d6', 'f4e6', 'f4f6', 'f4g6', 'f4h6', 'f4c7', 'f4f7',
-    'f4b8', 'f4f8', 'g4d1', 'g4g1', 'g4e2', 'g4f2', 'g4g2',
-    'g4h2', 'g4e3', 'g4f3', 'g4g3', 'g4h3', 'g4a4', 'g4b4',
-    'g4c4', 'g4d4', 'g4e4', 'g4f4', 'g4h4', 'g4e5', 'g4f5',
-    'g4g5', 'g4h5', 'g4e6', 'g4f6', 'g4g6', 'g4h6', 'g4d7',
-    'g4g7', 'g4c8', 'g4g8', 'h4e1', 'h4h1', 'h4f2', 'h4g2',
-    'h4h2', 'h4f3', 'h4g3', 'h4h3', 'h4a4', 'h4b4', 'h4c4',
-    'h4d4', 'h4e4', 'h4f4', 'h4g4', 'h4f5', 'h4g5', 'h4h5',
-    'h4f6', 'h4g6', 'h4h6', 'h4e7', 'h4h7', 'h4d8', 'h4h8',
-    'a5a1', 'a5e1', 'a5a2', 'a5d2', 'a5a3', 'a5b3', 'a5c3',
-    'a5a4', 'a5b4', 'a5c4', 'a5b5', 'a5c5', 'a5d5', 'a5e5',
-    'a5f5', 'a5g5', 'a5h5', 'a5a6', 'a5b6', 'a5c6', 'a5a7',
-    'a5b7', 'a5c7', 'a5a8', 'a5d8', 'b5b1', 'b5f1', 'b5b2',
-    'b5e2', 'b5a3', 'b5b3', 'b5c3', 'b5d3', 'b5a4', 'b5b4',
-    'b5c4', 'b5d4', 'b5a5', 'b5c5', 'b5d5', 'b5e5', 'b5f5',
-    'b5g5', 'b5h5', 'b5a6', 'b5b6', 'b5c6', 'b5d6', 'b5a7',
-    'b5b7', 'b5c7', 'b5d7', 'b5b8', 'b5e8', 'c5c1', 'c5g1',
-    'c5c2', 'c5f2', 'c5a3', 'c5b3', 'c5c3', 'c5d3', 'c5e3',
-    'c5a4', 'c5b4', 'c5c4', 'c5d4', 'c5e4', 'c5a5', 'c5b5',
-    'c5d5', 'c5e5', 'c5f5', 'c5g5', 'c5h5', 'c5a6', 'c5b6',
-    'c5c6', 'c5d6', 'c5e6', 'c5a7', 'c5b7', 'c5c7', 'c5d7',
-    'c5e7', 'c5c8', 'c5f8', 'd5d1', 'd5h1', 'd5a2', 'd5d2',
-    'd5g2', 'd5b3', 'd5c3', 'd5d3', 'd5e3', 'd5f3', 'd5b4',
-    'd5c4', 'd5d4', 'd5e4', 'd5f4', 'd5a5', 'd5b5', 'd5c5',
-    'd5e5', 'd5f5', 'd5g5', 'd5h5', 'd5b6', 'd5c6', 'd5d6',
-    'd5e6', 'd5f6', 'd5b7', 'd5c7', 'd5d7', 'd5e7', 'd5f7',
-    'd5a8', 'd5d8', 'd5g8', 'e5a1', 'e5e1', 'e5b2', 'e5e2',
-    'e5h2', 'e5c3', 'e5d3', 'e5e3', 'e5f3', 'e5g3', 'e5c4',
-    'e5d4', 'e5e4', 'e5f4', 'e5g4', 'e5a5', 'e5b5', 'e5c5',
-    'e5d5', 'e5f5', 'e5g5', 'e5h5', 'e5c6', 'e5d6', 'e5e6',
-    'e5f6', 'e5g6', 'e5c7', 'e5d7', 'e5e7', 'e5f7', 'e5g7',
-    'e5b8', 'e5e8', 'e5h8', 'f5b1', 'f5f1', 'f5c2', 'f5f2',
-    'f5d3', 'f5e3', 'f5f3', 'f5g3', 'f5h3', 'f5d4', 'f5e4',
-    'f5f4', 'f5g4', 'f5h4', 'f5a5', 'f5b5', 'f5c5', 'f5d5',
-    'f5e5', 'f5g5', 'f5h5', 'f5d6', 'f5e6', 'f5f6', 'f5g6',
-    'f5h6', 'f5d7', 'f5e7', 'f5f7', 'f5g7', 'f5h7', 'f5c8',
-    'f5f8', 'g5c1', 'g5g1', 'g5d2', 'g5g2', 'g5e3', 'g5f3',
-    'g5g3', 'g5h3', 'g5e4', 'g5f4', 'g5g4', 'g5h4', 'g5a5',
-    'g5b5', 'g5c5', 'g5d5', 'g5e5', 'g5f5', 'g5h5', 'g5e6',
-    'g5f6', 'g5g6', 'g5h6', 'g5e7', 'g5f7', 'g5g7', 'g5h7',
-    'g5d8', 'g5g8', 'h5d1', 'h5h1', 'h5e2', 'h5h2', 'h5f3',
-    'h5g3', 'h5h3', 'h5f4', 'h5g4', 'h5h4', 'h5a5', 'h5b5',
-    'h5c5', 'h5d5', 'h5e5', 'h5f5', 'h5g5', 'h5f6', 'h5g6',
-    'h5h6', 'h5f7', 'h5g7', 'h5h7', 'h5e8', 'h5h8', 'a6a1',
-    'a6f1', 'a6a2', 'a6e2', 'a6a3', 'a6d3', 'a6a4', 'a6b4',
-    'a6c4', 'a6a5', 'a6b5', 'a6c5', 'a6b6', 'a6c6', 'a6d6',
-    'a6e6', 'a6f6', 'a6g6', 'a6h6', 'a6a7', 'a6b7', 'a6c7',
-    'a6a8', 'a6b8', 'a6c8', 'b6b1', 'b6g1', 'b6b2', 'b6f2',
-    'b6b3', 'b6e3', 'b6a4', 'b6b4', 'b6c4', 'b6d4', 'b6a5',
-    'b6b5', 'b6c5', 'b6d5', 'b6a6', 'b6c6', 'b6d6', 'b6e6',
-    'b6f6', 'b6g6', 'b6h6', 'b6a7', 'b6b7', 'b6c7', 'b6d7',
-    'b6a8', 'b6b8', 'b6c8', 'b6d8', 'c6c1', 'c6h1', 'c6c2',
-    'c6g2', 'c6c3', 'c6f3', 'c6a4', 'c6b4', 'c6c4', 'c6d4',
-    'c6e4', 'c6a5', 'c6b5', 'c6c5', 'c6d5', 'c6e5', 'c6a6',
-    'c6b6', 'c6d6', 'c6e6', 'c6f6', 'c6g6', 'c6h6', 'c6a7',
-    'c6b7', 'c6c7', 'c6d7', 'c6e7', 'c6a8', 'c6b8', 'c6c8',
-    'c6d8', 'c6e8', 'd6d1', 'd6d2', 'd6h2', 'd6a3', 'd6d3',
-    'd6g3', 'd6b4', 'd6c4', 'd6d4', 'd6e4', 'd6f4', 'd6b5',
-    'd6c5', 'd6d5', 'd6e5', 'd6f5', 'd6a6', 'd6b6', 'd6c6',
-    'd6e6', 'd6f6', 'd6g6', 'd6h6', 'd6b7', 'd6c7', 'd6d7',
-    'd6e7', 'd6f7', 'd6b8', 'd6c8', 'd6d8', 'd6e8', 'd6f8',
-    'e6e1', 'e6a2', 'e6e2', 'e6b3', 'e6e3', 'e6h3', 'e6c4',
-    'e6d4', 'e6e4', 'e6f4', 'e6g4', 'e6c5', 'e6d5', 'e6e5',
-    'e6f5', 'e6g5', 'e6a6', 'e6b6', 'e6c6', 'e6d6', 'e6f6',
-    'e6g6', 'e6h6', 'e6c7', 'e6d7', 'e6e7', 'e6f7', 'e6g7',
-    'e6c8', 'e6d8', 'e6e8', 'e6f8', 'e6g8', 'f6a1', 'f6f1',
-    'f6b2', 'f6f2', 'f6c3', 'f6f3', 'f6d4', 'f6e4', 'f6f4',
-    'f6g4', 'f6h4', 'f6d5', 'f6e5', 'f6f5', 'f6g5', 'f6h5',
-    'f6a6', 'f6b6', 'f6c6', 'f6d6', 'f6e6', 'f6g6', 'f6h6',
-    'f6d7', 'f6e7', 'f6f7', 'f6g7', 'f6h7', 'f6d8', 'f6e8',
-    'f6f8', 'f6g8', 'f6h8', 'g6b1', 'g6g1', 'g6c2', 'g6g2',
-    'g6d3', 'g6g3', 'g6e4', 'g6f4', 'g6g4', 'g6h4', 'g6e5',
-    'g6f5', 'g6g5', 'g6h5', 'g6a6', 'g6b6', 'g6c6', 'g6d6',
-    'g6e6', 'g6f6', 'g6h6', 'g6e7', 'g6f7', 'g6g7', 'g6h7',
-    'g6e8', 'g6f8', 'g6g8', 'g6h8', 'h6c1', 'h6h1', 'h6d2',
-    'h6h2', 'h6e3', 'h6h3', 'h6f4', 'h6g4', 'h6h4', 'h6f5',
-    'h6g5', 'h6h5', 'h6a6', 'h6b6', 'h6c6', 'h6d6', 'h6e6',
-    'h6f6', 'h6g6', 'h6f7', 'h6g7', 'h6h7', 'h6f8', 'h6g8',
-    'h6h8', 'a7a1', 'a7g1', 'a7a2', 'a7f2', 'a7a3', 'a7e3',
-    'a7a4', 'a7d4', 'a7a5', 'a7b5', 'a7c5', 'a7a6', 'a7b6',
-    'a7c6', 'a7b7', 'a7c7', 'a7d7', 'a7e7', 'a7f7', 'a7g7',
-    'a7h7', 'a7a8', 'a7b8', 'a7c8', 'b7b1', 'b7h1', 'b7b2',
-    'b7g2', 'b7b3', 'b7f3', 'b7b4', 'b7e4', 'b7a5', 'b7b5',
-    'b7c5', 'b7d5', 'b7a6', 'b7b6', 'b7c6', 'b7d6', 'b7a7',
-    'b7c7', 'b7d7', 'b7e7', 'b7f7', 'b7g7', 'b7h7', 'b7a8',
-    'b7b8', 'b7c8', 'b7d8', 'c7c1', 'c7c2', 'c7h2', 'c7c3',
-    'c7g3', 'c7c4', 'c7f4', 'c7a5', 'c7b5', 'c7c5', 'c7d5',
-    'c7e5', 'c7a6', 'c7b6', 'c7c6', 'c7d6', 'c7e6', 'c7a7',
-    'c7b7', 'c7d7', 'c7e7', 'c7f7', 'c7g7', 'c7h7', 'c7a8',
-    'c7b8', 'c7c8', 'c7d8', 'c7e8', 'd7d1', 'd7d2', 'd7d3',
-    'd7h3', 'd7a4', 'd7d4', 'd7g4', 'd7b5', 'd7c5', 'd7d5',
-    'd7e5', 'd7f5', 'd7b6', 'd7c6', 'd7d6', 'd7e6', 'd7f6',
-    'd7a7', 'd7b7', 'd7c7', 'd7e7', 'd7f7', 'd7g7', 'd7h7',
-    'd7b8', 'd7c8', 'd7d8', 'd7e8', 'd7f8', 'e7e1', 'e7e2',
-    'e7a3', 'e7e3', 'e7b4', 'e7e4', 'e7h4', 'e7c5', 'e7d5',
-    'e7e5', 'e7f5', 'e7g5', 'e7c6', 'e7d6', 'e7e6', 'e7f6',
-    'e7g6', 'e7a7', 'e7b7', 'e7c7', 'e7d7', 'e7f7', 'e7g7',
-    'e7h7', 'e7c8', 'e7d8', 'e7e8', 'e7f8', 'e7g8', 'f7f1',
-    'f7a2', 'f7f2', 'f7b3', 'f7f3', 'f7c4', 'f7f4', 'f7d5',
-    'f7e5', 'f7f5', 'f7g5', 'f7h5', 'f7d6', 'f7e6', 'f7f6',
-    'f7g6', 'f7h6', 'f7a7', 'f7b7', 'f7c7', 'f7d7', 'f7e7',
-    'f7g7', 'f7h7', 'f7d8', 'f7e8', 'f7f8', 'f7g8', 'f7h8',
-    'g7a1', 'g7g1', 'g7b2', 'g7g2', 'g7c3', 'g7g3', 'g7d4',
-    'g7g4', 'g7e5', 'g7f5', 'g7g5', 'g7h5', 'g7e6', 'g7f6',
-    'g7g6', 'g7h6', 'g7a7', 'g7b7', 'g7c7', 'g7d7', 'g7e7',
-    'g7f7', 'g7h7', 'g7e8', 'g7f8', 'g7g8', 'g7h8', 'h7b1',
-    'h7h1', 'h7c2', 'h7h2', 'h7d3', 'h7h3', 'h7e4', 'h7h4',
-    'h7f5', 'h7g5', 'h7h5', 'h7f6', 'h7g6', 'h7h6', 'h7a7',
-    'h7b7', 'h7c7', 'h7d7', 'h7e7', 'h7f7', 'h7g7', 'h7f8',
-    'h7g8', 'h7h8', 'a8a1', 'a8h1', 'a8a2', 'a8g2', 'a8a3',
-    'a8f3', 'a8a4', 'a8e4', 'a8a5', 'a8d5', 'a8a6', 'a8b6',
-    'a8c6', 'a8a7', 'a8b7', 'a8c7', 'a8b8', 'a8c8', 'a8d8',
-    'a8e8', 'a8f8', 'a8g8', 'a8h8', 'b8b1', 'b8b2', 'b8h2',
-    'b8b3', 'b8g3', 'b8b4', 'b8f4', 'b8b5', 'b8e5', 'b8a6',
-    'b8b6', 'b8c6', 'b8d6', 'b8a7', 'b8b7', 'b8c7', 'b8d7',
-    'b8a8', 'b8c8', 'b8d8', 'b8e8', 'b8f8', 'b8g8', 'b8h8',
-    'c8c1', 'c8c2', 'c8c3', 'c8h3', 'c8c4', 'c8g4', 'c8c5',
-    'c8f5', 'c8a6', 'c8b6', 'c8c6', 'c8d6', 'c8e6', 'c8a7',
-    'c8b7', 'c8c7', 'c8d7', 'c8e7', 'c8a8', 'c8b8', 'c8d8',
-    'c8e8', 'c8f8', 'c8g8', 'c8h8', 'd8d1', 'd8d2', 'd8d3',
-    'd8d4', 'd8h4', 'd8a5', 'd8d5', 'd8g5', 'd8b6', 'd8c6',
-    'd8d6', 'd8e6', 'd8f6', 'd8b7', 'd8c7', 'd8d7', 'd8e7',
-    'd8f7', 'd8a8', 'd8b8', 'd8c8', 'd8e8', 'd8f8', 'd8g8',
-    'd8h8', 'e8e1', 'e8e2', 'e8e3', 'e8a4', 'e8e4', 'e8b5',
-    'e8e5', 'e8h5', 'e8c6', 'e8d6', 'e8e6', 'e8f6', 'e8g6',
-    'e8c7', 'e8d7', 'e8e7', 'e8f7', 'e8g7', 'e8a8', 'e8b8',
-    'e8c8', 'e8d8', 'e8f8', 'e8g8', 'e8h8', 'f8f1', 'f8f2',
-    'f8a3', 'f8f3', 'f8b4', 'f8f4', 'f8c5', 'f8f5', 'f8d6',
-    'f8e6', 'f8f6', 'f8g6', 'f8h6', 'f8d7', 'f8e7', 'f8f7',
-    'f8g7', 'f8h7', 'f8a8', 'f8b8', 'f8c8', 'f8d8', 'f8e8',
-    'f8g8', 'f8h8', 'g8g1', 'g8a2', 'g8g2', 'g8b3', 'g8g3',
-    'g8c4', 'g8g4', 'g8d5', 'g8g5', 'g8e6', 'g8f6', 'g8g6',
-    'g8h6', 'g8e7', 'g8f7', 'g8g7', 'g8h7', 'g8a8', 'g8b8',
-    'g8c8', 'g8d8', 'g8e8', 'g8f8', 'g8h8', 'h8a1', 'h8h1',
-    'h8b2', 'h8h2', 'h8c3', 'h8h3', 'h8d4', 'h8h4', 'h8e5',
-    'h8h5', 'h8f6', 'h8g6', 'h8h6', 'h8f7', 'h8g7', 'h8h7',
-    'h8a8', 'h8b8', 'h8c8', 'h8d8', 'h8e8', 'h8f8', 'h8g8',
-    'a7a8q', 'a7a8r', 'a7a8b', 'a7b8q', 'a7b8r', 'a7b8b', 'b7a8q',
-    'b7a8r', 'b7a8b', 'b7b8q', 'b7b8r', 'b7b8b', 'b7c8q', 'b7c8r',
-    'b7c8b', 'c7b8q', 'c7b8r', 'c7b8b', 'c7c8q', 'c7c8r', 'c7c8b',
-    'c7d8q', 'c7d8r', 'c7d8b', 'd7c8q', 'd7c8r', 'd7c8b', 'd7d8q',
-    'd7d8r', 'd7d8b', 'd7e8q', 'd7e8r', 'd7e8b', 'e7d8q', 'e7d8r',
-    'e7d8b', 'e7e8q', 'e7e8r', 'e7e8b', 'e7f8q', 'e7f8r', 'e7f8b',
-    'f7e8q', 'f7e8r', 'f7e8b', 'f7f8q', 'f7f8r', 'f7f8b', 'f7g8q',
-    'f7g8r', 'f7g8b', 'g7f8q', 'g7f8r', 'g7f8b', 'g7g8q', 'g7g8r',
-    'g7g8b', 'g7h8q', 'g7h8r', 'g7h8b', 'h7g8q', 'h7g8r', 'h7g8b',
-    'h7h8q', 'h7h8r', 'h7h8b'
-]
-
-# White, no castling
-_uci_to_idx_wn = dict((uci, idx) for idx, uci in enumerate(_idx_to_move_wn))
-
-# White, castling
-_uci_to_idx_wc = dict((uci, idx) for idx, uci in enumerate(_idx_to_move_wn))
-_uci_to_idx_wc['e1g1'], _uci_to_idx_wc['e1h1'] = _uci_to_idx_wc['e1h1'], _uci_to_idx_wc['e1g1']
-_uci_to_idx_wc['e1c1'], _uci_to_idx_wc['e1a1'] = _uci_to_idx_wc['e1a1'], _uci_to_idx_wc['e1c1'] 
-
-
-# Black, no castling
-_idx_to_move_bn = []
-for move in _idx_to_move_wn:
-    c0,r0,c1,r1,p = move[0],int(move[1]),move[2],int(move[3]),move[4:]
-    r0 = 9 - r0
-    r1 = 9 - r1
-    _idx_to_move_bn.append('{}{}{}{}{}'.format(c0,r0,c1,r1,p))
-_uci_to_idx_bn = dict((uci, idx) for idx, uci in enumerate(_idx_to_move_bn))
-
-# Black, castling
-_uci_to_idx_bc = dict((uci, idx) for idx, uci in enumerate(_idx_to_move_bn))
-_uci_to_idx_bc['e8g8'], _uci_to_idx_bc['e8h8'] = _uci_to_idx_bc['e8h8'], _uci_to_idx_bc['e8g8']
-_uci_to_idx_bc['e8c8'], _uci_to_idx_bc['e8a8'] = _uci_to_idx_bc['e8a8'], _uci_to_idx_bc['e8c8'] 
-
-uci_to_idx = [_uci_to_idx_wn, _uci_to_idx_wc, _uci_to_idx_bn, _uci_to_idx_bc]
-
-
-import collections
-import struct
-import zlib
-
-import chess
-import numpy as np
-from chess import Move
-
-flat_planes = []
-for i in range(256):
-    flat_planes.append(np.ones((8,8), dtype=np.uint8)*i)
-
-LeelaBoardData = collections.namedtuple('LeelaBoardData',
-                            'plane_bytes repetition '
-                            'transposition_key us_ooo us_oo them_ooo them_oo '
-                            'side_to_move rule50_count')
-
-def pc_board_property(propertyname):
-    '''Create a property based on self.pc_board'''
-    def prop(self):
-        return getattr(self.pc_board, propertyname)
-    return property(prop)
-    
-class LeelaBoard:
-    turn = pc_board_property('turn')
-    move_stack = pc_board_property('move_stack')
-    _plane_bytes_struct = struct.Struct('>Q')
-    
-    def __init__(self, leela_board = None, *args, **kwargs):
-        '''If leela_board is passed as an argument, return a copy'''
-        self.pc_board = chess.Board(*args, **kwargs)
-        self.lcz_stack = []
-        self._lcz_transposition_counter = collections.Counter()
-        self._lcz_push()
-        self.is_game_over = self.pc_method('is_game_over')
-        self.can_claim_draw = self.pc_method('can_claim_draw')
-        self.generate_legal_moves = self.pc_method('generate_legal_moves')
-                
-    def copy(self, history=7):
-        """Note! Currently the copy constructor uses pc_board.copy(stack=False), which makes pops impossible"""
-        cls = type(self)
-        copied = cls.__new__(cls)
-        copied.pc_board = self.pc_board.copy(stack=False)
-        copied.pc_board.stack[:] = self.pc_board.stack[-history:]
-        copied.pc_board.move_stack[:] = self.pc_board.move_stack[-history:]
-        copied.lcz_stack = self.lcz_stack[-history:]
-        copied._lcz_transposition_counter = self._lcz_transposition_counter.copy()
-        copied.is_game_over = copied.pc_method('is_game_over')
-        copied.can_claim_draw = copied.pc_method('can_claim_draw')
-        copied.generate_legal_moves = copied.pc_method('generate_legal_moves')        
-        return copied
-
-    def pc_method(self, methodname):
-        '''Return attribute of self.pc_board, useful for copying method bindings'''
-        return getattr(self.pc_board, methodname)
-    
-    def is_threefold(self):
-        transposition_key = self.pc_board._transposition_key()
-        return self._lcz_transposition_counter[transposition_key] >= 3
-    
-    def is_fifty_moves(self):
-        return self.pc_board.halfmove_clock >= 100
-    
-    def is_draw(self):
-        return self.is_threefold() or self.is_fifty_moves()
-
-    def push(self, move):
-        self.pc_board.push(move)
-        self._lcz_push()
-
-    def push_uci(self, uci):
-        # don't check for legality - it takes much longer to run...
-        # self.pc_board.push_uci(uci)
-        self.pc_board.push(Move.from_uci(uci))
-        self._lcz_push()
-
-    def push_san(self, san):
-        self.pc_board.push_san(san)
-        self._lcz_push()
-
-    def pop(self):
-        result = self.pc_board.pop()
-        _lcz_data = self.lcz_stack.pop()
-        self._lcz_transposition_counter.subtract((_lcz_data.transposition_key,))
-        return result
-
-    def _plane_bytes_iter(self):
-        """Get plane bytes... used for _lcz_push"""
-        pack = self._plane_bytes_struct.pack
-        pieces_mask = self.pc_board.pieces_mask
-        for color in (True, False):
-            for piece_type in range(1,7):
-                byts = pack(pieces_mask(piece_type, color))
-                yield byts
-
-    def _lcz_push(self):
-        """Push data onto the lcz data stack after pushing board moves"""
-        transposition_key = self.pc_board._transposition_key()
-        self._lcz_transposition_counter.update((transposition_key,))
-        repetitions = self._lcz_transposition_counter[transposition_key] - 1
-        # side_to_move = 0 if we're white, 1 if we're black
-        side_to_move = 0 if self.pc_board.turn else 1
-        rule50_count = self.pc_board.halfmove_clock
-        # Figure out castling rights
-        if not side_to_move:
-            # we're white
-            _c = self.pc_board.castling_rights
-            us_ooo, us_oo = (_c>>chess.A1) & 1, (_c>>chess.H1) & 1
-            them_ooo, them_oo = (_c>>chess.A8) & 1, (_c>>chess.H8) & 1
-        else: 
-            # We're black
-            _c = self.pc_board.castling_rights
-            us_ooo, us_oo = (_c>>chess.A8) & 1, (_c>>chess.H8) & 1
-            them_ooo, them_oo = (_c>>chess.A1) & 1, (_c>>chess.H1) & 1
-        # Create 13 planes... 6 us, 6 them, repetitions>=1
-        plane_bytes = b''.join(self._plane_bytes_iter())
-        repetition = (repetitions>=1)
-        lcz_data = LeelaBoardData(
-            plane_bytes, repetition=repetition,
-            transposition_key=transposition_key,
-            us_ooo=us_ooo, us_oo=us_oo, them_ooo=them_ooo, them_oo=them_oo,
-            side_to_move=side_to_move, rule50_count=rule50_count
-        )
-        self.lcz_stack.append(lcz_data)
-        
-    def serialize_features(self):
-        '''Get compacted bytes representation of input planes'''
-        planes = []
-        curdata = self.lcz_stack[-1]
-        bytes_false_true = bytes([False]), bytes([True])
-        bytes_per_history = 97
-        total_plane_bytes = bytes_per_history * 8
-        def bytes_iter():
-            plane_bytes_yielded = 0
-            for data in self.lcz_stack[-1:-9:-1]:
-                yield data.plane_bytes
-                yield bytes_false_true[data.repetition]
-                plane_bytes_yielded += bytes_per_history
-            # 104 total piece planes... fill in missing with 0s
-            yield bytes(total_plane_bytes - plane_bytes_yielded)
-            # Yield the rest of the constant planes
-            yield np.packbits((curdata.us_ooo,
-                             curdata.us_oo,
-                             curdata.them_ooo,
-                             curdata.them_oo,
-                             curdata.side_to_move)).tobytes()
-            yield chr(curdata.rule50_count).encode()
-        return b''.join(bytes_iter())
-    
-    @classmethod
-    def deserialize_features(cls, serialized):
-        planes_stack = []
-        rule50_count = serialized[-1]  # last byte is rule 50
-        board_attrs = np.unpackbits(memoryview(serialized[-2:-1]))  # second to last byte
-        us_ooo, us_oo, them_ooo, them_oo, side_to_move = board_attrs[:5]
-        bytes_per_history = 97
-        for history_idx in range(0, bytes_per_history*8, bytes_per_history):
-            plane_bytes = serialized[history_idx:history_idx+96]
-            repetition = serialized[history_idx+96]
-            if not side_to_move:
-                # we're white
-                planes = (np.unpackbits(memoryview(plane_bytes))[::-1]
-                                        .reshape(12, 8, 8)[::-1])                
-            else:
-                # We're black
-                planes = (np.unpackbits(memoryview(plane_bytes))[::-1]
-                                        .reshape(12, 8, 8)[::-1]
-                                        .reshape(2,6,8,8)[::-1,:,::-1]
-                                        .reshape(12, 8,8))
-            planes_stack.append(planes)
-            planes_stack.append([flat_planes[repetition]])
-        planes_stack.append([flat_planes[us_ooo],
-            flat_planes[us_oo],
-            flat_planes[them_ooo],
-            flat_planes[them_oo],
-            flat_planes[side_to_move],
-            flat_planes[rule50_count],
-            flat_planes[0],
-            flat_planes[1]])     
-        planes = np.concatenate(planes_stack)
-        return planes                
-        
-    def lcz_features(self):
-        '''Get neural network input planes as uint8'''
-        # print(list(self._planes_iter()))
-        planes_stack = []
-        curdata = self.lcz_stack[-1]
-        planes_yielded = 0
-        for data in self.lcz_stack[-1:-9:-1]:
-            plane_bytes = data.plane_bytes
-            if not curdata.side_to_move:
-                # we're white
-                planes = (np.unpackbits(memoryview(plane_bytes))[::-1]
-                                        .reshape(12, 8, 8)[::-1])                
-            else:
-                # We're black
-                planes = (np.unpackbits(memoryview(plane_bytes))[::-1]
-                                        .reshape(12, 8, 8)[::-1]
-                                        .reshape(2,6,8,8)[::-1,:,::-1]
-                                        .reshape(12, 8,8))
-            planes_stack.append(planes)
-            planes_stack.append([flat_planes[data.repetition]])
-            planes_yielded += 13
-        empty_planes = [flat_planes[0] for _ in range(104-planes_yielded)]
-        if empty_planes:
-            planes_stack.append(empty_planes)
-        # Yield the rest of the constant planes
-        planes_stack.append([flat_planes[curdata.us_ooo],
-            flat_planes[curdata.us_oo],
-            flat_planes[curdata.them_ooo],
-            flat_planes[curdata.them_oo],
-            flat_planes[curdata.side_to_move],
-            flat_planes[curdata.rule50_count],
-            flat_planes[0],
-            flat_planes[1]])     
-        planes = np.concatenate(planes_stack)
-        return planes
-
-    def lcz_uci_to_idx(self, uci_list):
-        # Return list of NN policy output indexes for this board position, given uci_list
-        
-        # TODO: Perhaps it's possible to just add the uci knight promotion move to the index dict
-        # currently knight promotions are not in the dict 
-        uci_list = [uci.rstrip('n') for uci in uci_list]
-        
-        data = self.lcz_stack[-1]
-        # uci_to_idx_index =
-        #  White, no-castling => 0
-        #  White, castling => 1
-        #  Black, no-castling => 2
-        #  Black, castling => 3
-        uci_to_idx_index = (data.us_ooo | data.us_oo) +  2*data.side_to_move
-        uci_idx_dct = uci_to_idx[uci_to_idx_index]
-        return [uci_idx_dct[m] for m in uci_list]
-    
-    @classmethod
-    def compress_features(cls, features):
-        """Compress a features array as returned from lcz_features method"""
-        features_8 = features.astype(np.uint8)
-        # Simple compression would do this...
-        # return zlib.compress(features_8)
-        piece_plane_bytes = np.packbits(features_8[:-8]).tobytes()
-        scalar_bytes = features_8[-8:][:,0,0].tobytes()
-        compressed = zlib.compress(piece_plane_bytes + scalar_bytes)
-        return compressed
-    
-    @classmethod
-    def decompress_features(cls, compressed_features):
-        """Decompress a compressed features array from compress_features"""
-        decompressed = zlib.decompress(compressed_features)
-        # Simple decompression would do this
-        # return np.frombuffer(decompressed, dtype=np.uint8).astype(np.float32).reshape(-1,8,8)
-        piece_plane_bytes = decompressed[:-8]
-        scalar_bytes = decompressed[-8:]
-        piece_plane_arr = np.unpackbits(memoryview(piece_plane_bytes))
-        scalar_arr = np.frombuffer(scalar_bytes, dtype=np.uint8).repeat(64)
-        result = np.concatenate((piece_plane_arr, scalar_arr)).astype(np.float32).reshape(-1,8,8)
-        return result
-    
-    def unicode(self):
-        if self.pc_board.is_game_over() or self.is_draw():
-            result = self.pc_board.result(claim_draw=True)
-            turnstring = 'Result: {}'.format(result)
-        else:
-            turnstring = 'Turn: {}'.format('White' if self.pc_board.turn else 'Black') 
-        boardstr = self.pc_board.unicode() + "\n" + turnstring
-        return boardstr
-
-    def __repr__(self):
-        return "LeelaBoard('{}')".format(self.pc_board.fen())
-
-    def _repr_svg_(self):
-        return self.pc_board._repr_svg_()
-
-    def __str__(self):
-        if self.pc_board.is_game_over() or self.is_draw():
-            result = self.pc_board.result(claim_draw=True)
-            turnstring = 'Result: {}'.format(result)
-        else:
-            turnstring = 'Turn: {}'.format('White' if self.pc_board.turn else 'Black') 
-        boardstr = self.pc_board.__str__() + "\n" + turnstring
-        return boardstr
-    
-    def __eq__(self, other):
-        return self.get_hash_key() == other.get_hash_key()
-    
-    def __hash__(self):
-        return hash(self.get_hash_key())
-
-    def get_hash_key(self):
-        transposition_key = self.pc_board._transposition_key() 
-        return (transposition_key +
-                (self._lcz_transposition_counter[transposition_key], self.pc_board.halfmove_clock) +
-                tuple(self.pc_board.move_stack[-7:])
-                )
-
-# lb = LeelaBoard()
-# lb.push_uci('c2c4')
-#lb.push_uci('c7c5')
-#lb.push_uci('d2d3')
-#lb.push_uci('c2c4')
-#lb.push_uci('b8c6')
-# saved_planes = planes
-# planes = lb.features()
-# output = leela_net(torch.from_numpy(planes).unsqueeze(0))
-# output

our_visualization/python_chess_customized_svg.py

@@ -1,414 +0,0 @@
-# This file has been copied and slightly modified from python-chess library,
-# Copyright (C) 2016-2020 Niklas Fiekas <niklas.fiekas@backscattering.de>.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-# Piece vector graphics are copyright (C) Colin M.L. Burnett
-# <https://en.wikipedia.org/wiki/User:Cburnett> and also licensed under the
-# GNU General Public License.
-
-import chess
-import math
-
-import xml.etree.ElementTree as ET
-
-from typing import Iterable, Optional, Tuple, Union
-
-SQUARE_SIZE = 45
-MARGIN = 20
-
-PIECES = {
-    "b": """<g id="black-bishop" class="black bishop" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9 36c3.39-.97 10.11.43 13.5-2 3.39 2.43 10.11 1.03 13.5 2 0 0 1.65.54 3 2-.68.97-1.65.99-3 .5-3.39-.97-10.11.46-13.5-1-3.39 1.46-10.11.03-13.5 1-1.354.49-2.323.47-3-.5 1.354-1.94 3-2 3-2zm6-4c2.5 2.5 12.5 2.5 15 0 .5-1.5 0-2 0-2 0-2.5-2.5-4-2.5-4 5.5-1.5 6-11.5-5-15.5-11 4-10.5 14-5 15.5 0 0-2.5 1.5-2.5 4 0 0-.5.5 0 2zM25 8a2.5 2.5 0 1 1-5 0 2.5 2.5 0 1 1 5 0z" fill="#000" stroke-linecap="butt"/><path d="M17.5 26h10M15 30h15m-7.5-14.5v5M20 18h5" stroke="#fff" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "k": """<g id="black-king" class="black king" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M22.5 11.63V6" stroke-linejoin="miter"/><path d="M22.5 25s4.5-7.5 3-10.5c0 0-1-2.5-3-2.5s-3 2.5-3 2.5c-1.5 3 3 10.5 3 10.5" fill="#000" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M11.5 37c5.5 3.5 15.5 3.5 21 0v-7s9-4.5 6-10.5c-4-6.5-13.5-3.5-16 4V27v-3.5c-3.5-7.5-13-10.5-16-4-3 6 5 10 5 10V37z" fill="#000"/><path d="M20 8h5" stroke-linejoin="miter"/><path d="M32 29.5s8.5-4 6.03-9.65C34.15 14 25 18 22.5 24.5l.01 2.1-.01-2.1C20 18 9.906 14 6.997 19.85c-2.497 5.65 4.853 9 4.853 9M11.5 30c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0" stroke="#fff"/></g>""",
-    # noqa: E501
-    "n": """<g id="black-knight" class="black knight" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M 22,10 C 32.5,11 38.5,18 38,39 L 15,39 C 15,30 25,32.5 23,18" style="fill:#000000; stroke:#000000;"/><path d="M 24,18 C 24.38,20.91 18.45,25.37 16,27 C 13,29 13.18,31.34 11,31 C 9.958,30.06 12.41,27.96 11,28 C 10,28 11.19,29.23 10,30 C 9,30 5.997,31 6,26 C 6,24 12,14 12,14 C 12,14 13.89,12.1 14,10.5 C 13.27,9.506 13.5,8.5 13.5,7.5 C 14.5,6.5 16.5,10 16.5,10 L 18.5,10 C 18.5,10 19.28,8.008 21,7 C 22,7 22,10 22,10" style="fill:#000000; stroke:#000000;"/><path d="M 9.5 25.5 A 0.5 0.5 0 1 1 8.5,25.5 A 0.5 0.5 0 1 1 9.5 25.5 z" style="fill:#ececec; stroke:#ececec;"/><path d="M 15 15.5 A 0.5 1.5 0 1 1 14,15.5 A 0.5 1.5 0 1 1 15 15.5 z" transform="matrix(0.866,0.5,-0.5,0.866,9.693,-5.173)" style="fill:#ececec; stroke:#ececec;"/><path d="M 24.55,10.4 L 24.1,11.85 L 24.6,12 C 27.75,13 30.25,14.49 32.5,18.75 C 34.75,23.01 35.75,29.06 35.25,39 L 35.2,39.5 L 37.45,39.5 L 37.5,39 C 38,28.94 36.62,22.15 34.25,17.66 C 31.88,13.17 28.46,11.02 25.06,10.5 L 24.55,10.4 z " style="fill:#ececec; stroke:none;"/></g>""",
-    # noqa: E501
-    "p": """<g id="black-pawn" class="black pawn"><path d="M22 9c-2.21 0-4 1.79-4 4 0 .89.29 1.71.78 2.38-1.95 1.12-3.28 3.21-3.28 5.62 0 2.03.94 3.84 2.41 5.03-3 1.06-7.41 5.55-7.41 13.47h23c0-7.92-4.41-12.41-7.41-13.47 1.47-1.19 2.41-3 2.41-5.03 0-2.41-1.33-4.5-3.28-5.62.49-.67.78-1.49.78-2.38 0-2.21-1.79-4-4-4z" stroke="#000" stroke-width="1.5" stroke-linecap="round"/></g>""",
-    # noqa: E501
-    "q": """<g id="black-queen" class="black queen" fill="#000" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><g fill="#000" stroke="none"><circle cx="6" cy="12" r="2.75"/><circle cx="14" cy="9" r="2.75"/><circle cx="22.5" cy="8" r="2.75"/><circle cx="31" cy="9" r="2.75"/><circle cx="39" cy="12" r="2.75"/></g><path d="M9 26c8.5-1.5 21-1.5 27 0l2.5-12.5L31 25l-.3-14.1-5.2 13.6-3-14.5-3 14.5-5.2-13.6L14 25 6.5 13.5 9 26zM9 26c0 2 1.5 2 2.5 4 1 1.5 1 1 .5 3.5-1.5 1-1.5 2.5-1.5 2.5-1.5 1.5.5 2.5.5 2.5 6.5 1 16.5 1 23 0 0 0 1.5-1 0-2.5 0 0 .5-1.5-1-2.5-.5-2.5-.5-2 .5-3.5 1-2 2.5-2 2.5-4-8.5-1.5-18.5-1.5-27 0z" stroke-linecap="butt"/><path d="M11 38.5a35 35 1 0 0 23 0" fill="none" stroke-linecap="butt"/><path d="M11 29a35 35 1 0 1 23 0M12.5 31.5h20M11.5 34.5a35 35 1 0 0 22 0M10.5 37.5a35 35 1 0 0 24 0" fill="none" stroke="#fff"/></g>""",
-    # noqa: E501
-    "r": """<g id="black-rook" class="black rook" fill="#000" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9 39h27v-3H9v3zM12.5 32l1.5-2.5h17l1.5 2.5h-20zM12 36v-4h21v4H12z" stroke-linecap="butt"/><path d="M14 29.5v-13h17v13H14z" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M14 16.5L11 14h23l-3 2.5H14zM11 14V9h4v2h5V9h5v2h5V9h4v5H11z" stroke-linecap="butt"/><path d="M12 35.5h21M13 31.5h19M14 29.5h17M14 16.5h17M11 14h23" fill="none" stroke="#fff" stroke-width="1" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "B": """<g id="white-bishop" class="white bishop" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><g fill="#fff" stroke-linecap="butt"><path d="M9 36c3.39-.97 10.11.43 13.5-2 3.39 2.43 10.11 1.03 13.5 2 0 0 1.65.54 3 2-.68.97-1.65.99-3 .5-3.39-.97-10.11.46-13.5-1-3.39 1.46-10.11.03-13.5 1-1.354.49-2.323.47-3-.5 1.354-1.94 3-2 3-2zM15 32c2.5 2.5 12.5 2.5 15 0 .5-1.5 0-2 0-2 0-2.5-2.5-4-2.5-4 5.5-1.5 6-11.5-5-15.5-11 4-10.5 14-5 15.5 0 0-2.5 1.5-2.5 4 0 0-.5.5 0 2zM25 8a2.5 2.5 0 1 1-5 0 2.5 2.5 0 1 1 5 0z"/></g><path d="M17.5 26h10M15 30h15m-7.5-14.5v5M20 18h5" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "K": """<g id="white-king" class="white king" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M22.5 11.63V6M20 8h5" stroke-linejoin="miter"/><path d="M22.5 25s4.5-7.5 3-10.5c0 0-1-2.5-3-2.5s-3 2.5-3 2.5c-1.5 3 3 10.5 3 10.5" fill="#fff" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M11.5 37c5.5 3.5 15.5 3.5 21 0v-7s9-4.5 6-10.5c-4-6.5-13.5-3.5-16 4V27v-3.5c-3.5-7.5-13-10.5-16-4-3 6 5 10 5 10V37z" fill="#fff"/><path d="M11.5 30c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0"/></g>""",
-    # noqa: E501
-    "N": """<g id="white-knight" class="white knight" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M 22,10 C 32.5,11 38.5,18 38,39 L 15,39 C 15,30 25,32.5 23,18" style="fill:#ffffff; stroke:#000000;"/><path d="M 24,18 C 24.38,20.91 18.45,25.37 16,27 C 13,29 13.18,31.34 11,31 C 9.958,30.06 12.41,27.96 11,28 C 10,28 11.19,29.23 10,30 C 9,30 5.997,31 6,26 C 6,24 12,14 12,14 C 12,14 13.89,12.1 14,10.5 C 13.27,9.506 13.5,8.5 13.5,7.5 C 14.5,6.5 16.5,10 16.5,10 L 18.5,10 C 18.5,10 19.28,8.008 21,7 C 22,7 22,10 22,10" style="fill:#ffffff; stroke:#000000;"/><path d="M 9.5 25.5 A 0.5 0.5 0 1 1 8.5,25.5 A 0.5 0.5 0 1 1 9.5 25.5 z" style="fill:#000000; stroke:#000000;"/><path d="M 15 15.5 A 0.5 1.5 0 1 1 14,15.5 A 0.5 1.5 0 1 1 15 15.5 z" transform="matrix(0.866,0.5,-0.5,0.866,9.693,-5.173)" style="fill:#000000; stroke:#000000;"/></g>""",
-    # noqa: E501
-    "P": """<g id="white-pawn" class="white pawn"><path d="M22 9c-2.21 0-4 1.79-4 4 0 .89.29 1.71.78 2.38-1.95 1.12-3.28 3.21-3.28 5.62 0 2.03.94 3.84 2.41 5.03-3 1.06-7.41 5.55-7.41 13.47h23c0-7.92-4.41-12.41-7.41-13.47 1.47-1.19 2.41-3 2.41-5.03 0-2.41-1.33-4.5-3.28-5.62.49-.67.78-1.49.78-2.38 0-2.21-1.79-4-4-4z" fill="#fff" stroke="#000" stroke-width="1.5" stroke-linecap="round"/></g>""",
-    # noqa: E501
-    "Q": """<g id="white-queen" class="white queen" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 12a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM24.5 7.5a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM41 12a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM16 8.5a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM33 9a2 2 0 1 1-4 0 2 2 0 1 1 4 0z"/><path d="M9 26c8.5-1.5 21-1.5 27 0l2-12-7 11V11l-5.5 13.5-3-15-3 15-5.5-14V25L7 14l2 12zM9 26c0 2 1.5 2 2.5 4 1 1.5 1 1 .5 3.5-1.5 1-1.5 2.5-1.5 2.5-1.5 1.5.5 2.5.5 2.5 6.5 1 16.5 1 23 0 0 0 1.5-1 0-2.5 0 0 .5-1.5-1-2.5-.5-2.5-.5-2 .5-3.5 1-2 2.5-2 2.5-4-8.5-1.5-18.5-1.5-27 0z" stroke-linecap="butt"/><path d="M11.5 30c3.5-1 18.5-1 22 0M12 33.5c6-1 15-1 21 0" fill="none"/></g>""",
-    # noqa: E501
-    "R": """<g id="white-rook" class="white rook" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9 39h27v-3H9v3zM12 36v-4h21v4H12zM11 14V9h4v2h5V9h5v2h5V9h4v5" stroke-linecap="butt"/><path d="M34 14l-3 3H14l-3-3"/><path d="M31 17v12.5H14V17" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M31 29.5l1.5 2.5h-20l1.5-2.5"/><path d="M11 14h23" fill="none" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-}
-
-PIECES = {
-    "b": """<g id="black-bishop" class="black bishop" fill="none" fill-rule="evenodd" stroke="#fff" stroke-width="1.0" stroke-linecap="round" stroke-linejoin="round"><path d="M9 36c3.39-.97 10.11.43 13.5-2 3.39 2.43 10.11 1.03 13.5 2 0 0 1.65.54 3 2-.68.97-1.65.99-3 .5-3.39-.97-10.11.46-13.5-1-3.39 1.46-10.11.03-13.5 1-1.354.49-2.323.47-3-.5 1.354-1.94 3-2 3-2zm6-4c2.5 2.5 12.5 2.5 15 0 .5-1.5 0-2 0-2 0-2.5-2.5-4-2.5-4 5.5-1.5 6-11.5-5-15.5-11 4-10.5 14-5 15.5 0 0-2.5 1.5-2.5 4 0 0-.5.5 0 2zM25 8a2.5 2.5 0 1 1-5 0 2.5 2.5 0 1 1 5 0z" fill="#000" stroke-linecap="butt"/><path d="M17.5 26h10M15 30h15m-7.5-14.5v5M20 18h5" stroke="#fff" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "k": """<g id="black-king" class="black king" fill="none" fill-rule="evenodd" stroke="#fff" stroke-width="1.0" stroke-linecap="round" stroke-linejoin="round"><path d="M22.5 11.63V6" stroke-linejoin="miter"/><path d="M22.5 25s4.5-7.5 3-10.5c0 0-1-2.5-3-2.5s-3 2.5-3 2.5c-1.5 3 3 10.5 3 10.5" fill="#000" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M11.5 37c5.5 3.5 15.5 3.5 21 0v-7s9-4.5 6-10.5c-4-6.5-13.5-3.5-16 4V27v-3.5c-3.5-7.5-13-10.5-16-4-3 6 5 10 5 10V37z" fill="#000"/><path d="M20 8h5" stroke-linejoin="miter"/><path d="M32 29.5s8.5-4 6.03-9.65C34.15 14 25 18 22.5 24.5l.01 2.1-.01-2.1C20 18 9.906 14 6.997 19.85c-2.497 5.65 4.853 9 4.853 9M11.5 30c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0" stroke="#fff"/></g>""",
-    # noqa: E501
-    "n": """<g id="black-knight" class="black knight" fill="none" fill-rule="evenodd" stroke="#fff" stroke-width="1.0" stroke-linecap="round" stroke-linejoin="round"><path d="M 22,10 C 32.5,11 38.5,18 38,39 L 15,39 C 15,30 25,32.5 23,18" style="fill:#000000; stroke:#000000;"/><path d="M 24,18 C 24.38,20.91 18.45,25.37 16,27 C 13,29 13.18,31.34 11,31 C 9.958,30.06 12.41,27.96 11,28 C 10,28 11.19,29.23 10,30 C 9,30 5.997,31 6,26 C 6,24 12,14 12,14 C 12,14 13.89,12.1 14,10.5 C 13.27,9.506 13.5,8.5 13.5,7.5 C 14.5,6.5 16.5,10 16.5,10 L 18.5,10 C 18.5,10 19.28,8.008 21,7 C 22,7 22,10 22,10" style="fill:#000000; stroke:#000000;"/><path d="M 9.5 25.5 A 0.5 0.5 0 1 1 8.5,25.5 A 0.5 0.5 0 1 1 9.5 25.5 z" style="fill:#ececec; stroke:#ececec;"/><path d="M 15 15.5 A 0.5 1.5 0 1 1 14,15.5 A 0.5 1.5 0 1 1 15 15.5 z" transform="matrix(0.866,0.5,-0.5,0.866,9.693,-5.173)" style="fill:#ececec; stroke:#ececec;"/><path d="M 24.55,10.4 L 24.1,11.85 L 24.6,12 C 27.75,13 30.25,14.49 32.5,18.75 C 34.75,23.01 35.75,29.06 35.25,39 L 35.2,39.5 L 37.45,39.5 L 37.5,39 C 38,28.94 36.62,22.15 34.25,17.66 C 31.88,13.17 28.46,11.02 25.06,10.5 L 24.55,10.4 z " style="fill:#ececec; stroke:none;"/></g>""",
-    # noqa: E501
-    "p": """<g id="black-pawn" class="black pawn"><path d="M22 9c-2.21 0-4 1.79-4 4 0 .89.29 1.71.78 2.38-1.95 1.12-3.28 3.21-3.28 5.62 0 2.03.94 3.84 2.41 5.03-3 1.06-7.41 5.55-7.41 13.47h23c0-7.92-4.41-12.41-7.41-13.47 1.47-1.19 2.41-3 2.41-5.03 0-2.41-1.33-4.5-3.28-5.62.49-.67.78-1.49.78-2.38 0-2.21-1.79-4-4-4z" stroke="#fff" stroke-width="1.0" stroke-linecap="round"/></g>""",
-    # noqa: E501
-    "q": """<g id="black-queen" class="black queen" fill="#000" fill-rule="evenodd" stroke="#000" stroke-width="1.0" stroke-linecap="round" stroke-linejoin="round"><g fill="#000" stroke="none"><circle cx="6" cy="12" r="2.75"/><circle cx="14" cy="9" r="2.75"/><circle cx="22.5" cy="8" r="2.75"/><circle cx="31" cy="9" r="2.75"/><circle cx="39" cy="12" r="2.75"/></g><path d="M9 26c8.5-1.5 21-1.5 27 0l2.5-12.5L31 25l-.3-14.1-5.2 13.6-3-14.5-3 14.5-5.2-13.6L14 25 6.5 13.5 9 26zM9 26c0 2 1.5 2 2.5 4 1 1.5 1 1 .5 3.5-1.5 1-1.5 2.5-1.5 2.5-1.5 1.5.5 2.5.5 2.5 6.5 1 16.5 1 23 0 0 0 1.5-1 0-2.5 0 0 .5-1.5-1-2.5-.5-2.5-.5-2 .5-3.5 1-2 2.5-2 2.5-4-8.5-1.5-18.5-1.5-27 0z" stroke-linecap="butt"/><path d="M11 38.5a35 35 1 0 0 23 0" fill="none" stroke-linecap="butt"/><path d="M11 29a35 35 1 0 1 23 0M12.5 31.5h20M11.5 34.5a35 35 1 0 0 22 0M10.5 37.5a35 35 1 0 0 24 0" fill="none" stroke="#fff"/></g>""",
-    # noqa: E501
-    "r": """<g id="black-rook" class="black rook" fill="#000" fill-rule="evenodd" stroke="#fff" stroke-width="0.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9 39h27v-3H9v3zM12.5 32l1.5-2.5h17l1.5 2.5h-20zM12 36v-4h21v4H12z" stroke-linecap="butt"/><path d="M14 29.5v-13h17v13H14z" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M14 16.5L11 14h23l-3 2.5H14zM11 14V9h4v2h5V9h5v2h5V9h4v5H11z" stroke-linecap="butt"/><path d="M12 35.5h21M13 31.5h19M14 29.5h17M14 16.5h17M11 14h23" fill="none" stroke="#fff" stroke-width="1" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "B": """<g id="white-bishop" class="white bishop" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><g fill="#fff" stroke-linecap="butt"><path d="M9 36c3.39-.97 10.11.43 13.5-2 3.39 2.43 10.11 1.03 13.5 2 0 0 1.65.54 3 2-.68.97-1.65.99-3 .5-3.39-.97-10.11.46-13.5-1-3.39 1.46-10.11.03-13.5 1-1.354.49-2.323.47-3-.5 1.354-1.94 3-2 3-2zM15 32c2.5 2.5 12.5 2.5 15 0 .5-1.5 0-2 0-2 0-2.5-2.5-4-2.5-4 5.5-1.5 6-11.5-5-15.5-11 4-10.5 14-5 15.5 0 0-2.5 1.5-2.5 4 0 0-.5.5 0 2zM25 8a2.5 2.5 0 1 1-5 0 2.5 2.5 0 1 1 5 0z"/></g><path d="M17.5 26h10M15 30h15m-7.5-14.5v5M20 18h5" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-    "K": """<g id="white-king" class="white king" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M22.5 11.63V6M20 8h5" stroke-linejoin="miter"/><path d="M22.5 25s4.5-7.5 3-10.5c0 0-1-2.5-3-2.5s-3 2.5-3 2.5c-1.5 3 3 10.5 3 10.5" fill="#fff" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M11.5 37c5.5 3.5 15.5 3.5 21 0v-7s9-4.5 6-10.5c-4-6.5-13.5-3.5-16 4V27v-3.5c-3.5-7.5-13-10.5-16-4-3 6 5 10 5 10V37z" fill="#fff"/><path d="M11.5 30c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0m-21 3.5c5.5-3 15.5-3 21 0"/></g>""",
-    # noqa: E501
-    "N": """<g id="white-knight" class="white knight" fill="none" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M 22,10 C 32.5,11 38.5,18 38,39 L 15,39 C 15,30 25,32.5 23,18" style="fill:#ffffff; stroke:#000000;"/><path d="M 24,18 C 24.38,20.91 18.45,25.37 16,27 C 13,29 13.18,31.34 11,31 C 9.958,30.06 12.41,27.96 11,28 C 10,28 11.19,29.23 10,30 C 9,30 5.997,31 6,26 C 6,24 12,14 12,14 C 12,14 13.89,12.1 14,10.5 C 13.27,9.506 13.5,8.5 13.5,7.5 C 14.5,6.5 16.5,10 16.5,10 L 18.5,10 C 18.5,10 19.28,8.008 21,7 C 22,7 22,10 22,10" style="fill:#ffffff; stroke:#000000;"/><path d="M 9.5 25.5 A 0.5 0.5 0 1 1 8.5,25.5 A 0.5 0.5 0 1 1 9.5 25.5 z" style="fill:#000000; stroke:#000000;"/><path d="M 15 15.5 A 0.5 1.5 0 1 1 14,15.5 A 0.5 1.5 0 1 1 15 15.5 z" transform="matrix(0.866,0.5,-0.5,0.866,9.693,-5.173)" style="fill:#000000; stroke:#000000;"/></g>""",
-    # noqa: E501
-    "P": """<g id="white-pawn" class="white pawn"><path d="M22 9c-2.21 0-4 1.79-4 4 0 .89.29 1.71.78 2.38-1.95 1.12-3.28 3.21-3.28 5.62 0 2.03.94 3.84 2.41 5.03-3 1.06-7.41 5.55-7.41 13.47h23c0-7.92-4.41-12.41-7.41-13.47 1.47-1.19 2.41-3 2.41-5.03 0-2.41-1.33-4.5-3.28-5.62.49-.67.78-1.49.78-2.38 0-2.21-1.79-4-4-4z" fill="#fff" stroke="#000" stroke-width="1.5" stroke-linecap="round"/></g>""",
-    # noqa: E501
-    "Q": """<g id="white-queen" class="white queen" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M8 12a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM24.5 7.5a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM41 12a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM16 8.5a2 2 0 1 1-4 0 2 2 0 1 1 4 0zM33 9a2 2 0 1 1-4 0 2 2 0 1 1 4 0z"/><path d="M9 26c8.5-1.5 21-1.5 27 0l2-12-7 11V11l-5.5 13.5-3-15-3 15-5.5-14V25L7 14l2 12zM9 26c0 2 1.5 2 2.5 4 1 1.5 1 1 .5 3.5-1.5 1-1.5 2.5-1.5 2.5-1.5 1.5.5 2.5.5 2.5 6.5 1 16.5 1 23 0 0 0 1.5-1 0-2.5 0 0 .5-1.5-1-2.5-.5-2.5-.5-2 .5-3.5 1-2 2.5-2 2.5-4-8.5-1.5-18.5-1.5-27 0z" stroke-linecap="butt"/><path d="M11.5 30c3.5-1 18.5-1 22 0M12 33.5c6-1 15-1 21 0" fill="none"/></g>""",
-    # noqa: E501
-    "R": """<g id="white-rook" class="white rook" fill="#fff" fill-rule="evenodd" stroke="#000" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9 39h27v-3H9v3zM12 36v-4h21v4H12zM11 14V9h4v2h5V9h5v2h5V9h4v5" stroke-linecap="butt"/><path d="M34 14l-3 3H14l-3-3"/><path d="M31 17v12.5H14V17" stroke-linecap="butt" stroke-linejoin="miter"/><path d="M31 29.5l1.5 2.5h-20l1.5-2.5"/><path d="M11 14h23" fill="none" stroke-linejoin="miter"/></g>""",
-    # noqa: E501
-}
-
-XX = """<g id="xx"><path d="M35.865 9.135a1.89 1.89 0 0 1 0 2.673L25.173 22.5l10.692 10.692a1.89 1.89 0 0 1 0 2.673 1.89 1.89 0 0 1-2.673 0L22.5 25.173 11.808 35.865a1.89 1.89 0 0 1-2.673 0 1.89 1.89 0 0 1 0-2.673L19.827 22.5 9.135 11.808a1.89 1.89 0 0 1 0-2.673 1.89 1.89 0 0 1 2.673 0L22.5 19.827 33.192 9.135a1.89 1.89 0 0 1 2.673 0z" fill="#000" stroke="#fff" stroke-width="1.688"/></g>"""  # noqa: E501
-
-CHECK_GRADIENT = """<radialGradient id="check_gradient"><stop offset="0%" stop-color="#ff0000" stop-opacity="1.0" /><stop offset="50%" stop-color="#e70000" stop-opacity="1.0" /><stop offset="100%" stop-color="#9e0000" stop-opacity="0.0" /></radialGradient>"""  # noqa: E501
-
-DEFAULT_COLORS = {
-    "square light": "#ffce9e",
-    "square dark": "#d18b47",
-    "square dark lastmove": "#aaa23b",
-    "square light lastmove": "#cdd16a",
-}
-
-class Arrow:
-    """Details of an arrow to be drawn."""
-
-    def __init__(self, tail: chess.Square, head: chess.Square, *, color: str = "#888", annotation: str = '') -> None:
-        self.tail = tail
-        self.head = head
-        self.color = color
-        self.annotation = annotation
-
-
-class SvgWrapper(str):
-    def _repr_svg_(self) -> "SvgWrapper":
-        return self
-
-
-def _svg(viewbox: int, size: Optional[int]) -> ET.Element:
-    svg = ET.Element("svg", {
-        "xmlns": "http://www.w3.org/2000/svg",
-        "version": "1.1",
-        "xmlns:xlink": "http://www.w3.org/1999/xlink",
-        "viewBox": f"0 0 {viewbox:d} {viewbox:d}",
-    })
-
-    if size is not None:
-        svg.set("width", str(size))
-        svg.set("height", str(size))
-
-    return svg
-
-
-def _text(content: str, x: int, y: int, width: int, height: int) -> ET.Element:
-    t = ET.Element("text", {
-        "x": str(x + width // 2),
-        "y": str(y + height // 2),
-        "font-size": str(max(1, int(min(width, height) * 0.7))),
-        "text-anchor": "middle",
-        "alignment-baseline": "middle",
-    })
-    t.text = content
-    return t
-
-
-def piece(piece: chess.Piece, size: Optional[int] = None) -> str:
-    """
-    Renders the given :class:`chess.Piece` as an SVG image.
-    >>> import chess
-    >>> import chess.svg
-    >>>
-    >>> chess.svg.piece(chess.Piece.from_symbol("R"))  # doctest: +SKIP
-    .. image:: ../docs/wR.svg
-    """
-    svg = _svg(SQUARE_SIZE, size)
-    svg.append(ET.fromstring(PIECES[piece.symbol()]))
-    return SvgWrapper(ET.tostring(svg).decode("utf-8"))
-
-
-def board(board: Optional[chess.BaseBoard] = None, *,
-          squares: Optional[chess.IntoSquareSet] = None,
-          flipped: bool = False,
-          coordinates: bool = True,
-          lastmove: Optional[chess.Move] = None,
-          check: Optional[chess.Square] = None,
-          arrows: Iterable[Union[Arrow, Tuple[chess.Square, chess.Square]]] = (),
-          size: Optional[int] = None,
-          style: Optional[str] = None,
-          square_colors: Iterable[str] = (), #TODO: remove as it is not needed anymore
-          only_pieces: bool = False) -> str:
-    """
-    Renders a board with pieces and/or selected squares as an SVG image.
-    :param board: A :class:`chess.BaseBoard` for a chessboard with pieces or
-        ``None`` (the default) for a chessboard without pieces.
-    :param squares: A :class:`chess.SquareSet` with selected squares.
-    :param flipped: Pass ``True`` to flip the board.
-    :param coordinates: Pass ``False`` to disable coordinates in the margin.
-    :param lastmove: A :class:`chess.Move` to be highlighted.
-    :param check: A square to be marked as check.
-    :param arrows: A list of :class:`~chess.svg.Arrow` objects like
-        ``[chess.svg.Arrow(chess.E2, chess.E4)]`` or a list of tuples like
-        ``[(chess.E2, chess.E4)]``. An arrow from a square pointing to the same
-        square is drawn as a circle, like ``[(chess.E2, chess.E2)]``.
-    :param size: The size of the image in pixels (e.g., ``400`` for a 400 by
-        400 board) or ``None`` (the default) for no size limit.
-    :param style: A CSS stylesheet to include in the SVG image.
-    >>> import chess
-    >>> import chess.svg
-    >>>
-    >>> board = chess.Board("8/8/8/8/4N3/8/8/8 w - - 0 1")
-    >>> squares = board.attacks(chess.E4)
-    >>> chess.svg.board(board=board, squares=squares)  # doctest: +SKIP
-    .. image:: ../docs/Ne4.svg
-    """
-    margin = MARGIN if coordinates else 0
-    svg = _svg(8 * SQUARE_SIZE + 2 * margin, size)
-
-    if style:
-        ET.SubElement(svg, "style").text = style
-
-    defs = ET.SubElement(svg, "defs")
-    if board:
-        for piece_color in chess.COLORS:
-            for piece_type in chess.PIECE_TYPES:
-                if board.pieces_mask(piece_type, piece_color):
-                    defs.append(ET.fromstring(PIECES[chess.Piece(piece_type, piece_color).symbol()]))
-
-    squares = chess.SquareSet(squares) if squares else chess.SquareSet()
-    if squares:
-        defs.append(ET.fromstring(XX))
-
-    if check is not None and not only_pieces:
-        defs.append(ET.fromstring(CHECK_GRADIENT))
-
-    for square, bb in enumerate(chess.BB_SQUARES):
-        file_index = chess.square_file(square)
-        rank_index = chess.square_rank(square)
-
-        x = (file_index if not flipped else 7 - file_index) * SQUARE_SIZE + margin
-        y = (7 - rank_index if not flipped else rank_index) * SQUARE_SIZE + margin
-
-        cls = ["square", "light" if chess.BB_LIGHT_SQUARES & bb else "dark"]
-        if lastmove and square in [lastmove.from_square, lastmove.to_square]:
-            cls.append("lastmove")
-        if square_colors == ():
-            fill_color = DEFAULT_COLORS[" ".join(cls)]
-        else:
-            fill_color = square_colors[square]
-
-        cls.append(chess.SQUARE_NAMES[square])
-        if not only_pieces:
-            ET.SubElement(svg, "rect", {
-                "x": str(x),
-                "y": str(y),
-                "width": str(SQUARE_SIZE),
-                "height": str(SQUARE_SIZE),
-                "class": " ".join(cls),
-                "stroke": "none",
-                "fill": fill_color,
-            })
-
-            if square == check:
-                ET.SubElement(svg, "rect", {
-                    "x": str(x),
-                    "y": str(y),
-                    "width": str(SQUARE_SIZE),
-                    "height": str(SQUARE_SIZE),
-                    "class": "check",
-                    "fill": "url(#check_gradient)",
-                })
-
-        # Render pieces.
-        if board is not None:
-            piece = board.piece_at(square)
-            if piece:
-                ET.SubElement(svg, "use", {
-                    "xlink:href": f"#{chess.COLOR_NAMES[piece.color]}-{chess.PIECE_NAMES[piece.piece_type]}",
-                    "transform": f"translate({x:d}, {y:d})",
-                })
-
-        # Render selected squares.
-        if squares is not None and square in squares:
-            #ET.SubElement(svg, "use", {
-            #    "xlink:href": "#xx",
-            #    "x": str(x),
-            #    "y": str(y),
-            #})
-            ET.SubElement(svg, "rect", {
-                "x": str(x),
-                "y": str(y),
-                "width": str(SQUARE_SIZE),
-                "height": str(SQUARE_SIZE),
-                "class": "check",
-                "fill": "none",
-                "stroke": "#FF0000",
-                "stroke-width": "5.0",
-                "rx": "2.5",
-                "opacity": "0.60"
-            })
-
-    if coordinates:
-        for file_index, file_name in enumerate(chess.FILE_NAMES):
-            x = (file_index if not flipped else 7 - file_index) * SQUARE_SIZE + margin
-            svg.append(_text(file_name, x, 0, SQUARE_SIZE, margin))
-            svg.append(_text(file_name, x, margin + 8 * SQUARE_SIZE, SQUARE_SIZE, margin))
-        for rank_index, rank_name in enumerate(chess.RANK_NAMES):
-            y = (7 - rank_index if not flipped else rank_index) * SQUARE_SIZE + margin
-            svg.append(_text(rank_name, 0, y, margin, SQUARE_SIZE))
-            svg.append(_text(rank_name, margin + 8 * SQUARE_SIZE, y, margin, SQUARE_SIZE))
-
-    for arrow in arrows:
-        try:
-            tail, head, color, annotation = arrow.tail, arrow.head, arrow.color, arrow.annotation  # type: ignore
-        except AttributeError:
-            tail, head = arrow  # type: ignore
-            color = "#888"
-            annotation = ''
-
-        tail_file = chess.square_file(tail)
-        tail_rank = chess.square_rank(tail)
-        head_file = chess.square_file(head)
-        head_rank = chess.square_rank(head)
-
-        xtail = margin + (tail_file + 0.5 if not flipped else 7.5 - tail_file) * SQUARE_SIZE
-        ytail = margin + (7.5 - tail_rank if not flipped else tail_rank + 0.5) * SQUARE_SIZE
-        xhead = margin + (head_file + 0.5 if not flipped else 7.5 - head_file) * SQUARE_SIZE
-        yhead = margin + (7.5 - head_rank if not flipped else head_rank + 0.5) * SQUARE_SIZE
-
-        if (head_file, head_rank) == (tail_file, tail_rank):
-            ET.SubElement(svg, "circle", {
-                "cx": str(xhead),
-                "cy": str(yhead),
-                "r": str(SQUARE_SIZE * 0.9 / 2),
-                "stroke-width": str(SQUARE_SIZE * 0.1),
-                "stroke": color,
-                "fill": "none",
-                "opacity": "0.5",
-                "class": "circle",
-            })
-        else:
-            # marker_size = 0.75 * SQUARE_SIZE
-            # marker_margin = 0.1 * SQUARE_SIZE
-            marker_size = 0.5 * SQUARE_SIZE
-            marker_margin = 0.05 * SQUARE_SIZE
-
-            dx, dy = xhead - xtail, yhead - ytail
-            hypot = math.hypot(dx, dy)
-
-            shaft_x = xhead - dx * (marker_size + marker_margin) / hypot
-            shaft_y = yhead - dy * (marker_size + marker_margin) / hypot
-
-            xtip = xhead - dx * marker_margin / hypot
-            ytip = yhead - dy * marker_margin / hypot
-
-            x_annot = xtail + (shaft_x - xtail) / 2
-            y_annot = ytail + (shaft_y - ytail) / 2
-
-            x_annot = xhead - dx * 0.74 * SQUARE_SIZE / hypot  # - (xtip - xtail)*(SQUARE_SIZE/2)
-            y_annot = yhead - dy * 0.74 * SQUARE_SIZE / hypot  # - (ytip - ytail)*(SQUARE_SIZE/2)
-
-            ET.SubElement(svg, "line", {
-                "x1": str(xtail),
-                "y1": str(ytail),
-                "x2": str(shaft_x),
-                "y2": str(shaft_y),
-                "stroke": color,
-                "stroke-width": str(SQUARE_SIZE * 0.15),
-                "opacity": "0.5",
-                "stroke-linecap": "butt",
-                "class": "arrow",
-            })
-
-            marker = [(xtip, ytip),
-                      (shaft_x + dy * 0.5 * marker_size / hypot,
-                       shaft_y - dx * 0.5 * marker_size / hypot),
-                      (shaft_x - dy * 0.5 * marker_size / hypot,
-                       shaft_y + dx * 0.5 * marker_size / hypot)]
-
-            ET.SubElement(svg, "polygon", {
-                "points": " ".join(str(x) + "," + str(y) for x, y in marker),
-                "fill": color,
-                "opacity": "0.5",
-                "class": "arrow",
-            })
-
-    for arrow in arrows:
-        try:
-            tail, head, color, annotation = arrow.tail, arrow.head, arrow.color, arrow.annotation  # type: ignore
-        except AttributeError:
-            tail, head = arrow  # type: ignore
-            color = "#888"
-            annotation = ''
-
-        tail_file = chess.square_file(tail)
-        tail_rank = chess.square_rank(tail)
-        head_file = chess.square_file(head)
-        head_rank = chess.square_rank(head)
-
-        xtail = margin + (tail_file + 0.5 if not flipped else 7.5 - tail_file) * SQUARE_SIZE
-        ytail = margin + (7.5 - tail_rank if not flipped else tail_rank + 0.5) * SQUARE_SIZE
-        xhead = margin + (head_file + 0.5 if not flipped else 7.5 - head_file) * SQUARE_SIZE
-        yhead = margin + (7.5 - head_rank if not flipped else head_rank + 0.5) * SQUARE_SIZE
-
-        marker_size = 0.5 * SQUARE_SIZE
-        marker_margin = 0.05 * SQUARE_SIZE
-
-        dx, dy = xhead - xtail, yhead - ytail
-        hypot = math.hypot(dx, dy)
-
-        shaft_x = xhead - dx * (marker_size + marker_margin) / hypot
-        shaft_y = yhead - dy * (marker_size + marker_margin) / hypot
-
-        xtip = xhead - dx * marker_margin / hypot
-        ytip = yhead - dy * marker_margin / hypot
-
-        x_annot = xhead - dx * 0.74 * SQUARE_SIZE / hypot
-        y_annot = yhead - dy * 0.74 * SQUARE_SIZE / hypot
-
-        if annotation != '':
-            ET.SubElement(svg, "circle", {
-                "cx": str(x_annot),
-                "cy": str(y_annot),
-                "r": str(SQUARE_SIZE * 0.175),
-                #"r": str(SQUARE_SIZE * 0.2),
-                "stroke-width": str(SQUARE_SIZE * 0.01),
-                "stroke": '#000000',
-                "fill": color,
-                "opacity": "1.0",
-                "class": "circle",
-            })
-            #style = get_style("'BundledDejavuSans'", str(SQUARE_SIZE * 0.1))
-            annot = ET.SubElement(svg, "text", {
-                "x": str(x_annot),
-                "y": str(y_annot),
-                "font-size": str(SQUARE_SIZE * 0.2),  # max(1, int(min(SQUARE_SIZE, SQUARE_SIZE) * 0.3))),
-                "text-anchor": "middle",
-                "dominant-baseline": "middle"
-                #"alignment-baseline": "middle"
-            })
-            annot.text = annotation
-
-    return SvgWrapper(ET.tostring(svg).decode("utf-8"))

our_visualization/svg_pieces.py

@@ -1,31 +0,0 @@
-from python_chess_customized_svg import piece
-import python_chess_customized_svg as svg
-import chess
-import base64
-
-#def get_svg_piece(symbol):
-#    img = piece(chess.Piece.from_symbol(symbol))
-#    svg_str = str(img)
-#    svg_byte = svg_str.encode()
-#    encoded = base64.b64encode(svg_byte)
-#    svg_piece = 'data:image/svg+xml;base64,{}'.format(encoded.decode())
-#    return svg_piece
-
-def get_svg_board(board, focused_square_ind, only_pieces):
-    if focused_square_ind is not None:
-        squares = [focused_square_ind]
-    else:
-        squares = []
-    if board.move_stack:
-        print('board stack YES')
-        lastmove = board.peek()
-    else:
-        print('board stack NO')
-        lastmove = None
-    svg_str = str(svg.board(board, squares=squares, arrows=[], lastmove=lastmove, coordinates=False, only_pieces=only_pieces))
-    svg_byte = svg_str.encode()
-    encoded = base64.b64encode(svg_byte)
-    svg_board = 'data:image/svg+xml;base64,{}'.format(encoded.decode())
-    return svg_board
-
-#SVG_PIECES = {piece: get_svg_piece(piece) for piece in ('b', 'k', 'n', 'p', 'q', 'r', 'B', 'K', 'N', 'P', 'Q', 'R')}

our_visualization/utils.py

@@ -1,32 +0,0 @@
-from leela_board import LeelaBoard
-import chess
-import torch
-
-
-def flip_move(move):
-    from_square = chess.square_mirror(chess.parse_square(move[:2]))
-    to_square = chess.square_mirror(chess.parse_square(move[2:4]))
-    promotion = move[4:] if len(move) > 4 else ""
-    return chess.square_name(from_square) + chess.square_name(to_square) + promotion
-
-
-def flip_board(fen, moves):
-    temp_board = chess.Board(fen=fen)
-    return temp_board.mirror().fen(), [flip_move(move) for move in moves]
-
-
-# Helper functions
-class ChessBoard:
-    def __init__(self, fen):  # Create new board from fen
-        self.board = LeelaBoard(fen=fen)
-        self.t = self.__t()
-
-    def move(self, move):  # Move piece on board ("e2e3")
-        self.board.push_uci(move)
-        self.t = self.__t()
-
-    def __t(self):  # Set board tensor (private method)
-        return torch.from_numpy(self.board.lcz_features()).float()
-
-    def __str__(self):  # Prints board state
-        return str(self.board)

our_visualization/visualization_demo.py

@@ -1,230 +0,0 @@
-import marimo
-
-__generated_with = "0.8.22"
-app = marimo.App(width="medium")
-
-
-@app.cell
-def __():
-    import marimo as mo
-    return (mo,)
-
-
-@app.cell
-def __():
-    import pandas as pd 
-    df = pd.read_csv("our_visualization/datasets/test_set.csv")
-    df.head()
-    return df, pd
-
-
-@app.cell
-def __():
-    import pickle
-    from utils import ChessBoard
-    import onnxruntime as ort
-    from leela_board import _idx_to_move_bn, _idx_to_move_wn
-    import numpy as np 
-    from onnx2torch import convert
-    import onnx
-    import torch 
-    import os 
-
-    def get_models(root="/our_visualization/models"):
-        paths = os.listdir(root)
-        model_paths = []
-        for path in paths:
-            if ".onnx" in path: model_paths.append(os.path.join(root, path))
-        return model_paths
-
-    def get_activations_from_model(model_path, pattern, fen):
-        # Write hooks for selected model path
-        def register_hooks_for_capture(model, pattern):
-            activations = {}
-            def get_activation(name):
-                def hook(module, input, output):
-                    activations[name] = output.detach().numpy()
-                return hook 
-
-            handles = []
-            for n, m in model.named_modules():
-                if pattern in n:
-                    handle = m.register_forward_hook(get_activation(n))
-                    handles.append(handle)
-            return activations, handles
-
-        # Load model and register hooks for it 
-        model = convert(onnx.load(model_path))
-        act, handles = register_hooks_for_capture(model, pattern)
-
-        # Get fen and pass it through model to generate activations
-        board = ChessBoard(fen)
-        inputs = board.t
-        _, _, _ = model(inputs.unsqueeze(dim=0))
-
-        # Remove handles
-        [h.remove() for h in handles]
-        return act
-    return (
-        ChessBoard,
-        convert,
-        get_activations_from_model,
-        get_models,
-        np,
-        onnx,
-        ort,
-        os,
-        pickle,
-        torch,
-    )
-
-
-@app.cell
-def __(df, mo):
-    min_elo, max_elo = df["Rating"].min() // 100 * 100, df["Rating"].max() // 100 * 100
-    elo_list = [f"{elo}" for elo in range(min_elo, max_elo + 100, 100)]
-    dropdown_elo = mo.ui.dropdown(value = "1000", options=elo_list, label=f"Select rating in range of {min_elo} - {max_elo}")
-    dropdown_elo
-    return dropdown_elo, elo_list, max_elo, min_elo
-
-
-@app.cell
-def __(df, dropdown_elo, mo):
-    unique_themes = set()
-    df_rated = df[(df["Rating"] >= int(dropdown_elo.value)) & (df["Rating"] <= int(dropdown_elo.value) + 100)]
-    for i in range(len(df_rated)):
-        themes = df_rated.iloc[i]["Themes"].split(" ")
-        for theme in themes: unique_themes.add(theme)
-    unique_themes_list = list(unique_themes)
-    unique_themes_list.sort()
-
-    dropdown_themes = mo.ui.dropdown(value=unique_themes_list[0], options=unique_themes_list, label=f"Select puzzle theme")
-    dropdown_themes
-    return (
-        df_rated,
-        dropdown_themes,
-        i,
-        theme,
-        themes,
-        unique_themes,
-        unique_themes_list,
-    )
-
-
-@app.cell
-def __(df_rated, dropdown_themes):
-    themes_mask = []
-    def _(themes_mask):
-        for i in range(len(df_rated)):
-            themes_new = df_rated.iloc[i]["Themes"].split(" ")
-            if dropdown_themes.value in themes_new: themes_mask.append(i)
-    _(themes_mask)
-    fens = list(df_rated.iloc[themes_mask]["FEN"])
-    df_rated.iloc[themes_mask][["FEN", "Moves", "Themes", "Rating"]]
-    return fens, themes_mask
-
-
-@app.cell
-def __(fens, mo):
-    dropdown_fen = mo.ui.dropdown(value = fens[0], options=fens, label="Select FEN")
-    dropdown_fen
-    return (dropdown_fen,)
-
-
-@app.cell
-def __(df_rated, dropdown_fen, mo):
-    moves = df_rated[df_rated["FEN"] == dropdown_fen.value]["Moves"].iloc[0].split(" ")
-    player_moves = moves[1::2]
-    board_moves = []
-    def _(board_moves):
-        for i in range(len(player_moves)):
-            board_moves.append(moves[:2 * i + 1])
-    _(board_moves)
-    moves_dict = {pm: om for pm, om in zip(player_moves, board_moves)}
-    dropdown_moves = mo.ui.dropdown(options=moves_dict, value=player_moves[0], label="Select which player move to look at")
-    # print(moves)
-    dropdown_moves
-    return board_moves, dropdown_moves, moves, moves_dict, player_moves
-
-
-@app.cell
-def __(dropdown_moves, mo):
-    dropdown_layer = mo.ui.dropdown(value="0", options=[f"{i}" for i in range(15)], label="Select layer (smaller - closer to input)")
-    focus_square = mo.ui.text_area(value=dropdown_moves.selected_key[:2], placeholder="Input square to look at (e.g. a1, b8, ...")
-    mo.vstack([dropdown_layer, focus_square])
-    return dropdown_layer, focus_square
-
-
-@app.cell
-def __(ChessBoard, dropdown_fen, dropdown_moves):
-    def _():
-        board = ChessBoard(dropdown_fen.value)
-        for move in dropdown_moves.value:
-            print(move)
-            # board.move(move)
-        return board.board.pc_board.fen()
-    FEN = _()
-    return (FEN,)
-
-
-@app.cell
-def __(focus_square):
-    import chess 
-    from global_data import global_data
-
-    focus_square_ind = 8 * (int(focus_square.value[1]) - 1) + ord(focus_square.value[0]) - ord("a")
-
-    def set_plotting_parameters(act, layer_number, fen):
-        layer_key = [k for k in act.keys() if "0" in k][0].replace("0", f"{layer_number}")
-        print(act.keys())
-        global_data.model = 'test'
-        global_data.activations = act[layer_key][0, :, ::-1 , :]
-        print(global_data.activations.shape)
-        global_data.subplot_rows = 8
-        global_data.subplot_cols = 4
-        global_data.board = chess.Board(fen)
-        global_data.show_all_heads = True
-        # global_data.selected_head = 1
-        global_data.visualization_mode = 'ROW'
-        global_data.focused_square_ind = focus_square_ind
-        # global_data.heatmap_horizontal_gap = 0.001
-
-        global_data.visualization_mode_is_64x64 = False
-        global_data.colorscale_mode = "mode1"
-        global_data.show_colorscale = False
-    return chess, focus_square_ind, global_data, set_plotting_parameters
-
-
-@app.cell
-def __(
-    FEN,
-    dropdown_layer,
-    get_activations_from_model,
-    get_models,
-    set_plotting_parameters,
-):
-    # FEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    # board = ChessBoard("r1b2rk1/pp2pp1p/6p1/3Qb2q/1P4n1/2P1BN2/P2N1PPP/R4RK1 w - - 0 14")
-    # board.move("f3e5")
-    # FEN = board.board.pc_board.fen()
-    PATTERN = "mha/QK/softmax"
-    # PATTERN = "smolgen_weights"
-    MODEL = get_models()[-1]
-    ACTIVATIONS = get_activations_from_model(MODEL, PATTERN, FEN)
-    set_plotting_parameters(ACTIVATIONS, int(dropdown_layer.value), FEN)
-    from activation_heatmap import heatmap_figure
-    fig = heatmap_figure()
-    fig.update_layout(height=1500, width=1200)
-    fig
-    return ACTIVATIONS, MODEL, PATTERN, fig, heatmap_figure
-
-
-@app.cell
-def __():
-    # Add fens after opponents moves 
-    # Default squares of interest
-    return
-
-
-if __name__ == "__main__":
-    app.run()