kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,297,932 | y_train_pred = xgbreg.predict(X_train )<compute_test_metric> | 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,297,932 | r2_score(y_train, y_train_pred )<predict_on_test> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
4,297,932 | y_val_pred = xgbreg.predict(X_val )<compute_test_metric> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
4,297,932 | r2_score(y_val, y_val_pred )<predict_on_test> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,297,932 | y_test_pred = xgbreg.predict(X_test )<compute_test_metric> | epochs = 30
batch_size = 86 | Digit Recognizer |
4,297,932 | r2_score(y_test, y_test_pred )<compute_test_metric> | 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,297,932 | mae = metrics.mean_absolute_error(y_val, y_val_pred)
mse = metrics.mean_squared_error(y_val, y_val_pred)
rmse = np.sqrt(metrics.mean_absolute_error(y_val, y_val_pred))
print("Mean Absolute Error")
print(mae)
print()
print("Mean Squared Error")
print(mse)
print()
print("Root Mean Squared Error")
print(rmse )<comp... | 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,297,932 | evaluation = evaluation_df('Extreme Gradient Boosting with Change in Data and tuning', mae, mse, rmse, evaluation )<load_from_csv> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
4,297,932 | df_test = pd.read_csv('.. /input/rossmann-store-sales/test.csv')
df_test.head()<count_missing_values> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission.csv",index=False ) | Digit Recognizer |
1,480,912 | df_test.isnull().sum()<filter> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
print(train.shape, test.shape ) | Digit Recognizer |
1,480,912 | df_test[df_test['Open'].isnull() ]<count_missing_values> | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
del train | Digit Recognizer |
1,480,912 | df_test[df_test['Open'].isnull() ]['Date'].value_counts()<count_values> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
1,480,912 | df_test[df_test['Store'] == 622]['Open'].value_counts()<feature_engineering> | X_train = X_train.values.reshape(X_train.shape[0], 28, 28, 1)
X_test = test.values.reshape(test.shape[0], 28, 28, 1)
Y_train = to_categorical(Y_train, num_classes = 10)
Y_train | Digit Recognizer |
1,480,912 | df_test['Open'] = df_test['Open'].fillna(1)
df_test.isnull().sum()<categorify> | from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization
from keras.utils import np_utils | Digit Recognizer |
1,480,912 | def mapping(features):
for feature in features:
temp_dict = {}
temp_dict = pd.Series(df_store[feature].values, index = df_store['Store'] ).to_dict()
df_test[feature] = df_test['Store'].map(temp_dict )<categorify> | model = Sequential()
dim = 28
nclasses = 10
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='same', activation='relu', input_shape=(dim,dim,1)))
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))
model.add(Dropout(0.2))
m... | Digit Recognizer |
1,480,912 | mapping(['StoreType', 'Assortment', 'Promo2', 'CompetitionDistance'] )<feature_engineering> | model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'] ) | Digit Recognizer |
1,480,912 | df_test['CompetitionDistanceLog10'] = np.log10(df_test['CompetitionDistance'])
df_test.head()<drop_column> | learning_rate_reduction = ReduceLROnPlateau(monitor='acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=1e-7)
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,
w... | Digit Recognizer |
1,480,912 | df_test.drop('CompetitionDistance', inplace = True, axis = 1)
df_test.head()<feature_engineering> | loss_and_metrics = model.evaluate(X_train, Y_train, batch_size=128)
print(loss_and_metrics ) | Digit Recognizer |
1,480,912 | df_test['DayOfYear'] = df_test['Date'].map(lambda x: datetime.datetime.strptime(str(x),'%Y-%m-%d' ).timetuple().tm_yday)
df_test.head(10 )<data_type_conversions> | pred = model.predict_classes(X_test)
submission = pd.DataFrame({
"ImageId": list(range(1,len(pred)+ 1)) ,
"Label": pred})
submission.to_csv("submission.csv", index=False, header=True ) | Digit Recognizer |
10,298,431 | df_test['Date'] = pd.to_datetime(df_test['Date'], format = '%Y-%m-%d' )<feature_engineering> | d_train = pd.read_csv(".. /input/digit-recognizer/train.csv")
d_test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
10,298,431 | df_test['Year'] = df_test['Date'].map(lambda x: x.year )<drop_column> | d_test.head()
| Digit Recognizer |
10,298,431 | df_test.drop('Date', inplace = True, axis = 1 )<count_values> | x_train = d_train.iloc[:, 1:].to_numpy(dtype = np.float)
x_train = np.reshape(x_train, newshape =(len(x_train), 1, 28, 28))
y_train = d_train['label'].to_numpy()
print(x_train.shape)
print(y_train.shape)
x_test = d_test.to_numpy(dtype = np.float)
x_test = np.reshape(x_test, newshape =(len(x_test), 1, 28, 28))
print... | Digit Recognizer |
10,298,431 | df_test['StateHoliday'].value_counts()<count_values> | x_train = x_train / 255
x_test = x_test / 255
print(x_train[0])
print(x_test[0] ) | Digit Recognizer |
10,298,431 | df_test['StateHoliday'] = df_test['StateHoliday'].apply(lambda x: 1 if x == 'a' else(2 if x == 'b' else(3 if x == 'c' else x)))
df_test['StateHoliday'].value_counts()<feature_engineering> | X_tr = torch.from_numpy(x_train ).type(torch.FloatTensor)
Y_tr = torch.from_numpy(y_train)
X_te = torch.from_numpy(x_test ).type(torch.FloatTensor)
Y_te = torch.from_numpy(np.zeros(x_test.shape))
X_train, X_va, Y_train, Y_va = train_test_split(X_tr, Y_tr, test_size = 0.2)
train_set = torch.utils.data.TensorDataset(... | Digit Recognizer |
10,298,431 | df_test['StateHoliday'] = df_test['StateHoliday'].map(lambda x: 0 if x == '0' else x)
type(df_test['StateHoliday'][0] )<filter> | class NMIST_CNN(nn.Module):
def __init__(self):
super(NMIST_CNN, self ).__init__()
self.cn1 = nn.Conv2d(1, 16, kernel_size = 4, padding = 2)
nn.init.xavier_normal_(self.cn1.weight)
nn.init.zeros_(self.cn1.bias)
self.bn1 = nn.BatchNorm2d(num_features = 16)
self.cn2 = nn.Conv2d(16, 32, kernel_size = 4)
nn.init.xavie... | Digit Recognizer |
10,298,431 | df_test_open = df_test[df_test['Open'] == 1]
df_test_closed = df_test[df_test['Open'] == 0]<feature_engineering> | model = NMIST_CNN()
print(model ) | Digit Recognizer |
10,298,431 | df_test_closed['Sales'] = 0<drop_column> | criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters() , lr=0.003)
epochs = 30
train_losses, test_losses, train_accuracies, test_accuracies = [], [], [], []
for e in range(epochs):
tr_loss = 0
tr_accuracy = 0
model.train()
for images, labels in trainloader:
optimizer.zero_grad()
results = model(im... | Digit Recognizer |
10,298,431 | df_test_open.drop('Open', inplace = True, axis = 1)
df_test_closed.drop('Open', inplace = True, axis = 1 )<drop_column> | prediction = []
with torch.no_grad() :
model.eval()
for images, x in testloader:
predictions = model(images)
top_p, top_class = predictions.topk(1, dim=1)
for n in range(len(predictions)) :
prediction.append(top_class[n].item())
submit = pd.DataFrame(data={'Label':prediction})
submit.insert(0, 'ImageId', range(1, 1... | Digit Recognizer |
10,298,431 | <drop_column><EOS> | submit.to_csv('submission.csv', index = False)
submit.head() | Digit Recognizer |
6,166,956 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<drop_column> | import keras
from keras.datasets import mnist
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd | Digit Recognizer |
6,166,956 | cols = ['Store', 'DayOfWeek', 'Promo', 'StateHoliday', 'SchoolHoliday', 'StoreType', 'Assortment', 'DayOfYear', 'Promo2', 'CompetitionDistanceLog10']
X = X[cols]<predict_on_test> | batch_size = 128
num_classes = 10
epochs = 30 | Digit Recognizer |
6,166,956 | X_pred = xgbreg.predict(X )<prepare_output> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
6,166,956 | df_test_open['Sales'] = X_pred<concatenate> | y_train = train["label"]
x_train = train.drop(labels=["label"], axis=1 ) | Digit Recognizer |
6,166,956 | df_test_final = pd.concat([df_test_open, df_test_closed] )<load_from_csv> | x_train, x_test, y_train, y_test = train_test_split(x_train, y_train , random_state = 42, test_size=0.3 ) | Digit Recognizer |
6,166,956 | sample_sub = pd.read_csv('.. /input/rossmann-store-sales/sample_submission.csv')
sample_sub.head()<categorify> | from keras import backend | Digit Recognizer |
6,166,956 | temp_dict = {}
temp_dict = pd.Series(df_test_final['Sales'].values, index = df_test_final['Id'] ).to_dict()
sample_sub['Sales'] = sample_sub['Id'].map(temp_dict )<save_to_csv> | x_train = x_train.astype('float')
x_test = x_test.astype('float')
test = test.astype('float')
x_train /= 255
x_test /= 255
test/= 255 | Digit Recognizer |
6,166,956 | sample_sub.to_csv('sample_submission.csv', header = ['Id', 'Sales'], index = False )<load_from_csv> | y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes ) | Digit Recognizer |
6,166,956 | data_path = '/kaggle/input/porto-seguro-safe-driver-prediction/'
train = pd.read_csv(data_path + 'train.csv', index_col='id')
test = pd.read_csv(data_path + 'test.csv', index_col='id')
submission = pd.read_csv(data_path + 'sample_submission.csv', index_col='id' )<concatenate> | model = Sequential() | Digit Recognizer |
6,166,956 | all_data = pd.concat([train, test], ignore_index=True)
all_data = all_data.drop('target', axis=1)
all_features = all_data.columns.tolist()<feature_engineering> | from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense | Digit Recognizer |
6,166,956 | all_data['num_missing'] =(all_data==-1 ).sum(axis=1)
remaining_features = [col for col in all_features \
if('cat' not in col and 'calc' not in col)]
remaining_features.append('num_missing' )<categorify> | model.add(Conv2D(32, kernel_size=(5, 5), activation='relu', input_shape=input_shape))
model.add(Conv2D(32, kernel_size=(5, 5), activation='relu', input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64,(3, 3), activation='relu'))
model.add(Conv2D(64,(3, 3), acti... | Digit Recognizer |
6,166,956 | cat_features = [col for col in all_features if 'cat' in col]
onehot_encoder = OneHotEncoder()
encoded_cat_matrix = onehot_encoder.fit_transform(all_data[cat_features] )<data_type_conversions> | model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.RMSprop(lr = 0.001, rho=0.9, epsilon=1e-08, decay = 0.0), metrics=['accuracy'] ) | Digit Recognizer |
6,166,956 | ind_features = [col for col in all_features if 'ind' in col]
first_col=True
for col in ind_features:
if first_col:
all_data['mix_ind'] = all_data[col].astype(str)+'_'
first_col = False
else:
all_data['mix_ind'] += all_data[col].astype(str)+'_'<count_values> | model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) | Digit Recognizer |
6,166,956 | cat_count_features = []
for col in cat_features+['mix_ind']:
val_counts_dic = all_data[col].value_counts().to_dict()
all_data[f'{col}_count'] = all_data[col].apply(lambda x: val_counts_dic[x])
cat_count_features.append(f'{col}_count' )<drop_column> | from keras.preprocessing.image import ImageDataGenerator | Digit Recognizer |
6,166,956 | drop_features = ['ps_ind_14', 'ps_ind_10_bin','ps_ind_11_bin',
'ps_ind_12_bin','ps_ind_13_bin','ps_car_14']
all_data_remaining = all_data[remaining_features+cat_count_features].drop(drop_features, axis=1)
all_data_sprs = sparse.hstack([sparse.csr_matrix(all_data_remaining),
encoded_cat_matrix],
format='csr' )<prepare_... | 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.3,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(x_t... | Digit Recognizer |
6,166,956 | num_train = train.shape[0]
X = all_data_sprs[:num_train]
X_test = all_data_sprs[num_train:]
y = train['target'].values<compute_train_metric> | annealer_callback = ReduceLROnPlateau(monitor = 'val_accuracy', patience = 3, verbose = 1, factor = 0.5, min_lr = 0.00001 ) | Digit Recognizer |
6,166,956 | def eval_gini(y_true, y_pred):
assert y_true.shape == y_pred.shape
n_samples = y_true.shape[0]
L_mid = np.linspace(1 / n_samples, 1, n_samples)
pred_order = y_true[y_pred.argsort() ]
L_pred = np.cumsum(pred_order)/ np.sum(pred_order)
G_pred = np.sum(L_mid - L_pred)
true_order = y_true[y_true.argsort() ]
L_true = np.... | model.fit_generator(generator=datagen.flow(x_train, y_train, batch_size = batch_size), steps_per_epoch= x_train.shape[0] // batch_size, epochs=epochs, validation_data=(x_test,y_test), verbose = 2,
callbacks = [annealer_callback] ) | Digit Recognizer |
6,166,956 | def gini_lgb(preds, dtrain):
labels = dtrain.get_label()
return 'gini', eval_gini(labels, preds), True<compute_test_metric> | score = model.evaluate(x_test, y_test, verbose=0)
score | Digit Recognizer |
6,166,956 | def gini_xgb(preds, dtrain):
labels = dtrain.get_label()
return 'gini', eval_gini(labels, preds )<choose_model_class> | results = model.predict(test)
results = np.argmax(results,axis = 1 ) | Digit Recognizer |
6,166,956 | folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=1991 )<init_hyperparams> | submission_df = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv" ) | Digit Recognizer |
6,166,956 | max_params_lgb = {'bagging_fraction': 0.8043696643500143,
'feature_fraction': 0.6829323879981047,
'lambda_l1': 0.9264555612104627,
'lambda_l2': 0.9774233689434216,
'min_child_samples': 10,
'min_child_weight': 125.68433948868649,
'num_leaves': 28,
'objective': 'binary',
'learning_rate': 0.01,
'bagging_freq': 1,
'verbosi... | submission_df["Label"] = results | Digit Recognizer |
6,166,956 | <init_hyperparams><EOS> | submission_df.to_csv("submission.csv", index = False ) | Digit Recognizer |
5,052,155 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<split> | %matplotlib inline
sns.set(style='white', context='notebook', palette='deep')
warnings.filterwarnings('ignore')
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
print(train.shape)
Y_train = train['label']
X_train = train.drop(labels = ["label"],axis = 1)
fig = plt.figure(figsize... | Digit Recognizer |
5,052,155 | oof_val_preds_xgb = np.zeros(X.shape[0])
oof_test_preds_xgb = np.zeros(X_test.shape[0])
for idx,(train_idx, valid_idx)in enumerate(folds.split(X, y)) :
print('
X_train, y_train = X[train_idx], y[train_idx]
X_valid, y_valid = X[valid_idx], y[valid_idx]
dtrain = xgb.DMatrix(X_train, y_train)
dvalid = xgb.DMatrix(X_val... | def check_missing_data(df):
flag=df.isna().sum().any()
if flag==True:
total = df.isnull().sum()
percent =(df.isnull().sum())/(df.isnull().count() *100)
output = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
data_type = []
for col in df.columns:
dtype = str(df[col].dtype)
data_type.append(dtype)
out... | Digit Recognizer |
5,052,155 | print('LightGBM OOF Gini Score:', eval_gini(y, oof_val_preds_lgb))<compute_test_metric> | X_train = X_train / 255.0
test = test / 255.0
mean_px = X_train.mean().astype(np.float32)
std_px = X_train.std().astype(np.float32)
def standardize(x):
return(x-mean_px)/std_px
X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1)
for i in range(6, 9):
plt.subplot(330 +(i+1))
plt.imsho... | Digit Recognizer |
5,052,155 | print('XGBoost OOF Gini Score:', eval_gini(y, oof_val_preds_xgb))<save_to_csv> | validation_split = 0.15
img_gen = 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... | Digit Recognizer |
5,052,155 | oof_test_preds = oof_test_preds_lgb * 0.6 + oof_test_preds_xgb * 0.4
submission['target'] = oof_test_preds
submission.to_csv('submission.csv' )<import_modules> | seed = 43
np.random.seed(seed)
learning_rate=0.00065
optimizer = Adam(lr=learning_rate)
def conv_block(x, filters, kernel_size, strides, layer_no, use_pool=False, padding='same'):
x = Convolution2D(filters=filters, kernel_size=kernel_size, strides=strides, name=f'conv{layer_no}',
padding=padding )(x)
x = BatchNormal... | Digit Recognizer |
5,052,155 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from numpy import nan<load_from_csv> | def calculate_performance(labels, pred, dataset):
pred_cat = np.argmax(pred, axis=1)
labels_cat = np.argmax(labels, axis=1)
corrects =(pred_cat == labels_cat)
falses = dataset[~corrects]
falses_labels = labels_cat[~corrects]
falses_preds = pred[~corrects]
examples_num = labels.shape[0]
accuracy = np.count_nonzero(co... | Digit Recognizer |
5,052,155 | train = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv' )<prepare_x_and_y> | styles=[':','-.','--','-',':','-.','--','-',':','-.','--','-']
nets = 3
model = [0] *nets
for j in range(3):
model[j] = Sequential()
model[j].add(Conv2D(j*16+16,kernel_size=5,activation='relu',input_shape=(28,28,1)))
model[j].add(MaxPool2D())
model[j].add(Conv2D(j*32+32,kernel_size=5,activation='relu'))
model[j].add(... | Digit Recognizer |
5,052,155 | y_train = train['SalePrice']
train.drop(['SalePrice'],axis=1,inplace=True)
features = pd.concat([train, test])
features.shape<drop_column> | model = Sequential()
model.add(Conv2D(32,kernel_size=3,activation='relu',input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_size=3,activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_size=5,strides=2,padding='same',activation='relu'))
model.add(BatchNormaliz... | Digit Recognizer |
5,052,155 | <data_type_conversions><EOS> | predictions = model.predict(test)
predictions = np.argmax(predictions,axis = 1)
submissions=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("submission.csv", index=False, header=True)
print(submissions.head(5)) | Digit Recognizer |
4,439,703 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<categorify> | %matplotlib inline
| Digit Recognizer |
4,439,703 | for column in features.columns :
if features[column].dtype == object :
df_dummies = pd.get_dummies(features[column],drop_first=True,prefix=column)
features.drop([column],axis=1,inplace=True)
features = pd.concat([features,df_dummies],axis=1)
features.head()<split> | training_data = pd.read_csv('.. /input/train.csv')
testing_data = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
4,439,703 | x_train = features.iloc[:len(y_train), :]
x_test = features.iloc[len(x_train):, :]<normalization> | label = training_data.label.value_counts()
label | Digit Recognizer |
4,439,703 | def bi_directional_elimination(x, y):
Sig_Level = 0.05;
features = x.columns.tolist()
selected_features = []
while(len(features)> 0):
remain_features = list(set(features)- set(selected_features))
pval = pd.Series(index=remain_features, dtype='float64')
for column in remain_features :
model = sm.OLS(y, sm.add_constant(... | train_data = training_data.drop(['label'], axis=1 ).values.astype('float32')
target = training_data['label'].values.astype('int32')
test_data = testing_data.values.astype('float32')
train_data = train_data.reshape(train_data.shape[0], 28, 28)/ 255.0
test_data = test_data.reshape(test_data.shape[0], 28, 28)/ 255.0 | Digit Recognizer |
4,439,703 | selected_features = bi_directional_elimination(x_train, y_train )<create_dataframe> | num = 10
target = keras.utils.to_categorical(target,num ) | Digit Recognizer |
4,439,703 | x_train = x_train[selected_features].copy()
x_test = x_test[selected_features].copy()<init_hyperparams> | num_classes = 10
input_shape =(28, 28, 1 ) | Digit Recognizer |
4,439,703 | regressor = xgboost.XGBRegressor()
booster=['gbtree','gblinear']
base_score=[0.25,0.5,0.75,1]
n_estimators = [100, 500, 900, 1100, 1500]
max_depth = [2, 3, 5, 10, 15]
learning_rate=[0.05,0.1,0.15,0.20]
min_child_weight=[1,2,3,4]
hyperparameter_grid = {
'n_estimators': n_estimators,
'max_depth':max_depth,
'learning_rate... | X_train, X_val, Y_train, Y_val = train_test_split(train_data, target , test_size = 0.1, random_state=42 ) | Digit Recognizer |
4,439,703 | random_cv.best_estimator_<choose_model_class> | 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,439,703 | regressor = xgboost.XGBRegressor(base_score=0.25, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,
importance_type='gain', interaction_constraints='',
learning_rate=0.1, max_delta_step=0, max_depth=2,
min_child_weight=1, missing=nan, monotone_constraints='() ',
n_estima... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.0001 ) | Digit Recognizer |
4,439,703 | regressor.fit(x_train,y_train )<predict_on_test> | 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(BatchNormalization())
model.add(Dropout(0.20))
mode... | Digit Recognizer |
4,439,703 | y_pred = regressor.predict(x_test )<save_to_csv> | model.compile(loss='categorical_crossentropy',
optimizer='Adam',
metrics=['accuracy'] ) | Digit Recognizer |
4,439,703 | df_pred = pd.DataFrame(y_pred)
df_sub = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/sample_submission.csv')
df_sub = pd.concat([df_sub['Id'],df_pred],axis=1)
df_sub.columns = ['Id','SalePrice']
df_sub.to_csv('sample_submission.csv',index=False )<import_modules> | fitting = model.fit_generator(datagen.flow(X_train, Y_train, batch_size = 90),
epochs = 50, validation_data =(X_val, Y_val),
verbose = 1, callbacks = [learning_rate_reduction] ) | Digit Recognizer |
4,439,703 | import numpy as np
import pandas as pd
import seaborn as sns
import sklearn
from sklearn import metrics
import tensorflow as tf
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split, StratifiedKFold
import numpy as np<load_from_csv> | predicted_classes = model.predict_classes(test_data ) | Digit Recognizer |
4,439,703 | <compute_train_metric><EOS> | submissions=pd.DataFrame({"ImageId": list(range(1,len(predicted_classes)+1)) ,
"Label": predicted_classes})
submissions.to_csv("submission.csv", index=False, header=True ) | Digit Recognizer |
2,285,148 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<compute_test_metric> | print(os.listdir(".. /input"))
sns.set(style='white', context='notebook', palette='deep')
| Digit Recognizer |
2,285,148 | def rmlse(y_true, y_pred):
return tf.sqrt(tf.reduce_mean(tf.square(tf.math.log(y_pred + 1)- tf.math.log(y_true + 1))))<save_to_csv> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
2,285,148 | def submit(model, X, ids, file_path):
SalePrice = model.predict(X)
submission = pd.DataFrame({"Id": ids, "SalePrice": SalePrice.reshape(-1)})
submission.to_csv(file_path, index=False )<sort_values> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
2,285,148 | train.corr() ["SalePrice"].sort_values(key = lambda x: abs(x), ascending=False )<feature_engineering> | X_train.head() | Digit Recognizer |
2,285,148 | for data in [train, test]:
null_counts = data.isnull().sum()
null_counts[null_counts > 0]
null_columns = list(pd.DataFrame(null_counts[null_counts > 0] ).index)
for column in null_columns:
if data[column].dtype == object:
data[column] = data[[column]].replace(np.NAN, "Unknown")
else:
data[column] = data[column].repla... | X_train.isnull().any().sum() | Digit Recognizer |
2,285,148 | train_test = pd.get_dummies(pd.concat([train, test]))<drop_column> | test.isnull().any().sum() | Digit Recognizer |
2,285,148 | train_features = train_test.iloc[0: len(train)]
test_features = train_test.iloc[len(train):]
_ = train_features.pop("Id")
_ = test_features.pop("SalePrice")
test_ids = test_features.pop("Id" )<split> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
2,285,148 | train_features, val_features = train_test_split(train_features, test_size=0.2, random_state=np.random.randint(1000))<sort_values> | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
2,285,148 | thresold = 0.05
correlated_scores = train_features.corr() ["SalePrice"]
correlated_scores = correlated_scores[correlated_scores.abs() >= thresold]
correlated_columns = list(correlated_scores.index)
correlated_columns.remove("SalePrice")
print(correlated_columns )<drop_column> | y_train = to_categorical(y_train, num_classes=10 ) | Digit Recognizer |
2,285,148 | train_targets = train_features.pop("SalePrice")
val_targets = val_features.pop("SalePrice" )<define_variables> | random_seed = 2 | Digit Recognizer |
2,285,148 | categorical_columns = set(train.dtypes[train.dtypes==object].index )<feature_engineering> | 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 |
2,285,148 | scale_strategies = ["none", "standard_scale", "standard_scale_exclude_categorcial_features"]
scale_strategy = scale_strategies[2]
if scale_strategy == scale_strategies[1]:
train_features =(train_features - mean_value)/ std_value
val_features =(val_features - mean_value)/ std_value
test_features =(test_features - mean_v... | model = Sequential()
model.add(Conv2D(filters=40, kernel_size=(5,5), padding='Same', activation='relu', input_shape=(28, 28, 1)))
model.add(Conv2D(filters=40, kernel_size=(5,5), padding='Same', activation='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Conv2D(filters=60, kernel_size=(3,3), padding='Same', ac... | Digit Recognizer |
2,285,148 | use_correlated_columns = True
if use_correlated_columns:
train_features = train_features[correlated_columns]
val_features = val_features[correlated_columns]
test_features = test_features[correlated_columns]<train_model> | optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False ) | Digit Recognizer |
2,285,148 | begin = time.time()
parameters = {
"depth": [4, 5, 6, 7, 8, 9],
"learning_rate": [0.01, 0.05, 0.07, 0.08, 0.09, 0.10, 0.11, 0.12, 0.13, 0.14, 0.15],
"iterations": [500, 10000],
}
def train_with_catboost(hyperparameters, X_train, X_val, y_train, y_val):
keys = hyperparameters.keys()
best_index = {key:0 for key in keys}
... | model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
2,285,148 | X = pd.concat([train_features, val_features])
y = pd.concat([train_targets, val_targets])
fold = 1
models = []
for train_indices, valid_indices in KFold(n_splits=5, shuffle=True ).split(X):
print("Training with Fold %d" %(fold))
X_train = X.iloc[train_indices]
X_val = X.iloc[valid_indices]
y_train = y.iloc[train_indi... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc', patience=5, factor=0.5, verbose=1, min_lr=0.00001 ) | Digit Recognizer |
2,285,148 | SalePrice = np.mean([model.predict(test_features)for model in models], axis=0)
submission = pd.DataFrame({"Id": test_ids, "SalePrice": SalePrice})
submission.to_csv("submission.csv", index=False )<train_on_grid> | epochs = 1
batch_size = 84 | Digit Recognizer |
2,285,148 | cat = catboost.CatBoostRegressor(
iterations = best_parameters["iterations"],
learning_rate = best_parameters["learning_rate"],
depth = best_parameters["depth"]
)
cat.fit(X, y, verbose=False)
evaluate(cat, X, y)
submit(cat, test_features, test_ids, "submission_cat_all_dataset.csv" )<set_options> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
2,285,148 | warnings.filterwarnings('ignore' )<load_from_csv> | history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size),
epochs=epochs, verbose=2, callbacks=[learning_rate_reduction],
validation_data=(X_val, y_val), steps_per_epoch=X_train.shape[0] // batch_size ) | Digit Recognizer |
2,285,148 | train = pd.read_csv('.. /input/tabular-playground-series-feb-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-feb-2021/test.csv' )<prepare_x_and_y> | result = model.predict(test)
result = np.argmax(result, axis=1)
result = pd.Series(result, name='Label')
| Digit Recognizer |
2,285,148 | X_train = train.drop(['id', 'target'], axis=1)
y_train = train.target
X_test = test.drop(['id'], axis=1 )<categorify> | my_sumission = pd.concat([pd.Series(range(1, 28001), name='ImageId'), result], axis=1)
my_sumission.to_csv("submission.csv", index=False ) | Digit Recognizer |
1,437,082 | cat_cols = [feature for feature in train.columns if 'cat' in feature]
def label_encoder(df):
for feature in cat_cols:
le = LabelEncoder()
le.fit(df[feature])
df[feature] = le.transform(df[feature])
return df<categorify> | trainRaw = pd.read_csv('.. /input/train.csv')
testRaw = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
1,437,082 | X_train = label_encoder(X_train)
X_test = label_encoder(X_test )<choose_model_class> | train = trainRaw.copy()
test_imagesKaggle = testRaw.copy()
train_labelsKaggle = trainRaw['label']
print("train with Labels ", train.shape)
print("train_labelsKaggle ", train_labelsKaggle.shape)
print("_"*50)
train.drop(['label'],axis=1, inplace=True)
train_imagesKaggle = train
print("train_imagesKaggle without Labe... | Digit Recognizer |
1,437,082 | split = KFold(n_splits=5, random_state=2 )<train_model> | train4Display = np.array(train_imagesKaggle ).reshape(42000,28,28)
test4Display = np.array(test_imagesKaggle ).reshape(28000,28,28)
z = 4056
print("train image")
print(train_labelsKaggle[z])
digit = train4Display[z]
plt.imshow(digit, cmap=plt.cm.binary)
plt.show()
print("test image")
digit = test4Display[z]
plt.i... | Digit Recognizer |
1,437,082 | def objective(trial, X, y, name='xgb'):
params = {'max_depth':trial.suggest_int('max_depth', 5, 50),
'n_estimators':200000,
'subsample': trial.suggest_uniform('subsample', 0.2, 1.0),
'colsample_bytree':trial.suggest_uniform('colsample_bytree', 0.2, 1.0),
'learning_rate':trial.suggest_uniform('learning_rate', 0.007, 0.0... | train_imagesKaggle = train4Display.reshape(42000,28,28,1)
test_imagesKaggle = test4Display.reshape(28000,28,28,1)
train_imagesKaggle = train_imagesKaggle.astype('float32')/ 255
test_imagesKaggle = test_imagesKaggle.astype('float32')/ 255
print("train_imagesKaggle ",train_imagesKaggle.shape)
print("test_imagesKaggle ... | Digit Recognizer |
1,437,082 | optimize = partial(objective, X=X_train, y=y_train)
study_lgbm = optuna.create_study(direction='minimize')
<init_hyperparams> | ( train_imagesRaw, train_labelsRaw),(test_imagesRaw, test_labelsRaw)= mnist.load_data() | Digit Recognizer |
1,437,082 | lgbm_params = {'max_depth': 16,
'subsample': 0.8032697250789377,
'colsample_bytree': 0.21067140508531404,
'learning_rate': 0.009867383057779643,
'reg_lambda': 10.987474846877767,
'reg_alpha': 17.335285595031994,
'min_child_samples': 31,
'num_leaves': 66,
'max_bin': 522,
'cat_smooth': 81,
'cat_l2': 0.029690334194270022,... | train_imagesKeras = train_imagesRaw.copy()
train_labelsKeras = train_labelsRaw.copy()
test_imagesKeras = test_imagesRaw.copy()
test_labelsKeras = test_labelsRaw.copy()
train_imagesKeras = train_imagesKeras.reshape(60000,28,28,1)
test_imagesKeras = test_imagesKeras.reshape(10000,28,28,1)
print("train_imagesKeras ",tra... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.