kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,361,589 | !pip install --upgrade xgboost
xgb.__version__<init_hyperparams> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,361,589 | xgb_params= {
"objective": "reg:squarederror",
"max_depth": 6,
"learning_rate": 0.01,
"colsample_bytree": 0.4,
"subsample": 0.6,
"reg_alpha" : 6,
"min_child_weight": 100,
"n_jobs": 2,
"seed": 2001,
'tree_method': "gpu_hist",
"gpu_id": 0,
}<define_variables> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
4,361,589 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape<prepare_x_and_y> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
4,361,589 | Test = xgb.DMatrix(Test[columns] )<train_model> | random_seed = 2 | Digit Recognizer |
4,361,589 | NUM_FOLDS = 10
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_d... | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
4,361,589 | mean_squared_error(train_oof, target, squared=False )<save_model> | 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(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
4,361,589 | np.save('train_oof', train_oof)
np.save('test_preds', test_preds )<predict_on_test> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
4,361,589 | %%time
shap_preds = model.predict(test, pred_contribs=True )<load_from_csv> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
4,361,589 | train = pd.read_csv('.. /input/tabular-playground-series-feb-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-feb-2021/test.csv')
for feature in cat_features:
le = LabelEncoder()
le.fit(train[feature])
train[feature] = le.transform(train[feature])
test[feature] = le.transform(test[feature] )... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,361,589 | sample_sub['target'] = test_preds
sample_sub.to_csv('submission.csv', index=False )<install_modules> | epochs = 30
batch_size = 86 | Digit Recognizer |
4,361,589 | !pip install librosa<import_modules> | Digit Recognizer | |
4,361,589 | import numpy as np
import pandas as pd
import os<load_pretrained> | 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 |
4,361,589 | audio_data = '/kaggle/input/birdsong-recognition/train_audio/nutwoo/XC462016.mp3'
x , sr = librosa.load(audio_data)
print(type(x), type(sr))
print(x.shape, sr )<load_pretrained> | history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
4,361,589 | librosa.load(audio_data, sr=44100 )<normalization> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
4,361,589 | <set_options><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
3,365,490 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | GlobalAveragePooling2D, Conv2D, BatchNormalization, Dropout
INPUT_DIR = '.. /input'
EMB_SIZE = 8
BATCH_SIZE = 1024
N_FOLDS = 2
N_ITER = 50
SEED = 32 | Digit Recognizer |
3,365,490 | sr = 22050
T = 5.0
t = np.linspace(0, T, int(T*sr), endpoint=False)
x = 0.5*np.sin(2*np.pi*220*t)
ipd.Audio(x, rate=sr)
librosa.output.write_wav('tone_220.wav', x, sr )<normalization> |
def _all_diffs(a, b):
return tf.expand_dims(a, axis=1)- tf.expand_dims(b, axis=0)
def _cdist(a, b, metric='euclidean'):
with tf.name_scope("_cdist"):
diffs = _all_diffs(a, b)
if metric == 'sqeuclidean':
return tf.reduce_sum(tf.square(diffs), axis=-1)
elif metric == 'euclidean':
return tf.sqrt(tf.reduce_sum(tf.... | Digit Recognizer |
3,365,490 | zero_crossings = librosa.zero_crossings(x[n0:n1], pad=False)
print(sum(zero_crossings))<import_modules> | def f1(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
recall = true_positives /(possible_positives + K.epsilon())
precision = true_positives /(predicted_positives + K... | Digit Recognizer |
3,365,490 | import cv2
import audioread
import logging
import os
import random
import time
import warnings
import librosa
import numpy as np
import pandas as pd
import soundfile as sf
import torch
import torch.nn as nn
import torch.cuda
import torch.nn.functional as F
import torch.utils.data as data
from contextlib import contextm... |
df_train = pd.read_csv(os.path.join(INPUT_DIR, 'train.csv'))
df_test = pd.read_csv(os.path.join(INPUT_DIR, 'test.csv'))
print(df_train.head() ) | Digit Recognizer |
3,365,490 | 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)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
def get_logger(out_file=None):
logger = logging.getLogger()
formatter = ... |
x_train = df_train.iloc[:,1:].values.astype('float32')/ 255.
x_test = df_test.values.astype('float32')/ 255.
xc_train = np.reshape(x_train,(len(x_train), 28, 28, 1))
xc_test = np.reshape(x_test,(len(x_test), 28, 28, 1))
y_train = df_train.label.values
yc_train = to_categorical(y_train)
input_size = output_size = x... | Digit Recognizer |
3,365,490 | logger = get_logger("main.log")
set_seed(1213 )<define_variables> |
def base_network(model_type='triplet', input_shape=input_csize):
if model_type == 'autoencoder':
pass
elif model_type == 'triplet':
model = Sequential([
Conv2D(filters=64, kernel_size=(3, 3), padding='same', input_shape=(input_csize, input_csize, 1,), activation='relu'),
Conv2D(filters=64, kernel_size=(3, 3), paddi... | Digit Recognizer |
3,365,490 | TARGET_SR = 32000
TEST = Path(".. /input/birdsong-recognition/test_audio" ).exists()<load_from_csv> |
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... | Digit Recognizer |
3,365,490 | if TEST:
DATA_DIR = Path(".. /input/birdsong-recognition/")
else:
DATA_DIR = Path(".. /input/birdcall-check/")
test = pd.read_csv(DATA_DIR / "test.csv")
test_audio = DATA_DIR / "test_audio"
test.head()<save_to_csv> |
yfull_test = []
skf = StratifiedKFold(n_splits=N_FOLDS, random_state=SEED, shuffle=True)
print(len(xc_train), len(y_train))
for i,(train_index, val_index)in enumerate(skf.split(xc_train, y_train)) :
triplet_model = base_network()
triplet_model.compile(optimizer=RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0),
l... | Digit Recognizer |
3,365,490 | sub = pd.read_csv(".. /input/birdsong-recognition/sample_submission.csv")
sub.to_csv("submission.csv", index=False )<choose_model_class> | pred = np.array(yfull_test)
pred = np.argmax(pred, axis=2)
values, counts = np.unique(pred, axis=0, return_counts=True)
pred = values[np.argmax(counts)]
print(pred.shape ) | Digit Recognizer |
3,365,490 | class ResNet(nn.Module):
def __init__(self, base_model_name: str, pretrained=False,
num_classes=264):
super().__init__()
base_model = models.__getattribute__(base_model_name )(
pretrained=pretrained)
layers = list(base_model.children())[:-2]
layers.append(nn.AdaptiveMaxPool2d(1))
self.encoder = nn.Sequential(*layers)... | Digit Recognizer | |
3,365,490 | model_config = {
"base_model_name": "resnet50",
"pretrained": False,
"num_classes": 264
}
melspectrogram_parameters = {
"n_mels": 128,
"fmin": 20,
"fmax": 16000
}
weights_path = ".. /input/birdcall-resnet50-init-weights/best.pth"<define_variables> | submission = pd.DataFrame({'ImageId': range(1, pred.shape[0]+1), 'Label': pred})
submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
4,861,518 | BIRD_CODE = {
'aldfly': 0, 'ameavo': 1, 'amebit': 2, 'amecro': 3, 'amegfi': 4,
'amekes': 5, 'amepip': 6, 'amered': 7, 'amerob': 8, 'amewig': 9,
'amewoo': 10, 'amtspa': 11, 'annhum': 12, 'astfly': 13, 'baisan': 14,
'baleag': 15, 'balori': 16, 'banswa': 17, 'barswa': 18, 'bawwar': 19,
'belkin1': 20, 'belspa2': 21, 'bewwr... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,861,518 | def get_model(config: dict, weights_path: str):
model = ResNet(**config)
checkpoint = torch.load(weights_path)
model.load_state_dict(checkpoint["model_state_dict"])
device = torch.device("cuda")
model.to(device)
model.eval()
return model<create_dataframe> | train_y = train["label"]
train_x = train.drop("label",axis = 1 ) | Digit Recognizer |
4,861,518 | def prediction_for_clip(test_df: pd.DataFrame,
clip: np.ndarray,
model: ResNet,
mel_params: dict,
threshold=0.55):
dataset = TestDataset(df=test_df,
clip=clip,
img_size=224,
melspectrogram_parameters=mel_params)
loader = data.DataLoader(dataset, batch_size=1, shuffle=False)
device = torch.device("cuda" if torch.cuda.... | train_y = to_categorical(train_y ) | Digit Recognizer |
4,861,518 | def prediction(test_df: pd.DataFrame,
test_audio: Path,
model_config: dict,
mel_params: dict,
weights_path: str,
threshold=0.5):
model = get_model(model_config, weights_path)
unique_audio_id = test_df.audio_id.unique()
warnings.filterwarnings("ignore")
prediction_dfs = []
for audio_id in unique_audio_id:
with timer(f... | model = Sequential() | Digit Recognizer |
4,861,518 | submission = prediction(test_df=test,
test_audio=test_audio,
model_config=model_config,
mel_params=melspectrogram_parameters,
weights_path=weights_path,
threshold=0.85)
submission.to_csv("submission.csv", index=False )<install_modules> | model.add(Conv2D(32,(3,3), strides=(1, 1), padding='same', activation="relu",input_shape =(28,28,1),data_format = "channels_last", use_bias = True))
model.add(Conv2D(32,(3,3), strides=(1, 1), padding='same', activation="relu", use_bias = True))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2), s... | Digit Recognizer |
4,861,518 | !pip install mlforecast<import_modules> | optimizer = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
4,861,518 | from copy import copy
from functools import partial
from pathlib import Path
import lightgbm as lgb
import numpy as np
import pandas as pd
from mlforecast.core import TimeSeries
from mlforecast.forecast import Forecast
from window_ops.rolling import rolling_mean<load_from_csv> | model.compile(optimizer = optimizer,loss = "categorical_crossentropy",metrics = ['accuracy'] ) | Digit Recognizer |
4,861,518 | input_path = Path('.. /input/m5-preprocess/processed/')
data = pd.read_parquet(input_path/'sales.parquet')
data<load_from_csv> | learning_rate_reduction = callbacks.ReduceLROnPlateau(monitor='loss',patience=3, verbose=1,factor=0.2,min_lr=0.00001 ) | Digit Recognizer |
4,861,518 | prices = pd.read_parquet(input_path/'prices.parquet')
prices<load_from_csv> | 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(tra... | Digit Recognizer |
4,861,518 | cal = pd.read_parquet(input_path/'calendar.parquet')
cal = cal.rename(columns={'date': 'ds'})
cal.head()<choose_model_class> | model.fit_generator(datagen.flow(train_x,train_y,batch_size = 100),epochs = 30,steps_per_epoch=train_x.shape[0] // 100, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
4,861,518 | lgb_params = {
'objective': 'poisson',
'metric': 'rmse',
'force_row_wise': True,
'learning_rate': 0.075,
'bagging_freq': 1,
'bagging_fraction': 0.75,
'lambda_l2': 0.1,
'n_estimators': 1200,
'num_leaves': 128,
'min_data_in_leaf': 100,
}
model = lgb.LGBMRegressor(**lgb_params)
model<define_variables> | y_pred = model.predict(test ) | Digit Recognizer |
4,861,518 | ts = TimeSeries(
freq='D',
lags=[7, 28],
lag_transforms = {
7: [(rolling_mean, 7),(rolling_mean, 28)],
28: [(rolling_mean, 7),(rolling_mean, 28)],
},
date_features=['year', 'month', 'day', 'dayofweek', 'quarter', 'week'],
)
ts<prepare_output> | y_pred = np.array(y_pred ) | Digit Recognizer |
4,861,518 | fcst = Forecast(model, ts )<define_variables> | y_pred_final = []
for i in y_pred:
y_pred_final.append(np.argmax(i))
| Digit Recognizer |
4,861,518 | <prepare_x_and_y><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("digit_mnist.csv",index=False ) | Digit Recognizer |
5,146,253 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_model> | warnings.filterwarnings(category=FutureWarning, action="ignore")
%matplotlib inline
backend.set_image_data_format('channels_last')
DATA_PATH = '.. /input/'
SERIES = 'A'
VERSION = 1
print('{:s}{:d}'.format(SERIES, VERSION))
| Digit Recognizer |
5,146,253 | %time fcst.model.fit(X_train, y_train, eval_set=[(X_train, y_train),(X_valid, y_valid)], verbose=20 )<predict_on_test> | train_data = pd.read_csv(DATA_PATH+'train.csv')
train_data.head() | Digit Recognizer |
5,146,253 | def my_predict_fn(model, new_x, features_order, alpha):
new_x = new_x.reset_index()
new_x = new_x.merge(cal)
new_x = new_x.merge(prices)
new_x = new_x.sort_values('unique_id')
new_x = new_x[features_order]
predictions = model.predict(new_x)
return alpha * predictions<define_variables> | test_data = pd.read_csv(DATA_PATH+'test.csv')
test_data.index =([x+1 for x in range(test_data.shape[0])])
print(test_data.shape)
test_data.head()
| Digit Recognizer |
5,146,253 | fcst.ts.num_threads<predict_on_test> | def get_model_params(layers)-> str:
res = {}
for layer in layers:
lres = {}
config = layer.get_config()
for key in ['filters', 'kernel_size', 'activation', 'pool_size',
'padding', 'strides', 'rate', 'units', 'kernel_regularizer',
'batch_input_shape']:
if key in config.keys() :
lres[key] = config[key]
res[layer.get_conf... | Digit Recognizer |
5,146,253 | %%time
alphas = [1.028, 1.023, 1.018]
preds = None
for alpha in alphas:
alpha_preds = fcst.predict(28, my_predict_fn, alpha=alpha)
alpha_preds = alpha_preds.set_index('ds', append=True)
if preds is None:
preds = 1 / 3 * alpha_preds
else:
preds += 1 / 3 * alpha_preds
preds<rename_columns> | x_train = train_data.iloc[:, 1:].values.reshape(
(train_data.shape[0], 28, 28, 1)).astype('float32')
x_train = x_train / 255.0
x_test = test_data.values.reshape(
(test_data.shape[0], 28, 28, 1)).astype('float32')
x_test = x_test / 255.0
lb = LabelBinarizer()
y_train_ = lb.fit_transform(train_data.iloc[:, 0])
| Digit Recognizer |
5,146,253 | wide = preds.reset_index().pivot_table(index='unique_id', columns='ds')
wide.columns = [f'F{i+1}' for i in range(28)]
wide.columns.name = None
wide.index.name = 'id'
wide<save_to_csv> | train_gen = ImageDataGenerator(
rotation_range=9,
zoom_range=0.09,
width_shift_range=0.09,
height_shift_range=0.11,
validation_split=0.05
)
train_gen.fit(x_train)
train_iterator = train_gen.flow(
x=x_train, y=y_train_, batch_size=256, subset='training')
val_iterator = train_gen.flow(
x=x_train, y=y_train_, batch... | Digit Recognizer |
5,146,253 | sample_sub = pd.read_csv(
'.. /input/m5-forecasting-accuracy/sample_submission.csv', index_col='id'
)
sample_sub.update(wide)
np.testing.assert_allclose(sample_sub.sum().sum() , preds['y_pred'].sum())
sample_sub.to_csv('submission.csv' )<set_options> | model = Sequential([
Conv2D(filters=128, kernel_size=(3, 3),
activation='relu', input_shape=(28, 28, 1)) ,
MaxPooling2D(pool_size=(2, 2)) ,
Conv2D(filters=256, kernel_size=(3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)) ,
Conv2D(filters=512, kernel_size=(4, 4), activation='relu'),
MaxPooling2D(pool_size=(2, ... | Digit Recognizer |
5,146,253 | warnings.filterwarnings("ignore")
pd.set_option('display.max_columns', 100)
pd.set_option('display.max_rows', 100)
DATA_PATH = '.. /input/jane-street-market-prediction/'
NFOLDS = 5
TRAIN = False
CACHE_PATH = '.. /input/mlp012003weights'
def save_pickle(dic, save_path):
with open(save_path, 'wb')as f:
pickle.dump(dic... | NEPOCHS = 300
early_stopping_cb = EarlyStopping(monitor='val_acc', min_delta=1e-5,
patience=15, restore_best_weights=True)
rl_reduce = ReduceLROnPlateau(monitor='val_loss', patience=10,factor=0.25,verbose=1,min_delta=1e-5)
opt_rms = RMSprop(learning_rate=1e-3, centered=False)
model.compile(loss='categorical_crossent... | Digit Recognizer |
5,146,253 | <choose_model_class><EOS> | test_gen = ImageDataGenerator(
rotation_range=9,
zoom_range=0.09,
width_shift_range=0.09,
height_shift_range=0.11,
)
test_gen.fit(x_test)
test_iterator = test_gen.flow(x=x_test, batch_size=len(x_test), shuffle=False)
test_x = test_iterator.next()
test_x
res = model.predict(test_x)
y_pred = pd.DataFrame([test_data... | Digit Recognizer |
4,082,669 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_pretrained> | %matplotlib inline | Digit Recognizer |
4,082,669 | embNN_model = Emb_NN_Model()
try:
embNN_model.load_state_dict(torch.load(".. /input/jane-embnn5-auc-400-400-400/Jane_EmbNN5_auc_400_400_400.pth"))
except:
embNN_model.load_state_dict(torch.load(".. /input/jane-embnn5-auc-400-400-400/Jane_EmbNN5_auc_400_400_400.pth", map_location='cpu'))
embNN_model = embNN_model.eval()... | path = Path('.. /input/')
!ls.. /input | Digit Recognizer |
4,082,669 | env = janestreet.make_env()
env_iter = env.iter_test()<concatenate> | class CustomImageItemList(ImageList):
def open(self, fn):
img = fn.reshape(28, 28)
img = np.stack(( img,)*3, axis=-1)
return Image(pil2tensor(img, dtype=np.float32))
@classmethod
def from_csv_custom(cls, path:PathOrStr, csv_name:str, imgIdx:int=1, header:str='infer', **kwargs)-> 'ItemList':
df = pd.read_csv(Path(path... | Digit Recognizer |
4,082,669 | if True:
for(test_df, pred_df)in tqdm(env_iter):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, feat_cols].values
if np.isnan(x_tt.sum()):
x_tt = np.nan_to_num(x_tt)+ np.isnan(x_tt)* f_mean
cross_41_42_43 = x_tt[:, 41] + x_tt[:, 42] + x_tt[:, 43]
cross_1_2 = x_tt[:, 1] /(x_tt[:, 2] + 1e-5)
feature_inp = np.con... | test = CustomImageItemList.from_csv_custom(path=path, csv_name='test.csv', imgIdx=0)
data =(CustomImageItemList.from_csv_custom(path=path, csv_name='train.csv')
.random_split_by_pct (.2)
.label_from_df(cols='label')
.add_test(test, label=0)
.databunch(bs=64, num_workers=0)
.normalize(imagenet_stats)) | Digit Recognizer |
4,082,669 | pd.set_option('display.max_columns', 100)
pd.set_option('display.max_rows', 100)
DATA_PATH = '.. /input/jane-street-market-prediction/'
NFOLDS = 5
TRAIN = False
CACHE_PATH = '.. /input/mlp012003weights'
def save_pickle(dic, save_path):
with open(save_path, 'wb')as f:
pickle.dump(dic, f)
def load_pickle(load_path):
w... | data.show_batch(rows=3, figsize=(6,6)) | Digit Recognizer |
4,082,669 | SEED = 1111
np.random.seed(SEED)
def create_mlp(
num_columns, num_labels, hidden_units, dropout_rates, label_smoothing, learning_rate
):
inp = tf.keras.layers.Input(shape=(num_columns,))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)... | learn = cnn_learner(data, models.resnet50, metrics=accuracy, model_dir='/tmp/models')
learn.lr_find() | Digit Recognizer |
4,082,669 | if True:
env = janestreet.make_env()
env_iter = env.iter_test()
for(test_df, pred_df)in tqdm(env_iter):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, feat_cols].values
if np.isnan(x_tt.sum()):
x_tt = np.nan_to_num(x_tt)+ np.isnan(x_tt)* f_mean
cross_41_42_43 = x_tt[:, 41] + x_tt[:, 42] + x_tt[:, 43]
cross_1_2 ... | %time learn.fit(2,slice(1e-2)) | Digit Recognizer |
4,082,669 | train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv' )<prepare_x_and_y> | learn.precompute=False
learn.unfreeze() | Digit Recognizer |
4,082,669 | train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
features_mean = []
features = [c for c in train.columns if 'feature' in c]
for i in features:
x = train[i].mean()
features_mean.append(x)
train[i] = train[i].fillna(x)
train['action'] =(( train['resp'].values)> 0 ).astype(... | lr = np.array([0.001, 0.0075, 0.01] ) | Digit Recognizer |
4,082,669 | f = np.median
f_mean = np.mean(train[features[1:]].values,axis=0 )<drop_column> | learn.fit_one_cycle(9,slice(2e-3,2e-5), wd=.1 ) | Digit Recognizer |
4,082,669 | del train<define_search_space> | test_pred, test_y, test_loss = learn.get_preds(ds_type=DatasetType.Test, with_loss=True ) | Digit Recognizer |
4,082,669 | epochs = 200
batch_size = 4096
hidden_units = [160, 160]
dropout_rates = [0.20, 0.20, 0.20]
label_smoothing = 1e-2
learning_rate = 1e-3<choose_model_class> | submission_df = pd.DataFrame({'ImageId': range(1, len(test_y)+ 1), 'Label': result}, columns=['ImageId', 'Label'])
submission_df.head() | Digit Recognizer |
4,082,669 | def create_mlp(num_columns, num_labels, hidden_units, dropout_rates, label_smoothing, learning_rate):
inp = tf.keras.layers.Input(shape=(num_columns,))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)) :
x = tf.keras.layers.Dense(hidden_u... | submission_df.to_csv("submission.csv",index=None ) | Digit Recognizer |
6,393,530 | clf.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=2 )<drop_column> | import keras
import numpy as np
import pandas as pd | Digit Recognizer |
6,393,530 | del X_train
del y_train<find_best_params> | train_df=pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test_df=pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
6,393,530 | models = []
models.append(clf)
th = 0.503<categorify> | target=train_df["label"]
train_df.drop("label",axis=1,inplace=True ) | Digit Recognizer |
6,393,530 | env = janestreet.make_env()
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
if np.isnan(x_tt[:, 1:].sum()):
x_tt[:, 1:] = np.nan_to_num(x_tt[:, 1:])+ np.isnan(x_tt[:, 1:])* f_mean
pred = np.mean([model(x_tt, training = False ).numpy() for model in m... | train_df=train_df/255
test_df=test_df/255 | Digit Recognizer |
6,393,530 | warnings.filterwarnings("ignore")
<load_from_csv> | X_train=train_df.values.reshape(-1,28,28,1)
test=test_df.values.reshape(-1,28,28,1 ) | Digit Recognizer |
6,393,530 | %%time
train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train = train.astype({c: np.float32 for c in train.select_dtypes(include='float64' ).columns} )<data_type_conversions> | y_train=to_categorical(target,num_classes=10 ) | Digit Recognizer |
6,393,530 | train.fillna(train.mean() ,inplace=True )<data_type_conversions> | X_train,X_test,y_train,y_test=train_test_split(X_train,y_train,test_size=0.10,random_state=42 ) | Digit Recognizer |
6,393,530 | train['action'] =(train['resp'] > 0 ).astype('int' )<define_variables> | batch_size=128
num_classes=10
epochs=20
inputshape=(28,28,1 ) | Digit Recognizer |
6,393,530 | resp_cols = ['resp_1', 'resp_2', 'resp_3', 'resp_4', 'resp']<split> | model=Sequential()
model.add(Conv2D(32,kernel_size=(5,5),activation="relu",input_shape=inputshape))
model.add(Conv2D(64,(3,3),activation="relu"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(128,kernel_size=(5,5),activation="relu"))
model.add(Conv2D(128,(3,3),activation="relu"))
model.add(Dropout(0.25))
m... | Digit Recognizer |
6,393,530 | features_train_data = train.iloc[:,7:137]<define_variables> | reduce_learning_rate = ReduceLROnPlateau(monitor = 'val_accuracy', patience = 3, verbose = 1, factor = 0.3, min_lr = 0.00001)
checkpoint = ModelCheckpoint('save_weights.h5', monitor = 'val_accuracy', verbose = 1, save_best_only = True, mode = 'max')
early_stopping = EarlyStopping(monitor = 'val_loss', min_delta = 1e-... | Digit Recognizer |
6,393,530 | all_drop_cols = set(high_correlations.index.get_level_values(0))<compute_train_metric> | model.fit(X_train,y_train,batch_size=batch_size,epochs=epochs,validation_data=(X_test,y_test),callbacks=callbacks)
accuracy=model.evaluate(X_test,y_test ) | Digit Recognizer |
6,393,530 | <prepare_x_and_y><EOS> | pred = model.predict_classes(test)
res = pd.DataFrame({"ImageId":list(range(1,28001)) ,"Label":pred})
res.to_csv("output.csv", index = False ) | Digit Recognizer |
6,732,418 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | %matplotlib inline
np.random.seed(17)
sns.set(style='white', context='notebook', palette='deep')
for dirname, _, filenames in os.walk('/kaggle/input/digit-recognizer'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Digit Recognizer |
6,732,418 | HIDDEN_LAYER_1 = [256, 256]
HIDDEN_LAYER_2 = [160, 160, 160]
HIDDEN_LAYER_3 = [128, 128, 128, 128]
TARGET_NUM = 5
input = tf.keras.layers.Input(shape=(X_train.shape[1],))
x1 = tf.keras.layers.BatchNormalization()(input)
x1 = tf.keras.layers.Dropout(0.25 )(x1)
for units in HIDDEN_LAYER_1:
x1 = tf.keras.layers.Dense(un... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
6,732,418 | history = model.fit(
x = X_train,
y = y_train,
epochs=25,
batch_size=4096,
validation_data=(X_valid, y_valid),
)
models = []
models.append(model )<find_best_model_class> | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
sns.countplot(Y_train)
plt.show() | Digit Recognizer |
6,732,418 | THRESHOLD = 0.502
janestreet.make_env.__called__ = False
env = janestreet.make_env()
print('predicting...')
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
X_test = test_df.loc[:, features].values
if np.isnan(X_test.sum()):
X_test = np.nan_to_num(X_test)+ np.isnan(X_test)* f_mean.values... | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
6,732,418 | SEED = 1111
np.random.seed(SEED)
train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
cols_to_remove = ['feature_26', 'feature_36', 'feature_24', 'feature_34', 'feature_12', 'feature_22', 'feature_32', 'feature_8', 'feature_18', 'feature_28', 'feature_108', 'feature_114', 'feature_101', 'feature_1... | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
6,732,418 | train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
train.fillna(train.mean() ,inplace=True)
train['action'] =(( train['resp'].values)> 0 ).astype(int)
features = [c for c in train.columns if "feature" in c]
f_mean = np.mean(train[features[1:]].values,axis=0)
resp_cols = [... | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
6,732,418 | Image(".. /input/tf-model-garden-official-models/TF.png" )<import_modules> | random_seed = 2 | Digit Recognizer |
6,732,418 | import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, BatchNormalization, Dropout, Concatenate, Lambda, GaussianNoise, Activation
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.optimizers import Adam
from tensorflow.... | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
6,732,418 | NFOLDS = 5
train_all = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train_all = train_all[train_all.date > 85].reset_index(drop = True)
train_all = train_all[train_all['weight'] != 0]
train_all.fillna(train_all.mean() ,inplace=True )<prepare_x_and_y> | 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(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
6,732,418 | train_all['date_bin'] =(pd.qcut(train_all['date'], q=4, labels=False)+1)*train_all['feature_0']
features = [c for c in train_all.columns if "feature" in c]
f_mean = np.mean(train_all[features[1:]].values,axis=0)
resp_cols = ['resp_1', 'resp_2', 'resp_3', 'resp', 'resp_4']
X_train = train_all.loc[:, train_all.columns.s... | plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)
Image("model.png" ) | Digit Recognizer |
6,732,418 | skf = StratifiedKFold(n_splits=NFOLDS, shuffle = True, random_state = 42)
result = next(skf.split(X_train, X_train.date_bin), None)
train = train_all.iloc[result[0]].reset_index(drop=True)
valid = train_all.iloc[result[1]].reset_index(drop=True )<drop_column> | model.compile(optimizer = 'nadam' , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
6,732,418 | del train, valid, train_all, result<choose_model_class> | callbacks_list = [
ReduceLROnPlateau(
monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=1e-05),
ModelCheckpoint(
filepath='MNIST_CNN_model.h5',
monitor='val_accuracy',
save_best_only=True
)] | Digit Recognizer |
6,732,418 | MNAME = 'model'
def get_callbacks(idx):
mc = ModelCheckpoint(MNAME+"-{}.h5".format(idx), save_best_only=True)
rp = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=0.00001)
es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=False)
return [mc, rp, es]
def create_dnn(num_colum... | epochs = 50
batch_size = 512 | Digit Recognizer |
6,732,418 | skf = StratifiedKFold(n_splits=NFOLDS, shuffle = True, random_state = 42)
history = []
for i in range(NFOLDS):
print('fold {}'.format(i))
result = next(skf.split(X_train, X_train.date_bin), None)
X_tr = X_train.iloc[result[0]].reset_index(drop=True)
X_tr.drop(labels='date_bin', axis = 1, inplace=True)
y_tr = y_trai... | 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 |
6,732,418 | env = janestreet.make_env()<correct_missing_values> | history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size,
callbacks=callbacks_list ) | Digit Recognizer |
6,732,418 | @njit
def fillna_npwhere_njit(array, values):
if np.isnan(array.sum()):
array = np.where(np.isnan(array), values, array)
return array<load_pretrained> | model = load_model('MNIST_CNN_model.h5' ) | Digit Recognizer |
6,732,418 | th = 0.501
clf0 = tf.keras.models.load_model("model-0.h5")
clf2 = tf.keras.models.load_model("model-2.h5")
clf4 = tf.keras.models.load_model("model-4.h5")
models = [clf0, clf2, clf4]
test_df_columns = ['weight'] + [f'feature_{i}' for i in range(130)] + ['date']
index_features = [n for n,col in enumerate(test_df_colu... | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
6,732,418 | <load_from_csv><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
7,429,783 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import keras
import tensorflow
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report,accuracy_score
from keras.models import Sequential
from keras.layers import Convolution2D,Max... | Digit Recognizer |
7,429,783 | class UtilityScoreCallback(tf.keras.callbacks.Callback):
def __init__(self, X, date, weight, resp, batch_size = 1024,
early_stopping_patience = 30, plateau_patience = 10, min_lr = 1e-6,
reduction_rate = 0.3, stage = 'train', fold_n = 0, verbose = 1):
super(Callback, self ).__init__()
self.X = X
self.date = date
self.we... | df_train=pd.read_csv('.. /input/digit-recognizer/train.csv')
df_test=pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
7,429,783 | def create_resnet(num_columns, num_labels, hidden_units, dropout_rates, label_smoothing, learning_rate):
inp = tf.keras.layers.Input(shape=(num_columns,))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)) :
x = tf.keras.layers.Dense(hidde... | print(type(df_test))
print(type(df_train))
df_test.isnull().sum()
df_train.isnull().sum()
df_test.isnull().sum().sum()
df_train.isnull().sum().sum() | Digit Recognizer |
7,429,783 | batch_size = 2048
hidden_units = [150, 150, 150]
dropout_rates = [0.25, 0.25, 0.25, 0.25]
label_smoothing = 1e-3
learning_rate = 1e-3
folds = 5
train_mode = True
opt_th_cross = 0.5<train_model> | classifier = Sequential()
classifier.add(Convolution2D(filters = 128, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
classifier.add(MaxPooling2D(pool_size=(2,2)))
classifier.add(BatchNormalization())
classifier.add(Convolution2D(filters = 128, kernel_size =(5,5),padding = 'Same',
a... | Digit Recognizer |
7,429,783 | if train_mode:
clf = create_resnet(len(features), 5, hidden_units, dropout_rates, label_smoothing, learning_rate)
clf.fit(train.loc[:, features].values,(train.loc[:,resp_cols] > 0 ).astype(int), epochs=150, batch_size=batch_size, shuffle=True)
<categorify> | classifier.add(Convolution2D(filters =256, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
classifier.add(BatchNormalization())
classifier.add(MaxPooling2D(pool_size=(2,2)))
classifier.add(Convolution2D(filters = 256, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
classifier.add(BatchNormalizatio... | Digit Recognizer |
7,429,783 | models = []
clf.call = tf.function(clf.call, experimental_relax_shapes=True)
models.append(clf )<split> | classifier.add(Flatten())
classifier.add(Dense(256, activation = "relu"))
classifier.add(Dropout(0.3))
classifier.add(Dense(10, activation = "softmax")) | Digit Recognizer |
7,429,783 | env = janestreet.make_env()
env_iter = env.iter_test()<feature_engineering> | classifier.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy'] ) | Digit Recognizer |
7,429,783 | for(test_df, pred_df)in tqdm(env_iter):
if test_df['weight'].values[0] > 0:
test_df = test_df.loc[:, features].values
if np.isnan(test_df[:, 1:].sum()):
test_df[:, 1:] = np.nan_to_num(test_df[:, 1:])+ np.isnan(test_df[:, 1:])* f_mean
pred = np.mean([model(test_df, training = False ).numpy() for model in models],axis=0)... | classifier.fit(target,label_cat,epochs=50 ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.