kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,858,410 | MAX_SEQ = 100
n_part = 7
D_MODEL = 256
N_LAYER = 2
DROPOUT = 0.1<feature_engineering> | X_train,Y_train=read_csv(".. /input/train.csv")
X_test,_=read_csv(".. /input/test.csv")
m,pixels=X_train.shape
classes=10
height,width,channels=28,28,1
X_train, X_test=X_train/255, X_test/255
X_train=X_train.reshape(-1,height,width,channels)
X_test=X_test.reshape(-1,height,width,channels)
print(Y_train.shape,X_trai... | Digit Recognizer |
2,858,410 | def feature_time_lag(df, time_dict):
tt = np.zeros(len(df), dtype=np.int64)
for ind, row in enumerate(df[['user_id','timestamp','task_container_id']].values):
if row[0] in time_dict.keys() :
if row[2]-time_dict[row[0]][1] == 0:
tt[ind] = time_dict[row[0]][2]
else:
t_last = time_dict[row[0]][0]
task_ind_last = time_dic... | def DigitalRecognizerModel(input_shape):
X_input = Input(input_shape)
X=Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same', activation ='relu', input_shape =(28,28,1))(X_input)
X=Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same', activation ='relu' )(X)
X=MaxPooling2D(pool_size=(2,2))(X)
X=Dropout(0.... | Digit Recognizer |
2,858,410 | 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(DROPOUT)
def forward(self, x):
x = self.lr1(x)
x = self.relu(x... | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
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_t... | Digit Recognizer |
2,858,410 | n_skill = 13523
group = joblib.load(".. /input/saint-plus-data-new/group_20210102.pkl.zip")
questions_df = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/questions.csv')
time_dict = joblib.load(".. /input/saint-plus-data-new/time_dict.pkl.zip" )<load_pretrained> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
2,858,410 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model1 = SAINTModel(n_skill, n_part, embed_dim= D_MODEL)
try:
model1.load_state_dict(torch.load(".. /input/saint-plus-model/saint_plus_model_20210102_padding_v2.pt"))
except:
model1.load_state_dict(torch.load(".. /input/saint-plus-model/saint_plus_... | digitalRecognizerModel = DigitalRecognizerModel(X_train[0].shape)
digitalRecognizerModel.compile(optimizer = "Adam", loss = "binary_crossentropy", metrics = ["accuracy"])
history = digitalRecognizerModel.fit_generator(datagen.flow(X_train,Y_train, batch_size=62),
epochs = 30, validation_data =(X_val,Y_val),
verbose =... | Digit Recognizer |
2,858,410 | <define_variables><EOS> | print("Time Start:" ,time.time())
val_predictions=digitalRecognizerModel.predict(X_val)
correct_val_predictions=np.mean(np.equal(np.argmax(val_predictions,axis=1), np.argmax(Y_val,axis=1)))
print("Validation Accuracy",correct_val_predictions)
test_predictions=digitalRecognizerModel.predict(X_test)
correct_test_pre... | Digit Recognizer |
594,887 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_pretrained> | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
594,887 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model2 = SAINTModel(n_skill, n_part, embed_dim= D_MODEL)
try:
model2.load_state_dict(torch.load(".. /input/saint-plus-model/saint_plus_model_20210103.pt_v2"))
except:
model2.load_state_dict(torch.load(".. /input/saint-plus-model/saint_plus_model_20... | from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.utils import np_utils
from keras.optimizers import RMSprop
from keras.callbacks import ReduceLROnPlateau
from keras.preprocessing.image import ImageDataGenerator
im... | Digit Recognizer |
594,887 | lt_correct_dict = pickle.load(open('.. /input/arvis-feature/last_timestamp_correct.pkl', 'rb'))
np_uq_td = pickle.load(open(".. /input/uq-data/np_uq_td_0518.pkl.data","rb"))
curr_u_dict = pickle.load(open(".. /input/uq-data/curr_u_dict_0614_only_user_three_time_diff.pkl.data","rb"))
max_timestamp_u_dict = pickle.load(o... | df_train_x = df_train.iloc[:,1:]
df_train_y = df_train.iloc[:,:1] | Digit Recognizer |
594,887 | def add_uq_feats_and_update(df):
conn = sqlite3.connect('user_ques_db.db')
cursor = conn.cursor()
global idx
uq_timediff = np.zeros(len(df), dtype=np.uint64)
for cnt,row in enumerate(df[['user_id','content_id','timestamp']].itertuples(index=False)) :
cursor.execute(f'select idx from user where user_id = {row[0]} and ... | def cnn_model(result_class_size):
model = Sequential()
model.add(Conv2D(32,(5, 5), input_shape=(28,28,1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(16,(3, 3), activation='relu'))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(130, activation='relu'))
model.add(Dense(... | Digit Recognizer |
594,887 | def add_user_feats_without_update(df):
utdiff = np.zeros(len(df), dtype=np.uint64)
utdiff_mean = np.zeros(len(df), dtype=np.uint64)
uelapdiff = np.zeros(len(df), dtype=np.float32)
for cnt,row in enumerate(df[['user_id','timestamp','prior_question_elapsed_time']].itertuples(index=False)) :
if row[0] in curr_u_dict:
u... | df_test = df_test / 255
df_train_x = df_train_x / 255 | Digit Recognizer |
594,887 | def add_user_feats(df):
utdiff = np.zeros(len(df), dtype=np.uint64)
utdiff_mean = np.zeros(len(df), dtype=np.uint64)
uelapdiff = np.zeros(len(df), dtype=np.float32)
for cnt,row in enumerate(tqdm(df[['user_id','content_id','answered_correctly',
'timestamp','prior_question_elapsed_time',
]].itertuples(index=False),tot... | arr_train_x_28x28 = np.reshape(df_train_x.values,(df_train_x.values.shape[0], 28, 28, 1))
arr_test_x_28x28 = np.reshape(df_test.values,(df_test.values.shape[0], 28, 28, 1)) | Digit Recognizer |
594,887 | def lagtime_for_test(df):
lagtime_mean = 0
lagtime_mean2 = 0
lagtime_mean3 = 0
lagtime = np.zeros(len(df), dtype=np.float32)
lagtime2 = np.zeros(len(df), dtype=np.float32)
lagtime3 = np.zeros(len(df), dtype=np.float32)
for i,(user_id,
content_type_id,
timestamp,
content_id,)in enumerate(zip(df['user_id'].values, df[... | random_seed = 3
split_train_x, split_val_x, split_train_y, split_val_y, = train_test_split(arr_train_x_28x28, arr_train_y, test_size = 0.08, random_state=random_seed ) | Digit Recognizer |
594,887 | def add_feats(df_np, feat_dict, col_idx, col_feat):
current_feat_value = np.zeros(len(df_np))
for cnt, row in enumerate(df_np[:,[col_idx, col_feat]]):
current_feat_value[cnt] = feat_dict[row[0]]
feat_dict[row[0]] += row[1]
df_np[:, col_feat] = current_feat_value
return df_np
def add_feats_from_dict(df_np, feat_dict, ... | reduce_lr = ReduceLROnPlateau(monitor='val_acc',
factor=0.5,
patience=3,
min_lr=0.00001 ) | Digit Recognizer |
594,887 | question_part_map = {
'part_-100_count' : 0,
'part_-100_count_correct' : 1,
'part_-100_accuracy' : 2,
'part_1_count' : 3,
'part_1_count_correct' : 4,
'part_1_accuracy' : 5,
'part_2_count' : 6,
'part_2_count_correct' : 7,
'part_2_accuracy' : 8,
'part_3_count' : 9,
'part_3_count_correct' : 10,
'part_3_accuracy' : 11,
'pa... | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1
)
datagen.fit(split_train_x ) | Digit Recognizer |
594,887 | def load_obj(name):
with open('.. /input/riiid-numpy-df-3/' + name + '.pkl', 'rb')as f:
return pickle.load(f )<load_pretrained> | model.fit_generator(datagen.flow(split_train_x,split_train_y, batch_size=64),
epochs = 30, validation_data =(split_val_x,split_val_y),
verbose = 2, steps_per_epoch=700
, callbacks=[reduce_lr] ) | Digit Recognizer |
594,887 | cat_model = CatBoostClassifier()
cat_model.load_model('.. /input/riiid-lgb-v1/cat_arvis_v4.cbm')
lgb_model = lgb.Booster(model_file='.. /input/riiid-lgb-v1/model_lgb_7946_v8_full_data_arvis.txt' )<load_pretrained> | prediction = model.predict_classes(arr_test_x_28x28, verbose=0)
data_to_submit = pd.DataFrame({"ImageId": list(range(1,len(prediction)+1)) , "Label": prediction})
data_to_submit.to_csv("result.csv", header=True, index = False ) | Digit Recognizer |
594,887 | dict_lectures = load_obj('dict_lectures')
dict_questions = load_obj('dict_questions')
dict_question_user_cnt = load_obj('dict_question_user_cnt')
dict_correct_answers_user_cnt = load_obj('dict_correct_answers_user_cnt')
dict_question_explonation_user_cnt = load_obj('dict_question_explonation_user_cnt')
dict_questi... | start_idx = randrange(df_test.shape[0]-10 ) | Digit Recognizer |
10,242,261 | features_map = {
'row_id' : 0,
'timestamp' : 1,
'user_id' : 2,
'content_id' : 3,
'content_type_id' : 4,
'task_container_id' : 5,
'prior_question_elapsed_time' : 6,
'prior_question_had_explanation' : 7,
'prior_group_answers_correct' : 8,
'prior_group_responses' : 9,
'prior_question_1_timedelta_min' : 10,
'prior_lecture_... | df_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
10,242,261 | idx = 86867031<split> | x_train = np.array(df_train.iloc[:,1:])
x_train = np.array([np.reshape(i,(28, 28, 1)) for i in x_train])
y_train = np.array(df_train.iloc[:,0] ) | Digit Recognizer |
10,242,261 | env = riiideducation.make_env()
iter_test = env.iter_test()<feature_engineering> | x_train = x_train/255.0
y_train = keras.utils.to_categorical(y_train ) | Digit Recognizer |
10,242,261 | previous_test_df = pd.DataFrame()
prev_test_df = None
for(test_df, sample_prediction_df)in iter_test:
test_df_saint = test_df.copy()
if(prev_test_df is not None)&(psutil.virtual_memory().percent < 90):
prev_test_df['answered_correctly'] = eval(test_df['prior_group_answers_correct'].iloc[0])
prev_test_df = prev_test_df... | x_test = np.array(df_test)
x_test = np.array([np.reshape(i,(28, 28, 1)) for i in x_test])
x_test = x_test/255.0 | Digit Recognizer |
10,242,261 | import torch
import pandas as pd
from saintmodel import SaintModel, SaintLightningModule, SaintHistory
from saintsubmit import load_saint_config, SaintPredictor, make_submission<choose_model_class> | X_train, X_test, Y_train, Y_test = train_test_split(x_train, y_train, test_size=0.2, stratify=y_train ) | Digit Recognizer |
10,242,261 | args = load_saint_config()
model = SaintModel(
seq_len=args.seq_len, n_dim=args.n_dim, std=args.std, dropout=args.dropout, nhead=args.nhead, n_layers=args.n_layers
)
module = SaintLightningModule(args, model )<load_pretrained> | model = keras.models.Sequential()
model.add(keras.layers.Conv2D(filters=32, kernel_size=(3,3), kernel_initializer='random_uniform', padding='same', activation='relu', input_shape=(X_train.shape[1:])))
model.add(keras.layers.Conv2D(filters=32, kernel_size=(3,3), kernel_initializer='random_uniform', padding='same', acti... | Digit Recognizer |
10,242,261 | %%time
module.load_state_dict(torch.load('/kaggle/input/riiid-saintp-solution/saint.ckpt')['state_dict'] )<load_pretrained> | es = EarlyStopping(monitor='loss', mode='min', verbose=1, patience=5)
filepath = "model.h5"
ckpt = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
rlp = ReduceLROnPlateau(monitor='loss', patience=2, factor=0.2 ) | Digit Recognizer |
10,242,261 | %%time
last_history = pd.read_pickle('/kaggle/input/riiid-saintp-solution/last_history.pickle')
last_timestamp = pd.read_pickle('/kaggle/input/riiid-saintp-solution/last_timestamp.pickle')
last_user_count = pd.read_pickle('/kaggle/input/riiid-saintp-solution/last_user_count.pickle')
dict_lag = pd.read_pickle('/kaggl... | history = model.fit(X_train, Y_train, batch_size=500, callbacks=[es, ckpt, rlp], epochs=100, validation_data=(X_test,Y_test)) | Digit Recognizer |
10,242,261 | device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
module.to(device )<choose_model_class> | id_img = []
label = []
for i in range(len(x_test)) :
id_img.append(i+1)
label.append(np.argmax(model.predict(x_test[i:i+1])))
img_id = np.array(id_img)
label = np.array(label ) | Digit Recognizer |
10,242,261 | <set_options><EOS> | op_df = pd.DataFrame()
op_df['ImageId'] = img_id
op_df['Label'] = label
op_df.to_csv("submission.csv", index=False ) | Digit Recognizer |
9,870,532 | <compute_test_metric><EOS> | decay=1e-4
xtrain = []
ytrain = []
xtest = []
xval = []
yval = []
for dirname, _, filenames in os.walk('/kaggle/input/digit-recognizer/'):
for filename in filenames:
print(os.path.join(dirname, filename))
train =pd.read_csv(os.path.join(dirname,'train.csv'))
test =pd.read_csv(os.path.join(dirname,'test.csv'))
sample_su... | Digit Recognizer |
9,011,532 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<install_modules> | import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt | Digit Recognizer |
9,011,532 | !pip install.. /input/python-datatable/datatable-0.11.0-cp37-cp37m-manylinux2010_x86_64.whl > /dev/null 2>&1<import_modules> | df = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
df.shape | Digit Recognizer |
9,011,532 | import numpy as np
import random
import pandas as pd
import joblib<set_options> | train_data = train_data.to_numpy()
train_labels = train_labels.to_numpy() | Digit Recognizer |
9,011,532 | _ = np.seterr(divide='ignore', invalid='ignore' )<define_variables> | train_data = train_data / 255 | Digit Recognizer |
9,011,532 | data_types_dict = {
'timestamp': 'int64',
'user_id': 'int32',
'content_id': 'int16',
'content_type_id':'int8',
'task_container_id': 'int16',
'answered_correctly': 'int8',
'prior_question_elapsed_time': 'float32',
'prior_question_had_explanation': 'bool'
}
target = 'answered_correctly'<load_from_csv> | filters = 64
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(filters=filters, kernel_size=(3,3), activation=tf.nn.relu),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Conv2D(filters=filters, kernel_size=(3,3), activation=tf.nn.relu),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Conv2D(filters=fi... | Digit Recognizer |
9,011,532 | print('start read train data...')
train_df = dt.fread('.. /input/riiid-test-answer-prediction/train.csv', columns=set(data_types_dict.keys())).to_pandas()<train_model> | history = model.fit(train_data, train_labels, epochs=40, batch_size=32, verbose=0 ) | Digit Recognizer |
9,011,532 | print('start handle lecture data...' )<load_from_csv> | df_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
df_test.shape | Digit Recognizer |
9,011,532 | lectures_df = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/lectures.csv' )<categorify> | test_data = df_test.to_numpy()
test_data = test_data / 255
test_data = test_data.reshape(( test_data.shape[0], 28, 28, 1))
test_data.shape | Digit Recognizer |
9,011,532 | lectures_df['type_of'] = lectures_df['type_of'].replace('solving question', 'solving_question')
lectures_df = pd.get_dummies(lectures_df, columns=['part', 'type_of'])
part_lectures_columns = [column for column in lectures_df.columns if column.startswith('part')]
types_of_lectures_columns = [column for column in lectu... | predictions = model.predict(test_data)
predictions = np.asarray([np.argmax(prediction)for prediction in predictions])
predictions.shape | Digit Recognizer |
9,011,532 | train_lectures = train_df[train_df.content_type_id == True].merge(lectures_df, left_on='content_id', right_on='lecture_id', how='left' )<groupby> | df_predictions = pd.DataFrame(predictions ).rename(columns={0: "Label"})
df_predictions.index.names = ['ImageId']
df_predictions.index += 1
df_predictions.head() | Digit Recognizer |
9,011,532 | user_lecture_stats_part = train_lectures.groupby('user_id',as_index = False)[part_lectures_columns + types_of_lectures_columns].sum()<data_type_conversions> | df_predictions.shape
df_predictions.to_csv("predictions.csv" ) | Digit Recognizer |
9,011,532 | lecturedata_types_dict = {
'user_id': 'int32',
'part_1': 'int8',
'part_2': 'int8',
'part_3': 'int8',
'part_4': 'int8',
'part_5': 'int8',
'part_6': 'int8',
'part_7': 'int8',
'type_of_concept': 'int8',
'type_of_intention': 'int8',
'type_of_solving_question': 'int8',
'type_of_starter': 'int8'
}
user_lecture_stats_part = u... | import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt | Digit Recognizer |
9,011,532 | for column in user_lecture_stats_part.columns:
if(column !='user_id'):
user_lecture_stats_part[column] =(user_lecture_stats_part[column] > 0 ).astype('int8' )<drop_column> | df = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
df.shape | Digit Recognizer |
9,011,532 | del(train_lectures)
gc.collect()<categorify> | train_data = train_data.to_numpy()
train_labels = train_labels.to_numpy() | Digit Recognizer |
9,011,532 | user_lecture_agg = train_df.groupby('user_id')['content_type_id'].agg(['sum', 'count'])
user_lecture_agg=user_lecture_agg.astype('int16' )<data_type_conversions> | train_data = train_data / 255 | Digit Recognizer |
9,011,532 | cum = train_df.groupby('user_id')['content_type_id'].agg(['cumsum', 'cumcount'])
cum['cumcount']=cum['cumcount']+1
train_df['user_interaction_count'] = cum['cumcount']
train_df['user_interaction_timestamp_mean'] = train_df['timestamp']/cum['cumcount']
train_df['user_lecture_sum'] = cum['cumsum']
train_df['user_lecture... | filters = 64
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(filters=filters, kernel_size=(3,3), activation=tf.nn.relu),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Conv2D(filters=filters, kernel_size=(3,3), activation=tf.nn.relu),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Conv2D(filters=fi... | Digit Recognizer |
9,011,532 | del cum
gc.collect()<train_model> | history = model.fit(train_data, train_labels, epochs=40, batch_size=32, verbose=0 ) | Digit Recognizer |
9,011,532 | print('start handle train_df...' )<data_type_conversions> | df_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
df_test.shape | Digit Recognizer |
9,011,532 | train_df['prior_question_had_explanation'].fillna(False, inplace=True)
train_df = train_df.astype(data_types_dict)
train_df = train_df[train_df[target] != -1].reset_index(drop=True )<groupby> | test_data = df_test.to_numpy()
test_data = test_data / 255
test_data = test_data.reshape(( test_data.shape[0], 28, 28, 1))
test_data.shape | Digit Recognizer |
9,011,532 | content_explation_agg=train_df[["content_id","prior_question_had_explanation",target]].groupby(["content_id","prior_question_had_explanation"])[target].agg(['mean'] )<rename_columns> | predictions = model.predict(test_data)
predictions = np.asarray([np.argmax(prediction)for prediction in predictions])
predictions.shape | Digit Recognizer |
9,011,532 | content_explation_agg=content_explation_agg.unstack()
content_explation_agg=content_explation_agg.reset_index()
content_explation_agg.columns = ['content_id', 'content_explation_false_mean','content_explation_true_mean']<data_type_conversions> | df_predictions = pd.DataFrame(predictions ).rename(columns={0: "Label"})
df_predictions.index.names = ['ImageId']
df_predictions.index += 1
df_predictions.head() | Digit Recognizer |
9,011,532 | content_explation_agg.content_id=content_explation_agg.content_id.astype('int16')
content_explation_agg.content_explation_false_mean=content_explation_agg.content_explation_false_mean.astype('float16')
content_explation_agg.content_explation_true_mean=content_explation_agg.content_explation_true_mean.astype('float16'... | df_predictions.shape
df_predictions.to_csv("predictions.csv" ) | Digit Recognizer |
9,999,514 | print('start handle attempt_no...' )<data_type_conversions> | train=pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test=pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
train.head() | Digit Recognizer |
9,999,514 | train_df["attempt_no"] = 1
train_df.attempt_no=train_df.attempt_no.astype('int8')
attempt_no_agg=train_df.groupby(["user_id","content_id"])["attempt_no"].agg(['sum'] ).astype('int8')
train_df["attempt_no"] = train_df[["user_id","content_id",'attempt_no']].groupby(["user_id","content_id"])["attempt_no"].cumsum()<data_... | X_train=train.drop("label", axis=1)
y_train=train["label"]
X_test=test | Digit Recognizer |
9,999,514 | print('start handle timestamp...')
prior_question_elapsed_time_mean=train_df['prior_question_elapsed_time'].mean()
train_df['prior_question_elapsed_time'].fillna(prior_question_elapsed_time_mean, inplace=True )<data_type_conversions> | X_train/=255.0
X_test/=255.0
X_train=X_train.values.reshape(-1,28,28,1)
X_test=X_test.values.reshape(-1,28,28,1)
y_train=to_categorical(y_train, num_classes=10 ) | Digit Recognizer |
9,999,514 | max_timestamp_u = train_df[['user_id','timestamp']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u.columns = ['user_id', 'max_time_stamp']
max_timestamp_u.user_id=max_timestamp_u.user_id.astype('int32' )<data_type_conversions> | X_train, x_test, Y_train, y_test= train_test_split(X_train,y_train,test_size=0.1,random_state=0 ) | Digit Recognizer |
9,999,514 | train_df['lagtime'] = train_df.groupby('user_id')['timestamp'].shift()
max_timestamp_u2 = train_df[['user_id','lagtime']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u2.columns = ['user_id', 'max_time_stamp2']
max_timestamp_u2.user_id=max_timestamp_u2.user_id.astype('int32' )<feature_engineering> | classifier=Sequential()
classifier.add(Conv2D(64,3,3, input_shape=(28,28,1), activation='relu'))
classifier.add(BatchNormalization())
classifier.add(Conv2D(64,3,3, activation='relu'))
classifier.add(BatchNormalization())
classifier.add(Conv2D(64,3,3, activation='relu'))
classifier.add(BatchNormalization())
classifie... | Digit Recognizer |
9,999,514 | train_df['lagtime']=train_df['timestamp']-train_df['lagtime']
lagtime_mean=train_df['lagtime'].mean()
train_df['lagtime'].fillna(lagtime_mean, inplace=True )<data_type_conversions> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
9,999,514 | train_df['lagtime']=train_df['lagtime']/(1000*3600)
train_df.lagtime=train_df.lagtime.astype('float32' )<data_type_conversions> | classifier.compile(optimizer=optimizer, loss='categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
9,999,514 |
<data_type_conversions> | datagen = ImageDataGenerator(zoom_range = 0.1,
height_shift_range = 0.1,
width_shift_range = 0.1,
rotation_range = 10 ) | Digit Recognizer |
9,999,514 | train_df['lagtime2'] = train_df.groupby('user_id')['timestamp'].shift(2)
max_timestamp_u3 = train_df[['user_id','lagtime2']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u3.columns = ['user_id', 'max_time_stamp3']
max_timestamp_u3.user_id=max_timestamp_u3.user_id.astype('int32')
train_df['lagtime2'... | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x ) | Digit Recognizer |
9,999,514 | train_df['lagtime2']=train_df['lagtime2']/(1000*3600)
train_df.lagtime2=train_df.lagtime2.astype('float32' )<data_type_conversions> | classifier.fit_generator(datagen.flow(X_train, Y_train, batch_size=16),
steps_per_epoch=500,
epochs=40,
verbose=2,
validation_data=(x_test[:400,:], y_test[:400,:]),
callbacks=[annealer] ) | Digit Recognizer |
9,999,514 | train_df['lagtime3'] = train_df.groupby('user_id')['timestamp'].shift(3)
train_df['lagtime3']=train_df['timestamp']-train_df['lagtime3']
lagtime_mean3=train_df['lagtime3'].mean()
train_df['lagtime3'].fillna(lagtime_mean3, inplace=True)
train_df['lagtime3']=train_df['lagtime3']/(1000*3600)
train_df.lagtime3=train_df.... | result=classifier.predict(X_test)
result=pd.Series(np.argmax(result, axis=1), name='Label')
result | Digit Recognizer |
9,999,514 |
<data_type_conversions> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),result],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
11,220,007 | train_df['timestamp']=train_df['timestamp']/(1000*3600)
train_df.timestamp=train_df.timestamp.astype('float16' )<feature_engineering> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
x_test = pd.read_csv('.. /input/digit-recognizer/test.csv')
train.head() | Digit Recognizer |
11,220,007 | train_df['delta_prior_question_elapsed_time'] = train_df.groupby('user_id')['prior_question_elapsed_time'].shift()
train_df['delta_prior_question_elapsed_time']=train_df['prior_question_elapsed_time']-train_df['delta_prior_question_elapsed_time']<data_type_conversions> | x_train = x_train.to_numpy()
x_test = x_test.to_numpy()
y_train = y_train.to_numpy() | Digit Recognizer |
11,220,007 | delta_prior_question_elapsed_time_mean=train_df['delta_prior_question_elapsed_time'].mean()
train_df['delta_prior_question_elapsed_time'].fillna(delta_prior_question_elapsed_time_mean, inplace=True)
train_df.delta_prior_question_elapsed_time=train_df.delta_prior_question_elapsed_time.astype('int32' )<data_type_convers... | x_train = x_train.reshape(-1,28,28)
x_test = x_test.reshape(-1,28,28)
print("(Image)Train Inputs: " , x_train.shape)
print("(Image)Test Inputs: " , x_test.shape ) | Digit Recognizer |
11,220,007 | train_df['lag'] = train_df.groupby('user_id')[target].shift()
cum = train_df.groupby('user_id')['lag'].agg(['cumsum', 'cumcount'])
user_agg = train_df.groupby('user_id')['lag'].agg(['sum', 'count'] ).astype('int16')
cum['cumsum'].fillna(0, inplace=True)
train_df['user_correctness'] = cum['cumsum'] / cum['cumcount']
... | def sharpner(img):
img = Image.fromarray(img.astype('uint8'))
img = img.filter(ImageFilter.UnsharpMask(radius=2, percent=150))
return np.array(img)
for i in range(x_train.shape[0]):
x_train[i] = sharpner(x_train[i])
for i in range(x_test.shape[0]):
x_test[i] = sharpner(x_test[i])
print(x_train.shape)
print(x_test.s... | Digit Recognizer |
11,220,007 | del cum
gc.collect()<data_type_conversions> | def one_hottie(labels,C):
One_hot_matrix = tf.one_hot(labels,C)
return tf.keras.backend.eval(One_hot_matrix)
y_train = one_hottie(y_train, 10)
print("Y shape: " + str(y_train.shape)) | Digit Recognizer |
11,220,007 |
<data_type_conversions> | model = tf.keras.Sequential([
tf.keras.layers.Conv2D(64, 3, activation='relu', input_shape=(28,28,1),padding="same"),
tf.keras.layers.MaxPool2D(strides=2),
tf.keras.layers.Conv2D(128, 3, activation='relu',padding="same"),
tf.keras.layers.MaxPool2D(strides=2),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Conv2D(256, 3,... | Digit Recognizer |
11,220,007 | train_df.prior_question_had_explanation=train_df.prior_question_had_explanation.astype('int8')
explanation_agg = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['sum', 'count'])
explanation_agg=explanation_agg.astype('int16')
<data_type_conversions> | model.compile(optimizer='adam', loss=tf.keras.losses.CategoricalCrossentropy() , metrics=['accuracy'] ) | Digit Recognizer |
11,220,007 | cum = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['cumsum', 'cumcount'])
cum['cumcount']=cum['cumcount']+1
train_df['explanation_mean'] = cum['cumsum'] / cum['cumcount']
train_df['explanation_true_count'] = cum['cumsum']
train_df['explanation_false_count'] = cum['cumcount']-cum['cumsum']
train_d... | datagen = tf.keras.preprocessing.image.ImageDataGenerator(
rotation_range=45,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
fill_mode='nearest')
datagen.fit(x_train)
result = model.fit_generator(datagen.flow(x_train, y_train,
batch_size=64),
epochs=50,
workers=4 ) | Digit Recognizer |
11,220,007 | del cum
gc.collect()<categorify> | model.compile(optimizer=tf.keras.optimizers.Nadam(learning_rate=0.006),
loss=tf.keras.losses.CategoricalCrossentropy() ,
metrics=['accuracy'])
| Digit Recognizer |
11,220,007 | content_agg = train_df.groupby('content_id')[target].agg(['sum', 'count','var'])
task_container_agg = train_df.groupby('task_container_id')[target].agg(['sum', 'count','var'])
content_agg=content_agg.astype('float32')
task_container_agg=task_container_agg.astype('float32' )<data_type_conversions> | result = model.fit(x=x_train,
y=y_train,
batch_size=64,
epochs=50,
verbose=1,
shuffle=False,
initial_epoch=20,
validation_split=0.2 ) | Digit Recognizer |
11,220,007 | train_df['task_container_uncor_count'] = train_df['task_container_id'].map(task_container_agg['count']-task_container_agg['sum'] ).astype('int32')
train_df['task_container_cor_count'] = train_df['task_container_id'].map(task_container_agg['sum'] ).astype('int32')
train_df['task_container_std'] = train_df['task_contai... | model.compile(optimizer=tf.keras.optimizers.Nadam(learning_rate=0.0001),
loss=tf.keras.losses.CategoricalCrossentropy() ,
metrics=['accuracy'] ) | Digit Recognizer |
11,220,007 | content_elapsed_time_agg=train_df.groupby('content_id')['prior_question_elapsed_time'].agg(['mean'])
content_had_explanation_agg=train_df.groupby('content_id')['prior_question_had_explanation'].agg(['mean'] )<train_model> | result = model.fit(x=x_train,
y=y_train,
batch_size=64,
epochs=50,
verbose=1,
shuffle=False,
initial_epoch=20,
validation_split=0.2 ) | Digit Recognizer |
11,220,007 | print('start questions data...' )<load_from_csv> | model.compile(optimizer=tf.keras.optimizers.Nadam(learning_rate=0.00006),
loss=tf.keras.losses.CategoricalCrossentropy() ,
metrics=['accuracy'] ) | Digit Recognizer |
11,220,007 | questions_df = pd.read_csv(
'.. /input/riiid-test-answer-prediction/questions.csv',
usecols=[0, 1,3,4],
dtype={'question_id': 'int16','bundle_id': 'int16', 'part': 'int8','tags': 'str'}
)<groupby> | result = model.fit(x=x_train,
y=y_train,batch_size=64,
epochs=90,
verbose=1,
shuffle=False,
initial_epoch=50,
validation_split=0.2 ) | Digit Recognizer |
11,220,007 | bundle_agg = questions_df.groupby('bundle_id')['question_id'].agg(['count'] )<data_type_conversions> | check = model.evaluate(x_train,y_train ) | Digit Recognizer |
11,220,007 | questions_df['content_sub_bundle'] = questions_df['bundle_id'].map(bundle_agg['count'] ).astype('int8' )<set_options> | preds = model.predict_classes(x_train)
preds.shape | Digit Recognizer |
11,220,007 | questions_df['tags'].fillna('188', inplace=True )<string_transform> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
y_train = train.iloc[:,0]
y_train = y_train.to_numpy() | Digit Recognizer |
11,220,007 | def gettags(tags,num):
tags_splits=tags.split(" ")
result=''
for t in tags_splits:
x=int(t)
if(x<32*(num+1)and x>=32*num):
result=result+' '+t
return result<categorify> | preds = model.predict_classes(x_test ) | Digit Recognizer |
11,220,007 | for num in range(0,6):
questions_df["tags"+str(num)] = questions_df["tags"].apply(lambda row: gettags(row,num))
le = LabelEncoder()
le.fit(np.unique(questions_df['tags'+str(num)].values))
questions_df['tags'+str(num)]=questions_df[['tags'+str(num)]].apply(le.transform )<data_type_conversions> | arr = [x for x in range(1,28001)]
label = pd.DataFrame(arr,columns = ["ImageId"])
label["Label"] = pd.DataFrame(preds)
label.head() | Digit Recognizer |
11,220,007 | questions_df_dict = {
'tags0': 'int8',
'tags1': 'int8',
'tags2': 'int8',
'tags3': 'int8',
'tags4': 'int8',
'tags5': 'int8',
}
questions_df = questions_df.astype(questions_df_dict )<drop_column> | label.to_csv('Y_test.csv',header=True,index = False ) | Digit Recognizer |
11,220,007 | questions_df.drop(columns=['tags'], inplace=True )<data_type_conversions> | model.save("MNIST_CNN_model_dataaug" ) | Digit Recognizer |
12,201,447 | questions_df['part_bundle_id']=questions_df['part']*100000+questions_df['bundle_id']
questions_df.part_bundle_id=questions_df.part_bundle_id.astype('int32')
<load_from_csv> | data_dir='/kaggle/input/digit-recognizer/' | Digit Recognizer |
12,201,447 |
<rename_columns> | train=pd.read_csv(data_dir+'train.csv')
test=pd.read_csv(data_dir+'test.csv' ) | Digit Recognizer |
12,201,447 | questions_df.rename(columns={'question_id':'content_id'}, inplace=True )<merge> | y_train=train['label']
x_train=train.drop('label',axis=1 ) | Digit Recognizer |
12,201,447 | questions_df = pd.merge(questions_df, content_explation_agg, on='content_id', how='left',right_index=True)
<drop_column> | def image_printer(i,df):
idx=i
data=df.iloc[idx].to_numpy().reshape(28,28 ).astype('uint8')
plt.imshow(data ) | Digit Recognizer |
12,201,447 | del content_explation_agg<data_type_conversions> | x_test=test | Digit Recognizer |
12,201,447 | questions_df['content_correctness'] = questions_df['content_id'].map(content_agg['sum'] / content_agg['count'])
questions_df.content_correctness=questions_df.content_correctness.astype('float16')
questions_df['content_correctness_std'] = questions_df['content_id'].map(content_agg['var'])
questions_df.content_correct... | import tensorflow as tf
import keras
from keras import backend as k
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Activation, BatchNormalization
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator
from keras.utils i... | Digit Recognizer |
12,201,447 | questions_df['content_elapsed_time_mean'] = questions_df['content_id'].map(content_elapsed_time_agg['mean'])
questions_df.content_elapsed_time_mean=questions_df.content_elapsed_time_mean.astype('float16')
questions_df['content_had_explanation_mean'] = questions_df['content_id'].map(content_had_explanation_agg['mean']... | img_cols=28
img_rows=28 | Digit Recognizer |
12,201,447 | del content_elapsed_time_agg
del content_had_explanation_agg
gc.collect()<categorify> | if k.image_data_format=='channels_first':
x_train=x_train.values.reshape(x_train.shape[0],1,img_rows,img_cols)
test=test.values.reshape(test.shape[0],1,img_rows,img_cols)
x_train=x_train/255.0
test=test/255.0
input_shape=(1,img_rows,img_cols)
else:
x_train=x_train.values.reshape(x_train.shape[0],img_rows,img_cols,1)... | Digit Recognizer |
12,201,447 | part_agg = questions_df.groupby('part')['content_correctness'].agg(['mean', 'var'])
questions_df['part_correctness_mean'] = questions_df['part'].map(part_agg['mean'])
questions_df['part_correctness_std'] = questions_df['part'].map(part_agg['var'])
questions_df.part_correctness_mean=questions_df.part_correctness_mean... | earlystopping=EarlyStopping(monitor='val_accuracy',mode='auto',patience=10,restore_best_weights=True)
modelacc=[]
nfilters=[64,128,256]
conv_layers=[1,2,3,4,5]
dense_layers=[0,1,2,3,4]
dropouts=[0.5]
for filters in nfilters:
for conl in conv_layers:
for densel in dense_layers:
for dp in dropouts:
cnnsays='Feature Maps... | Digit Recognizer |
12,201,447 | part_agg = questions_df.groupby('part')['content_uncorrect_count'].agg(['sum'])
questions_df['part_uncor_count'] = questions_df['part'].map(part_agg['sum'] ).astype('int32')
part_agg = questions_df.groupby('part')['content_correct_count'].agg(['sum'])
questions_df['part_cor_count'] = questions_df['part'].map(part_ag... | print('Highest validation accuracy {}'.format(round(100*max(history.history['val_accuracy']),2)) ) | Digit Recognizer |
12,201,447 | bundle_agg = questions_df.groupby('bundle_id')['content_correctness'].agg(['mean'])
questions_df['bundle_correctness_mean'] = questions_df['bundle_id'].map(bundle_agg['mean'])
questions_df.bundle_correctness_mean=questions_df.bundle_correctness_mean.astype('float16')
<data_type_conversions> | modelacc.sort(reverse=True)
modelacc | Digit Recognizer |
12,201,447 |
<drop_column> | pred=model.predict([test])
soln=[]
for i in range(len(pred)) :
soln.append(np.argmax(pred[i]))
| Digit Recognizer |
12,201,447 | <define_variables><EOS> | final=pd.DataFrame()
final['ImageId']=[i+1 for i in x_test.index]
final['Label']=soln
final.to_csv('newmnistcnn',index=False ) | Digit Recognizer |
12,294,222 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<init_hyperparams> | import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import seaborn as sns
import tensorflow as tf
from keras.preprocessing.image import ImageDataGenerator, load_img
from keras.layers import Conv2D, BatchNormalization, Activation, MaxPooling2D, GlobalAveragePooling2D, Dense, Flatten, Dropout... | Digit Recognizer |
12,294,222 | flag_lgbm=True
clfs = list()
params = {
'num_leaves': 400,
'max_bin':500,
'min_child_weight': 0.03454472573214212,
'feature_fraction': 0.52,
'bagging_fraction': 0.52,
'objective': 'binary',
'learning_rate': 0.2,
"boosting_type": "gbdt",
"metric": 'auc',
'reg_alpha': 0.3899927210061127,
'reg_lambda': 0.6485237330340494,... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
train.head(5 ) | Digit Recognizer |
12,294,222 | del train_df_clf
del valid_df
gc.collect()<prepare_x_and_y> | y = train['label']
train.drop('label', axis=1, inplace=True ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.