<jupyter_start><jupyter_text>doing something a little weird now. take mean of each electrode's value for each round. Maybe this'll be helpful for a neural net ?<jupyter_code>electrode_dict = dict()

# loop over subjects
for i in range(1, 11):
    str_int = str(i)
    #print(str_int)
    if i < 10:
        str_int = '0' + str_int
    
    tempNeur = loadmat('ephys_data/s' + str_int + '_ofc_hg_events.mat')['buttonpress_events_hg'][:, 0:951, :]
    # loop over rounds
    starter = [np.mean(i) for i in tempNeur[0, :, :]]
    
    for r in range(1, tempNeur.shape[0]):
        meanArray = [np.mean(i) for i in tempNeur[r, :, :]]
        starter = np.vstack((starter, meanArray))
    electrode_dict[str(i)] = starter

i = 10
str_int = str(i)
#print(str_int)
if i < 10:
    str_int = '0' + str_int

tempNeur = loadmat('ephys_data/s' + str_int + '_ofc_hg_events.mat')['buttonpress_events_hg'][:, 0:951, :]
# loop over rounds
starter = [np.mean(i) for i in tempNeur[0, :, :]]

for r in range(1, tempNeur.shape[0]):
    meanArray = [np.mean(i) for i in tempNeur[r, :, :]]
    starter = np.vstack((starter, meanArray))
electrode_dict[str(i)] = starter
for i in range(1, 11):
    str_int = str(i)
    print(electrode_dict['str_int'].shape)
import os
import pickle
with open(os.path.join('electrode_mean_dict.pickle'), 'wb') as handle1:
    pickle.dump(electrode_dict, handle1, protocol=pickle.HIGHEST_PROTOCOL)
data_filtered = pd.read_csv('Lillian_iter1/data567.csv')
data_filtered.head()
data_filtered[data_filtered['subject_number'] == 1]['round'].unique()
y_dict = dict()
x_dict = dict()

game_model = pd.read_csv('behavioral_data/gamble_choices.csv')

for i in range(1,10):
    str_int = str(i)
    if i < 10:
        str_int = '0' + str_int
    tempBehav = pd.read_csv('behavioral_data/gamble.data.s' + str_int + '.csv')
    tempNeur = electrode_dict[str(i)]
    tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

    no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1] == 0]
    onlyThreshold = no_bad[no_bad['choice.location'] != 'Timeout']
    
    bool_array = [(onlyThreshold['Risky.bet.hidden.number'] == 5).tolist() 
                  or (onlyThreshold['Risky.bet.hidden.number'] == 6).tolist() 
                  or (onlyThreshold['Risky.bet.hidden.number'] == 7).tolist()][0]
    
    y_dict[str(i)] = onlyThreshold[bool_array]['choice.class']
    x_dict[str(i)] = tempNeur[bool_array]
    
# oops forgot to do 10
i = 10
str_int = str(i)
if i < 10:
    str_int = '0' + str_int
tempBehav = pd.read_csv('behavioral_data/gamble.data.s' + str_int + '.csv')
tempNeur = electrode_dict[str(i)]
tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1][0:138] == 0]
onlyThreshold = no_bad[no_bad['choice.location'] != 'Timeout']

bool_array = [(onlyThreshold['Risky.bet.hidden.number'] == 5).tolist() 
              or (onlyThreshold['Risky.bet.hidden.number'] == 6).tolist() 
              or (onlyThreshold['Risky.bet.hidden.number'] == 7).tolist()][0]

#print(tempNeur.shape)


y_dict[str(i)] = onlyThreshold[bool_array]['choice.class']
x_dict[str(i)] = tempNeur[bool_array]



# stack all the stuff
#starter_y = y_dict['1']
starter_x = x_dict['1']
for i in range(2, 11): 
    #starter_y = np.vstack((starter_y, y_dict[str(i)]))
    starter_x = np.vstack((starter_x, x_dict[str(i)]))
y_starter = y_dict['1']
for i in range(2, 11): 
    y_starter = np.append(y_starter, y_dict[str(i)])
    
