kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,324,252 | MAX_SEQUENCE_LENGTH = 100
EMBEDDING_DIM = 300<data_type_conversions> | 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 |
13,324,252 | corpus = []
feats = ['question1','question2']
for f in feats:
train[f] = train[f].astype(str)
test[f] = test[f].astype(str)
corpus+=train[f].values.tolist()
tokenizer = Tokenizer()
tokenizer.fit_on_texts(corpus)
X_q1 = tokenizer.texts_to_sequences(train['question1'])
X_q2 = tokenizer.texts_to_sequences(train['quest... | model = load_model("./mod_best.hdf5" ) | Digit Recognizer |
13,324,252 | def get_coefs(word, *arr):
return word, np.asarray(arr, dtype='float32')
def load_embeddings(path):
with open(path)as f:
return dict(get_coefs(*line.strip().split(' ')) for line in tqdm(f))
def build_matrix(word_index, path):
embedding_index = load_embeddings(path)
embedding_matrix = np.zeros(( len(word_index)+ 1, 30... | batch_size = 128
epochs = 30
history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size = batch_size),
epochs = epochs, validation_data = datagen.flow(X_val,Y_val, batch_size = batch_size),
steps_per_epoch = X_train.shape[0] // batch_size,
callbacks = callbacks ) | Digit Recognizer |
13,324,252 | X_train_q1,X_val_q1,X_train_q2,X_val_q2,y_train,y_val = train_test_split(X_q1,X_q2,y,train_size=0.8,random_state=1024)
print(X_train_q1.shape,X_val_q1.shape)
X_train = [X_train_q1,X_train_q2]
X_val = [X_val_q1,X_val_q2]
X_test = [X_test_q1,X_test_q2]<categorify> | score = model.evaluate(X_val, Y_val, verbose=0)
print("Val_Loss :",score[0])
print("Val_Acc :",score[1] ) | Digit Recognizer |
13,324,252 | input_q1 = Input(shape = X_train[0].shape[1])
input_q2 = Input(shape = X_train[0].shape[1])
embedding_layer = Embedding(nb_words,
EMBEDDING_DIM,
input_length = X_train[0].shape[1],
weights = [embedding_matrix],
trainable=False)
embedded_sequences_q1 = embedding_layer(input_q1)
embedded_sequences_q2 = embedding_laye... | probabilities = model.predict(test)
y_pred = np.argmax(probabilities, axis=1)
print(y_pred.shape ) | Digit Recognizer |
13,324,252 | <save_to_csv><EOS> | submission = pd.DataFrame({'ImageId': np.arange(1, 28001), 'Label': y_pred})
submission.to_csv("submission.csv", index = False)
print("Your submission was successfully saved!" ) | Digit Recognizer |
14,235,927 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | print(tf.__version__)
| Digit Recognizer |
14,235,927 | le = LabelEncoder()
pd.set_option('display.max_rows', 400)
pd.set_option('display.max_columns', 160)
pd.set_option('display.max_colwidth', 40)
warnings.filterwarnings("ignore" )<load_from_csv> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
14,235,927 | test = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/test.csv')
test.head()<load_from_csv> | cut=0
nets = 15
epochs = 45
| Digit Recognizer |
14,235,927 | categories = pd.read_csv('.. /input/predict-future-sales-eng-translation/categories.csv')
pd.DataFrame(categories.category_name.values.reshape(-1, 4))<categorify> | if cut > 0:
n_train=round(cut*train.shape[0])
train = train[:n_train]
Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
X_train = X_train / 255.0
X_test = test / 255.0
X_train = X_train.values.reshape(-1,28,28,1)
X_test = X_test.values.reshape(-1,28,28,1)
Y_train = to_categorical(Y_train, n... | Digit Recognizer |
14,235,927 | categories['group_name'] = categories['category_name'].str.extract(r'(^[\w\s]*)')
categories['group_name'] = categories['group_name'].str.strip()
categories['group_id'] = le.fit_transform(categories.group_name.values)
categories.sample(5 )<load_from_csv> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.10,
width_shift_range=0.15,
height_shift_range=0.15 ) | Digit Recognizer |
14,235,927 | items = pd.read_csv('.. /input/predict-future-sales-eng-translation/items.csv')
items['item_name'] = items['item_name'].str.lower()
items['item_name'] = items['item_name'].str.replace('.', '')
for i in [r'[^\w\d\s\.]', r'\bthe\b', r'\bin\b', r'\bis\b',
r'\bfor\b', r'\bof\b', r'\bon\b', r'\band\b',
r'\bto\b', r'\bwith... | DEVICE = 'TPU'
if DEVICE == 'TPU':
print('connecting to TPU...')
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
print('Could not connect to TPU')
tpu = None
if tpu:
try:
print('Initializing TPU...')
tf.config.experimental_connect_to_cluster(t... | Digit Recognizer |
14,235,927 | dupes = items[(items.duplicated(subset=['item_name','category_id'],keep=False)) ]
dupes['in_test'] = dupes.item_id.isin(test.item_id.unique())
dupes = dupes.groupby('item_name' ).agg({'item_id':['first','last'],'in_test':['first','last']})
dupes = dupes[(dupes[('in_test', 'first')]==False)|(dupes[('in_test', 'last')]... | with distribution_strategy.scope() :
model = [0] *nets
for j in range(nets):
model[j] = Sequential()
model[j].add(Conv2D(32, kernel_size = 3, activation='relu', input_shape =(28, 28, 1)))
model[j].add(BatchNormalization())
model[j].add(Conv2D(32, kernel_size = 3, activation='relu'))
model[j].add(BatchNormalization())... | Digit Recognizer |
14,235,927 | sales = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/sales_train.csv')
sales =(sales
.query('0 < item_price < 50000 and 0 < item_cnt_day < 1001')
.replace({
'shop_id':{0:57, 1:58, 11:10},
'item_id':item_map
})
)
sales = sales[sales['shop_id'].isin(test.shop_id.unique())]
sales['date'] = pd.to... | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [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)
history[j] = model[j].fit_generator(datagen.flow(X_train2,Y_train2, batch_size=64),
epochs = epochs, steps_per_epoch = X_trai... | Digit Recognizer |
14,235,927 | temp = sales.groupby(['shop_id','weekday'] ).agg({'item_cnt_day':'sum'} ).reset_index()
temp = pd.merge(temp, sales.groupby(['shop_id'] ).agg({'item_cnt_day':'sum'} ).reset_index() , on='shop_id', how='left')
temp.columns = ['shop_id','weekday', 'shop_day_sales', 'shop_total_sales']
temp['day_quality'] = temp['shop_da... | results = np.zeros(( X_test.shape[0],10))
for j in range(nets):
results = results + model[j].predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission.csv",index=... | Digit Recognizer |
14,238,959 | sales =(sales
.groupby(['date_block_num', 'shop_id', 'item_id'])
.agg({
'item_cnt_day':'sum',
'revenue':'sum',
'first_sale_day':'first'
})
.reset_index()
.rename(columns={'item_cnt_day':'item_cnt'})
)
sales.sample(5 )<drop_column> | from __future__ import print_function, division
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
from torchvision import models, transforms
import matplotlib.pyplot as plt
import time
import copy
import pandas as pd
from sklearn.model_selection import train_test_split
... | Digit Recognizer |
14,238,959 | test['date_block_num'] = 34
del test['ID']<concatenate> | class MyDataset(Dataset):
def __init__(self, feature, target=None, transform=None):
self.X = feature
self.Y = target
self.transform = transform
def __len__(self):
return len(self.X)
def __getitem__(self, idx):
if self.transform is not None:
return self.transform(self.X[idx]), self.Y[idx]
elif self.Y is None:
return [s... | Digit Recognizer |
14,238,959 | df = pd.concat([df,test] ).fillna(0)
df = df.reset_index()
del df['index']<merge> | train_data_dir = ".. /input/digit-recognizer/train.csv"
test_data_dir = ".. /input/digit-recognizer/test.csv"
train = pd.read_csv(train_data_dir)
test = pd.read_csv(test_data_dir)
raw_train_labels = train["label"]
raw_train_imgs = train.drop(labels = ["label"], axis = 1)
normalized_train = raw_train_imgs/255.0
norma... | Digit Recognizer |
14,238,959 | df = pd.merge(df, sales, on=['shop_id', 'item_id', 'date_block_num'], how='left' ).fillna(0)
df = pd.merge(df, dates, on=['date_block_num','shop_id'], how='left')
df = pd.merge(df, items.drop(columns=['item_name','group_name','category_name']), on='item_id', how='left' )<feature_engineering> | data = next(iter(train_loader))
mean = data[0].mean()
std = data[0].std()
transform = transforms.Compose([
transforms.ToPILImage() ,
transforms.RandomAffine(degrees = 30),
transforms.RandomPerspective() ,
transforms.ToTensor() ,
transforms.Normalize(mean, std)])
augmented_train_set = MyDataset(train_data.float() , tra... | Digit Recognizer |
14,238,959 | shops = pd.read_csv('.. /input/predict-future-sales-eng-translation/shops.csv')
shops_cats = pd.DataFrame(
np.array(list(product(*[df['shop_id'].unique() , df['category_id'].unique() ]))),
columns =['shop_id', 'category_id']
)
temp = df.groupby(['category_id', 'shop_id'] ).agg({'item_cnt':'sum'} ).reset_index()
tem... | device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
dataloaders = {'train': train_loader, 'val': valid_loader}
dataset_sizes= {'train': len(train_set), 'val': len(valid_set)}
def train_model(model, criterion, optimizer, scheduler, dataloaders, dataset_sizes, num_epochs=25):
since = time.time()
best... | Digit Recognizer |
14,238,959 | shops.dropna(inplace=True)
shops['shop_name'] = shops['shop_name'].str.lower()
shops['shop_name'] = shops['shop_name'].str.replace(r'[^\w\d\s]', ' ')
shops['shop_type'] = 'regular'
shops.loc[shops['shop_name'].str.contains(r'tc'), 'shop_type'] = 'tc'
shops.loc[shops['shop_name'].str.contains(r'mall|center|mega'), 'sh... | epochs = 20
model_ft = models.resnet18(pretrained=False)
model_ft.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 10)
model_ft = model_ft.to(device)
criterion = nn.CrossEntropyLoss()
optimizer_ft = optim.Ada... | Digit Recognizer |
14,238,959 | df = pd.merge(df, shops.drop(columns='shop_name'), on='shop_id', how='left')
df.head()<feature_engineering> | test_pred = torch.LongTensor()
with torch.no_grad() :
for images in test_loader:
images = torch.autograd.Variable(images[0])
if torch.cuda.is_available() :
images = images.to(device)
outputs = model_ft(images)
predicted = outputs.cpu().data.max(1, keepdim=True)[1]
test_pred = torch.cat(( test_pred, predicted), dim=0... | Digit Recognizer |
14,238,959 | df['first_sale_day'] = df.groupby('item_id')['first_sale_day'].transform('max' ).astype('int16')
df.loc[df['first_sale_day']==0, 'first_sale_day'] = 1035
df['prev_days_on_sale'] = [max(idx)for idx in zip(df['first_day_of_month']-df['first_sale_day'],[0]*len(df)) ]
del df['first_day_of_month']<drop_column> | out_df = pd.DataFrame(np.c_[np.arange(1, len(test_set)+1)[:,None], test_pred.numpy() ],
columns=['ImageId', 'Label'])
out_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
13,971,433 | del sales, categories, shops, shops_cats, temp, temp2, test, dupes, item_map,
df.head()<feature_engineering> | train_path = "/kaggle/input/digit-recognizer/train.csv"
test_path = "/kaggle/input/digit-recognizer/test.csv"
sample_submission_path = "/kaggle/input/digit-recognizer/sample_submission.csv" | Digit Recognizer |
13,971,433 | df['item_cnt_unclipped'] = df['item_cnt']
df['item_cnt'] = df['item_cnt'].clip(0, 20 )<data_type_conversions> | train = pd.read_csv(train_path)
test = pd.read_csv(test_path)
sample_submission = pd.read_csv(sample_submission_path ) | Digit Recognizer |
13,971,433 | def downcast(df):
float_cols = [c for c in df if df[c].dtype in ["float64"]]
int_cols = [c for c in df if df[c].dtype in ['int64']]
df[float_cols] = df[float_cols].astype('float32')
df[int_cols] = df[int_cols].astype('int16')
return df
df = downcast(df )<data_type_conversions> | import torch
from torchvision.transforms import Normalize
from torch.utils.data import Dataset, DataLoader, random_split
from tqdm.notebook import tqdm | Digit Recognizer |
13,971,433 | df['item_age'] =(df['date_block_num'] - df.groupby('item_id')['date_block_num'].transform('min')).astype('int8')
df['item_name_first4_age'] =(df['date_block_num'] - df.groupby('item_name_first4')['date_block_num'].transform('min')).astype('int8')
df['item_name_first6_age'] =(df['date_block_num'] - df.groupby('item_na... | class LoadImagesLabels(Dataset):
def __init__(self, data_frame, stats = None, kind="train"):
self.stats = stats
self.kind = kind
self.imgs, self.labels = self.get_data(data_frame)
def get_data(self, data_frame):
imgs = np.zeros(shape=(data_frame.shape[0], 1, 28, 28), dtype=np.float32)
labels = None
if self.kind != "t... | Digit Recognizer |
13,971,433 | temp = df.query('item_cnt > 0' ).groupby(['item_id','shop_id'] ).agg({'date_block_num':'min'} ).reset_index()
temp.columns = ['item_id', 'shop_id', 'item_shop_first_sale']
df = pd.merge(df, temp, on=['item_id','shop_id'], how='left')
df['item_shop_first_sale'] = df['item_shop_first_sale'].fillna(50)
df['item_age_if_s... | dataset = LoadImagesLabels(train)
train_dataset, val_dataset = random_split(dataset,
[int(len(dataset)*0.7), len(dataset)-int(len(dataset)*0.7)])
test_dataset = LoadImagesLabels(test, dataset.stats, "test" ) | Digit Recognizer |
13,971,433 | def agg_cnt_col(df, merging_cols, new_col,aggregation):
temp = df.groupby(merging_cols ).agg(aggregation ).reset_index()
temp.columns = merging_cols + [new_col]
df = pd.merge(df, temp, on=merging_cols, how='left')
return df
df = agg_cnt_col(df, ['date_block_num','item_id'],'item_cnt_all_shops',{'item_cnt':'mean'})
df... | import matplotlib.pyplot as plt
import random | Digit Recognizer |
13,971,433 | def new_item_sales(df, merging_cols, new_col):
temp =(
df
.query('item_age==0')
.groupby(merging_cols)['item_cnt']
.mean()
.reset_index()
.rename(columns={'item_cnt': new_col})
)
df = pd.merge(df, temp, on=merging_cols, how='left')
return df
df = new_item_sales(df, ['date_block_num','category_id','shop_id'], 'ne... | train_dataloader = DataLoader(train_dataset, num_workers=multiprocessing.cpu_count() , shuffle=True, batch_size=2**6)
val_dataloader = DataLoader(val_dataset, num_workers=multiprocessing.cpu_count() , shuffle=False, batch_size=8 ) | Digit Recognizer |
13,971,433 | def agg_price_col(df, merging_cols, new_col):
temp = df.groupby(merging_cols ).agg({'revenue':'sum','item_cnt_unclipped':'sum'} ).reset_index()
temp[new_col] = temp['revenue']/temp['item_cnt_unclipped']
temp = temp[merging_cols + [new_col]]
df = pd.merge(df, temp, on=merging_cols, how='left')
return df
df = agg_price_... | import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import pytorch_lightning as pl
from torchvision import models
import pytorch_lightning.callbacks as pl_callbacks | Digit Recognizer |
13,971,433 | df = downcast(df )<merge> | class ClassificationModel(pl.LightningModule):
def __init__(self, learning_rate, weights=None):
super(ClassificationModel, self ).__init__()
self.learning_rate = learning_rate
self.loss = nn.CrossEntropyLoss(weight=weights)
pretrained_resnet = models.resnet18(pretrained=True)
self.encoder = nn.Sequential(
nn.Upsampl... | Digit Recognizer |
13,971,433 | def lag_feature(df, lag, col, merge_cols):
temp = df[merge_cols + [col]]
temp = temp.groupby(merge_cols ).agg({f'{col}':'first'} ).reset_index()
temp.columns = merge_cols + [f'{col}_lag{lag}']
temp['date_block_num'] += lag
df = pd.merge(df, temp, on=merge_cols, how='left')
df[f'{col}_lag{lag}'] = df[f'{col}_lag{lag}']... | trainer.fit(model, train_dataloader, val_dataloader ) | Digit Recognizer |
13,971,433 | lag12_cols = {
'item_cnt':['date_block_num', 'shop_id', 'item_id'],
'item_cnt_all_shops':['date_block_num', 'item_id'],
'category_cnt':['date_block_num', 'shop_id', 'category_id'],
'category_cnt_all_shops':['date_block_num', 'category_id'],
'group_cnt':['date_block_num', 'shop_id', 'group_id'],
'group_cnt_all_shops':['... | train_accuracy = pl.metrics.Accuracy(compute_on_step=False)
valid_accuracy = pl.metrics.Accuracy(compute_on_step=False)
train_predictions, train_real = [], []
valid_predictions, valid_real = [], []
model.eval()
model.cuda()
for x, y in tqdm(train_dataloader):
with torch.no_grad() :
y_pred = model(x.cuda())
train_acc... | Digit Recognizer |
13,971,433 | lag2_cols = {
'item_cnt_unclipped':['date_block_num', 'shop_id', 'item_id'],
'item_cnt_all_shops_median':['date_block_num', 'item_id'],
'category_cnt_median':['date_block_num', 'shop_id', 'category_id'],
'category_cnt_all_shops_median':['date_block_num', 'category_id']
}
for col in lag2_cols:
df = lag_feature(df, 1, co... | print("training accuracy", round(total_train_accuracy.item() * 100, 3), "%")
print("validation accuracy", round(total_valid_accuracy.item() * 100, 3), "%" ) | Digit Recognizer |
13,971,433 | df['item_cnt_diff'] = df['item_cnt_unclipped_lag1']/df['item_cnt_lag1to12']
df['item_cnt_all_shops_diff'] = df['item_cnt_all_shops_lag1']/df['item_cnt_all_shops_lag1to12']
df['category_cnt_diff'] = df['category_cnt_lag1']/df['category_cnt_lag1to12']
df['category_cnt_all_shops_diff'] = df['category_cnt_all_shops_lag1']/... | valid_matrix = confusion_matrix(valid_real, valid_predictions, labels=range(10))
train_matrix = confusion_matrix(train_real, train_predictions, labels=range(10)) | Digit Recognizer |
13,971,433 | df = lag_feature(df, 1, 'category_price',['date_block_num', 'category_id'])
df = lag_feature(df, 1, 'block_price',['date_block_num'])
del df['category_price'], df['block_price']<feature_engineering> | fail_images = []
real_labels, fail_labels = [], []
for x, y in tqdm(val_dataloader):
with torch.no_grad() :
y_pred = model(x.cuda())
y_pred = y_pred.argmax(dim=1 ).cpu()
mask =(y_pred == y ).numpy()
idxs = np.where(mask == False)[0]
if idxs.shape[0] > 0:
for idx in idxs:
fail_images.append(x[idx])
real_labels.append(... | Digit Recognizer |
13,971,433 | df.loc[(df['item_age']>0)&(df['item_cnt_lag1to12'].isna()), 'item_cnt_lag1to12'] = 0
df.loc[(df['category_age']>0)&(df['category_cnt_lag1to12'].isna()), 'category_cnt_lag1to12'] = 0
df.loc[(df['group_age']>0)&(df['group_cnt_lag1to12'].isna()), 'group_cnt_lag1to12'] = 0<feature_engineering> | model.to_torchscript("/kaggle/working/mnist_digit.torch.pt" ) | Digit Recognizer |
13,971,433 | df['item_cnt_lag1to12'] /= [min(idx)for idx in zip(df['item_age'],df['shop_age'],[12]*len(df)) ]
df['item_cnt_all_shops_lag1to12'] /= [min(idx)for idx in zip(df['item_age'],[12]*len(df)) ]
df['category_cnt_lag1to12'] /= [min(idx)for idx in zip(df['category_age'],df['shop_age'],[12]*len(df)) ]
df['category_cnt_all_shops... | submission = sample_submission.copy() | Digit Recognizer |
13,971,433 | df = downcast(df )<merge> | model.eval()
predicted_labels = []
for idx, img in tqdm(enumerate(test_dataset), total=len(test_dataset)) :
with torch.no_grad() :
y_predict = model(img.unsqueeze(0 ).cuda())
predicted_labels.append(y_predict.argmax(dim=1 ).cpu().item() ) | Digit Recognizer |
13,971,433 | def past_information(df, merging_cols, new_col, aggregation):
temp = []
for i in range(1,35):
block = df.query(f'date_block_num < {i}' ).groupby(merging_cols ).agg(aggregation ).reset_index()
block.columns = merging_cols + [new_col]
block['date_block_num'] = i
block = block[block[new_col]>0]
temp.append(block)
temp = ... | submission["Label"] = predicted_labels
submission.to_csv('/kaggle/working/submission.csv',index=False ) | Digit Recognizer |
13,971,433 | <data_type_conversions><EOS> | json.dump(stats, open('/kaggle/working/stats.json', 'w')) | Digit Recognizer |
11,420,133 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | %load_ext autoreload
%autoreload 2
np.random.seed(1)
w.filterwarnings('ignore' ) | Digit Recognizer |
11,420,133 | gc.collect()
df = downcast(df )<groupby> | train_file = pd.read_csv(os.path.join(main_path, "train.csv"))
test_file = pd.read_csv(os.path.join(main_path, "test.csv")) | Digit Recognizer |
11,420,133 | def matching_name_cat_age(df,n,all_shops):
temp_cols = [f'same_name{n}catage_cnt','date_block_num', f'item_name_first{n}','item_age','category_id']
if all_shops:
temp_cols[0] += '_all_shops'
else:
temp_cols += ['shop_id']
temp = []
for i in range(1,35):
block =(
df
.query(f'date_block_num < {i}')
.groupby(temp_cols[2... | print("Training file : ")
train_file.head(3 ).iloc[:,:17] | Digit Recognizer |
11,420,133 | df = downcast(df)
int8_cols = [
'item_cnt','month','group_id','shop_type',
'shop_city','shop_id','date_block_num','category_id',
'item_age',
]
int16_cols = [
'item_id','item_name_first4',
'item_name_first6','item_name_first11'
]
for col in int8_cols:
df[col] = df[col].astype('int8')
for col in int16_cols:
df[col] = d... | print("Testing file : ")
test_file.head(3 ).iloc[:,:17] | Digit Recognizer |
11,420,133 | def nearby_item_data(df,col):
if col in ['item_cnt_unclipped_lag1','item_cnt_lag1to12']:
cols = ['date_block_num', 'shop_id', 'item_id']
temp = df[cols + [col]]
else:
cols = ['date_block_num', 'item_id']
temp = df.groupby(cols ).agg({col:'first'} ).reset_index() [cols + [col]]
temp.columns = cols + [f'below_{col}']
tem... | train_file_norm = train_file.iloc[:, 1:] / 255.0
test_file_norm = test_file / 255.0 | Digit Recognizer |
11,420,133 | results = Counter()
items['item_name'].str.split().apply(results.update)
words = []
cnts = []
for key, value in results.items() :
words.append(key)
cnts.append(value)
counts = pd.DataFrame({'word':words,'count':cnts})
common_words = counts.query('count>200' ).word.to_list()
for word in common_words:
items[f'{word}_... | num_examples_train = train_file.shape[0]
num_examples_test = test_file.shape[0]
n_h = 32
n_w = 32
n_c = 3 | Digit Recognizer |
11,420,133 | df = df.join(items, on='item_id' )<categorify> | Train_input_images = np.zeros(( num_examples_train, n_h, n_w, n_c))
Test_input_images = np.zeros(( num_examples_test, n_h, n_w, n_c)) | Digit Recognizer |
11,420,133 | def binary_encode(df, letters, cols):
encoder = ce.BinaryEncoder(cols=[f'item_name_first{letters}'], return_df=True)
temp = encoder.fit_transform(df[f'item_name_first{letters}'])
df = pd.concat([df,temp], axis=1)
del df[f'item_name_first{letters}_0']
name_cols = [f'item_name_first{letters}_{x}' for x in range(1,cols... | for example in range(num_examples_train):
Train_input_images[example,:28,:28,0] = train_file.iloc[example, 1:].values.reshape(28,28)
Train_input_images[example,:28,:28,1] = train_file.iloc[example, 1:].values.reshape(28,28)
Train_input_images[example,:28,:28,2] = train_file.iloc[example, 1:].values.reshape(28,28)
fo... | Digit Recognizer |
11,420,133 | df.to_pickle('df_complete.pkl' )<set_options> | for example in range(num_examples_train):
Train_input_images[example] = cv2.resize(Train_input_images[example],(n_h, n_w))
for example in range(num_examples_test):
Test_input_images[example] = cv2.resize(Test_input_images[example],(n_h, n_w)) | Digit Recognizer |
11,420,133 | %reset -f<set_options> | Train_labels = np.array(train_file.iloc[:, 0] ) | Digit Recognizer |
11,420,133 | pd.set_option('display.max_rows', 160)
pd.set_option('display.max_columns', 160)
pd.set_option('display.max_colwidth', 30)
warnings.filterwarnings("ignore" )<prepare_x_and_y> | train_datagen = ImageDataGenerator(
rotation_range=27,
width_shift_range=0.3,
height_shift_range=0.2,
shear_range=0.3,
zoom_range=0.2,
horizontal_flip=False)
validation_datagen = ImageDataGenerator() | Digit Recognizer |
11,420,133 | df = pd.read_pickle('.. /input/files-top-scoring-notebook-output-exploration/df_complete.pkl')
X_train = df[~df.date_block_num.isin([0,1,33,34])]
y_train = X_train['item_cnt']
del X_train['item_cnt']
X_val = df[df['date_block_num']==33]
y_val = X_val['item_cnt']
del X_val['item_cnt']
X_test = df[df['date_block_num']==... | pretrained_model = keras.applications.resnet50.ResNet50(input_shape=(n_h, n_w, n_c),
include_top=False, weights='imagenet')
model = keras.Sequential([
pretrained_model,
keras.layers.Flatten() ,
keras.layers.Dense(units=60, activation='relu'),
keras.layers.Dense(units=10, activation='softmax')
] ) | Digit Recognizer |
11,420,133 | def build_lgb_model(params, X_train, X_val, y_train, y_val, cat_features):
lgb_train = lgb.Dataset(X_train, y_train)
lgb_val = lgb.Dataset(X_val, y_val)
model = lgb.train(params=params, train_set=lgb_train, valid_sets=(lgb_train, lgb_val), verbose_eval=50,
categorical_feature=cat_features)
return model<train_model> | Optimizer = 'RMSprop'
model.compile(optimizer=Optimizer,
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
11,420,133 | params = {
'objective': 'rmse',
'metric': 'rmse',
'num_leaves': 1023,
'min_data_in_leaf':10,
'feature_fraction':0.7,
'learning_rate': 0.01,
'num_rounds': 1000,
'early_stopping_rounds': 30,
'seed': 1
}
cat_features = ['category_id','month','shop_id','shop_city']
lgb_model = build_lgb_model(params, X_train, X_val, y_trai... | train_images, dev_images, train_labels, dev_labels = train_test_split(Train_input_images,
Train_labels,
test_size=0.1, train_size=0.9,
shuffle=True,
random_state=44)
test_images = Test_input_images | Digit Recognizer |
11,420,133 | submission = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/sample_submission.csv')
submission['item_cnt_month'] = lgb_model.predict(X_test ).clip(0,20)
submission[['ID', 'item_cnt_month']].to_csv('initial_lgb_submission.csv', index=False )<load_from_csv> | class myCallback(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')> 0.999999):
print("Stop training!")
self.model.stop_training = True | Digit Recognizer |
11,420,133 | categories = pd.read_csv('.. /input/predict-future-sales-eng-translation/categories.csv')
categories['group_name'] = categories['category_name'].str.extract(r'(^[\w\s]*)')
categories['group_name'] = categories['group_name'].str.strip()
items = pd.read_csv('.. /input/predict-future-sales-eng-translation/items.csv')
i... | EPOCHS = 5
batch_size = 212
history = model.fit_generator(train_datagen.flow(train_images,train_labels, batch_size=batch_size),
steps_per_epoch=train_images.shape[0] / batch_size,
epochs=EPOCHS,
validation_data=validation_datagen.flow(dev_images,dev_labels,
batch_size=batch_size),
validation_steps=dev_images.shape[0] /... | Digit Recognizer |
11,420,133 | X_train['lgb_pred'] = lgb_model.predict(X_train ).clip(0,20)
X_train['target'] = y_train
X_train['sq_err'] =(X_train['lgb_pred']-X_train['target'])**2
X_val['lgb_pred'] = lgb_model.predict(X_val ).clip(0,20)
X_val['target'] = y_val
X_val['sq_err'] =(X_val['lgb_pred']-X_val['target'])**2
X_test['lgb_pred'] = lgb_model... | submission = pd.read_csv('.. /input/digit-recognizer-submission/submission.csv')
submission.to_csv('digit_submission.csv', index=False ) | Digit Recognizer |
11,368,221 | data = X_train.groupby('date_block_num' ).agg({'lgb_pred':'mean','target':'mean','sq_err':'mean'} ).reset_index()
data['new_item_rmse'] = np.sqrt(X_train.query('item_age<=1' ).groupby('date_block_num' ).agg({'sq_err':'mean'} ).sq_err)
data['old_item_rmse'] = np.sqrt(X_train.query('item_age>1' ).groupby('date_block_num... | def set_seed(seed=0):
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
os.environ['PYTHONHASHSEED'] = str(seed)
set_seed(0 ) | Digit Recognizer |
11,368,221 | df = pd.read_pickle('.. /input/files-top-scoring-notebook-output-exploration/df_complete.pkl')
(
df
[df['category_id'].isin(X_test.category_id.unique())]
.query('item_cnt>0')
.groupby('category_id')
.agg({
'category_age':'max',
'shop_id':['nunique','unique'],
'item_cnt':'sum'
})
.join(categories['category_name'])
.jo... | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device ) | Digit Recognizer |
11,368,221 | (
X_val
[X_val['category_id'].isin(X_test.category_id.unique())]
.groupby('shop_id')
.agg({
'sq_err':'mean',
'target':'mean',
'lgb_pred':'mean'
})
.join(
X_test
.rename(columns={'lgb_pred':'test_pred'})
.groupby('shop_id')
.agg({'test_pred':'mean'})
)
.join(shops['shop_name'])
.sort_values('sq_err', ascending=False)... | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
sample_sub = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
11,368,221 | (
X_val
[X_val['category_id'].isin(X_test.category_id.unique())]
.groupby('category_id')
.agg({
'sq_err':['sum','mean'],
'target':'mean',
'lgb_pred':['sum','mean'],
'item_id':'nunique'
})
.join(
X_test
.rename(columns={'lgb_pred':'test_pred','item_id':'test_items'})
.groupby('category_id')
.agg({
'test_pred':['sum',... | X = train.drop(columns='label' ).values.reshape(-1, 28, 28, 1)
y = train.label.values
train_X, valid_X, train_y, valid_y = train_test_split(X,
y,
test_size=0.2
) | Digit Recognizer |
11,368,221 | CATEGORY = 20
(
items[
items['item_id'].isin(X_val.item_id.unique())&
items['item_id'].isin(X_test.item_id.unique())
]
[['category_id','category_name','item_id','item_name']]
.join(
X_test
.rename(columns={'lgb_pred':'test_pred'})
.groupby('item_id')
.agg({'test_pred':'mean'}),
on='item_id'
)
.join(
X_val
.gro... | class MNISTDataset(Dataset):
def __init__(self, X, y=None, is_test=False, transforms=None):
self.X = X
self.y = y
self.is_test = is_test
self.transforms = transforms
def __len__(self):
return len(self.X)
def __getitem__(self, index):
image = self.X[index]
if self.transforms:
image = self.transforms(image=image)['image... | Digit Recognizer |
11,368,221 | CATEGORY = 20
(
items[items['item_id'].isin(X_test.item_id.unique())]
[['category_id','category_name','item_id','item_name']]
.join(
X_test
.groupby('item_id')
.agg({
'lgb_pred':'mean',
'same_name4catage_cnt_all_shops':'first',
'new_items_in_cat_all_shops_lag1to12':'first',
'item_cnt_all_shops_lag1':'first',
'cate... | train_transforms = Compose([ToFloat(max_value=255),
ShiftScaleRotate(shift_limit=0.1,
scale_limit=0.1,
rotate_limit=10,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=1),
ToTensorV2()
])
valid_transforms = Compose([ToFloat(max_value=255),
ToTensorV2()
] ) | Digit Recognizer |
11,368,221 | submission_1 = pd.read_csv('.. /input/blend-boosting-best-score-on-predict-future-sales/submission_blend_1.csv')
submission_2 = pd.read_csv('initial_lgb_submission.csv')
submission_1['item_cnt_month'] = np.median(np.concatenate([np.expand_dims(submission_1['item_cnt_month'], axis = 1), np.expand_dims(submission_2['it... | example_transforms = Compose([ToFloat(max_value=255),
ShiftScaleRotate(shift_limit=0.3,
scale_limit=0.3,
rotate_limit=30,
p=1),
ToTensorV2()
] ) | Digit Recognizer |
11,368,221 | !pip install -q ".. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl"<import_modules> | class CNN(nn.Module):
def __init__(self):
super(CNN, self ).__init__()
self.dropout = nn.Dropout2d(0.5)
self.bn1_1 = nn.BatchNorm2d(48)
self.bn1_2 = nn.BatchNorm2d(48)
self.bn2 = nn.BatchNorm1d(256)
self.conv1 = nn.Conv2d(in_channels=1, out_channels=48, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(in... | Digit Recognizer |
11,368,221 | import pandas as pd
import numpy as np
import os
import tqdm
import cv2
import matplotlib.pyplot as plt
import seaborn as sns
import gc
import base64
from pycocotools import _mask as coco_mask
import typing as t
import zlib
from torch.utils.data import Dataset, DataLoader
import albumentations as A
from albumentations.... | class EarlyStopping:
def __init__(self, mode, path, patience=3, delta=0):
if mode not in {'min', 'max'}:
raise ValueError("Argument mode must be one of 'min' or 'max'.")
if patience <= 0:
raise ValueError("Argument patience must be a postive integer.")
if delta < 0:
raise ValueError("Argument delta must not be a nega... | Digit Recognizer |
11,368,221 | df = pd.read_csv('.. /input/hpa-single-cell-image-classification/sample_submission.csv' )<define_variables> | def train_one_epoch(model, train_loader, optimizer, device, criterion):
model.train()
running_loss_train = 0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
run... | Digit Recognizer |
11,368,221 | ROOT = '.. /input/hpa-single-cell-image-classification/'
train_or_test = 'test'<prepare_x_and_y> | def validate(model, valid_loader, device, criterion):
model.eval()
correct = 0
running_loss_val = 0
with torch.no_grad() :
for inputs, labels in valid_loader:
inputs, labels = inputs.to(device), labels.to(device)
outputs = model(inputs)
loss = criterion(outputs, labels)
pred = outputs.argmax(dim=1)
correct += pre... | Digit Recognizer |
11,368,221 | def get_cropped_cell(img, msk):
bmask = msk.astype(int)[...,None]
masked_img = img * bmask
true_points = np.argwhere(bmask)
top_left = true_points.min(axis=0)
bottom_right = true_points.max(axis=0)
cropped_arr = masked_img[top_left[0]:bottom_right[0]+1,top_left[1]:bottom_right[1]+1]
return cropped_arr<compute_test_m... | def fit(model, train_loader, valid_loader, learning_rate, num_epochs):
criterion = nn.CrossEntropyLoss(reduction='sum')
optimizer = optim.Adam(model.parameters() , lr=learning_rate)
es = EarlyStopping(mode='min', path='model.pth', patience=5)
model = model.to(device)
scheduler = ExponentialLR(optimizer, gamma=0.9)
... | Digit Recognizer |
11,368,221 | def get_stats(cropped_cell):
x =(cropped_cell/255.0 ).reshape(-1,3 ).mean(0)
x2 =(( cropped_cell/255.0)**2 ).reshape(-1,3 ).mean(0)
return x, x2<data_type_conversions> | TRAIN_BATCH_SIZE = 64
VALID_BATCH_SIZE = 512
NUM_EPOCHS = 50
LEARNING_RATE = 1e-3
NUM_WORKERS = 0
mnist_train = MNISTDataset(train_X, train_y, is_test=False, transforms=train_transforms)
mnist_valid = MNISTDataset(valid_X, valid_y, is_test=False, transforms=valid_transforms)
train_loader = DataLoader(mnist_train, bat... | Digit Recognizer |
11,368,221 | def read_img(image_id, color, train_or_test='test', image_size=None):
filename = f'{ROOT}/{train_or_test}/{image_id}_{color}.png'
assert os.path.exists(filename), f'not found {filename}'
img = cv2.imread(filename, cv2.IMREAD_UNCHANGED)
if image_size is not None:
img = cv2.resize(img,(image_size, image_size))
if img.ma... | TEST_BATCH_SIZE = 512
test_transforms = Compose([ToFloat(max_value=255),
ToTensorV2()
])
test_X = test.values.reshape(-1, 28, 28, 1)
mnist_test = MNISTDataset(test_X, is_test=True, transforms=test_transforms)
test_loader = DataLoader(mnist_test, batch_size=TEST_BATCH_SIZE, shuffle=False ) | Digit Recognizer |
11,368,221 | 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)... | def predict(model, test_loader, device):
model.eval()
predictions = sample_sub['Label'].values
with torch.no_grad() :
for i, inputs in enumerate(test_loader):
inputs = inputs.to(device)
outputs = model(inputs)
pred = outputs.argmax(dim=1 ).to('cpu' ).numpy()
predictions[i*TEST_BATCH_SIZE:i*TEST_BATCH_SIZE+len(input... | Digit Recognizer |
11,601,712 | warnings.filterwarnings("ignore", category=SourceChangeWarning)
NUC_MODEL = ".. /input/hpacellsegmentatormodelweights/dpn_unet_nuclei_v1.pth"
CELL_MODEL = ".. /input/hpacellsegmentatormodelweights/dpn_unet_cell_3ch_v1.pth"
segmentator = cellsegmentator.CellSegmentator(
NUC_MODEL,
CELL_MODEL,
scale_factor=0.25,
device... | from tensorflow.keras.layers import Dense, Flatten, Dropout, Conv2D, MaxPool2D
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split
import ma... | Digit Recognizer |
11,601,712 | df = pd.read_csv('./cell_df.csv' )<create_dataframe> | np.random.seed(42 ) | Digit Recognizer |
11,601,712 | valid_transforms = A.Compose([
A.Resize(width=224, height=224),
A.Normalize() ,
ToTensorV2() ,
])
class CellDataset(Dataset):
def __init__(self, data_dir, csv_file, transform=None):
super().__init__()
self.data_dir = data_dir
self.df = csv_file
self.transforms = transform
self.img_ids = self.df['image_id'].values
self... | def doSubmission(y_pred):
test_Id = np.arange(1, y_pred.size+1, dtype=np.int)
pred_dict = {"ImageId": test_Id, "Label": y_pred}
df = pd.DataFrame(pred_dict)
df.to_csv("sample_submission.csv", index=False, index_label=False ) | Digit Recognizer |
11,601,712 | test_dataset = CellDataset(data_dir='', csv_file=df, transform=valid_transforms )<load_pretrained> | df_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
df_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,601,712 | test_loader = DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=4,
drop_last=False )<choose_model_class> | y = df_train.label.to_numpy()
X = df_train.drop(columns=["label"] ).to_numpy(np.float64)
X /= 255.0 | Digit Recognizer |
11,601,712 | class Net(nn.Module):
def __init__(self, name = 'efficientnet_b0', num_classes=19):
super(Net, self ).__init__()
self.model = timm.create_model(name, pretrained=False, num_classes=num_classes)
def forward(self, x):
out = self.model(x)
return out
<feature_engineering> | X_totrain = X.reshape(X.shape[0], 28, 28, 1 ) | Digit Recognizer |
11,601,712 | def update_state_dict(state_dict):
new_state_dict = OrderedDict()
for key in state_dict.keys() :
new_state_dict['.'.join(key.split('.')[1:])] = state_dict[key]
return new_state_dict<load_pretrained> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y)
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1 ) | Digit Recognizer |
11,601,712 | model_b1_f0 = Net(name = 'efficientnet_b1')
model_b1_f0.load_state_dict(update_state_dict(torch.load('.. /input/efficientnet-b1-224-fold-0/epoch1-valid_loss_epoch0.118.pth')))
model_b1_f0.cuda() ;
model_b1_f0.eval() ;
model_b1_f1 = Net(name = 'efficientnet_b1')
model_b1_f1.load_state_dict(update_state_dict(torch.loa... | y_cat = to_categorical(y, 10)
y_train_cat = to_categorical(y_train, 10)
y_test_cat = to_categorical(y_test, 10 ) | Digit Recognizer |
11,601,712 | pred = torch.FloatTensor()
pred = pred.cuda()<categorify> | test = df_test.to_numpy(np.float64)
test = test.reshape(test.shape[0], 28, 28, 1)
test /= 255.0 | Digit Recognizer |
11,601,712 | tta1 = tta.ClassificationTTAWrapper(model_b1_f0, tta.aliases.flip_transform())
tta2 = tta.ClassificationTTAWrapper(model_b1_f1, tta.aliases.flip_transform())
tta3 = tta.ClassificationTTAWrapper(model_b1_f2, tta.aliases.flip_transform())
tta4 = tta.ClassificationTTAWrapper(model_b1_f3, tta.aliases.flip_transform())
... | def convNeuralNetwork(filters=256, kernel_size=(3, 3), pool_size=(2, 2), units=128, dropout=0.2):
cnn = Sequential()
cnn.add(Conv2D(filters=filters, kernel_size=kernel_size, strides=(1, 1),
input_shape=(28, 28, 1), activation="relu", padding="same"))
cnn.add(MaxPool2D(pool_size=pool_size, padding="same"))
cnn.add(Conv2... | Digit Recognizer |
11,601,712 | with torch.no_grad() :
for inp in tqdm.tqdm(test_loader):
bs, c, h, w = inp.size()
input_var = torch.autograd.Variable(inp.view(-1, c, h, w ).cuda())
output =(tta1(input_var)+tta2(input_var)+\
tta3(input_var)+tta4(input_var)+\
tta5(input_var)+tta6(input_var)+\
tta7(input_var)+tta8(input_var)+tta9(input_var)+tta10(inpu... | early_stopping = EarlyStopping(monitor="val_loss", patience=10, verbose=1,
restore_best_weights=True)
cnn = convNeuralNetwork(filters=2048, units=1024)
cnn_hist = cnn.fit(X_train, y_train_cat, validation_data=(X_test, y_test_cat),
epochs=50, batch_size=256, callbacks=[early_stopping] ) | Digit Recognizer |
11,601,712 | def isNaN(num):
return num != num<load_from_csv> | early_stopping = EarlyStopping(monitor="loss", patience=10, restore_best_weights=True)
model_checkpoint = ModelCheckpoint(filepath="./", monitor="loss", verbose=1,
save_best_only=True, save_weights_only=True)
model = convNeuralNetwork(filters=2048, units=1024)
model_hist = model.fit(X_totrain, y_cat, batch_size=256,... | Digit Recognizer |
11,601,712 | cell_df = pd.read_csv('./cell_df.csv')
cell_df['cls'] = ''<feature_engineering> | y_pred = model.predict(test ).argmax(1)
doSubmission(y_pred ) | Digit Recognizer |
11,684,407 | threshold = 0.0
for i in range(pred_torch.shape[0]):
p = torch.nonzero(pred_torch[i] > threshold ).squeeze().numpy().tolist()
if type(p)!= list: p = [p]
if len(p)== 0: cls = [(pred_torch[i].argmax().item() , pred_torch[i].max().item())]
else: cls = [(x, pred_torch[i][x].item())for x in p]
cell_df['cls'].loc[i] = cls<ca... | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import tensorflow as tf
from sklearn.model_selection import train_test_split | Digit Recognizer |
11,684,407 | def combine(r):
cls = r[0]
enc = r[1]
classes = [str(c[0])+ ' ' + str(c[1])+ ' ' + enc for c in cls]
return ' '.join(classes)
combine(cell_df[['cls', 'enc']].loc[24]);<feature_engineering> | training = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
testing = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
11,684,407 | cell_df['pred'] = cell_df[['cls', 'enc']].apply(combine, axis=1)
cell_df.head()<groupby> | X = training.drop(columns = 'label' ).values
y = training['label'].values | Digit Recognizer |
11,684,407 | subm = cell_df.groupby(['image_id'])['pred'].apply(lambda x: ' '.join(x)).reset_index()
subm.head()<load_from_csv> | X = X/255
X = X.reshape(X.shape[0], *(28, 28, 1))
print(X.shape ) | Digit Recognizer |
11,684,407 | sample_submission = pd.read_csv('.. /input/hpa-single-cell-image-classification/sample_submission.csv')
sample_submission.head()<merge> | testing = testing.values
testing = testing/255
testing = testing.reshape(testing.shape[0], *(28, 28, 1)) | Digit Recognizer |
11,684,407 | sub = pd.merge(
sample_submission,
subm,
how="left",
left_on='ID',
right_on='image_id',
)
sub.head()<feature_engineering> | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state = 0 ) | Digit Recognizer |
11,684,407 | def isNaN(num):
return num != num
for i, row in sub.iterrows() :
if isNaN(row['pred']): continue
sub.PredictionString.loc[i] = row['pred']<save_to_csv> | cnn = tf.keras.models.Sequential() | Digit Recognizer |
11,684,407 | sub.to_csv('submission.csv', index=False )<save_to_csv> | cnn.add(layer = tf.keras.layers.Conv2D(input_shape =(28, 28, 1),
filters=64,
kernel_size =(3,3),
activation = 'relu')) | Digit Recognizer |
11,684,407 | sub.to_csv('submission.csv', index=False )<load_from_csv> | cnn.add(layer = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides = 2)) | Digit Recognizer |
11,684,407 | !rm cell_df.csv<install_modules> | cnn.add(layer = tf.keras.layers.Conv2D(filters=64,
kernel_size =(3,3),
activation = 'relu')) | Digit Recognizer |
11,684,407 | !pip install ".. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl"
!pip install ".. /input/hpapytorchzoozip/pytorch_zoo-master"
!pip install ".. /input/hpacellsegmentatorraman/HPA-Cell-Segmentation/"
!pip install ".. /input/efficientnet-keras-source-code/" --no-deps
!pip install ".. /input/kerasapplicatio... | cnn.add(layer = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides = 2)) | Digit Recognizer |
11,684,407 | !pip install ".. /input/efficientnet-pytorch-07/efficientnet_pytorch-0.7.0"
<set_options> | cnn.add(layer = tf.keras.layers.Flatten() ) | Digit Recognizer |
11,684,407 | gpus = tf.config.list_physical_devices('GPU')
if gpus:
try:
for gpu in gpus:
tf.config.experimental.set_virtual_device_configuration(
gpu,
[tf.config.experimental.VirtualDeviceConfiguration(memory_limit=5600)])
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(... | cnn.add(layer = tf.keras.layers.Dropout(0.5)) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.