kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,444,244 | preds,_ = reslearner.get_preds(ds_type=DatasetType.Test )<filter> | train.set_index('PassengerId', inplace=True)
test.set_index('PassengerId', inplace=True)
train.head() | Titanic - Machine Learning from Disaster |
2,444,244 | test_df.has_cactus = preds.numpy() [:, 0]<save_to_csv> | print("Missing Values: ",train.Name.isna().sum())
train.Name.head(5 ) | Titanic - Machine Learning from Disaster |
2,444,244 | test_df.to_csv('submission.csv', index=False )<set_options> | train['title'] = train.Name.map(lambda x: x.split(',')[1].split('.')[0].strip())
train['title'] = train['title'].replace('Mlle', 'Miss')
train['title'] = train['title'].replace(['Mme','Lady','Ms','the Countess'], 'Mrs')
train.title.loc[(train.title != 'Master')&(train.title != 'Mr')&(train.title != 'Miss')&(train.ti... | Titanic - Machine Learning from Disaster |
2,444,244 | warnings.filterwarnings("ignore" )<load_from_csv> | train['family'] = train.SibSp + train.Parch
test['family'] = test.SibSp + test.Parch
test=test.drop(['SibSp','Parch'], axis=1)
train=train.drop(['SibSp','Parch'], axis=1 ) | Titanic - Machine Learning from Disaster |
2,444,244 | train = pd.read_csv('.. //input//train.csv')
print(train.shape)
print(train.head(10))<count_values> | print("Fare Values(first 20)
",train.Fare.unique() [:20])
train['fare_value']=round(train.Fare/10)*10
test['fare_value']=round(test.Fare/10)*10
col=train['fare_value']
print("
Fare values after rounding off for Simplification
",col.unique())
| Titanic - Machine Learning from Disaster |
2,444,244 | train.has_cactus.value_counts()<data_type_conversions> | test[test.Fare.isna() ] | Titanic - Machine Learning from Disaster |
2,444,244 | def create_training_model_data(dataframe, batch_size=32, mode='categorical'):
dataframe['has_cactus'] = dataframe['has_cactus'].astype(str)
IDG = ImageDataGenerator(rescale=1./255.,
horizontal_flip=True,
vertical_flip=True)
train_data = IDG.flow_from_dataframe(dataframe=dataframe[:15925],
directory='.. //input//train... | test[test.Ticket=="3"][test.title=="Mr"][test.Embarked=="S"][test.Pclass==3] | Titanic - Machine Learning from Disaster |
2,444,244 | train_data, validation_data = create_training_model_data(train )<choose_model_class> | test['fare_value']=test['fare_value'].replace(np.nan,10)
test.fare_value.isna().sum() | Titanic - Machine Learning from Disaster |
2,444,244 | model_alexnet = Sequential()
model_alexnet.add(Conv2D(32,(3,3),
input_shape=(32, 32, 1),
padding='same',
activation='relu'))
model_alexnet.add(MaxPooling2D(pool_size=(2,2), padding='same'))
model_alexnet.add(BatchNormalization())
model_alexnet.add(Conv2D(64,(3,3),
padding='same',
activation='relu'))
model_alexnet.add(... | print("Percentage of missing values: ",train.Cabin.isna().sum() /len(train.Cabin)*100 ) | Titanic - Machine Learning from Disaster |
2,444,244 | history = model_alexnet.fit_generator(train_data,
epochs=100,
steps_per_epoch=(15925/32),
callbacks=callbacks,
validation_data = validation_data,
validation_steps=(1575/32),
class_weight=class_weights,
verbose=2 )<define_variables> | test=test.drop(['Cabin'], axis=1)
train=train.drop(['Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
2,444,244 | test_IDG = ImageDataGenerator(rescale=1./255.)
test_data = test_IDG.flow_from_directory(
directory='.. //input//test//',
target_size=(32,32),
color_mode='grayscale',
class_mode='binary',
batch_size=1,
shuffle=False )<predict_on_test> | print("Percentage of missing values: ",train.Embarked.isna().sum() /len(train.Embarked)*100 ) | Titanic - Machine Learning from Disaster |
2,444,244 | y_pred = model_alexnet.predict_generator(test_data,steps=4000)
y_pred = np.hstack(y_pred ).tolist()<count_values> | print("Unique Values:
", train.Embarked.value_counts() ) | Titanic - Machine Learning from Disaster |
2,444,244 | has_cactus = [0 if proba<0.50 else 1 for proba in y_pred]
print(Counter(has_cactus ).keys())
print(Counter(has_cactus ).values() )<define_variables> | train[train.Embarked.isna() ] | Titanic - Machine Learning from Disaster |
2,444,244 | files=[]
files = [f for f in sorted(os.listdir('.. //input//test//test')) ]<create_dataframe> | train[(train.fare_value==80)&(train.Ticket=="1")] | Titanic - Machine Learning from Disaster |
2,444,244 | submission = pd.DataFrame({'id':files,
'has_cactus':y_pred} )<save_to_csv> | train.Embarked=train.Embarked.replace(np.nan,"S" ) | Titanic - Machine Learning from Disaster |
2,444,244 | submission.to_csv('submission.csv', index=False )<save_to_csv> | print("Percentage of missing values: ",train.Age.isna().sum() /len(train.Age)*100 ) | Titanic - Machine Learning from Disaster |
2,444,244 | submission.to_csv('submission.csv', index=False )<install_modules> | train['age_round']=round(train.Age/10)*10
train.age_round=train.age_round.replace(0,10)
train.age_round.unique() | Titanic - Machine Learning from Disaster |
2,444,244 | !pip install efficientnet_pytorch<define_variables> | train.age_round[train['age_round'] == 10]="child"
train['age_round'] = train['age_round'].replace([0,10], 'child')
train['age_round'] = train['age_round'].replace([20,30], 'young')
train['age_round'] = train['age_round'].replace([40,50], 'adult')
train['age_round'] = train['age_round'].replace([60,70,80], 'old' ) | Titanic - Machine Learning from Disaster |
2,444,244 | path = Path('.. /input/' )<set_options> | train=train.drop('Age',axis=1)
train=train.drop('age_round',axis=1)
test=test.drop('Age',axis=1)
train=train.drop('Fare',axis=1)
test=test.drop('Fare',axis=1 ) | Titanic - Machine Learning from Disaster |
2,444,244 | path.ls()<load_from_csv> | def scale(data):
print("
Scaling Data:
")
min_max_scaler = preprocessing.MinMaxScaler()
data_scale = min_max_scaler.fit_transform(data)
data_scale=pd.DataFrame(data_scale, columns=data.columns.values, index=data.index.values)
print(data_scale.head())
return(data_scale)
def cat_to_num(data):
print("
Converting Cate... | Titanic - Machine Learning from Disaster |
2,444,244 | train = pd.read_csv(path/'train.csv')
test = pd.read_csv(path/'sample_submission.csv' )<categorify> | X=data_preprocess(train)
test_data=data_preprocess(test)
y=label | Titanic - Machine Learning from Disaster |
2,444,244 | test_img = ImageList.from_df(test, path=path/'test', folder='test')
tfms = get_transforms()
data =(ImageList.from_df(train, path=path/'train', folder='train')
.split_by_rand_pct(0.01)
.label_from_df()
.add_test(test_img)
.transform(tfms, size=224, resize_method=ResizeMethod.SQUISH)
.databunch(path='.', bs=64, device=... | temp=pd.concat([X,label],axis=1 ) | Titanic - Machine Learning from Disaster |
2,444,244 | from efficientnet_pytorch import EfficientNet<choose_model_class> | html=
display(HTML(html)) | Titanic - Machine Learning from Disaster |
2,444,244 | model_name = 'efficientnet-b3'
def getModel(pret):
model = EfficientNet.from_pretrained(model_name)
model._fc = nn.Linear(model._fc.in_features,data.c)
return model<choose_model_class> | train, test,train_labels, test_labels = train_test_split(X, y, train_size=0.8, random_state=42 ) | Titanic - Machine Learning from Disaster |
2,444,244 | learn = Learner(data,getModel(True),metrics=[accuracy] )<define_search_space> | clf_dt = DecisionTreeClassifier(random_state=42)
clf_dt = clf_dt.fit(train, train_labels)
y_pred=clf_dt.predict(test)
accuracy_score(test_labels, y_pred ) | Titanic - Machine Learning from Disaster |
2,444,244 | lr=5e-3<train_model> | clf_rf = RandomForestClassifier(
random_state=42,
)
clf_rf = clf_rf.fit(train, train_labels)
y_pred=clf_rf.predict(test)
accuracy_score(test_labels, y_pred ) | Titanic - Machine Learning from Disaster |
2,444,244 | learn.fit_one_cycle(3,lr )<predict_on_test> | cv_value=5
scores=cross_val_score(clf_dt, X, y, cv=cv_value)
print("Decision Trees Accuracy: %0.2f(+/- %0.2f)" %(scores.mean() , scores.std() * 2))
scores=cross_val_score(clf_rf, X, y, cv=cv_value)
print("Random Forest Accuracy: %0.2f(+/- %0.2f)" %(scores.mean() , scores.std() * 2)) | Titanic - Machine Learning from Disaster |
2,444,244 | preds,_ = learn.get_preds(ds_type=DatasetType.Test)
idx = preds.numpy() [:,0]<save_to_csv> | clf=clf_rf
print("Default Parameters of estimator are:
",clf.get_params ) | Titanic - Machine Learning from Disaster |
2,444,244 | test.has_cactus = idx
test.to_csv('submission.csv', index=False )<import_modules> | parameters = {'n_estimators': [10, 100 , 200 , 400, 500],
'max_depth': [10, 20, 40, None],
'warm_start':[True,False],
'min_samples_leaf': [1, 2, 4],
}
p = GridSearchCV(clf , param_grid=parameters, cv=3 ) | Titanic - Machine Learning from Disaster |
2,444,244 | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from skimage.io import imread
from keras.applications import resnet50
from keras.optimizers import Adam
from keras.layers import GlobalAveragePooling2D, Dense
from keras.models import Model
from keras.callbacks import ModelChec... | start_time = time.time()
p.fit(X,y);
elapsed_time = time.time() - start_time
print("Time consumed to fit model: ",time.strftime("%H:%M:%S", time.gmtime(elapsed_time)) ) | Titanic - Machine Learning from Disaster |
2,444,244 | train = pd.read_csv('.. /input/aerial-cactus-identification/train.csv')
test = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv')
y_train = np.array(train.has_cactus )<prepare_x_and_y> | print("Scores for all Parameter Combination:
",p.cv_results_['mean_test_score'])
print("
Optimal C and Gamma Combination: ",p.best_params_)
print("
Maximum Accuracy acheieved on LeftOut Data: ",p.best_score_ ) | Titanic - Machine Learning from Disaster |
2,444,244 | X_train = []
for name in train.id:
X_train.append(imread('.. /input/aerial-cactus-identification/train/train/'+name))<prepare_x_and_y> | clf_rf = RandomForestClassifier(
random_state=42,
n_estimators=p.best_params_['n_estimators'],
warm_start=p.best_params_['warm_start'],
max_depth=p.best_params_['max_depth'],
min_samples_leaf=p.best_params_['min_samples_leaf'],
)
| Titanic - Machine Learning from Disaster |
2,444,244 | X_test = []
for name in test.id:
X_test.append(imread('.. /input/aerial-cactus-identification/test/test/'+name))<prepare_x_and_y> | clf_rf = clf_rf.fit(train, train_labels)
y_pred=clf_rf.predict(test)
accuracy_score(test_labels, y_pred ) | Titanic - Machine Learning from Disaster |
2,444,244 | X_train = np.array(X_train)
X_test = np.array(X_test )<normalization> | cv_value=5
scores=cross_val_score(clf_dt, X, y, cv=cv_value)
print("Decision Trees Accuracy: %0.2f(+/- %0.2f)" %(scores.mean() , scores.std() * 2))
scores=cross_val_score(clf_rf, X, y, cv=cv_value)
print("Random Forest Accuracy: %0.2f(+/- %0.2f)" %(scores.mean() , scores.std() * 2)) | Titanic - Machine Learning from Disaster |
2,444,244 | X_train = resnet50.preprocess_input(X_train)
X_test = resnet50.preprocess_input(X_test )<choose_model_class> | clf_rf = clf_rf.fit(X, y ) | Titanic - Machine Learning from Disaster |
2,444,244 | base_model = resnet50.ResNet50(include_top=False, weights='imagenet' )<choose_model_class> | y_pred=clf_rf.predict(test_data ) | Titanic - Machine Learning from Disaster |
2,444,244 | <choose_model_class><EOS> | my_submission = pd.DataFrame({'PassengerId': test_data.index.values, 'Survived': y_pred})
my_submission.to_csv('submission.csv', index=False)
my_submission | Titanic - Machine Learning from Disaster |
2,731,378 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_pretrained> | sns.set_style("whitegrid")
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 200)
warnings.filterwarnings('ignore')
print(device_lib.list_local_devices())
config = tf.ConfigProto(device_count={"CPU": 1, "GPU" : 1})
session = tf.Session(config=config)
K.set_session(session ) | Titanic - Machine Learning from Disaster |
2,731,378 | model.load_weights('.. /input/weights/model.hdf5' )<train_model> | test = pd.read_csv(".. /input/test.csv", ",")
train = pd.read_csv(".. /input/train.csv", ",")
test["is_test"] = True
train["is_test"] = False
common = pd.concat([test, train],axis=0 ).loc[:,["PassengerId", "Survived", "is_test",
"Age", "Cabin", "Embarked",
"Fare", "Name", "Parch", "Pclass",
"Sex", "SibSp", "Ticket"]] | Titanic - Machine Learning from Disaster |
2,731,378 | model.fit(X_train[:128], y_train[:128], epochs=30 )<train_model> | common["Ticket"].count() - len(common["Ticket"].unique() ) | Titanic - Machine Learning from Disaster |
2,731,378 | checkpoint = ModelCheckpoint(filepath='model.hdf5')
model.fit(X_train, y_train, epochs=100, batch_size=128, callbacks=[checkpoint] )<load_from_csv> | t = train.groupby(by="Ticket", as_index=False ).agg({"PassengerId" : 'count', "Sex" : lambda x : x[x=="female"].count() })
t.columns = ["Ticket", "SameTicket", "FemalesOnTicket"]
common = pd.merge(common, t, how="left", on="Ticket")
common["TicketDigits"] = pd.to_numeric(common["Ticket"].str.split(" " ).str[-1], erro... | Titanic - Machine Learning from Disaster |
2,731,378 | sample = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv' )<predict_on_test> | common["DoubleName"] = common["Name"].str.contains("\(")
common["NameLen"] = common["Name"].str.len() | Titanic - Machine Learning from Disaster |
2,731,378 | sample.has_cactus = model.predict(X_test )<save_to_csv> | common["Title"] = common["Name"].str.split(", " ).str[1].str.split(" " ).str[0]
common.loc[common["Title"].str[-1]!=".", "Title"]="Bad"
rare_title = common["Title"].value_counts() [common["Title"].value_counts() < 5].index
common["Title"] = common["Title"].apply(lambda x: 'Rare' if x in rare_title else x)
titletarget ... | Titanic - Machine Learning from Disaster |
2,731,378 | sample.to_csv('sample_submission.csv', index=False )<load_from_csv> | common["Family"] = common["Parch"] + common["SibSp"] + 1
common["Alone"] = common["Family"] == 1 | Titanic - Machine Learning from Disaster |
2,731,378 | input_path = '.. /input/'
train_path = input_path + 'train/train/'
test_path = input_path + 'test/test/'
train_dir=".. /input/train/train"
test_dir=".. /input/test/test"
train_df=pd.read_csv('.. /input/train.csv')
test_df=pd.read_csv('.. /input/sample_submission.csv')
train_id = train_df['id']
labels = train_df['has_... | cap = train.groupby(by="Cabin", as_index=False ).agg({"PassengerId" : 'count'})
cap.columns = ["Cabin", "SameCabin"]
common = pd.merge(common, cap, how="left", on="Cabin")
common["CabinNumber"] = pd.to_numeric(common["Cabin"].str[1:], errors = "coerce")
common["CabinEven"] = common["CabinNumber"] %2
common["CabinsPe... | Titanic - Machine Learning from Disaster |
2,731,378 | x_train, x_val, y_train, y_val = train_test_split(train_id, labels, test_size=0.2 )<data_type_conversions> | common['AgeGroup'] = pd.qcut(common['Age'].fillna(common['Age'].mean() ).astype(int), 6)
agetarget = common.groupby(by="AgeGroup", as_index=False ).agg({"Survived" : 'mean'})
agetarget.columns = ["AgeGroup", "TargetByAgeGroup"]
common = pd.merge(common, agetarget, how="left", on="AgeGroup")
common["IsTinyChild"] = c... | Titanic - Machine Learning from Disaster |
2,731,378 | def get_images(ids, filepath):
arr = []
for img_id in ids:
img = plt.imread(filepath + img_id)
arr.append(img)
arr = np.array(arr ).astype('float32')
arr = arr / 255
return arr<categorify> | common['FareGroup'] = pd.qcut(common['Fare'].fillna(common['Fare'].mean() ).astype(int), 6)
faretarget = common.groupby(by="FareGroup", as_index=False ).agg({"Survived" : 'mean'})
faretarget.columns = ["FareGroup", "TargetByFareGroup"]
common = pd.merge(common, faretarget, how="left", on="FareGroup")
common["Average... | Titanic - Machine Learning from Disaster |
2,731,378 | x_train = get_images(ids=x_train, filepath=train_path)
x_val = get_images(ids=x_val, filepath=train_path)
test = get_images(ids=test_id, filepath=test_path)
img_dim = x_train.shape[1:]<define_variables> | pclasstarget = common.groupby(by="Pclass", as_index=False ).agg({"Survived" : 'mean'})
pclasstarget.columns = ["Pclass", "TargetByPclass"]
common = pd.merge(common, pclasstarget, how="left", on="Pclass")
Embarkedtarget = common.groupby(by="Embarked", as_index=False ).agg({"Survived" : 'mean'})
Embarkedtarget.columns... | Titanic - Machine Learning from Disaster |
2,731,378 | batch_size = 64
epochs = 30
steps = x_train.shape[0] // batch_size<choose_model_class> | allfeatures = [
"PassengerId",
"is_test",
"Survived",
"Age",
"Fare",
"Parch",
"Pclass",
"SibSp",
"Sex",
"Embarked",
"SameTicket",
"FemalesOnTicket",
"SameCabin",
"Deck",
"TargetByDeck",
"TargetByTitle",
"TargetByAgeGroup",
"TargetByFareGroup",
"TargetByPclass",
"TargetByEmbarked",
"TargetBySex",
"Title",
"CabinNumber",... | Titanic - Machine Learning from Disaster |
2,731,378 | inputs = Input(shape=img_dim)
densenet121 = DenseNet121(weights='imagenet', include_top=False )(inputs)
flat1 = Flatten()(densenet121)
dense1 = Dense(units=256, use_bias=True )(flat1)
batchnorm1 = BatchNormalization()(dense1)
act1 = Activation(activation='relu' )(batchnorm1)
drop1 = Dropout(rate=0.5 )(act1)
out ... | c.iloc[:,3:] = Imputer(strategy="most_frequent" ).fit_transform(c.iloc[:,3:])
dep = c[c["is_test"] == False].loc[:, ["Survived"]]
indep = c[c["is_test"] == False].iloc[:, 3:]
res = c[c["is_test"] == True].iloc[:, 3:]
res_index = c[c["is_test"] == True].loc[:, "PassengerId"]
indep.iloc[:,3:] = StandardScaler().fit_tran... | Titanic - Machine Learning from Disaster |
2,731,378 | reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.3, patience=3, verbose=2, mode='max')
img_aug = ImageDataGenerator(rotation_range=20, vertical_flip=True, horizontal_flip=True)
img_aug.fit(x_train)
model.fit_generator(img_aug.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=steps, epochs=epoc... | with tf.device('/device:CPU:0'):
gs1 = Sequential()
gs1.add(Dense(45 ,activation='linear', input_dim=45))
gs1.add(BatchNormalization())
gs1.add(Dense(9,activation='linear'))
gs1.add(BatchNormalization())
gs1.add(Dropout(0.4))
gs1.add(Dense(5,activation='linear'))
gs1.add(BatchNormalization())
gs1.add(Dropout(0.2))
g... | Titanic - Machine Learning from Disaster |
2,731,378 | test_pred = model.predict(test, verbose=2 )<save_to_csv> | cvscores = []
data = pd.DataFrame()
i=1
with tf.device('/device:CPU:0'):
for train, test in StratifiedKFold(n_splits=5, shuffle=True, random_state=1 ).split(indep, dep.iloc[:,0]):
X = indep.reindex().iloc[train,:]
Y = dep.reindex().iloc[train,0]
Xv = indep.reindex().iloc[test,:]
Yv = dep.reindex().iloc[test,0]
gs1 = Se... | Titanic - Machine Learning from Disaster |
2,731,378 | test_df['has_cactus'] = test_pred
test_df.to_csv('submission.csv', index=False )<import_modules> | ; | Titanic - Machine Learning from Disaster |
2,731,378 | import os
import numpy as np
from fastai import *
from fastai.vision import *<define_variables> | indep_train, indep_test, dep_train, dep_test = train_test_split(indep, dep, test_size=0.40, random_state=47)
gs1 = lgb.LGBMClassifier(max_depth = 7,
lambda_l1 = 0.1,
lambda_l2 = 0.01,
learning_rate = 0.01,
n_estimators = 500, reg_alpha = 1.1, colsample_bytree = 0.9, subsample = 0.9,
n_jobs = 5)
gs1.fit(indep_train, d... | Titanic - Machine Learning from Disaster |
2,731,378 | train_path = Path('.. /input/train')
test_path = Path('.. /input/test')
print(train_path, test_path)
<load_from_csv> | model = []
cvscores = []
for i in range(0,90):
indep_train, indep_test, dep_train, dep_test = train_test_split(indep, dep, test_size=0.40, random_state=i)
gs1 = lgb.LGBMClassifier(max_depth = 7,
lambda_l1 = 0.1,
lambda_l2 = 0.01,
learning_rate = 0.01, num_iterations=20000,
n_estimators = 5000, reg_alpha = 1.1, colsamp... | Titanic - Machine Learning from Disaster |
2,731,378 | train_df = pd.read_csv('.. /input/train.csv')
train_df.head(10 )<load_from_csv> | result = pd.DataFrame(res_index.astype(np.int), columns=["PassengerId"])
result["Survived"] = g.astype(np.int)
result.to_csv("lgbm.csv", ",", index=None ) | Titanic - Machine Learning from Disaster |
2,731,378 | test_df = pd.read_csv('.. /input/sample_submission.csv')
<categorify> | gs1 = cb.CatBoostClassifier(depth = 9, reg_lambda=0.1,
learning_rate = 0.09,
iterations = 500)
gs1.fit(indep_train, dep_train, eval_set=[(indep_test, dep_test)], verbose=False, early_stopping_rounds=50);
g = gs1.predict(res)
a = accuracy_score(dep_test, gs1.predict(indep_test))
b = accuracy_score(dep_train, gs1.predi... | Titanic - Machine Learning from Disaster |
2,731,378 | test_data = ImageList.from_df(test_df, path = test_path, folder = 'test')
train_data =(ImageList.from_df(train_df, path = train_path, folder = 'train')
.split_by_rand_pct(0.1)
.label_from_df()
.add_test(test_data)
.transform(get_transforms() , size = 32)
.databunch(path = '.', bs = 64)
.normalize(imagenet_stats))<cho... | model = []
cvscores = []
for i in range(0, 90):
indep_train, indep_test, dep_train, dep_test = train_test_split(indep, dep, test_size=0.40, random_state=i)
gs1 = cb.CatBoostClassifier(depth = 9, reg_lambda=0.1,
learning_rate = 0.09,
iterations = 500)
gs1.fit(indep_train, dep_train, eval_set=[(indep_test, dep_test)], ... | Titanic - Machine Learning from Disaster |
2,731,378 | learner = cnn_learner(train_data, models.densenet161, metrics = [error_rate, accuracy] )<train_model> | gs1 = xgb.XGBClassifier(max_depth = 9,
learning_rate = 0.01,
n_estimators = 500, reg_alpha = 1.1, colsample_bytree = 0.9, subsample = 0.9,
n_jobs = 5)
gs1.fit(indep_train, dep_train, eval_set=[(indep_test, dep_test)], verbose=False, early_stopping_rounds=50);
g = gs1.predict(res)
a = accuracy_score(dep_test, gs1.pred... | Titanic - Machine Learning from Disaster |
2,731,378 | learner.fit_one_cycle(8 )<train_model> | model = []
cvscores = []
for i in range(0, 90):
indep_train, indep_test, dep_train, dep_test = train_test_split(indep, dep, test_size=0.40, random_state=i)
gs1 = xgb.XGBClassifier(max_depth = 7, reg_lambda = 0.02,
learning_rate = 0.01,
n_estimators = 5000, reg_alpha = 1.1, colsample_bytree = 0.9, subsample = 0.9,
n_jo... | Titanic - Machine Learning from Disaster |
2,731,378 | <predict_on_test><EOS> | d = {'Model':["Keras MLP", "LightGBM", "CatBoost", "XGBoost"],
'Mean accuracy': [mlp_mean, lgb_mean, cb_mean, xgb_mean],
'Std.Dev.': [mlp_stdev, lgb_stdev, cb_stdev, xgb_stdev],
'Leaderboard': [0.77033, 0.82296, 0.78947, 0.77511]}
pd.DataFrame(data=d, columns=["Model", "Mean accuracy", "Std.Dev.", "Leaderboard"] ).sort... | Titanic - Machine Learning from Disaster |
937,170 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline
warnings.filterwarnings(action='ignore', category=DeprecationWarning)
warnings.filterwarnings(action='ignore', category=FutureWarning ) | Titanic - Machine Learning from Disaster |
937,170 | test_df.to_csv('submission.csv', index = False )<import_modules> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
937,170 | print(os.listdir(".. /input"))
seed = 4529
np.random.seed(seed )<load_from_csv> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
937,170 | base_dir = os.path.join(".. ", "input")
train_df = pd.read_csv(os.path.join(base_dir, "train.csv"))
train_dir = os.path.join(base_dir, "train/train")
test_dir = os.path.join(base_dir, "test/test")
print(train_df.head() )<set_options> | data = pd.concat([train, test])
train_size = train.shape[0]
test_size = test.shape[0]
data[train_size-3:train_size+3] | Titanic - Machine Learning from Disaster |
937,170 | %load_ext tensorboard.notebook
%tensorboard --logdir logs<define_variables> | data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(data['Title'], data['Pclass'] ) | Titanic - Machine Learning from Disaster |
937,170 |
<define_variables> | age_ref = data.groupby('Title' ).Age.mean()
data = data.assign(
Age = data.apply(lambda r: r.Age if pd.notnull(r.Age)else age_ref[r.Title] , axis=1)
)
del age_ref | Titanic - Machine Learning from Disaster |
937,170 | train_df['has_cactus'] = train_df['has_cactus'].astype(str)
batch_size = 64
train_size = 15750
validation_size = 1750
datagen = ImageDataGenerator(
rescale=1./255,
horizontal_flip=True,
vertical_flip=False,
brightness_range=(1, 1.3),
shear_range=0.05,
validation_split=0.1)
data_args = {
"dataframe": train_df,
"direc... | data['AgeBand'] = pd.cut(data['Age'], 5, labels=range(5)).astype(int)
data[['AgeBand', 'Survived']].groupby(['AgeBand'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | model = Sequential([
Conv2D(64,(3,3), padding='same', activation="relu", input_shape=(32, 32, 3)) ,
BatchNormalization() ,
Conv2D(64,(3,3), padding='same', activation="relu"),
BatchNormalization() ,
Conv2D(64,(3,3), padding='same', activation="relu"),
BatchNormalization() ,
MaxPooling2D(2,2),
Dropout(0.4),
Conv2D(128,(... | data['Title'] = data['Title'].replace(['Don', 'Capt', 'Col', 'Major', 'Sir', 'Jonkheer', 'Rev', 'Dr'], 'Honored')
data['Title'] = data['Title'].replace(['Lady', 'Dona', 'Mme', 'Countess'], 'Mrs')
data['Title'] = data['Title'].replace(['Mlle', 'Ms'], 'Miss')
data[['Title', 'Survived']].groupby(['Title'] ).agg(['count... | Titanic - Machine Learning from Disaster |
937,170 | ckpt_path = 'aerial_cactus_detection.hdf5'
earlystop = EarlyStopping(monitor='val_acc', patience=10, verbose=1, restore_best_weights=True)
reducelr = ReduceLROnPlateau(monitor='val_acc', factor=0.5, patience=3, verbose=1, min_lr=1.e-6)
modelckpt_cb = ModelCheckpoint(ckpt_path, monitor='val_acc', verbose=1, save_best_... | data['Fare'] = data['Fare'].fillna(13.30 ) | Titanic - Machine Learning from Disaster |
937,170 | history = model.fit_generator(train_generator,
validation_data=validation_generator,
steps_per_epoch=train_size//batch_size,
validation_steps=validation_size//batch_size,
epochs=100, verbose=1,
shuffle=True,
callbacks=callbacks )<load_from_csv> | data['FareBand'] = 0
data.loc[(data.Fare > 0)&(data.Fare <= 7.5), 'FareBand'] = 1
data.loc[(data.Fare > 7.5)&(data.Fare <= 12.5), 'FareBand'] = 2
data.loc[(data.Fare > 12.5)&(data.Fare <= 17), 'FareBand'] = 3
data.loc[(data.Fare > 17)&(data.Fare <= 29), 'FareBand'] = 4
data.loc[data.Fare > 29, 'FareBand'] = 5
data[['Fa... | Titanic - Machine Learning from Disaster |
937,170 | test_df = pd.read_csv(os.path.join(base_dir, "sample_submission.csv"))
print(test_df.head())
test_images = []
images = test_df['id'].values
for image_id in images:
test_images.append(cv2.imread(os.path.join(test_dir, image_id)))
test_images = np.asarray(test_images)
test_images = test_images / 255.0
print("Number of... | data['Embarked'] = data['Embarked'].fillna('S')
data[['Embarked', 'Survived']].groupby(['Embarked'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | pred = model.predict(test_images)
test_df['has_cactus'] = pred
test_df.to_csv('aerial-cactus-submission.csv', index = False )<load_from_csv> | data['DeckCode'] =(data['Cabin']
.str.slice(0,1)
.map({
'C':1,
'E':2,
'G':3,
'D':4,
'A':5,
'B':6,
'F':7,
})
.fillna(0)
.astype(int))
data[['DeckCode', 'Survived']].groupby(['DeckCode'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | train = pd.read_csv('/kaggle/input/google-quest-challenge/train.csv')
test = pd.read_csv('/kaggle/input/google-quest-challenge/test.csv')
sample_submission = pd.read_csv('/kaggle/input/google-quest-challenge/sample_submission.csv' )<load_from_csv> | data['Room'] =(data['Cabin']
.str.slice(1,5 ).str.extract('([0-9]+)', expand=False)
.fillna(0)
.astype(int))
data['RoomBand'] = 0
data.loc[(data.Room > 0)&(data.Room <= 20), 'RoomBand'] = 1
data.loc[(data.Room > 20)&(data.Room <= 40), 'RoomBand'] = 2
data.loc[(data.Room > 40)&(data.Room <= 80), 'RoomBand'] = 3
data.lo... | Titanic - Machine Learning from Disaster |
937,170 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bert-base-uncased-huggingface-transformer/'
tokenizer = BertTokenizer.from_pretrained(BERT_PATH+'bert-base-uncased-vocab.txt')
MAX_SEQUENCE_LENGTH = 512
df_train = pd.read_csv(PATH+'train.csv')
df_test = pd.read_csv(PATH+'test.csv')
df_sub = pd.read_c... | data.loc[data.Ticket=='LINE', 'Ticket'] = 'LINE1' | Titanic - Machine Learning from Disaster |
937,170 | !pip install.. /input/sacremoses > /dev/null
sys.path.insert(0, ".. /input/transformers/" )<define_variables> | data['Odd'] =(data['Ticket']
.str.slice(-1)
.astype(int)
.map(lambda x: x % 2 == 0)
.astype(int)
)
data[['Odd', 'Survived']].groupby(['Odd'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | target_cols = ['question_asker_intent_understanding',
'question_body_critical', 'question_conversational',
'question_expect_short_answer', 'question_fact_seeking',
'question_has_commonly_accepted_answer',
'question_interestingness_others', 'question_interestingness_self',
'question_multi_intent', 'question_not_really_a... | data['FamilySize'] =(data['SibSp'] + data['Parch'] ).astype(int)
data[['FamilySize', 'Survived']].groupby(['FamilySize'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | train.isna().sum()<count_values> | data[['Sex', 'Survived']].groupby(['Sex'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | train_category = train['category'].value_counts()
test_category = test['category'].value_counts()<categorify> | data['FamilySizeBand'] = 0
data.loc[(data.FamilySize == 1), 'FamilySizeBand'] = 1
data.loc[(data.FamilySize == 2), 'FamilySizeBand'] = 2
data.loc[(data.FamilySize == 3), 'FamilySizeBand'] = 2
data.loc[data.FamilySize > 3, 'FamilySizeBand'] = 2
data[['FamilySizeBand', 'Survived']].groupby(['FamilySizeBand'] ).agg(['coun... | Titanic - Machine Learning from Disaster |
937,170 | def _convert_to_transformer_inputs(title, question, answer, tokenizer, max_sequence_length):
def return_id(str1, str2, truncation_strategy, length):
inputs = tokenizer.encode_plus(str1, str2,
add_special_tokens=True,
max_length=length,
truncation_strategy=truncation_strategy)
input_ids = inputs["input_ids"]
input_ma... | data['IsAlone'] =(data['SibSp'] + data['Parch'] == 0 ).astype(int)
data[['IsAlone', 'Survived']].groupby(['IsAlone'] ).agg(['count','mean'] ) | Titanic - Machine Learning from Disaster |
937,170 | def compute_spearmanr_ignore_nan(trues, preds):
rhos = []
for tcol, pcol in zip(np.transpose(trues), np.transpose(preds)) :
rhos.append(spearmanr(tcol, pcol ).correlation)
return np.nanmean(rhos)
def create_model() :
q_id = tf.keras.layers.Input(( MAX_SEQUENCE_LENGTH,), dtype=tf.int32)
a_id = tf.keras.layers.Input((... | data['SexCode'] = LabelEncoder().fit_transform(data['Sex'])
data['TitleCode'] = LabelEncoder().fit_transform(data['Title'])
data['EmbarkedCode'] = LabelEncoder().fit_transform(data['Embarked'] ) | Titanic - Machine Learning from Disaster |
937,170 | outputs = compute_output_arrays(df_train, output_categories)
inputs = compute_input_arrays(df_train, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
test_inputs = compute_input_arrays(df_test, input_categories, tokenizer, MAX_SEQUENCE_LENGTH )<split> | cols = [
'Pclass',
'Sex',
'FamilySize',
'SibSp',
'Parch',
'IsAlone',
'AgeBand',
'Fare',
'Title',
'DeckCode',
'RoomBand',
]
X_train = data[:train_size][cols]
Y_train = data[:train_size]['Survived'].astype(int)
X_test = data[train_size:][cols]
print(X_train.shape, Y_train.shape, X_test.shape)
X_train.head() | Titanic - Machine Learning from Disaster |
937,170 | gkf = GroupKFold(n_splits=5 ).split(X=df_train.question_body, groups=df_train.question_body)
valid_preds = []
test_preds = []
for fold,(train_idx, valid_idx)in enumerate(gkf):
if fold in [0, 2]:
train_inputs = [inputs[i][train_idx] for i in range(len(inputs)) ]
train_outputs = outputs[train_idx]
valid_inputs = [inputs... | one_hot_features = [
'Sex',
'AgeBand',
'Title',
'DeckCode',
'RoomBand',
]
X_train = pd.get_dummies(X_train, columns = one_hot_features)
X_test = pd.get_dummies(X_test, columns = one_hot_features)
print(X_train.shape, Y_train.shape, X_test.shape ) | Titanic - Machine Learning from Disaster |
937,170 | df_sub.iloc[:, 1:] = np.average(test_preds, axis=0)
df_sub.to_csv('submission.csv', index=False )<import_modules> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
logreg.score(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
937,170 | import os
import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow_hub as th
import matplotlib.pyplot as pl
from pprint import pprint as pp
from six import BytesIO as io
from tqdm import tqdm
from PIL import Image, ImageColor, ImageDraw, ImageFont, ImageOps<categorify> | svc = SVC(C=9)
svc.fit(X_train, Y_train)
print(svc.score(X_train, Y_train))
scores = model_selection.cross_val_score(svc, X_train, Y_train, cv=5, scoring='accuracy')
print(scores)
print("Kfold on SVC: %0.4f(+/- %0.4f)" %(scores.mean() , scores.std())) | Titanic - Machine Learning from Disaster |
937,170 | def pred(img_id, rs):
pred_str = []
for i in range(len(rs['detection_scores'])) :
cn = rs['detection_class_names'][i].decode("utf-8")
YMin,XMin,YMax,XMax = rs['detection_boxes'][i]
sc = rs['detection_scores'][i]
pred_str.append(
f"{cn} {sc} {XMin} {YMin} {XMax} {YMax}"
)
pred_str = " ".join(pred_str)
return {
"Ima... | knn = KNeighborsClassifier(n_neighbors=9)
knn.fit(X_train, Y_train)
print(knn.score(X_train, Y_train))
scores = model_selection.cross_val_score(knn, X_train, Y_train, cv=5, scoring='accuracy')
print(scores)
print("Kfold on KNeighborsClassifier: %0.4f(+/- %0.4f)" %(scores.mean() , scores.std())) | Titanic - Machine Learning from Disaster |
937,170 | def bound_bx_img(image,
ymin,
xmin,
ymax,
xmax,
color,
font,
thickness = 4,
display_str_list =()):
drw = ImageDraw.Draw(image)
im_width, im_height = image.size
(left, right, top, bottom)=(xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
drw.line([(left, top),(left, bottom),(right, bottom),(right... | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
gaussian.score(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
937,170 | sm_img_pth = ".. /input/open-images-2019-object-detection/test/4fce161b84175459.jpg"
with tf.Graph().as_default() :
img_str_ph = tf.placeholder(tf.string)
do_img = tf.image.decode_jpeg(img_str_ph)
de_img_fl = tf.image.convert_image_dtype(
image = do_img, dtype = tf.float32
)
img_tf = tf.expand_dims(de_img_fl, 0)
... | perceptron = Perceptron(max_iter=6)
perceptron.fit(X_train, Y_train)
perceptron.score(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
937,170 | img_str_ph = tf.placeholder(tf.string)
de_img = tf.image.decode_jpeg(img_str_ph)
de_img_fl = tf.image.convert_image_dtype(
image = de_img, dtype = tf.float32
)
img_ts = tf.expand_dims(de_img_fl, 0 )<feature_engineering> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
decision_tree.score(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
937,170 | mdl_url = "https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1"
dc = th.Module(mdl_url)
dc_ot = dc(img_ts, as_dict = True )<load_pretrained> | sgd = SGDClassifier(max_iter=3)
sgd.fit(X_train, Y_train)
sgd.score(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
937,170 | with tf.gfile.Open(sm_img_pth, "rb")as bf :
img_str = bf.read()
rs_ot, img_ot = ss.run(
[dc_ot, de_img],
feed_dict = {img_str_ph: img_str}
)<load_from_csv> | linear_svc = LinearSVC(C=0.07)
linear_svc.fit(X_train, Y_train)
print(linear_svc.score(X_train, Y_train))
scores = model_selection.cross_val_score(linear_svc, X_train, Y_train, cv=5, scoring='accuracy')
print(scores)
print("Kfold on LinearSVC: %0.4f(+/- %0.4f)" %(scores.mean() , scores.std())) | Titanic - Machine Learning from Disaster |
937,170 | sm_sub = pd.read_csv('.. /input/open-images-2019-object-detection/sample_submission.csv')
img_ids = sm_sub['ImageId']
preds = []
for img_id in tqdm(img_ids):
img_ph = f'.. /input/open-images-2019-object-detection/test/{img_id}.jpg'
with tf.gfile.Open(img_ph, "rb")as bf :
img_str = bf.read()
rs_ot = ss.run(
dc_ot,
fee... | rf_params = {
'n_estimators': 700,
'max_depth': 5,
'min_samples_split': 10,
'min_samples_leaf': 1,
'max_features':'auto',
'oob_score':True,
}
random_forest = RandomForestClassifier(**rf_params)
random_forest.fit(X_train, Y_train)
print(random_forest.score(X_train, Y_train))
scores = model_selection.cross_val_score(ra... | Titanic - Machine Learning from Disaster |
937,170 | submission = pd.DataFrame(preds)
submission.to_csv('submission.csv', index=False )<load_from_csv> | Titanic - Machine Learning from Disaster | |
937,170 | base_dir='.. /input/'
df1=pd.read_csv(base_dir+'tf-hub-end/'+'submission_75k.csv')
df1.head()<load_from_csv> | xg_boost = xgb.XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=0.65, gamma=2, learning_rate=0.3, max_delta_step=1,
max_depth=4, min_child_weight=2, missing=None, n_estimators=280,
n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,
reg_alpha=0, reg_lambda=1, scale_... | Titanic - Machine Learning from Disaster |
937,170 | base_dir='.. /input/'
df2=pd.read_csv(base_dir+'tf-hub-75k/'+'submission_75k.csv')
df2.head()<load_from_csv> | xg_boost.fit(X_train, Y_train)
Y_pred = xg_boost.predict(X_test)
print(xg_boost.score(X_train, Y_train))
scores = model_selection.cross_val_score(xg_boost, X_train, Y_train, cv=5, scoring='accuracy')
print(scores)
print("Kfold on XGBClassifier: %0.4f(+/- %0.4f)" %(scores.mean() , scores.std())) | Titanic - Machine Learning from Disaster |
937,170 | <load_from_csv><EOS> | submission = pd.DataFrame({
"PassengerId": data[train_size:]["PassengerId"],
"Survived": Y_pred
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
3,985,857 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<concatenate> | !pip install fastai==0.7.0
%load_ext autoreload
%autoreload 2
%matplotlib inline | Titanic - Machine Learning from Disaster |
3,985,857 | df_final=pd.concat([df1, df2, df3, df4])
df_final.head()<save_to_csv> | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
train_df.head() | Titanic - Machine Learning from Disaster |
3,985,857 | df_final.to_csv('submission.csv',index=None )<import_modules> | train_cats(train_df)
apply_cats(test_df, train_df ) | Titanic - Machine Learning from Disaster |
3,985,857 | import os
from pprint import pprint
from six import BytesIO
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow_hub as hub
from PIL import Image, ImageColor, ImageDraw, ImageFont, ImageOps
from tqdm import tqdm<categorify> | df_trn, y_trn, nas = proc_df(train_df, 'Survived')
df_test, _, _ = proc_df(test_df, na_dict=nas)
df_trn.head() | 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.