y_starter
starter_y = []
for i in y_starter:
    if i == 'Gamble':
        temp_int = 1
    else:
        temp_int = 0
    starter_y.append(temp_int)
starter_y = np.asarray(starter_y)

type(starter_x[0, :])
a = np.array([[1, 1], [2, 2], [3, 3]])
np.insert(a, 2, 5, axis = 1)
all_data = np.insert(starter_x.tolist(), [951], starter_y.tolist(), axis = 1)

# WHY CAN'T YOU JUST BE NORMAL
b = np.empty(0)
b
all_data2 = np.append(starter_x[0, :], starter_y[0])

for i in range(1, starter_x.shape[0]):
    temp_row = np.append(starter_x[i, :], starter_y[i])
    all_data2 = np.vstack((all_data2, temp_row))
    
all_data2.shape
all_data.shape
#starter_x.shape
#starter_y.shape


from sklearn.utils import resample

bootX, bootY = resample(starter_x, starter_y, replace=True, n_samples=500, random_state=1)
#bootY = resample(starter_y, replace=True, n_samples=500, random_state=1)

import os
import pickle
with open(os.path.join('bootX.pickle'), 'wb') as handle1:
    pickle.dump(bootX, handle1, protocol=pickle.HIGHEST_PROTOCOL)
with open(os.path.join('bootY.pickle'), 'wb') as handle1:
    pickle.dump(bootY, handle1, protocol=pickle.HIGHEST_PROTOCOL)
np.asarray(y_data)
X_train, X_test, y_train, y_test = train_test_split(starter_x, starter_y, test_size=0.2, random_state=100)
from sklearn.utils import resample

bootX_train, bootY_train = resample(X_train, y_train, replace=True, n_samples=400, random_state=100)
bootX_test, bootY_test = resample(X_train, y_train, replace=True, n_samples=100, random_state=100)<jupyter_output><empty_output><jupyter_text>neural net<jupyter_code>import os
import pickle
with open(os.path.join('x_data_neural.pickle'),'rb') as handle1:
    x_data = pickle.load(handle1)
    
with open(os.path.join('y_data_neural.pickle'),'rb') as handle2:
    y_data = pickle.load(handle2)
with open(os.path.join('bootX.pickle'),'rb') as handle3:
    boot_x = pickle.load(handle3)
    
with open(os.path.join('y_data_neural.pickle'),'rb') as handle4:
    boot_y = pickle.load(handle4)
import tensorflow as tf
tf.reset_default_graph()
'''x_data = boot[:, 0:951]
y_data = np.asarray([int(i) for i in boot[:, 951]])'''
X_train, X_test, y_train, y_test = train_test_split(boot_x, boot_y, test_size=0.2, random_state=100)
# define features
feature_cols = tf.contrib.learn.infer_real_valued_columns_from_input(bootX_train)

# dense neural network classifier
# two layers 300 and 100
# 10 clases
dnn_clf = tf.contrib.learn.DNNClassifier(hidden_units=[300,100], n_classes=10,
                                         feature_columns=feature_cols)

# if TensorFlow >= 1.1, make compatible with sklearn
dnn_clf = tf.contrib.learn.SKCompat(dnn_clf) 
# fit the model, 4000 iterations
dnn_clf.fit(X_train, y_train, batch_size=50, steps=1000)
# Calculate accuracies
from sklearn.metrics import accuracy_score

y_pred = dnn_clf.predict(X_test)
print()
print('Accuracy',accuracy_score(y_test, y_pred['classes']))
type(starter_x)
import tensorflow as tf

# Reset graph
tf.reset_default_graph()

tf.reset_default_graph()
n_inputs = 951  
n_hidden1 = 300
n_hidden2 = 100
n_outputs = 2
# Placeholders for data (inputs and targets)
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
y = tf.placeholder(tf.int64, shape=(None), name="y")
# Define neuron layers (ReLU in hidden layers)
# We'll take care of Softmax for output with loss function

