<jupyter_start><jupyter_text>Plot figuresTo plot the final figures.This script takes in the model summary files and plots results.<jupyter_code>import numpy as np
from scipy.spatial.distance import cdist # For calculating QPSK decoding
import dill
from itertools import product, cycle

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

# import tensorflow.keras.backend as K<jupyter_output><empty_output><jupyter_text>Utility function to extract data from figures -- work in progress<jupyter_code># The one who steals the data
def robinhood(fig, filename, col_dtype=[float, float], col_fmt=None):
    assert (len(fig.axes) < 2), "More than one axis not supported"
    ax = fig.axes[0]
    
    header = []
    fmt = []
    
    # Don't modify the argument here, it will get updated for all the following calls
    if not col_fmt:
        _col_fmt = [ "%d" if d == int else "%.5f" for d in col_dtype ]
    else:
        _col_fmt = col_fmt.copy()
    
    n_lines = len(ax.lines)
    x_data = ax.lines[0].get_xdata()
    
    data = np.zeros((x_data.shape[0], 2 * n_lines))
    
    for(i, line) in enumerate(ax.lines):
        data[:, 2*i] = line.get_xdata()
        data[:, 2*i+1] = line.get_ydata()
        
        header += ["x_" + line.get_label(), "y_" + line.get_label()]
        fmt += _col_fmt
            
    if filename is not None:
        with open(filename, 'w') as f:
            f.write(",".join(header) + "\n")
            np.savetxt(f, data, delimiter=",", fmt=",".join(fmt))<jupyter_output><empty_output><jupyter_text>Configuration of experiment<jupyter_code>blkSize     = 8
chDim       = 4

# Input
inVecDim   = 2 ** blkSize  # 1-hot vector length for block
encDim = 2*chDim

SNR_range_dB = np.arange( 0.0, 40.1, 2.0 )

