kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,294,222 | for i in range(0,num):
X_train_np = trains[i][features].values.astype(np.float32)
X_valid_np = valids[i][features].values.astype(np.float32)
tr_data = lgb.Dataset(X_train_np, label=trains[i][target], feature_name=list(features))
va_data = lgb.Dataset(X_valid_np, label=valids[i][target], feature_name=list(features))
d... | y = to_categorical(y, num_classes = 10)
y[0] | Digit Recognizer |
12,294,222 | MAX_SEQ = 100
class FFN(nn.Module):
def __init__(self, state_size=200):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, state_size)
self.relu = nn.ReLU()
self.lr2 = nn.Linear(state_size, state_size)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
x = self.lr1(x)
x = s... | train = train.values.reshape(train.shape[0], 28, 28, 1)
test = test.values.reshape(test.shape[0], 28, 28, 1)
print('Reshaped Train set: ',train.shape, " & Reshaped Test Set", test.shape ) | Digit Recognizer |
12,294,222 | user_sum_dict = user_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_count_dict = user_agg['count'].astype('int16' ).to_dict(defaultdict(int))
<data_type_conversions> | train = train.astype("float32")/255.0
test = test.astype("float32")/255.0 | Digit Recognizer |
12,294,222 | del user_agg
gc.collect()
task_container_sum_dict = task_container_agg['sum'].astype('int32' ).to_dict(defaultdict(int))
task_container_count_dict = task_container_agg['count'].astype('int32' ).to_dict(defaultdict(int))
task_container_std_dict = task_container_agg['var'].astype('float16' ).to_dict(defaultdict(int))
exp... | X_train, X_val, y_train, y_val = train_test_split(train, y, test_size=0.25, random_state=0)
print("Number of samples in Training set :", X_train.shape[0])
print("Number of samples in Validation set :", X_val.shape[0] ) | Digit Recognizer |
12,294,222 | user_lecture_sum_dict = user_lecture_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_lecture_count_dict = user_lecture_agg['count'].astype('int16' ).to_dict(defaultdict(int))
del user_lecture_agg
gc.collect()<categorify> | train_datagen = ImageDataGenerator(rotation_range=10,
zoom_range=0.1,
width_shift_range=0.1,
height_shift_range=0.1
)
training_set = train_datagen.flow(X_train, y_train,
batch_size=64
)
val_datagen = ImageDataGenerator()
val_set = val_datagen.flow(X_val, y_val,
batch_size=64
) | Digit Recognizer |
12,294,222 | max_timestamp_u_dict=max_timestamp_u.set_index('user_id' ).to_dict()
max_timestamp_u_dict2=max_timestamp_u2.set_index('user_id' ).to_dict()
max_timestamp_u_dict3=max_timestamp_u3.set_index('user_id' ).to_dict()
user_prior_question_elapsed_time_dict=user_prior_question_elapsed_time.set_index('user_id' ).to_dict()
del ma... | model = tf.keras.models.Sequential()
model.add(Conv2D(64, kernel_size=(5,5), padding='same', activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(64, kernel_size=(5,5), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(128, kernel_siz... | Digit Recognizer |
12,294,222 | attempt_no_sum_dict = attempt_no_agg['sum'].to_dict(defaultdict(int))
del attempt_no_agg
gc.collect()<feature_engineering> | reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=4,
verbose=1,
min_delta=0.0001 ) | Digit Recognizer |
12,294,222 | def get_max_attempt(user_id,content_id):
k =(user_id,content_id)
if k in attempt_no_sum_dict.keys() :
attempt_no_sum_dict[k]+=1
return attempt_no_sum_dict[k]
attempt_no_sum_dict[k] = 1
return attempt_no_sum_dict[k]<feature_engineering> | steps_per_epoch = training_set.n // training_set.batch_size
validation_steps = val_set.n // val_set.batch_size
hist = model.fit(x=training_set,
validation_data=val_set,
epochs=35,
callbacks=[reduce_lr],
steps_per_epoch=steps_per_epoch,
validation_steps=validation_steps
) | Digit Recognizer |
12,294,222 |
<define_variables> | _, acc_val = model.evaluate(val_set)
_, acc_tr = model.evaluate(val_set)
print("
Final Accuracy on training set : {:.2f}% & accuracy on validation is set: {:.2f}%".format(acc_tr*100, acc_val*100)) | Digit Recognizer |
12,294,222 | iter_test = env.iter_test()
prior_test_df = None
prev_test_df1 = None<define_search_space> | pred = model.predict(test)
res = np.argmax(pred, axis=1)
submission = pd.DataFrame({"ImageId":[i+1 for i in range(len(test)) ],
"Label": res})
submission.head(10 ) | Digit Recognizer |
12,294,222 | N=[0.4,0.6]<feature_engineering> | submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
12,294,222 | <import_modules><EOS> | submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
12,110,917 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, BatchNormalization, Dropout
from keras.callbacks import EarlyStopping, ReduceLROnPlateau
from keras.preprocessing.... | Digit Recognizer |
12,110,917 |
class Predictor(object):
def __init__(self, model, model_metadata, ohe_categorical_index_vocab,
mhe_categorical_index_vocab):
self._model = model
self._model_metadata = model_metadata
self._ohe_categorical_index_vocab = ohe_categorical_index_vocab
self._mhe_categorical_index_vocab = mhe_categorical_index_vocab
se... | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
12,110,917 | class Iter_Valid(object):
def __init__(self, df, max_user=1000):
df = df.reset_index(drop=True)
self.df = df
self.user_answer = df['user_answer'].astype(str ).values
self.answered_correctly = df['answered_correctly'].astype(str ).values
df['prior_group_responses'] = "[]"
df['prior_group_answers_correct'] = "[]"
self.s... | X_train = train.iloc[:,1:]
y_train = train.iloc[:,0] | Digit Recognizer |
12,110,917 | MAX_SEQ = 240
ACCEPTED_USER_CONTENT_SIZE = 2
EMBED_SIZE = 256
BATCH_SIZE = 64+32
DROPOUT = 0.1
class FFN(nn.Module):
def __init__(self, state_size = 200, forward_expansion = 1, bn_size = MAX_SEQ - 1, dropout=0.2):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, forward_expansi... | X_train = X_train.values.reshape(-1, 28, 28, 1)/255.
test = test.values.reshape(-1, 28, 28, 1)/255.
y_train = to_categorical(y_train, 10 ) | Digit Recognizer |
12,110,917 | class config:
FOLD = 0
ROOT_PATH = "/kaggle/input/riiid-xgboost-model-and-features"
MODEL_NAME = "xgb_v17_06_f0"
validaten_flg = False
DDOF = 1<load_pretrained> | random_seed = 0
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=random_seed ) | Digit Recognizer |
12,110,917 | model_path = f"{config.ROOT_PATH}/{config.MODEL_NAME}/{config.MODEL_NAME}"
model_name = f"{config.MODEL_NAME}_model.bst"
model_meta = f"{config.MODEL_NAME}_assets_model_metadata.json"
model = Predictor.from_path(model_path, model_name=model_name, meta_name=model_meta)
model._extract_model_metadata()
feature_names = mo... | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
) | Digit Recognizer |
12,110,917 | group = joblib.load("/kaggle/input/riiid-sakt-model/group.pkl.zip")
n_skill = joblib.load("/kaggle/input/riiid-sakt-model/skills.pkl.zip")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def create_model() :
return SAKTModel(n_skill, max_seq=MAX_SEQ, embed_dim=EMBED_SIZE, forward_expansion=1, e... | model = Sequential()
model.add(Conv2D(32,(5,5), padding='same', input_shape=X_train.shape[1:], activation='relu'))
model.add(Conv2D(32,(5,5), padding='same', activation='relu'))
model.add(MaxPool2D(2,2))
model.add(Conv2D(64,(3,3), padding='same', activation='relu'))
model.add(Conv2D(64,(3,3), padding='same', activation... | Digit Recognizer |
12,110,917 | content_agg_feats = pd.read_csv(f"{config.ROOT_PATH}/content_agg_feats.csv")
question_tags_ohe = pd.read_csv(f"{config.ROOT_PATH}/question_tags_ohe.csv")
lecture_tags_ohe = pd.read_csv(f"{config.ROOT_PATH}/lecture_tags_ohe.csv")
questions = pd.read_csv("/kaggle/input/riiid-test-answer-prediction/questions.csv")
que... | model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
12,110,917 | user_agg_feats_even = pd.read_csv(f"{config.ROOT_PATH}/user_agg_feat_even.csv")
user_agg_feats_odd = pd.read_csv(f"{config.ROOT_PATH}/user_agg_feat_odd.csv")
user_agg_feats_df = pd.concat([user_agg_feats_even, user_agg_feats_odd])
user_agg_feats_v = user_agg_feats_df.values
del user_agg_feats_df, user_agg_feats_even... | EPOCHS = 30
BATCH_SIZE = 20
callback_list = [
ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=1),
EarlyStopping(monitor='val_loss', min_delta=0.0005, patience=4)
]
history = model.fit(datagen.flow(X_train, y_train, batch_size=BATCH_SIZE),
epochs=EPOCHS,
callbacks=callback_list,
validation_data=(X_val, y_val... | Digit Recognizer |
12,110,917 | user_last_timestamp = pd.read_csv(f"{config.ROOT_PATH}/user_last_timestamp.csv")
last_timestamp_dic = {k: v for k, v in user_last_timestamp.values}
del user_last_timestamp
gc.collect()<load_pretrained> | results = model.predict(test)
results = np.argmax(results, axis=1)
results = pd.Series(results, name='Label')
submission = pd.concat([pd.Series(range(1,28001), name='ImageID'), results], axis=1)
submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
11,858,028 | WINDOW = config.ROOT_PATH
with open(f"{WINDOW}/user_all_count.pkl", "rb")as f:
user_all_count = pickle.load(f)
with open(f"{WINDOW}/user_correct_window_200.pkl", "rb")as f:
user_correct_window_200 = pickle.load(f)
with open(f"{WINDOW}/prior_question_elapsed_time_window_dict.pkl", "rb")as f:
prior_question_elapsed_tim... | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,858,028 | col1 = [f"work_q_tag_{i}_v3" for i in range(188)]
col2 = [f"cumsum_q_tag_{i}_v3" for i in range(188)]
col3 = [f"work_l_tag_{i}_v2" for i in range(188)]
user_agg_feats_c = col1 + col2 + col3
rate_col = [f"correct_rate_q_tag_{i}" for i in range(188)]<feature_engineering> | X = train.drop('label',axis = 1)
y = train.label | Digit Recognizer |
11,858,028 | def get_content_feature(_content_id):
idx = np.where(content_agg_feats_v[:,0] == _content_id)[0][0]
v = content_agg_feats_v[idx, 1:]
return v.tolist()
def get_user_feature(_user_id):
idx = np.where(user_agg_feats_v[:,0] == _user_id)[0]
if len(idx)== 0:
return np.zeros(user_agg_feats_v.shape[1] - 1)
else:
idx = idx[0]
... | y = to_categorical(y ) | Digit Recognizer |
11,858,028 | def update_infomation(row):
global user_agg_feats_v
_user_id = row["user_id"]
_timestamp = row["timestamp"]
_content_id = row["content_id"]
_answered_correctly = row["answered_correctly"]
_content_type_id = row["content_type_id"]
try:
_prior_question_had_explanation = int(row["prior_question_had_explanation"])
except ... | X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.25,random_state = 123 ) | Digit Recognizer |
11,858,028 | if config.validaten_flg:
target_df = pd.read_pickle('.. /input/riiid-cross-validation-files/cv1_valid.pickle')
iter_test = Iter_Valid(target_df, max_user=1000)
predicted = []
def set_predict(df):
predicted.append(df)
user_agg_feats_v = user_agg_feats_v[:10000]
last_timestamp_dic = {k: last_timestamp_dic[k] for k in ... | model = Sequential()
model.add(Conv2D(32,kernel_size =(3,3),activation = 'relu',input_shape =(28,28,1)))
model.add(Conv2D(64,kernel_size =(3,3),activation = 'relu'))
model.add(Flatten())
model.add(Dense(10,activation = 'softmax'))
| Digit Recognizer |
11,858,028 | print(psutil.virtual_memory().percent )<install_modules> | model.compile(optimizer = 'adam',loss = 'categorical_crossentropy',metrics = ['accuracy'] ) | Digit Recognizer |
11,858,028 | !pip install.. /input/lgbm-inference-db-full-data/pickle5-0.0.11/<import_modules> | history = model.fit(X_train,y_train,validation_data =(X_test,y_test),epochs = 20 ) | Digit Recognizer |
11,858,028 | import pandas as pd
import numpy as np
import gc
from sklearn.metrics import roc_auc_score
from collections import defaultdict
from tqdm.notebook import tqdm
import lightgbm as lgb
import pickle5 as pickle
from numba import jit<categorify> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64... | Digit Recognizer |
11,858,028 | @contextmanager
def timer(name):
t0 = time.time()
yield
print('
[{}] done in {} Minutes
'.format(name, round(( time.time() - t0)/ 60, 2)) )<define_variables> | model.compile(optimizer = 'Adam' , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
11,858,028 | train_pickle = '.. /input/lgbm-inference-db-full-data/train_df.pickle'
question_file = '.. /input/lgbm-inference-db-full-data/question_features.csv'
ms_in_a_day = 8.64 * 10 ** 7
prior_question_elapsed_time_mean = 25439.41<compute_train_metric> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_train ) | Digit Recognizer |
11,858,028 | left_asymptote = 0.25
@jit(nopython=True)
def get_new_theta(is_good_answer, beta, left_asymptote, theta, nb_previous_answers):
return theta + learning_rate_theta(nb_previous_answers)*(
is_good_answer - probability_of_good_answer(theta, beta, left_asymptote))
@jit(nopython=True)
def learning_rate_theta(nb_answers):
r... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
batch_size = 256
history = model.fit_generator(datagen.flow(X_train,y_train, batch_size=batch_size),
epochs = 30, validation_data =(X_test,y_test),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_si... | Digit Recognizer |
11,858,028 | def calc_user_feats_test(df, bundle_count, temp_values):
attempt_no_array = np.zeros(len(df), dtype=np.int32)
last_lecture_time_array = np.zeros(len(df), dtype=np.float64)
last_incorrect_time_array = np.zeros(len(df), dtype=np.float64)
acsu = np.zeros(len(df), dtype=np.int32)
acsu_part = np.zeros(len(df), dtype=np.... | predictions = model.predict_classes(test, verbose=1 ) | Digit Recognizer |
11,858,028 | def update_user_feats(df):
bundle_count = 1
for row in df[['user_id', 'answered_correctly', 'content_type_id', 'timestamp',
'part', 'content_id', 'answered_count', 'mean_content_accuracy_sm']].values:
if row[2] == 0:
answered_correctly_sum_user_dict['total'][row[0]] += row[1]
answered_correctly_sum_user_dict[int(row[4]... | prediction = pd.DataFrame({"ImageId":list(range(1,len(predictions)+1)) ,"Label":predictions} ) | Digit Recognizer |
11,858,028 | with open(train_pickle, 'rb')as file:
df = pickle.load(file )<categorify> | prediction.to_csv('kaggle_submission.csv',index=False,header=True)
prediction | Digit Recognizer |
11,858,028 | def multi_level_dict() :
return defaultdict(int)
attempt_dict = defaultdict(multi_level_dict )<categorify> | model = Sequential()
model.add(Conv2D(64,(3,3),activation='relu',input_shape=(28,28,1)))
model.add(Conv2D(64,(3,3),activation='relu'))
model.add(MaxPooling2D(2,2))
model.add(BatchNormalization())
model.add(Dropout(0.1))
model.add(Conv2D(128,(3,3),activation='relu'))
model.add(Conv2D(128,(3,3),activation='relu'))
mode... | Digit Recognizer |
11,858,028 | def multi_level_float_dict() :
return defaultdict(float )<data_type_conversions> | model.compile(RMSprop(lr=0.001,rho=0.9),loss='categorical_crossentropy',metrics=['accuracy'] ) | Digit Recognizer |
11,858,028 | with timer("counting"):
keys = np.sort(df['user_id'].unique())
total = len(keys)
user_bundle = df.groupby('user_id')['bundle_id'].apply(np.array ).apply(np.sort ).apply(np.unique)
user_attempts = df.groupby(['user_id', 'bundle_id'])['bundle_id'].count().astype(np.uint8 ).groupby('user_id' ).apply(np.array)
for user... | train_datagen = ImageDataGenerator(rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=False,
fill_mode='nearest')
train_datagen.fit(X_train)
train_generator = train_datagen.flow(X_train,y_train,batch_size=128)
| Digit Recognizer |
11,858,028 | <load_from_csv><EOS> | earlystop = EarlyStopping(monitor='val_loss',patience=2,verbose=1)
learning_reduce = ReduceLROnPlateau(patience=2,monitor="val_acc",verbose=1,min_lr=0.00001,factor=0.5)
callbacks = [learning_reduce]
history = model.fit_generator(train_generator,epochs=30,verbose=1,validation_data=(X_test,y_test),callbacks=callbacks ) | Digit Recognizer |
11,949,480 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | BATCH_SIZE = 64
VALID_BATCH_SIZE = 100
TEST_BATCH_SIZE = 100
EPOCHS = 5
NUM_CLASSES = 10
SEED = 42
EARLY_STOPPING = 25
OUTPUT_DIR = '/kaggle/working/'
MODEL_NAME = 'efficientnet-b0' | Digit Recognizer |
11,949,480 | TARGET = 'answered_correctly'
FEATS_1 = ['mean_user_accuracy',
'answered_count',
'mean_content_accuracy_sm',
'prior_question_elapsed_time',
'last_incorrect_time', 'prior_question_wait_time',
'content_freq_encoding',
'lag_time',
'attempt_no', 'last_lecture_time',
'mean_user_spent_time_part',
'answered_correctly_sum_user... | !pip install efficientnet-pytorch | Digit Recognizer |
11,949,480 | FEATS_2 = ['mean_user_accuracy',
'answered_correctly_sum_user',
'answered_count',
'mean_content_accuracy_sm',
'prior_question_elapsed_time',
'hmean_user_content_accuracy',
'last_incorrect_time', 'prior_question_wait_time',
'content_freq_encoding',
'lag_time',
'attempt_no', 'last_lecture_time',
'mean_user_spent_time_par... | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.autograd import Variable
from torch.utils.data import DataLoader, Dataset
from sklearn.metrics import accu... | Digit Recognizer |
11,949,480 | model_1 = lgb.Booster(model_file='.. /input/lgbm-inference-db-full-data/lightgbm_v11.5.txt' )<define_variables> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
print('Shape of the training data: ', train.shape)
print('Shape of the test data: ', test.shape ) | Digit Recognizer |
11,949,480 | model_2 = lgb.Booster(model_file='.. /input/lgbm-inference-db-full-data/lightgbm_v11.6.txt' )<predict_on_test> | train_df, valid_df = train_test_split(train, test_size = 0.2, random_state=SEED,stratify=train['label'] ) | Digit Recognizer |
11,949,480 | env = riiideducation.make_env()
iter_test = env.iter_test()
set_predict = env.predict<concatenate> | n_pixels = len(train_df.columns)- 1
class MNIST_Dataset(Dataset):
def __init__(self, df
):
if len(df.columns)== n_pixels:
self.X = df.values.reshape(( -1,28,28)).astype(np.uint8)[:,:,:,None]
self.y = None
self.X3 = np.full(( self.X.shape[0], 3, 28, 28), 0.0)
for i, s in enumerate(self.X):
self.X3[i] = np.moveaxis(c... | Digit Recognizer |
11,949,480 | previous_test_df = None
for(test_df, sample_prediction_df)in iter_test:
test_df = pd.concat([test_df.reset_index(drop=True),
questions_df.reindex(test_df['content_id'].values ).reset_index(drop=True)], axis=1)
test_df = pd.concat([test_df.reset_index(drop=True),
part_df.reindex(test_df['part'].values ).reset_index(dro... | train_dataset = MNIST_Dataset(train_df)
valid_dataset = MNIST_Dataset(valid_df)
test_dataset = MNIST_Dataset(test)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=BATCH_SIZE,
shuffle=True)
valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset,
batch_size=VALID_BATCH_SIZE, shu... | Digit Recognizer |
11,949,480 | env = riiideducation.make_env()
iter_test = env.iter_test()<import_modules> | def get_model(model_name='efficientnet-b0'):
model = EfficientNet.from_pretrained(model_name)
del model._fc
model._fc = nn.Linear(1280, NUM_CLASSES)
return model | Digit Recognizer |
11,949,480 | import sys
import numpy as np<set_options> | def set_seed(seed: int = 42):
random.seed(seed)
np.random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed ) | Digit Recognizer |
11,949,480 | warnings.filterwarnings("ignore")
<set_options> | set_seed(SEED)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
output_dir = OUTPUT_DIR
model = get_model(MODEL_NAME)
model = model.to(device)
optimizer = optim.Adam(model.parameters() , lr=0.001)
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)
loss_func = nn.CrossEntropyLoss(... | Digit Recognizer |
11,949,480 | device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
q_pad = 13523
a_pad = 3
start_token = 2<load_pretrained> | def prediction(model, data_loader):
model.eval()
test_pred = torch.LongTensor()
for i, data in enumerate(data_loader):
data = Variable(data, volatile=True)
if torch.cuda.is_available() :
data = data.type(torch.FloatTensor ).cuda()
output = model(data)
pred = output.cpu().data.max(1, keepdim=True)[1]
test_pred = torch... | Digit Recognizer |
11,949,480 | group = pd.read_pickle(".. /input/groups/group.pandas" )<categorify> | model.load_state_dict(torch.load("snapshot_epoch_{}.pth".format(best_epoch)))
test_pred = prediction(model, test_loader)
submission = pd.DataFrame(np.c_[np.arange(1, len(test_dataset)+1)[:,None], test_pred.numpy() ],
columns=['ImageId', 'Label'])
| Digit Recognizer |
11,949,480 | features_1_path = '.. /input/get-features-1/'
que_data = pd.read_pickle(features_1_path + "que_data.pickle")
difficulty =(np.round(que_data.que_correct_per, 1)*10 ).astype("int8" ).values
difficulty = torch.Tensor(difficulty ).long().to(device)
unique_tags = pd.concat([que_data.tags1,que_data.tags2, que_data.tags3, q... | submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
11,949,480 | st_user_info = {}
for i in user_info:
st_user_info[i] = {"timestamp_ms":user_info[i]["first_timestamp"]}
del user_info<categorify> | submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
11,953,506 | class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout=0.1, max_len=5000):
super(PositionalEncoding, self ).__init__()
self.dropout = nn.Dropout(p=dropout)
self.scale = nn.Parameter(torch.ones(1))
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float ).unsqueeze(1)... | import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import tensorflow as tf
from keras.utils import to_categorical
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import EarlyStopping | Digit Recognizer |
11,953,506 | class EmbedTag(nn.Module):
def __init__(self, d_model, que_arr, tags_n):
super(EmbedTag, self ).__init__()
self.que_arr = torch.LongTensor(que_arr ).to(device)
self.embedding = nn.Embedding(tags_n, d_model)
def forward(self, x):
x = self.que_arr[x, :]
x = self.embedding(x)
return torch.sum(x, dim=-2 )<categorify> | train_data = pd.read_csv('.. /input/digit-recognizer/train.csv')
test_data = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
11,953,506 | class TransformerModel(nn.Module):
def __init__(self, intoken, outtoken, hidden, que_arr, part_arr, difficulty, enc_layers=4, dec_layers=4, dropout=0.1, ts_unique=70, prior_unique=50):
super(TransformerModel, self ).__init__()
nhead = hidden//64
self.encoder = nn.Embedding(intoken, hidden)
self.pos_encoder = Positiona... | X_train = train_data.drop(labels = ["label"],axis = 1)
Y_train = train_data["label"]
Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
11,953,506 | d_model = 128
INPUT_DIM = q_pad+1
OUTPUT_DIM = 4
model_saint = TransformerModel(INPUT_DIM, OUTPUT_DIM, hidden=d_model, que_arr=que_arr,part_arr=part_valus, difficulty=difficulty ).to(device)
weights = torch.load(".. /input/last-saint/last.torch", map_location=torch.device(device))
model_saint.load_state_dict(weights)
... | X_train, X_test, Y_train, Y_test = train_test_split(X_train, Y_train, test_size = 0.2, random_state = 42 ) | Digit Recognizer |
11,953,506 | def pred_users(vals):
eval_batch = vals.shape[0]
tensor_question = np.zeros(( eval_batch, 100), dtype=np.long)
tensor_answers = np.zeros(( eval_batch, 100), dtype=np.long)
tensor_ts = np.zeros(( eval_batch, 100), dtype=np.long)
tensor_user_answer = np.zeros(( eval_batch, 100), dtype=np.long)
val_len = []
preds = []... | train_datagen = ImageDataGenerator(rescale = 1./255, shear_range = 0.2, zoom_range = 0.2 ) | Digit Recognizer |
11,953,506 | def split_preds(preds):
if preds.shape[0] > 1000:
ret = []
for i in np.array_split(preds, preds.shape[0]//1000):
ret.extend(pred_users(i))
return ret
else:
return pred_users(preds )<prepare_x_and_y> | test_datagen = ImageDataGenerator(rescale = 1./255 ) | Digit Recognizer |
11,953,506 | def update_group_var(vals):
global group
for i, line in enumerate(vals):
user_id = line[0]
question_id = line[1]
content_type_id = line[2]
ts = get_timestamp(line[4], user_id)
correct = line[6]
user_answer = line[7]
if content_type_id == True:
continue
if st_user_info.get(user_id, -1)== -1:
st_user_info[user_id] = {"t... | train = train_datagen.flow(X_train, Y_train, batch_size = 128 ) | Digit Recognizer |
11,953,506 | ordinal_enc = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 30: 21, 40: 22, 50: 23, 60: 24, 70: 25, 80: 26, 90: 27, 100: 28, 110: 29, 120: 30, 130: 31, 140: 32, 150: 33, 160: 34, 170: 35, 180: 36, 190: 37, 200: 38, 21... | test = test_datagen.flow(X_test, Y_test, batch_size = 128 ) | Digit Recognizer |
11,953,506 | prior_part_mean_dict = {1: 22166.159642501425,
2: 18714.69673913695,
3: 23620.317746179924,
4: 23762.753651169547,
5: 25094.620302855932,
6: 32417.37918735745,
7: 47444.16407400242}<load_pretrained> | callback = EarlyStopping(monitor='loss', patience=8, restore_best_weights=True ) | Digit Recognizer |
11,953,506 | with open('.. /input/lgbm-test/repeated_que_count', 'rb')as handle:
repeated_que_count = pickle.load(handle)
with open('.. /input/lgbm-test/user_info', 'rb')as handle:
user_info = pickle.load(handle)
with open('.. /input/lgbm-test/watched_tags', 'rb')as handle:
watched_tags = pickle.load(handle)
with open('.. /input... | cnn = tf.keras.models.Sequential() | Digit Recognizer |
11,953,506 | for u in user_info:
user_info[u]["count_2"] = user_info[u]["count"]
user_info[u]["part_count_2"] = user_info[u]["part_count"].copy()
user_info[u]["last_part"] = 1<init_hyperparams> | cnn.add(tf.keras.layers.Conv2D(filters = 32, kernel_size = 5, padding = 'same', activation = 'relu', input_shape = [28, 28, 1])) | Digit Recognizer |
11,953,506 | groups = pd.read_pickle(".. /input/lgbm-test/groups")
def numpy_ewma_vectorized_v2(data, window):
alpha = 2 /(window + 1.0)
alpha_rev = 1-alpha
n = data.shape[0]
pows = alpha_rev**(np.arange(n+1))
scale_arr = 1/pows[:-1]
offset = data[0]*pows[1:]
pw0 = alpha*alpha_rev**(n-1)
mult = data*pw0*scale_arr
cumsums = mult.... | cnn.add(tf.keras.layers.MaxPool2D(pool_size = 2, strides = 2, padding = 'valid')) | Digit Recognizer |
11,953,506 | features_1_path = '.. /input/get-features-1/'
que_data = pd.read_pickle(features_1_path + "que_data.pickle")
questions = que_data.drop(columns=["options_number","correctness_number", "correct_answer","tags6","tags5", "tags4"] ).to_dict("index")
questions1 = que_data[["tags1", "tags2", "tags3","tags4","tags5", "tags6"... | cnn.add(tf.keras.layers.Conv2D(filters = 64, kernel_size = 3, padding = 'same'))
cnn.add(tf.keras.layers.MaxPool2D(pool_size = 2, strides = 2, padding='valid')) | Digit Recognizer |
11,953,506 | lec_data = pd.read_csv(".. /input/riiid-test-answer-prediction/lectures.csv")
lec_dict = lec_data[["lecture_id", "tag"]].set_index("lecture_id" ).tag.to_dict()
features = [
'task_container_id', "ts_diff_shifted", "watched","ts_diff_shifted_2",
'content_id', "k", "k_acc", "el_avg", "wut",
'prior_question_elapsed_time',... | cnn.add(tf.keras.layers.MaxPool2D(pool_size = 2, strides = 2, padding='valid'))
cnn.add(Droupout(0.5)) | Digit Recognizer |
11,953,506 | stack_features = [
'task_container_id', "ts_diff_shifted", "watched","ts_diff_shifted_2",
'content_id', "k", "k_acc", "el_avg", "wut", "lgb_preds", "st_preds",
'prior_question_elapsed_time', "time_diff2", "rolling_mean_5", "rolling_mean_10", "rolling_mean_15", "prior_question_had_explanation_u_part_avg",
'prior_questio... | cnn.add(tf.keras.layers.Flatten() ) | Digit Recognizer |
11,953,506 | k_size = 20
cols = {test_cols[k]:k for k in range(len(test_cols)) }
features_dict = {features[k]:k for k in range(len(features)) }<init_hyperparams> | cnn.add(tf.keras.layers.Dense(units=256, activation='relu')) | Digit Recognizer |
11,953,506 | new_user = {'count': 0, 'mean_acc':0.5, 'correct_count': 0, 'last_lec':0, 'tmp':0,"first_timestamp":0, "second_timestamp":0,
"third_timestamp":0, "fourth_timestamp":0, "fifth_timestamp":0, "lecs_n":0,"interaction_n":0, "ts_diff_shifted":0.,
"part_corr":np.zeros(( 7), dtype=np.uint16), "part_count":np.zeros(( 7), dtype=... | cnn.add(tf.keras.layers.Dense(units=10, activation='softmax')) | Digit Recognizer |
11,953,506 | def get_meta_data(data_1):
user_id = data_1[cols['user_id']]
content_type_id = data_1[cols['content_type_id']]
content_id = data_1[cols['content_id']]
prior_group_answers_correct = data_1[cols['prior_group_answers_correct']]
timestamp = data_1[cols['timestamp']]
task_container_id = data_1[cols['task_container_id']]
pri... | cnn.compile(optimizer = 'adam', loss = 'categorical_crossentropy', metrics = ['accuracy'] ) | Digit Recognizer |
11,953,506 | def add_user(user_id):
user_info[user_id] = copy.deepcopy(new_user)
repeated_que_count[user_id] = {}
groups[user_id] = []<feature_engineering> | model = cnn.fit_generator(train, epochs = 100, validation_data = test, callbacks = [callback] ) | Digit Recognizer |
11,953,506 | def update_user_part_acc(user_id, question, answered_correctly, elapsed, explan):
part = parts.get(question, -1)
user_info[user_id]["part_count"][part-1] += 1
user_info[user_id]["part_corr"][part-1] += answered_correctly
if not isinstance(explan, pd._libs.missing.NAType)and explan == explan:
user_info[user_id]["had_ex... | cnn.evaluate(X_test,Y_test,verbose=2 ) | Digit Recognizer |
11,953,506 | def update_user(user_id, had_exp, elapsed, content_id ,answered_correctly, timestamp):
user_info[user_id]['count'] += 1
if repeated_que_count[user_id].get(content_id, -1)== -1:
repeated_que_count[user_id][content_id] = 1
else:
repeated_que_count[user_id][content_id] += 1
if answered_correctly:
user_info[user_id]['corre... | test_data /= 256
test_data = test_data.values.reshape(-1,28,28,1)
results = cnn.predict(test_data ) | Digit Recognizer |
11,953,506 | def update_lec_data(user_id, content_id):
if watched_tags.get(str(user_id), -1)== -1:
watched_tags[str(user_id)] = {}
if user_info.get(user_id, -1)== -1:
add_user(user_id)
user_info[user_id]["lecs_n"] += 1
lec_tag = lec_dict[content_id]
watched_tags[str(user_id)][str(lec_tag)] = 1
user_info[user_id]['last_lec'] = cont... | submission = pd.concat([pd.Series(range(1,28001),name = 'ImageId'),results],axis = 1 ) | Digit Recognizer |
11,953,506 | def non_lag_update(user_id, timestamp, elapsed, explan, lec):
timestamp = timestamp/8.64e+7
diff_timestamp_1 = timestamp - user_info[user_id]["first_timestamp"]
diff_timestamp_2 = timestamp - user_info[user_id]["second_timestamp"]
diff_timestamp_3 = timestamp - user_info[user_id]["third_timestamp"]
diff_timestamp_4 = t... | submission.to_csv('./submission.csv',index = False ) | Digit Recognizer |
11,914,085 | def update_data(prior_group_answers_correct):
global tmp_data
arr = np.array(ast.literal_eval(prior_group_answers_correct))
for i, line in enumerate(tmp_data):
user_id = line[cols['user_id']]
content_type_id = line[cols['content_type_id']]
content_id = line[cols['content_id']]
timestamp = line[cols['timestamp']]
task_c... | train=pd.read_csv("/kaggle/input/digit-recognizer/train.csv" ) | Digit Recognizer |
11,914,085 | tmp_data = []<define_variables> | test=pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,914,085 | def preprocess_1(chunk):
data_1 = chunk.values
out = np.zeros(( data_1.shape[0], len(features)))
batch_counts = data_1[:, [cols["user_id"],cols["content_type_id"]]]
batch_counts = Counter(batch_counts[batch_counts[:, 1] == False][:, 0])
global tmp_data
for i in range(data_1.shape[0]):
user_id, content_type_id, conten... | label=train["label"].values | Digit Recognizer |
11,914,085 | model_lgbm = lgb.Booster(model_file='.. /input/lgbm-test/lgb_classifier.txt')
stack_lgbm = lgb.Booster(model_file='.. /input/lgbm-test/lgb_stack.txt' )<define_variables> | train.drop("label",axis=1,inplace=True ) | Digit Recognizer |
11,914,085 | vals = 0<split> | t=train.values
ttest=test.values | Digit Recognizer |
11,914,085 | %%time
for(test_data,sample_prediction_df)in iter_test:
if not isinstance(vals, int):
if test_data.iloc[0].prior_group_answers_correct == test_data.iloc[0].prior_group_answers_correct:
past_vals = np.array(ast.literal_eval(test_data.iloc[0].prior_group_answers_correct))
past_answers = np.array(ast.literal_eval(test_dat... | t=t.astype('float32')
ttest=ttest.astype('float32' ) | Digit Recognizer |
11,914,085 | dicts_path = '/kaggle/input/agg-riiid/agg_riiid/'
user_content_id_agg = pd.read_pickle(dicts_path + 'user_content_id_agg.pkl.gzip')
user_content_id_agg['count'] = user_content_id_agg['count'].astype('int16' )<data_type_conversions> | t/=255
ttest/=255 | Digit Recognizer |
11,914,085 | user_content_id_count_dict = user_content_id_agg['count'].astype('int16' ).to_dict(defaultdict(int))<set_options> | tl = keras.utils.to_categorical(label, 10)
| Digit Recognizer |
11,914,085 | del user_content_id_agg
gc.collect()<import_modules> | input_shape =(28, 28, 1 ) | Digit Recognizer |
11,914,085 | import numpy as np
import lightgbm as lgb
import pickle
import riiideducation
import joblib<define_variables> | model = Sequential()
model.add(Conv2D(32,(3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=input_shape))
model.add(MaxPooling2D(( 2, 2)))
model.add(Dropout(0.2))
model.add(Conv2D(64,(3, 3), activation='relu', kernel_initializer='he_uniform', padding='same'))
model.add(MaxPooling2D... | Digit Recognizer |
11,914,085 | target = 'answered_correctly'<define_variables> | model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'] ) | Digit Recognizer |
11,914,085 | features = [
'content_id',
'prior_question_elapsed_time',
'prior_question_had_explanation',
'user_correctness',
'user_correctness_window_10_mean',
'part',
'content_count',
'content_sum',
'content_id_correctness_total',
'repeated_times',
'user_count_questions',
'explanation_mean_user',
'timestamp',
'timestamp_diff_last'... | np.random.seed(1234)
(x_train,x_test,y_train,y_test)= train_test_split(t,tl, train_size=0.75, random_state=1 ) | Digit Recognizer |
11,914,085 | dicts_path = '/kaggle/input/agg-riiid/agg_riiid/'
user_agg = pd.read_pickle(dicts_path + 'user_agg.pkl.gzip')
user_sum_dict = user_agg['sum'].astype('int32' ).to_dict(defaultdict(int))
user_count_dict = user_agg['count'].astype('int32' ).to_dict(defaultdict(int))
del user_agg
gc.collect()
content_agg = pd.read_pickle(... | model.fit(x_train, y_train,
batch_size=100,
epochs=400,
verbose=2,
validation_data=(x_test, y_test)) | Digit Recognizer |
11,914,085 | model_path = '/kaggle/input/trained-model/'
file = model_path + 'trained_model.pkl'
model = pickle.load(open(file, 'rb'))
print('Trained LGB model was loaded!' )<load_from_csv> | y_pred=model.predict(ttest,verbose=0 ) | Digit Recognizer |
11,914,085 | home_path = '/kaggle/input/riiid-test-answer-prediction/'
questions_df = pd.read_csv(home_path + 'questions.csv',
usecols=[0, 3, 4],
dtype={'question_id': 'int16', 'part': 'int8'}
)<data_type_conversions> | sample=pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
11,914,085 | questions_df['tags'].fillna('92', inplace=True)
questions_df['first_tag'] = questions_df['tags'].apply(lambda x: x.split() [0])
questions_df['first_tag'] = questions_df['first_tag'].astype('int16')
questions_df['second_tag'] = questions_df['tags'].apply(lambda x: x.split() [1] if len(x.split())> 1 else -1)
question... | pred = np.argmax(y_pred, axis = 1 ) | Digit Recognizer |
11,914,085 | lectures_df = pd.read_csv(home_path + 'lectures.csv',
dtype={'tag': 'int16', 'part': 'int8'}
)
type_of_dict = {'intention': 1, 'concept': 2, 'solving question': 3, 'starter': 4}
lectures_df['type_of'] = lectures_df['type_of'].map(type_of_dict )<import_modules> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),r],axis = 1 ) | Digit Recognizer |
11,914,085 | import random
from tqdm.notebook import tqdm
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader<load_pretrained> | submission.to_csv("mnist4.csv",index=False ) | Digit Recognizer |
11,650,794 | skills = joblib.load("/kaggle/input/skills-pkl/skills.pkl.zip")
n_skill = len(skills)
group = joblib.load("/kaggle/input/group-pkl/group.pkl.zip")
del joblib
gc.collect()<define_variables> | np.random.seed(1)
| Digit Recognizer |
11,650,794 | MAX_SEQ = 180
ACCEPTED_USER_CONTENT_SIZE = 4
EMBED_SIZE = 128
BATCH_SIZE = 64
DROPOUT = 0.1<choose_model_class> | X_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
X_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
print('Shape of the training data: ', X_train.shape)
print('Shape of the test data: ', X_test.shape ) | Digit Recognizer |
11,650,794 | class FFN(nn.Module):
def __init__(self, state_size = 200, forward_expansion = 1, bn_size=MAX_SEQ - 1, dropout=0.2):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, forward_expansion * state_size)
self.relu = nn.ReLU()
self.bn = nn.BatchNorm1d(bn_size)
self.lr2 = nn.Linear(f... | y_train = X_train['label']
X_train.drop(labels = ['label'], axis=1, inplace=True ) | Digit Recognizer |
11,650,794 | def future_mask(seq_length):
future_mask =(np.triu(np.ones([seq_length, seq_length]), k = 1)).astype('bool')
return torch.from_numpy(future_mask)
future_mask(5 )<choose_model_class> | y_train = to_categorical(y_train, num_classes=10)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.1 ) | Digit Recognizer |
11,650,794 | class TransformerBlock(nn.Module):
def __init__(self, embed_dim, heads = 8, dropout = DROPOUT, forward_expansion = 1):
super(TransformerBlock, self ).__init__()
self.multi_att = nn.MultiheadAttention(embed_dim=embed_dim, num_heads=heads, dropout=dropout)
self.dropout = nn.Dropout(dropout)
self.layer_normal = nn.Layer... | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 64, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 128, ... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.