kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,283,112 | submission = []
for index, rt in log_regions.iterrows() :
st = rt['Province_State']
co = rt['Country_Region']
popt = list(rt['ConfirmedCases'])
popt_ = list(rt['Fatalities'])
if popt_ == [0.0,0.0,69.0]:
popt_ = np.multiply(fp,popt)
print(co,st,popt,popt_)
rtest = test[(test['Province_State']==st)&(test['Country_Reg... | submission=pd.DataFrame({'Col1':test.Col1,'Col2':lr.predict(X_test)} ) | KNIT_HACKS |
9,283,112 | <import_modules><EOS> | submission.to_csv('submission_reduction.csv',index=False ) | KNIT_HACKS |
8,789,450 | <SOS> metric: rmse Kaggle data source: data-series-summarization-project-(v3)<load_from_csv> | inputFolderPath = '/kaggle/input/data-series-summarization-project-v3/'
outputFolderPath = '/kaggle/working/'
filename = 'synthetic_size50k_len256_znorm.bin'
inputFilePath = inputFolderPath + filename | Data Series Summarization Project (v3) |
8,789,450 | df=pd.read_csv("/kaggle/input/covid19-global-forecasting-week-2/train.csv",
usecols=['Province_State','Country_Region','Date','ConfirmedCases','Fatalities'])
<drop_column> | def sum32(inputFilePath):
summary_filepath = outputFolderPath + filename + '_sum32'
time_series50k = np.fromfile(inputFilePath, dtype=np.float32 ).reshape(-1, 256)
summary50k = []
for time_series in time_series50k:
summary50k.append(time_series[0])
summary50knp = np.array(summary50k,dtype=np.float32)
summary50knp.... | Data Series Summarization Project (v3) |
8,789,450 | <load_from_csv><EOS> | s32= sum32(inputFilePath)
r32 = rec32(s32)
pred32=np.fromfile(r32, dtype=np.float32)
s64= sum64(inputFilePath)
r64 = rec64(s64)
pred64=np.fromfile(r64, dtype=np.float32)
s128= sum128(inputFilePath)
r128 = rec128(s128)
pred128=np.fromfile(r128, dtype=np.float32)
output = []
globalCsvIndex = 0
for i in range(len... | Data Series Summarization Project (v3) |
6,926,526 | <SOS> metric: rmse Kaggle data source: dl-for-exploration-geophysics<choose_model_class> | import numpy as np
import pandas as pd | DL for exploration geophysics |
6,926,526 | submit_confirmed=[]
submit_fatal=[]
for i in df1:
data = i.ConfirmedCases.astype('int32' ).tolist()
try:
model = SARIMAX(data, order=(1,1,0), seasonal_order=(1,1,0,12),measurement_error=True)
model_fit = model.fit(disp=False)
predicted = model_fit.predict(len(data), len(data)+34)
new=np.concatenate(( np.array(data),... | test = pd.read_csv("/kaggle/input/mldl-competition-1/test.csv")
train = pd.read_csv("/kaggle/input/mldl-competition-1/train.csv")
sampleSabmission = pd.read_csv("/kaggle/input/mldl-competition-1/sampleSubmission.csv" ) | DL for exploration geophysics |
6,926,526 | df_submit=pd.concat([pd.Series(np.arange(1,1+len(submit_confirmed))),pd.Series(submit_confirmed),pd.Series(submit_fatal)],axis=1)
df_submit=df_submit.fillna(method='pad' ).astype(int)
df_submit.head()<merge> | print(tf.__version__)
| DL for exploration geophysics |
6,926,526 | df_submit.rename(columns={0: 'ForecastId', 1: 'ConfirmedCases',2: 'Fatalities',}, inplace=True)
complete_test= pd.merge(test, df_submit, how="left", on="ForecastId")
complete_test.head()<save_to_csv> | column_names = ['Id' 'X','Y','Z','Time']
X_train_orig = train[["X", "Y", "Z"]]
X_test_orig = test[["X", "Y", "Z"]]
Y_train_orig = train["Time"]
print(X_train_orig.shape)
print(X_test_orig.shape)
print(Y_train_orig.shape)
| DL for exploration geophysics |
6,926,526 | df_submit.to_csv('submission.csv',header=['ForecastId','ConfirmedCases','Fatalities'],index=False)
complete_test.to_csv('complete_test.csv',index=False )<set_options> | scaler = MinMaxScaler(feature_range=(-1, 1), copy=True)
scaler.fit(X_train_orig)
print("Maximum values of X_train(X, Y, Z): " + str(scaler.data_max_))
print("Minimum values of X_train(X, Y, Z): " + str(scaler.data_min_))
X_train_norm = scaler.transform(X_train_orig)
X_test_norm = scaler.transform(X_test_orig)
| DL for exploration geophysics |
6,926,526 | pd.set_option("display.max_columns", 200)
pd.set_option("display.max_rows", 200 )<load_from_csv> | X_train, X_val, y_train, y_val = train_test_split(X_train_norm, Y_train_orig, test_size=0.2)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape ) | DL for exploration geophysics |
6,926,526 | country_info = pd.read_csv("/kaggle/input/countryinfo/covid19countryinfo.csv")
country_info = country_info.rename({"region": "state"}, axis=1)
country_info.loc[country_info["state"].isna() , "state"] = "Unknown"
country_info = country_info.drop([col for col in country_info.columns if "Unnamed" in col], axis=1)
count... | model = keras.Sequential([
keras.layers.Dense(128, input_dim=3, activation='relu'),
keras.layers.Dense(6, activation='relu'),
keras.layers.Dense(1, activation="linear")
])
print(model.summary())
| DL for exploration geophysics |
6,926,526 | country_info["publicplace"] = np.where(country_info["publicplace"].str.contains("/"), country_info["publicplace"], np.nan )<count_values> | model.compile(optimizer='adam',
loss='MSE',
metrics=['accuracy'] ) | DL for exploration geophysics |
6,926,526 | country_info["publicplace"].value_counts()<define_variables> | history = model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=5 ) | DL for exploration geophysics |
6,926,526 | list_rel_columns = ['state', 'country', 'pop', 'tests',
'testpop', 'density', 'medianage', 'urbanpop', 'quarantine', 'schools',
'publicplace', 'gatheringlimit', 'gathering', 'nonessential',
'hospibed', 'smokers', 'sex0', 'sex14', 'sex25', 'sex54', 'sex64',
'sex65plus', 'sexratio', 'lung', 'femalelung', 'malelung', 'gdp... | test_loss, test_acc = model.evaluate(X_val, y_val, verbose=0)
print('
Test loss:', test_loss)
print('
Test accuracy:', test_acc ) | DL for exploration geophysics |
6,926,526 | country_info = country_info[list_rel_columns]<filter> | predictions = model.predict(X_test_norm ) | DL for exploration geophysics |
6,926,526 | <merge><EOS> | mySubmission = sampleSabmission
mySubmission["Predicted"] = predictions
mySubmission.head()
filename = 'IvanPredictions_1.csv'
mySubmission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | DL for exploration geophysics |
246,962 | %%time
train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-2/train.csv' )<drop_column> | %matplotlib inline
| March Machine Learning Mania 2016 |
246,962 | junk =['Id','Date','Province_State']
train.drop(junk, axis=1, inplace=True )<feature_engineering> | dr = pd.read_csv(".. /input/RegularSeasonDetailedResults.csv")
| March Machine Learning Mania 2016 |
246,962 | train['Country_Region'] = c<data_type_conversions> | simple_df_1 = pd.DataFrame()
simple_df_1[["team1", "team2"]] =dr[["Wteam", "Lteam"]].copy()
simple_df_1["pred"] = 1
simple_df_2 = pd.DataFrame()
simple_df_2[["team1", "team2"]] =dr[["Lteam", "Wteam"]]
simple_df_2["pred"] = 0
simple_df = pd.concat(( simple_df_1, simple_df_2), axis=0)
simple_df.head()
| March Machine Learning Mania 2016 |
246,962 | train['ConfirmedCases'] = train['ConfirmedCases'].astype(int)
train['Fatalities'] = train['Fatalities'].astype(int )<drop_column> | n = simple_df.team1.nunique()
n
| March Machine Learning Mania 2016 |
246,962 | def prep_data(train):
X_train = train[train.ConfirmedCases >0]
X_train.reset_index(inplace = True, drop = True)
train.reset_index(inplace = True, drop = True)
return(X_train, train )<concatenate> | trans_dict = {t: i for i, t in enumerate(simple_df.team1.unique())}
simple_df["team1"] = simple_df["team1"].apply(lambda x: trans_dict[x])
simple_df["team2"] = simple_df["team2"].apply(lambda x: trans_dict[x])
simple_df.head()
| March Machine Learning Mania 2016 |
246,962 | def Calculate_Table(X_train):
diff_conf, conf_old = [], 0
diff_fat, fat_old = [], 0
dd_conf, dc_old = [], 0
dd_fat, df_old = [], 0
ratios = []
for row in X_train.values:
diff_conf.append(row[1]-conf_old)
conf_old = row[1]
diff_fat.append(row[2]-fat_old)
fat_old = row[2]
dd_conf.append(diff_conf[-1]-dc_old)
dc_old = ... | train = simple_df.values
np.random.shuffle(train)
| March Machine Learning Mania 2016 |
246,962 | def populate_df_features(X_train,diff_conf, diff_fat, dd_conf, dd_fat, ratios):
pd.options.mode.chained_assignment = None
X_train['diff_confirmed'] = diff_conf
X_train['diff_fatalities'] = diff_fat
X_train['dd_confirmed'] = dd_conf
X_train['dd_fatalities'] = dd_fat
X_train['ratios'] = ratios
return X_train<categorify> | def embedding_input(name, n_in, n_out, reg):
inp = Input(shape=(1,), dtype="int64", name=name)
return inp, Embedding(n_in, n_out, input_length=1, W_regularizer=l2(reg))(inp)
def create_bias(inp, n_in):
x = Embedding(n_in, 1, input_length=1 )(inp)
return Flatten()(x)
| March Machine Learning Mania 2016 |
246,962 | def fill_nan(variable):
if math.isnan(variable):
return 0
else:
return variable<statistical_test> | n_factors = 50
team1_in, t1 = embedding_input("team1_in", n, n_factors, 1e-4)
team2_in, t2 = embedding_input("team2_in", n, n_factors, 1e-4)
b1 = create_bias(team1_in, n)
b2 = create_bias(team2_in, n)
| March Machine Learning Mania 2016 |
246,962 | def Cal_Series_Avg(X_train,ratio):
d_c = fill_nan(X_train.diff_confirmed[X_train.diff_confirmed != 0].mean())
dd_c = fill_nan(X_train.dd_confirmed[X_train.dd_confirmed != 0].mean())
d_f = fill_nan(X_train.diff_fatalities[X_train.diff_fatalities != 0].mean())
dd_f = fill_nan(X_train.dd_fatalities[X_train.dd_fatalitie... | x = merge([t1, t2], mode="dot")
x = Flatten()(x)
x = merge([x, b1], mode="sum")
x = merge([x, b2], mode="sum")
x = Dense(1, activation="sigmoid" )(x)
model = Model([team1_in, team2_in], x)
model.compile(Adam(0.001), loss="binary_crossentropy")
| March Machine Learning Mania 2016 |
246,962 | def apply_taylor(train, d_c, dd_c, d_f, dd_f, rate):
pred_c, pred_f = list(train.ConfirmedCases.loc[57:69].astype(int)) , list(train.Fatalities.loc[57:69].astype(int))
for i in range(1, 31):
pred_c.append(int(( train.ConfirmedCases[69] + d_c*i + 0.5*dd_c*(i**2))))
pred_f.append(pred_c[-1]*rate)
return pred_c, pred_f<d... | history = model.fit([train[:, 0], train[:, 1]], train[:, 2], batch_size=64, nb_epoch=10, verbose=2)
| March Machine Learning Mania 2016 |
246,962 | def apply_taylor2(train, d_c, dd_c, d_f, dd_f, rate):
pred_c, pred_f = list(train.ConfirmedCases.loc[57:58].astype(int)) , list(train.Fatalities.loc[57:58].astype(int))
for i in range(1, 42):
pred_c.append(int(( train.ConfirmedCases[58] + d_c*i + 0.5*dd_c*(i**2))))
pred_f.append(pred_c[-1]*rate)
return pred_c, pred_f<... | sub = pd.read_csv(".. /input/SampleSubmission.csv")
sub["team1"] = sub["Id"].apply(lambda x: trans_dict[int(x.split("_")[1])])
sub["team2"] = sub["Id"].apply(lambda x: trans_dict[int(x.split("_")[2])])
sub.head()
| March Machine Learning Mania 2016 |
246,962 | pc = []
pf = []
pc2 = []
pf2 = []
pred_c = []
pred_f = []
pred_c2 = []
pred_f2 = []
for i,country in enumerate(country_list):
country_data = train[train['Country_Region'] == country]
X_train, country_data = prep_data(country_data)
if(len(X_train)> 0):
diff_conf, conf_old, diff_fat, fat_old, dd_conf, dc_old, dd_fat, df... | sub["pred"] = model.predict([sub.team1, sub.team2])
sub = sub[["Id", "pred"]]
sub.head()
| March Machine Learning Mania 2016 |
246,962 | pc = list(map(int, pc))
pf = list(map(int, pf))
pc2 = list(map(int, pc2))
pf2 = list(map(int, pf2))<import_modules> | sub.to_csv("CF.csv", index=False)
| March Machine Learning Mania 2016 |
5,262,083 | import matplotlib.pyplot as plt<save_to_csv> | %load_ext Cython | Conway's Reverse Game of Life |
5,262,083 | my_submission = pd.DataFrame({'ForecastId': list(range(1,len(pc2)+1)) , 'ConfirmedCases': pc2, 'Fatalities': pf2})
print(my_submission)
my_submission.to_csv('submission.csv', index=False )<set_options> | %%cython
c
@cython.cdivision(True)
@cython.boundscheck(False)
@cython.nonecheck(False)
@cython.wraparound(False)
cdef int calc_neighs(unsigned char[:, :] field, int i, int j, int n, int k):
cdef:
int neighs = 0;
int i_min = i - 1;
int i_pl = i + 1;
int j_min = j - 1;
int j_pl = j + 1;
neighs = 0
if i_min >= 0:
if j... | Conway's Reverse Game of Life |
5,262,083 | %matplotlib inline
<define_variables> | NROW, NCOL = 20, 20
def generate_samples(delta=1, n=32):
batch = np.split(np.random.binomial(1, 0.5,(NROW * n, NCOL)).astype('uint8'), n)
Yy = [life.make_move(state, 5)for state in batch]
Xx = [life.make_move(state, 1)for state in Yy]
Y = np.array([y.ravel() for y in Yy])
X = np.array([x.ravel() for x in Xx])
retu... | Conway's Reverse Game of Life |
5,262,083 | base_dir = '.. /input/dogs-vs-cats-redux-kernels-edition'
train_dir = '.. /data/train'
test_dir = '.. /data/test'<load_pretrained> | def create_model(n_hidden_convs=2, n_hidden_filters=128, kernel_size=5):
nn = Sequential()
nn.add(Conv2D(n_hidden_filters, kernel_size, padding='same', activation='relu', input_shape=(20, 20, 1)))
nn.add(BatchNormalization())
for i in range(n_hidden_convs):
nn.add(Conv2D(n_hidden_filters, kernel_size, padding='same',... | Conway's Reverse Game of Life |
5,262,083 | with zipfile.ZipFile(os.path.join(base_dir, 'train.zip')) as train_zip:
train_zip.extractall('.. /data')
with zipfile.ZipFile(os.path.join(base_dir, 'test.zip')) as test_zip:
test_zip.extractall('.. /data' )<define_variables> | models = []
for delta in range(1, 6):
model = create_model(n_hidden_convs=6, n_hidden_filters=256)
es = EarlyStopping(monitor='loss', patience=9, min_delta=0.001)
model.fit_generator(data_generator(delta=delta, ravel=False), steps_per_epoch=500, epochs=50, verbose=1, callbacks=[es])
models.append(model ) | Conway's Reverse Game of Life |
5,262,083 | train_list = glob.glob(os.path.join(train_dir, '*.jpg'))
test_list = glob.glob(os.path.join(test_dir, '*.jpg'))<split> | train_df = pd.read_csv('.. /input/train.csv', index_col=0)
test_df = pd.read_csv('.. /input/test.csv', index_col=0 ) | Conway's Reverse Game of Life |
5,262,083 | train_list,val_list = train_test_split(train_list,test_size=0.1 )<normalization> | submit_df = pd.DataFrame(index=test_df.index, columns=['start.' + str(_)for _ in range(1, 401)] ) | Conway's Reverse Game of Life |
5,262,083 | class ImageTransform() :
def __init__(self, resize, mean, std):
self.data_transform = {
'train': transforms.Compose([
transforms.RandomResizedCrop(resize, scale=(0.5, 1.0)) ,
transforms.RandomHorizontalFlip() ,
transforms.ToTensor() ,
transforms.Normalize(mean, std)
]),
'val': transforms.Compose([
transforms.Resize(25... | for delta in range(1, 6):
mod = models[delta-1]
delta_df = test_df[test_df.delta == delta].iloc[:, 1:].values.reshape(-1, 20, 20, 1)
submit_df[test_df.delta == delta] = mod.predict(delta_df ).reshape(-1, 400 ).round(0 ).astype('uint8' ) | Conway's Reverse Game of Life |
5,262,083 | <set_options><EOS> | submit_df.to_csv('cnns_40.csv' ) | Conway's Reverse Game of Life |
13,799,686 | <SOS> metric: CategorizationAccuracy Kaggle data source: cifar-10<create_dataframe> | print("Tensorflow version " + tf.__version__)
AUTO = tf.data.experimental.AUTOTUNE | CIFAR-10 - Object Recognition in Images |
13,799,686 | train_dataset = DogvsCatDataset(train_list, transform=ImageTransform(size, mean, std), phase='train')
val_dataset = DogvsCatDataset(val_list, transform=ImageTransform(size, mean, std), phase='val' )<load_pretrained> | 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)
except ValueError:
strategy = tf.distribute.MirroredStrategy()
print("Number of accelerators: ", strategy... | CIFAR-10 - Object Recognition in Images |
13,799,686 | train_dataloader = data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_dataloader = data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
dataloader_dict = {'train': train_dataloader, 'val': val_dataloader}
print('Operation Check')
batch_iterator = iter(train_dataloader)
inputs, lab... | GCS_DS_PATH = KaggleDatasets().get_gcs_path("cifar-10-unzipped" ) | CIFAR-10 - Object Recognition in Images |
13,799,686 | use_pretrained = True
net = models.resnet50(pretrained=use_pretrained)
print(net )<train_model> | IMAGE_SIZE = [32, 32]
EPOCHS = 100
BATCH_SIZE = 16 * strategy.num_replicas_in_sync
ROOT_PATH_MAP = {
32: GCS_DS_PATH + "/tfrecords-jpeg-32x32/"
}
ROOT_PATH = ROOT_PATH_MAP[IMAGE_SIZE[0]]
TRAINING_FILENAMES = tf.io.gfile.glob(ROOT_PATH + "train/*.tfrec")
VALIDATION_FILENAMES = tf.io.gfile.glob(ROOT_PATH + "validation/*... | CIFAR-10 - Object Recognition in Images |
13,799,686 | net.fc = nn.Linear(in_features=2048, out_features=2)
print('Done' )<find_best_params> | np.set_printoptions(threshold=15, linewidth=80)
def batch_to_numpy_images_and_labels(data):
images, labels = data
numpy_images = images.numpy()
numpy_labels = labels.numpy()
if numpy_labels.dtype == object:
numpy_labels = [None for _ in enumerate(numpy_images)]
return numpy_images, numpy_labels
def title_from_label_an... | CIFAR-10 - Object Recognition in Images |
13,799,686 | params_to_update = []
update_params_name = ['fc.weight', 'fc.bias']
for name, param in net.named_parameters() :
if name in update_params_name:
param.requires_grad = True
params_to_update.append(param)
print(name)
else:
param.requires_grad = False<train_model> | def to_float32(image, label):
return tf.cast(image, tf.float32), label
def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
image = tf.reshape(image, [*IMAGE_SIZE, 3])
return image
def read_labeled_tfrecord(example):
LABELED_TFREC_FORMAT = {
"ima... | CIFAR-10 - Object Recognition in Images |
13,799,686 | def lr_schedule(epoch):
lr = 1e-3
if epoch > 95:
lr *= 0.5e-3
elif epoch > 80:
lr *= 1e-3
elif epoch > 50:
lr *= 1e-2
elif epoch > 20:
lr *= 1e-1
print('Learning rate: ', lr)
return lr<choose_model_class> | print("Training data shapes:")
for image, label in get_training_dataset().take(3):
print(image.numpy().shape, label.numpy().shape)
print("Training data label examples:", label.numpy())
print("Validation data shapes:")
for image, label in get_validation_dataset().take(3):
print(image.numpy().shape, label.numpy().sha... | CIFAR-10 - Object Recognition in Images |
13,799,686 | criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(params=params_to_update,lr=lr_schedule(0))<train_model> | training_dataset = get_training_dataset()
training_dataset = training_dataset.unbatch().batch(20)
train_batch = iter(training_dataset ) | CIFAR-10 - Object Recognition in Images |
13,799,686 | def train_model(net, dataloader_dict, criterion, optimizer, num_epoch):
since = time.time()
best_model_wts = copy.deepcopy(net.state_dict())
best_acc = 0.0
net = net.to(device)
for epoch in range(num_epoch):
print('Epoch {}/{}'.format(epoch + 1, num_epoch))
print('-'*20)
for phase in ['train', 'val']:
if phase == 't... | display_batch_of_images(next(train_batch)) | CIFAR-10 - Object Recognition in Images |
13,799,686 | num_epoch = 10
net = train_model(net, dataloader_dict, criterion, optimizer, num_epoch )<categorify> | validation_dataset = get_validation_dataset()
validation_dataset = validation_dataset.unbatch().batch(20)
validation_batch = iter(validation_dataset ) | CIFAR-10 - Object Recognition in Images |
13,799,686 | id_list = []
pred_list = []
with torch.no_grad() :
for test_path in tqdm(test_list):
img = Image.open(test_path)
_id = int(test_path.split('/')[-1].split('.')[0])
transform = ImageTransform(size, mean, std)
img = transform(img, phase='val')
img = img.unsqueeze(0)
img = img.to(device)
net.eval()
outputs = net(img)... | display_batch_of_images(next(validation_batch)) | CIFAR-10 - Object Recognition in Images |
13,799,686 |
<install_modules> | test_dataset = get_test_dataset()
test_dataset = test_dataset.unbatch().batch(20)
test_batch = iter(test_dataset ) | CIFAR-10 - Object Recognition in Images |
13,799,686 | !pip install segmentation_models_pytorch
! git clone https://github.com/Bjarten/early-stopping-pytorch.git
! mv./early-stopping-pytorch./lib<import_modules> | display_batch_of_images(next(test_batch)) | CIFAR-10 - Object Recognition in Images |
13,799,686 | import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader, sampler
from pathlib import Path
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import time
import torchvision
import cv2
import re
import segmentation_models_pytorch as smp
from lib.pytorch... | with strategy.scope() :
model = Sequential()
model.add(Conv2D(32,(3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', kernel_regularizer=l2(0.001), input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)))
model.add(BatchNormalization())
model.add(Conv2D(32,(3, 3), activation='relu', kernel_initializer='... | CIFAR-10 - Object Recognition in Images |
13,799,686 | class NerveDataset(Dataset):
def __init__(self, directory, pytorch=True, is_test=False):
super().__init__()
self.files = []
for file_name in directory.iterdir() :
if 'mask' in str(file_name):
continue
self.files.append(self.combine_files(file_name))
self.files = sorted(self.files, key=lambda file: int(re.search(r'\d+',... | training_dataset = get_training_dataset().map(to_float32)
validation_dataset = get_validation_dataset().map(to_float32)
checkpoint = ModelCheckpoint("model_checkpoint.h5", monitor='val_loss', mode='min', save_best_only=True, verbose=1)
early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verb... | CIFAR-10 - Object Recognition in Images |
13,799,686 | images_path = Path('.. /input/ultrasound-nerve-segmentation/train')
data = NerveDataset(images_path)
len(data )<train_model> | cmdataset = get_validation_dataset(ordered=True)
cmdataset = cmdataset.map(to_float32)
images_ds = cmdataset.map(lambda image, label: image)
labels_ds = cmdataset.map(lambda image, label: label ).unbatch()
cm_correct_labels = next(iter(labels_ds.batch(NUM_VALIDATION_IMAGES)) ).numpy()
cm_probabilities = model.predic... | CIFAR-10 - Object Recognition in Images |
13,799,686 | split_rate = 0.7
train_ds_len = int(len(data)* split_rate)
valid_ds_len = len(data)- train_ds_len
train_ds, valid_ds = torch.utils.data.random_split(data,(train_ds_len, valid_ds_len))
print(f'Train dataset length: {len(train_ds)}
')
print(f'Validation dataset length: {len(valid_ds)}
')
print(f'All data length: {len(... | cmat = confusion_matrix(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)))
score = f1_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro')
precision = precision_score(cm_correct_labels, cm_predictions, labels=range(len(CLASSES)) , average='macro')
recall = recall_score(c... | CIFAR-10 - Object Recognition in Images |
13,799,686 | unet = model = smp.Unet(
encoder_name="resnet34",
encoder_weights="imagenet",
in_channels=1,
classes=1,
activation = "sigmoid"
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
learning_rate = 0.001
epochs = 50
metrics = [smp.utils.metrics.IoU() ]
loss_function = smp.utils.losses.DiceLoss()
op... | test_ds = get_test_dataset(ordered=True)
test_ds = test_ds.map(to_float32)
print('Computing predictions...')
test_images_ds = test_ds.map(lambda image, idnum: image)
probabilities = model.predict(test_images_ds)
predictions = np.argmax(probabilities, axis=-1)
print(predictions)
label_map = np.vectorize(lambda in... | CIFAR-10 - Object Recognition in Images |
13,799,686 | test_images_path = Path('.. /input/ultrasound-nerve-segmentation/test')
test_data = NerveDataset(test_images_path, is_test=True)
test_dl = DataLoader(test_data, batch_size=1, shuffle=False)
len(test_data )<categorify> | dataset = get_validation_dataset()
dataset = dataset.unbatch().batch(20)
batch = iter(dataset ) | CIFAR-10 - Object Recognition in Images |
13,799,686 | def rle_encoding(x):
dots = np.where(x.T.flatten() ==1)[0]
run_lengths = []
prev = -2
for b in dots:
if(b>prev+1): run_lengths.extend(( b+1, 0))
run_lengths[-1] += 1
prev = b
return run_lengths<categorify> | images, labels = next(batch)
probabilities = model.predict(tf.cast(images, tf.float32))
predictions = np.argmax(probabilities, axis=-1)
display_batch_of_images(( images, labels), predictions ) | CIFAR-10 - Object Recognition in Images |
66,907 | encodings = []
counter = 0
for image in test_dl:
if torch.cuda.is_available() :
image = image.cuda()
pr_mask = unet(image)
pr_mask = pr_mask[0]
pr_mask = pr_mask.squeeze().cpu().detach().numpy().round().astype(np.uint8)
pr_mask = cv2.resize(pr_mask,(580,420), interpolation=cv2.INTER_CUBIC)
encodings.append(rle_encod... | print(check_output(["cp", ".. /input/sampleSubmission.csv", "sub.csv"] ).decode("utf8")) | Painter by Numbers |
3,352,071 | df_submission = pd.DataFrame(columns=["img", "pixels"])
for i, encoding in enumerate(encodings):
pixels = ' '.join(map(str, encoding))
df_submission.loc[i] = [str(i+1), pixels]
df_submission.to_csv('./submission.csv', index=False)
print('Done!' )<install_modules> | ! tar xf.. /input/bird-songs-pad-and-resize-spectrogram/spectrograms_resized.tar.bz2 | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | !pip install git+https://github.com/qubvel/segmentation_models.pytorch<load_from_zip> | %reload_ext autoreload
%autoreload 2
%matplotlib inline
| Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | !git clone https://github.com/Bjarten/early-stopping-pytorch.git esp<import_modules> | data_dir = Path('.. /input')
label_dir = data_dir/'multilabel-bird-species-classification-nips2013/nips4b_bird_challenge_train_labels/NIPS4B_BIRD_CHALLENGE_TRAIN_LABELS'
spect_dir = Path('./spectrograms_resized' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.utils.data import Dataset, DataLoader
import torchvision
from torchvision import transforms
import pandas as pd
import numpy as np
import os
from torchvision import transforms
from PIL import Image
import segm... | df = pd.read_csv(label_dir/'nips4b_birdchallenge_train_labels.csv', skiprows=[0, 2])
df.tail() | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | def save_checkpoint(self, val_loss, model):
if self.verbose:
self.trace_func(f'Validation loss decreased({self.val_loss_min:.6f} --> {val_loss:.6f} ).Saving model...')
with open(self.path, 'wb')as f:
pickle.dump(model, f)
self.val_loss_min = val_loss<drop_column> | df.drop(df.columns[[1, 3]],axis=1,inplace=True)
df.rename(columns={df.columns[0]:'file', df.columns[1]:'EMPTY'}, inplace=True)
df = df[:-1]
df.fillna(0, inplace=True)
df = df.astype('int32', errors='ignore')
df['file'] = df['file'].apply(lambda fn: str(Path(fn ).with_suffix('')))
df.tail() | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | EarlyStopping.save_checkpoint = save_checkpoint<define_variables> | tfms = get_transforms(do_flip=False, max_rotate=None, max_warp=None)
data =(src.transform(tfms, size=128)
.databunch(num_workers=0 ).normalize(imagenet_stats)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | input_ = '.. /input/ultrasound-nerve-segmentation'
train_path = f'{input_}/train'
test_path = f'{input_}/test'
train_csv_path = 'train_annotation.csv'
test_path = '.. /input/ultrasound-nerve-segmentation/test'<save_to_csv> | data.show_batch(rows=3, figsize=(12,9), ds_type=DatasetType.Valid ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | def create_csv(data_path, out_csv_path, key_word='mask'):
to_delete = f'_{key_word}'
for file_name in os.listdir(data_path):
if key_word in file_name:
img = file_name.replace(to_delete, '')
data = pd.DataFrame([img], index=['img'] ).transpose()
data.insert(0, 'mask', file_name)
else:
if not os.path.exists(out_csv_pat... | arch = models.resnet50
acc_02 = partial(accuracy_thresh, thresh=0.2)
learn = cnn_learner(data, arch, metrics=acc_02, path='.' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | create_csv(data_path=train_path, out_csv_path=train_csv_path )<categorify> | lr = 2.29E-02
learn.fit_one_cycle(5, slice(lr)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | class ImageDataset(Dataset):
def __init__(self, df, root_dir, transform=None):
self.df = df
self.root_dir = root_dir
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
mask = Image.open(os.path.join(self.root_dir, self.df.iloc[idx, ... | learn.save('stage-1-rn50', return_path=True ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | train_df = pd.read_csv(train_csv_path )<create_dataframe> | learn.fit_one_cycle(5, slice(3.02E-03, lr/5)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | train_samples = ImageDataset(df=train_df, root_dir=train_path )<define_variables> | learn.save('stage-2-rn50' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | ENCODER = 'vgg11_bn'
ENCODER_WEIGHTS = 'imagenet'
ACTIVATION = 'sigmoid'
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu' )<categorify> | data_256 =(src.transform(tfms, size=256)
.databunch(num_workers=0 ).normalize(imagenet_stats))
learn.data = data_256
learn.data.train_ds[0][0].shape | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | model = smp.Unet(
encoder_name=ENCODER,
encoder_weights=ENCODER_WEIGHTS,
in_channels=1,
classes=1,
activation=ACTIVATION
)<choose_model_class> | lr = 5E-03
learn.fit_one_cycle(5, slice(lr)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | loss = smp.utils.losses.DiceLoss()
metrics = [smp.utils.metrics.IoU() ]
optimizer = torch.optim.Adam
scheduler = lr_scheduler.StepLR<categorify> | learn.save('stage-1-256-rn50' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | my_transforms = transforms.Compose([
transforms.Resize(size=(224, 224)) ,
transforms.ToTensor()
] )<split> | learn.fit_one_cycle(5, slice(1.58E-06, lr/5)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | def split_df(df, fraction=0.8):
df_1 = df.sample(frac=fraction)
return df_1, df.drop(df_1.index )<train_model> | learn.save('stage-2-256-rn50' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | def train(model, train_df, train_dir, optimizer, loss, metrics,
learning_rate=0.01, batch_size=20, epochs=10, patience=3,
scheduler=None, step_size=5, gamma=0.1, device='cpu', transform=None):
early_stopping = EarlyStopping(patience, path='best_model.pkl', verbose=True)
optimizer = optimizer(model.parameters() , learn... | learn.fit_one_cycle(5, slice(1.58E-06, lr/5)) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | res = train(model=model,
train_df=train_df,
train_dir=train_path,
optimizer=optimizer,
loss=loss,
learning_rate=0.01,
metrics=metrics,
batch_size=20,
epochs=20,
scheduler=scheduler,
step_size=10,
patience=3,
device=DEVICE,
transform=my_transforms )<import_modules> | learn.save('stage-2-256-rn50-10e' ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | import pickle<save_to_csv> | test = ImageList.from_folder(spect_dir/'test/')
len(test ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | with open('results.pkl', 'wb')as f:
pickle.dump(res, f )<load_pretrained> | predictor = load_learner('.', test=test, num_workers=0)
preds, _ = predictor.get_preds(ds_type=DatasetType.Test)
fpreds = preds[:, 1:].reshape(-1, ) | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | with open('best_model.pkl', 'rb')as f:
best_model = pickle.load(f )<create_dataframe> | names = [f.stem for f in predictor.data.test_ds.items]
fnames = [x + '.wav_classnumber_' + str(i)for x in names for i in range(1, len(data.classes)) ] | Multi-label Bird Species Classification - NIPS 2013 |
3,352,071 | <categorify><EOS> | test_df = pd.DataFrame({'ID':fnames, 'Probability':fpreds}, columns=['ID', 'Probability'])
test_df.to_csv('submission.csv', index=False ) | Multi-label Bird Species Classification - NIPS 2013 |
3,334,951 | <SOS> metric: AUC Kaggle data source: influencers-in-social-networks<import_modules> | warnings.simplefilter(action='ignore', category=FutureWarning)
gc.enable() | Influencers in Social Networks |
3,334,951 | from tqdm.notebook import tqdm<sort_values> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Influencers in Social Networks |
3,334,951 | imgs = [f for f in os.listdir(test_path)]
imgs = sorted(imgs, key=lambda s: int(s.split('.')[0]))<save_to_csv> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Influencers in Social Networks |
3,334,951 | def create_csv_submission(model, data_path, img_list, out_path):
submission_df = pd.DataFrame(columns=['img', 'pixels'])
model.to(DEVICE)
model.eval()
for i, img in enumerate(tqdm(img_list)) :
x = Image.open(os.path.join(data_path, img))
x = my_transforms(x)
x = x.unsqueeze(0 ).to(DEVICE)
pred_mask = model.predict(... | def pre_pro(df):
df = df.astype('float32')
col = df.columns
for i in range(len(col)) :
m = df.loc[df[col[i]] != -np.inf, col[i]].min()
df[col[i]].replace(-np.inf,m,inplace=True)
M = df.loc[df[col[i]] != np.inf, col[i]].max()
df[col[i]].replace(np.inf,M,inplace=True)
df.fillna(0, inplace = True)
return df | Influencers in Social Networks |
3,334,951 | create_csv_submission(model=model,
data_path=test_path,
img_list=imgs,
out_path='submission.csv' )<load_from_csv> | def feat_eng(df):
df.replace(0, 0.001)
df['follower_diff'] =(df['A_follower_count'] > df['B_follower_count'])
df['following_diff'] =(df['A_following_count'] > df['B_following_count'])
df['listed_diff'] =(df['A_listed_count'] > df['B_listed_count'])
df['ment_rec_diff'] =(df['A_mentions_received'] > df['B_mentions_re... | Influencers in Social Networks |
3,334,951 | child=pd.read_csv('.. /input/child_wishlist_v2.csv',header=None,index_col=0)
childArray=child.values
<load_from_csv> | fe_train = feat_eng(train.copy())
fe_test = feat_eng(test.copy() ) | Influencers in Social Networks |
3,334,951 | gift=pd.read_csv('.. /input/gift_goodkids_v2.csv',header=None,index_col=0)
giftArray=gift.values
<load_from_csv> | train_df = fe_train
test_df = fe_test
y_train = np.array(train_df['Choice'] ) | Influencers in Social Networks |
3,334,951 | submitReader=pd.read_csv('.. /input/sample_submission_random_v2.csv')
submit=submitReader<compute_test_metric> | target = 'Choice'
predictors = train_df.columns.values.tolist() [1:] | Influencers in Social Networks |
3,334,951 | def childListPosition(whichChild,whichGift):
temp=np.argwhere(childArray[whichChild]==whichGift)
if temp.size>0:
return temp[0][0]+1
else:
return 0
def giftListPosition(whichGift,whichChild):
temp=np.argwhere(giftArray[whichGift]==whichChild)
if temp.size>0:
return temp[0][0]+1
else:
return 0
def childScore(whichChil... | param_lgb = {
'feature_fraction': 0.4647875434283183,
'lambda_l1': 0.14487098904632512,
'lambda_l2': 0.9546002933329684,
'learning_rate': 0.050592093295320606,
'max_depth': int(round(7.696194993998026)) ,
'min_data_in_leaf': int(round(9.879507661608065)) ,
'min_gain_to_split': 0.7998292013880356,
'min_sum_hessian_in_le... | Influencers in Social Networks |
3,334,951 | def changePosition(positionA,positionB):
tempa=submit.iloc[positionA][1]
tempb=submit.iloc[positionB][1]
submit.iloc[positionA][1]=tempb
submit.iloc[positionB][1]=tempa
return<compute_test_metric> | nfold = 20
skf = StratifiedKFold(n_splits=nfold, shuffle=True, random_state=2019)
oof = np.zeros(len(fe_train))
predictions = np.zeros(( len(fe_test),nfold))
i = 1
for train_index, valid_index in skf.split(fe_train, fe_train.Choice.values):
print("
fold {}".format(i))
xg_train = lgb.Dataset(fe_train.iloc[train_index][... | Influencers in Social Networks |
3,334,951 | def currentScore(childA,childB):
giftA=submit.iloc[childA][1]
giftB=submit.iloc[childB][1]
scoreA=score(childA,giftA)
scoreB=score(childB,giftB)
return scoreA+scoreB
def predictScore(childA,childB):
giftA=submit.iloc[childA][1]
giftB=submit.iloc[childB][1]
scoreA=score(childA,giftB)
scoreB=score(childB,giftA)
retur... | lgb_bay = []
for i in range(len(predictions)) :
lgb_bay.append(predictions[i][-1] ) | Influencers in Social Networks |
3,334,951 | def agent(childA,childB):
tempA=currentScore(childA,childB)
tempB=predictScore(childA,childB)
if tempA>tempB:
return 0
elif tempA==tempB:
changePosition(childA,childB)
elif tempA<tempB:
changePosition(childA,childB)
print('childA:'+str(childA)
+' childB:'+str(childB)
+' currentScore:'+str(tempA)
+' predictScore:... | submission = pd.read_csv('.. /input/sample_predictions.csv')
submission['Choice'] = lgb_bay
submission.to_csv('sub.csv', index = False, header = True ) | Influencers in Social Networks |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.