kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
20,482,624 | test = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv')
test['file_path'] = test.StudyInstanceUID.apply(lambda x: os.path.join('.. /input/ranzcr-clip-catheter-line-classification/test', f'{x}.jpg'))
target_cols = test.iloc[:, 1:12].columns.tolist()
test_dataset = RANZCRDataset(te... | history = model.fit(datagen.flow(Xtrain, ytrain, batch_size=100), validation_data=(Xvalid, yvalid), epochs = 100, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
20,482,624 | submit = False
if submit:
test_preds = []
for i in range(len(enet_type)) :
if enet_type[i] == 'resnet200d':
print('resnet200d loaded')
model = RANZCRResNet200D(enet_type[i], out_dim=len(target_cols))
model = model.to(device)
model.load_state_dict(torch.load(model_path[i], map_location='cuda:0'))
if tta:
test_preds +=... | ypred = model.predict(test_data)
for i in range(ypred.shape[0]):
pred = ypred[i, :]
ypred[i, 0] = list(pred ).index(pred.max() ) | Digit Recognizer |
20,482,624 | <load_from_csv><EOS> | submission = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv')
submission.iloc[:, 1] = ypred[:, 0].astype(np.int)
submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
20,343,341 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | !pip install efficientnet tensorflow_addons > /dev/null | Digit Recognizer |
20,343,341 | if torch.cuda.is_available() :
map_location=lambda storage, loc: storage.cuda()
else:
map_location='cpu'<set_options> | %matplotlib inline
| Digit Recognizer |
20,343,341 | if torch.cuda.is_available() :
device= 'cuda'
else:
device='cpu'
print(device )<categorify> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
20,343,341 | def get_transforms() :
return Compose([
Resize(IMAGE_SIZE, IMAGE_SIZE),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
] )<choose_model_class> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
20,343,341 | class ResNet200D(nn.Module):
def __init__(self, model_name='resnet200d'):
super().__init__()
self.model = timm.create_model(model_name, pretrained=False)
n_features = self.model.fc.in_features
self.model.global_pool = nn.Identity()
self.model.fc = nn.Identity()
self.pooling = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Line... | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
20,343,341 | def inference(models, test_loader, device):
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(images)in tk0:
images = images.to(device)
avg_preds = []
for model in models:
with torch.no_grad() :
y_preds1 = model(images)
y_preds2 = model(images.flip(-1))
y_preds =(y_preds1.sigmoid().to('cpu'... | Y_train = tf.keras.utils.to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
20,343,341 | MODEL_PATH = '.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold4_cv954.pth'
MODEL_PATH957 = '.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold3_cv957.pth'<choose_model_class> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=0 ) | Digit Recognizer |
20,343,341 | model = ResNet200D()
model.load_state_dict(torch.load(MODEL_PATH,map_location=map_location),strict=False)
model.eval()
models = [model.to(device)]
model957 = ResNet200D()
model957.load_state_dict(torch.load(MODEL_PATH957,map_location=map_location),strict=False)
model957.eval()
models957 = [model957.to(device)]<load_f... | efficientnet_size = 7
weights = "imagenet"
size = 56 | Digit Recognizer |
20,343,341 | test = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv')
test_dataset = TestDataset(test, transform=get_transforms())
test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,
num_workers=4 , pin_memory=True)
predictions = inference(models, test_loader, device... | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(filters = 3, kernel_size = 1, padding = 'Same',
activation ='relu', input_shape =(size,size,1)))
model.add(getattr(efn, f"EfficientNetB{efficientnet_size}" )(
weights=weights, include_top=False, input_shape=(size, size, 3)))
model.add(tf.keras.lay... | Digit Recognizer |
20,343,341 | target_cols = test.iloc[:, 1:12].columns.tolist()
test[target_cols] =(predictions + predictions957)/2
test[['StudyInstanceUID'] + target_cols].to_csv('submission.csv', index=False)
test.head()<import_modules> | optimizer = tf.keras.optimizers.Adam(lr=0.0001 ) | Digit Recognizer |
20,343,341 |
<define_variables> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
20,343,341 | AUTO = tf.data.experimental.AUTOTUNE
DIM = 600
IMAGE_SIZE=[DIM,DIM]
BATCH_SIZE = 8
DATA_PATH = ".. /input/ranzcr-clip-catheter-line-classification/"
OUTPUT_PATH = "./"<install_modules> | tf.random.set_seed(0)
history = model.fit(X_train,
Y_train,
epochs=10,
batch_size=128,
validation_data=(X_val, Y_val),
) | Digit Recognizer |
20,343,341 | !pip install.. /input/kerasapplications/keras-applications-master/
package_path = '.. /input/efficientnetmaster/efficientnet-master/'
sys.path.append(package_path)
<define_variables> | pred = model.predict_classes(test ) | Digit Recognizer |
20,343,341 | TEST_FILENAMES = tf.io.gfile.glob('.. /input/ranzcr-clip-catheter-line-classification/test_tfrecords/*.tfrec')
print(TEST_FILENAMES )<categorify> | submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv" ) | Digit Recognizer |
20,343,341 | def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
image = tf.image.resize(image, [DIM, DIM])
image = tf.reshape(image, [*IMAGE_SIZE, 3])
return image
def read_unlabeled_tfrecord(example):
UNLABELED_TFREC_FORMAT = {
'image': tf.io.FixedLenFeat... | submission["Label"] = pred | Digit Recognizer |
20,343,341 | models1=[]
for filename in glob.glob('.. /input/eff7trained/*best.h5'):
model = tf.keras.models.load_model(filename, custom_objects = None)
models1.append(model)
<predict_on_test> | submission.to_csv("submission.csv",index=False ) | Digit Recognizer |
18,487,180 | test_ds = get_test_dataset(ordered=True)
test_images_ds = test_ds.map(lambda image, idnum: image)
labels = ['ETT - Abnormal', 'ETT - Borderline',
'ETT - Normal', 'NGT - Abnormal', 'NGT - Borderline',
'NGT - Incompletely Imaged', 'NGT - Normal', 'CVC - Abnormal',
'CVC - Borderline', 'CVC - Normal', 'Swan Ganz Catheter... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
18,487,180 | test_ids_ds = test_ds.map(lambda image, idnum: idnum ).unbatch()
test_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES)) ).numpy().astype('U' )<save_to_csv> | x_train = train.drop('label', axis=1)/255.0
y_label = train['label'].values
x_test = test/255.0 | Digit Recognizer |
18,487,180 | submission = pd.DataFrame(mean, columns = labels)
submission.insert(0, "StudyInstanceUID", test_ids, False)
submission['StudyInstanceUID'] = submission['StudyInstanceUID'].apply(lambda x: x.rstrip(".jpg"))
submission.to_csv('submission.csv', index=False )<train_model> | datagen = ImageDataGenerator(
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
) | Digit Recognizer |
18,487,180 | print("Done" )<define_variables> | import tensorflow as tf | Digit Recognizer |
18,487,180 | batch_size = 1
image_size = 512
tta = True
submit = True
enet_type = ['resnet200d'] * 5
model_path = ['.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold0_cv953.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold1_cv955.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold2... | class ResidualUnit(tf.keras.layers.Layer):
def __init__(self, filters, strides=1, activation='relu', **kwargs):
super().__init__(**kwargs)
self.activation = tf.keras.activations.get(activation)
self.main_layers = [
tf.keras.layers.Conv2D(filters, 3, strides=strides, padding='SAME', use_bias=False),
tf.keras.layers.Ba... | Digit Recognizer |
18,487,180 | sys.path.append('.. /input/pytorch-image-models/pytorch-image-models-master')
sys.path.append('.. /input/timm-pytorch-image-models/pytorch-image-models-master')
DEBUG = False
%matplotlib inline
device = torch.device('cuda')if not DEBUG else torch.device('cpu' )<choose_model_class> | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(64,(7,7), input_shape=(28, 28, 1), padding='SAME'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.MaxPooling2D(2, 2))
prev_filters = 64
for filters in [64]*2 + [128]*2 + [256]... | Digit Recognizer |
18,487,180 | class RANZCRResNet200D(nn.Module):
def __init__(self, model_name='resnet200d', out_dim=11, pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=False)
n_features = self.model.fc.in_features
self.model.global_pool = nn.Identity()
self.model.fc = nn.Identity()
self.pooling = nn.Ada... | model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
checkpoint = ModelCheckpoint(
filepath=f'resnet-{int(time.time())}.dhf5',
monitor='loss',
save_best_only=True
)
annealer = LearningRateScheduler(lambda x: 1e-3 * 0.8**x)
callbacks = [checkpoint, annealer] | Digit Recognizer |
18,487,180 | transforms_test = albumentations.Compose([
Resize(image_size, image_size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
] )<load_from_csv> | batch_size = 64
history = model.fit(datagen.flow(X_train, y_label, batch_size=batch_size),
epochs = 30,
verbose = 1, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=callbacks, ) | Digit Recognizer |
18,487,180 | test = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv')
test['file_path'] = test.StudyInstanceUID.apply(lambda x: os.path.join('.. /input/ranzcr-clip-catheter-line-classification/test', f'{x}.jpg'))
target_cols = test.iloc[:, 1:12].columns.tolist()
test_dataset = RANZCRDataset(te... | model.evaluate(X_train, y_label ) | Digit Recognizer |
18,487,180 | if submit:
test_preds_1 = []
for i in range(len(enet_type)) :
if enet_type[i] == 'resnet200d':
print('resnet200d loaded')
model = RANZCRResNet200D(enet_type[i], out_dim=len(target_cols))
model = model.to(device)
model.load_state_dict(torch.load(model_path[i], map_location='cuda:0'))
if tta:
test_preds_1 += [tta_infer... | def predict_proba(X, model, num_samples):
preds = [model(X, training=True)for _ in range(num_samples)]
return np.stack(preds ).mean(axis=0)
def predict_class(X, model, num_samples):
proba_preds = predict_proba(X, model, num_samples)
return np.argmax(proba_preds, axis=1 ) | Digit Recognizer |
18,487,180 | submission = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv')
submission[target_cols] = np.mean(test_preds_1, axis=0 )<import_modules> | y_pred = predict_class(X_test, model, 10 ) | Digit Recognizer |
18,487,180 | from pathlib import Path
import random
from scipy.sparse import coo_matrix
import gc
from joblib import Parallel, delayed
import typing as tp
from torch.utils import data<define_variables> | res = pd.DataFrame(y_pred, columns=['Label'])
res.index = res.index + 1
res.index.rename('ImageId', inplace=True)
res.to_csv('res.csv' ) | Digit Recognizer |
18,487,180 | ROOT = Path.cwd().parent
INPUT = ROOT / "input"
OUTPUT = ROOT / "output"
DATA = INPUT / "ranzcr-clip-catheter-line-classification"
TRAIN = DATA / "train"
TEST = DATA / "test"
TRAINED_MODEL = INPUT / "ranzcr-clip-weights-for-multi-head-model-v2"
TMP = ROOT / "tmp"
TMP.mkdir(exist_ok=True)
RANDAM_SEED = 1086
N_CLASSES =... | successive_outputs = [layer.output for layer in model.layers[0:]]
visualization_model = tf.keras.models.Model(inputs = model.input, outputs = successive_outputs)
img = random.choice(X_train)
plt.imshow(img, cmap=plt.cm.binary)
plt.show() | Digit Recognizer |
18,487,180 | for p in DATA.iterdir() :
print(p.name)
train = pd.read_csv(DATA / "train.csv")
smpl_sub = pd.read_csv(DATA / "sample_submission.csv" )<split> | successive_feature_maps = visualization_model.predict(img)
layer_names = [layer.name for layer in model.layers]
for layer_name, feature_map in zip(layer_names, successive_feature_maps):
if len(feature_map.shape)== 4:
n_features = feature_map.shape[-1]
size = feature_map.shape[1]
pic_num_per_row = n_features // 8 + 1
d... | Digit Recognizer |
18,487,180 | if FAST_COMMIT and len(smpl_sub)== 3582:
smpl_sub = smpl_sub.iloc[:64 * 3].reset_index(drop=True )<categorify> | y_pred = model.predict_classes(X_train ) | Digit Recognizer |
18,487,180 | def multi_label_stratified_group_k_fold(label_arr: np.array, gid_arr: np.array, n_fold: int, seed: int=42):
np.random.seed(seed)
random.seed(seed)
start_time = time.time()
n_train, n_class = label_arr.shape
gid_unique = sorted(set(gid_arr))
n_group = len(gid_unique)
gid2aid = dict(zip(gid_unique, range(n_group)))
... | from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score | Digit Recognizer |
18,487,180 | label_arr = train[CLASSES].values
group_id = train.PatientID.values
train_val_indexs = list(
multi_label_stratified_group_k_fold(label_arr, group_id, N_FOLD, RANDAM_SEED))<feature_engineering> | conf_max = confusion_matrix(y_label, y_pred)
conf_max | Digit Recognizer |
18,487,180 | train["fold"] = -1
for fold_id,(trn_idx, val_idx)in enumerate(train_val_indexs):
train.loc[val_idx, "fold"] = fold_id
train.groupby("fold")[CLASSES].sum()<train_model> | diff_num = 5 | Digit Recognizer |
18,487,180 | <choose_model_class><EOS> | a_1d = norm_conf_max.flatten()
idx_1d = a_1d.argsort() [-diff_num:]
x_idx, y_idx = np.unravel_index(idx_1d, norm_conf_max.shape)
print(x_idx, y_idx ) | Digit Recognizer |
18,555,598 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,Dropout
import matplotlib.pyplot as plt
import keras
from keras.utils.np_utils import to_categorical | Digit Recognizer |
18,555,598 | class MultiHeadResNet200D(nn.Module):
def __init__(
self, out_dims_head: tp.List[int]=[3, 4, 3, 1], pretrained=False
):
self.base_name = "resnet200d_320"
self.n_heads = len(out_dims_head)
super(MultiHeadResNet200D, self ).__init__()
base_model = timm.create_model(
self.base_name, num_classes=sum(out_dims_head), p... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
test1 = test.copy() | Digit Recognizer |
18,555,598 | class LabeledImageDataset(data.Dataset):
def __init__(
self,
file_list: tp.List[
tp.Tuple[tp.Union[str, Path], tp.Union[int, float, np.ndarray]]],
transform_list: tp.List[tp.Dict],
):
self.file_list = file_list
self.transform = ImageTransformForCls(transform_list)
def __len__(self):
return len(self.file_list)
... | x_train=train.drop(['label'],1)
y_train=train['label']
x_train=x_train.values.reshape(-1,28,28,1)
test=test.values.reshape(-1,28,28,1)
x_train=x_train/255
test=test/255
| Digit Recognizer |
18,555,598 | def get_dataloaders_for_inference(
file_list: tp.List[tp.List], batch_size=64,
):
dataset = LabeledImageDataset(
file_list,
transform_list=[
["Normalize", {
"always_apply": True, "max_pixel_value": 255.0,
"mean": ["0.4887381077884414"], "std": ["0.23064819430546407"]}],
["ToTensorV2", {"always_apply": True}],
])
... | model=models.Sequential([
Conv2D(32,(5,5), activation='relu' , input_shape=(28,28,1)) ,
MaxPooling2D(pool_size=(2,2)) ,
Conv2D(64,(5,5), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Conv2D(64,(3,3), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Flatten() ,
Dense(64, activati... | Digit Recognizer |
18,555,598 | class ImageTransformBase:
def __init__(self, data_augmentations: tp.List[tp.Tuple[str, tp.Dict]]):
augmentations_list = [
self._get_augmentation(aug_name )(**params)
for aug_name, params in data_augmentations]
self.data_aug = albumentations.Compose(augmentations_list)
def __call__(self, pair: tp.Tuple[np.ndarray]... | model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model.fit(x_train, y_train, epochs=60, batch_size=64 ) | Digit Recognizer |
18,555,598 | def load_setting_file(path: str):
with open(path)as f:
settings = yaml.safe_load(f)
return settings
def set_random_seed(seed: int = 42, deterministic: bool = False):
random.seed(seed)
np.random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backe... | y_test = model.predict(test)
y_test = np.argmax(y_test, axis = 1)
index_list = []
for i in list(test1.index):
index_list.append(i+1)
submission_df = pd.DataFrame({
"ImageId": index_list,
"Label": y_test
})
submission_df.to_csv("submission_cnn.csv", index = False ) | Digit Recognizer |
18,243,332 | if not torch.cuda.is_available() :
device = torch.device("cpu")
else:
device = torch.device("cuda")
print(device )<load_pretrained> | import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from keras.utils.np_utils import to_categorical | Digit Recognizer |
18,243,332 | model_dir = TRAINED_MODEL
test_dir = TEST_RESIZED
test_file_list = [
(test_dir / f"{img_id}.png", [-1] * 11)
for img_id in smpl_sub["StudyInstanceUID"].values]
test_loader = get_dataloaders_for_inference(test_file_list, batch_size=64)
test_preds_arr = np.zeros(( N_FOLD, len(smpl_sub), N_CLASSES))
for fold_id in FOLD... | train=pd.read_csv('.. /input/digit-recognizer/train.csv')
test=pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
18,243,332 | sub = smpl_sub.copy()
sub[CLASSES] = test_preds_arr.mean(axis=0 )<prepare_output> | x_train=train.drop(['label'],1)
y_train=train['label'] | Digit Recognizer |
18,243,332 | Final_Submission = smpl_sub.copy()
Final_Submission[CLASSES] =.50 * sub[CLASSES] +.50 * submission[CLASSES]<save_to_csv> | x_train=np.array(x_train)
test=np.array(test ) | Digit Recognizer |
18,243,332 | Final_Submission.to_csv("submission.csv", index=False )<set_options> | x_train=x_train/255
test=test/255 | Digit Recognizer |
18,243,332 | sys.path.append('.. /input/pytorch-images-seresnet')
warnings.filterwarnings('ignore')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu' )<define_variables> | target=x_train.reshape(-1,28,28,1)
test=test.reshape(-1,28,28,1)
y_train=np.array(y_train)
label=to_categorical(y_train)
label.shape | Digit Recognizer |
18,243,332 | IMAGE_SIZE = 640
BATCH_SIZE = 128
TEST_PATH = '.. /input/ranzcr-clip-catheter-line-classification/test'
MODEL_PATH = '.. /input/resnet200d-public/resnet200d_320_CV9632.pth'<load_from_csv> | from keras.models import Sequential
from keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,Dropout | Digit Recognizer |
18,243,332 | test = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv' )<categorify> | model=Sequential([
Conv2D(32,(5,5), activation='relu' , input_shape=(28,28,1)) ,
MaxPooling2D(pool_size=(2,2)) ,
Conv2D(64,(5,5), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Conv2D(64,(3,3), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Flatten() ,
Dense(64, activation='rel... | Digit Recognizer |
18,243,332 | def get_transforms() :
return Compose([
Resize(IMAGE_SIZE, IMAGE_SIZE),
Normalize(
),
ToTensorV2() ,
] )<choose_model_class> | model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'] ) | Digit Recognizer |
18,243,332 | class ResNet200D(nn.Module):
def __init__(self, model_name='resnet200d_320'):
super().__init__()
self.model = timm.create_model(model_name, pretrained=False)
n_features = self.model.fc.in_features
self.model.global_pool = nn.Identity()
self.model.fc = nn.Identity()
self.pooling = nn.AdaptiveAvgPool2d(1)
self.fc = nn.... | model.fit(target,label,epochs=40,batch_size=64 ) | Digit Recognizer |
18,243,332 | def inference(models, test_loader, device):
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(images)in tk0:
images = images.to(device)
avg_preds = []
for model in models:
with torch.no_grad() :
y_preds1 = model(images)
y_preds2 = model(images.flip(-1))
y_preds =(y_preds1.sigmoid().to('cpu'... | Y_pred = model.predict(test)
Y_pred_classes = np.argmax(Y_pred,axis = 1 ) | Digit Recognizer |
18,243,332 | model = ResNet200D()
model.load_state_dict(torch.load(MODEL_PATH)['model'])
model.eval()
models = [model.to(device)]<load_pretrained> | submission_data = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
18,243,332 | test_dataset = TestDataset(test, transform=get_transforms())
test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,
num_workers=4 , pin_memory=True)
predictions = inference(models, test_loader, device )<save_to_csv> | submission_data['Label']=Y_pred_classes | Digit Recognizer |
18,243,332 | target_cols = test.iloc[:, 1:12].columns.tolist()
test[target_cols] = predictions
test[['StudyInstanceUID'] + target_cols].to_csv('submission.csv', index=False)
test.head()<define_variables> | submission_data.to_csv('submit.csv' ,index=False ) | Digit Recognizer |
18,243,332 | batch_size = 1
image_size = 512
tta = True
submit = True
enet_type = ['resnet200d'] * 5
model_path = ['.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold0_cv953.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold1_cv955.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold2... | def test_output(i):
plt.imshow(x_train[i],cmap='gray')
predicted=np.argmax(model.predict(target[i].reshape(-1,28,28,1)))
actual=np.argmax(label[i])
plt.xlabel(f'predicted= {predicted} Actual= {actual}' ) | Digit Recognizer |
18,243,332 | sys.path.append('.. /input/pytorch-image-models/pytorch-image-models-master')
sys.path.append('.. /input/timm-pytorch-image-models/pytorch-image-models-master')
DEBUG = False
%matplotlib inline
device = torch.device('cuda')if not DEBUG else torch.device('cpu' )<choose_model_class> | from PIL import Image, ImageGrab | Digit Recognizer |
18,243,332 | class RANZCRResNet200D(nn.Module):
def __init__(self, model_name='resnet200d', out_dim=11, pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=False)
n_features = self.model.fc.in_features
self.model.global_pool = nn.Identity()
self.model.fc = nn.Identity()
self.pooling = nn.Ada... | def predict_digit1(img):
img = Image.open(img)
plt.imshow(img)
img = img.convert('L', dither=Image.NONE)
img = img.resize(( 28,28))
img = np.array(img)
img=np.invert(img)
predicted=np.argmax(model.predict(img.reshape(-1,28,28,1)))
plt.xlabel(f'Predicted= {predicted}' ) | Digit Recognizer |
18,243,332 | transforms_test = albumentations.Compose([
Resize(image_size, image_size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
] )<load_from_csv> | predict_digit1('.. /input/temporary/Images/images.jfif' ) | Digit Recognizer |
18,243,332 | test = pd.read_csv('.. /input/ranzcr-clip-catheter-line-classification/sample_submission.csv')
test['file_path'] = test.StudyInstanceUID.apply(lambda x: os.path.join('.. /input/ranzcr-clip-catheter-line-classification/test', f'{x}.jpg'))
target_cols = test.iloc[:, 1:12].columns.tolist()
test_dataset = RANZCRDataset(te... | predict_digit1('.. /input/temporary/Images/download.png' ) | Digit Recognizer |
18,243,332 | if submit:
test_preds = []
for i in range(len(enet_type)) :
if enet_type[i] == 'resnet200d':
print('resnet200d loaded')
model = RANZCRResNet200D(enet_type[i], out_dim=len(target_cols))
model = model.to(device)
model.load_state_dict(torch.load(model_path[i], map_location='cuda:0'))
if tta:
test_preds += [tta_inference... | predict_digit1('.. /input/temporary/Images/531-5314816_handwritten-1-number-9-hand-written-png-transparent.png' ) | Digit Recognizer |
18,243,332 | <categorify><EOS> | predict_digit1('.. /input/temporary/Images/1.jpg' ) | Digit Recognizer |
20,287,499 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | import numpy as np
import pandas as pd
import os
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
import pandas as pd
import matplotlib.pyplot as plt | Digit Recognizer |
20,287,499 |
dfx = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
df_train, df_valid = model_selection.train_test_split(dfx, test_size=0.1, random_state=42, stratify=dfx.label.values)
_train = df_train.reset_index(drop=True)
df_valid = df_valid.reset_index(drop=True)
image_path = ".. /input/cassava-lea... | train = np.loadtxt(open('/kaggle/input/digit-recognizer/train.csv', 'r'), delimiter=',', skiprows=1, dtype='float32')
test = np.loadtxt(open('/kaggle/input/digit-recognizer/test.csv', 'r'), delimiter=',', skiprows=1, dtype='float32')
train_images = train[:, 1:].reshape(( train.shape[0], 28, 28, 1)) / 255.0
train_labe... | Digit Recognizer |
20,287,499 |
cassava_train = CassavaDataset(train_image_paths, train_targets, 'train')
cassava_test = CassavaDataset(valid_image_paths, valid_targets, 'test')
batch_size = 16
train_loader = DataLoader(cassava_train, batch_size=batch_size, shuffle=False, num_workers=2)
test_loader = DataLoader(cassava_test, batch_size=batch_siz... | augmentation_layer = tf.keras.Sequential([
tf.keras.layers.experimental.preprocessing.RandomRotation(0.1, input_shape=(28, 28, 1)) ,
tf.keras.layers.experimental.preprocessing.RandomZoom(( 0.2, 0.2)) ,
] ) | Digit Recognizer |
20,287,499 |
class AverageMeter:
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def accuracy(output, target, topk=(1,)) :
maxk = max(topk)
batch_size = targe... | for i in range(5):
new_img = augmentation_layer(train_images[np.random.randint(train_images.shape[0])] ).numpy()
plt.imshow(new_img.reshape(( 28, 28)))
plt.show() | Digit Recognizer |
20,287,499 |
def train_epoch(model, loader, device, loss_func, optimizer, scheduler):
model.train()
summary_loss = AverageMeter()
summary_acc = AverageMeter()
start = time.time()
n = len(loader)
for batch in tqdm(loader):
images, labels = batch
images = images.to(device)
labels = labels.to(device)
out = model(images)
loss = l... | model = Sequential([
tf.keras.layers.Input(( 28, 28, 1)) ,
augmentation_layer,
Conv2D(32, 3, activation='relu', padding="same"),
MaxPooling2D(2),
Conv2D(64, 3, activation='relu', padding="same"),
MaxPooling2D(2),
Conv2D(64, 3, activation='relu', padding="same"),
MaxPooling2D(2),
Flatten() ,
Dropout(0.3),
Dense(128, act... | Digit Recognizer |
20,287,499 |
resnet = timm.create_model('resnext50_32x4d', pretrained=True)
num_ftrs = resnet.fc.in_features
resnet.fc = nn.Linear(num_ftrs, 5)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
resnet.to(device )<choose_model_class> | model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
) | Digit Recognizer |
20,287,499 |
num_epochs = 1
best_acc = 0
best_epoch = 0
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(resnet.parameters() , lr=0.01, momentum=0.9)
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.2, patience=2, verbose=True, eps=1e-6)
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch + 1, n... | history = model.fit(train_images, train_labels, epochs=100 ) | Digit Recognizer |
20,287,499 |
num_epochs = 10
best_acc = 0
best_epoch = 0
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(xception.parameters() , lr=0.01, momentum=0.9)
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.2, patience=2, verbose=True, eps=1e-6)
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch + 1... | predition_model = tf.keras.Sequential()
for layer in model.layers:
if layer != augmentation_layer:
predition_model.add(layer)
predition_model.compile(loss="sparse_categorical_crossentropy", optimizer="adam" ) | Digit Recognizer |
20,287,499 |
PATH = './timm_resnext_epoch10_384.pth'
resnet = timm.create_model('resnext50_32x4d', pretrained=False)
num_ftrs = resnet.fc.in_features
resnet.fc = nn.Linear(num_ftrs, 5)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
resnet.to(device)
resnet.load_state_dict(torch.load(PATH))
resnet.eval... | test_labels = np.argmax(predition_model.predict(test_images), axis=-1)
print(test_labels.shape ) | Digit Recognizer |
20,287,499 |
submission_df = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission_df.head()<normalization> | image_ids = np.arange(1, test_labels.shape[0]+1)
result = np.concatenate(( image_ids.reshape(image_ids.shape[0], 1), test_labels.reshape(test_labels.shape[0], 1)) , axis=1)
df = pd.DataFrame(result, columns=["ImageId", "Label"], dtype='int')
df.to_csv("submission.csv", index=False ) | Digit Recognizer |
20,119,647 |
input_size = 384
stats =([0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261])
trans1 = transforms.Compose([transforms.Resize(( input_size, input_size)) ,
transforms.Pad(8, padding_mode='reflect'),
transforms.ToTensor() ,
transforms.Normalize(*stats)])
trans2 = transforms.Compose([transforms.Resize(( input_size, input_s... | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
20,119,647 |
test_path = '/kaggle/input/cassava-leaf-disease-classification/test_images/'
test_images = os.listdir(test_path)
train_image_paths = [os.path.join(test_path, x)for x in test_images]
y_preds = []
y2_preds = []
p = 0
for i in test_images:
res = []
image = Image.open(f'/kaggle/input/cassava-leaf-disease-classification/... | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
20,119,647 | df_sub = pd.DataFrame({'image_id': test_images, 'label': y_preds})
display(df_sub )<save_to_csv> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
20,119,647 | df_sub.to_csv('submission.csv', index=False )<install_modules> | Y_train=to_categorical(Y_train, num_classes=10 ) | Digit Recognizer |
20,119,647 | pip install cleantext<install_modules> | random_seed=2 | Digit Recognizer |
20,119,647 | pip install ktrain<set_options> | 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 |
20,119,647 | warnings.filterwarnings("ignore" )<load_from_csv> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
20,119,647 | df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
display(df.head())
display(df.shape )<categorify> | optimizer = RMSprop(lr=0.001,rho=0.9,epsilon=1e-08,decay=0.0 ) | Digit Recognizer |
20,119,647 | l=len(df)
display(l)
cleanlist=[]
textlength=[]
for i in range(l):
ct=cleantext.clean(df.iloc[i,3], clean_all= True)
cleanlist.append(ct)
lct=len(ct)
textlength.append(lct)
<create_dataframe> | model.compile(optimizer=optimizer,loss="categorical_crossentropy",metrics=["accuracy"] ) | Digit Recognizer |
20,119,647 | df_clean=pd.DataFrame(cleanlist)
df_clean.columns=['cleantext']
frames=[df,df_clean]
newdf=pd.concat(frames, axis=1)
display(newdf )<train_model> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_loss',patience=3,verbose=1,factor=0.5,min_lr=0.00001 ) | Digit Recognizer |
20,119,647 | ( x_train, y_train),(x_test, y_test), preproc=text.texts_from_df(newdf, 'cleantext',label_columns=['target'],
maxlen=127,max_features=100000,
preprocess_mode='bert', val_pct=.1 )<train_model> | epochs=15
batch_size=86 | Digit Recognizer |
20,119,647 | model=text.text_classifier('bert',(x_train, y_train), preproc=preproc)
learner=ktrain.get_learner(model, train_data=(x_train, y_train),
val_data=(x_test, y_test),
batch_size=32 )<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)
datagen.fit(X_t... | Digit Recognizer |
20,119,647 | learner.fit_onecycle(2e-5, 3)
predictor=ktrain.get_predictor(learner.model, preproc )<predict_on_test> | history = model.fit(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 |
20,119,647 | predictor.predict(['calm','earthquake'] )<load_from_csv> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
20,119,647 | <predict_on_test><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 |
21,936,867 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<prepare_output> | import tensorflow as tf
import numpy as np
import pandas as pd
| Digit Recognizer |
21,936,867 | df_pred=pd.DataFrame(predlist)
df_pred.columns=['target']
frames=[df1,df_pred]
df2=pd.concat(frames, axis=1)
display(df2.head() )<feature_engineering> | training = pd.read_csv('.. /input/digit-recognizer/train.csv' ) | Digit Recognizer |
21,936,867 | df2.loc[df2['target']=='target','target']=1
df2.loc[df2['target']=='not_target','target']=0
display(df2['target'].mean())
df2=df2[['id','target']]
display(df2.shape)
display(df2.head() )<save_to_csv> | x_train, y_train = training.iloc[:, 1:], training.iloc[:, 0:1] | Digit Recognizer |
21,936,867 | df2.to_csv("submission.csv", index=False )<load_from_url> | x_train = x_train / 255 | Digit Recognizer |
21,936,867 | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py<import_modules> | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(filters=32, kernel_size=5, padding="same", activation="relu", input_shape=[28, 28, 1]))
model.add(tf.keras.layers.Conv2D(filters=32, kernel_size=5, padding="same", activation="relu"))
model.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2, paddin... | Digit Recognizer |
21,936,867 | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import layers, models, optimizers
from tensorflow.keras.callbacks import ModelCheckpoint<load_from_csv> | model.fit(x_train, y_train, epochs=15 ) | Digit Recognizer |
21,936,867 | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv" )<categorify> | test = pd.read_csv('.. /input/digit-recognizer/test.csv')
test = test / 255
test = test.values.reshape(-1, 28, 28, 1 ) | Digit Recognizer |
21,936,867 | def bert_encode(texts, tokenizer, max_len):
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
tokens... | predictions = model.predict(test ) | Digit Recognizer |
21,936,867 | <categorify><EOS> | export = pd.DataFrame([np.argmax(prediction)for prediction in predictions])
export.index += 1
export = export.reset_index()
export.columns = ['ImageId', 'Label']
export.to_csv('submission.csv', index=False ) | Digit Recognizer |
21,648,756 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | from tensorflow.keras.preprocessing.image \
| Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.