one_hot_code = np.eye(inVecDim)<jupyter_output><empty_output><jupyter_text>Traditional MethodsLoad the constellation data from prespecified files and find BLER.<jupyter_code>results_traditional = {}
def rbf_channel(txBlk, n0):
    N, dim = txBlk.shape
    
    p1 = txBlk[:,:]
    p2 = np.hstack((-txBlk[:,dim//2:],txBlk[:,:dim//2]))
    
    h1 = np.sqrt(1.0/encDim) * np.random.randn(N)
    h2 = np.sqrt(1.0/encDim) * np.random.randn(N)
    
    outBlk = h1[:,None]*p1 + h2[:,None]*p2 + np.random.normal(scale=np.sqrt(n0), size=txBlk.shape)
    
    return outBlk, h1, h2
def rbf_channel_nonoise(txBlk):
    N, dim = txBlk.shape
    
    p1 = txBlk[:,:]
    p2 = np.hstack((-txBlk[:,dim//2:],txBlk[:,:dim//2]))
    
    h1 = np.sqrt(1.0/encDim) * np.random.randn(N)
    h2 = np.sqrt(1.0/encDim) * np.random.randn(N)
    
    outBlk = h1[:,None]*p1 + h2[:,None]*p2
    
    return outBlk, h1, h2
def add_pilot(txBlk, pilotSym):
#     pilotSym = [+1.0, +1.0]
    blkWithPilot = np.insert(txBlk, [0,chDim], values=pilotSym, axis=1)
    
    return blkWithPilot
def equalizer(rxBlk, pilotSym):
#     pilotSym = [+1.0, +1.0]
    
    N, dim = rxBlk.shape
#     print("eq>> rxBlk =", rxBlk)
    
    p1 = rxBlk[:,:]
    p2 = np.hstack((-rxBlk[:,dim//2:],rxBlk[:,:dim//2]))
    
    rxPilots = rxBlk[:,[0,1+chDim]]
    
    h1_hat = (pilotSym[1]*rxPilots[:,1]+pilotSym[0]*rxPilots[:,0])/(pilotSym[1]**2+pilotSym[0]**2)
    h2_hat = (pilotSym[0]*rxPilots[:,1]-pilotSym[1]*rxPilots[:,0])/(pilotSym[1]**2+pilotSym[0]**2)
    
#     print( "eq>> h1_hat:", h1_hat)
#     print( "eq>> h2_hat:", h2_hat)
    
    
    z1_hat = rxBlk[:,:dim//2]
    z2_hat = rxBlk[:,dim//2:]
    
#     print("eq>> z1_hat =", z1_hat)
#     print("eq>> z2_hat =", z2_hat)
    
    
#     print(h1_hat.shape, h2_hat.shape, z1_hat.shape, z2_hat.shape)
    
    zR = (h1_hat[:,None]*z1_hat+h2_hat[:,None]*z2_hat) / (h1_hat[:,None]**2+h2_hat[:,None]**2)
    zI = (h1_hat[:,None]*z2_hat-h2_hat[:,None]*z1_hat) / (h1_hat[:,None]**2+h2_hat[:,None]**2)
    
#     print("eq>>zR =", zR)
#     print("eq>>zI =", zI)
    
    outBlk = np.hstack((zR[:,1:],zI[:,1:]))
    
    return outBlk, h1_hat, h2_hat
qam_map = np.genfromtxt("./../AWGN/sphere_data/{:03d}x{:03d}_qam.csv".format(inVecDim,encDim))
qam_sym_pow = np.mean(np.sum(qam_map*qam_map,axis=1))
print( "QAM Avg. Tx Power:", qam_sym_pow )

qam_d_min = np.unique(cdist(qam_map,qam_map))[1]
print("d_min:", qam_d_min )

qam_en = qam_sym_pow / (qam_d_min**2)
print("En:", qam_en)

# calculate the pilot symbol
qam_pilotSym = np.sqrt(qam_sym_pow/encDim) * np.ones(2)

noisePower = qam_sym_pow * 10.0**(-SNR_range_dB/10.0)
n0_per_comp = noisePower/(2*chDim+2)
err = []
for n0 in n0_per_comp:
  thisErr = 0
  thisCount = 0

  while thisErr < 500 and thisCount < 5000000:
    txSym = np.random.randint(inVecDim, size=1000)
    symBlk = qam_map[txSym]
    txTest = add_pilot(symBlk, qam_pilotSym)
    rxTest, _, _ = rbf_channel(txTest, n0)
    rxEqualized, _, _ = equalizer(rxTest, qam_pilotSym)
    rxDecode = cdist(rxEqualized, qam_map)
    rxSym = np.argmin(rxDecode,axis=1)
    thisErr += np.sum(rxSym!=txSym)
    thisCount += 1000
  err.append(thisErr/thisCount)

results_traditional["QAM"] = {
    "en": qam_en,
    "dmin": qam_d_min,
    "sym_pow": qam_sym_pow,
    "bler": np.array(err)
}
agrell_map = np.genfromtxt("./../AWGN/sphere_data/{:03d}x{:03d}_agrell.csv".format(inVecDim,encDim))
agrell_sym_pow = np.mean(np.sum(agrell_map*agrell_map,axis=1))
print( "QAM Avg. Tx Power:", agrell_sym_pow )

noisePower = agrell_sym_pow * 10.0**(-SNR_range_dB/10.0)
n0_per_comp = noisePower/(2*chDim)

agrell_d_min = np.unique(cdist(agrell_map,agrell_map))[1]
print("d_min:", agrell_d_min )

agrell_en = agrell_sym_pow / (agrell_d_min**2)
print("En:", agrell_en)

agrell_map = np.sqrt(blkSize/agrell_sym_pow) * agrell_map
# agrell_map = np.sqrt(1.0/agrell_sym_pow) * agrell_map
agrell_sym_pow = np.mean(np.sum(agrell_map*agrell_map,axis=1))
print( "Normalized Agrell Avg. Tx Power:", agrell_sym_pow )

# calculate the pilot symbol
agrell_pilotSym = np.sqrt(agrell_sym_pow/encDim) * np.ones(2)
# agrell_pilotSym = 10.0*np.ones(2)

noisePower = agrell_sym_pow * 10.0**(-SNR_range_dB/10.0)
n0_per_comp = noisePower/(2*chDim+2)
# print("Agrell n0 =", n0_per_comp)
err = []
for n0 in n0_per_comp:
  thisErr = 0
  thisCount = 0
  while thisErr < 500 and thisCount < 5000000:
    txSym = np.random.randint(inVecDim, size=1000)
    symBlk = agrell_map[txSym]
    txTest = add_pilot(symBlk, agrell_pilotSym)
    rxTest, _, _ = rbf_channel(txTest, n0)
    rxEqualized, _, _ = equalizer(rxTest, agrell_pilotSym)
    rxDecode = cdist(rxEqualized, agrell_map)
    rxSym = np.argmin(rxDecode,axis=1)
    thisErr += np.sum(rxSym!=txSym)
    thisCount += 1000
  err.append(thisErr/thisCount)

results_traditional["Agrell"] = {
    "en": agrell_en,
    "d_min": agrell_d_min,
    "sym_pow": agrell_sym_pow,
    "bler": np.array(err)
}<jupyter_output><empty_output><jupyter_text>Deep Learning modelsPaths to each model summaries along with the label for legend<jupyter_code>model_summary = {}
results = {}

if blkSize==8 and chDim==4:
    model_summary = { 
        "ae": "./models/08x04/Oshea/rbf_oshea_64_32_16_10dB_summary.dil",
        "vae_awgn": "./models/08x04/AWGN/rbf_awgn_64_32_16_n080_summary.dil",
        "vae_rbf": "./models/08x04/RBF/rbf_rbf_64_32_16_n080_summary.dil",
#         "vae_awgn2": "./models/08x04/AWGN_2/rbf_awgn_64_32_16_n080_summary.dil",
#         "vae_rbf2": "./models/08x04/RBF_2/rbf_rbf_64_32_16_n080_summary.dil"
    }
elif blkSize==4 and chDim==2:
    model_summary = {
        "ae": "./models/04x02/Oshea/rbf_oshea_64_32_16_10dB_summary.dil",
        "vae_awgn": "./models/04x02/AWGN/rbf_awgn_64_32_16_n040_summary.dil",
        "vae_rbf": "./models/04x02/RBF/rbf_rbf_64_32_16_n040_summary.dil"
        
    }
elif blkSize==2 and chDim==1:
    model_summary = {
        "ae": "./models/02x01/Oshea/rbf_oshea_64_32_16_10dB_summary.dil",
        "vae_awgn": "./models/02x01/AWGN/rbf_awgn_64_32_16_n020_summary.dil",
        "vae_rbf": "./models/02x01/RBF/rbf_rbf_64_32_16_n020_summary.dil"
    }
else:
    raise NotImplementedError("Not implemented (blkSize={},chDim={})".format(blkSize,chDim))
import os.path
for (model_exp, summary_file) in model_summary.items():
    log_msg = "{:40s}    {:70s}".format(model_exp,summary_file)
    if os.path.isfile(summary_file):
        log_msg += "EXISTS"
    else:
        log_msg += "NOT FOUND"
    print(log_msg)<jupyter_output>ae                                          ./models/08x04/Oshea/rbf_oshea_64_32_16_10dB_summary.dil              EXISTS
vae_awgn                                    ./models/08x04/AWGN/rbf_awgn_64_32_16_n080_summary.dil                EXISTS
vae_rbf                                     ./models/08x04/RBF/rbf_rbf_64_32_16_n080_summary.dil                  EXISTS<jupyter_text>Load the results from summary files<jupyter_code>results = {}
for (label, summary_file) in model_summary.items():
    with open(summary_file, "rb") as file:
        results[label] = dill.load(file)<jupyter_output><empty_output><jupyter_text>Plot evolution of packing densities<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(8*1.5, 6*1.5))
data = {}

for (label, result_dict) in results.items():
    epochs = result_dict[list(result_dict.keys())[0]]["packing_density_epochs"]
    d = []
    clr = next(colors)
    for (modelid, log) in result_dict.items():
#         plt.semilogy(log["packing_density_epochs"],
#                  log["packing_density_en"], color=clr, alpha=0.1)
        d.append(log["packing_density_en"])
    d_mean = np.mean(d, axis=0)
    d_std = np.std(d, axis=0)
    plt.fill_between(result_dict[list(result_dict.keys())[0]]["packing_density_epochs"],
                    d_mean+d_std, d_mean-d_std, alpha=0.20)
    plt.plot(result_dict[list(result_dict.keys())[0]]["packing_density_epochs"],
                 d_mean, color=clr, alpha=0.9, label=label)
    
    # hack for robinhood to pickup shaded area
    plt.plot(result_dict[list(result_dict.keys())[0]]["packing_density_epochs"],
             d_mean + d_std, color=clr, alpha=0.00, label= label + "_upper")
    plt.plot(result_dict[list(result_dict.keys())[0]]["packing_density_epochs"],
             d_mean - d_std, color=clr, alpha=0.00, label= label + "_lower")
    
plt.plot(epochs, len(epochs)*[results_traditional["QAM"]["en"]], linewidth=3, label="QAM", color=next(colors), linestyle="-.")
plt.plot(epochs, len(epochs)*[results_traditional["Agrell"]["en"]], linewidth=3, label="Agrell", color=next(colors), linestyle="-.")

if blkSize==2 and chDim==1:
    plt.ylim([0.49, 0.55]) # For 02x01
elif blkSize==4 and chDim==2:
    plt.ylim([0.75, 1.40]) # For 04x02
elif blkSize==8 and chDim==4:
    plt.ylim([0.75, 7.0]) # For 08x04
# plt.xlim([0, 3000])
plt.legend(loc='lower left', prop={'size':14})
plt.grid()
robinhood(fig, "output_rbf_en_evo_{:02d}x{:02d}.csv".format(blkSize,chDim), col_dtype=[int, float])<jupyter_output><empty_output><jupyter_text>Plot Packing Density<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(4*1.5,3*1.5))

for (label, result) in results.items():
    clr = next(colors)
    en = [ log["packing_density_en"][-1] for log in result.values() ]
    sns.distplot([log["packing_density_en"][-1] for log in result.values()], 
                 label=label, color=clr,
                 bins=100, rug=False, 
                 
                 kde=True, 
                 kde_kws=dict(cumulative=True, 
                              linestyle=":" if "Oshea" in label or "[1]" in label else "-"),
                 
                 hist=False,
                 hist_kws=dict(cumulative=True, 
                               density=True, 
                               histtype="step", 
                               linestyle=":" if "Oshea" in label or "[1]" in label else "-",
                               linewidth=2,
                               color=clr, alpha=1.0))
    
# Plot lines for traditional methods
plt.plot(128*[results_traditional["QAM"]["en"]], [0] + 127 * [1], linewidth=3, label="QAM", color=next(colors), linestyle="-.")
# plt.plot(2*[results_traditional["Agrell"]["en"]], [0,1], linewidth=3, label="Agrell [17]", color=next(colors), linestyle="-.")
plt.plot(128*[results_traditional["Agrell"]["en"]], [0] + 127 * [1], linewidth=3, label="Agrell", color=next(colors), linestyle="-.")

# Experiment specific axis limits
if blkSize==8 and chDim==4:
    plt.xlim([0.95*results_traditional["Agrell"]["en"], 2.5*results_traditional["Agrell"]["en"]])
elif blkSize==4 and chDim==2:
    pass
elif blkSize==2 and chDim==1:
    pass
else:
    raise NotImplementedError("Not implemented (blkSize={},chDim={})".format(blkSize,chDim))

plt.xlabel("$E_n$", fontdict={'fontsize':16})
plt.ylabel("CDF", fontdict={'fontsize':16})
plt.grid()
plt.legend(loc='upper left', prop={'size':14})
# plt.savefig("output_awgn_en_{:02d}x{:02d}.pdf".format(blkSize,chDim), format='pdf', bbox_inches='tight')

robinhood(fig, "output_rbf_en_{:02d}x{:02d}.csv".format(blkSize,chDim))<jupyter_output><empty_output><jupyter_text>Plot BLER<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(4*1.5,3*1.5))

for (label, result) in results.items():
    best_model_id = min(result, key=lambda l: result[l]['packing_density_en'][-1])
    plt.semilogy(result[best_model_id]["snr_dB"], 
                 result[best_model_id]["bler"], 
                 label=label, color=next(colors), linewidth=2,
                 linestyle=":" if "Oshea" in label or "[1]" in label else "-")

plt.semilogy(SNR_range_dB, results_traditional["QAM"]["bler"], label="QAM", color=next(colors), linestyle="-.")
# plt.semilogy(SNR_range_dB, results_traditional["Agrell"]["bler"], label="Agrell [17]", color=next(colors), linestyle="-.")
plt.semilogy(SNR_range_dB, results_traditional["Agrell"]["bler"], label="Agrell", color=next(colors), linestyle="-.")
    
plt.legend(loc="lower left", prop={'size':14})
plt.grid()
# plt.title("Best observed BLER of trained models", fontdict={'fontsize':18})
plt.xlabel("SNR ($dB$)", fontdict={'fontsize':16})
plt.ylabel("BLER", fontdict={'fontsize':16})
plt.ylim((1e-4,1e0))
robinhood(fig, "output_rbf_best_bler_{:02d}x{:02d}.csv".format(blkSize,chDim), col_dtype=[int, float])<jupyter_output><empty_output><jupyter_text>Plot BLER with std dev<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(4*1.5,3*1.5))

for (label, result_dict) in results.items():
    clr = next(colors)
    
    d = [log["bler"] for (_, log) in result_dict.items()]
    d_mean = np.mean(d, axis=0)
    d_std = np.std(d, axis=0)
    
    plt.fill_between(result_dict[list(result_dict.keys())[0]]["snr_dB"],
                    d_mean + d_std, d_mean - d_std, alpha=0.20)
    plt.semilogy(result_dict[list(result_dict.keys())[0]]["snr_dB"],
                 d_mean, 
                 label=label, color=clr, linewidth=2,
                 linestyle=":" if "Oshea" in label or "[1]" in label else "-")
    
    # hack for robinhood to pickup shaded area
    plt.plot(result_dict[list(result_dict.keys())[0]]["snr_dB"],
             d_mean + d_std, color=clr, alpha=0.00, label= label + "_upper")
    plt.plot(result_dict[list(result_dict.keys())[0]]["snr_dB"],
             d_mean - d_std, color=clr, alpha=0.00, label= label + "_lower")

plt.semilogy(SNR_range_dB, results_traditional["QAM"]["bler"], label="QAM", color=next(colors), linestyle="-.")
plt.semilogy(SNR_range_dB, results_traditional["Agrell"]["bler"], label="Agrell [17]", color=next(colors), linestyle="-.")

plt.legend(loc="lower left", prop={'size':14})
plt.grid()
plt.xlabel("SNR ($dB$)", fontdict={'fontsize':16})
plt.ylabel("BLER", fontdict={'fontsize':16})
plt.ylim((1e-4,1e0))
# plt.savefig("output_rbf_avg_bler_{:02d}x{:02d}.pdf".format(blkSize,chDim), format='pdf', bbox_inches='tight')
robinhood(fig, "output_rbf_avg_bler_{:02d}x{:02d}.csv".format(blkSize,chDim), col_dtype=[int, float])<jupyter_output><empty_output><jupyter_text>Evolution of BLER @ 16dB<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(6*1.5, 3*1.5))
data = {}

for (label, result_dict) in results.items():
    epochs = result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"]
    d = []
    clr = next(colors)
    for (modelid, log) in result_dict.items():
#         plt.semilogy(log["packing_density_epochs"],
#                  log["packing_density_en"], color=clr, alpha=0.1)
        d.append(log["bler_16dB_bler"])
    d_mean = np.mean(d, axis=0)
    d_std = np.std(d, axis=0)
    plt.fill_between(result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"],
                    d_mean+d_std, d_mean-d_std, alpha=0.20)
    plt.semilogy(result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"],
                 d_mean, color=clr, alpha=0.9, label=label)
    
    # hack for robinhood to pickup shaded area
    plt.plot(result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"],
             d_mean + d_std, color=clr, alpha=0.00, label= label + "_upper")
    plt.plot(result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"],
             d_mean - d_std, color=clr, alpha=0.00, label= label + "_lower")
    
plt.plot(epochs, len(epochs)*[results_traditional["QAM"]["bler"][8]], linewidth=3, label="QAM", color=next(colors), linestyle="-.")
plt.plot(epochs, len(epochs)*[results_traditional["Agrell"]["bler"][8]], linewidth=3, label="Agrell", color=next(colors), linestyle="-.")

if blkSize==2 and chDim==1:
    plt.ylim([2e-2, 8e-2]) # For 02x01
elif blkSize==4 and chDim==2:
    plt.ylim([3e-2, 1e-1]) # For 04x02
elif blkSize==8 and chDim==4:
    plt.ylim([5e-2, 3e-1]) # For 08x04
plt.xlim([0, 3000])
plt.legend(loc='lower left', prop={'size':14})
plt.grid()
robinhood(fig, "output_rbf_bler16dB_evo_{:02d}x{:02d}.csv".format(blkSize,chDim), col_dtype=[int, float])<jupyter_output><empty_output><jupyter_text>Evolution of BLER @ 20dB<jupyter_code>colors = cycle(['b', 'g', 'c', 'r', 'm', 'y'])
fig = plt.figure(figsize=(6*1.5, 3*1.5))
data = {}

for (label, result_dict) in results.items():
    epochs = result_dict[list(result_dict.keys())[0]]["bler_16dB_epochs"]
    d = []
    clr = next(colors)
    for (modelid, log) in result_dict.items():
#         plt.semilogy(log["packing_density_epochs"],
#                  log["packing_density_en"], color=clr, alpha=0.1)
        d.append(log["bler_20dB_bler"])
    d_mean = np.mean(d, axis=0)
    d_std = np.std(d, axis=0)
    plt.fill_between(result_dict[list(result_dict.keys())[0]]["bler_20dB_epochs"],
                    d_mean+d_std, d_mean-d_std, alpha=0.20)
    plt.semilogy(result_dict[list(result_dict.keys())[0]]["bler_20dB_epochs"],
                 d_mean, color=clr, alpha=0.9, label=label)
    
    # hack for robinhood to pickup shaded area
    plt.plot(result_dict[list(result_dict.keys())[0]]["bler_20dB_epochs"],
             d_mean + d_std, color=clr, alpha=0.00, label= label + "_upper")
    plt.plot(result_dict[list(result_dict.keys())[0]]["bler_20dB_epochs"],
             d_mean - d_std, color=clr, alpha=0.00, label= label + "_lower")
    
plt.plot(epochs, len(epochs)*[results_traditional["QAM"]["bler"][10]], linewidth=3, label="QAM", color=next(colors), linestyle="-.")
plt.plot(epochs, len(epochs)*[results_traditional["Agrell"]["bler"][10]], linewidth=3, label="Agrell", color=next(colors), linestyle="-.")

if blkSize==2 and chDim==1:
    plt.ylim([7e-3, 2e-2]) # For 02x01
elif blkSize==4 and chDim==2:
    plt.ylim([1.5e-2, 4e-2]) # For 04x02
elif blkSize==8 and chDim==4:
    plt.ylim([0.2e-1, 1.2e-1]) # For 08x04
# plt.xlim([0, 3000])
plt.legend(loc='lower left', prop={'size':14})
plt.grid()
robinhood(fig, "output_rbf_bler20dB_evo_{:02d}x{:02d}.csv".format(blkSize,chDim), col_dtype=[int, float])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1786386050531239, 'fraction_numerical': 0.040872350160134206, 'mean_word_length': 3.864490603363007, 'pattern_counts': {'":': 23, '<': 53, '<?xml version=': 0, '>': 62, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '452138', 'license': 'MIT', 'n_tokens_mistral': 8373, 'n_tokens_neox': 7951, 'n_words': 1245, 'path': 'RBF/plot_figures.ipynb', 'repo_name': 'v-i-s-h/dl-vi-comm', 'size': '19671'}