kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,081,536 | train_user_df.secs_elapsed.fillna(-1,inplace=True)
train_user_df.action.fillna(-1,inplace=True)
train_user_df.iloc[:,-11:]=train_user_df.iloc[:,-11:].fillna(-1)
train_user_df['secs_elapsed']=train_user_df['secs_elapsed'].astype('int64')
train_user_df['action']=train_user_df['action'].astype('int64' )<data_type_conv... | x_train,x_val,y_train,y_val=train_test_split(x,y,test_size=0.1,random_state=0 ) | Digit Recognizer |
4,081,536 | test_user_df.secs_elapsed.fillna(-1,inplace=True)
test_user_df.action.fillna(-1,inplace=True)
test_user_df.iloc[:,-11:]=test_user_df.iloc[:,-11:].fillna(-1)
test_user_df['secs_elapsed']=test_user_df['secs_elapsed'].astype('int64')
test_user_df['action']=test_user_df['action'].astype('int64' )<count_missing_values> | x_train=x_train.values
y_train=y_train.values
x_val=x_val.values
y_val=y_val.values
x_test=x_test.values | Digit Recognizer |
4,081,536 | train_user_df.isnull().sum() /train_user_df.shape[0] *100<define_variables> | x_train=x_train.reshape(37800,28,28,1)
x_val=x_val.reshape(4200,28,28,1)
x_test=x_test.reshape(28000,28,28,1 ) | Digit Recognizer |
4,081,536 | categorical_cols=[cname for cname in train_user_df.columns if cname not in ['id','date_account_created','date_first_booking','first_device_type','first_browser',
'timestamp_first_active','country_destination'] and
train_user_df[cname].dtype == "object"]
numerical_cols=[cname for cname in train_user_df.columns if cname ... | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64... | Digit Recognizer |
4,081,536 | categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
numerical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant'))
])
preprocessor = ColumnTransformer(
transformers=[
('cat', categorical_trans... | model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta() ,
metrics=['accuracy'] ) | Digit Recognizer |
4,081,536 | test_id = test_user_df.id
test_X = test_user_df.drop(['id'], axis='columns' )<categorify> | model.fit(x_train, y_train,
batch_size=128,
epochs=15,
verbose=1,
validation_data=(x_val, y_val)) | Digit Recognizer |
4,081,536 | labels = train_user_df.country_destination
le = LabelEncoder()
train_y = le.fit_transform(labels )<drop_column> | pred=model.predict(x_test,verbose=0)
new_pred = [np.argmax(y, axis=None, out=None)for y in pred]
output=pd.DataFrame({'ImageId':sub['ImageId'],'Label':new_pred})
output.to_csv('Digit_recognizer.csv', index=False ) | Digit Recognizer |
1,029,364 | train_X = train_user_df.drop(['id','country_destination'], axis='columns' )<find_best_model_class> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
| Digit Recognizer |
1,029,364 | def cross_validation_with_ndcg(pipe, X, y, scorer, cv=5):
skf = StratifiedKFold(n_splits=cv, shuffle=True, random_state=100)
scores = []
for train_index, holdout_index in skf.split(X, y):
X_train, X_test = X.iloc[train_index], X.iloc[holdout_index]
y_train, y_test = y[train_index], y[holdout_index]
pipe.fit(X_train, y... | label = np.array(train.iloc[:,0],np.str)
data = np.array(train.iloc[:,1:],np.float32)
label_test = np.array([])
data_test = np.array(test.iloc[:,:],np.float32)
| Digit Recognizer |
1,029,364 | n_estimaters_param=[50, 100, 200]
max_depth_param=[3,4,5]
learning_rate_param=[0.1,0.2]
params = [(x, y, z)for x in learning_rate_param for y in n_estimaters_param for z in max_depth_param]
result_list=[]
for learning_rates,n_estimaters, max_depth in params:
xg_model_ = XGBClassifier(max_depth=max_depth,learning_rate=l... | data = data.reshape(data.shape[0],28,28,1)
data_test = data_test.reshape(data_test.shape[0],28,28,1)
data = data/255
data_test = data_test/255 | Digit Recognizer |
1,029,364 | result_df=pd.DataFrame(result_list,columns=['learning_rate','n_estimator','max_depth','mean_score'])
result_df.sort_values(by='mean_score',ascending=False ).head(5 )<train_model> | print("Before conding")
print(label[:10])
labels = np_utils.to_categorical(label,10)
print("Encoded Data")
print(labels[:10] ) | Digit Recognizer |
1,029,364 | xg_model = XGBClassifier(max_depth=5,learning_rate=0.1, n_estimators=200,verbosity=0,objective='multi:softprob',n_jobs=-1)
pipe = Pipeline([
('customproccess',Custom_Proccess()),
('preprocessor', preprocessor),
("model", xg_model)
])
pipe.fit(train_X, train_y)
predict = pipe.predict_proba(test_X )<feature_engine... | def model_generator(dropout=[0.25],denses=[512,10],activation="relu"):
model = Sequential()
model.add(Conv2D(filters=32,kernel_size=3,padding='same', activation='relu', input_shape=(28, 28,1)))
model.add(Conv2D(filters=32, kernel_size=3, border_mode='same', activation='relu'))
model.add(MaxPool2D(pool_size=3))
model.a... | Digit Recognizer |
1,029,364 | ids = []
cts = []
for i in range(len(test_id)) :
idx = test_id[i]
ids += [idx] * 5
cts += le.inverse_transform(np.argsort(predict[i])[::-1])[:5].tolist()<save_to_csv> | def model_generator2(dropout=[0.25],denses=[512,10],activation="relu"):
model = Sequential()
model.add(Conv2D(filters=16,kernel_size=2,padding='same', activation='relu', input_shape=(28, 28,1)))
model.add(MaxPool2D(pool_size=2))
model.add(Dropout(0.20))
model.add(Conv2D(filters=32, kernel_size=2, border_mode='same', a... | Digit Recognizer |
1,029,364 | sub_df = pd.DataFrame(np.column_stack(( ids, cts)) , columns=['id', 'country'])
sub_df.to_csv('sub-03.csv',index=False )<load_from_csv> | def model_fit(model,batch_size=64,epochs=10):
optimizer = Adam(lr=0.0001)
model.compile(loss="categorical_crossentropy",optimizer=optimizer,metrics=['accuracy'])
checkpointer = ModelCheckpoint(filepath='mnist.model.best', verbose=1, monitor='val_loss', save_best_only=True)
training = model.fit(data, labels,batch_siz... | Digit Recognizer |
1,029,364 | train = pd.read_csv('.. /input/airbnb-recruiting-new-user-bookings/train_users_2.csv.zip')
age_gender = pd.read_csv('.. /input/airbnb-recruiting-new-user-bookings/age_gender_bkts.csv.zip')
countries_df = pd.read_csv('.. /input/airbnb-recruiting-new-user-bookings/countries.csv.zip')
session_df = pd.read_csv('.. /inpu... | model1 = model_generator(dropout=[0.25],denses=[128,10],activation="relu")
training = model_fit(model1,batch_size=128,epochs=100 ) | Digit Recognizer |
1,029,364 | def glimpse(df, maxvals=10, maxlen=110):
print('Shape: ', df.shape)
def pad(y):
max_len = max([len(x)for x in y])
return [x.ljust(max_len)for x in y]
toprnt = pad(df.columns.tolist())
toprnt = pad([toprnt[i] + ' ' + str(df.iloc[:,i].dtype)for i in range(df.shape[1])])
num_nas = [df.iloc[:,i].isnull().sum() for i in... | def scoring(model):
model.load_weights('mnist.model.best')
score = model.evaluate(data[:2000], labels[:2000], verbose=0)
accuracy = 100*score[1]
print('Test accuracy: %.4f%%' % accuracy)
label_test = model.predict_classes(data_test)
print("Sample of the prdiction",label_test[:10])
return label_test | Digit Recognizer |
1,029,364 | train.first_affiliate_tracked.value_counts()<count_values> | label_test = scoring(model1 ) | Digit Recognizer |
1,029,364 | <count_duplicates><EOS> | np.savetxt("submission.csv", np.dstack(( np.arange(1, label_test.size+1),label_test)) [0],"%d,%d",header="ImageId,Label",comments="" ) | Digit Recognizer |
1,278,424 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | %matplotlib inline
np.random.seed()
sns.set(style='white', context='notebook', palette='deep')
print("Done" ) | Digit Recognizer |
1,278,424 | train['gender'].value_counts()<feature_engineering> | dataset = pd.read_csv(".. /input/train.csv")
competition_dataset = pd.read_csv(".. /input/test.csv")
dataset.describe
| Digit Recognizer |
1,278,424 | train['age'] = train['age'].apply(lambda x: 122 if x > 122 else x)
train['age'] = train['age'].apply(lambda x: 18 if x < 18 else x )<feature_engineering> | del dataset
print("Done" ) | Digit Recognizer |
1,278,424 | test['age'] = test['age'].apply(lambda x: 122 if x > 122 else x)
test['age'] = test['age'].apply(lambda x: 18 if x < 18 else x )<count_values> | label = to_categorical(label, num_classes = 10)
feature = feature / 255.0
competition_dataset = competition_dataset / 255.0
print("Done" ) | Digit Recognizer |
1,278,424 | train['signup_flow'].value_counts()<count_values> | feature_train, feature_val, label_train, label_val = train_test_split(feature, label, test_size = 0.1, stratify=label ) | Digit Recognizer |
1,278,424 | train['signup_method'].value_counts()<count_duplicates> | model_1 = Sequential()
model_1.add(Dense(200, activation = "relu", input_shape =(784,)))
model_1.add(Dense(100, activation = "relu"))
model_1.add(Dense(60, activation = "relu"))
model_1.add(Dense(30, activation = "relu"))
model_1.add(Dense(10, activation = "softmax"))
optimizer = optimizers.SGD(lr=0.03, clipnorm=5.)
m... | Digit Recognizer |
1,278,424 | train[train.duplicated() ]<count_values> | history = model_1.fit(feature_train, label_train, batch_size = 100, epochs = 8,
validation_data =(feature_val, label_val), verbose = 1)
| Digit Recognizer |
1,278,424 | session_df['device_type'].value_counts()<count_values> | feature_train, feature_val, label_train, label_val = train_test_split(feature, label, test_size = 0.1, stratify=label ) | Digit Recognizer |
1,278,424 | session_df['action_detail'].value_counts() [:10]<filter> | model_2 = Sequential()
model_2.add(Conv2D(filters = 4, kernel_size =(5,5), strides = 1, padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model_2.add(Conv2D(filters = 8, kernel_size =(4,4), strides = 2, padding = 'Same',
activation ='relu'))
model_2.add(Conv2D(filters = 12, kernel_size =(4,4), strides = 2... | Digit Recognizer |
1,278,424 | view_search_time = session_df[session_df.action_detail == 'view_search_results']
view_search_time<drop_column> | history = model_2.fit(feature_train, label_train, batch_size = 100, epochs = 16,
validation_data =(feature_val, label_val), verbose = 1)
| Digit Recognizer |
1,278,424 | labels = train['country_destination']
train.drop('country_destination', inplace = True, axis = 1 )<concatenate> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(fea... | Digit Recognizer |
1,278,424 | data = pd.concat(( train, test), axis=0, ignore_index=True)
data = data.drop(['id', 'date_first_booking'], axis=1 )<categorify> | model_3 = Sequential()
model_3.add(Conv2D(filters = 6, kernel_size =(6,6), strides = 1, padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model_3.add(Conv2D(filters = 12, kernel_size =(5,5), strides = 2, padding = 'Same',
activation ='relu'))
model_3.add(Conv2D(filters = 24, kernel_size =(4,4), strides = ... | Digit Recognizer |
1,278,424 | cat_features = ['gender', 'signup_method', 'signup_flow', 'language', 'affiliate_channel',
'affiliate_provider', 'first_affiliate_tracked', 'signup_app', 'first_device_type', 'first_browser']
for f in cat_features:
data_dummy = pd.get_dummies(data[f], prefix=f)
data.drop([f], axis=1, inplace = True)
data = pd.concat(... | history = model_3.fit(datagen.flow(feature_train,label_train, batch_size=100),
epochs = 8, validation_data =(feature_val, label_val),
verbose = 2 ) | Digit Recognizer |
1,278,424 | from datetime import datetime
from sklearn.preprocessing import LabelEncoder<data_type_conversions> | model_4 = Sequential()
model_4.add(Conv2D(filters = 32, kernel_size =(5,5), strides = 1, padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model_4.add(BatchNormalization())
model_4.add(Conv2D(filters = 32, kernel_size =(5,5), strides = 1, padding = 'Same',
activation ='relu'))
model_4.add(BatchNormalizat... | Digit Recognizer |
1,278,424 | data['date_account_created'] = pd.to_datetime(data['date_account_created'] )<feature_engineering> | history = model_4.fit(datagen.flow(feature_train,label_train, batch_size=100),
epochs = 35, validation_data =(feature_val, label_val),
verbose = 2, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
1,278,424 | data['ac_year'] = data['date_account_created'].dt.year
data['ac_month'] = data['date_account_created'].dt.month
data['ac_day'] = data['date_account_created'].dt.day<drop_column> | results = model_4.predict(competition_dataset)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
1,278,424 | <data_type_conversions><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission_MNIST.csv",index=False)
| Digit Recognizer |
797,209 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | %matplotlib inline
| Digit Recognizer |
797,209 | data['ts_fa_year'] = data['timestamp_first_active'].dt.year
data['ts_fa_month'] = data['timestamp_first_active'].dt.month
data['ts_fa_day'] = data['timestamp_first_active'].dt.day<drop_column> | train = pd.read_csv(".. /input/train.csv" ).values
test = pd.read_csv(".. /input/test.csv" ).values
X_train = train[:, 1:].astype('float32')
Y_train = train[:, 0].astype('int32')
X_test = test[:, :].astype('float32' ) | Digit Recognizer |
797,209 | data.drop('timestamp_first_active', inplace = True, axis = 1 )<categorify> | X_train = X_train/255.
X_test = X_test/255.
X_train = X_train.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
Y_train = to_categorical(Y_train, num_classes=10)
X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size=0.15, random_state=23)
datagen = ImageDataGenerator(
rotation... | Digit Recognizer |
797,209 | le = LabelEncoder()
y = le.fit_transform(labels )<prepare_x_and_y> | model = Sequential()
model.add(Conv2D(16, kernel_size=(5, 5),
activation='relu',
input_shape=(28, 28, 1)))
model.add(Conv2D(32, kernel_size=(3, 3),
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=(... | Digit Recognizer |
797,209 | X = data[:train.shape[0]]
X_test = data[train.shape[0]:]<train_model> | reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.2,
patience=2)
history = model.fit_generator(datagen.flow(X_train, Y_train, batch_size=70),
epochs=20,
validation_data=(X_val, Y_val),
verbose=2,
callbacks=[reduce_lr] ) | Digit Recognizer |
797,209 | xgb = XGBClassifier(use_label_encoder=False)
xgb.fit(X, y)
<predict_on_test> | Y_val_pred = model.predict_classes(X_val)
Y_val_true = np.argmax(Y_val, axis=1)
print(confusion_matrix(Y_val_true, Y_val_pred)) | Digit Recognizer |
797,209 | y_pred = xgb.predict_proba(X_test )<define_variables> | Y_test_pred = model.predict_classes(X_test)
submission = pd.DataFrame({ 'ImageId': range(1, 28001), 'Label': Y_test_pred })
submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
4,899,984 | ids = []
countries = []
test_id = test['id']<categorify> | from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import RMSprop,Adam
from keras.preprocessing.image import ImageDataGenerator | Digit Recognizer |
4,899,984 | for i in range(len(test_id)) :
idx = test_id[i]
ids += [idx] * 5
countries += le.inverse_transform(np.argsort(y_pred[i])[::-1])[:5].tolist()<save_to_csv> | from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from mlxtend.plotting import plot_confusion_matrix | Digit Recognizer |
4,899,984 | submission = pd.DataFrame(np.column_stack(( ids, countries)) , columns=['id', 'country'])
submission.to_csv('submission.csv',index=False )<set_options> | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
4,899,984 | pd.set_option('display.max_columns', 500)
warnings.filterwarnings("ignore" )<load_from_csv> | X_train = train_data.copy()
y_train = train_data['label']
del X_train['label']
X_test = test_data.copy()
y_train = to_categorical(y_train, num_classes = 10 ) | Digit Recognizer |
4,899,984 | %%time
train_cudf = cudf.read_csv('/kaggle/input/jane-street-market-prediction/train.csv')
train = train_cudf.to_pandas()
del train_cudf
features = pd.read_csv('.. /input/jane-street-market-prediction/features.csv')
example_test = pd.read_csv('.. /input/jane-street-market-prediction/example_test.csv')
sample_predict... | X_train = X_train.astype('float32')/255
X_test = X_test.astype('float32')/255 | Digit Recognizer |
4,899,984 | missing_values_count = train.isnull().sum()
print(missing_values_count)
total_cells = np.product(train.shape)
total_missing = missing_values_count.sum()
print("% of missing data = ",(total_missing/total_cells)* 100 )<prepare_x_and_y> | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.1, random_state=2020 ) | Digit Recognizer |
4,899,984 | train = train[train['weight'] != 0]
train = train.query('date > 85' ).reset_index(drop = True)
train = train.astype({c: np.float32 for c in train.select_dtypes(include='float64' ).columns})
train['action'] =(( train['weight'].values * train['resp'].values)> 0 ).astype('int')
train.fillna(train.mean() ,inplace=True)
... | 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,899,984 | del x, y, train, features, example_test, sample_prediction_df<import_modules> | optimizer = RMSprop(lr=0.001,rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
4,899,984 | print("XGBoost version:", xgb.__version__ )<choose_model_class> | model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
4,899,984 | clf = xgb.XGBClassifier(
n_estimators=500,
max_depth=11,
learning_rate=0.05,
subsample=0.9,
colsample_bytree=0.7,
missing=-999,
random_state=2020,
tree_method='gpu_hist'
)<train_model> | epochs = 50
batch_size = 378 | Digit Recognizer |
4,899,984 | %time clf.fit(X_train, y_train )<predict_on_test> | 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,899,984 | TRAINING = True
start_time = time.time()
if TRAINING:
env = janestreet.make_env()
th = 0.5
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, test_df.columns.str.contains('feature')].values
if np.isnan(x_tt[:, 1:].sum()):
x_tt[:, 1:] = np.nan_to_num(x_tt[:, 1:])+ np.is... | history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val, y_val),
steps_per_epoch=X_train.shape[0] // batch_size ) | Digit Recognizer |
4,899,984 | train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train = train.query('weight>0' ).reset_index(drop=True)
train.fillna(train.median() ,inplace=True)
train['feature_stock_id_sum'] = train['feature_41'] + train['feature_42'] + train['feature_43']
train['feature_1_2_cross'] = train['feature_1']/(... | y_test = model.predict(X_test ) | Digit Recognizer |
4,899,984 | features = [c for c in train.columns if 'feature' in c]
f_mean = np.nanmean(train[features[1:]].values,axis=0 )<define_variables> | y_test_classes = np.argmax(y_test, axis = 1 ) | Digit Recognizer |
4,899,984 | PATH ='.. /input/neutralizing2'
<define_variables> | num = range(1, len(y_test)+1)
output = pd.DataFrame({'ImageId': num,
'Label': y_test_classes})
output.to_csv('submission.csv', index=False ) | Digit Recognizer |
4,899,984 | <choose_model_class><EOS> | y_val_pred = model.predict(X_val ) | Digit Recognizer |
10,029,170 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | %matplotlib inline
| Digit Recognizer |
10,029,170 | def set_all_seeds(seed):
np.random.seed(seed)
random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed )<normalization> | mnist_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
mnist_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
10,029,170 | class NeutralizeTransform:
def __init__(self,proportion=1.0):
self.proportion = proportion
def fit(self,X,y):
self.lms = []
self.mean_exposure = np.mean(y,axis=0)
self.y_shape = y.shape[-1]
for x in X.T:
scores = x.reshape(( -1,1))
exposures = y
exposures = np.hstack(( exposures, np.array([np.mean(scores)] * len(expos... | mnist_train.isna().any().any() | Digit Recognizer |
10,029,170 | TRAINING = False<categorify> | 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 |
10,029,170 | %%time
if TRAINING:
mask = train[features].isna()
train.fillna(0,inplace=True)
for feature in features:
nt = NeutralizeTransform(proportion=0.25)
train[feature] = nt.fit_transform(train[feature].values.reshape(( -1,1)) ,
train['resp'].values.reshape(( -1,1)))
pd.to_pickle(nt,f'NeutralizeTransform_{feature}.pkl')
tr... | standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(mnist_train_data)
standardized_data.shape | Digit Recognizer |
10,029,170 | gc.collect()<define_variables> | cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape | Digit Recognizer |
10,029,170 | TRAINING = False<prepare_x_and_y> | lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape | Digit Recognizer |
10,029,170 | X_tr = train.query('date<350')[features].values
y_tr =(train.query('date<350')[resp_cols].values > 0 ).astype(int)
X_val = train.query('date>400')[features].values
y_val =(train.query('date>400')[resp_cols].values > 0 ).astype(int)
del train
gc.collect()
if TRAINING:
metric = {}
for seed in [2020,1982]:
set_all_seeds... | new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack(( new_coordinates, mnist_train_label)).T | Digit Recognizer |
10,029,170 | if not TRAINING:
f = np.median
env = janestreet.make_env()
th = 0.495
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].values[0] > 0:
test_df['feature_stock_id_sum'] = test_df['feature_41'] + test_df['feature_42'] + test_df['feature_43']
test_df['feature_1_2_cross'] = test_df['feature_1']/(test_df['f... | df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head() | Digit Recognizer |
10,029,170 |
<load_from_csv> | pca = decomposition.PCA()
pca.n_components = 2
pca_data = pca.fit_transform(standardized_data)
pca_data.shape | Digit Recognizer |
10,029,170 | start_time = time.time()
train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
print('Load in data successful!')
print('-----------------------------------------------------------------------')
time_passed_m = int(( time.time() - start_time)// 60)
time_passed_s = int(( time.time() - start_time)% ... | pca_data = np.vstack(( pca_data.T, mnist_train_label)).T | Digit Recognizer |
10,029,170 | SEED = 42
np.random.seed(SEED)
TRAINING_PGTS = True
MANUAL_VALIDATING = False
TRAINING = True
print(f'TRAINING_PGTS = {TRAINING_PGTS}
\
MANUAL_VALIDATING = {MANUAL_VALIDATING}
\
TRAINING = {TRAINING}' )<prepare_x_and_y> | df_PCA = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_PCA.head() | Digit Recognizer |
10,029,170 | 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 =... | mnist_train_data = np.array(mnist_train_data)
mnist_train_label = np.array(mnist_train_label ) | Digit Recognizer |
10,029,170 | def create_mlp(num_columns, num_labels, hidden_units,
dropout_rates, label_smoothing, learning_rate):
inp = Input(shape=(num_columns,))
x = BatchNormalization()(inp)
x = Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)) :
x = Dense(hidden_units[i] )(x)
x = BatchNormalization()(x)
x = Activation(tf.ker... | 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 |
10,029,170 | class PurgedGroupTimeSeriesSplit(_BaseKFold):
@_deprecate_positional_args
def __init__(self,
n_splits=5,
*,
max_train_group_size=np.inf,
max_test_group_size=np.inf,
group_gap=None,
verbose=False
):
super().__init__(n_splits, shuffle=False, random_state=None)
self.max_train_group_size = max_train_group_size
self.gro... | 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 |
10,029,170 | n_samples = 2000
n_groups = 20
assert n_samples % n_groups == 0
idx = np.linspace(0, n_samples-1, num=n_samples)
X_train_pgts = np.random.random(size=(n_samples, 5))
y_train_pgts = np.random.choice([0, 1], n_samples)
groups = np.repeat(np.linspace(0, n_groups-1, num=n_groups), n_samples/n_groups)
groups.shape<split> | 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 |
10,029,170 | FOLDS = 5
models = []
if TRAINING_PGTS:
gkf = PurgedGroupTimeSeriesSplit(n_splits=FOLDS, group_gap=20)
splits = list(gkf.split(y_train, groups=train['date'].values))
for fold,(train_indices, test_indices)in tqdm(enumerate(splits)) :
X_train_pgts, X_test_pgts = X_train.iloc[train_indices, :], X_train.iloc[test_indices,... | 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 |
10,029,170 | if MANUAL_VALIDATING:
er = EarlyStopping(patience = 8,
restore_best_weights = True,
monitor = 'val_loss')
ReduceLR = tf.keras.callbacks.ReduceLROnPlateau(monitor = 'val_loss',
factor = 0.1,
patience = 8,
verbose = 1,
mode = 'min')
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
filepath = 'js_model_v... | predictions = cnn_model.predict(mnist_test_arr ) | Digit Recognizer |
10,029,170 | class JSMP_Dataset(Dataset):
def __init__(self, file_path, window_size):
self.file_path = file_path
self.window_size = window_size
train = pd.read_csv(file_path)
train = train.query('date > 85' ).reset_index(drop = True)
train.fillna(train.mean() ,inplace=True)
train['action'] =(( train['resp'].values)> 0 ).astype(i... | predictions_test = []
for i in predictions:
predictions_test.append(np.argmax(i)) | Digit Recognizer |
10,029,170 | window_size = 5
file_path = '/kaggle/input/jane-street-market-prediction/train.csv'
ds = JSMP_Dataset(file_path, window_size )<normalization> | submission = pd.DataFrame({
"ImageId": mnist_test.index+1,
"Label": predictions_test
})
submission.to_csv('my_submission.csv', index=False ) | Digit Recognizer |
10,029,170 | class Chomp1d(nn.Module):
def __init__(self, chomp_size):
super(Chomp1d, self ).__init__()
self.chomp_size = chomp_size
def forward(self, x):
return x[:, :, :-self.chomp_size].contiguous()
class TemporalBlock(nn.Module):
def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.2):
super... | %matplotlib inline
| Digit Recognizer |
10,029,170 | class TCN(nn.Module):
def __init__(self, input_size, output_size, num_channels, kernel_size, dropout):
super(TCN, self ).__init__()
self.tcn = TemporalConvNet(input_size, num_channels, kernel_size=kernel_size, dropout=dropout)
self.fc1 = nn.Linear(130 * num_channels[-1], 128)
self.dropout1 = nn.Dropout(dropout)
self... | mnist_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
mnist_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
10,029,170 | device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('use devise:', device)
net1 = TCN(input_size=5, output_size=5, num_channels=[16, 8, 4, 2], kernel_size=2, dropout=0.5)
net2 = TCN(input_size=5, output_size=5, num_channels=[16, 8, 4, 2], kernel_size=2, dropout=0.5)
net1.load_state_dict(to... | mnist_train.isna().any().any() | Digit Recognizer |
10,029,170 | th = 0.5
env = janestreet.make_env()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('use devise:', device)
for i,(test_df, pred_df)in enumerate(env.iter_test()):
x_tt = test_df.loc[:, ds.features].values
if np.isnan(x_tt[:, 1:].sum()):
x_tt[:, 1:] = np.nan_to_num(x_tt[:, 1:])+ np.isnan(... | 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 |
10,029,170 | import os
import time
import gc
import random
import numpy as np
import pandas as pd
from tqdm.notebook import tqdm
import pathlib
from sklearn.metrics import log_loss, roc_auc_score
from sklearn.model_selection import KFold
from sklearn.model_selection._split import _BaseKFold, indexable, _num_samples
from sklearn.uti... | standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(mnist_train_data)
standardized_data.shape | Digit Recognizer |
10,029,170 | GPUs = tf.config.experimental.list_physical_devices(device_type='GPU')
for gpu in GPUs:
tf.config.experimental.set_memory_growth(gpu, True )<import_modules> | cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape | Digit Recognizer |
10,029,170 | print('tensorflow_version_is',tf.__version__ )<define_variables> | lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape | Digit Recognizer |
10,029,170 | SEED=42
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
tf.random.set_seed(seed)
seed_everything(seed=SEED )<load_from_disk> | new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack(( new_coordinates, mnist_train_label)).T | Digit Recognizer |
10,029,170 | %%time
print('Loading data...')
train = pd.read_feather('.. /input/janestreet-save-as-feather/train.feather')
print('Done!' )<normalization> | df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head() | Digit Recognizer |
10,029,170 | class Mish(tf.keras.layers.Layer):
def __init__(self, **kwargs):
super(Mish, self ).__init__(**kwargs)
self.supports_masking = True
def call(self, inputs):
return inputs * K.tanh(K.softplus(inputs))
def get_config(self):
base_config = super(Mish, self ).get_config()
return dict(list(base_config.items())+ list(config.i... | pca = decomposition.PCA()
pca.n_components = 2
pca_data = pca.fit_transform(standardized_data)
pca_data.shape | Digit Recognizer |
10,029,170 | train = train.query('date > 85' ).reset_index(drop = True)
train = train.query('weight > 0' ).reset_index(drop = True)
train.fillna(train.mean() ,inplace=True)
base_features = [c for c in train.columns if "feature" in c]
f_mean = np.mean(train[base_features[1:]].values,axis=0)
train['action'] =(train['resp'] > 0 ).... | pca_data = np.vstack(( pca_data.T, mnist_train_label)).T | Digit Recognizer |
10,029,170 | def RestNet_(num_columns,
num_labels,
hidden_size,
dropout_rate,
label_smoothing,
learning_rate):
inp = layers.Input(shape=(num_columns,))
x = layers.BatchNormalization()(inp)
x = layers.Dense(132 )(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(0.315 )(x)
x1 = layers.Dense(hidden_size*1.2 )(x)
x1 = layers.BatchN... | df_PCA = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_PCA.head() | Digit Recognizer |
10,029,170 | hidden_units = 256
dropout_rates = 0.3
label_smoothing = 5e-3
learning_rate = 1e-3
model = RestNet_(X.shape[1],
y.shape[1],
hidden_units,
dropout_rates,
label_smoothing,
learning_rate)
model.summary()<set_options> | mnist_train_data = np.array(mnist_train_data)
mnist_train_label = np.array(mnist_train_label ) | Digit Recognizer |
10,029,170 | del model
gc.collect()<define_search_model> | 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 |
10,029,170 | class PurgedGroupTimeSeriesSplit(_BaseKFold):
@_deprecate_positional_args
def __init__(self,
n_splits=5,
*,
max_train_group_size=np.inf,
max_test_group_size=np.inf,
group_gap=None,
verbose=False
):
super().__init__(n_splits, shuffle=False, random_state=None)
self.max_train_group_size = max_train_group_size
self.gro... | 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 |
10,029,170 | NUM_FOLDS = 7
EPOCHS = 500
BATCH_SIZE = 6500
TRAINING = False
CV = True
if TRAINING:
if CV:
gkf = PurgedGroupTimeSeriesSplit(n_splits = NUM_FOLDS, group_gap=15)
splits = list(gkf.split(y, groups=train['date'].values))
for fold,(train_indices, test_indices)in enumerate(splits):
keras.backend.clear_session()
reduce_lr =... | 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 |
10,029,170 | %%time
class LiteModel:
@classmethod
def from_file(cls, model_path):
return LiteModel(tf.lite.Interpreter(model_path=model_path))
@classmethod
def from_keras_model(cls, kmodel):
converter = tf.lite.TFLiteConverter.from_keras_model(kmodel)
tflite_model = converter.convert()
return LiteModel(tf.lite.Interpreter(model_co... | 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 |
10,029,170 | f = np.median
th = 0.502
weight_model = [1,1,1,2,2,2]<feature_engineering> | predictions = cnn_model.predict(mnist_test_arr ) | Digit Recognizer |
10,029,170 | env = janestreet.make_env()
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
test_df_ = test_df.loc[:, base_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
cross_41_42_43 = test_df_[:, 41] + test_df_[... | predictions_test = []
for i in predictions:
predictions_test.append(np.argmax(i)) | Digit Recognizer |
10,029,170 | !mkdir cache<import_modules> | submission = pd.DataFrame({
"ImageId": mnist_test.index+1,
"Label": predictions_test
})
submission.to_csv('my_submission.csv', index=False ) | Digit Recognizer |
10,029,170 | class PurgedGroupTimeSeriesSplit(_BaseKFold):
@_deprecate_positional_args
def __init__(self,
n_splits=5,
*,
max_train_group_size=np.inf,
max_test_group_size=np.inf,
group_gap=None,
verbose=False
):
super().__init__(n_splits, shuffle=False, random_state=None)
self.max_train_group_size = max_train_group_size
self.gro... | %matplotlib inline
| Digit Recognizer |
10,029,170 | class FinData(Dataset):
def __init__(self, data, target, date, mode='train', transform=None, cache_dir=None, multi=False):
self.data = data
self.target = target
self.mode = mode
self.transform = transform
self.cache_dir = cache_dir
self.date = date
self.multi = multi
def __getitem__(self, index):
if torch.is_tensor(ind... | mnist_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
mnist_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.