def neuron_layer(X, n_neurons, name, activation=None):
    # X input to neuron
    # number of neurons for the layer
    # name of layer
    # pass in eventual activation function
    
    with tf.name_scope(name):
        n_inputs = int(X.get_shape()[1])
        
        # initialize weights to prevent vanishing / exploding gradients
        stddev = 2 / np.sqrt(n_inputs)
        init = tf.truncated_normal((n_inputs, n_neurons), stddev=stddev)
        
        # Initialize weights for the layer
        W = tf.Variable(init, name="weights")
        # biases
        b = tf.Variable(tf.zeros([n_neurons]), name="bias")
        
        # Output from every neuron
        Z = tf.matmul(X, W) + b
        if activation is not None:
            return activation(Z)
        else:
            return Z
# Define the hidden layers
with tf.name_scope("dnn"):
    hidden1 = neuron_layer(X, n_hidden1, name="hidden1",
                           activation=tf.nn.relu)
    hidden2 = neuron_layer(hidden1, n_hidden2, name="hidden2",
                           activation=tf.nn.relu)
    logits = neuron_layer(hidden2, n_outputs, name="outputs")
# Define loss function (that also optimizes Softmax for output):

with tf.name_scope("loss"):
    # logits are from the last output of the dnn
    xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y,
                                                              logits=logits)
    loss = tf.reduce_mean(xentropy, name="loss")
with tf.name_scope("dropout"):
    dropout = tf.nn.dropout(X, 0.1)
# Training step with Gradient Descent

learning_rate = 0.01

with tf.name_scope("train"):
    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
    training_op = optimizer.minimize(loss)
# Evaluation to see accuracy

with tf.name_scope("eval"):
    correct = tf.nn.in_top_k(logits, y, 1)
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))
# create validation set.
# make it 20% of train set

X_train2, X_val, y_train2, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=100)
# i think i'll probably have to bootstrap the data since there's so little.
batch_size = 30
iteration = 0
X_train2[iteration*batch_size:(iteration+1)*batch_size]
init = tf.global_variables_initializer()
saver = tf.train.Saver()

n_epochs = 3
batch_size = 30

with tf.Session() as sess:
    init.run()
    for epoch in range(n_epochs):
        for iteration in range(X_train.shape[0] // batch_size):
            X_batch = X_train2[iteration*batch_size:(iteration+1)*batch_size]
            y_batch = y_train2[iteration*batch_size:(iteration+1)*batch_size]
            
            sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
        acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
        acc_val = accuracy.eval(feed_dict={X: X_val,
                                            y: y_val})
        print(epoch, "Train accuracy:", acc_train, "Val accuracy:", acc_val)

    save_path = saver.save(sess, "./my_model_final.ckpt") # save model
with tf.Session() as sess:
    saver.restore(sess, "./my_model_final.ckpt") # or better, use save_path
    X_new_scaled = X_test
    Z = logits.eval(feed_dict={X: X_new_scaled})
    y_pred = np.argmax(Z, axis=1)

print("Predicted classes:", y_pred)
print("Actual classes:   ", y_test)
sum(y_pred == y_test)/len(y_test)<jupyter_output><empty_output><jupyter_text>neural net 2 with result_frame<jupyter_code>result_frame2 = result_frame.drop(['Subject'], axis = 1)
result_frame2 = result_frame2.drop('Unnamed: 0', axis = 1)

result_frame2.head()
X_data = result_frame2.drop('Result', axis = 1)
y_data = result_frame2['Result']
X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=0.2, random_state=100)
n_inputs = 10 
n_hidden1 = 300
n_hidden2 = 100
n_outputs = 2
X_train2, X_val, y_train2, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=100)

init = tf.global_variables_initializer()
saver = tf.train.Saver()

n_epochs = 5
batch_size = 30

