kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,584,011 | 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)
questions_df_dict = {
'tags0': 'int8',
'tags1': '... | Digit Recognizer | |
14,584,011 | 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... | count_network = 5
size_for_network = X_train.shape[0] // count_network
X_train_list = []
X_valid_list = []
Y_train_list = []
Y_valid_list = []
for i in range(count_network):
X_train_list.append(X_train[i * size_for_network :(i + 1)* size_for_network])
Y_train_list.append(Y_train[i * size_for_network :(i + 1)* size_for... | Digit Recognizer |
14,584,011 | del content_agg
del bundle_agg
del part_agg
gc.collect()
<define_variables> | def build_model(lr):
model = models.Sequential()
model.add(Conv2D(96, 3, activation='relu', padding='same', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(SpatialDropout2D(0.4))
model.add(MaxPooling2D(( 2, 2)))
model.add(Conv2D(160, 3, activation='relu', padding='same'))
model.add(BatchNormaliza... | Digit Recognizer |
14,584,011 | features_dict = {
'timestamp':'float16',
'user_interaction_count':'int16',
'user_interaction_timestamp_mean':'float32',
'lagtime':'float32',
'lagtime2':'float32',
'lagtime3':'float32',
'content_id':'int16',
'task_container_id':'int16',
'user_lecture_sum':'int16',
'user_lecture_lv':'float16',
'prior_question_elapsed_tim... | list_models = [build_model(lr=1e-2)for _ in range(count_network)]
list_history = []
for i in range(count_network):
checkpoint_path = f'bestmodel{i + 1}.hdf5'
checkpoint = ModelCheckpoint(checkpoint_path, monitor='val_categorical_accuracy',
verbose=0, save_best_only=True, mode='max')
scheduler = LearningRateScheduler(l... | Digit Recognizer |
14,584,011 | flag_lgbm=True
clfs = list()
params = {
'num_leaves': 200,
'max_bin':450,
'feature_fraction': 0.52,
'bagging_fraction': 0.52,
'objective': 'binary',
'learning_rate': 0.05,
"boosting_type": "gbdt",
"metric": 'auc',
}
trains=list()
valids=list()
num=1
for i in range(0,num):
train_df_clf=train_df[1200*10000:2*1200*10000]
... | for i in range(count_network):
list_models[i].load_weights(f'bestmodel{i + 1}.hdf5')
print(f'Model №{i + 1}')
_, acc = list_models[i].evaluate(X_train_list[i], Y_train_list[i])
_, acc2 = list_models[i].evaluate(X_valid_list[i], Y_valid_list[i])
print() | Digit Recognizer |
14,584,011 | del train_df_clf
del valid_df
gc.collect()<prepare_x_and_y> | def get_predict(models, data, method_voting='soft', count_classes=10):
if method_voting == 'soft':
for_test = np.zeros(( data.shape[0], count_classes))
for i in range(len(models)) :
for_test += models[i].predict(data)
return np.argmax(for_test, axis=1)
elif method_voting == 'hard':
for_test = np.zeros(( data.shape[0]... | Digit Recognizer |
14,584,011 | 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... | submit = pd.DataFrame(get_predict(list_models, X_test), columns=['Label'], index=pd.read_csv('.. /input/digit-recognizer/sample_submission.csv')['ImageId'])
submit2 = pd.DataFrame(get_predict(list_models, X_test, method_voting='hard'), columns=['Label'],
index=pd.read_csv('.. /input/digit-recognizer/sample_submission.... | Digit Recognizer |
14,584,011 | <choose_model_class><EOS> | comparison = submit.join(submit2, lsuffix='_1', rsuffix='_2')
comparison.loc[~(comparison['Label_1'] == comparison['Label_2'])] | Digit Recognizer |
13,709,795 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<data_type_conversions> | import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.preprocessing.image import ImageDataGenerator
from keras.utils import to_categorical
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, Ma... | Digit Recognizer |
13,709,795 | 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... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
df = train.copy()
df_test = test.copy() | Digit Recognizer |
13,709,795 | 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> | df.isnull().any().sum() | Digit Recognizer |
13,709,795 | 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... | df_test.isnull().any().sum() | Digit Recognizer |
13,709,795 | attempt_no_sum_dict = attempt_no_agg['sum'].to_dict(defaultdict(int))
del attempt_no_agg
gc.collect()
<feature_engineering> | seed = 3141
np.random.seed(seed ) | Digit Recognizer |
13,709,795 | 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]
<split> | X = train.iloc[:,1:]
Y = train.iloc[:,0]
x_train , x_test , y_train , y_test = train_test_split(X, Y , test_size=0.1, random_state=seed ) | Digit Recognizer |
13,709,795 | env = riiideducation.make_env()
iter_test = env.iter_test()
prior_test_df = None
prev_test_df1 = None
N=[0.4,0.6]<groupby> | x_train = x_train.values.reshape(-1, 28, 28, 1)
x_test = x_test.values.reshape(-1, 28, 28, 1)
df_test=df_test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
13,709,795 | %%time
for(test_df, sample_prediction_df)in iter_test:
test_df1=test_df.copy()
if(prev_test_df1 is not None):
prev_test_df1['answered_correctly'] = eval(test_df1['prior_group_answers_correct'].iloc[0])
prev_test_df1 = prev_test_df1[prev_test_df1.content_type_id == False]
prev_group = prev_test_df1[['user_id', 'content... | 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 ) | Digit Recognizer |
13,709,795 | !pip install --quiet /kaggle/input/kerasapplications
!pip install --quiet /kaggle/input/efficientnet-git<set_options> | x_train = x_train.astype("float32")/255
x_test = x_test.astype("float32")/255
df_test = df_test.astype("float32")/255 | Digit Recognizer |
13,709,795 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
seed = 0
seed_everything(seed)
warnings.filterwarnings('ignore' )<define_variables> | datagen.fit(x_train ) | Digit Recognizer |
13,709,795 | BATCH_SIZE = 16 * REPLICAS
HEIGHT = 512
WIDTH = 512
CHANNELS = 3
N_CLASSES = 5
TTA_STEPS = 5<normalization> | y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
print(y_train[0] ) | Digit Recognizer |
13,709,795 | def data_augment(image, label):
p_spatial = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_rotate = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_1 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_2 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_crop = tf.random.uniform([], 0, 1.0, dtype=... | model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu', strides=1, padding='same', data_format='channels_last',
input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation='relu', strides=1, padding='same', data_format='channels_... | Digit Recognizer |
13,709,795 | def transform_rotation(image, height, rotation):
DIM = height
XDIM = DIM%2
rotation = rotation * tf.random.uniform([1],dtype='float32')
rotation = math.pi * rotation / 180.
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
zero = tf.constant([0],dtype='float32')
rotation... | optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999 ) | Digit Recognizer |
13,709,795 | def model_fn(input_shape, N_CLASSES):
inputs = L.Input(shape=input_shape, name='input_image')
base_model = efn.EfficientNetB4(input_tensor=inputs,
include_top=False,
weights=None,
pooling='avg')
x = L.Dropout (.5 )(base_model.output)
output = L.Dense(N_CLASSES, activation='softmax', name='output' )(x)
model = Model... | model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
13,709,795 | files_path = f'{database_base_path}test_images/'
test_size = len(os.listdir(files_path))
test_preds = np.zeros(( test_size, N_CLASSES))
for model_path in model_path_list:
print(model_path)
K.clear_session()
model.load_weights(model_path)
if TTA_STEPS > 0:
test_ds = get_dataset(files_path, tta=True ).repeat()
ct_steps... | reduce_lr = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x ) | Digit Recognizer |
13,709,795 | submission = pd.DataFrame({'image_id': image_names, 'label': test_preds})
submission.to_csv('submission.csv', index=False)
display(submission.head() )<define_variables> | decays = [(lambda x: 1e-3 * 0.9 ** x )(x)for x in range(10)]
i=1
for lr in decays:
print("Epoch " + str(i)+" Learning Rate: " + str(lr))
i+=1 | Digit Recognizer |
13,709,795 | tez_path = '.. /input/tez-lib/'
effnet_path = '.. /input/efficientnet-pytorch/'
sys.path.append(tez_path)
sys.path.append(effnet_path)
<feature_engineering> | early_stopping = EarlyStopping(
min_delta=0.001,
patience=20,
restore_best_weights=True,
) | Digit Recognizer |
13,709,795 | class LeafModel(tez.Model):
def __init__(self, num_classes):
super().__init__()
self.effnet = EfficientNet.from_name("efficientnet-b4")
self.dropout = nn.Dropout(0.1)
self.out = nn.Linear(1792, num_classes)
self.step_scheduler_after = "epoch"
def forward(self, image, targets=None):
batch_size, _, _, _ = image.shape
... | batch_size = 64
epochs = 50 | Digit Recognizer |
13,709,795 | test_aug = albumentations.Compose([
albumentations.RandomResizedCrop(256, 256),
albumentations.Transpose(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HueSaturationValue(
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5
),
albumentations.RandomBri... | history = model.fit_generator(datagen.flow(x_train, y_train, batch_size = batch_size), epochs = epochs,
validation_data =(x_test, y_test), verbose=1,
steps_per_epoch=x_train.shape[0] // batch_size,
callbacks = [reduce_lr] ) | Digit Recognizer |
13,709,795 | dfx = pd.read_csv(".. /input/cassava-leaf-disease-classification/sample_submission.csv")
image_path = ".. /input/cassava-leaf-disease-classification/test_images/"
test_image_paths = [os.path.join(image_path, x)for x in dfx.image_id.values]
test_targets = dfx.label.values
test_dataset = ImageDataset(
image_paths=test_... | import matplotlib.pyplot as plt | Digit Recognizer |
13,709,795 | <predict_on_test><EOS> | pred_digits_test = np.argmax(model.predict(df_test),axis=1)
image_id_test = []
for i in range(len(pred_digits_test)) :
image_id_test.append(i+1)
d = {'ImageId':image_id_test,'Label':pred_digits_test}
answer = pd.DataFrame(d)
answer.to_csv('answer.csv',index=False ) | Digit Recognizer |
13,706,409 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<save_to_csv> | %matplotlib inline
%load_ext autoreload
%autoreload 2
| Digit Recognizer |
13,706,409 | final_preds = final_preds.argmax(axis=1)
dfx.label = final_preds
dfx.to_csv("submission.csv", index=False )<save_to_csv> | train_data = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test_data = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
13,706,409 | df = pd.read_csv('/kaggle/input/finalsub3/finalsub2.csv')
df.to_csv('submission.csv', index=False )<set_options> | print("Training Data : ")
train_data.head(3 ).iloc[:,:17] | Digit Recognizer |
13,706,409 | warnings.filterwarnings("ignore" )<load_from_csv> | train_data_norm = train_data.iloc[:, 1:] / 255.0
test_data_norm = test_data / 255.0 | Digit Recognizer |
13,706,409 | train_data = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/train_V2.csv')
test_data = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv')
train_data.describe().drop('count' ).T<filter> | num_examples_train = train_data.shape[0]
num_examples_test = test_data.shape[0]
n_h = 32
n_w = 32
n_c = 3 | Digit Recognizer |
13,706,409 | train_data[train_data['winPlacePerc'].isnull() ]<feature_engineering> | Train_input_images = np.zeros(( num_examples_train, n_h, n_w, n_c))
Test_input_images = np.zeros(( num_examples_test, n_h, n_w, n_c)) | Digit Recognizer |
13,706,409 |
mapper = lambda x: 'solo' if('solo'in x)else 'duo' if('duo' in x)or('crash'in x)else 'squad'
train_data['matchType'] = train_data['matchType'].apply(mapper)
match_type_counts=train_data.groupby('matchId')['matchType'].first().value_counts().sort_values(ascending=False )<concatenate> | for example in range(num_examples_train):
Train_input_images[example,:28,:28,0] = train_data.iloc[example, 1:].values.reshape(28,28)
Train_input_images[example,:28,:28,1] = train_data.iloc[example, 1:].values.reshape(28,28)
Train_input_images[example,:28,:28,2] = train_data.iloc[example, 1:].values.reshape(28,28)
fo... | Digit Recognizer |
13,706,409 | all_data = train_data.append(test_data, sort=False ).reset_index(drop=True)
del train_data, test_data
gc.collect()<feature_engineering> | for example in range(num_examples_train):
Train_input_images[example] = cv2.resize(Train_input_images[example],(n_h, n_w))
for example in range(num_examples_test):
Test_input_images[example] = cv2.resize(Test_input_images[example],(n_h, n_w)) | Digit Recognizer |
13,706,409 | match = all_data.groupby('matchId')
all_data['killsPerc'] = match['kills'].rank(pct=True ).values
all_data['killPlacePerc'] = match['killPlace'].rank(pct=True ).values
all_data['walkDistancePerc'] = match['walkDistance'].rank(pct=True ).values
all_data['walkPerc_killsPerc'] = all_data['walkDistancePerc'] / all_data['k... | Train_labels = np.array(train_data.iloc[:, 0] ) | Digit Recognizer |
13,706,409 | def fillInf(df, val):
numcols = df.select_dtypes(include='number' ).columns
cols = numcols[numcols != 'winPlacePerc']
df[df == np.Inf] = np.NaN
df[df == np.NINF] = np.NaN
for c in cols: df[c].fillna(val, inplace=True )<feature_engineering> | image_generator = ImageDataGenerator(
rotation_range=27,
width_shift_range=0.3,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=False,
samplewise_center=True,
samplewise_std_normalization=True
)
validation_datagen = ImageDataGenerator() | Digit Recognizer |
13,706,409 | all_data['_healthItems'] = all_data['heals'] + all_data['boosts']
all_data['_headshotKillRate'] = all_data['headshotKills'] / all_data['kills']
all_data['_killPlaceOverMaxPlace'] = all_data['killPlace'] / all_data['maxPlace']
all_data['_killsOverWalkDistance'] = all_data['kills'] / all_data['walkDistance']<drop_column> | pretrained_model = keras.applications.resnet50.ResNet50(input_shape=(n_h, n_w, n_c),
include_top=False, weights='imagenet')
model = keras.Sequential([
pretrained_model,
keras.layers.Flatten() ,
keras.layers.Dense(units=60, activation='relu'),
keras.layers.Dense(units=10, activation='softmax')
] ) | Digit Recognizer |
13,706,409 | all_data.drop(['boosts','heals','killStreaks','DBNOs'], axis=1, inplace=True)
all_data.drop(['headshotKills','roadKills','vehicleDestroys'], axis=1, inplace=True)
all_data.drop(['rideDistance','swimDistance','matchDuration'], axis=1, inplace=True)
all_data.drop(['rankPoints','killPoints','winPoints'], axis=1, inplac... | Optimizer = 'RMSprop'
model.compile(optimizer=Optimizer,
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
13,706,409 | match = all_data.groupby(['matchId'])
group = all_data.groupby(['matchId','groupId','matchType'])
agg_col = list(all_data.columns)
exclude_agg_col = ['Id','matchId','groupId','matchType','maxPlace','numGroups','winPlacePerc']
for c in exclude_agg_col:
agg_col.remove(c)
sum_col = ['kills','killPlace','damageDealt','... | train_images, dev_images, train_labels, dev_labels = train_test_split(Train_input_images,
Train_labels,
test_size=0.1, train_size=0.9,
shuffle=True,
random_state=44)
test_images = Test_input_images | Digit Recognizer |
13,706,409 | minKills = all_data.sort_values(['matchId','groupId','kills','killPlace'] ).groupby(
['matchId','groupId','kills'] ).first().reset_index().copy()
for n in np.arange(4):
c = 'kills_' + str(n)+ '_Place'
nKills =(minKills['kills'] == n)
minKills.loc[nKills, c] = minKills[nKills].groupby(['matchId'])['killPlace'].rank().... | train_datagen = ImageDataGenerator(
rotation_range=27,
width_shift_range=0.3,
height_shift_range=0.2,
shear_range=0.3,
zoom_range=0.2,
horizontal_flip=False)
validation_datagen = ImageDataGenerator() | Digit Recognizer |
13,706,409 |
all_data = pd.merge(all_data, match_data)
del match_data
gc.collect()
all_data['enemy.players'] = all_data['m.players'] - all_data['players']
for c in sum_col:
all_data['p.max_msum.' + c] = all_data['max.' + c] / all_data['m.sum.' + c]
all_data['p.max_mmax.' + c] = all_data['max.' + c] / all_data['m.max.' + c]
all_d... | class myCallback(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')> 0.999999):
print("Stop training!")
self.model.stop_training = True | Digit Recognizer |
13,706,409 | match = all_data.groupby('matchId')
matchRank = match[numcols].rank(pct=True ).rename(columns=lambda s: 'rank.' + s)
all_data = reduce_mem_usage(pd.concat([all_data, matchRank], axis=1))
rank_col = matchRank.columns
del matchRank
gc.collect()
match = all_data.groupby('matchId')
matchRank = match[rank_col].max().rena... | EPOCHS = 5
batch_size = 212
history = model.fit_generator(train_datagen.flow(train_images,train_labels, batch_size=batch_size),
steps_per_epoch=train_images.shape[0] / batch_size,
epochs=EPOCHS,
validation_data=validation_datagen.flow(dev_images,dev_labels,
batch_size=batch_size),
validation_steps=dev_images.shape[0] /... | Digit Recognizer |
13,706,409 | killMinorRank = all_data[['matchId','min.kills','max.killPlace']].copy()
group = killMinorRank.groupby(['matchId','min.kills'])
killMinorRank['rank.minor.maxKillPlace'] = group.rank(pct=True ).values
all_data = pd.merge(all_data, killMinorRank)
killMinorRank = all_data[['matchId','max.kills','min.killPlace']].copy()
... | submission = pd.read_csv('.. /input/digit-recognizer-submission/submission.csv')
submission.to_csv('digit_submission.csv', index=False ) | Digit Recognizer |
13,706,409 | constant_column = [col for col in all_data.columns if all_data[col].nunique() == 1]
all_data.drop(constant_column, axis=1, inplace=True )<feature_engineering> | mnist_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
mnist_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
13,706,409 |
all_data['matchType'] = all_data['matchType'].apply(mapper)
all_data = pd.concat([all_data, pd.get_dummies(all_data['matchType'])], axis=1)
all_data.drop(['matchType'], axis=1, inplace=True)
all_data['matchId'] = all_data['matchId'].apply(lambda x: int(x,16))
all_data['groupId'] = all_data['groupId'].apply(lambda ... | mnist_train_data = mnist_train.loc[:, "pixel0":]
mnist_train_label = mnist_train.loc[:, "label"]
mnist_train_data = mnist_train_data/255.0
mnist_test = mnist_test/255.0 | Digit Recognizer |
13,706,409 | null_cnt = all_data.isnull().sum().sort_values()<categorify> | standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(mnist_train_data)
standardized_data.shape | Digit Recognizer |
13,706,409 | cols = [col for col in all_data.columns if col not in ['Id','matchId','groupId']]
for i, t in all_data.loc[:, cols].dtypes.iteritems() :
if t == object:
all_data[i] = pd.factorize(all_data[i])[0]
all_data = reduce_mem_usage(all_data )<prepare_x_and_y> | cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape | Digit Recognizer |
13,706,409 | X_train = all_data[all_data['winPlacePerc'].notnull() ].reset_index(drop=True)
X_test = all_data[all_data['winPlacePerc'].isnull() ].drop(['winPlacePerc'], axis=1 ).reset_index(drop=True)
del all_data
gc.collect()
Y_train = X_train.pop('winPlacePerc')
X_test_grp = X_test[['matchId','groupId']].copy()
train_matchId =... | lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape | Digit Recognizer |
13,706,409 | params={'learning_rate': 0.05,
'objective':'mae',
'metric':'mae',
'num_leaves': 128,
'verbose': 1,
'random_state':42,
'bagging_fraction': 0.7,
'feature_fraction': 0.7
}
reg = lgb.LGBMRegressor(**params, n_estimators=10000)
reg.fit(X_train, Y_train)
pred = reg.predict(X_test, num_iteration=reg.best_iteration_ )<concat... | new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack(( new_coordinates, mnist_train_label)).T | Digit Recognizer |
13,706,409 | X_test_grp['_nofit.winPlacePerc'] = pred
group = X_test_grp.groupby(['matchId'])
X_test_grp['winPlacePerc'] = pred
X_test_grp['_rank.winPlacePerc'] = group['winPlacePerc'].rank(method='min')
X_test = pd.concat([X_test, X_test_grp], axis=1 )<feature_engineering> | df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head() | Digit Recognizer |
13,706,409 | fullgroup =(X_test['numGroups'] == X_test['maxPlace'])
subset = X_test.loc[fullgroup]
X_test.loc[fullgroup, 'winPlacePerc'] =(subset['_rank.winPlacePerc'].values - 1)/(subset['maxPlace'].values - 1)
subset = X_test.loc[~fullgroup]
gap = 1.0 /(subset['maxPlace'].values - 1)
new_perc = np.around(subset['winPlacePerc']... | pca = decomposition.PCA()
pca.n_components = 2
pca_data = pca.fit_transform(standardized_data)
pca_data.shape | Digit Recognizer |
13,706,409 | X_test.loc[X_test['maxPlace'] == 0, 'winPlacePerc'] = 0
X_test.loc[X_test['maxPlace'] == 1, 'winPlacePerc'] = 1
X_test.loc[(X_test['maxPlace'] > 1)&(X_test['numGroups'] == 1), 'winPlacePerc'] = 0<save_to_csv> | pca_data = np.vstack(( pca_data.T, mnist_train_label)).T | Digit Recognizer |
13,706,409 | test = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv')
test['matchId'] = test['matchId'].apply(lambda x: int(x,16))
test['groupId'] = test['groupId'].apply(lambda x: int(x,16))
submission = pd.merge(test, X_test[['matchId','groupId','winPlacePerc']])
submission = submission[['Id','winPlacePe... | df_PCA = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_PCA.head() | Digit Recognizer |
13,706,409 | warnings.filterwarnings('ignore')
%matplotlib inline
<load_from_csv> | mnist_train_data = np.array(mnist_train_data)
mnist_train_label = np.array(mnist_train_label ) | Digit Recognizer |
13,706,409 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
submission = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' )<prepare_x_and_y> | from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Lambda, Flatten, BatchNormalization
from tensorflow.keras.layers import Conv2D, MaxPool2D, AvgPool2D
from tensorflow.keras.optimizers import Adadelta
from keras.utils.np_utils import to_categorical
from tensorflow.keras.p... | Digit Recognizer |
13,706,409 | X_train = train.drop(['label'], axis=1)
y_train = train['label']<feature_engineering> | nclasses = mnist_train_label.max() - mnist_train_label.min() + 1
mnist_train_label = to_categorical(mnist_train_label, num_classes = nclasses)
print("Shape of ytrain after encoding: ", mnist_train_label.shape ) | Digit Recognizer |
13,706,409 | X_train /= 255.0
test /= 255.0<train_model> | def build_model(input_shape=(28, 28, 1)) :
model = Sequential()
model.add(Conv2D(32, kernel_size = 3, activation='relu', input_shape = input_shape))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 5, strides=2... | Digit Recognizer |
13,706,409 | X_train1 = X_train.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1 )<categorify> | cnn_model = build_model(( 28, 28, 1))
compile_model(cnn_model, 'adam', 'categorical_crossentropy')
model_history = train_model(cnn_model, mnist_train_data, mnist_train_label, 80, 0.2 ) | Digit Recognizer |
13,706,409 | y_train = to_categorical(y_train, num_classes=10 )<split> | predictions = cnn_model.predict(mnist_test_arr ) | Digit Recognizer |
13,706,409 | X_train, X_val , y_train, y_val = train_test_split(X_train1, y_train, test_size=0.2 )<choose_model_class> | predictions_test = []
for i in predictions:
predictions_test.append(np.argmax(i)) | Digit Recognizer |
13,706,409 | model = keras.models.Sequential()
model.add(keras.layers.Conv2D(filters = 64, kernel_size=(5,5), padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(keras.layers.BatchNormalization())
model.add(keras.layers.Conv2D(filters = 64, kernel_size=(5,5), padding='same', activation='relu'))
model.add(keras.... | submission = pd.DataFrame({
"ImageId": mnist_test.index+1,
"Label": predictions_test
})
submission.to_csv('my_first_submission.csv', index=False ) | Digit Recognizer |
13,706,409 | model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=["accuracy"] )<train_model> | import tensorflow as tf
import tensorflow.keras as keras
from tensorflow.keras import models, layers, utils
from tensorflow.keras import Sequential
from sklearn.model_selection import train_test_split
from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPooling2D, MaxPool2D
| Digit Recognizer |
13,706,409 | history = model.fit(X_train, y_train, epochs=25, validation_data=(X_val, y_val))<predict_on_test> | x_train, x_val, y_train, y_val = train_test_split(mnist_train_data, mnist_train_label, test_size = 0.2, random_state = 2 ) | Digit Recognizer |
13,706,409 | y_pred = model.predict(test )<save_to_csv> | def define_model() :
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(layers.BatchNormalization())
model.add(Conv2D(filters=128, kernel_size =(3,3), activation="relu"))
model.add(Co... | Digit Recognizer |
13,706,409 | submission['Label'] = results
submission.to_csv('submission.csv', index=False )<import_modules> | model = define_model()
model.compile(optimizer="adam", loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
13,706,409 | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from skimage import color
from skimage import measure
from skimage.filters import try_all_threshold
from skimage.filters import threshold_otsu
from skimage.filters import thr... | model.fit(x_train, y_train , epochs=30 ) | Digit Recognizer |
13,706,409 | df_train = pd.read_csv('.. /input/digit-recognizer/train.csv')
df_test = pd.read_csv('.. /input/digit-recognizer/test.csv' )<prepare_x_and_y> | predictions = model.predict(mnist_test_arr ) | Digit Recognizer |
13,706,409 | y_train = df_train['label']
X_train = df_train.drop('label', axis = 1)
X_test = np.array(df_test )<categorify> | predictions_test = []
for i in predictions:
predictions_test.append(np.argmax(i)) | Digit Recognizer |
13,706,409 | y_train = to_categorical(y_train, num_classes = 10)
y_train.shape<split> | submission = pd.DataFrame({
"ImageId": mnist_test.index+1,
"Label": predictions_test
})
submission.to_csv('my_second_submission.csv', index=False ) | Digit Recognizer |
13,663,724 | X_train, X_val, y_train, y_val = train_test_split(X_train,
y_train,
test_size=0.25,
random_state=1 )<define_search_space> | def rotate_image(image, angle = 90, scale = 1.0):
h, w = image.shape
M = cv2.getRotationMatrix2D(( w/2, h/2), angle, scale)
return cv2.warpAffine(image, M,(w, h)) | Digit Recognizer |
13,663,724 | kernel_ =(5,5 )<choose_model_class> | data = np.loadtxt('/kaggle/input/digit-recognizer/train.csv', delimiter = ',', skiprows = 1 ) | Digit Recognizer |
13,663,724 | 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 = ... | y = data[:, 0]
x = data[:, 1:].reshape(-1, 28, 28)
x_train, x_cv, y_train, y_cv = train_test_split(x, y, test_size = 0.1)
x_train_temp = x_train.copy()
for angle in np.arange(-10, 15, 5):
x_train = np.concatenate(( x_train, np.array([rotate_image(image, angle, scale = 1)for image in x_train_temp])))
x_train = x_trai... | Digit Recognizer |
13,663,724 | aug = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1)
gen_train = aug.flow(X_train, y_train, batch_size=64)
gen_val = aug.flow(X_val, y_val, batch_size=64 )<choose_model_class> | print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')) ) | Digit Recognizer |
13,663,724 | model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'] )<choose_model_class> | YaNet = Sequential(name = 'YaNet')
YaNet.add(Conv2D(filters = 32,
kernel_size =(5, 5),
kernel_initializer = 'he_uniform',
padding = 'same',
activation = 'relu',
input_shape =(28, 28, 1)))
YaNet.add(BatchNormalization())
YaNet.add(Conv2D(filters = 32,
kernel_size =(5, 5),
kernel_initializer = 'he_uniform',
padding = ... | Digit Recognizer |
13,663,724 | checkpoint = tf.keras.callbacks.ModelCheckpoint("weights.hdf5",
monitor='val_accuracy',
verbose=1,
save_best_only=True)
reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=4,
min_lr=0.00005,
verbose=1)
early_stop = tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights... | x_test = np.loadtxt('/kaggle/input/digit-recognizer/test.csv', skiprows = 1, delimiter = ',')
x_test = x_test.reshape(-1, 28, 28, 1 ) | Digit Recognizer |
13,663,724 | <load_pretrained><EOS> | final_prediction = np.argmax(YaNet.predict(x_test), axis = 1)
output = pd.DataFrame({'ImageId': np.arange(1, x_test.shape[0]+1), 'Label': final_prediction})
output.to_csv('my_submission.csv', index = False ) | Digit Recognizer |
13,128,051 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import os
import seaborn as sns
import matplotlib.image as mpimg | Digit Recognizer |
13,128,051 | y_test = model.predict(X_test)
y_pred = np.argmax(y_test, axis=1 )<save_to_csv> | train_input = ".. /input/digit-recognizer/train.csv"
test_input = ".. /input/digit-recognizer/test.csv"
train_dataset = pd.read_csv(train_input)
test_dataset = pd.read_csv(test_input ) | Digit Recognizer |
13,128,051 | output_csv = {"ImageId":[*range(1,1+len(y_pred)) ], "Label":y_pred}
Y_pre = pd.DataFrame(output_csv)
Y_pre.set_index("ImageId", drop=True, append=False, inplace=True)
Y_pre.to_csv("/kaggle/working/submission.csv" )<import_modules> | train_labels = tf.keras.utils.to_categorical(train_dataset.pop("label")) | Digit Recognizer |
13,128,051 | import numpy as np
import pandas as pd
import os
import torch
import torch.nn as nn
import torch.optim as optim
from PIL import Image
from matplotlib import pyplot as plt
from torch.utils.data import Dataset,DataLoader
from torchvision import transforms as T
from torchvision import models
import tqdm
from sklearn.metri... | train_dataset = np.array(train_dataset.values.reshape(-1, 28, 28, 1))
test_dataset = np.array(test_dataset.values.reshape(-1, 28, 28, 1)) | Digit Recognizer |
13,128,051 | train_df=pd.read_csv(".. /input/digit-recognizer/train.csv")
test_df=pd.read_csv(".. /input/digit-recognizer/test.csv" )<categorify> | train_dataset = train_dataset/255.0
test_dataset = test_dataset/255.0 | Digit Recognizer |
13,128,051 | def get_image(data_df,idx):
return Image.fromarray(np.uint8(np.reshape(data_df.iloc[idx][data_df.columns[-784:]].to_numpy() ,(28,28)))).convert('RGB')
<categorify> | checkpoint_path = "logs/checkpoints/" | Digit Recognizer |
13,128,051 | class TrainDataSet(Dataset):
def __init__(self,data_df,transforms=T.ToTensor()):
self.data_df=data_df
self.transform=transforms
def __len__(self):
return self.data_df.shape[0]
def __getitem__(self,idx):
image=self.transform(get_image(self.data_df,idx))
label=torch.tensor(self.data_df.label.iloc[idx],dtype=torch.long)... | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64,(3, 3), input_shape=(28, 28, 1), activation=tf.nn.relu, padding="SAME"),
tf.keras.layers.MaxPooling2D() ,
tf.keras.layers.Conv2D(64,(3, 3), activation=tf.nn.relu, padding="SAME"),
tf.keras.layers.MaxPooling2D() ,
tf.keras.layers.Dropout(0.5),
tf.keras.layer... | Digit Recognizer |
13,128,051 | class TestDataSet(TrainDataSet):
def __getitem__(self,idx):
image=self.transform(get_image(self.data_df,idx))
return image<choose_model_class> | model.load_weights(checkpoint_path ) | Digit Recognizer |
13,128,051 | def create_model() :
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 10)
return model<categorify> | labels = [np.argmax(predict)for predict in model.predict(test_dataset)]
df = pd.DataFrame({
"ImageId": list(range(1, len(test_dataset)+1)) ,
"Label": labels,
} ) | Digit Recognizer |
13,128,051 | transform=T.Compose([
T.Resize(( 256,256)) ,
T.ToTensor() ,
T.Normalize(( 0.485, 0.456, 0.406),(0.229, 0.224, 0.225))
] )<choose_model_class> | df.to_csv("submission.csv", index=False ) | Digit Recognizer |
13,128,051 | def train_once(model,dataloader,criterion,optimizer,device):
total_loss=0
n_total=0
criterion.reduction="sum"
model.train()
for i,(images,labels)in enumerate(tqdm.tqdm(dataloader)) :
optimizer.zero_grad()
images=images.to(device)
labels=labels.to(device)
outputs=model(images)
loss=criterion(outputs,labels)
total_lo... | model.save("model.h5" ) | Digit Recognizer |
13,441,242 | class Validation_Metrics(object):
def __init__(self,activation_func=nn.Softmax(dim=1)) :
self.predictions=[]
self.labels=[]
self.activation_func=activation_func
self.collapsed=False
def update(self,model_outputs,labels):
if not self.collapsed:
self.predictions.append(self.activation_func(model_outputs ).detach())
se... | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
print(train.shape)
train.head() | Digit Recognizer |
13,441,242 | def val(model,dataloader,criterion,device):
total_loss=0
n_total=0
criterion.reduction="sum"
Metrics=Validation_Metrics()
model.eval()
with torch.no_grad() :
for images,labels in tqdm.tqdm(dataloader):
images=images.to(device)
labels=labels.to(device)
outputs=model(images)
loss=criterion(outputs,labels)
Metrics.upd... | x_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
x_test = test.values.astype('float32' ) | Digit Recognizer |
13,441,242 | n_folds=5<prepare_output> | x_train = x_train/255.0
x_test = x_test/255.0 | Digit Recognizer |
13,441,242 | train_df.insert(1,"fold",np.random.randint(1,n_folds+1,size=train_df.shape[0]))<define_variables> | y_train = keras.utils.to_categorical(y_train, 10)
X_train, X_val, Y_train, Y_val = train_test_split(X_train, y_train, test_size = 0.1, random_state = 42 ) | Digit Recognizer |
13,441,242 | def Get_Train_Val_Set(fold_i,transform=transform):
train_set=TrainDataSet(train_df[train_df.fold!=fold_i],transforms=transform)
test_set=TrainDataSet(train_df[train_df.fold==fold_i],transforms=transform)
return train_set, test_set<set_options> | batch_size = 64
epochs = 20
input_shape =(28, 28, 1 ) | Digit Recognizer |
13,441,242 | USE_CUDA = torch.cuda.is_available()
device = torch.device("cuda" if USE_CUDA else "cpu" )<choose_model_class> | model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',kernel_initializer='he_normal',input_shape=input_shape))
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',kernel_initializer='he_normal'))
model.add(MaxPool2D(( 2, 2)))
model.add(Dropout(0.20))
model.add(Conv2D(64,(3, 3), activatio... | Digit Recognizer |
13,441,242 | criterion=nn.CrossEntropyLoss()
optimizer_name="Adam"
optimizer_parameters={"lr":0.0001}
epochs=1<choose_model_class> | model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics = ['accuracy'] ) | Digit Recognizer |
13,441,242 | def create_optimizer(model,optimizer_name,optimizer_parameters):
if optimizer_name=="SGD":
return optim.SGD(model.parameters() ,**optimizer_parameters)
elif optimizer_name=="Adam":
return optim.Adam(model.parameters() ,**optimizer_parameters )<load_pretrained> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False ) | Digit Recognizer |
13,441,242 | Best_val_accuracy=0
for fold in range(1,n_folds+1):
print(f"Training fold {fold}")
model=create_model()
model.to(device)
optimizer=create_optimizer(model,optimizer_name,optimizer_parameters)
TrainSet,ValSet=Get_Train_Val_Set(fold)
TrainLoader=DataLoader(TrainSet, batch_size=256)
ValLoader=DataLoader(ValSet, batch_... | datagen.fit(X_train)
model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 1,
steps_per_epoch = X_train.shape[0] // batch_size
) | Digit Recognizer |
13,441,242 | optimizer=create_optimizer(model,optimizer,optimizer_parameters)
optimizer<define_variables> | predictions = model.predict(X_test)
results = np.argmax(predictions, axis = 1 ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.