Upload 19 files

.gitattributes

@@ -36,3 +36,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 our_visualization/assets/DejaVuSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 our_visualization/assets/DejaVuSans.ttf filter=lfs diff=lfs merge=lfs -text
 our_visualization/assets/DejavuSansMono-5m7L.ttf filter=lfs diff=lfs merge=lfs -text
+assets/DejaVuSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+assets/DejaVuSans.ttf filter=lfs diff=lfs merge=lfs -text
+assets/DejavuSansMono-5m7L.ttf filter=lfs diff=lfs merge=lfs -text

activation_heatmap.py

@@ -0,0 +1,436 @@
+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
+

assets/DejaVuSans-Bold.ttf

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

assets/DejaVuSans.ttf

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

assets/DejavuSansMono-5m7L.ttf

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

assets/custom.css

@@ -0,0 +1,59 @@
+*[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;
+}

board2planes.py

@@ -0,0 +1,97 @@
+#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
+

constants.py

@@ -0,0 +1,24 @@
+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.

global_data.py

@@ -0,0 +1,539 @@
+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')

layouts/visualization_demo.slides.json

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

leela_board.py

@@ -0,0 +1,617 @@
+# -*- 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

models/leela-large-official.onnx

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

python_chess_customized_svg.py

@@ -0,0 +1,414 @@
+# 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"))

svg_pieces.py

@@ -0,0 +1,31 @@
+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')}

utils.py

@@ -0,0 +1,32 @@
+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)

visualization_demo.py

@@ -0,0 +1,230 @@
+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="/Users/sereda/Documents/chessXAI/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()