kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,188,803 | def GRU_model_fasttext() :
global max_len,num_tokens,embedding_weights_fasttext
inputs = layers.Input(shape=(max_len,))
x = layers.Embedding(input_dim=num_tokens,\
output_dim=embedding_dim,\
embeddings_initializer=keras.initializers.Constant(embedding_weights_fasttext),\
trainable=False )(inputs)
x = layers.SpatialDro... | plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)
Image("model.png" ) | Digit Recognizer |
4,188,803 | model_nums = 2
size1 = x_train.shape[0]
y_train_pred = np.zeros(( model_nums,size1,6),dtype="float32")
y_train_pred[0] = GRU_model_fasttext.predict(x_train)
y_train_pred[1] = GRU_model_glove.predict(x_train)
size2 = X_test.shape[0]
y_test_pred = np.zeros(( model_nums,size2,6),dtype="float32")
y_test_pred[0] = GRU_m... | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
epochs = 30
batch_size = 80 | Digit Recognizer |
4,188,803 | submission_result[bad_comment_cat] = y_pred
submission_result.to_csv("submission.csv",index=False )<import_modules> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,188,803 | import numpy as np
import pandas as pd
import datetime
from xgboost import XGBRegressor
from sklearn.model_selection import GridSearchCV, KFold<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_t... | Digit Recognizer |
4,188,803 | train = pd.read_csv(r'.. /input/rossmann-store-sales/train.csv', parse_dates=['Date'], low_memory=False)
train.head()<load_from_csv> | 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,188,803 | test = pd.read_csv(r'.. /input/rossmann-store-sales/test.csv', parse_dates=['Date'], low_memory=False, index_col='Id')
test.head()<load_from_csv> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_pre.csv",index=False ) | Digit Recognizer |
3,811,922 | store = pd.read_csv(r'.. /input/rossmann-store-sales/store.csv', index_col='Store')
store.head()<data_type_conversions> | print(tf.__version__)
| Digit Recognizer |
3,811,922 | mean_dist = store['CompetitionDistance'].mean()
store.loc[store['CompetitionDistance'].isnull() , 'CompetitionDistance'] = mean_dist
store.loc[store['Promo2'] == 0, ['Promo2SinceWeek','Promo2SinceYear']] = 0
store['Promo2SinceWeek'] = store['Promo2SinceWeek'].astype('int')
store['Promo2SinceYear'] = store['Promo2Since... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
train_df.head() | Digit Recognizer |
3,811,922 | train.loc[train['StateHoliday'] != '0', 'StateHoliday'] = '1'
train['StateHoliday'] = train['StateHoliday'].astype('int')
test.loc[test['StateHoliday'] != '0', 'StateHoliday'] = '1'
test['StateHoliday'] = test['StateHoliday'].astype('int')
train['year'] = train['Date'].dt.year
train['month'] = train['Date'].dt.month
... | y_train = train_df.label.values
x_train = train_df.drop(columns=["label"] ).values
x_test = test_df.values
x_train[:10] | Digit Recognizer |
3,811,922 | kfold = KFold(n_splits=5, random_state=2021, shuffle=True)
parameters = {'learning_rate' : [0.1,0.2,0.35]}
clf = XGBRegressor(random_state=2021, use_label_encoder=False, n_estimators=100, max_depth=4 )<create_dataframe> | x_train = x_train / 255.0
x_test = x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(784,)) ,
tf.keras.layers.Dense(256, activation=tf.nn.relu),
tf.keras.layers.Dense(128, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
| Digit Recognizer |
3,811,922 | submit_frame = pd.DataFrame(columns=['Id','Sales'] )<feature_engineering> | class myCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('acc')> 0.997):
print("
Reached 99% accuracy so cancelling training!")
self.model.stop_training = True
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=['accuracy'])
model.fit(x_train, y_t... | Digit Recognizer |
3,811,922 | for st_no in range(1,1116):
train_t = train.loc[train['Store'] == st_no].copy()
train_t.drop('Store', axis=1, inplace=True)
test_t = test.loc[test['Store'] == st_no].copy()
test_t.drop('Store',axis=1,inplace=True)
st_t = store.loc[store.index==st_no].iloc[0,:]
if test_t.shape[0] > 0:
train_t['Promo2'] = 0
train_t['Ne... | classifications = model.predict(x_test ) | Digit Recognizer |
3,811,922 | submit_frame.sort_values('Id', inplace=True)
print(submit_frame.shape)
print(submit_frame.head())
submit_frame.to_csv(r'submission.csv', index=False )<set_options> | def write_submissions(file_name, imageId, predictions):
output = pd.DataFrame({
'ImageId': imageId, 'Label': predictions
})
output.to_csv(file_name, index=False)
write_submissions('submission_1.csv', pd.Series(range(1,28001)) , np.argmax(classifications, axis=1)) | Digit Recognizer |
3,811,922 | warnings.filterwarnings('ignore' )<load_from_csv> | y_train = train_df.label.values
x_train = train_df.drop(columns=["label"] ).values
x_test = test_df.values | Digit Recognizer |
3,811,922 | df_train = pd.read_csv('.. /input/rossmann-store-sales/train.csv' )<count_missing_values> | x_train = x_train.reshape(42000, 28, 28, 1)
x_test = x_test.reshape(28000, 28, 28, 1)
x_train = x_train / 255.0
x_test = x_test / 255.0 | Digit Recognizer |
3,811,922 | df_train.isnull().sum()<count_values> | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64,(3, 3), activation='relu', input_shape=(28, 28, 1)) ,
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64,(3, 3), activation='relu'),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(1024, activation='relu'),
t... | Digit Recognizer |
3,811,922 | df_train['DayOfWeek'].value_counts()<count_unique_values> | model.fit(x_train, y_train, epochs=20 ) | Digit Recognizer |
3,811,922 | len(df_train['Store'].unique() )<count_values> | classifications = model.predict(x_test)
write_submissions('submission_2.csv', pd.Series(range(1,28001)) , np.argmax(classifications, axis=1)) | Digit Recognizer |
3,811,922 | <count_values><EOS> | f, axarr = plt.subplots(3, 4)
FIRST_IMAGE = 0
SECOND_IMAGE = 7
THIRD_IMAGE = 8
CONVOLUTION_NUMBER = 1
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs=model.input, outputs=layer_outputs)
for x in range(0, 4):
f1 = activation_model.predict(x_train[FIRST_IMAGE].re... | Digit Recognizer |
3,823,766 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
3,823,766 | df_train[df_train['StateHoliday'] == '0']['StateHoliday'].value_counts()<count_values> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
3,823,766 | df_train['StateHoliday'] = df_train['StateHoliday'].apply(lambda x: 0 if x == '0' else x)
df_train['StateHoliday'].value_counts()<load_from_csv> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
3,823,766 | df_store = pd.read_csv('.. /input/rossmann-store-sales/store.csv')
df_store.head()<count_missing_values> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
3,823,766 | df_store.isnull().sum()<count_values> | random_seed = 2 | Digit Recognizer |
3,823,766 | df_store['StoreType'].value_counts()<count_values> | 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 |
3,823,766 | df_store['Assortment'].value_counts()<count_values> | 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 |
3,823,766 | df_store['StoreType'] = df_store['StoreType'].apply(lambda x: 1 if x == 'a' else(2 if x == 'b' else(3 if x == 'c' else 4)))
df_store['StoreType'].value_counts()<count_values> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
3,823,766 | df_store['Assortment'] = df_store['Assortment'].apply(lambda x: 1 if x == 'a' else(2 if x == 'b' else 3))
df_store['Assortment'].value_counts()<feature_engineering> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
3,823,766 | df_store['CompetitionDistance'] = df_store['CompetitionDistance'].fillna(max(df_store['CompetitionDistance']))
df_store.info()<categorify> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
3,823,766 | def mapping(features):
for feature in features:
temp_dict = {}
temp_dict = pd.Series(df_store[feature].values, index = df_store['Store'] ).to_dict()
df_train[feature] = df_train['Store'].map(temp_dict )<categorify> | epochs = 29
batch_size = 86 | Digit Recognizer |
3,823,766 | mapping(['StoreType', 'Assortment', 'CompetitionDistance'] )<filter> | Digit Recognizer | |
3,823,766 | df_train[df_train['Sales'] == 0]<filter> | 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 |
3,823,766 | df_train[df_train['Open'] == 0]<count_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=[learning_rate_reduction] ) | Digit Recognizer |
3,823,766 | df_train[df_train['Open'] == 0]['Sales'].value_counts()<count_values> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
3,823,766 | <count_values><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,566,234 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | import pandas as pd
from sklearn.datasets import fetch_mldata
import torch
import numpy as np
import torch.utils.data
import matplotlib.pyplot as plt
from scipy.io import loadmat
import os
import urllib | Digit Recognizer |
3,566,234 | df_train['StateHoliday'] = df_train['StateHoliday'].apply(lambda x: 1 if x == 'a' else(2 if x == 'b' else(3 if x == 'c' else x)))
df_train['StateHoliday'].value_counts()<feature_engineering> | test_data = pd.read_csv('.. /input/test.csv')
mnist_path = "mnist-original.mat"
mnist_alternative_url = "https://github.com/amplab/datascience-sp14/raw/master/lab7/mldata/mnist-original.mat"
response = urllib.request.urlopen(mnist_alternative_url)
with open(mnist_path, "wb")as f:
content = response.read()
f.write(con... | Digit Recognizer |
3,566,234 | df_train['DayOfYear'] = df_train['Date'].map(lambda x: datetime.datetime.strptime(str(x),'%Y-%m-%d' ).timetuple().tm_yday)
df_train.head(10 )<data_type_conversions> | def pairwise_distances(x, y):
x_norm =(x**2 ).sum(1 ).view(-1, 1)
y_t = torch.transpose(y, 0, 1)
y_norm =(y**2 ).sum(1 ).view(1, -1)
dist = x_norm + y_norm - 2.0 * torch.mm(x, y_t)
return torch.clamp(dist, 0.0, np.inf ) | Digit Recognizer |
3,566,234 | df_train['Date'] = pd.to_datetime(df_train['Date'], format = '%Y-%m-%d' )<feature_engineering> | %%time
cuda_test = torch.from_numpy(X_test ).cuda().float()
cuda_train = torch.from_numpy(X ).cuda().float()
ds = torch.utils.data.TensorDataset(cuda_test)
_min_dists = []
_arg_min_dists = []
bs = 1000
for batch, in torch.utils.data.DataLoader(ds, batch_size=bs, pin_memory=False):
min_dist, arg_min_dist = pairwise_dis... | Digit Recognizer |
3,566,234 | df_train['Year'] = df_train['Date'].map(lambda x: x.year)
df_train.head()<drop_column> | min_dists = torch.cat(_min_dists)
arg_min_dists = torch.cat(_arg_min_dists)
print(f'Number of not found samples: {len(min_dists[min_dists>0])}' ) | Digit Recognizer |
3,566,234 | <prepare_x_and_y><EOS> | sub = pd.read_csv('.. /input/sample_submission.csv')
sub.Label = y[arg_min_dists.cpu() ]
sub.to_csv('sub.csv', index=False)
!head sub.csv | Digit Recognizer |
4,795,843 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<split> | from fastai import *
from fastai.vision import *
from fastai.metrics import accuracy,error_rate | Digit Recognizer |
4,795,843 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.1, random_state = 53)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.1, random_state = 53 )<normalization> | 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,795,843 | scaler = preprocessing.StandardScaler()<normalization> | path = '.. /input' | Digit Recognizer |
4,795,843 | X_train_scalled = scaler.fit_transform(X_train)
X_val_scalled = scaler.transform(X_val)
X_test_scalled = scaler.transform(X_test )<choose_model_class> | test = CustomImageItemList.from_csv_custom(path=path, csv_name='test.csv', imgIdx=0)
data =(CustomImageItemList.from_csv_custom(path=path, csv_name='train.csv')
.split_by_rand_pct (.2)
.label_from_df(cols='label')
.add_test(test, label=0)
.databunch(bs=64, num_workers=0)
.normalize(imagenet_stats)) | Digit Recognizer |
4,795,843 | linreg = LinearRegression()<train_model> | learn = cnn_learner(data, models.resnet50, metrics=error_rate,model_dir="/tmp/model/" ) | Digit Recognizer |
4,795,843 | linreg.fit(X_train_scalled, y_train )<predict_on_test> | learn.fit_one_cycle(4 ) | Digit Recognizer |
4,795,843 | y_val_pred = linreg.predict(X_val_scalled )<predict_on_test> | learn.save("model_1", return_path=True ) | Digit Recognizer |
4,795,843 | y_train_pred = linreg.predict(X_train_scalled )<create_dataframe> | learn.fit_one_cycle(1 ) | Digit Recognizer |
4,795,843 | data = pd.DataFrame({'Actual':y_val, 'Predicted':y_val_pred})
data<compute_test_metric> | learn.load('model_1' ) | Digit Recognizer |
4,795,843 | r2_score(y_val, y_val_pred )<compute_test_metric> | learn.lr_find() | Digit Recognizer |
4,795,843 | r2_score(y_train, y_train_pred )<compute_test_metric> | learn.unfreeze()
learn.fit_one_cycle(10, max_lr=slice(1e-5,1e-4)) | Digit Recognizer |
4,795,843 | 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 )<crea... | predictions, *_ = learn.get_preds(DatasetType.Test)
labels = np.argmax(predictions, 1)
submission_df = pd.DataFrame({'ImageId': list(range(1,len(labels)+1)) , 'Label': labels})
submission_df.to_csv(f'submission.csv', index=False ) | Digit Recognizer |
5,056,419 | evaluation = pd.DataFrame()<create_dataframe> | %matplotlib inline
| Digit Recognizer |
5,056,419 | def evaluation_df(method, mae, mse, rmse, evaluation):
temp_evaluation = pd.DataFrame({'Method':[method], 'MAE': [mae], 'MSE': [mse], 'RMSE': [rmse]})
evaluation = pd.concat([evaluation, temp_evaluation])
evaluation = evaluation[['Method', 'MAE', 'MSE', 'RMSE']]
return evaluation<create_dataframe> | test = pd.read_csv(".. /input/test.csv")
train = pd.read_csv(".. /input/train.csv" ) | Digit Recognizer |
5,056,419 | evaluation = evaluation_df('Linear Regression', mae, mse, rmse, evaluation )<install_modules> | y_train = train["label"]
y_train.head() | Digit Recognizer |
5,056,419 | !pip install xgboost<train_model> | x_train = train.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
5,056,419 | %%time
xgbreg = xgb.XGBRegressor()
xgbreg.fit(X_train_scalled, y_train )<compute_test_metric> | y_train.value_counts() | Digit Recognizer |
5,056,419 | xgbreg.score(X_train_scalled, y_train )<predict_on_test> | x_train = x_train/255.0
test = test/255.0 | Digit Recognizer |
5,056,419 | y_train_pred = xgbreg.predict(X_train_scalled )<compute_test_metric> | x_train = x_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1)
print('x_train shape:', x_train.shape ) | Digit Recognizer |
5,056,419 | r2_score(y_train, y_train_pred )<predict_on_test> | y_train = keras.utils.to_categorical(y_train,num_classes=10 ) | Digit Recognizer |
5,056,419 | y_val_pred = xgbreg.predict(X_val_scalled )<compute_test_metric> | random_seed = 1 | Digit Recognizer |
5,056,419 | r2_score(y_val, y_val_pred )<compute_test_metric> | from sklearn.model_selection import train_test_split | Digit Recognizer |
5,056,419 | 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... | from sklearn.model_selection import train_test_split | Digit Recognizer |
5,056,419 | evaluation = evaluation_df('Extreme Gradient Boosting', mae, mse, rmse, evaluation )<choose_model_class> | 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 |
5,056,419 |
<predict_on_test> | from keras.layers import LeakyReLU | Digit Recognizer |
5,056,419 |
<choose_model_class> | model = Sequential()
model.add(Conv2D(32,(3,3), padding='Same', activation='relu', input_shape=(28, 28, 1)))
model.add(Dropout(0.25))
model.add(Conv2D(32,(7,7),activation='relu'))
model.add(Conv2D(128,(5,5),activation='relu'))
model.add(MaxPool2D(( 2,2)))
model.add(Conv2D(64,(3,3), padding='Same',activation='relu'))
... | Digit Recognizer |
5,056,419 | %%time
xgbreg = xgb.XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,
importance_type='gain', interaction_constraints='',
learning_rate=0.45, max_delta_step=0, max_depth=7,
min_child_weight=15, monotone_constraints='() ',
n_estimators=120, n_... | optimizer = Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0)
model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
| Digit Recognizer |
5,056,419 | xgbreg.score(X_train_scalled, 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=20,
zoom_range = 0.13,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(x_... | Digit Recognizer |
5,056,419 | y_train_pred = xgbreg.predict(X_train_scalled )<compute_test_metric> | model.fit_generator(
datagen.flow(x_train, y_train, batch_size=256),
steps_per_epoch=len(x_train)//256,
epochs=30,
) | Digit Recognizer |
5,056,419 | r2_score(y_train, y_train_pred )<predict_on_test> | score = model.evaluate(x_val, y_val, verbose=1)
print('Test loss:', score[0])
print('Test accuracy:', score[1] ) | Digit Recognizer |
5,056,419 | y_val_pred = xgbreg.predict(X_val_scalled )<compute_test_metric> | result = model.predict(test)
result = np.argmax(result,axis=1)
result = pd.Series(result,name="Label" ) | Digit Recognizer |
5,056,419 | r2_score(y_val, y_val_pred )<compute_test_metric> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),result],axis = 1)
submission.to_csv("cnn_mnist.csv",index=False ) | Digit Recognizer |
7,836,969 | 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 )<crea... | digit_recon_tran_csv = pd.read_csv('/kaggle/input/digit-recognizer/train.csv',dtype = np.float32)
digit_recon_test_csv = pd.read_csv('/kaggle/input/digit-recognizer/test.csv',dtype = np.float32 ) | Digit Recognizer |
7,836,969 | evaluation = evaluation_df('Extreme Gradient Boosting Tuning 1', mae, mse, rmse, evaluation )<choose_model_class> | print('tran dataset size: ',digit_recon_tran_csv.size,'
')
print('test dataset size: ',digit_recon_test_csv.size,'
' ) | Digit Recognizer |
7,836,969 |
<predict_on_test> | tran_label = digit_recon_tran_csv.label.values
tran_image = digit_recon_tran_csv.loc[:,digit_recon_tran_csv.columns != "label"].values/255
test_image = digit_recon_test_csv.values/255 | Digit Recognizer |
7,836,969 |
<choose_model_class> | train_image, valid_image, train_label, valid_label = train_test_split(tran_image,
tran_label,
test_size = 0.2,
random_state = 42 ) | Digit Recognizer |
7,836,969 | %%time
xgbreg = xgb.XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,
importance_type='gain', interaction_constraints='',
learning_rate=0.3, max_delta_step=0, max_depth=6,
min_child_weight=1, monotone_constraints='() ',
n_estimators=3000, n_j... | print(torch.__version__)
class MNIST_data(Dataset):
def __init__(self,
data,
transform = transforms.Compose([transforms.ToPILImage() ,
transforms.RandomAffine(30,(0.1,0.1)) ,
transforms.ToTensor()
])
):
if len(data)== 1:
self.X = data[0].reshape(-1,28,28)
self.y = None
else:
self.X = data[0].reshape(-1,28,28)
self... | Digit Recognizer |
7,836,969 | y_train_pred = xgbreg.predict(X_train_scalled )<compute_test_metric> | batch_size = 64
train_dataset = MNIST_data(( train_image,train_label))
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size, shuffle=True)
valid_dataset = MNIST_data(( valid_image,valid_label))
valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset,
batch_size=batch_size, s... | Digit Recognizer |
7,836,969 | r2_score(y_train, y_train_pred )<predict_on_test> | class YANNet(nn.Module):
def __init__(self):
super(YANNet,self ).__init__()
self.conv = nn.Sequential(
nn.Conv2d(1,8,3,1,1),
nn.BatchNorm2d(8),
nn.ReLU() ,
nn.Conv2d(8,16,3,1,1),
nn.BatchNorm2d(16),
nn.ReLU() ,
nn.MaxPool2d(2),
nn.Conv2d(16,16,3,1,1),
nn.BatchNorm2d(16),
nn.ReLU() ,
nn.Conv2d(16,8,3,1,1),
nn.BatchNorm... | Digit Recognizer |
7,836,969 | y_val_pred = xgbreg.predict(X_val_scalled )<compute_test_metric> | model = YANNet()
error = nn.CrossEntropyLoss()
if torch.cuda.is_available() :
model = model.cuda()
error = error.cuda()
optimizer = torch.optim.SGD(model.parameters() , lr=0.1)
scheduler = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1 ) | Digit Recognizer |
7,836,969 | r2_score(y_val, y_val_pred )<compute_test_metric> | num_epoc = 120
for epoch in range(num_epoc):
epoc_train_loss = 0.0
epoc_train_corr = 0.0
epoc_valid_corr = 0.0
print('Epoch:{}/{}'.format(epoch,num_epoc))
model.train()
scheduler.step()
for batch_idx,(images, labels)in enumerate(train_loader):
if torch.cuda.is_available() :
images = images.cuda()
labels = labels.cuda()... | Digit Recognizer |
7,836,969 | 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... | model = model.cpu()
model.eval() | Digit Recognizer |
7,836,969 | evaluation = evaluation_df('Extreme Gradient Boosting with Tuning 2', mae, mse, rmse, evaluation )<count_missing_values> | digit_recon_submission_csv = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv',dtype = np.float32)
print(digit_recon_submission_csv.head(10)) | Digit Recognizer |
7,836,969 | df_store.isnull().sum() * 100 / df_store.shape[0]<categorify> | for i in range(test_image.shape[0]):
one_image = torch.from_numpy(test_image[i] ).view(1,1,28,28)
one_output = model(one_image)
test_results[i,0] = i+1
test_results[i,1] = torch.max(one_output.data,1)[1].numpy()
| Digit Recognizer |
7,836,969 | <feature_engineering><EOS> | Data = {'ImageId': test_results[:, 0], 'Label': test_results[:, 1]}
DataFrame = pd.DataFrame(Data)
DataFrame.to_csv('submission.csv', index=False, sep=',' ) | Digit Recognizer |
4,223,111 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<drop_column> | print(os.listdir(".. /input"))
seed = 4529
np.random.seed(seed ) | Digit Recognizer |
4,223,111 | df_train.drop('CompetitionDistance', inplace = True, axis = 1)
df_train.head()<prepare_x_and_y> | base_dir = os.path.join(".. ", "input")
train_df = pd.read_csv(os.path.join(base_dir, "train.csv"))
test_df = pd.read_csv(os.path.join(base_dir, "test.csv"))
len(train_df ) | Digit Recognizer |
4,223,111 | X = df_train.drop(['Sales', 'Store'], axis = 1)
y = df_train['Sales']<split> | %load_ext tensorboard.notebook
%tensorboard --logdir logs | Digit Recognizer |
4,223,111 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.1, random_state = 53)
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size = 0.5, random_state = 53 )<choose_model_class> | x = train_df.drop(['label'], axis=1 ).values
y = train_df['label'].values
test_x = test_df.values | Digit Recognizer |
4,223,111 | %%time
xgbreg = xgb.XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,
importance_type='gain', interaction_constraints='',
learning_rate=0.3, max_delta_step=0, max_depth=6,
min_child_weight=1, monotone_constraints='() ',
n_estimators=3000, n_j... | x = x.reshape(-1, 28, 28, 1)
x = x / 255.0
test_x = test_x.reshape(-1, 28, 28, 1)
test_x = test_x / 255.0
y = to_categorical(y, num_classes=10)
x_train, x_val, y_train, y_val = train_test_split(x, y, test_size = 0.1, random_state=seed ) | Digit Recognizer |
4,223,111 | y_train_pred = xgbreg.predict(X_train )<compute_test_metric> | model = Sequential([
Conv2D(128,(3,3), activation="relu", input_shape=(28, 28, 1)) ,
BatchNormalization() ,
Conv2D(128,(3,3), activation="relu"),
BatchNormalization() ,
MaxPooling2D(2,2),
Dropout(0.2),
Conv2D(64,(3,3), activation="relu"),
BatchNormalization() ,
Conv2D(64,(3,3), activation="relu"),
BatchNormalization() ... | Digit Recognizer |
4,223,111 | r2_score(y_train, y_train_pred )<predict_on_test> | batch_size = 128
epochs = 30
datagen = ImageDataGenerator(rotation_range=15,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range=0.15,
shear_range=0.15)
datagen.fit(x_train)
history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
validation_data=(x_val, y_val),
steps_per_epoch = x_t... | Digit Recognizer |
4,223,111 | <compute_test_metric><EOS> | pred = model.predict(test_x)
pred = np.argmax(pred, axis=1)
pred = pd.Series(pred, name="Label")
test_df = pd.concat([pd.Series(range(1,28001), name = "ImageId"), pred],axis = 1)
test_df.to_csv('mnist-submission.csv', index = False ) | Digit Recognizer |
4,297,932 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<compute_test_metric> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | 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... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,297,932 | evaluation = evaluation_df('Extreme Gradient Boosting with Change in Data', mae, mse, rmse, evaluation )<prepare_x_and_y> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
4,297,932 | X = df_train.drop(['Sales', 'Year'], axis = 1)
y = df_train['Sales']<split> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
4,297,932 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.1, random_state = 53)
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size = 0.5, random_state = 53 )<choose_model_class> | random_seed = 2 | Digit Recognizer |
4,297,932 | %%time
xgbreg = xgb.XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bynode=1, colsample_bytree=1, gamma=0, gpu_id=-1,
importance_type='gain', interaction_constraints='',
learning_rate=0.3, max_delta_step=0, max_depth=5,
min_child_weight=1, monotone_constraints='() ',
n_estimators=4500, n_j... | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.05, random_state=random_seed ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.