with tf.Session() as sess:
    init.run()
    for epoch in range(n_epochs):
        for iteration in range(X_train.shape[0] // batch_size):
            X_batch = X_train2[iteration*batch_size:(iteration+1)*batch_size]
            y_batch = y_train2[iteration*batch_size:(iteration+1)*batch_size]
            
            sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
        acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
        acc_val = accuracy.eval(feed_dict={X: X_val,
                                            y: y_val})
        print(epoch, "Train accuracy:", acc_train, "Val accuracy:", acc_val)

    save_path = saver.save(sess, "./my_model_final.ckpt") # save model
with tf.Session() as sess:
    saver.restore(sess, "./my_model_final.ckpt") # or better, use save_path
    X_new_scaled = X_test
    Z = logits.eval(feed_dict={X: X_new_scaled})
    y_pred = np.argmax(Z, axis=1)

print("Predicted classes:", y_pred)
print("Actual classes:   ", y_test)
for y in y_dict['1']:
    print(y)
y_dict['1']
starter_y = y_dict['1'].tolist()
starter_y.append(starter_y[0])
starter_y
a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
c = np.vstack((a,b))
np.vstack((c, b))
game_model = pd.read_csv('behavioral_data/gamble_choices.csv')

i = 1
str_int = str(i)
if i < 10:
    str_int = '0' + str_int
tempBehav = pd.read_csv('behavioral_data/gamble.data.s' + str_int + '.csv')
tempNeur = electrode_dict[str(i)]
tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1] == 0]
onlyThreshold = no_bad[no_bad['choice.location'] != 'Timeout']

bool_array = [(onlyThreshold['Risky.bet.hidden.number'] == 5).tolist() 
              or (onlyThreshold['Risky.bet.hidden.number'] == 6).tolist() 
              or (onlyThreshold['Risky.bet.hidden.number'] == 7).tolist()]


onlyThreshold[bool_array]
electrode_dict['1'][bool_array].shape
tempNeur = loadmat('ephys_data/s01_ofc_hg_events.mat')['buttonpress_events_hg'][:, 0:951, :]
tempNeur[0, :, :].shape
len([np.mean(i) for i in tempNeur[0, :, :]])
type(tempNeur)
subject_dict = dict()

game_model = pd.read_csv('behavioral_data/gamble_choices.csv')

for i in range(1,10):
    str_int = str(i)
    if i < 10:
        str_int = '0' + str_int
    tempBehav = pd.read_csv('behavioral_data/gamble.data.s' + str_int + '.csv')
    tempNeur = loadmat('ephys_data/s' + str_int + '_ofc_hg_events.mat')
    tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

    no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1] == 0]
    onlyThreshold = no_bad[no_bad['choice.location'] != 'Timeout']
    
    
    electrodesBPE = tempNeur['buttonpress_events_hg']
    
    #make columns for electrode feature engineering. use 3 bins
    for j in range(10):
        for b in range(1, 4):
            onlyThreshold.loc[:, 'Electrode' + str(j) + '_min' + '_bin' + str(b)] = np.nan
            onlyThreshold.loc[:, 'Electrode' + str(j) + '_max' + '_bin' + str(b)] = np.nan
            onlyThreshold.loc[:, 'Electrode' + str(j) + '_avg' + '_bin' + str(b)] = np.nan
            
    bin_dict = {'1': range(317), '2': range(317, 634), '3': range(634, 951)}

        
    for e in range(min(electrodesBPE.shape[2], 10)):
        electrode_str = 'Electrode' + str(e)
        for binn in range(1, 4):
            tempBinn = electrodesBPE[:, bin_dict[str(binn)], e]
            #print(len([min(i) for i in tempBinn]))
            #print(len(onlyThreshold.loc[:, electrode_str + '_min' + '_bin' + str(binn)]))
            #print('/n')
            
            onlyThreshold.loc[:, electrode_str + '_min' + '_bin' + str(binn)] = [min(x) for x in tempBinn]
            onlyThreshold.loc[:, electrode_str + '_max' + '_bin' + str(binn)] = [max(x) for x in tempBinn]
            onlyThreshold.loc[:, electrode_str + '_avg' + '_bin' + str(binn)] = [np.mean(x) for x in tempBinn]
            
    #only trials 5 6 7
    
    onlyThreshold = onlyThreshold[(onlyThreshold['Risky.bet.hidden.number'] == 5).tolist()
                          or (onlyThreshold['Risky.bet.hidden.number'] == 6).tolist()
                          or (onlyThreshold['Risky.bet.hidden.number'] == 7).tolist()]
    
    
            
    subject_dict[str(i)] = onlyThreshold
            
    
    
    
