kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,725,565 | learn = Learner(data,
md_ef,
metrics = [qk],
model_dir="models" ).to_fp16()
learn.data.add_test(ImageList.from_df(test_df,
'.. /input/aptos2019-blindness-detection',
folder='test_images',
suffix='.png'))<load_pretrained> | svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc | Titanic - Machine Learning from Disaster |
9,725,565 | learn.load('abcdef');<compute_test_metric> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
9,725,565 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian | Titanic - Machine Learning from Disaster |
9,725,565 | def run_subm(learn=learn, coefficients=[0.5, 1.5, 2.5, 3.5]):
opt = OptimizedRounder()
preds,y = learn.get_preds(DatasetType.Test)
tst_pred = opt.predict(preds, coefficients)
test_df.diagnosis = tst_pred.astype(int)
test_df.to_csv('submission.csv',index=False)
print('done' )<define_variables> | perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2)
acc_perceptron | Titanic - Machine Learning from Disaster |
9,725,565 | TTA = False<set_options> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
9,725,565 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
%matplotlib inline
<set_options> | sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
acc_sgd | Titanic - Machine Learning from Disaster |
9,725,565 | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(42 )<load_from_csv> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
9,725,565 | def get_df() :
base_image_dir = os.path.join('.. ', 'input/aptos2019-blindness-detection/')
train_dir = os.path.join(base_image_dir,'train_images/')
df = pd.read_csv(os.path.join(base_image_dir, 'train.csv'))
df['path'] = df['id_code'].map(lambda x: os.path.join(train_dir,'{}.png'.format(x)))
df = df.drop(columns=['... | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
acc_random_forest | Titanic - Machine Learning from Disaster |
9,725,565 | def qk(y_pred, y):
return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0' )<compute_test_metric> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron',
'Stochastic Gradient Decent', 'Linear SVC',
'Decision Tree'],
'Score': [acc_svc, acc_knn, acc_log,
acc_random_forest, acc_gaussian, acc_perceptron,
acc_sgd, acc_linear_svc, acc_decisi... | Titanic - Machine Learning from Disaster |
9,725,565 | <save_to_csv><EOS> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": Y_pred
})
submission.to_csv('submission2.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,325,212 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | %matplotlib inline | Titanic - Machine Learning from Disaster |
8,325,212 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1)
learn = Learner(data,
md_ef,
metrics = [qk],
callback_fns=[
BnFreeze,
partial(SaveModelCallback, monitor='quad_kappa', name='bestmodel')
],
model_dir="models",
)
if TTA:
learn = learn.to_fp32()
else:
learn = learn.to_fp16()
learn.data.add_test(I... | df = pd.read_csv(".. /input/titanic/train.csv")
df.head() | Titanic - Machine Learning from Disaster |
8,325,212 | !mkdir models
!cp '.. /input/kaggle-public/abcdef.pth' 'models'
learn.load('abcdef');<load_pretrained> | df.drop(['PassengerId','Cabin','Name','Ticket'],axis=1,inplace=True)
df.head() | Titanic - Machine Learning from Disaster |
8,325,212 | learn.load('bestmodel' )<train_on_grid> | df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | rounder = OptimizedRounder()
rounder.fit(valid_preds[0], valid_preds[1])
rounder_coefficients = rounder.coefficients()
print(rounder_coefficients )<count_values> | df = df[df["Embarked"].notna() ]
df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | test_df_tta['diagnosis'].value_counts()<import_modules> | df["Age"] = df[["Age","Pclass"]].apply(find_age,axis=1)
df.head() | Titanic - Machine Learning from Disaster |
8,325,212 | import os
import sys
import cv2
import time
import scipy as sp
import numpy as np
import pandas as pd
from tqdm import tqdm
from PIL import Image
from functools import partial
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import set_random_seed
import keras
from keras import initializers
from ... | df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | SEED = 7
np.random.seed(SEED)
set_random_seed(SEED)
INPUT_PATH = '.. /input/aptos2019-blindness-detection/'
DIM = 224
BATCH_SIZE = 4
CHANNEL_SIZE = 3
NUM_EPOCHS = 30
LR = 1e-3
CLASS= {0: "No DR", 1: "Mild", 2: "Moderate", 3: "Severe", 4: "Proliferative DR"}
NUM_CLASSES = len(CLASS.keys())
SAVED_MODEL_NAME = 'model.h... | df["Embarked"].value_counts() | Titanic - Machine Learning from Disaster |
8,325,212 | train = pd.read_csv(INPUT_PATH + 'train.csv')
test = pd.read_csv(INPUT_PATH + 'test.csv' )<feature_engineering> | le = LabelEncoder()
le.fit(["S","C","Q"])
df["Embarked"] = le.fit_transform(df["Embarked"] ) | Titanic - Machine Learning from Disaster |
8,325,212 | train['images'] = train['id_code'].apply(lambda x: INPUT_PATH + "train_images/" + str(x)+ ".png")
test['images'] = test['id_code'].apply(lambda x: INPUT_PATH + "test_images/" + str(x)+ ".png")
train.drop(['id_code'],axis = 1, inplace =True)
train = train[['images','diagnosis']]<predict_on_test> | from sklearn.preprocessing import StandardScaler | Titanic - Machine Learning from Disaster |
8,325,212 | def get_preds_and_labels(model, generator):
preds = []
labels = []
for _ in range(int(np.ceil(generator.samples / BATCH_SIZE))):
x, y = next(generator)
preds.append(model.predict(x))
labels.append(y)
return np.concatenate(preds ).ravel() , np.concatenate(labels ).ravel()<train_model> | scaler = StandardScaler() | Titanic - Machine Learning from Disaster |
8,325,212 | class Metrics(Callback):
def on_train_begin(self, logs={}):
self.val_kappas = []
def on_epoch_end(self, epoch, logs={}):
y_pred, labels = get_preds_and_labels(model, val_generator)
y_pred = np.rint(y_pred ).astype(np.uint8 ).clip(0, 4)
_val_kappa = cohen_kappa_score(labels, y_pred, weights='quadratic')
self.va... | s = scaler.fit(df[["Fare"]] ) | Titanic - Machine Learning from Disaster |
8,325,212 | train_datagen = ImageDataGenerator(rotation_range=360,
horizontal_flip=True,
vertical_flip=True,
validation_split=0.15,
preprocessing_function=preprocess_image,
rescale=1 / 128.)
train_generator = train_datagen.flow_from_dataframe(train,
x_col='images',
y_col='diagnosis',
target_size=(DIM, DIM),
batch_size=BATCH_SIZE,
... | df["Fare"] = s.transform(df[["Fare"]])
df.head() | Titanic - Machine Learning from Disaster |
8,325,212 | class RAdam(keras.optimizers.Optimizer):
def __init__(self, lr=0.001, beta_1=0.9, beta_2=0.999,
epsilon=None, decay=0., weight_decay=0., amsgrad=False,
total_steps=0, warmup_proportion=0.1, min_lr=0., **kwargs):
super(RAdam, self ).__init__(**kwargs)
with K.name_scope(self.__class__.__name__):
self.iterations = K.va... | df["Male"] = pd.get_dummies(df["Sex"],drop_first=True ) | Titanic - Machine Learning from Disaster |
8,325,212 | class GroupNormalization(Layer):
def __init__(self,
groups=32,
axis=-1,
epsilon=1e-5,
center=True,
scale=True,
beta_initializer='zeros',
gamma_initializer='ones',
beta_regularizer=None,
gamma_regularizer=None,
beta_constraint=None,
gamma_constraint=None,
**kwargs):
super(GroupNormalization, self ).__init__(**kwargs)
... | df.drop("Sex",inplace=True,axis=1 ) | Titanic - Machine Learning from Disaster |
8,325,212 | resnet = ResNet50(weights=None,
include_top=False,
input_shape=(DIM, DIM, CHANNEL_SIZE))
resnet.load_weights('.. /input/resnet50-weights-file/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5' )<choose_model_class> | x = df[['Male','Agegroup','SibSp','Pclass', 'Parch', 'Fare', 'Embarked']].values
y = df["Survived"].values | Titanic - Machine Learning from Disaster |
8,325,212 | for i, layer in enumerate(resnet.layers):
if "batch_normalization" in layer.name:
effnet.layers[i] = GroupNormalization(groups=32, axis=-1, epsilon=0.00001 )<choose_model_class> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
8,325,212 | def build_model() :
model = Sequential()
model.add(resnet)
model.add(GlobalAveragePooling2D())
model.add(Dropout(0.5))
model.add(Dense(5, activation=elu))
model.add(Dense(1, activation="linear"))
model.compile(loss='mse',
optimizer=RAdam(lr=0.00005),
metrics=['mse', 'acc'])
print(model.summary())
return model
mod... | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
8,325,212 | kappa_metrics = Metrics()
es = EarlyStopping(monitor='val_loss', mode='auto', verbose=1, patience=12)
rlr = ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=4,
verbose=1,
mode='auto',
epsilon=0.0001)
with tf.device('/gpu:0'):
history = model.fit_generator(train_generator,
steps_per_epoch=train_generator.sam... | x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.35 ) | Titanic - Machine Learning from Disaster |
8,325,212 | model.load_weights(SAVED_MODEL_NAME )<compute_test_metric> | from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
8,325,212 | y_train_preds, train_labels = get_preds_and_labels(model, train_generator)
y_train_preds = np.rint(y_train_preds ).astype(np.uint8 ).clip(0, 4)
train_score = cohen_kappa_score(train_labels, y_train_preds, weights="quadratic")
y_val_preds, val_labels = get_preds_and_labels(model, val_generator)
y_val_preds = np.rint... | tree = DecisionTreeClassifier(max_depth=4,random_state=10 ) | Titanic - Machine Learning from Disaster |
8,325,212 | print(f"The Training Cohen Kappa Score is: {round(train_score, 5)}")
print(f"The Validation Cohen Kappa Score is: {round(val_score, 5)}" )<compute_train_metric> | tree.fit(x_train,y_train ) | Titanic - Machine Learning from Disaster |
8,325,212 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred <... | predict = tree.predict(x_test ) | Titanic - Machine Learning from Disaster |
8,325,212 | y_val_preds, val_labels = get_preds_and_labels(model, val_generator)
optR = OptimizedRounder()
optR.fit(y_val_preds, val_labels)
coefficients = optR.coefficients()
opt_val_predictions = optR.predict(y_val_preds, coefficients)
new_val_score = cohen_kappa_score(val_labels, opt_val_predictions, weights="quadratic" )<co... | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
8,325,212 | print(f"Optimized Thresholds:
{coefficients}
")
print(f"The Validation Quadratic Weighted Kappa(QWK)
\
with optimized rounding thresholds is: {round(new_val_score, 5)}
")
print(f"This is an improvement of {round(new_val_score - val_score, 5)}
\
over the unoptimized rounding" )<feature_engineering> | accuracy_score(y_test,predict ) | Titanic - Machine Learning from Disaster |
8,325,212 | test['diagnosis'] = np.zeros(test.shape[0])
test_generator = ImageDataGenerator(preprocessing_function=preprocess_image,
rescale=1 / 128.).flow_from_dataframe(test,
x_col='images',
y_col='diagnosis',
target_size=(DIM, DIM),
batch_size=BATCH_SIZE,
class_mode= 'other',
shuffle=False )<save_to_csv> | test = pd.read_csv(".. /input/titanic/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
8,325,212 | y_test,_ = get_preds_and_labels(model, test_generator)
y_test = optR.predict(y_test, coefficients ).astype(np.uint8)
test['diagnosis'] = y_test
test['id_code'] = test['id_code']
test.drop(['images'], axis = 1, inplace = True)
test.to_csv('submission.csv', index=False )<import_modules> | test.drop(['Cabin','Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,325,212 | import cv2
import matplotlib.pyplot as plt
from os.path import isfile
import torch.nn.init as init
import torch
import torch.nn as nn
from PIL import Image, ImageFilter
from sklearn.model_selection import train_test_split, StratifiedKFold
from torch.utils.data import Dataset
from torchvision import transforms
from torc... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | package_path = '.. /input/efficientnet/efficientnet-pytorch/EfficientNet-PyTorch/'
sys.path.append(package_path)
def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | package_dir = ".. /input/pretrained-models/pretrained-models/pretrained-models.pytorch-master/"
sys.path.insert(0, package_dir)
device = torch.device("cuda:0")
ImageFile.LOAD_TRUNCATED_IMAGES = True<load_from_csv> | test["Age"] = test[["Age","Pclass"]].apply(find_age,axis=1)
df.head() | Titanic - Machine Learning from Disaster |
8,325,212 | class RetinopathyDatasetTest(Dataset):
def __init__(self, csv_file, transform):
self.data = pd.read_csv(csv_file)
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
img_name = os.path.join('.. /input/aptos2019-blindness-detection/test_images', self.data.loc[idx, 'id_code']... | test = test.fillna(df.mean())
test.isnull().sum() | Titanic - Machine Learning from Disaster |
8,325,212 | BatchNormalization, Input, Conv2D, GlobalAveragePooling2D,concatenate,Concatenate)
WORKERS = 2
CHANNEL = 3
warnings.filterwarnings("ignore")
SIZE = 300
NUM_CLASSES = 5<load_from_csv> | le = LabelEncoder()
le.fit(["S","C","Q"])
test["Embarked"] = le.fit_transform(test["Embarked"] ) | Titanic - Machine Learning from Disaster |
8,325,212 | df_train = pd.read_csv('.. /input/aptos2019-blindness-detection/train.csv')
df_test = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
x = df_train['id_code']
y = df_train['diagnosis']
x, y = shuffle(x, y, random_state=8)
y = to_categorical(y, num_classes=NUM_CLASSES)
train_x, valid_x, train_y, valid... | le.fit(["male","female"])
test["Sex"] = le.fit_transform(test["Sex"])
test["Male"] = pd.get_dummies(test["Sex"],drop_first=True)
test.head() | Titanic - Machine Learning from Disaster |
8,325,212 | import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import style
import seaborn as sns
from sklearn.model_selection import StratifiedKFold
from joblib import load, dump
from sklearn.metrics import cohen_kappa_score
from sklearn.metrics import confusion_matrix
from fastai ... | scaler = StandardScaler() | Titanic - Machine Learning from Disaster |
8,325,212 | GlobalParams = collections.namedtuple('GlobalParams', [
'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate',
'num_classes', 'width_coefficient', 'depth_coefficient',
'depth_divisor', 'min_depth', 'drop_connect_rate', 'image_size'])
BlockArgs = collections.namedtuple('BlockArgs', [
'kernel_size', 'num_repeat', ... | s = scaler.fit(test[["Fare"]] ) | Titanic - Machine Learning from Disaster |
8,325,212 | img = np.loadtxt(".. /input/aptos2019-blindness-detection/train.csv",
delimiter=",",
skiprows=1,
usecols=(0),
dtype = "str"
)
img
label = np.loadtxt(".. /input/aptos2019-blindness-detection/train.csv",
delimiter=",",
skiprows=1,
usecols=(1),
dtype = "int"
)
label
img_label_trains = []
img_label_validations = []
for... | test["Fare"] = s.transform(test[["Fare"]])
test.head() | Titanic - Machine Learning from Disaster |
8,325,212 | d = pd.DataFrame(data=data, columns=columns, dtype='str')
d['diagnosis'] = d['diagnosis'].astype(int)
d.to_csv("submission_xce_.csv",index=False )<define_variables> | x = test[['Male', 'Agegroup', 'SibSp','Pclass', 'Parch', 'Fare', 'Embarked']].values | Titanic - Machine Learning from Disaster |
8,325,212 | wei = [0.4, 0.6]
ker = [submission3, d]<define_variables> | ypredict = tree.predict(x)
ypredict | Titanic - Machine Learning from Disaster |
8,325,212 | numClass = 5
subemp = np.zeros(( ker[0].shape[0],numClass))<prepare_output> | submission = pd.DataFrame({'PassengerId':test['PassengerId'],'Survived':ypredict} ) | Titanic - Machine Learning from Disaster |
8,325,212 | for i in range(len(ker)) :
subemp[ker[i].index, ker[i].diagnosis.tolist() ] += wei[i]
print(subemp)
<save_to_csv> | filename = 'Titanic1.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
7,976,123 | subKER = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
subKER['diagnosis'] = subemp.argmax(1 ).astype(int)
subKER.to_csv('submissionKER.csv', index=False )<define_variables> | sns.set()
pd.set_option('display.max_rows',None ) | Titanic - Machine Learning from Disaster |
7,976,123 | score = [0.777, 0.758, 0.749, 0.783]
weight = [0.29, 0.16, 0.09,0.06, 0.40]
subData = [submission1, submission2, d, submission3, submission4]
predsData = [preds1, preds2, preds4]<save_to_csv> | train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
7,976,123 | numClass = 5
subTemp = np.zeros(( subData[0].shape[0],numClass))
for i in range(len(subData)) :
subTemp[subData[i].index, subData[i].diagnosis.tolist() ] += weight[i]
print(subTemp)
sub = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
sub['diagnosis'] = subTemp.argmax(1 ).astype(int)
su... | print('Total by Sex')
print(train.Sex.value_counts())
print('
Total Survived by Sex')
print(train.loc[train.Survived==1].Sex.value_counts() ) | Titanic - Machine Learning from Disaster |
7,976,123 | numClass = 5
subTemp = np.zeros(( subData[0].shape[0],numClass))
for i in range(len(subData)) :
subTemp[subData[i].index, subData[i].diagnosis.tolist() ] += weight[i]
print(subTemp)
<save_to_csv> | train_with_age=train.query('Age!="NaN"')
print('Total Survived by Age under 10')
print(train_with_age.loc[train_with_age.Age <= 10].Survived.value_counts())
print('
Total Survived by Age between 10 and 20')
print(train_with_age.loc[(train_with_age.Age > 10)&(train_with_age.Age <= 20)].Survived.value_counts())
prin... | Titanic - Machine Learning from Disaster |
7,976,123 | sub = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
sub['diagnosis'] = subTemp.argmax(1 ).astype(int)
sub.to_csv('submission.csv', index=False )<load_from_csv> | print('Total by Pclass')
print(train.Pclass.value_counts())
print('
Total Survived by Pclass')
print(train.loc[train.Survived==1].Pclass.value_counts() ) | Titanic - Machine Learning from Disaster |
7,976,123 |
<set_options> | complete=pd.concat([train,test],ignore_index=True ) | Titanic - Machine Learning from Disaster |
7,976,123 | %matplotlib inline<define_variables> | complete.drop(['Cabin','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
7,976,123 | TRAINING = True<load_from_csv> | complete['Title']=complete.Name.str.extract('([A-Za-z]+)\.' ) | Titanic - Machine Learning from Disaster |
7,976,123 | test_df = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
print(test_df.shape)
if TRAINING:
train_df = pd.read_csv('.. /input/aptos2019-blindness-detection/train.csv')
print(train_df.shape)
train_df.head()<load_from_csv> | q1_fare=complete.Fare.quantile(0.25)
q3_fare=complete.Fare.quantile(0.75)
IQR=q3_fare-q1_fare
min_val=q1_fare-(IQR*1.5)
max_val=q3_fare+(IQR*1.5)
print('Minimum: {}'.format(min_val))
print('Maximum: {}'.format(max_val)) | Titanic - Machine Learning from Disaster |
7,976,123 |
<define_variables> | for row in range(len(complete)) :
if np.isnan(complete.loc[row,'Age'])==True:
complete.loc[row,'Age']=complete.loc[(complete.Title==(complete.loc[row,'Title'])) &(complete.SibSp==(complete.loc[row,'SibSp'])) ].Age.mean() | Titanic - Machine Learning from Disaster |
7,976,123 | IMG_SIZE = 224
NB_CHANNELS = 3<categorify> | complete.Fare.fillna(complete.Fare.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
7,976,123 | def get_pad_width(im, new_shape, is_rgb=True):
pad_diff = new_shape - im.shape[0], new_shape - im.shape[1]
t, b = math.floor(pad_diff[0]/2), math.ceil(pad_diff[0]/2)
l, r = math.floor(pad_diff[1]/2), math.ceil(pad_diff[1]/2)
if is_rgb:
pad_width =(( t,b),(l,r),(0, 0))
else:
pad_width =(( t,b),(l,r))
return pad_width
... | complete.loc[complete.Age.isna() ] | Titanic - Machine Learning from Disaster |
7,976,123 | if TRAINING:
N = train_df.shape[0]
x_train = np.empty(( N, 224, 224, 3), dtype=np.uint8)
for i, image_id in enumerate(tqdm(train_df['id_code'])) :
x_train[i, :, :, :] = preprocess_image(cv2.imread(
f'.. /input/aptos2019-blindness-detection/train_images/{image_id}.png'
))<prepare_x_and_y> | for row in range(len(complete)) :
if np.isnan(complete.loc[row,'Age'])==True:
complete.loc[row,'Age']=complete.loc[complete.Title==(complete.loc[row,'Title'])].Age.mean() | Titanic - Machine Learning from Disaster |
7,976,123 | N = test_df.shape[0]
x_test = np.empty(( N, 224, 224, 3), dtype=np.uint8)
for i, image_id in enumerate(tqdm(test_df['id_code'])) :
x_test[i, :, :, :] = preprocess_image(cv2.imread(
f'.. /input/aptos2019-blindness-detection/test_images/{image_id}.png'
))<categorify> | complete.drop(['Name','Embarked'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
7,976,123 | if TRAINING:
y_train = pd.get_dummies(train_df['diagnosis'] ).values
print(x_train.shape)
print(y_train.shape)
print(x_test.shape )<split> | def sex(x):
if x == 'male':
return 0
else:
return 1
complete['Sex']=complete.Sex.apply(sex ) | Titanic - Machine Learning from Disaster |
7,976,123 | if TRAINING:
x_train, x_val, y_train, y_val = train_test_split(
x_train, y_train,
test_size=0.2
)<filter> | def age(x):
if x <= 10:
return 0
elif x <= 20:
return 1
elif x <= 30:
return 2
elif x <= 45:
return 3
else:
return 4
complete['Age']=complete.Age.apply(age ) | Titanic - Machine Learning from Disaster |
7,976,123 |
<data_type_conversions> | train=complete.loc[0:890]
test=complete.loc[891:] | Titanic - Machine Learning from Disaster |
7,976,123 |
<categorify> | from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
7,976,123 |
<prepare_x_and_y> | def tuning_random_forest(MaxLeafNodes,MaxDepth,NEstimators):
model=RandomForestClassifier(random_state=1,max_leaf_nodes=MaxLeafNodes,max_depth=MaxDepth,n_estimators=NEstimators)
X=train[['Age','Fare','Pclass','Sex']]
y=train.Survived
X_train, X_test, y_train, y_test=train_test_split(X,y,test_size=0.2,random_state=1)
... | Titanic - Machine Learning from Disaster |
7,976,123 |
<data_type_conversions> | model=RandomForestClassifier(random_state=1,max_leaf_nodes=30,max_depth=10,n_estimators=200)
X=train[['Age','Fare','Pclass','Sex']]
y=train.Survived
X_train, X_test, y_train, y_test=train_test_split(X,y,test_size=0.2,random_state=1)
model.fit(X_train,y_train)
predicted=model.predict(X_test)
accuracy_score(y_test,pr... | Titanic - Machine Learning from Disaster |
7,976,123 |
<randomize_order> | test2=test.loc[:,['Age','Fare','Pclass','Sex']]
X=train[['Age','Fare','Pclass','Sex']]
y=train.Survived
model.fit(X,y)
predicted=model.predict(test2 ) | Titanic - Machine Learning from Disaster |
7,976,123 | if TRAINING:
indexes = np.random.permutation(len(x_train))
x_train = x_train[indexes]
y_train = y_train[indexes]<categorify> | test2=test.loc[:,['PassengerId']]
submission=pd.DataFrame({'PassengerId':test2.PassengerId,'Survived':predicted})
submission=submission.astype('int32')
submission.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
5,213,367 | if TRAINING:
for i in range(3, -1, -1):
y_train[:, i] = np.logical_or(y_train[:, i], y_train[:, i + 1])
y_val[:, i] = np.logical_or(y_val[:, i], y_val[:, i + 1])
print("Multilabel version:", y_train.sum(axis=0))<normalization> | train_data = '.. /input/titanic/train.csv'
test_data = '.. /input/titanic/test.csv'
| Titanic - Machine Learning from Disaster |
5,213,367 | if TRAINING:
for i in tqdm(range(len(x_val))):
x_val[i] = cv2.resize(x_val[i, 20: -20, 20: -20, :],(IMG_SIZE, IMG_SIZE))
for i in tqdm(range(len(x_train))):
x_train[i] = cv2.resize(x_train[i, 20: -20, 20: -20, :],(IMG_SIZE, IMG_SIZE))<define_variables> | train_set = pd.read_csv(train_data)
test_set = pd.read_csv(test_data ) | Titanic - Machine Learning from Disaster |
5,213,367 | class MixupGenerator() :
def __init__(self, X_train, y_train, seq=None, batch_size=32, alpha=0.2, shuffle=True, datagen=None):
self.X_train = X_train
self.y_train = y_train
self.batch_size = batch_size
self.alpha = alpha
self.shuffle = shuffle
self.sample_num = len(X_train)
self.datagen = datagen
self.seq = seq
def __... | train_set.isnull().sum(axis=0 ) | Titanic - Machine Learning from Disaster |
5,213,367 | BATCH_SIZE = 32
def create_datagen() :
return ImageDataGenerator(
preprocessing_function=seq.augment_image
)
if TRAINING:
data_generator = create_datagen().flow(x_train, y_train, batch_size=BATCH_SIZE)
mixup_generator = MixupGenerator(x_train, y_train, seq=seq, batch_size=BATCH_SIZE, alpha=0.2 )()<define_variables> | %matplotlib inline
sns.set_style('whitegrid')
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
5,213,367 | true_labels = np.array([1, 0, 1, 1, 0, 1])
pred_labels = np.array([1, 0, 0, 0, 0, 1] )<compute_test_metric> | train_set.isnull().sum() | Titanic - Machine Learning from Disaster |
5,213,367 | accuracy_score(true_labels, pred_labels )<compute_test_metric> | train_set['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
5,213,367 | cohen_kappa_score(true_labels, pred_labels )<predict_on_test> | train_set['Cabin'].value_counts().head() | Titanic - Machine Learning from Disaster |
5,213,367 | class Metrics(Callback):
def on_train_begin(self, logs={}):
self.val_kappas = []
def on_epoch_end(self, epoch, logs={}):
X_val, y_val = self.validation_data[:2]
y_val =(y_val.sum(axis=1)- 1 ).clip(0, 4)
y_pred = self.model.predict(X_val)> 0.5
y_pred =(y_pred.astype(int ).sum(axis=1)- 1 ).clip(0, 4)
_val_kappa = cohen... | merged = pd.concat([train_set,test_set], sort = False)
merged.head(3 ) | Titanic - Machine Learning from Disaster |
5,213,367 | base_model = Xception(
weights=None,
include_top=False,
input_shape=(224,224,3)
)
base_model.load_weights(".. /input/keras-pretrained-models/xception_weights_tf_dim_ordering_tf_kernels_notop.h5" )<choose_model_class> | merged['Cabin'].value_counts().head(3 ) | Titanic - Machine Learning from Disaster |
5,213,367 | def build_model() :
model = Sequential()
model.add(base_model)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(5, activation='sigmoid'))
model.compile(
loss='binary_crossentropy',
optimizer=Adam(lr=0.00005),
metrics=['accuracy']
)
return model<train_on_grid> | merged['Cabin'].fillna('X', inplace=True ) | Titanic - Machine Learning from Disaster |
5,213,367 | if TRAINING:
kappa_metrics = Metrics()
rlr = callbacks.ReduceLROnPlateau(factor=0.5, patience=4, verbose=1)
es = callbacks.EarlyStopping(patience=10, verbose=1, mode="min")
history = model.fit_generator(
data_generator,
steps_per_epoch=x_train.shape[0] / BATCH_SIZE,
epochs=200,
validation_data=(x_val, y_val),
callba... | merged['Title'] = merged['Name'].str.extract('([A-Za-z]+)\.')
merged['Title'].head() | Titanic - Machine Learning from Disaster |
5,213,367 | if TRAINING:
with open('history.json', 'w')as f:
json.dump(str(history.history), f)
history_df = pd.DataFrame(history.history)
history_df[['loss', 'val_loss']].plot()
history_df[['acc', 'val_acc']].plot()<data_type_conversions> | merged['Title'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 |
<save_to_csv> | merged['Title'].replace(to_replace = ['Dr', 'Rev', 'Col', 'Major', 'Capt'], value = 'Officer', inplace=True)
merged['Title'].replace(to_replace = ['Dona', 'Jonkheer', 'Countess', 'Sir', 'Lady', 'Don'], value = 'Aristocrat', inplace = True)
merged['Title'].replace({'Mlle':'Miss', 'Ms':'Miss', 'Mme':'Mrs'}, inplace = T... | Titanic - Machine Learning from Disaster |
5,213,367 | if TRAINING:
weights_path = 'model.h5'
else:
weights_path = '.. /input/weights/model.h5'
model.load_weights(weights_path)
y_test = model.predict(x_test)> 0.5
y_test =(y_test.astype(int ).sum(axis=1)- 1 ).clip(0, 4)
test_df['diagnosis'] = y_test
test_df.to_csv('submission.csv',index=False )<set_options> | merged['SibSp'].value_counts()
| Titanic - Machine Learning from Disaster |
5,213,367 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
%matplotlib inline
<define_variables> | merged['Parch'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | package_dir = '.. /input/efficientnet/efficientnet_pytorch'
sys.path.insert(0, package_dir)
<load_pretrained> | merged['Family_size'] = merged.SibSp + merged.Parch + 1
merged['Family_size'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1 )<load_from_csv> | merged['Family_size'].replace(to_replace = [1], value = 'single', inplace = True)
merged['Family_size'].replace(to_replace = [2,3], value = 'small', inplace = True)
merged['Family_size'].replace(to_replace = [4,5], value = 'medium', inplace = True)
merged['Family_size'].replace(to_replace = [6, 7, 8, 11], value = 'l... | Titanic - Machine Learning from Disaster |
5,213,367 | def get_df() :
base_image_dir = os.path.join('.. ', 'input/aptos2019-blindness-detection/')
train_dir = os.path.join(base_image_dir,'train_images/')
df = pd.read_csv(os.path.join(base_image_dir, 'train.csv'))
df['path'] = df['id_code'].map(lambda x: os.path.join(train_dir,'{}.png'.format(x)))
df = df.drop(columns=['... | merged['Family_size'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | bs = 64
sz = 224
tfms = get_transforms(do_flip=True,flip_vert=True )<compute_test_metric> | ticket = []
for x in list(merged['Ticket']):
if x.isdigit() :
ticket.append('N')
else:
ticket.append(x.replace('.','' ).replace('/','' ).strip().split(' ')[0])
merged['Ticket'] = ticket | Titanic - Machine Learning from Disaster |
5,213,367 | def qk(y_pred, y):
return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0' )<load_pretrained> | merged['Ticket'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | learn = Learner(data,
md_ef,
metrics = [qk],
model_dir="models" ).to_fp16()
learn.data.add_test(ImageList.from_df(test_df,
'.. /input/aptos2019-blindness-detection',
folder='test_images',
suffix='.png'))<train_model> | merged['Ticket'] = merged['Ticket'].apply(lambda x: x[0])
merged['Ticket'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | learn.fit_one_cycle(10,1e-3 )<compute_train_metric> | outliers(merged['Fare'] ) | Titanic - Machine Learning from Disaster |
5,213,367 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | merged.isnull().sum() | Titanic - Machine Learning from Disaster |
5,213,367 | def run_subm(learn=learn, coefficients=[0.5, 1.5, 2.5, 3.5]):
opt = OptimizedRounder()
preds,y = learn.get_preds(DatasetType.Test)
tst_pred = opt.predict(preds, coefficients)
test_df.diagnosis = tst_pred.astype(int)
test_df.to_csv('submission.csv',index=False)
print('done' )<set_options> | merged['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
5,213,367 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
<set_options> | merged['Embarked'].fillna(value = 'S', inplace=True ) | Titanic - Machine Learning from Disaster |
5,213,367 | warnings.filterwarnings('always')
warnings.filterwarnings('ignore')
%matplotlib inline
style.use('fivethirtyeight')
sns.set(style='whitegrid', color_codes=True)
<set_options> | merged['Fare'].fillna(value= merged['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
5,213,367 | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(42 )<feature_engineering> | df = merged.loc[:, ['Sex', 'Pclass', 'Embarked', 'Title', 'Family_size', 'Parch', 'SibSp', 'Cabin', 'Ticket']]
LE = LabelEncoder()
df = df.apply(LE.fit_transform)
df.head(5)
| Titanic - Machine Learning from Disaster |
5,213,367 | temp = vision.data.open_image
<load_from_csv> | df['Age'] = merged['Age']
df.head(2 ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.