kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,330,495 | from keras.applications.nasnet import NASNetLarge
from keras.applications.inception_resnet_v2 import InceptionResNetV2<choose_model_class> | image_gen_val = ImageDataGenerator(rescale=1./255)
val_data_gen = image_gen_val.flow(X_val, y_val, batch_size=BATCH_SIZE ) | Digit Recognizer |
13,330,495 | base_model = InceptionResNetV2(include_top=False,
weights='imagenet',
input_shape=(331,331,3)
)
base_model.trainable = False<choose_model_class> | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32,(3,3), activation='relu', input_shape=(28, 28, 1)) ,
tf.keras.layers.BatchNormalization(axis=1),
tf.keras.layers.Conv2D(32,(3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64,(3,3), activation='relu'),
tf.keras.layers.Ba... | Digit Recognizer |
13,330,495 | model = Sequential([
base_model,
GlobalAveragePooling2D() ,
Dense(256,activation = 'relu'),
Dropout(0.5),
Dense(120,activation='softmax')
])
model.summary()<choose_model_class> | model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy() ,
metrics=['accuracy'] ) | Digit Recognizer |
13,330,495 | model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'] )<choose_model_class> | epochs=20
history = model.fit_generator(
train_data_gen,
steps_per_epoch=int(np.ceil(total_train / float(BATCH_SIZE))),
epochs=epochs,
validation_data=val_data_gen,
validation_steps=int(np.ceil(total_val / float(BATCH_SIZE)))
) | Digit Recognizer |
13,330,495 | my_calls = [keras.callbacks.EarlyStopping(monitor='val_accuracy',patience=2),
keras.callbacks.ModelCheckpoint("Model.h5",verbose=1,save_best_only=True)]<train_model> | epochs=17
history = model.fit_generator(
full_data_gen,
steps_per_epoch=int(np.ceil(total_full / float(BATCH_SIZE))),
epochs=epochs
) | Digit Recognizer |
13,330,495 | <load_pretrained><EOS> | predictions = model.predict_classes(X_test, verbose=0)
submissions=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("DigitsClassif.csv", index=False, header=True ) | Digit Recognizer |
13,255,052 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, StratifiedKFold
import os
import math | Digit Recognizer |
13,255,052 | testgen = Imgen(preprocessing_function=keras.applications.inception_resnet_v2.preprocess_input )<prepare_x_and_y> | class LN5(nn.Module):
def __init__(self):
super(LN5, self ).__init__()
self.lc = nn.Sequential(
nn.Conv2d(1, 6, 5, padding=2),
nn.BatchNorm2d(6),
nn.ReLU(inplace=True),
nn.AvgPool2d(2, 2),
nn.Conv2d(6, 16, 5),
nn.BatchNorm2d(16),
nn.ReLU(inplace=True),
nn.AvgPool2d(2, 2),
)
self.ll = nn.Sequential(
nn.Dropout(0.3),... | Digit Recognizer |
13,255,052 | test_ds = testgen.flow_from_dataframe(
sample_sub,
directory = '.. /input/dog-breed-identification/test',
x_col = 'id',
y_col = None,
target_size =(331,331),
class_mode= None,
batch_size=32,
shuffle=False
)<predict_on_test> | def train_model(tt_loader, conv_model, optimizer, scheduler, criterion):
conv_model.train()
for batch_idx,(data, target)in enumerate(tt_loader):
data = data.unsqueeze(1)
data, target = data, target
optimizer.zero_grad()
output = conv_model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
sched... | Digit Recognizer |
13,255,052 | predictions = model.predict(test_ds,verbose=1 )<prepare_output> | def kfold(num_model, num_epochs, conv, train_images, train_labels):
kf = StratifiedKFold(n_splits=num_model, shuffle=True, random_state=123)
criterion = nn.CrossEntropyLoss()
for k,(tr_idx, val_idx)in enumerate(kf.split(train_images, train_labels)) :
print('start model {}'.format(k))
conv_model = LN5()
optimizer = opt... | Digit Recognizer |
13,255,052 | pred = [np.argmax(i)for i in predictions]<define_variables> | def load_pkl(num_model, num_epochs, conv):
for k in range(num_model):
conv_model = LN5()
conv_model.load_state_dict(torch.load('.. /input/conv-10-100/conv_{}_{}_{}.pkl'.format(num_model,num_epochs,k)))
conv.append(conv_model)
def total_loss(num_model, conv, train_images, train_labels):
train_images = train_images.res... | Digit Recognizer |
13,255,052 | file_list = test_ds.filenames
id_list = []
for name in file_list:
m = re.sub('test/', '', name)
m = re.sub('.jpg', '', m)
id_list.append(m )<load_from_csv> | train_df = pd.read_csv(".. /input/digit-recognizer/train.csv")
train_labels = train_df['label'].values
train_images =(train_df.iloc[:,1:].values ).astype('float32')
num_model = 10
num_epochs = 100
conv = [] | Digit Recognizer |
13,255,052 | submission = pd.read_csv('.. /input/dog-breed-identification/sample_submission.csv' )<prepare_output> | load_pkl(num_model, num_epochs, conv)
loss = total_loss(num_model, conv, train_images, train_labels)
predictions(num_model, conv, loss ) | Digit Recognizer |
7,484,184 | submission['id'] = id_list
submission.iloc[:,1:] =predictions
submission.head()<save_to_csv> | train_df = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_df = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
X_train = train_df.iloc[:, 1:].values.astype('float32')
y_train = train_df.iloc[:, 0].values.astype('int16')
X_test = test_df.values.astype('float32' ) | Digit Recognizer |
7,484,184 | final_df = submission.set_index('id')
final_df.to_csv('Submission.csv' )<set_options> | X_train = X_train / 255
X_test = X_test / 255
y_train = to_categorical(y_train)
y_train.shape | Digit Recognizer |
7,484,184 | %%time
%matplotlib inline<define_variables> | seed = 10
np.random.seed(seed ) | Digit Recognizer |
7,484,184 | %%time
train_dir = '.. /input/dog-breed-identification/train'
test_dir ='.. /input/dog-breed-identification/test'<load_from_csv> | import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Convolution2D, MaxPooling2D, BatchNormalization, Dense, Flatten, Dropout | Digit Recognizer |
7,484,184 | %%time
def append_ext(fn):
return fn+".jpg"
traindf = pd.read_csv('.. /input/dog-breed-identification/labels.csv',dtype=str)
testdf = pd.read_csv('.. /input/dog-breed-identification/sample_submission.csv',dtype=str)
traindf["id"] = traindf["id"].apply(append_ext)
testdf["id"] = testdf["id"].apply(append_ext)
<define... | train_x, val_x, train_y, val_y = train_test_split(X_train, y_train, test_size = 0.10, random_state = 42, stratify = y_train ) | Digit Recognizer |
7,484,184 | %%time
train_datagen=ImageDataGenerator(rescale=1./255.,
horizontal_flip = True,
validation_split=0.02
)<define_variables> | model = Sequential()
model.add(Convolution2D(32,(5, 5), activation = 'relu', padding = 'same', input_shape =(28, 28, 1)))
model.add(MaxPooling2D(pool_size =(2, 2)))
model.add(Convolution2D(64,(3, 3), activation = 'relu', padding = 'same'))
model.add(MaxPooling2D(pool_size =(2, 2)))
model.add(Dropout(0.3))
model.add(... | Digit Recognizer |
7,484,184 | BATCH_SIZE = 32<define_search_space> | history = model.fit(train_x, train_y, epochs = 15, batch_size = 64, validation_data =(val_x, val_y)) | Digit Recognizer |
7,484,184 | <prepare_x_and_y><EOS> | predictions = model.predict_classes(X_test, verbose = 0)
submissions = pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("digit.csv", index = False, header = True ) | Digit Recognizer |
13,182,620 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<prepare_x_and_y> | submit = True
| Digit Recognizer |
13,182,620 | x,y = next(train_generator )<create_dataframe> | ( x_train, y_train),(x_test, y_test)= tf.keras.datasets.mnist.load_data()
x_train_norm = x_train/255.
x_test_norm = x_test/255 . | Digit Recognizer |
13,182,620 | valid_generator=train_datagen.flow_from_dataframe(
dataframe=traindf,
directory=train_dir,
x_col="id",
y_col="breed",
subset="validation",
batch_size=BATCH_SIZE,
seed=42,
shuffle=True,
class_mode="categorical",
target_size=image_size,
color_mode="rgb")
<prepare_x_and_y> | kaggle = pd.read_csv('.. /input/digit-recognizer/test.csv')
kaggle_norm = np.asarray(kaggle/255.)
k_train = pd.read_csv('.. /input/digit-recognizer/train.csv')
k_labels = np.asarray(k_train['label'])
k_train = k_train.drop(columns=['label'])
k_train_norm = np.asarray(k_train/255.) | Digit Recognizer |
13,182,620 | test_datagen=ImageDataGenerator(rescale=1./255.)
test_generator=test_datagen.flow_from_dataframe(
dataframe=testdf,
directory=test_dir,
x_col="id",
y_col=None,
batch_size=BATCH_SIZE,
seed=42,
shuffle=False,
class_mode=None,
target_size=image_size,
color_mode="rgb" )<choose_model_class> | k_train_norm = k_train_norm.reshape(42000, 28, 28, 1)
kaggle_norm = kaggle_norm.reshape(28000, 28, 28, 1)
x_train_norm = x_train_norm.reshape(60000, 28, 28, 1)
x_test_norm = x_test_norm.reshape(10000, 28, 28, 1 ) | Digit Recognizer |
13,182,620 | pretrained_model = tf.keras.applications.InceptionV3(
weights='imagenet',
include_top=False ,
input_shape=shape
)
pretrained_model.trainable = False
model = tf.keras.Sequential([
pretrained_model,
tf.keras.layers.GlobalAveragePooling2D() ,
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dropout(0.5),
... | def train_model(model, train_features, train_label, epochs,
batch_size=None, validation_split=None):
history = model.fit(x=train_features, y=train_label,
batch_size=batch_size,
epochs=epochs, shuffle=True,
validation_split=validation_split,
verbose = 1)
epochs = history.epoch
hist = pd.DataFrame(history.history)
retu... | Digit Recognizer |
13,182,620 | opt = tf.keras.optimizers.Adam(learning_rate=0.001)
opt=tf.keras.optimizers.SGD(lr=1e-3, momentum=0.9)
model.compile(optimizer = opt ,
loss="categorical_crossentropy",
metrics=["accuracy"])
model.summary()<choose_model_class> | def create_X(learning_rate):
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(32, 4, activation='relu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.MaxPooling2D(( 2,2)))
model.add(tf.keras.layers.Conv2D(64, 2, activation='relu'))
model.add(tf.keras.layers.MaxPooling2D(( 2,2)))
model.ad... | Digit Recognizer |
13,182,620 | reduce = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss',factor=0.2,patience=5, min_lr=0.001)
early = tf.keras.callbacks.EarlyStopping(patience=2,
min_delta=0.001,
restore_best_weights=True )<train_model> | def getKaggles() :
kaggles = pd.DataFrame(columns=['ImageId','Label'])
predicts = convoluterX.predict(kaggle_norm)
for j in range(len(kaggle_norm)) :
probs = predicts[j]
max_id = np.argmax(probs)
kaggles.at[j,'ImageId'] = j+1
kaggles.at[j,'Label'] = max_id
return kaggles
kaggles = getKaggles()
kaggles.to_csv('submis... | Digit Recognizer |
13,020,289 | STEP_SIZE_TRAIN = train_generator.n//train_generator.batch_size
STEP_SIZE_VALID = valid_generator.n//valid_generator.batch_size
STEP_SIZE_TEST = test_generator.n//test_generator.batch_size
history = model.fit(train_generator,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=valid_generator,
validation_steps=STEP_SIZE_V... | import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Input
import matplotlib.pyplot as plt | Digit Recognizer |
13,020,289 | score = model.evaluate(valid_generator,batch_size=32)
print("Accuracy: {:.2f}%".format(score[1] * 100))
print("Loss: ",score[0])
<import_modules> | data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
data_sub = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
X = data.iloc[:, 1:]
y = data.iloc[:, 0] | Digit Recognizer |
13,020,289 | from sklearn.metrics import f1_score<predict_on_test> | X_train, X_test = X[:40000]/255.0, X[40000:]/255.0
y_train, y_test = y[:40000], y[40000:]
X_valid, y_valid = X_train[:10000], y_train[:10000] | Digit Recognizer |
13,020,289 | Y_pred = model.predict(valid_generator)
y_pred = np.argmax(Y_pred, axis=1 )<compute_test_metric> | model = tf.keras.models.Sequential([
Input(shape=X_train.shape[1:]),
Dense(256, activation='sigmoid'),
Dense(128, activation='sigmoid'),
Dense(10, activation='softmax'),
])
model.compile(optimizer='sgd',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(X_train, y_train, epochs=20,
val... | Digit Recognizer |
13,020,289 | f_score = f1_score(valid_generator.classes,y_pred,average='macro')
print('F1 score:',f_score)
<predict_on_test> | model.evaluate(X_test, y_test ) | Digit Recognizer |
13,020,289 | pred=model.predict(test_generator )<load_from_csv> | model = tf.keras.Sequential([
Input(shape=X_train.shape[1:]),
Dense(256, activation='relu'),
Dense(128, activation='relu'),
Dense(10, activation='softmax'),
])
model.compile(optimizer='RMSProp',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(X_train, y_train, epochs=20,
validation_d... | Digit Recognizer |
13,020,289 | df_submission = pd.read_csv('/kaggle/input/dog-breed-identification/sample_submission.csv')
df_submission.head()<define_variables> | print('Accuracy {}'.format(np.round(model.evaluate(X_test, y_test)[1], 4)) ) | Digit Recognizer |
13,020,289 | file_list = test_generator.filenames
id_list = []
for name in file_list:
m = re.sub('test/', '', name)
m = re.sub('.jpg', '', m)
id_list.append(m )<prepare_output> | model = tf.keras.Sequential([
Input(shape=X_train.shape[1:]),
Dense(256, activation='relu'),
BatchNormalization() ,
Dropout(0.1),
Dense(128, activation='relu'),
BatchNormalization() ,
Dropout(0.45),
Dense(10, activation='softmax'),
])
model.compile(optimizer='RMSProp',
loss='sparse_categorical_crossentropy',
metrics=[... | Digit Recognizer |
13,020,289 | df_submission['id'] = id_list
df_submission.iloc[:,1:] = pred
df_submission.head()<define_variables> | print('Accuracy {}'.format(np.round(model.evaluate(X_test, y_test)[1], 4)) ) | Digit Recognizer |
13,020,289 | breeds=['id','beagle','chihuahua','doberman','french_bulldog', 'golden_retriever', 'malamute','pug','saint_bernard','scottish_deerhound','tibetan_mastiff']<filter> | X_train, X_valid, X_test = np.array(X_train ).reshape(-1, 28, 28, 1), np.array(X_valid ).reshape(-1, 28, 28, 1), np.array(X_test ).reshape(-1, 28, 28, 1 ) | Digit Recognizer |
13,020,289 | selected_breeds = df_submission.loc[:,breeds]<save_to_csv> | model = tf.keras.models.Sequential([
Input(shape=X_train.shape[1:]),
Conv2D(32, 7, activation='relu', padding='same'),
Conv2D(32, 5, activation='relu', padding='same'),
MaxPooling2D(pool_size=(2,2)) ,
BatchNormalization() ,
Dropout(0.3),
Conv2D(64, 5, activation='relu', padding='same'),
Conv2D(64, 5, activation='relu',... | Digit Recognizer |
13,020,289 | final_sub = df_submission.set_index('id')
final_sub.to_csv('Submission.csv' )<set_options> | print('Accuracy {}'.format(np.round(model.evaluate(X_test, y_test)[1], 4)) ) | Digit Recognizer |
13,020,289 | %%time
%matplotlib inline<define_variables> | train_datagen = ImageDataGenerator(
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
validation_split = 0.25
)
valid_datagen = ImageDataGenerator(
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
validation_split = 0.25
)
train_datagen.fit(X_tr... | Digit Recognizer |
13,020,289 | %%time
train_dir = '.. /input/dog-breed-identification/train'
test_dir ='.. /input/dog-breed-identification/test'<load_from_csv> | history = model.fit_generator(generator=train_generator,
validation_data=valid_generator,
epochs = 20 ) | Digit Recognizer |
13,020,289 | %%time
def append_ext(fn):
return fn+".jpg"
traindf = pd.read_csv('.. /input/dog-breed-identification/labels.csv',dtype=str)
testdf = pd.read_csv('.. /input/dog-breed-identification/sample_submission.csv',dtype=str)
traindf["id"] = traindf["id"].apply(append_ext)
testdf["id"] = testdf["id"].apply(append_ext)
<define... | print('Accuracy {}'.format(np.round(model.evaluate(X_test, y_test)[1], 4)) ) | Digit Recognizer |
13,020,289 | %%time
train_datagen=ImageDataGenerator(rescale=1./255.,
zoom_range = [0.7,1],
horizontal_flip = True,
validation_split=0.05
)<define_variables> | history = model.fit_generator(generator=train_generator,
validation_data=valid_generator,
epochs = 200,
callbacks=[checkpoint, early_stopping] ) | Digit Recognizer |
13,020,289 | BATCH_SIZE = 32<prepare_x_and_y> | model = tf.keras.models.load_model('model.h5')
model.evaluate(X_test, y_test ) | Digit Recognizer |
13,020,289 | train_generator=train_datagen.flow_from_dataframe(
dataframe=traindf,
directory=train_dir,
x_col="id",
y_col="breed",
subset="training",
batch_size=BATCH_SIZE,
seed=42,
shuffle=True,
class_mode="categorical",
target_size=(224,224),
color_mode="rgb"
)<prepare_x_and_y> | data_sub = np.array(data_sub ).reshape(-1, 28, 28 , 1 ).astype('float32')/ 255 | Digit Recognizer |
13,020,289 | x,y = next(train_generator )<create_dataframe> | preds = model.predict(data_sub ) | Digit Recognizer |
13,020,289 | valid_generator=train_datagen.flow_from_dataframe(
dataframe=traindf,
directory=train_dir,
x_col="id",
y_col="breed",
subset="validation",
batch_size=BATCH_SIZE,
seed=42,
shuffle=True,
class_mode="categorical",
target_size=(224,224),
color_mode="rgb")
<prepare_x_and_y> | np.argmax(preds[0] ) | Digit Recognizer |
13,020,289 | test_datagen=ImageDataGenerator(rescale=1./255.)
test_generator=test_datagen.flow_from_dataframe(
dataframe=testdf,
directory=test_dir,
x_col="id",
y_col=None,
batch_size=BATCH_SIZE,
seed=42,
shuffle=False,
class_mode=None,
target_size=(224,224),
color_mode="rgb" )<choose_model_class> | labels = [np.argmax(x)for x in preds]
ids = [x+1 for x in range(len(preds)) ]
sub = pd.DataFrame() | Digit Recognizer |
13,020,289 | pretrained_model = tf.keras.applications.ResNet50V2(
weights='imagenet',
include_top=False ,
input_shape=[224,224,3]
)
pretrained_model.trainable = False
model = tf.keras.Sequential([
pretrained_model,
tf.keras.layers.GlobalAveragePooling2D() ,
tf.keras.layers.Dense(120, activation='softmax')
] )<choose_model_class... | sub['ImageId'] = ids
sub['Label'] = labels
sub.to_csv('mnist_submission.csv', index=False)
pd.read_csv('mnist_submission.csv' ) | Digit Recognizer |
13,009,821 | opt=tf.keras.optimizers.SGD(lr=1e-4, momentum=0.9)
model.compile(optimizer = opt ,
loss="categorical_crossentropy",
metrics=["accuracy"])
model.summary()<choose_model_class> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
13,009,821 | early = tf.keras.callbacks.EarlyStopping(patience=2,
min_delta=0.001,
restore_best_weights=True )<train_model> | X = train.drop("label",axis=1 ).values.reshape(-1,28,28,1)
y = train["label"].values
X_test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
13,009,821 | STEP_SIZE_TRAIN = train_generator.n//train_generator.batch_size
STEP_SIZE_VALID = valid_generator.n//valid_generator.batch_size
STEP_SIZE_TEST = test_generator.n//test_generator.batch_size
history = model.fit(train_generator,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=valid_generator,
validation_steps=STEP_SIZE_V... | X = X.astype('float32')
X_test = X_test.astype('float32')
X = X/255.0
X_test = X_test/255.0
y = tensorflow.keras.utils.to_categorical(y,10 ) | Digit Recognizer |
13,009,821 | score = model.evaluate(valid_generator,batch_size=32)
print("Accuracy: {:.2f}%".format(score[1] * 100))
print("Loss: ",score[0])
<import_modules> | X_train,X_val,y_train,y_val = train_test_split(X,y,test_size=0.2,random_state=1 ) | Digit Recognizer |
13,009,821 | from sklearn.metrics import f1_score, confusion_matrix<define_variables> | Digit Recognizer | |
13,009,821 | target_names = []
for key in train_generator.class_indices:
target_names.append(key )<predict_on_test> | nn = 10
model = [0]*nn
for j in range(nn):
model[j] = Sequential()
model[j].add(Conv2D(24,kernel_size=(3,3),padding='same',activation='relu',input_shape=(28,28,1)))
model[j].add(BatchNormalization())
model[j].add(Conv2D(24,kernel_size=(3,3),padding='same',activation='relu'))
model[j].add(BatchNormalization())
model[... | Digit Recognizer |
13,009,821 | Y_pred = model.predict(valid_generator)
y_pred = np.argmax(Y_pred, axis=1 )<compute_test_metric> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range=0.1,
width_shift_range=0.1,
height_shift_range=0.1
)
datagen.fit(X ) | Digit Recognizer |
13,009,821 | cm = confusion_matrix(valid_generator.classes,y_pred)
<compute_test_metric> | epochs = 50
history = [0]*nn
for j in range(nn):
X_train,X_val,y_train,y_val = train_test_split(X,y,test_size=0.1,random_state=7)
history[j] = model[j].fit_generator(datagen.flow(X_train,y_train,batch_size=64),
epochs=epochs,validation_data=(X_val,y_val),
verbose=1)
| Digit Recognizer |
13,009,821 | f_score = f1_score(valid_generator.classes,y_pred,average='macro')
print('F1 score:',f_score)
<predict_on_test> | results = np.zeros(( X_test.shape[0],10))
for j in range(nn):
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('ENSEMBLE.csv',index=False ) | Digit Recognizer |
13,009,821 | pred=model.predict(test_generator )<load_from_csv> | model.fit(datagen.flow(X_train,y_train,batch_size=128),epochs=10,validation_data=(X_val,y_val)) | Digit Recognizer |
13,009,821 | df_submission = pd.read_csv('/kaggle/input/dog-breed-identification/sample_submission.csv')
df_submission.head()<define_variables> | model.fit(datagen.flow(X,y,batch_size=128),epochs=20,verbose=1 ) | Digit Recognizer |
13,009,821 | file_list = test_generator.filenames
id_list = []
for name in file_list:
m = re.sub('test/', '', name)
m = re.sub('.jpg', '', m)
id_list.append(m )<prepare_output> | model_log = model.fit(X_train,y_train,batch_size=128,epochs=10,verbose=1,validation_data=(X_val,y_val)) | Digit Recognizer |
13,009,821 | df_submission['id'] = id_list
df_submission.iloc[:,1:] = pred
df_submission.head()<define_variables> | model_log = model.fit(X,y,batch_size=128,epochs=20,verbose=1 ) | Digit Recognizer |
13,009,821 | breeds=['id','beagle','chihuahua','doberman','french_bulldog', 'golden_retriever', 'malamute','pug','saint_bernard','scottish_deerhound','tibetan_mastiff']<filter> | X_train = X_train.reshape(X_train.shape[0],28,28,1)
X_test = X_test.reshape(X_test.shape[0],28,28,1)
X_train.astype('float32')
X_test.astype('float32')
X_train=X_train/255
X_val=X_val/255 | Digit Recognizer |
13,009,821 | selected_breeds = df_submission.loc[:,breeds]<save_to_csv> | import numpy as np
import pandas as pd | Digit Recognizer |
13,009,821 | final_sub = df_submission.set_index('id')
final_sub.to_csv('Submission.csv' )<import_modules> | results = model.predict(X_test ) | Digit Recognizer |
13,009,821 | from sklearn.preprocessing impbort LabelEncoder
<load_from_csv> | np.argmax(results,axis=1 ) | Digit Recognizer |
13,009,821 | comp_df = pd.read_csv('.. /input/dog-breed-identification/labels.csv')
test_df = pd.read_csv('.. /input/dog-breed-identification/sample_submission.csv')
print('Training set: {}, Test set: {}'.format(comp_df.shape[0],test_df.shape[0]))<count_values> | 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('submission8.csv',index=False ) | Digit Recognizer |
12,997,499 | comp_df.breed.value_counts()<categorify> | %matplotlib inline
np.random.seed(2 ) | Digit Recognizer |
12,997,499 | comp_df['label'] = LabelEncoder().fit_transform(comp_df.breed)
dict_df = comp_df[['label','breed']].copy()
dict_df.drop_duplicates(inplace=True)
dict_df.set_index('label',drop=True,inplace=True)
index_to_breed = dict_df.to_dict() ['breed']<feature_engineering> | from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import itertools | Digit Recognizer |
12,997,499 | train_dir = '.. /input/dog-breed-identification/train'
comp_df.id = comp_df.id.apply(lambda x: x+'.jpg')
comp_df.id = comp_df.id.apply(lambda x:train_dir+'/'+x)
comp_df.pop('breed' )<prepare_x_and_y> | from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ReduceLROnPlateau | Digit Recognizer |
12,997,499 | class img_dataset(Dataset):
def __init__(self,dataframe,transform=None,test=False):
self.dataframe = dataframe
self.transform = transform
self.test = test
def __getitem__(self,index):
x = Image.open(self.dataframe.iloc[index,0])
if self.transform:
x = self.transform(x)
if self.test:
return x
else:
y = self.dataframe.... | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,997,499 | train_transformer = transforms.Compose([transforms.RandomResizedCrop(224),
transforms.RandomRotation(15),
transforms.RandomHorizontalFlip() ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
val_transformer = transforms.Compose([transforms.Resize(256),
transforms.CenterCrop(... | X_train /= 255.0
test /= 255.0 | Digit Recognizer |
12,997,499 | def print_epoch_result(train_loss,train_acc,val_loss,val_acc):
print('loss: {:.3f}, acc: {:.3f}, val_loss: {:.3f}, val_acc: {:.3f}'.format(train_loss,
train_acc,
val_loss,
val_acc))
def train_model(model, cost_function, optimizer,num_epochs=5):
train_losses = []
val_losses = []
train_acc = []
val_acc = []
train_acc_obj... | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
12,997,499 | device = torch.device('cuda:0' if torch.cuda.is_available else 'cpu' )<split> | random_seed = 2
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 |
12,997,499 | training_samples = comp_df.shape[0]
test_size=0.05
batch_size = 64
sample_df = comp_df.sample(training_samples)
x_train,x_val,_,_ = train_test_split(sample_df,sample_df,test_size=test_size)
train_set = img_dataset(x_train, transform=train_transformer)
val_set = img_dataset(x_val, transform=val_transformer)
train_lo... | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Valid', activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same', activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.2))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
12,997,499 | class net(torch.nn.Module):
def __init__(self, base_model, base_out_features, num_classes):
super(net,self ).__init__()
self.base_model=base_model
self.linear1 = torch.nn.Linear(base_out_features, 512)
self.output = torch.nn.Linear(512,num_classes)
def forward(self,x):
x = F.relu(self.base_model(x))
x = F.relu(self.l... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc', patience=2, verbose=1, factor=0.5, min_lr=0.00001 ) | Digit Recognizer |
12,997,499 | cost_function = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam([param for param in model_final.parameters() if param.requires_grad], lr=0.0003)
EPOCHS = 30<train_model> | 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 ) | Digit Recognizer |
12,997,499 | train_losses, train_acc, val_losses, val_acc = train_model(model=model_final,
cost_function=cost_function,
optimizer=optimizer,
num_epochs=EPOCHS )<load_from_csv> | datagen.fit(X_train ) | Digit Recognizer |
12,997,499 | test_dir = '.. /input/dog-breed-identification/test'
test_df = test_df[['id']]
test_df.id = test_df.id.apply(lambda x: x+'.jpg')
test_df.id = test_df.id.apply(lambda x : test_dir+'/'+x)
test_set = img_dataset(test_df,transform=val_transformer, test=True)
test_loader = DataLoader(test_set, batch_size=batch_size, shuf... | 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 |
12,997,499 | model_final.eval()
predictions = torch.tensor([])
print('Start predicting.... ')
for x in test_loader:
x = x.to(device)
y_hat = model_final(x)
predictions = torch.cat([predictions, y_hat.cpu() ])
print('Finish prediction.' )<predict_on_test> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
12,997,499 | <save_to_csv><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("sub2.csv",index=False)
| Digit Recognizer |
12,983,127 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<install_modules> | %matplotlib inline
| Digit Recognizer |
12,983,127 | print("
...INSTALLING AND IMPORTING CELL-PROFILER TOOL(HPACELLSEG )...
")
try:
except:
!pip install -q "/kaggle/input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl"
!pip install -q "/kaggle/input/hpapytorchzoozip/pytorch_zoo-master"
!pip install -q "/kaggle/input/hpacellsegmentatormaster/HPA-Cell-Segmentat... | with open("/kaggle/input/digit-recognizer/train.csv")as f:
reader = csv.reader(f, delimiter=',')
next(reader)
dataset = [row for row in reader] | Digit Recognizer |
12,983,127 | NUC_MODEL = '/kaggle/input/hpacellsegmentatormodelweights/dpn_unet_nuclei_v1.pth'
CELL_MODEL = '/kaggle/input/hpacellsegmentatormodelweights/dpn_unet_cell_3ch_v1.pth'
B2_CELL_CLSFR_DIR = "/kaggle/input/hpa-cellwise-classification-training/ebnet_b2_wdensehead/ckpt-0007-0.0901.ckpt"
DATA_DIR = "/kaggle/input/hpa-single-c... | labels, images = np.array_split(np.array(dataset, dtype='float32'), [1,], axis=1)
labels, images = labels.flatten() , images.reshape(( len(images), 28, 28)) [..., np.newaxis] | Digit Recognizer |
12,983,127 | def binary_mask_to_ascii(mask, mask_val=1):
mask = np.where(mask==mask_val, 1, 0 ).astype(np.bool)
if mask.dtype != np.bool:
raise ValueError(f"encode_binary_mask expects a binary mask, received dtype == {mask.dtype}")
mask = np.squeeze(mask)
if len(mask.shape)!= 2:
raise ValueError(f"encode_binary_mask expects a ... | split_ratio = 0.1
data_set = tf.data.Dataset.from_tensor_slices(( images, labels)).shuffle(len(labels))
train_set = data_set.take(int(len(labels)*(1-split_ratio)) ).batch(32 ).cache().prefetch(1)
val_set = data_set.skip(len(labels)-int(len(labels)*(1-split_ratio)) ).batch(32 ).cache().prefetch(1 ) | Digit Recognizer |
12,983,127 | inference_model = tf.keras.models.load_model(B2_CELL_CLSFR_DIR)
IMAGE_SIZES = [1728, 2048, 3072, 4096]
BATCH_SIZE = 8
CONF_THRESH = 0.0
TILE_SIZE =(224,224)
if ONLY_PUBLIC:
predict_df_1728 = pub_ss_df[pub_ss_df.ImageWidth==IMAGE_SIZES[0]]
predict_df_2048 = pub_ss_df[pub_ss_df.ImageWidth==IMAGE_SIZES[1]]
predict_df_30... | data_augmentation = keras.models.Sequential([
keras.layers.experimental.preprocessing.Rescaling(1./255, input_shape=(28, 28, 1)) ,
keras.layers.experimental.preprocessing.RandomRotation(0.1),
keras.layers.experimental.preprocessing.RandomZoom(0.1),
keras.layers.experimental.preprocessing.RandomTranslation(0.1, 0.1)
] ... | Digit Recognizer |
12,983,127 | predictions = []
sub_df = pd.DataFrame(columns=["ID"], data=predict_ids_1728+predict_ids_2048+predict_ids_3072+predict_ids_4096)
for size_idx, submission_ids in enumerate([predict_ids_1728, predict_ids_2048, predict_ids_3072, predict_ids_4096]):
size = IMAGE_SIZES[size_idx]
if submission_ids==[]:
print(f"
...SKIPPING... | DefaultConv2D = partial(keras.layers.Conv2D, kernel_size=3, activation='relu', padding='same')
model = keras.models.Sequential([
data_augmentation,
DefaultConv2D(filters=32),
DefaultConv2D(filters=32),
keras.layers.MaxPool2D() ,
DefaultConv2D(filters=64),
DefaultConv2D(filters=64),
keras.layers.MaxPool2D() ,
DefaultCo... | Digit Recognizer |
12,983,127 | ss_df = ss_df.merge(sub_df, how="left", on="ID")
ss_df["PredictionString"] = ss_df.apply(create_pred_col, axis=1)
ss_df = ss_df.drop(columns=["PredictionString_x", "PredictionString_y"])
ss_df.to_csv("/kaggle/working/submission.csv", index=False)
display(ss_df )<install_modules> | DefaultConv2D = partial(keras.layers.Conv2D, kernel_size=3, activation='relu', padding='same')
model = keras.models.Sequential([
data_augmentation,
DefaultConv2D(filters=32),
DefaultConv2D(filters=32),
keras.layers.MaxPool2D() ,
DefaultConv2D(filters=64),
DefaultConv2D(filters=64),
keras.layers.MaxPool2D() ,
DefaultCo... | Digit Recognizer |
12,983,127 | !pip install.. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl
!pip install.. /input/hpapytorchzoozip/pytorch_zoo-master
!pip install.. /input/hpacellsegmentatormaster/HPA-Cell-Segmentation-master<set_options> | with open("/kaggle/input/digit-recognizer/test.csv")as f:
reader = csv.reader(f, delimiter=',')
next(reader)
dataset = [row for row in reader]
test_imgs = np.array(dataset, dtype='float32' ).reshape(( len(dataset), 28, 28)) [..., np.newaxis] | Digit Recognizer |
12,983,127 | random.seed(0)
LOCAL = False
COMPUTE_PUBLIC = False
COMPUTE_PRIVATE = True
EXP_NAME_1ST = ["exp049", "exp050"]
MODEL_NAMES_1ST = [
"model_best_0.pth",
"model_best_1.pth",
"model_best_2.pth",
"model_best_3.pth",
]
TEST_LOCAL_COMPUTED_1ST = [
"pred_0.csv",
"pred_1.csv",
"pred_2.csv",
"pred_3.csv"
]
BACKBONE_NAME = "sere... | predictions = [np.argmax(p)for p in model.predict(test_imgs)]
ids = np.arange(len(dataset)) + 1
submission_df = pd.DataFrame({'ImageId':ids, 'label':predictions})
submission_df.head() | Digit Recognizer |
12,983,127 | <load_from_csv><EOS> | submission_df.to_csv("submission.csv", index=False ) | Digit Recognizer |
14,556,937 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<categorify> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep')
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Digit Recognizer |
14,556,937 | test = post_process1(test)
test<predict_on_test> | train_data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
14,556,937 | test_image = test.groupby("image_id" ).first().reset_index()
if LOCAL:
pass
else:
test_loader = DataLoader(
ImageDataset(test_image),
batch_size=BATCH_SIZE,
num_workers=MAX_THRE,
pin_memory=True,
)
models = []
for p in MODEL_PATHS_IMAGE:
model = get_model(p)
model.eval()
models.append(model)
preds = predict(models... | X = train_data.drop('label', axis=1)
y = train_data['label'] | Digit Recognizer |
14,556,937 | if LOCAL:
pass
else:
test_loader = DataLoader(
MyDataset(test, mode="test", w_mask=W_MASK),
batch_size=BATCH_SIZE,
num_workers=MAX_THRE,
pin_memory=True,
)
models = []
for p in MODEL_PATHS:
model = get_model(p)
model.eval()
models.append(model)
preds = predict_weighted(models, test_loader, GPU, WEIGHT_1ST_2ND)
di... | sns.countplot(x=y)
print(y.value_counts().sort_index(ascending=True)) | Digit Recognizer |
14,556,937 | cols = sample_submission.columns
if COMPUTE_PUBLIC is False and COMPUTE_PRIVATE is False:
print("dryrun, replace with local computed file")
test_2nd = pd.read_csv(TEST_LOCAL_COMPUTED_PATHS[0])
for p in TEST_LOCAL_COMPUTED_PATHS[1:]:
test_2nd.loc[:, COLS_TARGET] += pd.read_csv(p ).loc[:, COLS_TARGET]
test_2nd.loc[:, C... | X.isna().sum().value_counts() | Digit Recognizer |
14,556,937 | if len(sample_submission)== 559:
sub = pd.read_csv("submission.csv")
display(sub )<load_from_csv> | y.isna().sum() | Digit Recognizer |
14,556,937 | if len(sample_submission)== 559:
sub = pd.read_csv("submission.csv")
for index, row in sub.head(3 ).iterrows() :
image_id = row["ID"]
w = row["ImageWidth"]
h = row["ImageHeight"]
pred_strs = row["PredictionString"].split()
pred_strs = list(split_list(pred_strs, 3))
for i, pred in enumerate(pred_strs):
class_id, cnf, e... | X = X / 255.0
X = X.values.reshape(-1, 28, 28, 1)
y = to_categorical(y, num_classes = 10 ) | Digit Recognizer |
14,556,937 | !pip install -q.. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl<define_variables> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42 ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.