kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,805,765 | warnings.filterwarnings("ignore")
VERSION = ''<define_variables> | pred = model.predict_classes(X_test_norm ) | Digit Recognizer |
6,805,765 | SEED = 420
N_ESTIMATORS = 250
DEVICE = torch.device("cpu" )<compute_test_metric> | sample_submission['Label'] = pred | Digit Recognizer |
6,805,765 | <load_pretrained><EOS> | sample_submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
1,909,759 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy.misc import toimage
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
import keras
from keras.models import Sequential
from keras.layers import Den... | Digit Recognizer |
1,909,759 | class Best_clf_cv_transformer(BaseEstimator, TransformerMixin):
def __init__(self, myparams={'name':'LSvc', 'C':1}, **other_params):
self.myparams = myparams
self.myinit(**other_params)
return
def myinit(self, **other_params):
self.cv = 5
if 'cv' in self.myparams:
self.cv= self.myparams['cv']
clf = None
name = self.my... | df_train = pd.read_csv(".. /input/train.csv", encoding = 'ISO-8859-1')
df_subm = pd.read_csv(".. /input/test.csv", encoding = 'ISO-8859-1' ) | Digit Recognizer |
1,909,759 | def seed_all() :
random.seed(SEED)
np.random.seed(SEED)
random.seed(SEED)
seed_all()<load_from_csv> | df_train.isnull().sum().sum() , df_subm.isnull().sum().sum() | Digit Recognizer |
1,909,759 | def load_preprocess_data(filename='.. /input/jane-street-market-prediction/train.csv', isTrainData=True):
dtype = None
if isTrainData:
dtype = {
'date' : 'int64',
'weight' : 'float64',
'resp' : 'float64',
'ts_id' : 'int64',
'feature_0' : 'float64'
}
else:
dtype = {
'date' : 'int64',
'weight' : 'float64',
'feature_0' : ... | X_train = df_train[df_train.columns[1:]]
y_train = df_train['label'] | Digit Recognizer |
1,909,759 | X_TRAIN, X_TEST, Y_TRAIN, Y_TEST, W_train, W_test, preprocess_pipe = load_preprocess_data()
gc.collect()
X_TRAIN.shape, Y_TRAIN.shape<normalization> | X_train, X_test, y_train, y_test = train_test_split(X_train, y_train ) | Digit Recognizer |
1,909,759 | def learning_rate_010_decay_power_09(current_iter):
base_learning_rate = 0.1
lr = base_learning_rate * np.power (.995, current_iter)
return lr if lr > 1e-2 else 1e-2
<init_hyperparams> | y_train = to_categorical(y_train)
y_test = to_categorical(y_test ) | Digit Recognizer |
1,909,759 | FIT_PARAMS= {
"early_stopping_rounds":30,
"eval_metric" : 'auc',
"eval_set" : [(X_TEST, Y_TEST[:,-1])],
'eval_names': ['valid'],
'callbacks': [lgb.reset_parameter(learning_rate=learning_rate_010_decay_power_09)],
'verbose': 50,
'categorical_feature': 'auto'
}<init_hyperparams> | X_train = X_train/255
X_test = X_test/255 | Digit Recognizer |
1,909,759 |
<init_hyperparams> | model = Sequential() | Digit Recognizer |
1,909,759 | OPT_PARAMS_1 = {'n_estimators': N_ESTIMATORS, 'colsample_bytree': 0.668, 'min_child_samples': 150, 'min_child_weight': 1, 'num_leaves': 80, 'reg_alpha': 0, 'reg_lambda': 0.002, 'subsample': 0.87}
OPT_PARAMS_2 = {'n_estimators': N_ESTIMATORS, 'colsample_bytree': 0.668, 'min_child_samples': 190, 'min_child_weight': 1, 'n... | model.add(Conv2D(32,(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(Conv2D(32,(3, 3), activation='relu'))
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), activation='relu'))
model.add(MaxPooling2D(pool_size=(... | Digit Recognizer |
1,909,759 | def create_train_lgbm(X_train, y_train, component):
if component == 1:
opt_params = deepcopy(OPT_PARAMS_1)
else:
opt_params = deepcopy(OPT_PARAMS_2)
lgb_clf_1 = lgb.LGBMClassifier(**opt_params)
lgb_clf_1.fit(X_train, y_train, **FIT_PARAMS)
if lgb_clf_1.best_iteration_ != N_ESTIMATORS:
opt_params['n_estimators'] = l... | model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax')) | Digit Recognizer |
1,909,759 | def getLgbs() :
LGBS = []
for model_id in range(5):
y_train = Y_TRAIN[:, model_id]
lgbm_1 = create_train_lgbm(X_TRAIN, y_train, 1)
lgbm_2 = create_train_lgbm(X_TRAIN, y_train, 2)
LGBS.append(( lgbm_1, lgbm_2))
pickleSave(LGBS, 'lgbs.bin')
return LGBS<choose_model_class> | sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True ) | Digit Recognizer |
1,909,759 | def getSclfs() :
SCLFS = []
for model_id in range(5):
sclf = StackingClassifier(classifiers=LGBS[model_id], fit_base_estimators=False,
use_probas=True, average_probas=False,
meta_classifier=Best_clf_cv_transformer({ 'name': 'LSvc', 'params': {'penalty': 'l2', 'class_weight': 'balanced'}, 'param_grid': {'C' : [0.01, 0.0... | model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'] ) | Digit Recognizer |
1,909,759 | LGBS = unpickle('.. /input/jane-lgbm-stackedlsvc/lgbs.bin')
SCLFS = unpickle('.. /input/jane-lgbm-stackedlsvc/sclfs.bin' )<predict_on_test> | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
) | Digit Recognizer |
1,909,759 | def predict(test_df, isRetProb=False):
test_df.drop(columns=['weight', 'date'], inplace=True)
test_df.reset_index(drop=True, inplace=True)
X_test = preprocess_pipe.transform(test_df ).reshape(( -1, 130))
y_probs = []
for sclf in SCLFS:
y_p = sclf.predict_proba(X_test ).reshape(( -1, 2)) [:, 1].reshape(( -1, 1))
y_pro... | datagen.fit(X_train ) | Digit Recognizer |
1,909,759 | env = janestreet.make_env()
env_iter = env.iter_test()<predict_on_test> | model.fit_generator(datagen.flow(X_train, y_train, batch_size=128),
steps_per_epoch=int(len(X_train)/ 128), epochs=30 ) | Digit Recognizer |
1,909,759 | for test_df, pred_df in env_iter:
if test_df["weight"].item() > 0:
predictions = predict(test_df)
pred_df.action = predictions
else:
pred_df.action = 0
env.predict(pred_df )<train_model> | test_data = df_subm.values | Digit Recognizer |
1,909,759 | print('Done !' )<load_from_csv> | test_data = test_data.reshape(test_data.shape[0],28,28,1 ) | Digit Recognizer |
1,909,759 | if tuning or training:
train_data = pd.read_csv('/kaggle/input/jane-street-market-prediction/train.csv')
train_data.fillna(train_data.mean() ,inplace=True)
metadata = pd.read_csv('/kaggle/input/jane-street-market-prediction/features.csv')
metadata.drop(['feature'],axis=1,inplace=True)
def replace_bool(tf):
if tf:
r... | test_data = test_data/255 | Digit Recognizer |
1,909,759 | tf.random.set_seed(42)
SEED=42
def create_model(hp, num_columns, num_labels):
inp = tf.keras.layers.Input(shape =(num_columns, 1))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Conv1D(filters=8,
kernel_size=hp.Int('kernel_size',5,10,step=5),
strides=1,
activation='relu' )(x)
x = tf.keras.layers.M... | predictions = model.predict(test_data ) | Digit Recognizer |
1,909,759 | if tuning:
model_fn = lambda hp: create_model(hp,X_train.shape[-1],y_train.shape[-1])
tuner = kt.tuners.bayesian.BayesianOptimization(
hypermodel=model_fn,
objective= kt.Objective('val_AUC', direction='max'),
num_initial_points=4,
max_trials=20)
tuner.search(X_train,y_train,batch_size=4096,epochs=20, validation_data... | predictions = np.argmax(predictions, axis=1, out=None ) | Digit Recognizer |
1,909,759 | if training:
hp = pd.read_pickle('best_hp_cnn_day_86_metadata_deep.pkl')
model_fn = lambda hp: create_model(hp,X_train.shape[-1],y_train.shape[-1])
model = model_fn(hp)
model.fit(X_train,y_train,validation_data=(X_test,y_test),epochs=100,batch_size=4096,
callbacks=[EarlyStopping('val_AUC',mode='max',patience=10,rest... | with open("resultCNNwithPrepros.csv", "wb")as f:
f.write(b'ImageId,Label
')
np.savetxt(f, np.hstack([(np.array(range(28000)) +1 ).reshape(-1,1), predictions.astype(int ).reshape(-1,1)]), fmt='%i', delimiter="," ) | Digit Recognizer |
4,940,763 | if not training or tuning:
model_fn = lambda hp: create_model(hp,159,5)
hp = pd.read_pickle('/kaggle/input/jscnn/best_hp_cnn_day_86.pkl')
model = model_fn(hp)
model.load_weights('/kaggle/input/jscnn/JS_CNN_day_86.hdf5')
samples_mean = pd.read_csv('/kaggle/input/jscnn/f_mean.csv')
features_transform = np.load('/kag... | %matplotlib inline
| Digit Recognizer |
4,940,763 | plt.style.use('fivethirtyeight')
y_ = Fore.YELLOW
r_ = Fore.RED
g_ = Fore.GREEN
b_ = Fore.BLUE
m_ = Fore.MAGENTA
c_ = Fore.CYAN
sr_ = Style.RESET_ALL
warnings.filterwarnings('ignore')
<load_from_csv> | base = Path('.. /input' ) | Digit Recognizer |
4,940,763 | folder_path = '.. /input/jane-street-market-prediction/'
sample = pd.read_csv(folder_path + 'example_sample_submission.csv')
test_data = pd.read_csv(folder_path + 'example_test.csv' )<set_options> | data_df = pd.read_csv(base/'train.csv')
data_df.head() | Digit Recognizer |
4,940,763 | def seed_everything(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(seed=42 )<load_from_csv> | trn_df = data_df.drop(val_df.index)
trn_df.shape | Digit Recognizer |
4,940,763 | features = [f'feature_{i}' for i in range(130)]
config = {
"epochs":100,
"train_batch_size":1024,
"valid_batch_size":1024,
"test_batch_size":64,
"nfolds":5,
"learning_rate":0.0005,
'encoder_input':len(features),
"input_size1":len(features),
"input_size2":128,
'output_size':5,
}
data_path = '.. /input/jsmp-pytorch-botte... | trn_x, trn_y = trn_df.loc[:, 'pixel0':'pixel783'], trn_df['label']
val_x, val_y = val_df.loc[:, 'pixel0':'pixel783'], val_df['label'] | Digit Recognizer |
4,940,763 | class GaussianNoise(nn.Module):
def __init__(self,device,sigma=0.1, is_relative_detach=True):
super().__init__()
self.sigma = sigma
self.is_relative_detach = is_relative_detach
self.noise = torch.tensor(0,dtype=torch.float ).to(device)
def forward(self, x):
if self.training and self.sigma != 0:
scale = self.sigma * x.... | def reshape(dt_x, dt_y):
dt_x = np.array(dt_x, dtype = np.uint8 ).reshape(-1,28,28)
dt_x = np.stack(( dt_x,)*3, axis=-1)
dt_y = np.array(dt_y)
return dt_x, dt_y | Digit Recognizer |
4,940,763 | class Model(nn.Module):
def __init__(self,input_size1,input_size2,output_size):
super(Model,self ).__init__()
self.layer1 = self.batch_linear_drop(input_size1,256,0.3,activation=nn.ELU)
self.layer2 = self.batch_linear(256,128,activation= nn.ELU)
self.layer3 = self.batch_linear_drop(input_size1+128,256,0.1,nn.ReLU)
s... | trn_x, trn_y = reshape(trn_x, trn_y)
val_x, val_y = reshape(val_x, val_y ) | Digit Recognizer |
4,940,763 | data_path = '.. /input/jsmp-pytorch-bottelneck-model-train'
models = list()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
for i in range(config['nfolds']):
model = Model(config['input_size1'],config['input_size2'],config['output_size'])
model.load_state_dict(torch.load(f"{data_path}/model{i}... | train=Path('.. /working/data/train')
save(train, trn_x, trn_y)
valid = Path('.. /working/data/valid')
save(valid, val_x, val_y ) | Digit Recognizer |
4,940,763 | def inference(test):
all_prediction = np.zeros(( test.shape[0],5))
inputs = torch.tensor(test,dtype=torch.float)
for model in models:
inputs = inputs.to(device,dtype=torch.float)
encoder_inp = encoder.get_encoder(inputs)
outputs = model(inputs,encoder_inp)
all_prediction += outputs.sigmoid().detach().cpu().numpy()
... | path = Path('.. /working/data/')
data =(ImageList.from_folder(path)
.split_by_folder(train='train', valid='valid')
.label_from_folder()
.transform(get_transforms(do_flip=False), size=28)
.databunch(bs=256 ).normalize(imagenet_stats)) | Digit Recognizer |
4,940,763 | test_data = pd.read_csv(folder_path + 'example_test.csv')
test_data.fillna(0,inplace=True)
test_data = test_data[features].to_numpy()
predictions = inference(test_data)
predictions = predictions.mean(axis=1)
sns.distplot(predictions);<split> | learn = cnn_learner(data, models.resnet34, loss_func=nn.CrossEntropyLoss() , metrics=accuracy ) | Digit Recognizer |
4,940,763 | env = janestreet.make_env()
iter_test = env.iter_test()<predict_on_test> | learn.fit_one_cycle(3, 1e-2 ) | Digit Recognizer |
4,940,763 | %%time
all_predictions = list()
for(test_df, sample_prediction_df)in iter_test:
if test_df['weight'].item() != 0:
test_df.fillna(0,inplace=True)
predictions = inference(test_df[features].to_numpy())
prediction = np.mean(predictions)
all_predictions.append(prediction)
sample_prediction_df.action = np.where(predictio... | learn.save('stage1' ) | Digit Recognizer |
4,940,763 | submission = pd.read_csv('./submission.csv')
submission.head()<install_modules> | learn.unfreeze()
learn.lr_find()
learn.recorder.plot() | Digit Recognizer |
4,940,763 | !pip install -q git+https://github.com/mljar/mljar-supervised.git@dev<import_modules> | learn.fit_one_cycle(15, slice(5e-5)) | Digit Recognizer |
4,940,763 | import pandas as pd
from supervised.automl import AutoML<load_from_csv> | learn.save('stage2' ) | Digit Recognizer |
4,940,763 | train = pd.read_csv(".. /input/bnp-paribas-cardif-claims-management/train.csv.zip")
test = pd.read_csv(".. /input/bnp-paribas-cardif-claims-management/test.csv.zip")
sub = pd.read_csv(".. /input/bnp-paribas-cardif-claims-management/sample_submission.csv.zip")
x_cols = [f for f in train.columns if "v" in f]<train_mod... | learn.unfreeze()
learn.lr_find()
learn.recorder.plot() | Digit Recognizer |
4,940,763 | automl = AutoML(
total_time_limit=8*3600,
optuna_time_budget=1800,
mode="Optuna",
)
automl.fit(train[x_cols], train["target"] )<save_to_csv> | learn.fit_one_cycle(5, 5e-5 ) | Digit Recognizer |
4,940,763 | pred = automl.predict_proba(test)
sub["PredictedProb"] = pred[:, 1]
sub.to_csv("./1_submission.csv", index=False )<import_modules> | def create_tst(path:Path, test):
path.mkdir(parents=True, exist_ok=True)
for i in range(len(test)) :
matplotlib.image.imsave(str(path/(str(i)+ '.jpeg')) , test[i] ) | Digit Recognizer |
4,940,763 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import MinMaxScaler<load_from_csv> | test_df = pd.read_csv(base/'test.csv')
test_df = np.array(test_df, dtype=np.uint8 ).reshape(-1,28,28)
test_df = np.stack(( test_df,)*3, axis=-1)
test_df.shape | Digit Recognizer |
4,940,763 | data = pd.read_csv('.. /input/ghouls-goblins-and-ghosts-boo/train.csv.zip')
data<load_from_csv> | tst_path = Path('.. /working/test')
create_tst(tst_path, test_df ) | Digit Recognizer |
4,940,763 | validate_data = pd.read_csv('.. /input/ghouls-goblins-and-ghosts-boo/test.csv.zip')
validate_data<define_variables> | preds = []
ImageId = []
for i in range(len(test_df)) :
img = open_image(tst_path/str(str(i)+'.jpeg'))
pred_cls, pred_idx, pred_img = learn.predict(img)
preds.append(int(pred_idx))
ImageId.append(i+1 ) | Digit Recognizer |
4,940,763 | validate_data_ids = validate_data['id']<count_missing_values> | submission = pd.DataFrame({'ImageId':ImageId, 'Label':preds} ) | Digit Recognizer |
4,940,763 | data.isnull().any()<data_type_conversions> | submission.to_csv('submission.csv',index=False ) | Digit Recognizer |
4,940,763 | <compute_test_metric><EOS> | shutil.rmtree(tst_path)
path_val = Path('.. /working/data/valid')
shutil.rmtree(path_val)
path_trn = Path('.. /working/data/train')
shutil.rmtree(path_trn ) | Digit Recognizer |
800,022 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<compute_test_metric> | print(os.listdir(".. /input"))
| Digit Recognizer |
800,022 | data, validate_data<prepare_x_and_y> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
800,022 | train_set_x, train_set_y = data.drop('type', 1), data['type']<choose_model_class> | Y_train = train["label"]
X_train = train.drop(labels="label",axis=1)
Y_train.value_counts() | Digit Recognizer |
800,022 | classifier = GridSearchCV(
KNeighborsClassifier() ,
param_grid={
'n_neighbors': np.arange(1, 100),
'p': np.arange(1, 10)
},
scoring='accuracy',
cv=3
)<train_model> | X_train = X_train/255.0
test = test/255.0 | Digit Recognizer |
800,022 | classifier.fit(train_set_x, train_set_y )<find_best_params> | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
800,022 | scores = classifier.cv_results_['mean_test_score']
scores, scores.mean() , scores.max()<find_best_params> | Y_train = to_categorical(Y_train,num_classes=10 ) | Digit Recognizer |
800,022 | classifier.best_params_<predict_on_test> | X_train, X_test, Y_train, Y_test = train_test_split(X_train, Y_train, test_size = 0.05 ) | Digit Recognizer |
800,022 | np.mean(classifier.predict(train_set_x)== train_set_y )<predict_on_test> | def conv_layer(x,concat_axis,nb_filter,dropout_rate=None,weight_decay=1E-4):
x = BatchNormalization(axis=concat_axis,
gamma_regularizer=l2(weight_decay),
beta_regularizer=l2(weight_decay))(x)
x = Activation('relu' )(x)
x = Conv2D(nb_filter,(3,3),padding='same',kernel_regularizer=l2(weight_decay),use_bias=False )(x)
... | Digit Recognizer |
800,022 | submission = classifier.predict(validate_data )<save_to_csv> | model = Densenet(nb_classes=10,
img_dim=(28,28,1),
depth = 34,
nb_dense_block = 5,
growth_rate=12,
nb_filter=32,
dropout_rate=0.2,
weight_decay=1E-4)
model.summary()
| Digit Recognizer |
800,022 | pd.DataFrame({'id': validate_data_ids, 'type': submission} ).to_csv('submission.csv', index=False )<load_pretrained> | model_filepath = 'model.h5'
batch_size=64
annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x)
lr_reduce = ReduceLROnPlateau(monitor='val_acc', factor=0.1, epsilon=1e-5, patience=2, verbose=1)
msave = ModelCheckpoint(model_filepath, save_best_only=True ) | Digit Recognizer |
800,022 | warnings.filterwarnings('ignore');
zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/train.csv.zip' ).extractall()
zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/test.csv.zip' ).extractall()
%matplotlib inline
<train_model> | model.compile(loss='categorical_crossentropy',
optimizer = Adamax() ,
metrics=['accuracy'])
model.fit(X_train ,Y_train,
batch_size = 64,
validation_data =(X_test,Y_test),
epochs = 20,
callbacks=[lr_reduce,msave,annealer],
verbose = 1 ) | Digit Recognizer |
800,022 | def N_net(train, test, target):
hidden_layer_sizes=(100,)
activation = 'relu'
solver = 'adam'
batch_size = 'auto'
alpha = 0.0001
random_state = 0
max_iter = 10000
early_stopping = True
clf = MLPClassifier(
hidden_layer_sizes=hidden_layer_sizes,
activation=activation,
solver=solver,
batch_size=batch_size,
alpha=alpha,... | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
800,022 | <split><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 |
1,636,227 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_on_grid> | import numpy as np
import pandas as pd
import seaborn as sns
from seaborn import countplot
import matplotlib.pyplot as plt
from keras import optimizers
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, Activation, BatchNormalization
from keras.models import Sequential
from keras.preprocessing.image i... | Digit Recognizer |
1,636,227 | def SVM(train, test, target):
clf_result=svm.SVC(kernel='rbf', gamma=1/2 , C=1.0,class_weight='balanced', random_state=0)
clf_result.fit(train, target)
predict= np.array(clf_result.predict(test))
return predict<categorify> | TRAIN_PATH = '.. /input/train.csv'
TEST_PATH = '.. /input/test.csv'
SUBMISSION_NAME = 'submission.csv'
BATCH_SIZE = 64
EPOCHS = 45
LEARNING_RATE = 0.001
HEIGHT = 28
WIDTH = 28
CANAL = 1
N_CLASSES = 10 | Digit Recognizer |
1,636,227 | def LogRes(ghost,ghoul,goblin, test, target,HowDo):
vsnp= np.empty(( 529,6),dtype="float64")
submission=np.empty(( 529),dtype="int")
ghost0=np.zeros(len(ghost)) ;ghost1=np.ones(len(ghost))
ghoul0=np.zeros(len(ghoul)) ;ghoul1=np.ones(len(ghoul))
goblin0=np.zeros(len(goblin)) ;goblin1=np.ones(len(goblin))
vs1 = ghost.a... | train = pd.read_csv(TRAIN_PATH)
test = pd.read_csv(TEST_PATH)
labels = train['label']
train = train.drop(['label'], axis=1 ) | Digit Recognizer |
1,636,227 | def LogRes2(ghost,ghoul,goblin, test, target,HowDo):
vsnp=np.empty(( 529,3),dtype="float64")
submission=np.empty(( 529),dtype="int")
ghost0=np.zeros(len(ghost)) ;ghost1=np.ones(len(ghost))
ghoul0=np.zeros(len(ghoul)) ;ghoul1=np.ones(len(ghoul))
goblin0=np.zeros(len(goblin)) ;goblin1=np.ones(len(goblin))
vs1 = ghost.a... | labels.value_counts() | Digit Recognizer |
1,636,227 | def syuunou(vote, ID):
pred:str=[]
for n in range(len(ID)) :
if np.argmax(vote[:,n])==0:
pred.append('Ghost')
if np.argmax(vote[:,n])==2:
pred.append('Ghoul')
if np.argmax(vote[:,n])==1:
pred.append('Goblin')
s_c= pd.DataFrame({"id": ID, "type": pred})
return s_c<compute_test_metric> | train = train.values.reshape(-1,HEIGHT,WIDTH,CANAL)
test = test.values.reshape(-1,HEIGHT,WIDTH,CANAL)
labels = labels.values | Digit Recognizer |
1,636,227 | def tohyo(predict, vote):
vote[0] +=(predict==0);vote[1] +=(predict==1);vote[2] +=(predict==2 )<load_from_csv> | labels = pd.get_dummies(labels ).values | Digit Recognizer |
1,636,227 | def main_n() :
train = pd.read_csv('./train.csv')
test = pd.read_csv('./test.csv')
type_array = pd.get_dummies(train['type']); del train['type']
COLOR = pd.get_dummies(train['color']); del train['color'] ;del train['id']
COLOR2 = pd.get_dummies(test['color']); del test['color']; ID = test["id"]; del test['id']
vote =... | train = train / 255.0
test = test / 255.0 | Digit Recognizer |
1,636,227 | submission=main_n()
rows=submission
submission = rows
submission.to_csv("submission6.csv", index=False )<choose_model_class> | x_train, x_val, y_train, y_val = train_test_split(train, labels, test_size=0.1, random_state=1 ) | Digit Recognizer |
1,636,227 |
<categorify> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
horizontal_flip=False,
vertical_flip=False,
rotation_range=15,
zoom_range = 0.15,
width_shift_range=0.15,
height_shift_range=0.15)
datagen.fit(... | Digit Recognizer |
1,636,227 |
<load_from_csv> | model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(5,5),padding='Same', input_shape=(HEIGHT, WIDTH, CANAL)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2D(filters=32, kernel_size=(5,5),padding='Same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.ad... | Digit Recognizer |
1,636,227 | train_data=pd.read_csv('/kaggle/input/ghouls-goblins-and-ghosts-boo/train.csv.zip')
train_data.head()<count_values> | print('Dataset size: %s' % train.shape[0])
print('Epochs: %s' % EPOCHS)
print('Learning rate: %s' % LEARNING_RATE)
print('Batch size: %s' % BATCH_SIZE)
print('Input dimension:(%s, %s, %s)' %(HEIGHT, WIDTH, CANAL)) | Digit Recognizer |
1,636,227 | train_data['type'].value_counts()<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 ) | Digit Recognizer |
1,636,227 | test_data=pd.read_csv('/kaggle/input/ghouls-goblins-and-ghosts-boo/test.csv.zip')
test_data.head()<count_values> | predictions = model.predict_classes(test ) | Digit Recognizer |
1,636,227 | train_data['color'].value_counts()<count_values> | submission = pd.DataFrame({"ImageId": list(range(1, len(predictions)+ 1)) , "Label": predictions})
submission.to_csv(SUBMISSION_NAME, index=False)
submission.head(10 ) | Digit Recognizer |
2,158,474 | test_data['color'].value_counts()<categorify> | sns.set() | Digit Recognizer |
2,158,474 | train_data=pd.concat([train_data,pd.get_dummies(train_data['color'])],axis=1)
train_data.drop('color',axis=1,inplace=True)
train_data.head()<categorify> | train_data = pd.read_csv(".. /input/train.csv")
test_data = pd.read_csv(".. /input/test.csv")
sample_submission = pd.read_csv(".. /input/sample_submission.csv" ) | Digit Recognizer |
2,158,474 | test_data=pd.concat([test_data,pd.get_dummies(test_data['color'])],axis=1)
test_data.drop('color',axis=1,inplace=True)
test_data.head()<prepare_x_and_y> | X_train = train_data.drop("label", axis=1)
y_train = train_data[["label"]]
X_test = test_data.copy() | Digit Recognizer |
2,158,474 | X=train_data.drop(['id','type'],axis=1)
y=pd.get_dummies(train_data['type'] )<split> | X_train = X_train.astype("float32")/ 255
X_test = X_test.astype("float32")/ 255
X_train = X_train.values.reshape(( len(X_train), 28, 28, 1))
X_test = X_test.values.reshape(( len(X_test), 28, 28, 1))
y_train = pd.get_dummies(y_train, columns=["label"] ) | Digit Recognizer |
2,158,474 | X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.1,random_state=42)
print(X_train.shape,y_train.shape)
print(X_test.shape,y_test.shape )<import_modules> | model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), padding="valid", input_shape=X_train.shape[1:]))
model.add(Activation("relu"))
model.add(Conv2D(64, kernel_size=(3, 3), padding="valid"))
model.add(Activation("relu"))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Conv2D(64, kerne... | Digit Recognizer |
2,158,474 | from tensorflow import keras
from keras.layers import Dense,Dropout
from keras.models import Sequential<choose_model_class> | epochs = 50
batch_size = 256
model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, validation_split=0.2 ) | Digit Recognizer |
2,158,474 | model=Sequential()
model.add(Dense(100,input_shape=(X.shape[1],)))
model.add(Dense(100,activation='relu'))
model.add(Dense(100,activation='relu'))
model.add(Dense(3,activation='softmax'))
model.summary()<choose_model_class> | y_pred = np.argmax(model.predict(X_test), axis=1 ) | Digit Recognizer |
2,158,474 | model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'] )<train_model> | result = pd.Series(y_pred, name="Label" ).to_frame().reset_index().rename(columns={"index": "ImageId"})
result["ImageId"] += 1
result.head() | Digit Recognizer |
2,158,474 | <import_modules><EOS> | result.to_csv("out.csv", index=False ) | Digit Recognizer |
5,082,686 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | %matplotlib inline
| Digit Recognizer |
5,082,686 | pred=model.predict(test_data.drop('id',axis=1))
pred_final=[np.argmax(i)for i in pred]
submission = pd.DataFrame({'id':test_data['id'], 'type':pred_final})
submission.head()<categorify> | train_file = ".. /input/train.csv"
test_file = ".. /input/test.csv"
output_file = "submission.csv"
raw_data = np.loadtxt(train_file, skiprows=1, dtype='int', delimiter=',')
x_train, y_train = raw_data[:, 1:], raw_data[:, 0]
x_train = x_train.reshape(-1, 28, 28, 1 ).astype("float32")/255
y_train = keras.utils.to_catego... | Digit Recognizer |
5,082,686 | submission['type'].replace(to_replace=[0,1,2],value=['Ghost','Ghoul','Goblin'],inplace=True)
submission.head()<save_to_csv> | model = keras.models.Sequential([
keras.layers.Conv2D(32, kernel_size=3, activation='relu',
input_shape=(28, 28, 1)) ,
keras.layers.BatchNormalization() ,
keras.layers.Conv2D(32, kernel_size=3, activation='relu'),
keras.layers.BatchNormalization() ,
keras.layers.Conv2D(32, kernel_size=5, strides=2, padding='same',
acti... | Digit Recognizer |
5,082,686 | submission.to_csv('.. /working/submission.csv', index=False )<load_pretrained> | def elastic_transform(image, alpha_range, sigma, random_state=None):
random_state = np.random.RandomState(random_state)
if np.isscalar(alpha_range):
alpha = alpha_range
else:
alpha = np.random.uniform(low=alpha_range[0], high=alpha_range[1])
shape = image.shape
dx = gaussian_filter(random_state.rand(*shape)* 2 - 1, s... | Digit Recognizer |
5,082,686 | zf1 = zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/train.csv.zip')
print(zf1.namelist())
zf2 = zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/test.csv.zip')
print(zf2.namelist())
zf3 = zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/sample_submission.csv.zip')
print(zf3.n... | datagen = keras.preprocessing.image.ImageDataGenerator(
zoom_range=0.0,
height_shift_range=2,
width_shift_range=2,
preprocessing_function=lambda x: elastic_transform(x, alpha_range=[8, 10], sigma=3))
datagen.fit(x_train ) | Digit Recognizer |
5,082,686 | zf1.extractall()
zf2.extractall()
zf3.extractall()<load_from_csv> | batch_size = 32
epochs = 30
learning_rate_reduction = keras.callbacks.ReduceLROnPlateau(monitor='val_acc', patience=3, verbose=1, factor=0.5, min_lr=0.00001)
model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
epochs=epochs, verbose=2,
callbacks=[learning_rate_reduction],
steps_per_epoch=x_train... | Digit Recognizer |
5,082,686 | train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv' )<load_from_csv> | raw_data_test = np.loadtxt(test_file, skiprows=1, dtype='int', delimiter=',')
x_test = raw_data_test.reshape(-1, 28, 28, 1 ).astype("float32")/255 | Digit Recognizer |
5,082,686 | <categorify><EOS> | results = model.predict_classes(x_test)
results = pd.Series(results, name='Label')
submission = pd.concat([pd.Series(range(1, x_test.shape[0] + 1), name='ImageId'), results], axis=1)
submission.to_csv(output_file, index=False ) | Digit Recognizer |
2,075,583 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | np.random.seed(13 ) | Digit Recognizer |
2,075,583 | from sklearn.neural_network import MLPClassifier
from sklearn import metrics
import joblib<prepare_x_and_y> | num_classes = 10
batch_size = 128
epochs = 700
img_rows, img_cols = 28, 28
input_shape =(img_rows, img_cols,1 ) | Digit Recognizer |
2,075,583 | hidden_layer_sizes=(100,)
activation = 'relu'
solver = 'adam'
batch_size = 'auto'
alpha = 0.0001
random_state = 0
max_iter = 10000
x = ['bone_length', 'rotting_flesh', 'hair_length', 'has_soul']
train_X = training[x]
y1 = ['type']
train_y1 = training[y1]
clf = MLPClassifier(
hidden_layer_sizes=hidden_layer_sizes,
act... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
2,075,583 | sub = pd.read_csv('sample_submission.csv')
sub['type'] = list(predict_Y1)
sub.to_csv('sample_submission.csv', index=False )<set_options> | y_train = train["label"]
x_train = train.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
2,075,583 | warnings.filterwarnings('ignore' )<load_pretrained> | x_train /= 255
test /= 255 | Digit Recognizer |
2,075,583 | zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/train.csv.zip' ).extractall()
zipfile.ZipFile('/kaggle/input/ghouls-goblins-and-ghosts-boo/test.csv.zip' ).extractall()
<load_from_csv> | x_train = x_train.values.reshape(-1,img_rows,img_cols,1 ).astype('float32')
test = test.values.reshape(-1,img_rows,img_cols,1 ).astype('float32' ) | Digit Recognizer |
2,075,583 | train = pd.read_csv('./train.csv')
test = pd.read_csv('./test.csv')
<categorify> | y_train = keras.utils.to_categorical(y_train, num_classes = num_classes ) | Digit Recognizer |
2,075,583 | train2 = pd.get_dummies(train['type'])
del train['type']
COLOR = pd.get_dummies(train['color'])
del train['color']
del train['id']
target = pd.DataFrame(train2['Ghost']* 0 + train2['Ghoul'] * 2 + train2['Goblin'] * 1)
target_GOB = pd.DataFrame(train2['Ghost']* 0 + train2['Ghoul'] * 0 + train2['Goblin'] * 1)
target ... | x_train, x_test, y_train, y_test = train_test_split(x_train, y_train, test_size = 0.1 ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.