kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,556,937 | sys.path = [
'.. /input/smp20210127/pytorch-image-models-master/pytorch-image-models-master',
'.. /input/hpapytorchzoozip/pytorch_zoo-master/',
'.. /input/hpa-seg/HPA-Cell-Segmentation/hpacellseg',
'.. /input/hpafinal'
] + sys.path
warnings.filterwarnings("ignore" )<import_modules> | cnn_model = Sequential()
cnn_model.add(Conv2D(filters = 32, kernel_size =(5, 5), padding = 'same', activation ='relu', input_shape =(28,28,1)))
cnn_model.add(Conv2D(filters = 32, kernel_size =(5, 5), padding = 'same', activation ='relu'))
cnn_model.add(MaxPool2D(pool_size=(2, 2)))
cnn_model.add(Dropout(0.25))
cnn_mod... | Digit Recognizer |
14,556,937 | remove_small_holes, remove_small_objects)
device = torch.device('cuda' )<define_variables> | cnn_model.compile(
optimizer = 'adam',
loss = "categorical_crossentropy",
metrics=["accuracy"]
) | Digit Recognizer |
14,556,937 | seg_size = 512
seg_bs = 8388608 // seg_size ** 2
seg_TTA = 8
small_th_dict = {
2048: 500,
1024: 125,
512 : 32,
}
small_th = small_th_dict[seg_size]
mask_dir = 'test_mask_npz_fullsize_cell_mask'
model_dirs = [
'.. /input/bo-hpa-models',
'.. /input/bo-hpa-models-3d256',
'.. /input/hpa-models',
'.. /input/hpa-models-qishe... | early_stopping = keras.callbacks.EarlyStopping(
patience=5,
min_delta=0.001,
restore_best_weights=True,
) | Digit Recognizer |
14,556,937 | NORMALIZE = {"mean": [124 / 255, 117 / 255, 104 / 255], "std": [1 /(0.0167 * 255)] * 3}
def get_trans_seg(img, I, rev=False):
if I >= 4 and not rev:
img = img.transpose(2,3)
if I % 4 == 0:
pass
elif I % 4 == 1:
img = img.flip(2)
elif I % 4 == 2:
img = img.flip(3)
elif I % 4 == 3:
img = img.flip(2 ).flip(3)
if I >= ... | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range = 0.1,
)
datagen.fit(X_train ) | Digit Recognizer |
14,556,937 | class HPADatasetSeg(Dataset):
def __init__(self, df, root='.. /input/hpa-single-cell-image-classification/test/'):
self.df = df.reset_index(drop=True)
self.root = root
def __len__(self):
return len(self.df)
def __getitem__(self, index):
row = self.df.loc[index]
r = os.path.join(self.root, f'{row.ID}_red.png')
y = os... | history = cnn_model.fit_generator(
datagen.flow(X_train,y_train, batch_size=64),
validation_data=(X_test, y_test),
steps_per_epoch=X_train.shape[0] // 64,
epochs=30,
callbacks=[early_stopping]
) | Digit Recognizer |
14,556,937 | for gray, rgb, target_shapes, IDs in tqdm(loader_seg):
nuc_segmentations = cellsegmentor.pred_nuclei(gray)
cell_segmentations = cellsegmentor.pred_cells(rgb, precombined=True)
for data_id, target_shape, nuc_seg, cell_seg in zip(IDs, target_shapes, nuc_segmentations, cell_segmentations):
nuc, cell = label_cell(nuc_seg... | test_data = test_data / 255.0
test_data = test_data.values.reshape(-1, 28, 28, 1)
results = cnn_model.predict(test_data)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
14,556,937 | del cellsegmentor
gc.collect()
torch.cuda.empty_cache()<set_options> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
7,945,168 | !nvidia-smi<categorify> | import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow import keras
from keras.utils.np_utils import to_categorical
from tensorflow.keras.applications.resnet50 import preprocess_input
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.... | Digit Recognizer |
7,945,168 | def encode_binary_mask(mask: np.ndarray)-> t.Text:
if mask.dtype != np.bool:
raise ValueError(
"encode_binary_mask expects a binary mask, received dtype == %s" %
mask.dtype)
mask = np.squeeze(mask)
if len(mask.shape)!= 2:
raise ValueError(
"encode_binary_mask expects a 2d mask, received shape == %s" %
mask.shape)... | righe, colonne = 28,28
n_classi = 10
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv")
y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
X_train = X_train / 255.0
test = test / 255.0
X_train = X_train.values.reshape(-1,righe... | Digit Recognizer |
7,945,168 | def read_img(image_id, color, train_or_test='test', image_size=None):
filename = f'.. /input/hpa-single-cell-image-classification/{train_or_test}/{image_id}_{color}.png'
img = cv2.imread(filename, 0)
return img
class HPADatasetTest(Dataset):
def __init__(self, image_ids, mode='test'):
self.image_ids = image_ids
self.m... | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.10,
width_shift_range=0.1,
height_shift_range=0.1 ) | Digit Recognizer |
7,945,168 | dataset = HPADatasetTest(df_sub.ID.values, mode='test')
dataloader = DataLoader(dataset, batch_size=1, num_workers=2 )<choose_model_class> | nets = 7
model = [0] *nets
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(righe,colonne,1)))
model[i].add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model[i].add(MaxPool2D(pool_si... | Digit Recognizer |
7,945,168 | class enetv2(nn.Module):
def __init__(self, enet_type, out_dim=num_classes):
super(enetv2, self ).__init__()
self.enet = timm.create_model(enet_type, False)
if('efficientnet' in enet_type)or('mixnet' in enet_type):
self.enet.conv_stem.weight = nn.Parameter(self.enet.conv_stem.weight.repeat(1,n_ch//3+1,1,1)[:, :n_ch])
... | learning_rate = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
batch = 64
epochs = 5
H = [0] * nets
for j in range(nets):
X_train2, X_val2, y_train2, y_val2 = train_test_split(X_train, y_train, test_size = 0.1)
H[j] = model[j].fit_generator(datagen.flow(X_train2,y_train2, batch_size=batch),
epochs = epochs, valida... | Digit Recognizer |
7,945,168 | kernel_types = {
'resnet50d_512_multilabel_8flips_ss22rot45_co2_lr1e4_bs32_focal_ext_15epo': {
'model_class': 'enetv2',
'folds': [1],
'enet_type': 'resnet50d',
'input_type': ['512', 'masked'],
},
'rex150_512_multilabel_8flips_ss22rot45_co7_lr3e4_bs32_ext_cellpseudo2full_15epo': {
'model_class': 'enetv2',
'folds': [0],
... | results = np.zeros(( test.shape[0],10))
for j in range(nets):
results = results + model[j].predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
sub = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
sub.to_csv("submission.csv",index=False ) | Digit Recognizer |
7,945,168 | def load_state_dict(model, model_file):
for folder in model_dirs:
model_path = os.path.join(folder, model_file)
if os.path.exists(model_path):
state_dict = torch.load(model_path)
state_dict = {k[7:] if k.startswith('module.')else k: state_dict[k] for k in state_dict.keys() }
model.load_state_dict(state_dict, strict=T... | Digit Recognizer | |
13,825,967 | def load_model(model_name,path):
if model_name == 'densenet121':
state_dict = torch.load(path, torch.device('cuda'))
model = class_densenet121_dropout(num_classes=19,in_channels=4,pretrained_file=None)
model.cuda()
model.load_state_dict(state_dict)
model.eval()
return model<define_variables> | Data=pd.read_csv('.. /input/digit-recognizer/train.csv' ) | Digit Recognizer |
13,825,967 | folds = [0,1,2,3,4]
model_dic = {'densenet121':'.. /input/hpafinal/output/run_nn_20210504_000509/'}<load_pretrained> | Y=np.array(Data['label'])
X=np.array(Data.drop('label',axis=1)) / 255 . | Digit Recognizer |
13,825,967 | rgby_models = []
for model_name in model_dic:
path = model_dic[model_name]
for fold in folds:
if os.path.exists(path+'fold%s.ckpt'%fold):
model = load_model(model_name,path+'fold%s.ckpt'%fold)
rgby_models.append(model)
print('daishu model count:', len(rgby_models))<categorify> | plt.imshow(X[25].reshape(28,28))
print(Y[25] ) | Digit Recognizer |
13,825,967 | def get_trans(img, I, mode='bgry'):
if mode == 'rgby':
img = img[:, [2,1,0,3]]
if I >= 4:
img = img.transpose(2,3)
if I % 4 == 0:
return img
elif I % 4 == 1:
return img.flip(2)
elif I % 4 == 2:
return img.flip(3)
elif I % 4 == 3:
return img.flip(2 ).flip(3)
def get_trans_daishu(img, I, mode='bgry'):
if mode == 'rgb... | X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2 ) | Digit Recognizer |
13,825,967 | IDs = []
encs = []
PRED_FINAL = []
little_bs = 16
with torch.no_grad() :
for ID, enc, images in tqdm(dataloader):
try:
if len(enc[0])> 0:
with amp.autocast() :
for k in images.keys() :
images[k] = images[k].cuda()
if images[k].ndim == 5:
images[k] = images[k].squeeze(0)
preds = {
'orig': [],
'cells': [],
}
for m, inp_... | import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,Flatten,BatchNormalization,Dropout,Conv2D,MaxPool2D | Digit Recognizer |
13,825,967 | PredictionString = []
for i in tqdm(range(PRED_FINAL.shape[0])) :
enc = encs[i]
prob = PRED_FINAL[i]
sub_string = []
for cid, p in enumerate(prob):
sub_string.append(' '.join([str(cid), f'{p:.5f}', enc]))
sub_string = ' '.join(sub_string)
PredictionString.append(sub_string )<create_dataframe> | print(tf.config.list_physical_devices('GPU'),'//',tf.test.is_built_with_cuda() ) | Digit Recognizer |
13,825,967 | df_pred = pd.DataFrame({
'ID': IDs,
'PredictionString': PredictionString
})
df_pred = df_pred.groupby(['ID'])['PredictionString'].apply(lambda x: ' '.join(x)).reset_index()<save_to_csv> | datagen = tf.keras.preprocessing.image.ImageDataGenerator(
rotation_range=12,
width_shift_range=0.12,
height_shift_range=0.12,
shear_range=0.12,
validation_split=0.2
) | Digit Recognizer |
13,825,967 | df_sub = df_sub[['ID', 'ImageWidth', 'ImageHeight']].merge(df_pred, on='ID', how="left")
df_sub.fillna('', inplace=True)
df_sub.to_csv('submission.csv', index=False )<install_modules> | training_generator = datagen.flow(X_train, y_train, batch_size=32,subset='training')
validation_generator = datagen.flow(X_train, y_train, batch_size=32,subset='validation' ) | Digit Recognizer |
13,825,967 | !pip install -q ".. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl"
!pip install -q ".. /input/hpapytorchzoozip/pytorch_zoo-master"
!pip install -q ".. /input/hpacellsegmentatormaster/HPA-Cell-Segmentation-master"
NUC_MODEL = '.. /input/hpacellsegmentatormodelweights/dpn_unet_nuclei_v1.pth'
CELL_MODEL =... | model=Sequential() | Digit Recognizer |
13,825,967 | segmentator = cellseg.CellSegmentator(
NUC_MODEL,
CELL_MODEL,
scale_factor=0.25,
padding=True,
multi_channel_model=True
)
<set_options> | model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',activation ='relu', input_shape =(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',activation ='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Drop... | Digit Recognizer |
13,825,967 | gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "...Physical GPUs,", len(logical_gpus), "Logical GPUs...
")
except RuntimeError as e:
prin... | model.compile(
loss="sparse_categorical_crossentropy",
optimizer=tf.keras.optimizers.RMSprop(lr=0.003, rho=0.9, epsilon=1e-08, decay=0.0),
metrics=["accuracy"]
) | Digit Recognizer |
13,825,967 | RGB_model = keras.models.load_model('.. /input/hpa-models-2021/ProteinModelRGB_rev_18.h5')
G_model = keras.models.load_model('.. /input/hpa-models-2021/GreentileProteinModel_rev_2.h5')
multicellmodel = keras.models.load_model('.. /input/hpa-models-2021/Full_image_greenModelRev9.h5', custom_objects={'FixedDropout':Fix... | cb=tf.keras.callbacks.EarlyStopping(patience=10,restore_best_weights=True)
learning_rate_reduction = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
13,825,967 | remove_small_holes, remove_small_objects)
def label_cell(nuclei_pred, cell_pred):
def __wsh(
mask_img,
threshold,
border_img,
seeds,
threshold_adjustment=0.35,
small_object_size_cutoff=10,
):
img_copy = np.copy(mask_img)
m = seeds * border_img
img_copy[m <= threshold + threshold_adjustment] = 0
img_copy[m > thres... | model.fit(training_generator,epochs=100,callbacks=[cb,learning_rate_reduction],validation_data=validation_generator ) | Digit Recognizer |
13,825,967 | def build_image_names(image_id: str)-> list:
mt = f'/kaggle/input/hpa-single-cell-image-classification/test/{image_id}_red.png'
er = f'/kaggle/input/hpa-single-cell-image-classification/test/{image_id}_yellow.png'
nu = f'/kaggle/input/hpa-single-cell-image-classification/test/{image_id}_blue.png'
high = f'/kaggle/input... | model.evaluate(X_test, y_test ) | Digit Recognizer |
13,825,967 | start = time.time()
test_dir = '.. /input/hpa-single-cell-image-classification/test/'
test_images = os.listdir(test_dir)
images = [i.split("_")[0] for i in test_images]
names = np.unique(images)
public = len(names)==559
if public:
print('...only public testset...')
names = names[0:2]<save_to_csv> | pred_Data=np.array(pd.read_csv('.. /input/digit-recognizer/test.csv')/ 255.)
X_pred=pred_Data.reshape(( -1,28,28,1)) | Digit Recognizer |
13,825,967 | sub.to_csv("/kaggle/working/submission.csv", index=False )<import_modules> | predictions=model.predict_classes(X_pred ) | Digit Recognizer |
13,825,967 | <prepare_x_and_y><EOS> | submit=pd.DataFrame({'ImageId':range(1,len(predictions)+1),'Label':predictions})
submit.to_csv('submission.csv',index=False ) | Digit Recognizer |
13,423,365 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | warnings.filterwarnings('ignore')
sns.set_context("paper", font_scale = 1, rc={"grid.linewidth": 3})
pd.set_option('display.max_rows', 100, 'display.max_columns', 400)
| Digit Recognizer |
13,423,365 | from sklearn.model_selection import StratifiedKFold
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.calibration import CalibratedClassifierCV<split> | train_data=pd.read_csv('.. /input/digit-recognizer/train.csv')
test_data=pd.read_csv('.. /input/digit-recognizer/test.csv')
sample_data = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
13,423,365 | np.random.seed(0)
n_folds = 10
shuffle = False
if shuffle:
idx = np.random.permutation(y.size)
X = X[idx]
y = y[idx]
skf = list(StratifiedKFold(n_folds ).split(X, y))
clfs = [RandomForestClassifier(n_estimators=1000, n_jobs=-1, criterion='gini'),
RandomForestClassifier(n_estimators=1000, n_jobs=-1, criterion='entropy... | train_df = train_data.iloc[:, 1:].values
y_train = train_data.iloc[:, 0].values
test_df = test_data.values | Digit Recognizer |
13,423,365 | clf = LogisticRegression()
clf.fit(dataset_blend_train, y)
y_submission = clf.predict_proba(dataset_blend_test)[:, 1]
y_submission =(y_submission - y_submission.min())/(y_submission.max() - y_submission.min())
tmp = np.vstack([range(1, len(y_submission)+ 1), y_submission] ).T
np.savetxt(fname='submission.csv', X=tmp,... | img_tform_1 = transforms.Compose([
transforms.ToPILImage() ,transforms.ToTensor() ,transforms.Normalize(( 0.5),(0.5)) ])
img_tform_2 = transforms.Compose([
transforms.ToPILImage() ,transforms.RandomRotation(10),transforms.ToTensor() ,transforms.Normalize(( 0.5),(0.5)) ])
img_tform_3 = transforms.Compose([
transforms.... | Digit Recognizer |
13,423,365 | !pip install /kaggle/input/kerasapplications -q
!pip install /kaggle/input/efficientnet-keras-source-code/ -q --no-deps<install_modules> | class MnistDataset(Dataset):
def __init__(self, features,transform=img_tform_1):
self.features = features.iloc[:,1:].values.reshape(( -1,28,28)).astype(np.uint8)
self.targets = torch.from_numpy(features.label.values)
self.transform=transform
def __len__(self):
return(self.features.shape[0])
def __getitem__(self, idx... | Digit Recognizer |
13,423,365 | 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... | def create_dataloaders(seed, test_size=0.1, df=train_data, batch_size=32):
train_df, val_df = train_test_split(df,test_size=test_size,random_state=seed)
train_data_1 = MnistDataset(train_df)
train_data_2 = MnistDataset(train_df, img_tform_2)
train_data_3 = MnistDataset(train_df, img_tform_3)
train_data_4 = MnistDat... | Digit Recognizer |
13,423,365 | !cp -r.. /input/focallosstensorflowstablefromartemmavrin/focal-loss-master/*./
!pip install./focal-loss-master/<choose_model_class> | class Model(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3),
nn.BatchNorm2d(32),
nn.LeakyReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=3),
nn.BatchNorm2d(32),
nn.LeakyReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=5, stride=2, padding=14),
nn.BatchN... | Digit Recognizer |
13,423,365 | def binary_focal_loss(gamma=2, alpha=0.25):
alpha = tf.constant(alpha, dtype=tf.float32)
gamma = tf.constant(gamma, dtype=tf.float32)
def binary_focal_loss_fixed(y_true, y_pred):
y_true = tf.cast(y_true, tf.float32)
alpha_t = y_true*alpha +(K.ones_like(y_true)-y_true)*(1-alpha)
p_t = y_true*y_pred +(K.ones_like... | def train_fn(model, optimizer, scheduler, loss_fn, dataloader, device):
model.train()
final_loss = 0
train_acc=0
total=0
train_preds=[]
for features,labels in dataloader:
optimizer.zero_grad()
inputs, targets = features.to(device), labels.to(device)
outputs = model(inputs)
loss = loss_fn(outputs, targets)
loss.backw... | Digit Recognizer |
13,423,365 | 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-models/resultsv7/ebnet_b2_wdensehead/ckpt-0006-0.0924.ckpt"
DATA_DIR = "/kaggle/input/hpa-single-cell-image-classi... | DEVICE =('cuda' if torch.cuda.is_available() else 'cpu')
EPOCHS = 12
BATCH_SIZE = 128
LEARNING_RATE = 1e-3
WEIGHT_DECAY = 1e-8
seed=42
| Digit Recognizer |
13,423,365 | 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 ... | def run_training(seed):
train_loader, valid_loader= create_dataloaders(seed=seed)
model=Model()
model.to(DEVICE)
optimizer = torch.optim.Adam(model.parameters() , lr=LEARNING_RATE,weight_decay=WEIGHT_DECAY)
scheduler = optim.lr_scheduler.OneCycleLR(optimizer=optimizer, pct_start=0.1, div_factor=1e2,
max_lr=1e-2, epo... | Digit Recognizer |
13,423,365 | inference_model = tf.keras.models.load_model(B2_CELL_CLSFR_DIR)
IMAGE_SIZES = [1728, 2048, 3072, 4096]
BATCH_SIZE = 20
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_3... | pred_df = sample_data.copy()
run_training(seed)
| Digit Recognizer |
13,423,365 | 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... | final_pred = pred_df['predict']
sample_data.Label = final_pred.astype(int)
sample_data.head() | Digit Recognizer |
13,423,365 | 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"])
display(ss_df)
torch.cuda.empty_cache()<categorify> | sample_data.to_csv('./submission.csv', index=False ) | Digit Recognizer |
13,673,359 | def auto_select_accelerator() :
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
print("Running on TPU:", tpu.master())
except ValueError:
strategy = tf.... | data_train = pd.read_csv(".. /input/digit-recognizer/train.csv")
X_test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
13,673,359 | HPA_MODELS = False
COMPETITION_NAME = "hpa-single-cell-image-classification"
strategy = auto_select_accelerator()
BATCH_SIZE = strategy.num_replicas_in_sync * 16
IMSIZE =(224, 240, 260, 300, 380, 456, 528, 600, 720)
load_dir = f"/kaggle/input/{COMPETITION_NAME}/"
sub_df = pd.read_csv('.. /input/hpa-single-cell-image-c... | X, y = data_train.drop(labels = ["label"],axis = 1)/255.,data_train["label"]
X_test = X_test/255 . | Digit Recognizer |
13,673,359 | !pip install /kaggle/input/kerasapplications -q
!pip install /kaggle/input/efficientnet-keras-source-code/ -q --no-deps<install_modules> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.3,
min_lr=0.00001)
early_stopping = EarlyStopping(
min_delta=0.000001,
patience=20,
restore_best_weights=True,
) | Digit Recognizer |
13,673,359 | 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... | skf = StratifiedKFold(n_splits=3,random_state=42,shuffle=True)
sub = pd.DataFrame(data=None, index=(range(1,28001)) , columns=None, dtype=None, copy=False)
for train_index, val_index in skf.split(X, y):
model = keras.Sequential([
keras.layers.Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',
activation ='relu... | Digit Recognizer |
13,673,359 | !cp -r.. /input/focallosstensorflowstablefromartemmavrin/focal-loss-master/*./
!pip install./focal-loss-master/<choose_model_class> | sub["result"] = sub.mode(dropna=True,axis=1)[0]
result = pd.Series(sub["result"],name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),result],axis = 1)
submission = submission.dropna().astype('int32')
submission.to_csv("mnist_ansamble_of_cnn.csv",index=False ) | Digit Recognizer |
14,315,639 | def binary_focal_loss(gamma=2, alpha=0.25):
alpha = tf.constant(alpha, dtype=tf.float32)
gamma = tf.constant(gamma, dtype=tf.float32)
def binary_focal_loss_fixed(y_true, y_pred):
y_true = tf.cast(y_true, tf.float32)
alpha_t = y_true*alpha +(K.ones_like(y_true)-y_true)*(1-alpha)
p_t = y_true*y_pred +(K.ones_like... | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
images_train, images_val = train_test_split(train, test_size=0.3)
label_train = images_train['label']
label_val = images_val['label']
images_train = images_train.drop(['label'],axis = 1)
images_val = images_val.drop(['label'],axis = 1)
label_train = pd... | Digit Recognizer |
14,315,639 | 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-models/HPA - Cellwise Classification TRAINING/ebnet_b2_wdensehead/ckpt-0007-0.0901.ckpt"
DATA_DIR = "/kaggle/input... | model2 = models.Sequential()
model2.add(layers.Conv2D(filters = 128, kernel_size=(5, 5), activation='relu', padding='same', input_shape =(28, 28, 1)))
model2.add(layers.BatchNormalization())
model2.add(layers.Conv2D(filters = 64, kernel_size=(5, 5), activation='relu', padding='same', input_shape =(28, 28, 1)))
model... | Digit Recognizer |
14,315,639 | <define_variables><EOS> | images_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
images_test =(images_test.values ).astype('float32')
images_test = images_test.reshape(images_test.shape[0], 28, 28, 1)
y_pred = model2.predict(images_test)
y_pred = pd.DataFrame(y_pred)
y_pred = pd.Series(y_pred.idxmax(axis=1),index=y_pred.index... | Digit Recognizer |
14,227,432 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<create_dataframe> | import numpy as np
import pandas as pd
from matplotlib import pyplot as plt | Digit Recognizer |
14,227,432 | 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... | train_data = pd.read_csv('.. /input/digit-recognizer/train.csv')
test_data = pd.read_csv('.. /input/digit-recognizer/test.csv')
train_data.head() | Digit Recognizer |
14,227,432 | 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"])
display(ss_df)
torch.cuda.empty_cache()<categorify> | train_labels = train_data['label']
train_data = train_data.drop('label', axis=1 ) | Digit Recognizer |
14,227,432 | def auto_select_accelerator() :
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
print("Running on TPU:", tpu.master())
except ValueError:
strategy = tf.... | encoder = LabelBinarizer()
train_labels = encoder.fit_transform(train_labels ) | Digit Recognizer |
14,227,432 | HPA_MODELS = False
COMPETITION_NAME = "hpa-single-cell-image-classification"
strategy = auto_select_accelerator()
BATCH_SIZE = strategy.num_replicas_in_sync * 16
IMSIZE =(224, 240, 260, 300, 380, 456, 528, 600, 720)
load_dir = f"/kaggle/input/{COMPETITION_NAME}/"
sub_df = pd.read_csv('.. /input/hpa-single-cell-image-c... | train_data = train_data.astype('float32')/ 255
test_data = test_data.astype('float32')/ 255 | Digit Recognizer |
14,227,432 | !pip install /kaggle/input/iterative-stratification/iterative-stratification-master/<install_modules> | train_data = train_data[:, :, :, np.newaxis]
test_data = test_data[:, :, :, np.newaxis] | Digit Recognizer |
14,227,432 |
<define_variables> | X_train, X_val, y_train, y_val = train_test_split(train_data, train_labels, test_size=0.1, random_state=157, stratify=train_labels ) | Digit Recognizer |
14,227,432 | package_path = '.. /input/efficientnet-pytorch/EfficientNet-PyTorch/EfficientNet-PyTorch-master'
sys.path.append(package_path)
<import_modules> | data_generator = 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=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1
)
data_g... | Digit Recognizer |
14,227,432 | import pandas as pd
import numpy as np
from fastai.vision.all import *
import pickle
import os<import_modules> | init_relu = he_uniform(seed=157)
init_tanh = glorot_uniform(seed=157)
model = Sequential()
model.add(Conv2D(name='Conv_1', input_shape=(28, 28, 1), filters=64, kernel_size=(3, 3), padding='same', kernel_initializer=init_relu, kernel_constraint=maxnorm(3)))
model.add(BatchNormalization())
model.add(Activation(relu))... | Digit Recognizer |
14,227,432 |
<define_variables> | os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = ""
os.environ['PYTHONHASHSEED'] = str(157)
random.seed(157)
np.random.seed(157)
tf.compat.v1.set_random_seed(157)
session_conf = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1,
inter_op_parallelism_threads=1)
sess = tf.com... | Digit Recognizer |
14,227,432 | path = Path('.. /input/hpa-cell-tiles-sample-balanced-dataset' )<load_from_csv> | lr = 0.001
opt = Adam(learning_rate=lr, amsgrad=True)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
checkpoint = ModelCheckpoint('neural_network_checkpoint_training.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='min')
lr_decay = LearningRateScheduler(lambda x: lr... | Digit Recognizer |
14,227,432 | df = pd.read_csv(path/'cell_df.csv' )<feature_engineering> | clf = load_model('neural_network_checkpoint_training.h5')
prediction = clf.predict(test_data)
prediction = pd.DataFrame(np.argmax(prediction, axis=-1), columns=['Label'])
img_idx = pd.DataFrame(np.arange(1, len(prediction)+ 1), columns=['ImageId'])
prediction = pd.concat([img_idx, prediction], axis=1)
prediction.t... | Digit Recognizer |
14,079,394 | labels = [str(i)for i in range(19)]
for x in labels: df[x] = df['image_labels'].apply(lambda r: int(x in r.split('|')) )<count_unique_values> | !curl https://raw.githubusercontent.com/pytorch/xla/master/contrib/scripts/env-setup.py -o pytorch-xla-env-setup.py | Digit Recognizer |
14,079,394 | unique_counts = {}
for lbl in labels:
unique_counts[lbl] = len(dfs[dfs.image_labels == lbl])
full_counts = {}
for lbl in labels:
count = 0
for row_label in dfs['image_labels']:
if lbl in row_label.split('|'): count += 1
full_counts[lbl] = count
counts = list(zip(full_counts.keys() , full_counts.values() , unique_count... | !python pytorch-xla-env-setup.py | Digit Recognizer |
14,079,394 | nfold = 5
seed = 42
y = dfs[labels].values
X = dfs[['image_id', 'cell_id']].values
dfs['fold'] = np.nan
mskf = MultilabelStratifiedKFold(n_splits=nfold, random_state=seed)
for i,(_, test_index)in enumerate(mskf.split(X, y)) :
dfs.iloc[test_index, -1] = i
dfs['fold'] = dfs['fold'].astype('int' )<feature_engineering> | !pip install pytorch_lightning --quiet | Digit Recognizer |
14,079,394 | dfs['is_valid'] = False
dfs['is_valid'][dfs['fold'] == 0] = True<count_values> | torch_xla._XLAC._xla_get_devices() | Digit Recognizer |
14,079,394 | dfs.is_valid.value_counts()<prepare_x_and_y> | torch.manual_seed(100)
np.random.seed(100 ) | Digit Recognizer |
14,079,394 | def get_y(r): return r['image_labels'].split('|')
get_y(dfs.loc[12] )<define_variables> | df = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df.iloc[:3,:10] | Digit Recognizer |
14,079,394 | sample_stats =([0.07237246, 0.04476176, 0.07661699], [0.17179589, 0.10284516, 0.14199627] )<define_variables> | df_train, df_val = train_test_split(df, test_size=.1, stratify=df.label ) | Digit Recognizer |
14,079,394 | dls.show_batch(nrows=3, ncols=3 )<choose_model_class> | def toX(df):
return df.values.astype(np.float32 ).reshape(-1,1,28,28)/ 127.5 - 1.
class MnistDataLoader(object):
def __init__(self, df, bs):
self.X = toX(df.iloc[:, 1:])
self.y = df.values[:, 0]
self.bs = bs
self.n_batches = int(np.ceil(df.shape[0] / bs))
def __len__(self):
return self.n_batches
def __iter__(self):
m... | Digit Recognizer |
14,079,394 | def get_learner(lr=1e-3):
opt_func = partial(Adam, lr=lr, wd=0.01, eps=1e-8)
model = EfficientNet.from_pretrained("efficientnet-b5", advprop=True)
model._fc = nn.Linear(2048, dls.c)
learn = Learner(
dls, model, opt_func=opt_func,
metrics=[accuracy_multi, PrecisionMulti() ]
).to_fp16()
return learn
<choose_model_cl... | class ResnetBlock(nn.Module):
def __init__(self, channels):
super(ResnetBlock, self ).__init__()
self.conv = nn.Sequential(
nn.Conv2d(channels, channels, 3, 1, 1, bias=False),
nn.BatchNorm2d(channels),
nn.ReLU() ,
nn.Conv2d(channels, channels, 3, 1, 1, bias=False),
nn.BatchNorm2d(channels))
def forward(self, x):
x = F... | Digit Recognizer |
14,079,394 | learn=get_learner()<find_best_params> | class MnistModule(pl.LightningModule):
def __init__(self):
super().__init__()
self.model = MiniResnet()
self.loss_fn = nn.CrossEntropyLoss()
def forward(self, X):
return self.model(X)
def training_step(self, batch, batch_i):
X, y = batch
h = self.model(X)
loss = self.loss_fn(h, y)
self.log('train_loss', loss, on_ste... | Digit Recognizer |
14,079,394 | learn.lr_find()<define_search_space> | x = torch.tensor(val_dl.X, device=module.device)
h = module.predict(x ).cpu().numpy() | Digit Recognizer |
14,079,394 | lr=3e-2<find_best_params> | y_hat = h.argmax(1)
(y_hat == val_dl.y ).mean() | Digit Recognizer |
14,079,394 | learn.fine_tune(6,base_lr=lr )<import_modules> | df_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
df_sub = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
14,079,394 | from sklearn.metrics import multilabel_confusion_matrix as cm<split> | X = torch.tensor(toX(df_test), device = module.device)
%time preds = module.predict(X ) | Digit Recognizer |
14,079,394 | val_targ = dfs[labels][dfs.is_valid == True].values<predict_on_test> | df_sub['Label'] = preds.argmax(1 ).cpu().numpy()
df_sub.to_csv('submission.csv', index=False ) | Digit Recognizer |
14,079,394 | <data_type_conversions><EOS> | !rm *.whl
!rm *.py
!rm *.ckpt
!ls | Digit Recognizer |
14,110,957 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Conv2D, MaxPool2D, Activation, Dropout, Flatten, Dense, BatchNormalization
from keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection imp... | Digit Recognizer |
14,110,957 | val_preds = val_preds > 0.5<data_type_conversions> | df = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
print(df.shape)
print(test.shape)
print(df.head() ) | Digit Recognizer |
14,110,957 | full_preds = val_preds_all[0].numpy()<compute_test_metric> | labels = df["label"]
X = df.drop('label', axis = 1)
print(labels.value_counts())
print("Baseline Accuracy: " + str(round(labels.value_counts().max() /labels.value_counts().sum() ,3)) ) | Digit Recognizer |
14,110,957 | vis_arr = cm(val_targ, val_preds )<filter> | def normalizeANDreshape(df, minimum, maximum):
diff = maximum - minimum
zero_min = df - minimum
adjusted = zero_min/diff
shaped = adjusted.values.reshape(-1,28,28,1)
return shaped
print(np.max(normalizeANDreshape(X, 0, 255)))
print(np.min(normalizeANDreshape(X, 0, 255)))
print(type(normalizeANDreshape(X, 0, 255)))
... | Digit Recognizer |
14,110,957 | val = dfs[dfs.is_valid==True]
len(val[val['16'] == 1] )<compute_test_metric> | y = pd.get_dummies(labels)
y.head() | Digit Recognizer |
14,110,957 | average_precision = average_precision_score(val_targ, val_preds)
average_precision<find_best_params> | X_train, X_val, y_train, y_val = train_test_split(normalizeANDreshape(X, 0, 255), y, test_size = 0.20 ) | Digit Recognizer |
14,110,957 | precision = dict()
recall = dict()
average_precision = dict()
for i in range(19):
precision[i], recall[i], _ = precision_recall_curve(val_targ[:, i], val_preds[:, i])
average_precision[i] = average_precision_score(val_targ[:, i], val_preds[:, i])
precision["micro"], recall["micro"], _ = precision_recall_curve(val_tar... | augment = ImageDataGenerator(rotation_range = 15,
width_shift_range = 0.35,
height_shift_range = 0.35,
zoom_range = 0.2,
)
augment.fit(X_train ) | Digit Recognizer |
14,110,957 | path = Path('.. /input/hpa-cell-tiles-test-with-enc-dataset' )<load_from_csv> | def makeCNN(shape):
model = Sequential()
model.add(Conv2D(filters = 64, kernel_size =(4,4), padding = 'same', activation = 'relu', input_shape = shape))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(BatchNormalization())
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, kernel_size =(3,3), padding = 'same', a... | Digit Recognizer |
14,110,957 | df = pd.read_csv(path/'cell_df.csv' )<save_to_csv> | model.compile(optimizer = Adam() ,
loss = 'categorical_crossentropy',
metrics = 'accuracy' ) | Digit Recognizer |
14,110,957 | df.to_csv('cell_df.csv', index=False )<train_model> | epochs = 50
batch_size = 64
history = model.fit_generator(augment.flow(X_train,y_train, batch_size=batch_size),
epochs = epochs,
steps_per_epoch=len(X_train)// batch_size,
validation_data =(X_val,y_val),
verbose = 1,
use_multiprocessing = True,
workers = 2
) | Digit Recognizer |
14,110,957 | test_dl = learn.dls.test_dl(df )<define_variables> | validation_predictions = model.predict_classes(X_val)
confusion = confusion_matrix(validation_predictions,y_val.idxmax(axis=1))
print(confusion ) | Digit Recognizer |
14,110,957 | test_dl.show_batch()<predict_on_test> | test = normalizeANDreshape(test, 0, 255)
predictions = model.predict_classes(test)
print(predictions[0:5] ) | Digit Recognizer |
14,110,957 | preds, _ = learn.get_preds(dl=test_dl )<load_pretrained> | Id = []
for i in range(len(test)) :
Id.append(i+1)
output = pd.DataFrame({'ImageID': Id, 'Label': predictions})
output.to_csv('predictions.csv', index=False ) | Digit Recognizer |
11,475,252 | with open('preds.pickle', 'wb')as handle:
pickle.dump(preds, handle )<feature_engineering> | import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn.model_selection import train_test_split | Digit Recognizer |
11,475,252 | tta, _ = learn.tta(dl=test_dl )<save_to_csv> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,475,252 | with open('tta.pickle', 'wb')as handle:
pickle.dump(tta, handle )<prepare_output> | y = train["label"]
y = tf.keras.utils.to_categorical(y, num_classes=10)
image_id = list(test.index)
image_id = [i+1 for i in image_id]
train = train.drop("label", axis=1)
train = train.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1 ) | Digit Recognizer |
11,475,252 | cls_prds = torch.argmax(preds, dim=-1)
len(cls_prds), cls_prds<load_from_csv> | import keras, os
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPool2D, BatchNormalization, MaxPool2D
from keras.callbacks import ModelCheckpoint, EarlyStopping | Digit Recognizer |
11,475,252 | sample_submission = pd.read_csv('.. /input/hpa-single-cell-image-classification/sample_submission.csv')
sample_submission.head()<feature_engineering> | xtrain, xtest, ytrain, ytest = train_test_split(train, y, test_size=0.2)
xtrain, xval, ytrain, yval = train_test_split(xtrain, ytrain, test_size=0.25 ) | Digit Recognizer |
11,475,252 | df['cls'] = cls_prds
df['pred'] = df[['cls', 'enc']].apply(lambda r: str(r[0])+ ' 1 ' + r[1], axis=1)
df.head()<groupby> | class LRFinder:
def __init__(self, model):
self.model = model
self.losses = []
self.lrs = []
self.best_loss = 1e9
def on_batch_end(self, batch, logs):
lr = K.get_value(self.model.optimizer.lr)
self.lrs.append(lr)
loss = logs['loss']
self.losses.append(loss)
if math.isnan(loss)or loss > self.best_loss * 4:
self.mod... | Digit Recognizer |
11,475,252 | subm = df.groupby(['image_id'])['pred'].apply(lambda x: ' '.join(x)).reset_index()
subm.head()<merge> | def model() :
model = Sequential()
model.add(Conv2D(32, kernel_size = 3, activation='relu', input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 5, strides=2, padding='same', activation=... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.