kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,317,713 | models = []
for i in range(k):
print('i =', i)
model = build_model()
for j in range(k):
if i == j:
continue
current_pos_indexes = folds_indexes[i]
model.fit_generator(image_generator(current_pos_indexes), steps_per_epoch= len(current_pos_indexes)/ 16, epochs=20)
models.append(model )<find_best_params> | train['Parch'].value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | for model in models:
for j in range(k):
current_pos_indexes = folds_indexes[j]
print(model.evaluate_generator(image_generator(indexes=current_pos_indexes), steps=len(current_pos_indexes)/ 16))<define_variables> | train['Survived'].groupby(train['Parch'] ).mean() | Titanic - Machine Learning from Disaster |
11,317,713 | test_files = os.listdir('.. /input/test/test/' )<load_pretrained> | train['Ticket_Len'] = train['Ticket'].apply(lambda x: len(x))
train['Ticket_Len'].value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | preds = []
for _ in range(len(models)) :
preds.append([])
batch = 40
for i in range(int(4000/batch)) :
images = []
for j in range(batch):
img = mpimg.imread('.. /input/test/test/'+test_files[i*batch + j])
images += [img]
for k2 in range(len(models)) :
model = models[k2]
out = model.predict(np.array(images))
preds[k2]... | train['Ticket_Lett'] = train['Ticket'].apply(lambda x: str(x)[0])
train['Ticket_Lett'].value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | all_out = np.array(list(map(lambda x: np.array(x ).reshape(-1, 1), preds)) )<feature_engineering> | pd.qcut(train['Fare'], 3 ).value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | all_out = np.mean(all_out, axis=0 )<create_dataframe> | train['Survived'].groupby(pd.qcut(train['Fare'], 3)).mean() | Titanic - Machine Learning from Disaster |
11,317,713 | sub_file = pd.DataFrame(data = {'id': test_files, 'has_cactus': all_out.reshape(-1 ).tolist() } )<save_to_csv> | train['Cabin_Lett'] = train['Cabin'].apply(lambda x: str(x)[0])
train['Cabin_Lett'].value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | sub_file.to_csv('sample_submission.csv', index=False )<import_modules> | train['Survived'].groupby(train['Cabin_Lett'] ).mean() | Titanic - Machine Learning from Disaster |
11,317,713 | print(fastai.__version__ )<define_variables> | train['Cabin_num'] = train['Cabin'].apply(lambda x: str(x ).split(' ')[-1][1:])
train['Cabin_num'].replace('an', np.NaN, inplace = True)
train['Cabin_num'] = train['Cabin_num'].apply(lambda x: int(x)if not pd.isnull(x)and x != '' else np.NaN ) | Titanic - Machine Learning from Disaster |
11,317,713 | PATH = Path('.')
!ls {PATH}<load_from_csv> | pd.qcut(train['Cabin_num'],3 ).value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | df = pd.read_csv(PATH/'.. /input/train.csv'); df.head()<define_variables> | train['Survived'].groupby(pd.qcut(train['Cabin_num'], 3)).mean() | Titanic - Machine Learning from Disaster |
11,317,713 | bs = 128<feature_engineering> | def names(train, test):
for i in [train, test]:
i['Name_Len'] = i['Name'].apply(lambda x: len(x))
i['Name_Title'] = i['Name'].apply(lambda x: x.split(',')[1] ).apply(lambda x: x.split() [0])
del i['Name']
return train, test | Titanic - Machine Learning from Disaster |
11,317,713 | tfms = get_transforms(do_flip=True, flip_vert=True )<load_from_csv> | def age_impute(train, test):
for i in [train, test]:
i['Age_Null_Flag'] = i['Age'].apply(lambda x: 1 if pd.isnull(x)else 0)
data = train.groupby(['Name_Title', 'Pclass'])['Age']
i['Age'] = data.transform(lambda x: x.fillna(x.mean()))
return train, test | Titanic - Machine Learning from Disaster |
11,317,713 | data =(ImageList.from_csv(csv_name='train.csv', path=PATH/'.. /input', folder='train/train')
.split_by_rand_pct()
.label_from_df(cols='has_cactus')
.transform(tfms)
.add_test_folder('test/test')
.databunch(bs=bs)
.normalize(imagenet_stats))<define_variables> | def fam_size(train, test):
for i in [train, test]:
i['Fam_Size'] = np.where(( i['SibSp']+i['Parch'])== 0 , 'Alone',
np.where(( i['SibSp']+i['Parch'])<= 3,'Small', 'Big'))
del i['SibSp']
del i['Parch']
return train, test | Titanic - Machine Learning from Disaster |
11,317,713 | data.show_batch(rows=3, figsize=(7, 7))<find_best_params> | def cabin(train, test):
for i in [train, test]:
i['Cabin_Lett'] = i['Cabin'].apply(lambda x: str(x)[0])
del i['Cabin']
return train, test | Titanic - Machine Learning from Disaster |
11,317,713 | data.classes, data.c<choose_model_class> | def cabin_num(train, test):
for i in [train, test]:
i['Cabin_num1'] = i['Cabin'].apply(lambda x: str(x ).split(' ')[-1][1:])
i['Cabin_num1'].replace('an', np.NaN, inplace = True)
i['Cabin_num1'] = i['Cabin_num1'].apply(lambda x: int(x)if not pd.isnull(x)and x != '' else np.NaN)
i['Cabin_num'] = pd.qcut(train['Cabin_... | Titanic - Machine Learning from Disaster |
11,317,713 | learn = cnn_learner(data, models.resnet34, metrics=accuracy, path=PATH )<train_model> | train.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
11,317,713 | learn.fit_one_cycle(4 )<train_model> | train['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
11,317,713 | learn.fit_one_cycle(1 )<predict_on_test> | test[test.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
11,317,713 | probs, preds = learn.get_preds(ds_type=DatasetType.Test )<prepare_x_and_y> | train[(train.Pclass==3)&(train.Age>50)].Fare.median() | Titanic - Machine Learning from Disaster |
11,317,713 | ilst = data.test_ds.x<define_variables> | test['Fare'].fillna(7.75, inplace=True ) | Titanic - Machine Learning from Disaster |
11,317,713 | fnames = [item.name for item in ilst.items]; fnames[:10]<create_dataframe> | def dummies(train, test, columns = ['Pclass', 'Sex', 'Embarked', 'Ticket_Lett', 'Cabin_Lett', 'Name_Title', 'Fam_Size']):
for column in columns:
train[column] = train[column].apply(lambda x: str(x))
test[column] = test[column].apply(lambda x: str(x))
good_cols = [column+'_'+i for i in train[column].unique() if i in tes... | Titanic - Machine Learning from Disaster |
11,317,713 | test_df = pd.DataFrame({'id': fnames, 'has_cactus': probs[:, 1]}); test_df<save_to_csv> | def drop(train, test, bye = ['PassengerId']):
for i in [train, test]:
for z in bye:
del i[z]
return train, test | Titanic - Machine Learning from Disaster |
11,317,713 | test_df.to_csv('submission.csv', index=None )<set_options> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
train, test = names(train, test)
train, test = age_impute(train, test)
train, test = cabin_num(train, test)
train, test = cabin(train, test)
train, test = fam_size(train, test)
train, test = ticket_grouped(train, ... | Titanic - Machine Learning from Disaster |
11,317,713 | %matplotlib inline
train_on_gpu = True
<install_modules> | rf = RandomForestClassifier(criterion='gini',
n_estimators=700,
min_samples_split=10,
min_samples_leaf=1,
max_features='auto',
oob_score=True,
random_state=1,
n_jobs=-1)
rf.fit(train.iloc[:, 1:], train.iloc[:, 0])
print("%.4f" % rf.oob_score_ ) | Titanic - Machine Learning from Disaster |
11,317,713 | !pip install albumentations > /dev/null 2>&1
!pip install pretrainedmodels > /dev/null 2>&1
!pip install kekas > /dev/null 2>&1
!pip install adabound > /dev/null 2>&1<import_modules> | pd.concat(( pd.DataFrame(train.iloc[:, 1:].columns, columns = ['variable']),
pd.DataFrame(rf.feature_importances_, columns = ['importance'])) ,
axis = 1 ).sort_values(by='importance', ascending = False)[:20] | Titanic - Machine Learning from Disaster |
11,317,713 | import albumentations
from albumentations import torch as AT
import pretrainedmodels
import adabound
from kekas import Keker, DataOwner, DataKek
from kekas.transformations import Transformer, to_torch, normalize
from kekas.metrics import accuracy
from kekas.modules import Flatten, AdaptiveConcatPool2d
from kekas.callba... | predictions = rf.predict(test)
predictions = pd.DataFrame(predictions, columns=['Survived'])
test = pd.read_csv(".. /input/titanic/test.csv")
predictions = pd.concat(( test.iloc[:, 0], predictions), axis = 1)
predictions.to_csv('submission.csv', sep=",", index = False ) | Titanic - Machine Learning from Disaster |
4,286,398 | labels = pd.read_csv('.. /input/train.csv')
fig = plt.figure(figsize=(25, 8))
train_imgs = os.listdir(".. /input/train/train")
for idx, img in enumerate(np.random.choice(train_imgs, 20)) :
ax = fig.add_subplot(4, 20//4, idx+1, xticks=[], yticks=[])
im = Image.open(".. /input/train/train/" + img)
plt.imshow(im)
lab... | sns.set_palette('viridis')
sns.set_style('whitegrid')
%matplotlib inline
np.random.seed(42 ) | Titanic - Machine Learning from Disaster |
4,286,398 | test_img = os.listdir('.. /input/test/test')
test_df = pd.DataFrame(test_img, columns=['id'])
test_df['has_cactus'] = -1
test_df['data_type'] = 'test'
labels['has_cactus'] = labels['has_cactus'].astype(int)
labels['data_type'] = 'train'
labels.head()<count_values> | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,286,398 | labels.loc[labels['data_type'] == 'train', 'has_cactus'].value_counts()<split> | def get_df_by_group(df, group):
df_groupedby = df.groupby(group ).agg({'PassengerId':'count', 'Survived': 'sum'} ).rename(columns={'PassengerId': 'NumPassengers'})
df_groupedby['Rate'] = df_groupedby['Survived'] / df_groupedby['NumPassengers']
return df_groupedby
df = train_df.copy() | Titanic - Machine Learning from Disaster |
4,286,398 | train, valid = train_test_split(labels, stratify=labels.has_cactus, test_size=0.2 )<load_from_csv> | train_groupby_sex = get_df_by_group(df, ['Sex'])
train_groupby_sex | Titanic - Machine Learning from Disaster |
4,286,398 | def reader_fn(i, row):
image = cv2.imread(f".. /input/{row['data_type']}/{row['data_type']}/{row['id']}")[:,:,::-1]
label = torch.Tensor([row["has_cactus"]])
return {"image": image, "label": label}<concatenate> | train_groupby_pclass = get_df_by_group(df, ['Pclass'])
train_groupby_pclass | Titanic - Machine Learning from Disaster |
4,286,398 | def augs(p=0.5):
return albumentations.Compose([
albumentations.HorizontalFlip() ,
albumentations.VerticalFlip() ,
albumentations.RandomBrightness() ,
], p=p )<categorify> | df['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
4,286,398 | def get_transforms(dataset_key, size, p):
PRE_TFMS = Transformer(dataset_key, lambda x: cv2.resize(x,(size, size)))
AUGS = Transformer(dataset_key, lambda x: augs()(image=x)["image"])
NRM_TFMS = transforms.Compose([
Transformer(dataset_key, to_torch()),
Transformer(dataset_key, normalize())
])
train_tfms = transfor... | def fill_embarked_nan(df):
return df['Embarked'].fillna(value='S')
df['Embarked'] = fill_embarked_nan(df)
df['Embarked'].isnull().any() | Titanic - Machine Learning from Disaster |
4,286,398 | train_tfms, val_tfms = get_transforms("image", 32, 0.5 )<load_pretrained> | class_median_age_series = df.groupby(['Pclass'])['Age'].median()
class_median_age_series | Titanic - Machine Learning from Disaster |
4,286,398 | train_dk = DataKek(df=train, reader_fn=reader_fn, transforms=train_tfms)
val_dk = DataKek(df=valid, reader_fn=reader_fn, transforms=val_tfms)
batch_size = 64
workers = 0
train_dl = DataLoader(train_dk, batch_size=batch_size, num_workers=workers, shuffle=True, drop_last=True)
val_dl = DataLoader(val_dk, batch_size=ba... | def fill_age_nan(df):
return df[['Age', 'Pclass']].apply(lambda x: class_median_age_series.get(x['Pclass'])if(pd.isnull(x['Age'])) else x['Age'], axis=1)
df['Age'] = fill_age_nan(df ) | Titanic - Machine Learning from Disaster |
4,286,398 | test_dk = DataKek(df=test_df, reader_fn=reader_fn, transforms=val_tfms)
test_dl = DataLoader(test_dk, batch_size=batch_size, num_workers=workers, shuffle=False )<init_hyperparams> | def ageclass_by_age(age):
if age < 10:
return '< 10'
elif(age >= 10 and age < 20):
return '>= 10 and < 20'
elif(age >= 20 and age < 35):
return '>= 20 and < 35'
elif(age >= 35 and age < 50):
return '>= 35 and < 50'
elif(age >= 50 and age < 65):
return '>= 50 and < 65'
else:
return '> 65'
def convert_age_to_ageclass(df)... | Titanic - Machine Learning from Disaster |
4,286,398 | class Net(nn.Module):
def __init__(
self,
num_classes: int,
p: float = 0.2,
pooling_size: int = 2,
last_conv_size: int = 1664,
arch: str = "densenet169",
pretrained: str = "imagenet")-> None:
super().__init__()
net = pretrainedmodels.__dict__[arch](pretrained=pretrained)
modules = list(net.children())[:-1]
modules ... | train_groupby_age = get_df_by_group(df, ['Age'])
train_groupby_age | Titanic - Machine Learning from Disaster |
4,286,398 | dataowner = DataOwner(train_dl, val_dl, None)
model = Net(num_classes=1)
criterion = nn.BCEWithLogitsLoss()<categorify> | def extract_title_from_name(df):
return df['Name'].apply(lambda x:(x[x.index(',')+ 1:x.index('.')] ).strip())
df['Title'] = extract_title_from_name(df)
df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
4,286,398 | def step_fn(model: torch.nn.Module,
batch: torch.Tensor)-> torch.Tensor:
inp = batch["image"]
return model(inp )<compute_test_metric> | def reduce_list_titles(title):
if(title in ['Mrs', 'Miss', 'Master', 'Mr', 'Dr']):
title = title
elif(title in ['Ms','Mme']):
title = 'Mrs'
elif(title in ['Mlle', 'Lady']):
title = 'Miss'
elif(title in ['Don']):
title = 'Mr'
else:
title = 'Other'
return title
def convert_title_to_reduced_list(df):
return df['Title'].ap... | Titanic - Machine Learning from Disaster |
4,286,398 | def bce_accuracy(target: torch.Tensor,
preds: torch.Tensor,
thresh: bool = 0.5)-> float:
target = target.cpu().detach().numpy()
preds =(torch.sigmoid(preds ).cpu().detach().numpy() > thresh ).astype(int)
return accuracy_score(target, preds)
def roc_auc(target: torch.Tensor,
preds: torch.Tensor)-> float:
target = targ... | train_groupby_title = get_df_by_group(df, ['Title'])
train_groupby_title.sort_values(by='Rate', ascending=False ) | Titanic - Machine Learning from Disaster |
4,286,398 | keker = Keker(model=model,
dataowner=dataowner,
criterion=criterion,
step_fn=step_fn,
target_key="label",
metrics={"acc": bce_accuracy, 'auc': roc_auc},
opt=torch.optim.SGD,
opt_params={"momentum": 0.99} )<load_pretrained> | def convert_family_size_cat(df):
family_members=df['Parch'] + df['SibSp']
if(family_members == 0):
return 'NO_FAMILY'
if(family_members <= 3 and family_members >=0):
return 'SMALL_FAMILY'
else:
return 'BIG_FAMILY'
def convert_parch_and_sibsp_to_family_cat(df):
return df.apply(convert_family_size_cat, axis=1)
df['Famil... | Titanic - Machine Learning from Disaster |
4,286,398 | keker.unfreeze(model_attr="net")
layer_num = -1
keker.freeze_to(layer_num, model_attr="net" )<find_best_params> | train_groupby_family = get_df_by_group(df, ['Family'])
train_groupby_family.sort_values(by='Family', ascending=False ) | Titanic - Machine Learning from Disaster |
4,286,398 | keker.kek_one_cycle(max_lr=1e-2,
cycle_len=5,
momentum_range=(0.95, 0.85),
div_factor=25,
increase_fraction=0.3,
logdir='train_logs')
keker.plot_kek('train_logs' )<find_best_params> | def fill_cabin_nan(df):
return df['Cabin'].apply(lambda x: str(x)[0] if(pd.notnull(x)) else str('O'))
df['Cabin'] = fill_cabin_nan(df ) | Titanic - Machine Learning from Disaster |
4,286,398 | keker.kek_one_cycle(max_lr=1e-3,
cycle_len=5,
momentum_range=(0.95, 0.85),
div_factor=25,
increase_fraction=0.2,
logdir='train_logs1')
keker.plot_kek('train_logs1' )<predict_on_test> | train_groupby_cabin = get_df_by_group(df, ['Cabin'])
train_groupby_cabin.sort_values(by='Rate', ascending=False ) | Titanic - Machine Learning from Disaster |
4,286,398 | preds = keker.predict_loader(loader=test_dl )<categorify> | grouped_df = df.groupby(['Sex', 'Age', 'Pclass', 'Family', 'Title'] ).agg({'PassengerId':'count', 'Survived': 'sum'} ).rename(columns={'PassengerId': 'NumPassengers'})
grouped_df['Rate'] = grouped_df['Survived'] / grouped_df['NumPassengers']
grouped_df = grouped_df.reset_index()
grouped_df.head(10 ) | Titanic - Machine Learning from Disaster |
4,286,398 |
<save_to_csv> | def convert_to_categories_and_fill_nan(X):
df = pd.DataFrame(X, columns=cat_attributes)
df['Title'] = extract_title_from_name(df)
df['Title'] = convert_title_to_reduced_list(df)
df['Embarked'] = fill_embarked_nan(df)
df['Age'] = fill_age_nan(df)
df['Age'] = convert_age_to_ageclass(df)
df['Family'] = convert_parch... | Titanic - Machine Learning from Disaster |
4,286,398 | test_preds = pd.DataFrame({'imgs': test_df.id.values, 'preds': preds.reshape(-1,)})
test_preds.columns = ['id', 'has_cactus']
test_preds.to_csv('sub.csv', index=False)
test_preds.head()<load_from_csv> | cat_attributes = ['Pclass', 'Age', 'Sex', 'Embarked', 'Cabin', 'Name', 'SibSp', 'Parch']
num_attributes = ['Fare'] | Titanic - Machine Learning from Disaster |
4,286,398 | data_path = '.. /input/'
df_train = pd.read_csv(data_path + 'train.csv')
df_test = pd.read_csv(data_path + 'test.csv')
df_train = df_train.sample(n=5000000)
print(df_train.shape)
print(df_test.shape )<count_missing_values> | num_pipeline = Pipeline([
('imputer', SimpleImputer(strategy='most_frequent')) ,
('std_scaler', StandardScaler())
])
cat_pipeline = Pipeline([
('convert_to_categories_and_fill_nan', FunctionTransformer(convert_to_categories_and_fill_nan, validate=False)) ,
('cat_encoder', OneHotEncoder())
] ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train.isnull().sum()<count_missing_values> | full_pipeline = ColumnTransformer([
('num', num_pipeline, num_attributes),
('cat', cat_pipeline, cat_attributes)
] ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.dropna()
df_train.isnull().sum()<count_missing_values> | X_train = train_df[['Fare','Sex', 'Pclass', 'Age', 'SibSp', 'Parch', 'Embarked', 'Cabin', 'Name']].copy()
X_test = test_df[['Fare','Sex', 'Pclass', 'Age', 'SibSp', 'Parch','Embarked', 'Cabin', 'Name']].copy()
y_train = train_df['Survived']
X_train.info() | Titanic - Machine Learning from Disaster |
4,286,398 | df_test.isnull().sum()<filter> | X_concat = pd.concat([X_train, X_test])
X_concat_prepared = full_pipeline.fit_transform(X_concat)
X_train_prepared = X_concat_prepared[:891]
X_test_prepared = X_concat_prepared[891:]
X_train_prepared[:10] | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.loc[(df_train['fare_amount'] > 0)&(df_train['fare_amount'] < 200)]
df_train = df_train.loc[(df_train['pickup_longitude'] > -300)&(df_train['pickup_longitude'] < 300)]
df_train = df_train.loc[(df_train['pickup_latitude'] > -300)&(df_train['pickup_latitude'] < 300)]
df_train = df_train.loc[(df_train['... | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score, cross_val_predict
from sklearn.metrics import precision_score, recall_score, confusion_matrix, precision_score, recall_score, f1_score, classification_report
from ... | Titanic - Machine Learning from Disaster |
4,286,398 | df_test = df_test.loc[(df_test['pickup_longitude'] > -300)&(df_test['pickup_longitude'] < 300)]
df_test = df_test.loc[(df_test['pickup_latitude'] > -300)&(df_test['pickup_latitude'] < 300)]
df_test = df_test.loc[(df_test['dropoff_longitude'] > -300)&(df_test['dropoff_longitude'] < 300)]
df_test = df_test.loc[(df_test['... | logistic_reg = LogisticRegression(solver='lbfgs',max_iter=1000,random_state=101)
y_logistic_score = cross_val_score(logistic_reg, X_train_prepared, y_train, cv=10, scoring='accuracy')
y_logistic_score.mean() | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.drop(['index'], axis=1)
df_train.head()<prepare_x_and_y> | y_logistic_pred = cross_val_predict(logistic_reg, X_train_prepared, y_train, cv=10 ) | Titanic - Machine Learning from Disaster |
4,286,398 | ids = df_test['key']
train_Y = df_train['fare_amount']
df_train = df_train.drop(['fare_amount'], axis=1)
print(df_train.shape)
print(df_test.shape )<data_type_conversions> | confusion_matrix(y_train, y_logistic_pred ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train['pickup_datetime'] = df_train['pickup_datetime'].apply(lambda x: datetime.datetime.strptime(x, '%Y-%m-%d %H:%M:%S UTC'))
df_train['pickup_year'] = df_train['pickup_datetime'].apply(lambda x: datetime.datetime.strftime(x, '%Y')).astype('int64')
df_train['pickup_month'] = df_train['pickup_datetime'].apply(lambd... | precision_score(y_train, y_logistic_pred ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.drop(['pickup_datetime'], axis=1)
df_test = df_test.drop(['pickup_datetime'], axis=1 )<feature_engineering> | recall_score(y_train, y_logistic_pred ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train['longitude_diff'] = df_train['dropoff_longitude'] - df_train['pickup_longitude']
df_train['latitude_diff'] = df_train['dropoff_latitude'] - df_train['pickup_latitude']
df_train['distance'] =(( df_train['longitude_diff']**2)+(df_train['latitude_diff']**2)) **0.5
df_test['longitude_diff'] = df_test['dropoff_long... | f1_score(y_train, y_logistic_pred ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.drop(['key'], axis=1)
df_test = df_test.drop(['key'], axis=1 )<train_model> | print(classification_report(y_train,y_logistic_pred)) | Titanic - Machine Learning from Disaster |
4,286,398 | x_train,x_test,y_train,y_test = train_test_split(df_train, train_Y, test_size=0.2, random_state=0)
def xgbmodel(x_train,x_test,y_train,y_test):
matrix_train = xgb.DMatrix(x_train, label=y_train)
matrix_test = xgb.DMatrix(x_test, label=y_test)
model = xgb.train(params={'objective':'reg:linear', 'eval_metric':'rmse'},... | y_decision_function = cross_val_predict(logistic_reg, X_train_prepared, y_train, cv=10, method='decision_function' ) | Titanic - Machine Learning from Disaster |
4,286,398 | submission = pd.DataFrame({'key':ids, 'fare_amount':pred})
submission.to_csv('submission.csv', index=False )<load_from_csv> | threshold = 2
print(confusion_matrix(y_train, y_decision_function > threshold))
print(precision_score(y_train, y_decision_function > threshold))
print(recall_score(y_train, y_decision_function > threshold)) | Titanic - Machine Learning from Disaster |
4,286,398 | nyc_weather = pd.read_csv('.. /input/nyc-weather/nyc_weather.csv')
weather_cols = ['DATE','AWND','PRCP','SNOW','TMAX','TMIN']
nyc_weather = nyc_weather[weather_cols].copy()
nyc_weather['DATE'] = pd.to_datetime(nyc_weather['DATE'], utc=True, format='%m/%d/%Y')
nyc_weather.head()
<load_from_csv> | threshold = -2
print(confusion_matrix(y_train, y_decision_function > threshold))
print(precision_score(y_train, y_decision_function > threshold))
print(recall_score(y_train, y_decision_function > threshold)) | Titanic - Machine Learning from Disaster |
4,286,398 | holidays = pd.read_csv('.. /input/us-bank-holidays-20092018/US Bank Holidays 2012-2018.csv')
holidays['Date'] = pd.to_datetime(holidays['Date'], utc=True, format='%m/%d/%y')
holidays.head(12 )<load_from_csv> | precisions, recalls, thresholds = precision_recall_curve(y_train, y_decision_function ) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
n = sum(1 for line in open('.. /input/new-york-city-taxi-fare-prediction/train.csv')) - 1
s = 10000000
skip = sorted(random.sample(range(1,n+1),n-s))
train_full = pd.read_csv('.. /input/new-york-city-taxi-fare-prediction/train.csv', skiprows=skip)
test = pd.read_csv('.. /input/new-york-city-taxi-fare-prediction... | roc_auc_score(y_train, y_decision_function ) | Titanic - Machine Learning from Disaster |
4,286,398 | train_one = train_full.iloc[:2500000,:]
train_two = train_full.iloc[2500000:5000000,:]
train_three = train_full.iloc[5000000:7500000,:]
train_four = train_full.iloc[7500000:,:]
train_one.head()<data_type_conversions> | param_grid = {
'penalty': ['l1', 'l2'],
'C': [0.01,0.1,0.9,0.95]
}
logistic_reg = LogisticRegression()
grid_search = GridSearchCV(logistic_reg, param_grid, cv=5,scoring='accuracy')
grid_search.fit(X_train_prepared, y_train ) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_sample = train_one.dropna()
train_sample['pickup_datetime'] = train_sample.pickup_datetime.str.slice(0, 16)
test['pickup_datetime'] = test.pickup_datetime.str.slice(0, 16)
train_sample['pickup_datetime'] = pd.to_datetime(train_sample.pickup_datetime, utc=True, format='%Y-%m-%d %H:%M')
test['pickup_datet... | print(grid_search.best_params_)
print(grid_search.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_sample = train_two.dropna()
train_sample['pickup_datetime'] = train_sample.pickup_datetime.str.slice(0, 16)
train_sample['pickup_datetime'] = pd.to_datetime(train_sample.pickup_datetime, utc=True, format='%Y-%m-%d %H:%M')
train_sample.drop(labels='key', axis=1, inplace=True)
train_sample.loc[:,'passenge... | means = grid_search.cv_results_['mean_test_score']
stds = grid_search.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_sample = train_three.dropna()
train_sample['pickup_datetime'] = train_sample.pickup_datetime.str.slice(0, 16)
train_sample['pickup_datetime'] = pd.to_datetime(train_sample.pickup_datetime, utc=True, format='%Y-%m-%d %H:%M')
train_sample.drop(labels='key', axis=1, inplace=True)
train_sample.loc[:,'passen... | param_grid = {
'n_neighbors':[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]
}
grid_search_knn = GridSearchCV(KNeighborsClassifier() , param_grid, cv=5, scoring='accuracy')
grid_search_knn.fit(X_train_prepared, y_train ) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_sample = train_four.dropna()
train_sample['pickup_datetime'] = train_sample.pickup_datetime.str.slice(0, 16)
train_sample['pickup_datetime'] = pd.to_datetime(train_sample.pickup_datetime, utc=True, format='%Y-%m-%d %H:%M')
train_sample.drop(labels='key', axis=1, inplace=True)
train_sample.loc[:,'passeng... | print(grid_search_knn.best_params_)
print(grid_search_knn.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | train_full_pre = pd.concat([train_one, train_two, train_three,train_four] )<drop_column> | means = grid_search_knn.cv_results_['mean_test_score']
stds = grid_search_knn.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search_knn.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | del train_full<concatenate> | param_grid = [
{'kernel':['rbf'], 'C':[0.7,0.8,1], 'gamma':[0.07, 0.08, 0.09]},
{'kernel':['poly'],'C':[0.1,1,10,100], 'gamma':['auto']}
]
grid_search_svc = GridSearchCV(SVC() , param_grid, cv=5, scoring='accuracy')
grid_search_svc.fit(X_train_prepared, y_train ) | Titanic - Machine Learning from Disaster |
4,286,398 | train_sample = train_full_pre.copy()
full_pickups = pd.concat([train_sample[['pickup_longitude','pickup_latitude']],test[['pickup_longitude','pickup_latitude']]], axis = 0)
full_pickups.columns = ['x','y']
full_dropoffs = pd.concat([train_sample[['dropoff_longitude','dropoff_latitude']],test[['dropoff_longitude','drop... | print(grid_search_svc.best_params_)
print(grid_search_svc.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
X_df = full_locs.copy()
X_kmeans = full_locs.values
del full_locs
num_clusters = 200
with open('.. /input/taxi-weather-holidays-kmeans-neighborhoods/kmeans_200_round4.pkl', 'rb')as fid:
kmeans = pickle.load(fid)
z = kmeans.predict(X_kmeans)
centers = kmeans.cluster_centers_
x_centers = [pair[0] for pair in cen... | means = grid_search_svc.cv_results_['mean_test_score']
stds = grid_search_svc.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search_knn.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | del X_kmeans, X_df
train_one['pickup_neighborhood'] = kmeans.predict(np.column_stack([train_one.pickup_longitude.values,train_one.pickup_latitude.values]))
train_one['dropoff_neighborhood'] = kmeans.predict(np.column_stack([train_one.dropoff_longitude.values,train_one.dropoff_latitude.values]))
train_one['pickup_neighb... | param_grid = {
'max_features':[8,9,10,11,12,13],
'max_leaf_nodes':[7,8,9,10,11],
'min_samples_split':[3,4,5]
}
grid_search_tree = GridSearchCV(DecisionTreeClassifier() , param_grid, cv=5, scoring='accuracy')
grid_search_tree.fit(X_train_prepared, y_train ) | Titanic - Machine Learning from Disaster |
4,286,398 | with open('kmeans_minibatch_200_round4_v2.pkl', 'wb')as fid:
pickle.dump(kmeans, fid)
<drop_column> | print(grid_search_tree.best_params_)
print(grid_search_tree.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | del KMeans, le_dict, MiniBatchKMeans,StandardScaler, calculate_distance, centers, degree_to_radion, holidays, kmeans,nyc_weather, pickle, z, z_centers, x_centers, y_centers<set_options> | means = grid_search_tree.cv_results_['mean_test_score']
stds = grid_search_tree.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search_tree.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | gc.collect()
dir()<concatenate> | feature_importance_list = grid_search_tree.best_estimator_.feature_importances_
list_categories = full_pipeline.named_transformers_['cat']['cat_encoder'].categories_
flat_list = [item for sublist in list_categories for item in sublist]
attribute_list = num_attributes + flat_list
df_attribute_importance = pd.DataFrame({... | Titanic - Machine Learning from Disaster |
4,286,398 | train_full = pd.concat([train_one, train_two, train_three, train_four] )<categorify> | ada_boost_clf = AdaBoostClassifier(DecisionTreeClassifier() , random_state=42)
param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
"base_estimator__splitter" : ["best", "random"],
"algorithm" : ["SAMME","SAMME.R"],
"n_estimators" :[1,2,3],
"learning_rate": [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3,1.5]}
grid_se... | Titanic - Machine Learning from Disaster |
4,286,398 | categorical_cols = ['pickup_neighborhood','dropoff_neighborhood','day_hour','month','year','passenger_count','holiday','hot_day','cold_day','rainy_day','snowy_day','windy_day']
numerical_cols = ['distance']
df_cats = train_full[categorical_cols].copy()
le_dict = {}
for col in categorical_cols:
le_dict[col] = LabelEncod... | print(grid_search_ada.best_params_)
print(grid_search_ada.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | df = test.copy()
df_cats = df[categorical_cols].copy()
le_dict = {}
for col in categorical_cols:
le_dict[col] = LabelEncoder().fit(df_cats[col])
df_cats[col] = le_dict[col].transform(df_cats[col])
X_cats_full = df_cats.values
X_onehot = ohe.transform(X_cats_full)
del df_cats, X_cats_full
X_nums_full = df[numerical_c... | means = grid_search_ada.cv_results_['mean_test_score']
stds = grid_search_ada.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search_ada.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | X_train, X_test, y_train, y_test = train_test_split(X,y,test_size =.1)
<init_hyperparams> | feature_importance_list = grid_search_ada.best_estimator_.feature_importances_
list_categories = full_pipeline.named_transformers_['cat']['cat_encoder'].categories_
flat_list = [item for sublist in list_categories for item in sublist]
attribute_list = num_attributes + flat_list
df_attribute_importance = pd.DataFrame({'... | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
params = {'objective': 'regression',
'boosting': 'gbdt',
'metric': 'rmse',
'num_leaves': 50,
'max_depth': 8,
'learning_rate': 0.5,
'bagging_fraction': 0.8,
'feature_fraction': 0.8,
'min_split_gain': 0.02,
'min_child_samples': 10,
'min_child_weight': 0.02,
'lambda_l2': 0.0475,
'verbosity': -1,
'data_random_seed':... | gradient_boost_clf = GradientBoostingClassifier(DecisionTreeClassifier() , random_state=42)
param_grid = {'loss' : ["deviance"],
'n_estimators' : [300, 400, 500],
'learning_rate': [0.2, 0.15, 0.1],
'max_depth': [3, 4, 6, 8],
'min_samples_leaf': [60, 80, 100],
'max_features': [0.5, 0.3, 0.1]
}
grid_search_gradient_boos... | Titanic - Machine Learning from Disaster |
4,286,398 | lgb_public= model_lgb.predict(X_public, num_iteration=model_lgb.best_iteration)
final_pred_public =lgb_public.flatten()
test_predictions_lgb = [float(np.asscalar(x)) for x in final_pred_public]
test_predictions_lgb = [x if x>0 else 0 for x in test_predictions_lgb]
sample = pd.DataFrame({'key': test_id,'fare_amount':te... | print(grid_search_gradient_boost.best_params_)
print(grid_search_gradient_boost.best_score_ ) | Titanic - Machine Learning from Disaster |
4,286,398 | plt.style.use('dark_background')
sns.set_style("darkgrid")
<define_variables> | means = grid_search_gradient_boost.cv_results_['mean_test_score']
stds = grid_search_gradient_boost.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, grid_search_gradient_boost.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_path = '.. /input/train.csv'
traintypes = {'fare_amount': 'float32',
'pickup_datetime': 'str',
'pickup_longitude': 'float32',
'pickup_latitude': 'float32',
'dropoff_longitude': 'float32',
'dropoff_latitude': 'float32',
'passenger_count': 'uint8'}
cols = list(traintypes.keys())
train_df = pd.read_csv(train... | param_grid = {
'bootstrap': [True],
'max_depth': [80,120,140],
'max_features':[4,5,6,7,8],
'min_samples_leaf':[2,3,4],
'min_samples_split':[8,10,12,14,16],
'n_estimators': [100,200,300,500,1000]
}
forest2_clf = RandomForestClassifier()
rnd_search = RandomizedSearchCV(forest2_clf, param_distributions=param_grid,
n_iter=... | Titanic - Machine Learning from Disaster |
4,286,398 | %%time
train_df.to_feather('nyc_taxi_data_raw.feather' )<load_from_csv> | rnd_search.best_params_ | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = pd.read_feather('nyc_taxi_data_raw.feather')
<filter> | rnd_search.best_score_ | Titanic - Machine Learning from Disaster |
4,286,398 | len(df_train[df_train.fare_amount > 0] )<drop_column> | means = rnd_search.cv_results_['mean_test_score']
stds = rnd_search.cv_results_['std_test_score']
for mean, std, params in zip(means, stds, rnd_search.cv_results_['params']):
print("%0.3f(+/-%0.03f)for %r"
%(mean, std * 2, params)) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train[df_train.fare_amount>=0]<count_missing_values> | feature_importance_list = rnd_search.best_estimator_.feature_importances_ | Titanic - Machine Learning from Disaster |
4,286,398 | df_train.isnull().sum()<drop_column> | list_categories = full_pipeline.named_transformers_['cat']['cat_encoder'].categories_
flat_list = [item for sublist in list_categories for item in sublist]
attribute_list = num_attributes + flat_list
df_attribute_importance = pd.DataFrame({'attribute_name': attribute_list, 'importance': feature_importance_list})
df_at... | Titanic - Machine Learning from Disaster |
4,286,398 | df_train = df_train.dropna(how = 'any', axis = 'rows')
<load_from_csv> | best_estimator = rnd_search.best_estimator_ | Titanic - Machine Learning from Disaster |
4,286,398 | df_test = pd.read_csv('.. /input/test.csv')
df_test.head(5 )<data_type_conversions> | y_test_predictions = best_estimator.predict(X_test_prepared ) | Titanic - Machine Learning from Disaster |
4,286,398 | df_train['pickup_datetime'] = pd.to_datetime(df_train['pickup_datetime'],format="%Y-%m-%d %H:%M:%S UTC" )<data_type_conversions> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": y_test_predictions
})
submission.head() | Titanic - Machine Learning from Disaster |
4,286,398 | <feature_engineering><EOS> | submission.to_csv('submission5.csv', index=False ) | Titanic - Machine Learning from Disaster |
4,211,056 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
4,211,056 | df_train = add_new_date_time_features(df_train)
df_test = add_new_date_time_features(df_test )<feature_engineering> | trainData = pd.read_csv('.. /input/train.csv')
testData = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
4,211,056 | def calculate_abs_different(df):
df['abs_diff_longitude'] =(df.dropoff_longitude - df.pickup_longitude ).abs()
df['abs_diff_latitude'] =(df.dropoff_latitude - df.pickup_latitude ).abs()
calculate_abs_different(df_train)
calculate_abs_different(df_test )<feature_engineering> | print(trainData.dtypes.sort_values())
print(testData.dtypes.sort_values() ) | Titanic - Machine Learning from Disaster |
4,211,056 | def convert_different_miles(df):
df['abs_diff_longitude'] = df.abs_diff_longitude*50
df['abs_diff_latitude'] = df.abs_diff_latitude*69
convert_different_miles(df_train)
convert_different_miles(df_test )<feature_engineering> | trainData.isnull().sum() [trainData.isnull().sum() >0] | Titanic - Machine Learning from Disaster |
4,211,056 | meas_ang = 0.506
def add_distance(df):
df['Euclidean'] =(df.abs_diff_latitude**2 + df.abs_diff_longitude**2)**0.5
df['delta_manh_long'] =(df.Euclidean*np.sin(np.arctan(df.abs_diff_longitude / df.abs_diff_latitude)-meas_ang)).abs()
df['delta_manh_lat'] =(df.Euclidean*np.cos(np.arctan(df.abs_diff_longitude / df.abs_diff_... | testData.isnull().sum() [testData.isnull().sum() >0] | 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.