kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,821,394 | gc.collect()<define_search_model> | X = train
z = target | Titanic - Machine Learning from Disaster |
6,821,394 | def upsample_conv(filters, kernel_size, strides, padding):
return layers.Conv2DTranspose(filters, kernel_size, strides=strides, padding=padding)
def upsample_simple(filters, kernel_size, strides, padding):
return layers.UpSampling2D(strides)
if UPSAMPLE_MODE=='DECONV':
upsample=upsample_conv
else:
upsample=upsample_s... | Xtrain, Xval, Ztrain, Zval = train_test_split(X, z, test_size=0.2, random_state=0)
train_set = lgbm.Dataset(Xtrain, Ztrain, silent=False)
valid_set = lgbm.Dataset(Xval, Zval, silent=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | def IoU(y_true, y_pred, eps=1e-6):
intersection = K.sum(y_true * y_pred, axis=[1,2,3])
union = K.sum(y_true, axis=[1,2,3])+ K.sum(y_pred, axis=[1,2,3])- intersection
return K.mean(( intersection + eps)/(union + eps), axis=0)
def zero_IoU(y_true, y_pred):
return IoU(1-y_true, 1-y_pred)
def agg_loss(in_gt, in_pred):
r... | params = {
'boosting_type':'gbdt',
'objective': 'regression',
'num_leaves': 31,
'learning_rate': 0.05,
'max_depth': -1,
'subsample': 0.8,
'bagging_fraction' : 1,
'max_bin' : 5000 ,
'bagging_freq': 20,
'colsample_bytree': 0.6,
'metric': 'rmse',
'min_split_gain': 0.5,
'min_child_weight': 1,
'min_child_samples': 10,
'scal... | Titanic - Machine Learning from Disaster |
6,821,394 | weight_path="{}_weights.best.hdf5".format('seg_model')
checkpoint = ModelCheckpoint(weight_path, monitor='val_loss', verbose=1,
save_best_only=True, mode='min', save_weights_only = True)
reduceLROnPlat = ReduceLROnPlateau(monitor='val_loss', factor=0.2,
patience=1, verbose=1, mode='min',
min_delta=0.0001, cooldown=2,... | feature_score = pd.DataFrame(train.columns, columns = ['feature'])
feature_score['score_lgb'] = modelL.feature_importance() | Titanic - Machine Learning from Disaster |
6,821,394 | step_count = min(MAX_TRAIN_STEPS, train_df.shape[0]//BATCH_SIZE)
aug_gen = create_aug_gen(make_image_gen(train_df))
loss_history = [seg_model.fit_generator(aug_gen,
steps_per_epoch=step_count,
epochs=10,
validation_data=(valid_x, valid_y),
callbacks=callbacks_list,
workers=1,
max_queue_size = 20,use_multiprocessing=Tr... | y_train_lgb = modelL.predict(train, num_iteration=modelL.best_iteration ).astype('int')
y_preds_lgb = modelL.predict(test, num_iteration=modelL.best_iteration ) | Titanic - Machine Learning from Disaster |
6,821,394 | seg_model.load_weights(weight_path)
seg_model.save('seg_model.h5' )<predict_on_test> | data_tr = xgb.DMatrix(Xtrain, label=Ztrain)
data_cv = xgb.DMatrix(Xval , label=Zval)
data_train = xgb.DMatrix(train)
data_test = xgb.DMatrix(test)
evallist = [(data_tr, 'train'),(data_cv, 'valid')] | Titanic - Machine Learning from Disaster |
6,821,394 | pred_y = seg_model.predict(valid_x)
print(pred_y.shape, pred_y.min() , pred_y.max() , pred_y.mean() )<choose_model_class> | parms = {'max_depth':8,
'objective':'reg:logistic',
'eta' :0.3,
'subsample':0.8,
'lambda ' :4,
'colsample_bytree ':0.9,
'colsample_bylevel':1,
'min_child_weight': 10}
modelx = xgb.train(parms, data_tr, num_boost_round=200, evals = evallist,
early_stopping_rounds=30, maximize=False,
verbose_eval=10)
print('score = %1.5... | Titanic - Machine Learning from Disaster |
6,821,394 | if IMG_SCALING is not None:
fullres_model = models.Sequential()
fullres_model.add(layers.AvgPool2D(IMG_SCALING, input_shape =(None, None, 3)))
fullres_model.add(seg_model)
fullres_model.add(layers.UpSampling2D(IMG_SCALING))
else:
fullres_model = seg_model
fullres_model.save('fullres_model.h5' )<predict_on_test> | feature_score['score_xgb'] = feature_score['feature'].map(modelx.get_score(importance_type='weight'))
feature_score | Titanic - Machine Learning from Disaster |
6,821,394 | def predict(img, path=test_image_dir):
c_img = imread(os.path.join(path, c_img_name))
c_img = np.expand_dims(c_img, 0)/255.0
cur_seg = fullres_model.predict(c_img)[0]
cur_seg = binary_opening(cur_seg>1e3, np.expand_dims(disk(2), -1))
return cur_seg, c_img
def pred_encode(img):
cur_seg, _ = predict(img)
cur_rles = rle_... | y_train_xgb = modelx.predict(data_train ).astype('int')
y_preds_xgb = modelx.predict(data_test ) | Titanic - Machine Learning from Disaster |
6,821,394 | test_paths = np.array(os.listdir(test_image_dir))
print(len(test_paths), 'test images found' )<define_variables> | Scaler_train = preprocessing.MinMaxScaler()
train = pd.DataFrame(
Scaler_train.fit_transform(train),
columns=train.columns,
index=train.index
) | Titanic - Machine Learning from Disaster |
6,821,394 | %%time
out_pred_rows = []
for c_img_name in tqdm_notebook(test_paths[:30000]):
out_pred_rows += [pred_encode(c_img_name)]<prepare_output> | test = pd.DataFrame(
Scaler_train.fit_transform(test),
columns=test.columns,
index=test.index
) | Titanic - Machine Learning from Disaster |
6,821,394 | sub = pd.DataFrame(out_pred_rows)
sub.columns = ['ImageId', 'EncodedPixels']
sub = sub[sub.EncodedPixels.notnull() ]
sub.head()<save_to_csv> | logreg = LogisticRegression()
logreg.fit(train, target)
coeff_logreg = pd.DataFrame(train.columns.delete(0))
coeff_logreg.columns = ['feature']
coeff_logreg["score_logreg"] = pd.Series(logreg.coef_[0])
coeff_logreg.sort_values(by='score_logreg', ascending=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | sub1 = pd.read_csv('.. /input/sample_submission.csv')
sub1 = pd.DataFrame(np.setdiff1d(sub1['ImageId'].unique() , sub['ImageId'].unique() , assume_unique=True), columns=['ImageId'])
sub1['EncodedPixels'] = None
print(len(sub1), len(sub))
sub = pd.concat([sub, sub1])
print(len(sub))
sub.to_csv('submission.csv', index... | coeff_logreg["score_logreg"] = coeff_logreg["score_logreg"].abs()
feature_score = pd.merge(feature_score, coeff_logreg, on='feature' ) | Titanic - Machine Learning from Disaster |
6,821,394 |
<set_options> | eli5.show_weights(logreg ) | Titanic - Machine Learning from Disaster |
6,821,394 | %matplotlib inline
pd.options.display.max_rows = 128
pd.options.display.max_columns = 128
plt.rcParams['figure.figsize'] =(12, 9 )<load_from_csv> | y_train_logreg = logreg.predict(train ).astype('int')
y_preds_logreg = logreg.predict(test ) | Titanic - Machine Learning from Disaster |
6,821,394 | train = pd.read_csv('.. /input/train/train.csv')
print('train shape:', train.shape)
test = pd.read_csv('.. /input/test/test.csv')
print('test shape:', test.shape)
sample_submission = pd.read_csv('.. /input/test/sample_submission.csv')
labels_breed = pd.read_csv('.. /input/breed_labels.csv')
labels_state = pd.read... | linreg = LinearRegression()
linreg.fit(train, target)
coeff_linreg = pd.DataFrame(train.columns.delete(0))
coeff_linreg.columns = ['feature']
coeff_linreg["score_linreg"] = pd.Series(linreg.coef_)
coeff_linreg.sort_values(by='score_linreg', ascending=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | test_df_ids = test[['PetID']]
print(test_df_ids.shape)
test_df_imgs = pd.DataFrame(test_image_files)
test_df_imgs.columns = ['image_filename']
test_imgs_pets = test_df_imgs['image_filename'].apply(lambda x: x.split('/')[-1].split('-')[0])
test_df_imgs = test_df_imgs.assign(PetID=test_imgs_pets)
print(len(test_imgs_... | eli5.show_weights(linreg ) | Titanic - Machine Learning from Disaster |
6,821,394 | class PetFinderParser(object):
def __init__(self, debug=False):
self.debug = debug
self.sentence_sep = ' '
self.extract_sentiment_text = False
def open_metadata_file(self, filename):
with open(filename, 'r')as f:
metadata_file = json.load(f)
return metadata_file
def open_sentiment_file(self, filename):
with open(f... | coeff_linreg["score_linreg"] = coeff_linreg["score_linreg"].abs() | Titanic - Machine Learning from Disaster |
6,821,394 | aggregates = ['mean', 'sum']
train_metadata_desc = train_dfs_metadata.groupby(['PetID'])['metadata_annots_top_desc'].unique()
train_metadata_desc = train_metadata_desc.reset_index()
train_metadata_desc[
'metadata_annots_top_desc'] = train_metadata_desc[
'metadata_annots_top_desc'].apply(lambda x: ' '.join(x))
prefix = ... | feature_score = pd.merge(feature_score, coeff_linreg, on='feature')
feature_score = feature_score.fillna(0)
feature_score = feature_score.set_index('feature')
feature_score | Titanic - Machine Learning from Disaster |
6,821,394 | train_proc = train.copy()
train_proc = train_proc.merge(
train_sentiment_gr, how='left', on='PetID')
train_proc = train_proc.merge(
train_metadata_gr, how='left', on='PetID')
train_proc = train_proc.merge(
train_metadata_desc, how='left', on='PetID')
train_proc = train_proc.merge(
train_sentiment_desc, how='left... | y_train_linreg = linreg.predict(train ).astype('int')
y_preds_linreg = linreg.predict(test ) | Titanic - Machine Learning from Disaster |
6,821,394 | train_breed_main = train_proc[['Breed1']].merge(
labels_breed, how='left',
left_on='Breed1', right_on='BreedID',
suffixes=('', '_main_breed'))
train_breed_main = train_breed_main.iloc[:, 2:]
train_breed_main = train_breed_main.add_prefix('main_breed_')
train_breed_second = train_proc[['Breed2']].merge(
labels_breed,... | feature_score.sort_values('mean', ascending=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | X = pd.concat([train_proc, test_proc], ignore_index=True, sort=False)
{}'.format(np.sum(pd.isnull(X))))
column_types = X.dtypes
int_cols = column_types[column_types == 'int']
float_cols = column_types[column_types == 'float']
cat_cols = column_types[column_types == 'object']
print('\tinteger columns:
{}'.format(int_co... | w_lgb = 0.48
w_xgb = 0.48
w_logreg = 0.03
w_linreg = 1 - w_lgb - w_xgb - w_logreg
w_linreg | Titanic - Machine Learning from Disaster |
6,821,394 | X_temp = X.copy()
text_columns = ['Description', 'metadata_annots_top_desc', 'sentiment_entities']
categorical_columns = ['main_breed_BreedName', 'second_breed_BreedName']
to_drop_columns = ['PetID', 'Name', 'RescuerID']
rescuer_count = X.groupby(['RescuerID'])['PetID'].count().reset_index()
rescuer_count.columns = ['R... | feature_score.sort_values('merging', ascending=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | n_components = 5
text_features = []
for i in X_text.columns:
print('generating features from: {}'.format(i))
svd_ = TruncatedSVD(
n_components=n_components, random_state=1337)
nmf_ = NMF(
n_components=n_components, random_state=1337)
tfidf_col = TfidfVectorizer().fit_transform(X_text.loc[:, i].values)
svd_col = sv... | y_preds = w_lgb*y_preds_lgb + w_xgb*y_preds_xgb + w_logreg*y_preds_logreg + w_linreg*y_preds_linreg | Titanic - Machine Learning from Disaster |
6,821,394 | X_temp_column_types = X_temp.dtypes
X_temp_int_cols = X_temp_column_types[X_temp_column_types == 'int']
X_temp_float_cols = X_temp_column_types[X_temp_column_types == 'float']
X_temp_cat_cols = X_temp_column_types[X_temp_column_types == 'object']
print('\tinteger columns:
{}'.format(X_temp_int_cols))
print('
\tfloat co... | submission['Survived'] = [1 if x>0.5 else 0 for x in y_preds]
submission.head() | Titanic - Machine Learning from Disaster |
6,821,394 | from sklearn.datasets import make_hastie_10_2
from sklearn.ensemble import GradientBoostingClassifier
import matplotlib.pyplot as plt<split> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,821,394 | <prepare_x_and_y><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
4,754,840 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | import pandas as pd
import numpy as np | Titanic - Machine Learning from Disaster |
4,754,840 | clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.05, max_depth=5, random_state=0)
clf.fit(tr_x, tr_y )<predict_on_test> | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
4,754,840 | val_prediction = clf.predict(val_x )<compute_test_metric> | train.drop(['Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 | cohen_kappa_score(val_y, val_prediction, weights = "quadratic" )<import_modules> | sample_sub=pd.read_csv(".. /input/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<load_from_csv> | test.drop(['Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<prepare_x_and_y> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<choose_model_class> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<train_model> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 | clf_submit = GradientBoostingClassifier(n_estimators=100, learning_rate=0.05, max_depth=5, random_state=0)
clf_submit.fit(all_x, all_y )<save_to_csv> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 | prediction = clf_submit.predict(test_data)
submission = pd.DataFrame({'PetID': test['PetID'].values, 'AdoptionSpeed': [int(i)for i in prediction]})
print(submission.head())
submission.to_csv('submission.csv', index=False )<train_model> | train.drop(['Cabin'],axis=1,inplace=True)
test.drop(['Cabin'],axis=1,inplace=True)
test.drop(['Ticket'],axis=1,inplace=True)
train.drop(['Ticket'],axis=1,inplace=True)
train.drop(['PassengerId'],axis=1,inplace=True)
test.drop(['PassengerId'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<prepare_x_and_y> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<categorify> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<feature_engineering> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<feature_engineering> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 |
<feature_engineering> | train['Age'].fillna(( train['Age'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<prepare_x_and_y> | test['Age'].fillna(( test['Age'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<train_model> | test['Fare'].fillna(( test['Fare'].mean()), inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 |
<import_modules> | train.dropna() | Titanic - Machine Learning from Disaster |
4,754,840 | np.random.seed(724 )<compute_test_metric> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 | def confusion_matrix(rater_a, rater_b, min_rating=None, max_rating=None):
assert(len(rater_a)== len(rater_b))
if min_rating is None:
min_rating = min(rater_a + rater_b)
if max_rating is None:
max_rating = max(rater_a + rater_b)
num_ratings = int(max_rating - min_rating + 1)
conf_mat = [[0 for i in range(num_rating... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,754,840 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | Pclass=pd.get_dummies(train['Pclass'],drop_first=True)
Pclass1=pd.get_dummies(test['Pclass'],drop_first=True)
Sex=pd.get_dummies(train['Sex'],drop_first=True)
Sex1=pd.get_dummies(test['Sex'],drop_first=True)
Embarked=pd.get_dummies(train['Embarked'],drop_first=True)
Embarked1=pd.get_dummies(test['Embarked'],drop_f... | Titanic - Machine Learning from Disaster |
4,754,840 | print('Train')
train = pd.read_csv(".. /input/train/train.csv")
print(train.shape)
print('Test')
test = pd.read_csv(".. /input/test/test.csv")
print(test.shape)
print('Breeds')
breeds = pd.read_csv(".. /input/breed_labels.csv")
print(breeds.shape)
print('Colors')
colors = pd.read_csv(".. /input/color_labels.c... | train=pd.concat([train,Pclass,Sex,Embarked],axis=1)
test=pd.concat([test,Pclass1,Sex1,Embarked1],axis=1 ) | Titanic - Machine Learning from Disaster |
4,754,840 | SVD_COMPONENTS = 120
train_desc = train.Description.fillna("none" ).values
test_desc = test.Description.fillna("none" ).values
tfv = TfidfVectorizer(min_df=3, max_features=10000,
strip_accents='unicode', analyzer='word', token_pattern=r'\w{1,}',
ngram_range=(1, 3), use_idf=1, smooth_idf=1, sublinear_tf=1,
stop_words = ... | train.drop(['Sex','Embarked','Pclass'],axis=1,inplace=True)
test.drop(['Sex','Embarked','Pclass'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
4,754,840 | vertex_xs = []
vertex_ys = []
bounding_confidences = []
bounding_importance_fracs = []
dominant_blues = []
dominant_greens = []
dominant_reds = []
dominant_pixel_fracs = []
dominant_scores = []
label_descriptions = []
label_scores = []
nf_count = 0
nl_count = 0
for pet in train_id:
try:
with open('.. /input/train_metad... | y=train['Survived'] | Titanic - Machine Learning from Disaster |
4,754,840 | numeric_cols = ['Age', 'Quantity', 'Fee', 'VideoAmt', 'PhotoAmt', 'AdoptionSpeed', 'doc_sent_mag', 'doc_sent_score', 'dominant_score', 'dominant_pixel_frac', 'dominant_red', 'dominant_green', 'dominant_blue', 'bounding_importance', 'bounding_confidence', 'vertex_x', 'vertex_y', 'label_score'] + ['svd_{}'.format(i)for i... | X=train.drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
4,754,840 | foo = train.dtypes
cat_feature_names = foo[foo == "category"]
cat_features = [train.columns.get_loc(c)for c in train.columns if c in cat_feature_names]<train_on_grid> | sc = StandardScaler()
X = sc.fit_transform(X)
test = sc.fit_transform(test ) | Titanic - Machine Learning from Disaster |
4,754,840 | N_SPLITS = 3
def run_cv_model(train, test, target, model_fn, params={}, eval_fn=None, label='model'):
kf = StratifiedKFold(n_splits=N_SPLITS, random_state=24, shuffle=True)
fold_splits = kf.split(train, target)
cv_scores = []
qwk_scores = []
pred_full_test = 0
pred_train = np.zeros(( train.shape[0], N_SPLITS))
all_co... | import keras
from keras.models import Sequential
from keras.layers import Dense | Titanic - Machine Learning from Disaster |
4,754,840 | optR = OptimizedRounder()
coefficients_ = np.mean(results['coefficients'], axis=0)
print(coefficients_)
train_predictions = [r[0] for r in results['train']]
train_predictions = optR.predict(train_predictions, coefficients_ ).astype(int)
Counter(train_predictions )<predict_on_test> | model = Sequential()
model.add(Dense(9, kernel_initializer = 'uniform', activation = 'relu', input_dim = 9))
model.add(Dense(9, kernel_initializer = 'uniform', activation = 'relu'))
model.add(Dense(5, kernel_initializer = 'uniform', activation = 'relu'))
model.add(Dense(1, kernel_initializer = 'uniform', activation = '... | Titanic - Machine Learning from Disaster |
4,754,840 | optR = OptimizedRounder()
test_predictions = [r[0] for r in results['test']]
test_predictions = optR.predict(test_predictions, coefficients_ ).astype(int)
Counter(test_predictions )<predict_on_test> | model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'] ) | Titanic - Machine Learning from Disaster |
4,754,840 | optR = OptimizedRounder()
test_predictions = [r[0] for r in results['test']]
test_predictions = optR.predict(test_predictions, coefficients_ ).astype(int)
Counter(test_predictions )<create_dataframe> | model.fit(X, y, batch_size = 32, nb_epoch = 100 ) | Titanic - Machine Learning from Disaster |
4,754,840 | pd.DataFrame(sk_cmatrix(target, train_predictions), index=list(range(5)) , columns=list(range(5)) )<compute_test_metric> | y_pred = model.predict(test)
y_final =(y_pred > 0.5 ).astype(int ).reshape(test.shape[0] ) | Titanic - Machine Learning from Disaster |
4,754,840 | <save_to_csv><EOS> | sample_sub['Survived']= y_final
sample_sub.to_csv("submit.csv", index=False)
sample_sub.head() | Titanic - Machine Learning from Disaster |
11,536,833 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
11,536,833 | submission.to_csv('submission.csv', index=False )<import_modules> | df_test = pd.read_csv(".. /input/titanic/test.csv")
df_train = pd.read_csv(".. /input/titanic/train.csv")
def concat_df(train_data, test_data):
return pd.concat([train_data, test_data], sort=True ).reset_index(drop=True)
def divide_df(all_data):
return all_data.loc[:890], all_data.loc[891:].drop(['Survived'], axis=1... | Titanic - Machine Learning from Disaster |
11,536,833 | import pandas as pd
import numpy as np
import json
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
import statsmodels.api as sm
from sklearn import metrics
import hypertools as hyp
from imblearn.over_sampling import SMOT... | total_missing_train = df_train.isnull().sum().sort_values(ascending=False)
percent_1 = df_train.isnull().sum() /df_train.isnull().count() *100
percent_2 =(round(percent_1, 1)).sort_values(ascending=False)
train_missing_data = pd.concat([total_missing_train, percent_2], axis=1, keys=['Total', '%'])
print(total_missin... | Titanic - Machine Learning from Disaster |
11,536,833 | pets = pd.read_csv('.. /input/train/train.csv')
pets2 = pd.read_csv('.. /input/test/test.csv' )<define_variables> | total_missing_test = df_test.isnull().sum().sort_values(ascending=False)
percent_3 = df_test.isnull().sum() /df_test.isnull().count() *100
percent_4 =(round(percent_3, 1)).sort_values(ascending=False)
test_missing_data = pd.concat([total_missing_test, percent_4], axis=1, keys=['Total', '%'])
print(total_missing_test... | Titanic - Machine Learning from Disaster |
11,536,833 | petID = np.asarray(pets2.PetID )<feature_engineering> | age_by_pclass_sex = df_all.groupby(['Sex', 'Pclass'] ).median() ['Age']
for pclass in range(1, 4):
for sex in ['female', 'male']:
print('Median age of Pclass {} {}s: {} '.format(pclass, sex, age_by_pclass_sex[sex][pclass].astype(int)))
df_all['Age'] = df_all.groupby(['Sex', 'Pclass'])['Age'].apply(lambda x: x.fillna(x... | Titanic - Machine Learning from Disaster |
11,536,833 | def add_pure(dataframe):
dataframe['pure_bred'] = 0
for i in range(0,(len(pets))):
try:
if dataframe.Breed2[i] == 0 or(dataframe.Breed1[i] == dataframe.Breed2[i]):
dataframe.iat[i, dataframe.columns.get_loc('pure_bred')] = 1
except:
continue
return(dataframe)
def add_sentiments(dataframe, path):
dataframe['sentiment_s... | df_all[df_all['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
11,536,833 | def image_data(dataframe, ext):
vertex_xs = []
vertex_ys = []
bounding_confidences = []
bounding_importance_fracs = []
dominant_blues = []
dominant_greens = []
dominant_reds = []
dominant_pixel_fracs = []
dominant_scores = []
label_descriptions = []
label_scores = []
nf_count = 0
nl_count = 0
for pet in dataframe.PetID... | df_all['Embarked'] = df_all['Embarked'].fillna('S')
| Titanic - Machine Learning from Disaster |
11,536,833 | def fillna(dataframe):
for i in dataframe.columns:
if i not in ['Name', 'Description', 'PetID', 'RescuerID']:
if i not in ['Age', 'Quantity', 'PhotoAmt', 'VideoAmt', 'sentiment_score', 'sentiment_magnitude', 'Fee']:
dataframe[i].fillna(dataframe[i].mode() [0], inplace = True)
else:
dataframe[i].fillna(dataframe[i].mea... | df_all[df_all['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
11,536,833 | def add_length(dataframe):
dataframe['desc_len'] = 0
for i in range(0, len(dataframe)) :
dataframe.iat[i, dataframe.columns.get_loc('desc_len')] = len(str(dataframe.Description[i]))
def sqrt_age(dataframe):
dataframe.Age = np.sqrt(dataframe.Age )<define_variables> | med_fare = df_all.groupby(['Pclass', 'Parch', 'SibSp'])['Fare'].median() [3][0][0]
df_all['Fare'] = df_all['Fare'].fillna(med_fare ) | Titanic - Machine Learning from Disaster |
11,536,833 | def find_weights(dataframe):
weights = []
count = 0
for i in range(0,5):
count = 0
weight = 0.0
for j in dataframe.AdoptionSpeed:
if j == i:
count += 1
weight = count/len(dataframe.AdoptionSpeed)
weights.append(weight)
return weights<categorify> | data1=df_train.copy()
data1['Family_size'] = data1['SibSp'] + data1['Parch'] +1
data1['Family_size'].value_counts().sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
11,536,833 | add_pure(pets)
add_pure(pets2)
add_sentiments(pets, '.. /input/train_sentiment/')
add_sentiments(pets2, '.. /input/test_sentiment/')
image_data(pets, '.. /input/train_metadata/')
image_data(pets2, '.. /input/test_metadata/')
<categorify> | df_all['Deck'] = df_all['Cabin'].apply(lambda s: s[0] if pd.notnull(s)else 'M')
df_all_decks = df_all.groupby(['Deck', 'Pclass'] ).count().drop(columns=['Survived', 'Sex', 'Age', 'SibSp', 'Parch',
'Fare', 'Embarked', 'Cabin', 'PassengerId',
'Ticket'] ).rename(columns={'Name': 'Count'})
df_all_decks | Titanic - Machine Learning from Disaster |
11,536,833 | create_cats(pets)
create_cats(pets2)
sentiment_to_float(pets)
sentiment_to_float(pets2 )<categorify> | def get_pclass_dist(df):
deck_counts = {'A': {}, 'B': {}, 'C': {}, 'D': {}, 'E': {}, 'F': {}, 'G': {}, 'M': {}, 'T': {}}
decks = df.columns.levels[0]
for deck in decks:
for pclass in range(1, 4):
try:
count = df[deck][pclass][0]
deck_counts[deck][pclass] = count
except KeyError:
deck_counts[deck][pclass] = 0
df_decks =... | Titanic - Machine Learning from Disaster |
11,536,833 | add_length(pets)
add_length(pets2)
pets = pets.drop(['Name', 'PetID', 'Description','RescuerID'], axis = 1)
pets2 = pets2.drop(['Name', 'PetID', 'Description','RescuerID'], axis = 1)
pets = pd.get_dummies(pets)
pets2 = pd.get_dummies(pets2)
<feature_engineering> | idx = df_all[df_all['Deck'] == 'T'].index
df_all.loc[idx, 'Deck'] = 'A' | Titanic - Machine Learning from Disaster |
11,536,833 | def mat_interactions(dataframe):
dataframe['mat_int_1_1'] = dataframe.MaturitySize_1 * dataframe.Type_1
dataframe['mat_int_1_2'] = dataframe.MaturitySize_2 * dataframe.Type_1
dataframe['mat_int_1_3'] = dataframe.MaturitySize_3 * dataframe.Type_1
dataframe['mat_int_1_4'] = dataframe.MaturitySize_4 * dataframe.Type_1
dat... | df_all['Deck'] = df_all['Deck'].replace(['A', 'B', 'C'], 'ABC')
df_all['Deck'] = df_all['Deck'].replace(['D', 'E'], 'DE')
df_all['Deck'] = df_all['Deck'].replace(['F', 'G'], 'FG')
df_all['Deck'].value_counts() | Titanic - Machine Learning from Disaster |
11,536,833 | def age_interactions(dataframe):
dataframe['age_int_1_1'] = dataframe.Age * dataframe.Health_1
dataframe['age_int_1_2'] = dataframe.Age * dataframe.Health_2
dataframe['age_int_1_3'] = dataframe.Age * dataframe.Health_3<define_variables> | df_all.drop(['Cabin'], inplace=True, axis=1)
df_train, df_test = divide_df(df_all)
dfs = [df_train, df_test]
for df in dfs:
print(df_test.isnull().sum())
print('-'*25 ) | Titanic - Machine Learning from Disaster |
11,536,833 | pets_vars = pets.columns.tolist()
adopt = ['AdoptionSpeed']
X=[i for i in pets_vars if i not in adopt]<categorify> | df_all = concat_df(df_train, df_test)
df_all.head() | Titanic - Machine Learning from Disaster |
11,536,833 | k=find_weights(pets)
balance_weight = {0 :int(( max(k)*len(pets)) -(min(k)*len(pets)))}<normalization> | df_all['Fare'] = pd.qcut(df_all['Fare'], 13 ) | Titanic - Machine Learning from Disaster |
11,536,833 | train_y = pets[adopt]
smote = SMOTE(sampling_strategy = 'not majority', k_neighbors = 100)
new_XX, train_y = smote.fit_resample(pets[X], train_y.values.ravel())
<choose_model_class> | df_all['Age'] = pd.qcut(df_all['Age'], 10 ) | Titanic - Machine Learning from Disaster |
11,536,833 | model = ExtraTreesClassifier()
model.fit(new_XX, train_y)
feature_list = {}
for i in range(0, len(model.feature_importances_)) :
feature_list.update({i:model.feature_importances_[i]})
feature_list = sorted(feature_list.items() , key=lambda kv: kv[1], reverse = True )<define_variables> | df_all['Ticket_Frequency'] = df_all.groupby('Ticket')['Ticket'].transform('count' ) | Titanic - Machine Learning from Disaster |
11,536,833 | j = feature_list[0:50]
new_X = []
for i in j:
new_X.append(X[i[0]])
new_X<create_dataframe> | df_all['Title'] = df_all['Name'].str.split(', ', expand=True)[1].str.split('.', expand=True)[0]
df_all['Is_Married'] = 0
df_all['Is_Married'].loc[df_all['Title'] == 'Mrs'] = 1 | Titanic - Machine Learning from Disaster |
11,536,833 | train_X = pd.DataFrame(data = new_XX, columns=X)
train_x = train_X[new_X]
test_x = pets2[new_X]<train_model> | df_train,df_test= divide_df(df_all)
dfs=[df_train,df_test] | Titanic - Machine Learning from Disaster |
11,536,833 | rf_model = RandomForestClassifier(class_weight = 'balanced', n_estimators = 1000, random_state = 42)
rf_model.fit(train_x, train_y )<choose_model_class> | mean_survival_rate = np.mean(df_train['Survived'])
train_family_survival_rate = []
train_family_survival_rate_NA = []
test_family_survival_rate = []
test_family_survival_rate_NA = []
for i in range(len(df_train)) :
if df_train['Family'][i] in family_rates:
train_family_survival_rate.append(family_rates[df_train['Famil... | Titanic - Machine Learning from Disaster |
11,536,833 | parameters = {'learning_rate':0.15, 'max_depth':6,'subsample':0.5,'objective':'multi:softmax', 'num_class':5}
model = XGBClassifier(**parameters )<count_unique_values> | for df in [df_train, df_test]:
df['Survival_Rate'] =(df['Ticket_Survival_Rate'] + df['Family_Survival_Rate'])/ 2
df['Survival_Rate_NA'] =(df['Ticket_Survival_Rate_NA'] + df['Family_Survival_Rate_NA'])/ 2 | Titanic - Machine Learning from Disaster |
11,536,833 | np.unique(train_y, return_counts = True )<train_model> | non_numeric_features = ['Embarked', 'Sex', 'Deck', 'Title', 'Family_Size_Grouped', 'Age', 'Fare']
for df in dfs:
for feature in non_numeric_features:
df[feature] = LabelEncoder().fit_transform(df[feature] ) | Titanic - Machine Learning from Disaster |
11,536,833 | model.fit(train_x,train_y, eval_metric = 'merror', verbose = True)
pred_xg = model.predict(test_x)
pred_xg = np.round(pred_xg)
pred_xg = pred_xg.astype(int )<data_type_conversions> | onehot_features = ['Pclass', 'Sex', 'Deck', 'Embarked', 'Title', 'Family_Size_Grouped']
encoded_features = []
for df in dfs:
for feature in onehot_features:
encoded_feat = OneHotEncoder().fit_transform(df[feature].values.reshape(-1, 1)).toarray()
n = df[feature].nunique()
cols = ['{}_{}'.format(feature, n)for n in rang... | Titanic - Machine Learning from Disaster |
11,536,833 | df = {'PetID': petID, 'AdoptionSpeed': pred_xg}
df = pd.DataFrame(df)
df.AdoptionSpeed = df.AdoptionSpeed.astype('int32' )<count_values> | df_all = concat_df(df_train, df_test)
drop_cols = ['Deck', 'Embarked', 'Family', 'Family_Size', 'Family_Size_Grouped', 'Survived',
'Name', 'Parch', 'PassengerId', 'Pclass', 'Sex', 'SibSp', 'Ticket', 'Title',
'Ticket_Survival_Rate', 'Family_Survival_Rate', 'Ticket_Survival_Rate_NA', 'Family_Survival_Rate_NA']
df_all.dr... | Titanic - Machine Learning from Disaster |
11,536,833 | df.AdoptionSpeed.value_counts(dropna= False )<save_to_csv> | X = df_train.drop(columns=drop_cols ) | Titanic - Machine Learning from Disaster |
11,536,833 | df.to_csv('submission.csv', index = False )<define_variables> | X_train = StandardScaler().fit_transform(X)
Y_train = df_train['Survived'].values
X_test = StandardScaler().fit_transform(df_test.drop(columns=drop_cols))
print('X_train shape: {}'.format(X_train.shape))
print('Y_train shape: {}'.format(Y_train.shape))
print('X_test shape: {}'.format(X_test.shape)) | Titanic - Machine Learning from Disaster |
11,536,833 | BALANCING = False
MODEL_USE = 3
<compute_test_metric> | sgd = linear_model.SGDClassifier(max_iter=5, tol=None)
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
sgd.score(X_train, Y_train)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | def kappa(y_true, y_pred):
return cohen_kappa_score(y_true, y_pred, weights='quadratic' )<load_from_csv> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | breeds = pd.read_csv('.. /input/breed_labels.csv')
colors = pd.read_csv('.. /input/color_labels.csv')
train = pd.read_csv('.. /input/train/train.csv')
test = pd.read_csv('.. /input/test/test.csv')
sub = pd.read_csv('.. /input/test/sample_submission.csv')
states = pd.read_csv('.. /input/state_labels.csv')
<set_opti... | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | %matplotlib inline
plt.style.use('ggplot' )<count_values> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | train['AdoptionSpeed'].value_counts()<count_values> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | states_to_ID = states.set_index('StateName')
state_value_counts = train['State'].value_counts(ascending=False)
state_distribution = states_to_ID['StateID'].map(state_value_counts ).sort_values(ascending=False)
state_distribution
<feature_engineering> | perceptron = Perceptron(max_iter=5)
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | train['State'] = train['State'].replace(41401, 41326 )<feature_engineering> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | train['Description'] = train['Description'].fillna('')
test['Description'] = test['Description'].fillna('')
train['desc_len'] = train['Description'].apply(lambda x: len(x))<prepare_x_and_y> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
11,536,833 | target_train = train['AdoptionSpeed']
cleaned_train = train.drop(columns=['Name', 'RescuerID', 'Description', 'PetID', 'AdoptionSpeed'])
test_pet_ID = test['PetID']
test_X = test.drop(columns=['Name', 'RescuerID', 'Description', 'PetID'])
<count_missing_values> | rf = RandomForestClassifier(n_estimators=100,oob_score=True)
scores = cross_val_score(rf, X_train, Y_train, cv=10, scoring = "accuracy")
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std() ) | Titanic - Machine Learning from Disaster |
11,536,833 | target_train.isnull().values.any()<count_missing_values> | rf.fit(X_train, Y_train)
Y_prediction = rf.predict(X_test)
rf.score(X_train, Y_train)
acc_random_forest = round(rf.score(X_train, Y_train)* 100, 2)
print(round(acc_random_forest,2,), "%" ) | Titanic - Machine Learning from Disaster |
11,536,833 | test_X.isnull().values.any()<define_variables> | random_forest = RandomForestClassifier(n_estimators=100, oob_score = True)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
print(round(acc_random_forest,2,), "%" ) | Titanic - Machine Learning from Disaster |
11,536,833 | seed = 42<choose_model_class> | print("oob score:", round(random_forest.oob_score_, 4)*100, "%" ) | Titanic - Machine Learning from Disaster |
11,536,833 | class EnsembleModel:
def __init__(self,balancing=False):
self.balance_ratio = 5 if balancing else 1
self.rf_model = RandomForestClassifier()
self.lgb_model = lgb.LGBMClassifier()
self.rand_forest_params= {
'bootstrap': [True, False],
'max_depth': [30,50],
'min_samples_leaf': [20, 30],
'min_samples_split': [10,15],
'n_e... | print("oob score:", round(rf.oob_score_, 4)*100, "%" ) | 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.