for i in range(1, 10):
    print(subject_dict[str(i)].shape)
list(subject_dict['3'])

tempNeur = loadmat('ephys_data/s03_ofc_hg_events.mat')
tempNeur['buttonpress_events_hg'][0, 0, :]

i = 10
str_int = str(i)

tempBehav = pd.read_csv('behavioral_data/gamble.data.s' + str_int + '.csv')
tempNeur = loadmat('ephys_data/s' + str_int + '_ofc_hg_events.mat')
tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1][0:138] == 0]
#no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1] == 0]
onlyThreshold = no_bad[no_bad['choice.location'] != 'Timeout']
    

electrodesBPE = tempNeur['buttonpress_events_hg']

print(electrodesBPE.shape)
#make columns for electrode feature engineering. use 3 bins
for j in range(10):
    for b in range(1, 4):
        onlyThreshold.loc[:, 'Electrode' + str(j) + '_min' + '_bin' + str(b)] = np.nan
        onlyThreshold.loc[:, 'Electrode' + str(j) + '_max' + '_bin' + str(b)] = np.nan
        onlyThreshold.loc[:, 'Electrode' + str(j) + '_avg' + '_bin' + str(b)] = np.nan

bin_dict = {'1': range(317), '2': range(317, 634), '3': range(634, 951)}


for e in range(electrodesBPE.shape[2]):
    electrode_str = 'Electrode' + str(e)
    for binn in range(1, 4):
        tempBinn = electrodesBPE[:, bin_dict[str(binn)], e]
        
        onlyThreshold.loc[:, electrode_str + '_min' + '_bin' + str(binn)] = [min(x) for x in tempBinn]
        onlyThreshold.loc[:, electrode_str + '_max' + '_bin' + str(binn)] = [max(x) for x in tempBinn]
        onlyThreshold.loc[:, electrode_str + '_avg' + '_bin' + str(binn)] = [np.mean(x) for x in tempBinn]

#only trials 5 6 7

onlyThreshold = onlyThreshold[(onlyThreshold['Risky.bet.hidden.number'] == 5).tolist()
                      or (onlyThreshold['Risky.bet.hidden.number'] == 6).tolist()
                      or (onlyThreshold['Risky.bet.hidden.number'] == 7).tolist()]



subject_dict[str(i)] = onlyThreshold

tempBehav = pd.read_csv('behavioral_data/gamble.data.s10.csv')
tempBehav.shape
tempNeur = loadmat('ephys_data/s' + str_int + '_ofc_hg_events.mat')
tempNeur['buttonpress_events_hg'].shape
onlyThreshold = tempBehav[tempBehav['choice.location'] != 'Timeout']
onlyThreshold.shape
import os
import pickle
with open(os.path.join('subject_dictno10.pickle'), 'wb') as handle1:
    pickle.dump(subject_dict, handle1, protocol=pickle.HIGHEST_PROTOCOL)
main_frame = subject_dict['1']
main_frame.loc[:, 'subject_number'] = '1'
for key, value in subject_dict.items():
    value.loc[:, 'subject_number'] = key
    main_frame = main_frame.append(value)

    
main_frame.head()
#main_frame.shape
# some of the subjects have 59 electrodes.... ?? ? ???????

main_frame.to_csv('data567.csv')
game_model = pd.read_csv('behavioral_data/gamble_choices.csv')

s8 = pd.read_csv('behav8_v1.csv')
s8 = s8.merge(game_model, left_index=True, right_index=True)
s8[(s8['Risky.bet.hidden.number']  == 5).tolist() 
   or (s8['Risky.bet.hidden.number']  == 6).tolist()
  or (s8['Risky.bet.hidden.number']  == 7).tolist()].head()

