kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,953,593 | most_common = all_data.Embarked.mode()
print("Most common Embarked value: {0}".format(most_common[0]))
for data in [train_data, test_data]:
data.fillna(value={'Embarked': most_common[0]}, inplace=True )<drop_column> | subs=pd.DataFrame({"ImageId":ImageId,"Label":class_score} ) | Digit Recognizer |
10,953,593 | <categorify><EOS> | subs.to_csv("submission.csv",index=False)
subs.head(3 ) | Digit Recognizer |
10,770,776 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<prepare_x_and_y> | import tensorflow as tf
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import VGG16
from keras.models import Model
from keras.layers import Dense
from keras.layers import Flatten
from keras.m... | Digit Recognizer |
10,770,776 | X = train_data.drop(['Survived', 'PassengerId'], axis=1)
y = train_data['Survived']
test_X = test_data.drop(['PassengerId'], axis=1 )<train_on_grid> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
target = train['label']
train = train.drop(['label'], axis=1)
| Digit Recognizer |
10,770,776 | best_models = {}
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)
def print_best_parameters(hyperparameters, best_parameters):
value = "Best parameters: "
for key in hyperparameters:
value += str(key)+ ": " + str(best_parameters[key])+ ", "
if hyperparameters:
print(value[:-2])
def get_best_mod... | full = pd.concat([train, test])
full=full.to_numpy()
full=full.reshape(-1, 28, 28)
full.shape | Digit Recognizer |
10,770,776 | class MyXGBClassifier(XGBClassifier):
def fit(self, X, y=None):
return super(XGBClassifier, self ).fit(X, y,
verbose=False,
early_stopping_rounds=40,
eval_metric='logloss',
eval_set=[(val_X, val_y)] )<choose_model_class> | full = np.pad(full,(( 0,0),(2,2),(2,2)) , mode='constant')
full = stacked_img = np.stack([full, full, full], axis=3)
full.shape | Digit Recognizer |
10,770,776 | randomForest = RandomForestClassifier(random_state=1, n_estimators=20, max_features='auto',
criterion='gini', max_depth=4, min_samples_split=2,
min_samples_leaf=3)
xgbClassifier = MyXGBClassifier(seed=1, tree_method='gpu_hist', predictor='gpu_predictor',
use_label_encoder=False, learning_rate=0.4, gamma=0.4,
max_depth... | full=full.astype("float32")
full = full/255
train=full[:42000, :, :, :]
test=full[42000:, :, :, :] | Digit Recognizer |
10,770,776 | hyperparameters = {
'n_jobs' : [-1],
'voting' : ['hard', 'soft'],
'weights' : [(1, 1, 1),
(2, 1, 1),(1, 2, 1),(1, 1, 2),
(2, 2, 1),(1, 2, 2),(2, 1, 2),
(3, 2, 1),(1, 3, 2),(2, 1, 3),(3, 1, 2)]
}
estimator = VotingClassifier(estimators=classifiers)
best_model_voting = get_best_model(estimator, hyperparameters )<find... | X_train, X_val, Y_train, Y_val = train_test_split(train, target, test_size = 0.2, random_state = 1 ) | Digit Recognizer |
10,770,776 | evaluate_model(best_model_voting.best_estimator_, 'voting' )<save_to_csv> | Y_val_access = Y_val | Digit Recognizer |
10,770,776 | for model in best_models:
predictions = best_models[model].predict(test_X)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('submission_' + model + '.csv', index=False )<load_from_csv> | Y_val=to_categorical(Y_val, num_classes=10)
Y_train=to_categorical(Y_train, num_classes=10 ) | Digit Recognizer |
10,770,776 | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' )<prepare_x_and_y> | def create_model() :
VGG = VGG16(
input_shape=(32, 32, 3),
weights='imagenet',
include_top=False,
)
model =tf.keras.Sequential([VGG,
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
return model | Digit Recognizer |
10,770,776 | features = ['Pclass','Sex','SibSp','Parch','Fare','Age']
x = pd.get_dummies(train_data[features])
x_test = pd.get_dummies(test_data[features])
y = train_data["Survived"]
<data_type_conversions> | im = ImageDataGenerator(zoom_range=0.1, rotation_range=15, height_shift_range= 0.05, width_shift_range= 0.05)
flow=im.flow(X_train, Y_train, batch_size=32 ) | Digit Recognizer |
10,770,776 | x['Fare'].fillna(x['Fare'].mode() [0], inplace=True)
x_test['Fare'].fillna(x_test['Fare'].mode() [0], inplace=True)
x['Age'].fillna(x['Age'].mode() [0], inplace=True)
x_test['Age'].fillna(x_test['Age'].mode() [0], inplace=True)
<train_on_grid> | mymod=create_model()
mymod.summary()
mymod.compile(optimizer=Adam(lr=0.0001), loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
10,770,776 | param_grid = {'alpha': sp_rand() }
model = Ridge()
rsearch = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=100)
rsearch.fit(x,y)
print(rsearch )<save_to_csv> | predictions_val = np.zeros(shape=(5, X_val.shape[0], 10))
predictions_test = np.zeros(shape=(5, test.shape[0], 10))
for i in range(5):
print('training model ', i+1, '...')
perf = mymod.fit_generator(flow, epochs=10, steps_per_epoch= X_train.shape[0]/32, validation_data=(X_val, Y_val), verbose=0)
pred_val = mymod.pred... | Digit Recognizer |
10,770,776 | <load_from_csv><EOS> | preds= pd.Series(preds_test,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),preds],axis = 1)
submission.to_csv("MINST.csv",index=False ) | Digit Recognizer |
11,247,216 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalization
from keras.preprocessing.image import ImageDataGenerator... | Digit Recognizer |
11,247,216 | temp = np.where(np.isnan(train_data.Age))
len(temp[0] )<feature_engineering> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,247,216 | for item in temp[0]:
train_data.Age.at[item] = np.mean(train_data.Age)
temp = np.where(np.isnan(train_data.Age))
len(temp[0] )<feature_engineering> | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
X_train = X_train / 255.0
X_test = test / 255.0
X_train = X_train.values.reshape(-1,28,28,1)
X_test = X_test.values.reshape(-1,28,28,1)
Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
11,247,216 | temp = np.where(np.isnan(test_data.Fare))
for item in temp[0]:
test_data.Fare.at[item] = np.mean(test_data.Fare)
temp = np.where(np.isnan(test_data.Fare))
len(temp[0] )<feature_engineering> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.10,
width_shift_range=0.1,
height_shift_range=0.1 ) | Digit Recognizer |
11,247,216 | temp = np.where(np.isnan(test_data.Age))
for item in temp[0]:
test_data.Age.at[item] = np.mean(train_data.Age)
temp = np.where(np.isnan(test_data.Age))
len(temp[0] )<categorify> | enet = EfficientNetB3(input_shape=(32, 32, 3), weights='imagenet',include_top=False ) | Digit Recognizer |
11,247,216 | y = train_data['Survived']
features = ['Pclass', 'Sex', 'SibSp', 'Parch','Fare', 'Age']
x = pd.get_dummies(train_data[features])
x_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators = 100, max_depth = 5, random_state = 1)
model.fit(x, y)
predictions = model.predict(x_test )<save_... | X_train = np.pad(X_train,(( 0,0),(2,2),(2,2),(0,0)) , mode='constant')
X_train.shape | Digit Recognizer |
11,247,216 | output = pd.DataFrame({'PassengerId' : test_data.PassengerId, 'Survived' : predictions})
output.to_csv('submission.csv', index = False)
print("Your submission was successfully saved!" )<load_from_csv> | X_train = np.squeeze(X_train, axis=-1)
X_train = stacked_img = np.stack(( X_train,)*3, axis=-1)
X_train.shape | Digit Recognizer |
11,247,216 | df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv' )<count_values> | nets = 2
model = [0] *nets
for j in range(nets):
model[j] = Sequential(enet)
model[j].add(Flatten())
model[j].add(Dense(units=1024, use_bias=True, activation='relu'))
model[j].add(BatchNormalization())
model[j].add(Dense(units=512, use_bias=True, activation='relu'))
model[j].add(BatchNormalization())
model[j].add(D... | Digit Recognizer |
11,247,216 | df['Sex'].value_counts()<concatenate> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [0] * nets
epochs = 45
for j in range(nets):
X_train2, X_val2, Y_train2, Y_val2 = train_test_split(X_train, Y_train, test_size = 0.1)
history[j] = model[j].fit_generator(datagen.flow(X_train2,Y_train2, batch_size=64),
epochs = epochs, steps_per_ep... | Digit Recognizer |
11,247,216 | complete_df = pd.concat([df, test_df] )<count_missing_values> | X_test = np.pad(X_test,(( 0,0),(2,2),(2,2),(0,0)) , mode='constant')
X_test = np.squeeze(X_test, axis=-1)
X_test = stacked_img = np.stack(( X_test,)*3, axis=-1)
X_test.shape | Digit Recognizer |
11,247,216 | complete_df.isnull().sum()<filter> | results = np.zeros(( X_test.shape[0],10))
for j in range(nets):
results = results + model[j].predict(X_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("MNIST_EffNet_Ensemble.... | Digit Recognizer |
11,247,216 | <feature_engineering><EOS> | X_test1a = test / 255.0
X_test1a = X_test1a.values.reshape(-1,28,28,1 ) | Digit Recognizer |
11,282,263 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<filter> | mnist_test = pd.read_csv(".. /input/mnist-in-csv/mnist_test.csv")
mnist_train = pd.read_csv(".. /input/mnist-in-csv/mnist_train.csv" ) | Digit Recognizer |
11,282,263 | complete_df[complete_df['Fare'].isnull() ]<feature_engineering> | sample_submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv" ) | Digit Recognizer |
11,282,263 | complete_df['Fare'] = complete_df.groupby('Pclass')['Fare'].transform(lambda val: val.fillna(val.median()))<feature_engineering> | test['dataset'] = 'test' | Digit Recognizer |
11,282,263 | complete_df.loc[complete_df['Sex']=='female','Age'] = complete_df[complete_df['Sex']=='female']['Age'].transform(lambda val: val.fillna(val.median()))
complete_df.loc[complete_df['Sex']=='male', 'Age'] = complete_df[ complete_df['Sex']=='male' ]['Age'].transform(lambda val: val.fillna(val.median()))<count_missing_value... | train['dataset'] = 'train' | Digit Recognizer |
11,282,263 | complete_df.isnull().sum()<drop_column> | dataset = pd.concat([train.drop('label', axis=1), test] ).reset_index() | Digit Recognizer |
11,282,263 | X = complete_df[:891].drop(['PassengerId', 'Survived', 'Name', 'Ticket', 'Cabin'] ,axis=1)
X<categorify> | mnist = pd.concat([mnist_train, mnist_test] ).reset_index(drop=True)
labels = mnist['label'].values
mnist.drop('label', axis=1, inplace=True)
mnist.columns = cols | Digit Recognizer |
11,282,263 | X = pd.get_dummies(X)
X<prepare_x_and_y> | idx_mnist = mnist.sort_values(by=list(mnist.columns)).index
dataset_from = dataset.sort_values(by=list(mnist.columns)) ['dataset'].values
original_idx = dataset.sort_values(by=list(mnist.columns)) ['index'].values | Digit Recognizer |
11,282,263 | y = complete_df[:891]['Survived']<import_modules> | for i in range(len(idx_mnist)) :
if dataset_from[i] == 'test':
sample_submission.loc[original_idx[i], 'Label'] = labels[idx_mnist[i]] | Digit Recognizer |
11,282,263 | from sklearn.model_selection import train_test_split<import_modules> | sample_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
8,738,762 | from sklearn.model_selection import train_test_split<split> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
8,738,762 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42 )<import_modules> | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
8,738,762 | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV<define_search_space> | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
8,738,762 | param_grid = {'max_depth':[4,5,6,7,8,9,10]}<train_on_grid> | Y_train = keras.utils.to_categorical(Y_train, 10 ) | Digit Recognizer |
8,738,762 | forest = RandomForestClassifier(random_state=42)
grid = GridSearchCV(forest, param_grid, cv=10)
grid.fit(X_train, y_train )<find_best_params> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1 ) | Digit Recognizer |
8,738,762 | grid.best_params_<import_modules> | batch_size = 86
num_classes = 10
epochs = 10
input_shape =(28, 28, 1 ) | Digit Recognizer |
8,738,762 | from sklearn.metrics import accuracy_score, classification_report<predict_on_test> | batch_size = 86
num_classes = 10
epochs = 10
input_shape =(28, 28, 1)
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(( ... | Digit Recognizer |
8,738,762 | test_predictions = grid.predict(X_test)
print(accuracy_score(y_test, test_predictions))<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 |
8,738,762 | print(classification_report(y_test, test_predictions))<categorify> | mnist_test = pd.read_csv(".. /input/mnist-in-csv/mnist_test.csv")
mnist_train = pd.read_csv(".. /input/mnist-in-csv-train/mnist_train.csv" ) | Digit Recognizer |
8,738,762 | X_final = complete_df[891:].drop(['PassengerId', 'Survived', 'Name', 'Ticket', 'Cabin'] ,axis=1)
X_final = pd.get_dummies(X_final )<predict_on_test> | sample_submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv" ) | Digit Recognizer |
8,738,762 | forest = RandomForestClassifier(max_depth=6, random_state=42)
forest.fit(X,y)
final_preds = forest.predict(X_final )<load_from_csv> | test['dataset'] = 'test' | Digit Recognizer |
8,738,762 | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission<prepare_output> | train['dataset'] = 'train' | Digit Recognizer |
8,738,762 | submission['Survived'] = final_preds
submission<data_type_conversions> | dataset = pd.concat([train.drop('label', axis=1), test] ).reset_index() | Digit Recognizer |
8,738,762 | submission['Survived'] = submission['Survived'].astype(int)
submission<save_to_csv> | mnist = pd.concat([mnist_train, mnist_test] ).reset_index(drop=True)
labels = mnist['label'].values
mnist.drop('label', axis=1, inplace=True)
mnist.columns = cols | Digit Recognizer |
8,738,762 | submission.to_csv('submission.csv', index=False )<save_to_csv> | idx_mnist = mnist.sort_values(by=list(mnist.columns)).index
dataset_from = dataset.sort_values(by=list(mnist.columns)) ['dataset'].values
original_idx = dataset.sort_values(by=list(mnist.columns)) ['index'].values | Digit Recognizer |
8,738,762 | submission.to_csv('submission.csv', index=False )<set_options> | for i in range(len(idx_mnist)) :
if dataset_from[i] == 'test':
sample_submission.loc[original_idx[i], 'Label'] = labels[idx_mnist[i]]
| Digit Recognizer |
8,738,762 | sns.set_style("whitegrid")
%matplotlib inline<set_options> | sample_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
4,401,419 | warnings.filterwarnings('ignore' )<load_from_csv> | train_data = pd.read_csv(".. /input/train.csv" ) | Digit Recognizer |
4,401,419 | train = pd.read_csv('.. /input/telstra-recruiting-network/train.csv.zip')
test = pd.read_csv('.. /input/telstra-recruiting-network/test.csv.zip')
severity_type = pd.read_csv('.. /input/telstra-recruiting-network/severity_type.csv.zip', error_bad_lines= False, warn_bad_lines= False)
resource_type = pd.read_csv('.. /i... | X = train_data[label_names[1:]]
y = train_data[label_names[0]] | Digit Recognizer |
4,401,419 | train_1 = train.merge(severity_type, how = 'left', left_on='id', right_on='id')
train_2 = train_1.merge(resource_type, how = 'left', left_on='id', right_on='id')
train_3 = train_2.merge(log_failure, how = 'left', left_on='id', right_on='id')
train_4 = train_3.merge(event_type, how = 'left', left_on='id', right_on='i... | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2 ) | Digit Recognizer |
4,401,419 | train_4.drop_duplicates(subset= 'id', keep= 'first', inplace = True)
train_4.head()<import_modules> | img_rows, img_cols = 28, 28
num_classes =10
X_train = X_train.values.reshape([-1,28,28,1])/255
X_test = X_test.values.reshape([-1,28,28,1])/255
y_train = y_train.values
y_test = y_test.values
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes ) | Digit Recognizer |
4,401,419 | from catboost import CatBoostClassifier, Pool
from sklearn.model_selection import train_test_split<prepare_x_and_y> | model = Sequential()
| Digit Recognizer |
4,401,419 | X = train_4[['id', 'location', 'severity_type', 'resource_type',
'log_feature', 'volume', 'event_type']]
y = train_4.fault_severity<split> | model.add(tf.keras.layers.Conv2D(32,(3, 3), padding='same',
input_shape=(img_rows,img_cols,1)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.Conv2D(32,(3, 3)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.... | Digit Recognizer |
4,401,419 | X_train, X_validation, y_train, y_validation = train_test_split(X, y, test_size=0.20, random_state=101 )<define_variables> | batch_size =128
epochs = 100
history = model.fit(X_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_test, y_test)) | Digit Recognizer |
4,401,419 | categorical_features_indices = np.where(X_train.dtypes == object)[0]<create_dataframe> | test_data = pd.read_csv(".. /input/test.csv")
y_pred = model.predict(test_data.values.reshape([-1,28,28,1])/255,batch_size=batch_size)
y_pred = np.argmax(y_pred,axis=1)
| Digit Recognizer |
4,401,419 | train_dataset = Pool(data=X_train,
label=y_train,
cat_features=categorical_features_indices)
eval_dataset = Pool(data=X_validation,
label=y_validation,
cat_features=categorical_features_indices )<choose_model_class> | save = pd.DataFrame()
save["ImageId"] = list(range(1,len(y_pred)+1))
save["Label"] = y_pred
save.to_csv("submit.csv", index=False)
| Digit Recognizer |
10,941,180 | model = CatBoostClassifier(iterations=1000,
learning_rate=1,
depth=2,
loss_function='MultiClass',
random_seed=1,
bagging_temperature=22,
od_type='Iter',
metric_period=100,
od_wait=100 )<train_model> | train_df = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
print(train_df.shape ) | Digit Recognizer |
10,941,180 | model.fit(train_dataset, eval_set= eval_dataset, plot= True )<predict_on_test> | X_train = train_df.iloc[:,1:].values
y_train = train_df.iloc[:,0].values | Digit Recognizer |
10,941,180 | preds_class = model.predict(eval_dataset)
preds_proba = model.predict_proba(eval_dataset )<merge> | N = X_train.shape[0]
X_train = X_train.reshape(N,28,28,1)
X_train = X_train.astype('float32')
X_train /= 255.
y_train = tf.one_hot(y_train, 10)
X_train.shape, y_train.shape | Digit Recognizer |
10,941,180 | test_1 = test.merge(severity_type, how = 'left', left_on='id', right_on='id')
test_2 = test_1.merge(resource_type, how = 'left', left_on='id', right_on='id')
test_3 = test_2.merge(log_failure, how = 'left', left_on='id', right_on='id')
test_4 = test_3.merge(event_type, how = 'left', left_on='id', right_on='id' )<rem... | def make_model(inputs):
x = tf.keras.layers.Conv2D(filters=32,kernel_size=(3,3))(inputs)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.ReLU()(x)
x = tf.keras.layers.MaxPool2D()(x)
x = tf.keras.layers.Conv2D(filters=64,kernel_size=(3,3))(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras... | Digit Recognizer |
10,941,180 | test_4.drop_duplicates(subset= 'id', keep= 'first', inplace = True)
test_4.head()<count_missing_values> | tf.keras.backend.clear_session()
inputs = tf.keras.Input(shape=(28,28,1))
outputs = make_model(inputs)
model = tf.keras.Model(
inputs=inputs,
outputs=outputs,
name="simple"
)
model.compile(optimizer='adam', loss='categorical_crossentropy' ) | Digit Recognizer |
10,941,180 | test_4.isnull().sum()<save_to_csv> | history = model.fit(X_train,y_train, validation_split=0.2,epochs=10 ) | Digit Recognizer |
10,941,180 | predict_test=model.predict_proba(test_4)
pred_df=pd.DataFrame(predict_test,columns=['predict_0', 'predict_1', 'predict_2'])
submission_cat=pd.concat([test[['id']],pred_df],axis=1)
submission_cat.to_csv('sub_cat_1.csv',index=False,header=True )<load_from_csv> | X_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ).values
N_test = X_test.shape[0]
X_test = X_test.reshape(N_test,28,28,1)
X_test = X_test.astype('float32')
X_test /= 255.
X_test.shape | Digit Recognizer |
10,941,180 | train = pd.read_csv(input_path / 'train.csv', index_col='id')
test = pd.read_csv(input_path / 'test.csv', index_col='id')
submission = pd.read_csv(input_path / 'sample_submission.csv', index_col='id' )<split> | pred = model.predict(X_test)
pred.shape | Digit Recognizer |
10,941,180 | <init_hyperparams><EOS> | submissions=pd.DataFrame({"ImageId": list(range(1,len(pred)+1)) ,
"Label": np.argmax(pred, axis=1)})
submissions.to_csv("my_submissions.csv", index=False, header=True ) | Digit Recognizer |
8,326,415 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<init_hyperparams> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalization
from keras.preprocessing... | Digit Recognizer |
8,326,415 | parameters2 = {
'n_estimators': 350,
'tree_method': 'exact',
'learning_rate': 0.03,
'colsample_bytree': 0.9,
'subsample': 0.9,
'min_child_weight': 9,
'max_depth': 11,
'n_jobs': -1
}<train_on_grid> | batch_size = 86
num_nets = 15 | Digit Recognizer |
8,326,415 |
<choose_model_class> | digits_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
digits_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
8,326,415 |
<train_model> | X = digits_train.drop(columns="label" ).values.reshape(digits_train.shape[0],28,28,1)/ 255.0
Y = to_categorical(digits_train["label"], num_classes=10)
X_test = digits_test.values.reshape(digits_test.shape[0],28,28,1)/ 255.0 | Digit Recognizer |
8,326,415 | final_model = XGBRegressor(tree_method='hist', min_child_weight=9, max_depth=11, n_jobs=-1, colsample_bytree=0.5, learning_rate=0.01, n_estimators=1500)
final_model.fit(X_train, y_train, early_stopping_rounds=10, eval_set=[(X_test, y_test)], verbose=False)
prediction = final_model.predict(X_test)
mse = mean_squared_... | datagen_train = ImageDataGenerator(
rotation_range = 10,
zoom_range = 0.10,
width_shift_range=0.1,
height_shift_range=0.1
) | Digit Recognizer |
8,326,415 | submission['target'] = final_model.predict(test)
submission.to_csv('xgb_reg.csv' )<import_modules> | model = [0] * num_nets
for j in range(num_nets):
model[j] = Sequential()
model[j].add(Conv2D(32, kernel_size = 3, activation = "relu", input_shape =(28, 28, 1)))
model[j].add(BatchNormalization())
model[j].add(Conv2D(32, kernel_size = 3, activation = "relu"))
model[j].add(BatchNormalization())
model[j].add(Conv2D(32... | Digit Recognizer |
8,326,415 | import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib_venn import venn2
import shap
from optuna.integration import _lightgbm_tuner as lgb_tuner
import optuna
from catboost import CatBoost
from catboost import Pool
from catboost import cv
import category_encoders as ce
from tqdm import tqdm
import lightg... | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [0] * num_nets
epochs = 45
for j in range(num_nets):
x_train, x_val, y_train, y_val = train_test_split(X, Y, test_size = 0.1)
history[j] = model[j].fit_generator(datagen_train.flow(x_train, y_train, batch_size = 64),
epochs = epochs,
steps_per_epo... | Digit Recognizer |
8,326,415 | <prepare_x_and_y><EOS> | results = np.zeros(( X_test.shape[0], 10))
for j in range(num_nets):
results = results + model[j].predict(X_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.ImageId = submiss... | Digit Recognizer |
7,034,662 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<init_hyperparams> | import datetime
import imageio
import numpy as np
import pandas as pd
import pickle
from sklearn.model_selection import train_test_split
from fastai.vision import *
from fastai.metrics import accuracy, error_rate
from fastai.widgets import DatasetFormatter, PredictionsCorrector | Digit Recognizer |
7,034,662 | fold_num = 10
EARLY_STOPPING_ROUNDS = 10
VERBOSE_EVAL = 10000
LGB_ROUND_NUM = 10000
objective = 'regression'
metric = 'rmse'
params = {
'task': 'train',
'boosting_type': 'gbdt',
'objective': objective,
'metric': metric,
'verbosity': -1,
"seed": 42,
}
@contextmanager
def timer(logger=None, format_str='{:.3f}[s]', prefix... | print(fastai.__version__ ) | Digit Recognizer |
7,034,662 | fold = KFold(n_splits=5, shuffle=True, random_state=71)
cv = list(fold.split(X, y))
oof, models = fit_lgbm(X.values, y, cv, params=params )<create_dataframe> | np.random.seed(42 ) | Digit Recognizer |
7,034,662 | def visualize_importance(models, feat_train_df):
feature_importance_df = pd.DataFrame()
for i, model in enumerate(models):
_df = pd.DataFrame()
_df['feature_importance'] = model.feature_importance()
_df['column'] = feat_train_df.columns
_df['fold'] = i + 1
feature_importance_df = pd.concat([feature_importance_df, _df... | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
7,034,662 | X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8)
def opt(trial):
n_estimators = trial.suggest_int('n_estimators', 0, 1000)
max_depth = trial.suggest_int('max_depth', 1, 20)
learning_rate = trial.suggest_discrete_uniform('learning_rate', 0.01,0.1,0.01)
min_child_weight = trial.suggest_int('m... | y = train["label"].values
X = train.iloc[:, 1:].values
X.shape, y.shape | Digit Recognizer |
7,034,662 | def fit_xgb(X, y, cv, params: dict=None, verbose: int=50):
metric_func = mean_squared_error
if params is None:
params = {}
models = []
oof_pred = np.zeros_like(y, dtype=np.float)
for i,(idx_train, idx_valid)in enumerate(cv):
x_train, y_train = X[idx_train], y[idx_train]
x_valid, y_valid = X[idx_valid], y[idx_valid]
mo... | X_train, X_valid, y_train, y_valid = \
train_test_split(X, y, test_size=0.05, random_state=42, stratify=y ) | Digit Recognizer |
7,034,662 |
params_xgb = {'n_estimators': 208,
'max_depth': 4,
'learning_rate':0.08,
'min_child_weight': 13,
'subsample': 0.8,
'colsample_bytree': 0.8}
oof_xgb, models_xgb = fit_xgb(X.values, y, cv, params=params_xgb )<set_options> | def to_img_shape(X, y=[]):
"Format matrix of rows, Nx784 to Nx28x28x3"
X = np.array(X ).reshape(-1,28,28)
X = np.stack(( X,)*3, axis=-1)
y = np.array(y)
return X, y
def save_imgs(path:Path, data, labels=[]):
path.mkdir(parents=True, exist_ok=True)
for label in np.unique(labels):
(path / str(label)).mkdir(parents... | Digit Recognizer |
7,034,662 | def opt_cb(trial):
params = {
'iterations' : trial.suggest_int('iterations', 50, 300),
'depth' : trial.suggest_int('depth', 4, 10),
'learning_rate' : trial.suggest_loguniform('learning_rate', 0.01, 0.3),
'random_strength' :trial.suggest_int('random_strength', 0, 100),
'bagging_temperature' :trial.suggest_loguniform('ba... | X_train, y_train = to_img_shape(X_train, y_train)
X_valid, y_valid = to_img_shape(X_valid, y_valid)
X_test, _ = to_img_shape(test ) | Digit Recognizer |
7,034,662 | def fit_cb(X, y, cv, params: dict=None, verbose: int=50):
metric_func = mean_squared_error
if params is None:
params = {}
models = []
oof_pred = np.zeros_like(y, dtype=np.float)
for i,(idx_train, idx_valid)in enumerate(cv):
x_train, y_train = X[idx_train], y[idx_train]
x_valid, y_valid = X[idx_valid], y[idx_valid]
tra... | %%time
save_imgs(Path('/kaggle/working/data/train'), X_train, y_train ) | Digit Recognizer |
7,034,662 | params_cb = {
'loss_function': 'RMSE',
'max_depth': 3,
'learning_rate': 0.08,
'subsample': 0.8,
'num_boost_round': 1000,
'early_stopping_rounds': 100,
}
oof_cb, models_cb = fit_cb(X.values, y, cv, params=params_cb )<drop_column> | %%time
save_imgs(Path('/kaggle/working/data/valid'), X_valid, y_valid ) | Digit Recognizer |
7,034,662 | df_test = df_test.drop("id",axis=1 )<predict_on_test> | %%time
save_imgs(Path('/kaggle/working/data/test'), X_test ) | Digit Recognizer |
7,034,662 | pred_lgb = np.array([model.predict(df_test.values)for model in models])
pred_lgb = np.mean(pred_lgb, axis=0)
pred_lgb = np.where(pred_lgb < 0, 0, pred_lgb)
pred_xgb = np.array([model.predict(df_test.values)for model in models_xgb])
pred_xgb = np.mean(pred_xgb, axis=0)
pred_xgb = np.where(pred_xgb < 0, 0, pred_xgb)... | path = Path('/kaggle/working/data')
image_list =(ImageList.from_folder(path)
.split_by_folder()
.label_from_folder())
data =(image_list.databunch(bs=1)
.normalize(imagenet_stats)) | Digit Recognizer |
7,034,662 | submission["target"] = tmp_sub["pred"].copy()<save_to_csv> | tfms = get_transforms()
tfms[0] | Digit Recognizer |
7,034,662 | submission.to_csv("submission.csv", index=False )<save_to_csv> | tfms[1] | Digit Recognizer |
7,034,662 | submission.to_csv("submission.csv", index=False )<create_dataframe> | tfms = get_transforms(do_flip=False)
tfms[0] | Digit Recognizer |
7,034,662 | oof_df = pd.DataFrame({"lgb":oof,
"xgb":oof_xgb,
"cb":oof_cb})
oof_df["pred"] = oof_df.mean(axis="columns" )<import_modules> | image_list =(image_list.transform(get_transforms(do_flip=False), size=28)
.add_test(ItemList.from_folder(path=path/"test"), label=None))
data =(image_list.databunch(bs=256)
.normalize(imagenet_stats)) | Digit Recognizer |
7,034,662 | import numpy as np
import pandas as pd<load_from_csv> | learn = cnn_learner(data, models.resnet18, metrics=accuracy ) | Digit Recognizer |
7,034,662 | train_data = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
test_data = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
print('Train: ', train_data.shape)
print('Test: ', test_data.shape )<prepare_x_and_y> | learn.model | Digit Recognizer |
7,034,662 | y = train_data['target']
X = train_data.drop(columns=['target', 'id'])
X_test = test_data.drop(columns='id' )<split> | learn.lr_find() | Digit Recognizer |
7,034,662 | X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.05, random_state=22 )<init_hyperparams> | learn.fit_one_cycle(5, 0.02 ) | Digit Recognizer |
7,034,662 | params = {'objective': 'regression',
'metric': 'rmse',
'verbosity': -1,
'boosting_type': 'gbdt',
'feature_pre_filter': False,
'learning_rate': 0.007,
'num_leaves': 102,
'min_child_samples': 20,
'sub_feature': 0.4,
'sub_row': 1,
'subsample_freq': 0,
'lambda_l1': 4.6,
'lambda_l2': 1.9}
N_FOLDS = 10
kf = KFold(n_splits = ... | learn.save('stage-1' ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.