kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,549,939 | train = pd.read_csv('.. /input/train.csv')
test_file = pd.read_csv('.. /input/sample_submission.csv')
<choose_model_class> | test_data.loc[(test_data['Pclass'] == 1)&(test_data['Fare'] == 0.0),'Fare'] = 76.68
test_data.loc[(test_data['Pclass'] == 2)&(test_data['Fare'] == 0.0),'Fare'] = 23.06
test_data.loc[(test_data['Pclass'] == 3)&(test_data['Fare'] == 0.0),'Fare'] = 13.91 | Titanic - Machine Learning from Disaster |
4,549,939 | learn = cnn_learner(train_img , models.densenet201, metrics = [error_rate,accuracy] )<find_best_params> | test_data.Age.isna().sum() | Titanic - Machine Learning from Disaster |
4,549,939 | learn.lr_find()
<train_model> | means = test_data.groupby(['Sex', 'Pclass'] ).Age.mean()
test_data.Age = test_data.apply(lambda x: means[x.Sex][x.Pclass] if pd.isnull(x.Age)else x.Age, axis=1 ) | Titanic - Machine Learning from Disaster |
4,549,939 | alpha = 3e-02
learn.fit_one_cycle(5,slice(alpha))<predict_on_test> | test_data['Sex'] = pd.Categorical(test_data['Sex'])
dfDummies = pd.get_dummies(test_data['Sex'], prefix = 'category')
test_data = pd.concat([test_data.drop(columns=['Sex']), dfDummies], axis=1)
test_data['Pclass'] = pd.Categorical(test_data['Pclass'])
dfDummies = pd.get_dummies(test_data['Pclass'], prefix = 'catego... | Titanic - Machine Learning from Disaster |
4,549,939 | preds,_ = learn.get_preds(ds_type = DatasetType.Test)
<prepare_output> | for i in range(len(test_data)) :
if test_data.loc[i, "SibSp"] + test_data.loc[i, "Parch"] == 0:
test_data.loc[i, "Alone"] = 1
else:
test_data.loc[i, "Alone"] = 0
test_data.Alone = test_data.Alone.astype(int ) | Titanic - Machine Learning from Disaster |
4,549,939 | test_file.has_cactus = preds.numpy() [:,0]<save_to_csv> | scaler.fit(test_data ) | Titanic - Machine Learning from Disaster |
4,549,939 | test_file.to_csv('submission.csv',index=False )<load_from_csv> | test_data = scaler.transform(test_data ) | Titanic - Machine Learning from Disaster |
4,549,939 | train_dir = '.. /input/train/train/'
test_dir = '.. /input/test/test/'
train_df = pd.read_csv('.. /input/train.csv')
test_images = os.listdir(test_dir)
test_df = pd.DataFrame(
list(zip(test_images, [0] * len(test_images))),
columns=['id', 'has_cactus']
)
<split> | test_data = pd.DataFrame(test_data, columns=features ) | Titanic - Machine Learning from Disaster |
4,549,939 | X = train_df.id
y = train_df.has_cactus
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
train_gen_df = pd.concat([X_train, y_train], axis=1 ).reset_index(drop=True)
valid_gen_df = pd.concat([X_test, y_test], axis=1 ).reset_index(drop=True )<prepare_x_and_y> | predict = model.predict_classes(test_data ) | Titanic - Machine Learning from Disaster |
4,549,939 | <choose_model_class><EOS> | my_submission = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predict})
my_submission.to_csv('submission.csv', index=False)
print(my_submission ) | Titanic - Machine Learning from Disaster |
8,271,636 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
np.random.seed(42 ) | Titanic - Machine Learning from Disaster |
8,271,636 | callbacks = [
EarlyStopping(monitor='val_loss', patience=10),
ModelCheckpoint(filepath='model.h5', monitor='val_loss', save_best_only=True)
]
history = model.fit_generator(
train_gen,
validation_data=valid_gen,
validation_steps=len(train_gen),
steps_per_epoch=len(train_gen_df)/ batch_size,
epochs=100,
verbose=True,
s... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
data = pd.concat([train, test], axis=0, ignore_index=True)
| Titanic - Machine Learning from Disaster |
8,271,636 | model.load_weights('model.h5')
test_datagen = ImageDataGenerator(
rescale=1.0 / 255.0
)
test_gen = valid_datagen.flow_from_dataframe(
dataframe=test_df,
directory=test_dir,
x_col='id',
class_mode=None,
batch_size=1,
target_size=(32, 32),
shuffle=False
)<predict_on_test> | data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,271,636 | predictions = model.predict_generator(test_gen, steps=len(test_gen), verbose=True)
<save_to_csv> | train[['Fare','Name','Ticket','SibSp','Parch']].iloc[train.index[(train['Pclass']==3)&(train['Fare']>60)]] | Titanic - Machine Learning from Disaster |
8,271,636 | test_df['has_cactus'] = predictions
test_df.to_csv('submission.csv', index=False)
print('Done!' )<import_modules> | train['FareCorr'] = train['Fare'].copy()
m=0
for grp, grp_df in train[['Ticket', 'Name', 'Pclass', 'Fare', 'PassengerId']].groupby(['Ticket']):
if(len(grp_df)!= 1):
if m==0:
print(grp_df)
m=1
for ind, row in grp_df.iterrows() :
passID = row['PassengerId']
train.loc[train['PassengerId'] == passID, 'FareCorr'] = train['... | Titanic - Machine Learning from Disaster |
8,271,636 | import numpy as np
import pandas as pd<import_modules> | train['FareCat']=pd.cut(train['FareCorr'], bins=[0,15,65,max(train["FareCorr"]+1)], labels=['low','mid','high'])
train['FareCat'].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | from pathlib import Path
from fastai import *
from fastai.vision import *
import torch<define_variables> | for name_string in data['Name']:
data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
data['Title']=data['Title'].replace({'Ms':'Miss','Mlle':'Miss','Mme':'Mrs'})
data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | data_folder = Path(".. /input")
<load_from_csv> | data['Title']=data['Title'].replace(['Sir','Don','Dona','Jonkheer','Lady','Countess'], 'Noble')
data['Title']=data['Title'].replace(['Dr', 'Rev','Col','Major','Capt'], 'Others')
data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/sample_submission.csv" )<choose_model_class> | data['Parch'][(data['Age']<15)&(data['Title']=='Miss')].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | learn = cnn_learner(train_img, models.densenet201, metrics=[error_rate, accuracy] )<train_model> | data['Parch'][(data['Age']>=15)&(data['Age']<25)&(data['Title']=='Miss')].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | lr = 3e-02
learn.fit_one_cycle(5, slice(lr))<predict_on_test> | title_list=data.groupby('Title')['Age'].median().index.to_list()
for title in title_list:
if title=='Miss':
data.loc[(data['Age'].isnull())&(data['Title'] == title)&(data['Parch'] == 0), 'Age'] \
= data['Age'][(data['Title']== title)&(data['Age']>=15)].median()
data.loc[(data['Age'].isnull())&(data['Title'] == title)&(... | Titanic - Machine Learning from Disaster |
8,271,636 | preds,_ = learn.get_preds(ds_type=DatasetType.Test )<filter> | data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.has_cactus = preds.numpy() [:, 0]<save_to_csv> | data.loc[data['SibSp'] + data['Parch'] + 1 == 1, 'FamilySize'] = 'Single'
data.loc[data['SibSp'] + data['Parch'] + 1 > 1 , 'FamilySize'] = 'Small'
data.loc[data['SibSp'] + data['Parch'] + 1 > 4 , 'FamilySize'] = 'Big' | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.to_csv('submission.csv', index=False )<import_modules> | data.FamilySize.value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | from pathlib import Path
from fastai import *
from fastai.vision import *
import torch<load_from_csv> | data['Last_Name'] = data['Name'].str.extract('([A-Za-z]+),', expand=True)
data['Last_Name'].value_counts()
| Titanic - Machine Learning from Disaster |
8,271,636 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/sample_submission.csv" )<define_variables> | data['Last_Name'] = data['Name'].apply(lambda x: str.split(x, ",")[0])
default_value = 0.5
data['FamilySurvival'] = default_value
for grp, grp_df in data[['Survived', 'Last_Name', 'Ticket', 'PassengerId']].groupby(['Last_Name']):
if(len(grp_df)!= 1):
for ind, row in grp_df.iterrows() :
smax = grp_df.drop(ind)['Survive... | Titanic - Machine Learning from Disaster |
8,271,636 | test_img = ImageList.from_df(test_df, path=data_folder/'test', folder='test' )<categorify> | data['FareCorr'] = data['Fare'].copy()
for grp, grp_df in data[['Ticket','Name', 'Pclass', 'Fare', 'PassengerId']].groupby(['Ticket']):
if(len(grp_df)!= 1):
for ind, row in grp_df.iterrows() :
passID = row['PassengerId']
data.loc[data['PassengerId'] == passID, 'FareCorr'] = data['Fare'][data['PassengerId'] == passID]/l... | Titanic - Machine Learning from Disaster |
8,271,636 | train_img =(ImageList.from_df(train_df, path=data_folder/'train', folder='train')
.split_by_rand_pct(0.01)
.label_from_df()
.add_test(test_img)
.transform(trfm, size=128)
.databunch(path='.', bs=64, device= torch.device('cuda:0'))
.normalize(imagenet_stats)
)<choose_model_class> | data['FareCat']=pd.qcut(data['FareCorr'], 7, labels=['1','2','3','4','5','6','7'])
data['FareCat'].value_counts() | Titanic - Machine Learning from Disaster |
8,271,636 | learn = cnn_learner(train_img, models.resnet18, metrics=[error_rate, accuracy] )<train_model> | data[data['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
8,271,636 | lr = 3e-02
learn.fit_one_cycle(5, slice(lr))<predict_on_test> | data['Embarked'].fillna('C', inplace = True ) | Titanic - Machine Learning from Disaster |
8,271,636 | preds,_ = learn.get_preds(ds_type=DatasetType.Test )<filter> | data_pre = data.drop(['Embarked','Survived','PassengerId','Name','Age','Parch','SibSp','Ticket','Fare','Cabin','Last_Name','FareCorr'],axis=1 ) | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.has_cactus = preds.numpy() [:, 0]<save_to_csv> | num_attribs = []
cat_attribs = list(data_pre.drop(labels=num_attribs, axis=1 ).columns ) | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.to_csv('submission_resnet_18.csv', index=False )<load_from_csv> | num_pipeline = Pipeline([
('imputer', SimpleImputer(strategy="median")) ,
('std_scaler', StandardScaler()),
] ) | Titanic - Machine Learning from Disaster |
8,271,636 | def load_data(dataframe=None, batch_size=1024, mode='categorical'):
if dataframe is None:
dataframe = pd.read_csv('.. /input/aerial-cactus-identification/train.csv')
dataframe['has_cactus'] = dataframe['has_cactus'].apply(str)
gen = ImageDataGenerator(rescale=1./255.,
validation_split=0.1, horizontal_flip=True, verti... | cat_pipeline = Pipeline([
('imputer', SimpleImputer(strategy="most_frequent")) ,
('cat', OneHotEncoder()),
] ) | Titanic - Machine Learning from Disaster |
8,271,636 | def baseline_model() :
model = Sequential()
model.add(Conv2D(32,(3, 3), input_shape=(32, 32, 3), padding='same', use_bias=False, kernel_regularizer=l2(1e-4)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2D(32,(3, 3), padding='same', use_bias=False, kernel_regularizer=l2(1e-4)))
model.... | full_pipeline = ColumnTransformer([
('cat', cat_pipeline, cat_attribs),
])
data_post = full_pipeline.fit_transform(data_pre ) | Titanic - Machine Learning from Disaster |
8,271,636 | def train_baseline() :
batch_size = 1024
trainGen, valGen = load_data(batch_size=batch_size)
model = baseline_model()
model.load_weights('.. /input/kernel658e346ac9/baseline.h5')
opt = Adam(1e-4)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
cbs = [ReduceLROnPlateau(monitor='lo... | oneHot=OneHotEncoder()
data_post_alt=oneHot.fit_transform(data_pre[cat_attribs] ) | Titanic - Machine Learning from Disaster |
8,271,636 | model = train_baseline()
model.save('baseline.h5')
predict_baseline(model )<set_options> | X_train = data_post[:len(train['Survived']),:].toarray()
y_train = train['Survived'].copy().to_numpy()
X_test = data_post[len(train['Survived']):,:].toarray() | Titanic - Machine Learning from Disaster |
8,271,636 | warnings.filterwarnings('ignore')
%matplotlib inline
print(os.listdir(".. /input"))
<load_from_csv> | def hyperparameter_analysis(searcher, top_values=5):
tested_hyperparameters=pd.DataFrame()
for i in range(len(searcher.cv_results_['params'])) :
tested_hyperparameters = tested_hyperparameters.append(searcher.cv_results_['params'][i], ignore_index=True)
tested_hyperparameters['train score in %']=(searcher.cv_results_[... | Titanic - Machine Learning from Disaster |
8,271,636 | device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('device: {}'.format(device))
train_folder='.. /input/train/train/'
test_folder='.. /input/test//test/'
labels=pd.read_csv('.. /input/train.csv')
submission=pd.read_csv('.. /input/sample_submission.csv')
print('train dataset size: {}'.format(le... | def create_model(input_shape=X_train.shape[1:],
number_hidden=2,
neurons_per_hidden=10,
hidden_drop_rate= 0.2,
hidden_activation = 'selu',
hidden_initializer="lecun_normal",
output_activation ='sigmoid',
loss='binary_crossentropy',
optimizer = Nadam(lr=0.0005),
):
model = Sequential()
model.add(Input(shape=input_shape... | Titanic - Machine Learning from Disaster |
8,271,636 | class Cactus(Dataset):
def __init__(self, folder, labels, transform=None):
self.transform=transform
self.folder=folder
self.labels=labels
def __len__(self):
return self.labels.shape[0]
def __getitem__(self,index):
img_path=os.path.join(self.folder, self.labels['id'].iloc[index])
img=Image.open(img_path)
img_label=sel... | keras.backend.clear_session()
np.random.seed(42)
tf.random.set_seed(42)
dnn_clf=create_model()
history = dnn_clf.fit(X_train, y_train, epochs=30, batch_size=30, verbose=0 ) | Titanic - Machine Learning from Disaster |
8,271,636 | transformed_dataset=Cactus(train_folder, labels,
transform=transforms.Compose([
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFlip() ,
transforms.RandomAffine(10),
transforms.RandomRotation(( -10,10))
]))
visualize_samples(transformed_dataset, indices )<create_dataframe> | print('Training score: ' + str(( pd.DataFrame(history.history)['accuracy'].max() *100)) + '%' ) | Titanic - Machine Learning from Disaster |
8,271,636 | tfs_train=transforms.Compose([
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFlip() ,
transforms.RandomRotation(( -10,10)) ,
transforms.ToTensor() ,
transforms.Normalize(( 0.485, 0.456, 0.406),(0.229, 0.224, 0.225))
])
tfs_test=transforms.Compose([
transforms.ToTensor() ,
transforms.Normalize(( 0.485, 0... | y_train_pred_dnn = dnn_clf.predict_classes(X_train ) | Titanic - Machine Learning from Disaster |
8,271,636 | def train_model(model, train_loader, val_loader, loss, optimizer, num_epoch=10):
print('Training...')
loss_history=[]
train_history=[]
val_history=[]
val_loss_history=[]
for epoch in range(num_epoch):
model.train()
loss_accum=0
correct_samples=0
total_samples=0
for i_step,(x,y)in enumerate(train_loader):
x,y=x.to(devi... | metric_scores(y_train, y_train_pred_dnn ) | Titanic - Machine Learning from Disaster |
8,271,636 | model=models.resnet18(pretrained=True)
num_ftrs=model.fc.in_features
model.fc=nn.Linear(num_ftrs,2)
model=model.to(device)
criterion=nn.CrossEntropyLoss()
optimizer=optim.Adamax(model.parameters() , lr=0.003, weight_decay=0.001)
scheduler=StepLR(optimizer, step_size=10, gamma=0.1)
loss_history, train_history, val_... | y_train_proba_dnn = dnn_clf.predict(X_train ) | Titanic - Machine Learning from Disaster |
8,271,636 | model.eval()
predictions=[]
for i,(x,y)in enumerate(test_loader):
x,y=x.to(device), y.to(device)
prediction=model(x)
pred=prediction[:,1].detach().cpu().numpy()
for i in pred:
predictions.append(i)
submission['has_cactus']=predictions
submission.to_csv('submission.csv',index=False )<set_options> | proba_df=pd.DataFrame(y_train_proba_dnn, columns=['probabilities'])*100
proba_df['false_predictions']=(pd.DataFrame(y_train_pred_dnn)-pd.DataFrame(y_train)) [0]
proba_df['probabilities'][proba_df['false_predictions']==0].hist() | Titanic - Machine Learning from Disaster |
8,271,636 | start = time.time()
np.random.seed(10)
%matplotlib inline
%reload_ext autoreload
%autoreload 2<load_from_csv> | check_df=data[:891].copy()
check_df['false_predictions']=proba_df['false_predictions']
check_df['probabilities']=proba_df['probabilities']
check_df[check_df['PassengerId']==18] | Titanic - Machine Learning from Disaster |
8,271,636 | data_folder = Path(".. /input")
train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/sample_submission.csv" )<concatenate> | np.random.seed(42)
tf.random.set_seed(42)
dnn_clf_fi=KerasClassifier(build_fn = create_model)
dnn_clf_fi.fit(X_train, y_train, epochs=30, batch_size=30)
perm = PermutationImportance(dnn_clf_fi, random_state=42 ).fit(X_train,y_train)
| Titanic - Machine Learning from Disaster |
8,271,636 | df1 = train_df[train_df.has_cactus==0].copy()
df2 = df1.copy()
train_df = train_df.append([df1, df2], ignore_index=True )<train_model> | feature_importance_ann(perm, feature_names, top_values=10, neg_values=False ) | Titanic - Machine Learning from Disaster |
8,271,636 | test_img = ImageList.from_df(test_df, path=data_folder/'test', folder='test')
trfm = get_transforms(do_flip=True, flip_vert=True, max_rotate=10.0, max_zoom=1.1,
max_lighting=0.2, max_warp=0.2,
p_affine=0.75, p_lighting=0.75 ,xtra_tfms=[contrast(scale=(0.5, 1), p=0.75)])
imagesize = 64
batchsize = 64
def train_data(im... | feature_importance_ann(perm, feature_names, top_values=20, neg_values=True ) | Titanic - Machine Learning from Disaster |
8,271,636 | data = train_data(imagesize,batchsize )<train_model> | k = 17
sel = SelectFromModel(perm, threshold=-np.inf, max_features=k, prefit=True)
best_festures_index=np.where(sel.get_support() ==True)
X_train_bf = data_post[:len(train['Survived']),best_festures_index[0]].copy()
X_test_bf = data_post[len(train['Survived']):,best_festures_index[0]].copy() | Titanic - Machine Learning from Disaster |
8,271,636 | train_img1 = train_data(64,64)
<define_variables> | y_pred_dnn = dnn_clf.predict_classes(X_test ) | Titanic - Machine Learning from Disaster |
8,271,636 | train_img1.show_batch(rows=5, figsize=(10,10))
<choose_model_class> | my_submission=pred_to_df(y_pred_dnn)
my_submission.head() | Titanic - Machine Learning from Disaster |
8,271,636 | nmodels = 3<choose_model_class> | save_to_csv(my_submission,'submission' ) | Titanic - Machine Learning from Disaster |
8,271,636 | def get_ensemble(nmodels):
ens_model = []
learning_rate =[2.95e-02,3e-02,3e-02]
model_list = [models.densenet161,models.densenet161,models.densenet201]
for i in range(nmodels):
print(f'-----Training model: {i+1}--------')
data = train_data(64,64)
learn_resnet = cnn_learner(data, model_list[i], metrics=[error_rate, ac... | X_train_gs=X_train.copy()
X_test_gs=X_test.copy()
| Titanic - Machine Learning from Disaster |
8,271,636 | ens = get_ensemble(3 )<train_model> | keras.backend.clear_session()
np.random.seed(42)
tf.random.set_seed(42)
dnn_clf_gs = KerasClassifier(build_fn = create_model, verbose = 0)
param_grid = {
'input_shape': X_train_gs.shape[1:]
}
grid_search_dnn = GridSearchCV(dnn_clf_gs, param_grid, cv=5, n_jobs=-1, verbose=0, return_train_score=True)
training_gs = gr... | Titanic - Machine Learning from Disaster |
8,271,636 | end = time.time()
print(end - start )<categorify> | print('Mean training score: ' + str(( grid_search_dnn.cv_results_['mean_train_score'][grid_search_dnn.best_index_]*100 ).round(2)) +'%(' + str(( grid_search_dnn.cv_results_['std_train_score'][grid_search_dnn.best_index_]*100 ).round(2)) + '%)')
print('Mean validation score: ' + str(( grid_search_dnn.cv_results_['mean_... | Titanic - Machine Learning from Disaster |
8,271,636 | ens_test_preds = []
for mdl in ens:
preds,_ = mdl.TTA(ds_type=DatasetType.Test)
print(np.array(preds ).shape)
ens_test_preds.append(np.array(preds))<predict_on_test> | hyperparameter_analysis(grid_search_dnn, 10 ) | Titanic - Machine Learning from Disaster |
8,271,636 | ens_preds = np.mean(ens_test_preds, axis =0 )<predict_on_test> | y_pred_dnn_opti = grid_search_dnn.best_estimator_.predict(X_test_gs ) | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.has_cactus = ens_preds[:, 0]
test_df.head()
<save_to_csv> | survived_dnn_opti=pred_to_df(y_pred_dnn_opti)
survived_dnn_opti.head() | Titanic - Machine Learning from Disaster |
8,271,636 | test_df.to_csv('submission.csv', index=False )<categorify> | save_to_csv(survived_dnn_opti,'survived_dnn_opti' ) | Titanic - Machine Learning from Disaster |
8,271,636 | interp = ClassificationInterpretation.from_learner(ens[0])
interp1 = ClassificationInterpretation.from_learner(ens[1])
interp2 = ClassificationInterpretation.from_learner(ens[2])
<define_variables> | param_distribs = {
'n_estimators': randint(low=50, high=150),
'max_features': randint(low=5, high=15),
'min_samples_split': randint(low=10, high=30),
}
forest_clf = RandomForestClassifier(random_state=42)
rnd_search_rf = RandomizedSearchCV(forest_clf, param_distributions=param_distribs, n_jobs=-1,
n_iter=50, cv=5, sco... | Titanic - Machine Learning from Disaster |
8,271,636 | train_imgs_path = '.. /input/train/train'
test_imgs_path = '.. /input/test/test'
labels_path = '.. /input/train.csv'
in_path = '.. /input/'<load_from_csv> | print('Best score: ' + str(( rnd_search_rf.best_score_*100 ).round(2)) + '%' ) | Titanic - Machine Learning from Disaster |
8,271,636 | df = pd.read_csv(labels_path)
df['id'] = 'train/train/' + df['id']
df.head()<categorify> | print('Mean training score: ' + str(( rnd_search_rf.cv_results_['mean_train_score'][rnd_search_rf.best_index_]*100 ).round(2)) +'%(' + str(( rnd_search_rf.cv_results_['std_train_score'][0]*100 ).round(2)) + '%)')
print('Mean validation score: ' + str(( rnd_search_rf.cv_results_['mean_test_score'][rnd_search_rf.best_in... | Titanic - Machine Learning from Disaster |
8,271,636 | data = vision.ImageDataBunch.from_df(in_path, df, ds_tfms=vision.get_transforms() , size=224)
data = data.normalize(vision.imagenet_stats )<define_variables> | pd.DataFrame(rnd_search_rf.best_params_.items() , columns=['hyperparameter','value'] ) | Titanic - Machine Learning from Disaster |
8,271,636 | data.show_batch(rows=3, figsize=(10, 8))<train_on_grid> | hyperparameter_analysis(rnd_search_rf ) | Titanic - Machine Learning from Disaster |
8,271,636 | learn = vision.cnn_learner(data, vision.models.resnet34, metrics=metrics.accuracy)
learn.fit(2 )<find_best_params> | feature_importance(rnd_search_rf.best_estimator_, feature_names, 10 ) | Titanic - Machine Learning from Disaster |
8,271,636 | interp = vision.ClassificationInterpretation.from_learner(learn)
losses,idxs = interp.top_losses()<load_from_csv> | final_rf_clf = rnd_search_rf.best_estimator_
final_rf_clf | Titanic - Machine Learning from Disaster |
8,271,636 | submission_df = pd.read_csv('.. /input/sample_submission.csv')
files = submission_df['id'].values
img_paths =('.. /input/test/test/' + submission_df['id'] ).values<predict_on_test> | y_train_pred_rf = final_rf_clf.predict(X_train ) | Titanic - Machine Learning from Disaster |
8,271,636 | preds = []
for p in tqdm(img_paths):
pred = learn.predict(vision.open_image(p)) [-1].numpy()
preds.append(pred )<prepare_output> | metric_scores(y_train, y_train_pred_rf ) | Titanic - Machine Learning from Disaster |
8,271,636 | submission_df['has_cactus'] = np.array(preds)[:, 1]
submission_df.head()<save_to_csv> | y_pred_rf = final_rf_clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
8,271,636 | submission_df.to_csv('submission.csv', index=False )<import_modules> | survived_rf=pred_to_df(y_pred_rf)
survived_rf.head() | Titanic - Machine Learning from Disaster |
8,271,636 | resnet_weights_path = '.. /input/resnet50/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'
print(os.listdir(".. /input"))<categorify> | save_to_csv(survived_rf,'survived_rf' ) | Titanic - Machine Learning from Disaster |
8,271,636 | def prep_cnn_data(df, n_x, n_c, path):
tensors = np.zeros(( df.shape[0], n_x, n_x, n_c))
for i in range(df.shape[0]):
pic = load_img(path+df.iloc[i]['id'])
pic_array = img_to_array(pic)
tensors[i,:] = pic_array
tensors = tensors / 255.
return tensors<load_from_csv> | param_distribs = {
'max_depth': randint(low=1, high=5),
'n_estimators': randint(low=5, high=120),
'max_features': randint(low=5, high=15),
}
gb_clf = GradientBoostingClassifier()
rnd_search_gb = RandomizedSearchCV(gb_clf, param_distributions=param_distribs,
n_iter=40, cv=5, scoring="accuracy", random_state=42, return_t... | Titanic - Machine Learning from Disaster |
8,271,636 | train_df = pd.read_csv('.. /input/aerial-cactus-identification/train.csv')
test_df = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv')
train = prep_cnn_data(train_df, 32, 3, path='.. /input/aerial-cactus-identification/train/train/')
train_y = train_df['has_cactus'].values
test = prep_cnn_d... | print('Mean training score: ' + str(( rnd_search_gb.cv_results_['mean_train_score'][rnd_search_gb.best_index_]*100 ).round(2)) +'%(' + str(( rnd_search_gb.cv_results_['std_train_score'][0]*100 ).round(2)) + '%)')
print('Mean validation score: ' + str(( rnd_search_gb.cv_results_['mean_test_score'][rnd_search_gb.best_in... | Titanic - Machine Learning from Disaster |
8,271,636 | datagen = ImageDataGenerator(
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
vertical_flip=True)
<drop_column> | rnd_search_gb.cv_results_['mean_train_score'] | Titanic - Machine Learning from Disaster |
8,271,636 | del model<choose_model_class> | hyperparameter_analysis(rnd_search_gb, 5 ) | Titanic - Machine Learning from Disaster |
8,271,636 | model = Sequential()
model.add(Conv2D(filters = 64, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(32,32,3)))
model.add(Conv2D(filters = 64, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.5))
model.add(Conv2D(filters = 32, ke... | feature_importance(rnd_search_gb.best_estimator_, feature_names, 10 ) | Titanic - Machine Learning from Disaster |
8,271,636 | model.compile(optimizer = 'adam', loss = "binary_crossentropy", metrics=["accuracy"] )<train_model> | final_gb_clf = rnd_search_gb.best_estimator_
final_gb_clf | Titanic - Machine Learning from Disaster |
8,271,636 | batch_size=256
epochs=200
x_train=train[3500:]
y_train=train_y[3500:]
x_val=train[:3500]
y_val=train_y[:3500]
red_lr= ReduceLROnPlateau(monitor='val_acc',patience=3,verbose=1,factor=0.7)
History = model.fit_generator(datagen.flow(x_train,y_train,batch_size=batch_size),
epochs= epochs, steps_per_epoch=x_train.shape[0]/... | y_train_pred_gb = final_gb_clf.predict(X_train ) | Titanic - Machine Learning from Disaster |
8,271,636 | pred=model.predict(test)
test_csv = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv')
df=pd.DataFrame({'id':test_csv['id'] })
df['has_cactus']=pred
df.to_csv("submission.csv",index=False )<set_options> | metric_scores(y_train, y_train_pred_gb ) | Titanic - Machine Learning from Disaster |
8,271,636 | %matplotlib inline<set_options> | y_pred_gb = final_gb_clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
8,271,636 | %matplotlib inline<set_options> | survived_gb=pred_to_df(y_pred_gb)
survived_gb.head() | Titanic - Machine Learning from Disaster |
8,271,636 | <load_from_csv><EOS> | save_to_csv(survived_gb,'survived_gb' ) | Titanic - Machine Learning from Disaster |
1,603,678 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | import numpy as np
import pandas as pd
from pandas.plotting import scatter_matrix
import keras
from keras.models import Sequential
from keras.layers import Dense,MaxPooling2D,Flatten,Dropout
from keras.layers.convolutional import Conv2D
from keras import backend | Titanic - Machine Learning from Disaster |
1,603,678 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<data_type_conversions> | input_neurons=10
output_neurons=1 | Titanic - Machine Learning from Disaster |
1,603,678 | X_train = train.iloc[:, 2:].values.astype('float64')
y_train = train['target'].values
X_test = test.iloc[:, 1:].values.astype('float64' )<train_model> | np.random.seed(7 ) | Titanic - Machine Learning from Disaster |
1,603,678 | class GaussianMixtureNB(BaseEstimator, ClassifierMixin):
def __init__(self, n_components=1, reg_covar=1e-06):
self.n_components = n_components
self.reg_covar = reg_covar
def fit(self, X, y):
self.log_prior_ = np.log(np.bincount(y)/ len(y))
shape =(len(self.log_prior_), X.shape[1])
self.log_pdf_ = [[GaussianMixture(n_c... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,603,678 | i_train, i_valid = next(StratifiedShuffleSplit(n_splits=1 ).split(X_train, y_train))<train_model> | def simplify_ages(df):
df['Age'] = df['Age'].fillna(df.Age.mean())
bins =(-1, 0, 5, 12, 18, 25, 35, 60, 120)
group_names = ['Unknown', 'Baby', 'Child', 'Teenager', 'Student', 'Young Adult', 'Adult', 'Senior']
categories = pd.cut(df['Age'], bins, labels=group_names)
df['Age'] = categories.cat.codes
return df
def simp... | Titanic - Machine Learning from Disaster |
1,603,678 | pipeline = make_pipeline(StandardScaler() ,
GaussianMixtureNB(n_components=10, reg_covar=0.03))
pipeline.fit(X_train[i_train], y_train[i_train])
print('Training AUC is {}.'
.format(roc_auc_score(y_train[i_train],
pipeline.predict_proba(X_train[i_train])[:, 1])))
print('Validation AUC is {}.'
.format(roc_auc_score(y... | train_df=transform_features(train_df)
test_df=transform_features(test_df ) | Titanic - Machine Learning from Disaster |
1,603,678 | pipeline.fit(X_train, y_train )<save_to_csv> | xtrain_df = train_df.drop(['PassengerId','Ticket','Survived','Name','Parch','SibSp'], axis=1)
ytrain_df = train_df['Survived']
xtest_df = test_df.drop(['PassengerId','Ticket','Name','Parch','SibSp'], axis=1 ) | Titanic - Machine Learning from Disaster |
1,603,678 | submission = pd.read_csv('.. /input/sample_submission.csv')
submission['target'] = pipeline.predict_proba(X_test)[:, 1]
submission.to_csv('submission.csv', index=False )<load_from_csv> | model = Sequential()
model.add(Dense(32, input_dim=input_neurons, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(5, activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(output_neurons, activation='sigmoid')) | Titanic - Machine Learning from Disaster |
1,603,678 | test = pd.read_csv('.. /input/test.csv')
train = pd.read_csv('.. /input/train.csv')
<split> | model.compile(loss='binary_crossentropy', optimizer='adam',
metrics=['accuracy'] ) | Titanic - Machine Learning from Disaster |
1,603,678 | features = train.columns.values[2:202]
x_train = train[features].values
y_train = train.target.values
skf = StratifiedKFold(n_splits=10)
skf.get_n_splits(x_train, y_train )<init_hyperparams> | model.fit(xtrain_df, ytrain_df,epochs=50, batch_size=1,verbose=1 ) | Titanic - Machine Learning from Disaster |
1,603,678 | random_state = 2567
lgb_params = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 13,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 0.4,
"feature_fraction" : 0.05,
"min_data_in_leaf": 80,
"min_sum_heassian_in_leaf": 10,
"tree_learner": "serial",
"boost_f... | scores = model.evaluate(xtrain_df, ytrain_df)
print("
%s: %.2f%%" %(model.metrics_names[1], scores[1]*100)) | Titanic - Machine Learning from Disaster |
1,603,678 | oof = np.zeros(len(train))
predictions = np.zeros(len(test))
for train_index, test_index in skf.split(x_train, y_train):
print("TRAIN:", train_index, "TEST:", test_index)
x_train_cv, x_test_cv = x_train[train_index], x_train[test_index]
y_train_cv, y_test_cv = y_train[train_index], y_train[test_index]
trn_data = lgb.D... | predictions = model.predict_classes(xtest_df,verbose=0)
predictions=predictions.flatten()
results = pd.Series(predictions,name="Survived")
submission = pd.concat([pd.Series(range(892,1310),name = "PassengerId"),results],axis = 1)
submission.to_csv("titanic_datagen.csv",index=False)
backend.clear_session() | Titanic - Machine Learning from Disaster |
11,963,250 | sub_df = pd.DataFrame({"ID_code":test["ID_code"].values})
sub_df["target"] = predictions
sub_df.to_csv("lgb_submission.csv", index=False )<set_options> | %matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
11,963,250 | warnings.filterwarnings('ignore' )<load_from_csv> | train =pd.read_csv(".. /input/titanic/train.csv")
test =pd.read_csv(".. /input/titanic/test.csv")
train.describe(include='all' ) | Titanic - Machine Learning from Disaster |
11,963,250 | %%time
train_df = pd.read_csv(PATH+"train.csv")
test_df = pd.read_csv(PATH+"test.csv" )<count_missing_values> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,963,250 | def missing_data(data):
total = data.isnull().sum()
percent =(data.isnull().sum() /data.isnull().count() *100)
tt = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
types = []
for col in data.columns:
dtype = str(data[col].dtype)
types.append(dtype)
tt['Types'] = types
return(np.transpose(tt))<count_m... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,963,250 | %%time
missing_data(train_df )<count_missing_values> | print(train.Embarked [train.Embarked == 'S'].count())
print(train.Embarked [train.Embarked == 'C'].count())
print(train.Embarked [train.Embarked == 'Q'].count() ) | 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.