tempBehav = pd.read_csv('behavioral_data/gamble.data.s01.csv')
tempNeur = loadmat('ephys_data/s01_ofc_hg_events.mat')
tempBehav = tempBehav.merge(game_model, left_index=True, right_index=True)

no_bad = tempBehav[badTrials['bad_trials_OFC'][i-1] == 0]
no_bad = no_bad[no_bad['choice.location'] != 'Timeout']

#only trials 5 6 7

onlyThreshold = no_bad[(no_bad['Risky.bet.hidden.number'] == 5).tolist()
                          or (no_bad['Risky.bet.hidden.number'] == 6).tolist()
                          or (no_bad['Risky.bet.hidden.number'] == 7).tolist()]
    
onlyThreshold
bin_dict = {'1': range(317), '2': range(317, 634), '3': range(634, 951)}
bin_dict['1']
test1 = tempNeur['buttonpress_events_hg']
test1[:, 0:317, 0]
(s8['Risky.bet.hidden.number']  == 5).tolist() or (s8['Risky.bet.hidden.number']  == 6).tolist()
s8['dummy'] = np.nan
s8.head()

badTrials['bad_trials_OFC'].shape

np.max(electrodesBPE['Electrode_1'][0, :])
badTrials['bad_trials_OFC'][0] == 0
#convert left and right in choice location to 0 and 1 (respectively)
behav8['choice.location'].isnull().any()

behav8['convertedLocation'] = np.nan
for index, row in behav8.iterrows():
    if row['choice.location'] == 'Left':
        behav8.at[index, 'convertedLocation'] = 0
    else:
        behav8.at[index, 'convertedLocation'] = 1
        
behav8.head()
        

from sklearn.model_selection import train_test_split

X = behav8.drop(['choice.class', 'outcome', 'choice.location'], axis = 1)
Y = behav8['outcome']



x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=100)

from sklearn import linear_model

# Name our logistic regression object
LogisticRegressionModel = linear_model.LogisticRegression()

# we create an instance of logistic Regression Classifier and fit the data.
print ('Training a logistic Regression Model..')
LogisticRegressionModel.fit(x_train, y_train)

training_accuracy=LogisticRegressionModel.score(x_train,y_train)
print ('Training Accuracy: ', training_accuracy)
test_accuracy=LogisticRegressionModel.score(x_test,y_test)
print('Accuracy of the model on unseen test data: ',test_accuracy)
#serious overfitting in the above. 
# going to check it out in r...
behav8.to_csv('behav8_v1.csv')
import numpy as np
import matplotlib.pyplot as plt

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

import mne
from mne.datasets import sample
from mne.decoding import (SlidingEstimator, GeneralizingEstimator,
                          cross_val_multiscore, LinearModel, get_coef)
import pandas as pd

 best_trials = pd.read_csv('best_trials_master_df.csv')
neur8 = loadmat('s08_ofc_hg_events.mat')
neur8


# try the same with result_frame ?

result_frame = pd.read_csv('result_frame.csv')
result_frame.head()


result_frame2 = result_frame.drop(['Subject'], axis = 1)
result_frame2 = result_frame2.drop('Unnamed: 0', axis = 1)

result_frame2.head()
X_data = result_frame2.drop('Result', axis = 1)
y_data = result_frame2['Result']<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14615348465623385, 'fraction_numerical': 0.02363832886883782, 'mean_word_length': 3.9545983701979046, 'pattern_counts': {'":': 0, '<': 19, '<?xml version=': 0, '>': 14, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 9, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '3', 'dir': 'jupyter-structured-clean-dedup', 'id': '603019', 'license': 'MIT', 'n_tokens_mistral': 8266, 'n_tokens_neox': 7814, 'n_words': 1592, 'path': 'Model History/explore_lillian3.ipynb', 'repo_name': 'dattasiddhartha/DataX-NeuralDecisionMaking', 'size': '21279'}