kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,108,910 | print('
print('Intermediate results...')
final_df = []
for current_strategy in list(RESULTS.iloc[:,2:]):
auc_score = metrics.roc_auc_score(RESULTS[TARGET], RESULTS[current_strategy])
final_df.append([current_strategy, auc_score])
final_df = pd.DataFrame(final_df, columns=['Stategy', 'Result'])
final_df.sort_values(... | X = X.drop(['Cabin'],axis = 1)
X | Titanic - Machine Learning from Disaster |
11,108,910 | test_df['DT_W'] = test_df['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
RESULTS['DT_W'] =(test_df['DT_W'].dt.year-2017)*52 + test_df['DT_W'].dt.weekofyear
for curent_time_block in range(RESULTS['DT_W'].min() , RESULTS['DT_W'].max() +1):
print('
print('Time Block:', curent_time_block)
... | X_temp = X
Sex_Embarked = {"Sex":{"male": 1.,"female": 0.},
"Embarked":{"S": 0.,"C": 1.,"Q": 2.},
"Deck":{"A": 1.,"B": 2.,"C": 3.,
"D": 4.,"E": 5.,"F": 6.,
"G": 7.,"T": 8.}}
X_temp = X_temp.replace(Sex_Embarked, inplace=False)
X_temp = pd.DataFrame(CT.fit_transform(X_temp),
columns=[ 'Ticket', 'Pclass', 'Sex', 'Age', ... | Titanic - Machine Learning from Disaster |
11,108,910 | print('
print('Small bonus')
test_df = pd.read_pickle('.. /input/ieee-data-minification/test_transaction.pkl')
kernel_with_identity = pd.read_csv('.. /input/ieee-gb-2-make-amount-useful-again/submission.csv')
kernel_no_identity = pd.read_csv('.. /input/ieee-experimental/submission.csv')
test_df = test_df[['Transact... | X_temp = X_temp.drop(['Deck'],axis = 1)
| Titanic - Machine Learning from Disaster |
11,108,910 | import numpy as np
import pandas as pd
from shutil import copyfile
import xgboost as xgb<prepare_x_and_y> | X_temp['family_Size'] = X_temp.Parch + X_temp.SibSp
X_temp = X_temp.drop(['Parch','SibSp'],axis = 1 ) | Titanic - Machine Learning from Disaster |
11,108,910 | X_train, y_train, X_test, submission = a1w.quick_wrangle()<save_to_csv> | mean = ['{0}, {1:.0f}'.format(pclass,np.nanmean(X.where(X.Pclass == pclass,inplace = False ).Fare)) for pclass in X.Pclass.unique() ]
print(mean ) | Titanic - Machine Learning from Disaster |
11,108,910 | for n in range(100, 501, 200):
clf = xgb.XGBClassifier(n_estimators=n, n_jobs=4, max_depth=10, learning_rate=0.03, subsample=0.9, colsample_bytree=0.9, missing=-999)
clf.fit(X_train, y_train)
submission['isFraud'] = clf.predict_proba(X_test)[:, 1]
submission.to_csv('XGBoost' + str(n)+ '.csv' )<set_options> | X_temp = X_temp.drop(['Ticket'],axis = 1 ) | Titanic - Machine Learning from Disaster |
11,108,910 | warnings.filterwarnings("ignore")
%matplotlib inline<feature_engineering> | X_train, X_valid, Y_train, Y_valid = train_test_split(X_temp,Y,test_size = 0.25,random_state = 1)
logistic = LogisticRegression(C=1, penalty="l1", solver='liblinear', random_state=7 ).fit(X_train,Y_train)
model = SelectFromModel(logistic, prefit=True)
X_new = model.transform(X_train)
X_new | Titanic - Machine Learning from Disaster |
11,108,910 | LABELS = ["isFraud"]
all_files = glob.glob(".. /input/lgmodels/*.csv")
scores = np.zeros(len(all_files))
for i in range(len(all_files)) :
scores[i] = float('.'+all_files[i].split(".")[3])
print(i,scores[i],all_files[i] )<sort_values> | selected_features = pd.DataFrame(model.inverse_transform(X_new),
index=X_train.index,
columns=X_train.columns)
selected_columns = selected_features.columns[selected_features.var() != 0]
selected_columns | Titanic - Machine Learning from Disaster |
11,108,910 | top = scores.argsort() [::-1]
for i, f in enumerate(top):
print(i,scores[f],all_files[f] )<load_from_csv> | cm2 = confusion_matrix(Y_valid,logistic.predict(X_valid))
log_acc = accuracy_score(Y_valid,logistic.predict(X_valid))
print(log_acc,'
',cm2 ) | Titanic - Machine Learning from Disaster |
11,108,910 | outs = [pd.read_csv(all_files[f], index_col=0)for f in top]
concat_sub = pd.concat(outs, axis=1)
cols = list(map(lambda x: "m" + str(x), range(len(concat_sub.columns))))
concat_sub.columns = cols<feature_engineering> | sc = MinMaxScaler()
scaled_X_temp = pd.DataFrame(sc.fit_transform(X_temp),columns = X_temp.columns)
scaled_X_temp | Titanic - Machine Learning from Disaster |
11,108,910 | rank = np.tril(corr.values,-1)
rank[rank<0.92] = 1
m =(rank>0 ).sum() -(rank>0.97 ).sum()
m_gmean, s = 0, 0
for n in range(m):
mx = np.unravel_index(rank.argmin() , rank.shape)
w =(m-n)/m
m_gmean += w*(np.log(concat_sub.iloc[:,mx[0]])+np.log(concat_sub.iloc[:,mx[1]])) /2
s += w
rank[mx] = 1
m_gmean = np.exp(m_gmean/s... | X_train, X_valid, Y_train, Y_valid = train_test_split(scaled_X_temp,Y,test_size = 0.25,random_state = 1)
knn_Classifier = KNeighborsClassifier(n_neighbors = 7, metric = 'minkowski', p=2)
knn_Classifier.fit(X_train,Y_train)
Y_pred_knn = knn_Classifier.predict(X_valid)
cm2 = confusion_matrix(Y_valid,Y_pred_knn)
knn_... | Titanic - Machine Learning from Disaster |
11,108,910 | concat_sub['isFraud'] = m_gmean
concat_sub[['isFraud']].to_csv('stack_gmean.csv' )<set_options> | cv_knn_score = cross_val_score(knn_Classifier,scaled_X_temp,Y,cv = 10,scoring='accuracy' ).mean()
print(cv_knn_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | warnings.simplefilter('ignore')
sns.set()
%matplotlib inline<load_from_csv> | svm_Classifier = SVC(kernel = 'rbf', random_state = 0)
cv_svm_score = cross_val_score(svm_Classifier,scaled_X_temp,Y,cv = 10,scoring='accuracy' ).mean()
print(cv_svm_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | %%time
warnings.simplefilter('ignore')
files = ['.. /input/ieee-fraud-detection/test_identity.csv',
'.. /input/ieee-fraud-detection/test_transaction.csv',
'.. /input/ieee-fraud-detection/train_identity.csv',
'.. /input/ieee-fraud-detection/train_transaction.csv',
'.. /input/ieee-fraud-detection/sample_submission.csv']... | nb_Classifier = GaussianNB()
cv_nb_score = cross_val_score(nb_Classifier,scaled_X_temp,Y,cv = 10,scoring='accuracy' ).mean()
print(cv_nb_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | train_transaction.loc[train_transaction.card3.isin(train_transaction.card3.value_counts() [train_transaction.card3.value_counts() < 200].index), 'card3'] = "Others"
train_transaction.loc[train_transaction.card5.isin(train_transaction.card5.value_counts() [train_transaction.card5.value_counts() < 300].index), 'card5'] =... | dt_Classifier = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
cv_dt_score = cross_val_score(dt_Classifier,scaled_X_temp,Y,cv = 10,scoring='accuracy' ).mean()
print(cv_dt_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | train_transaction.loc[train_transaction.addr1.isin(train_transaction.addr1.value_counts() [train_transaction.addr1.value_counts() <= 5000 ].index), 'addr1'] = "Others"
train_transaction.loc[train_transaction.addr2.isin(train_transaction.addr2.value_counts() [train_transaction.addr2.value_counts() <= 50 ].index), 'addr2... | rf_Classifier = RandomForestClassifier(n_estimators=10, max_depth=None, random_state=0)
cv_rf_score = cross_val_score(rf_Classifier,scaled_X_temp, Y,cv = 8,scoring='accuracy' ).mean()
print(cv_rf_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | train_transaction.loc[train_transaction['P_emaildomain'].isin(['gmail.com', 'gmail']),'P_emaildomain'] = 'Google'
train_transaction.loc[train_transaction['P_emaildomain'].isin(['yahoo.com', 'yahoo.com.mx', 'yahoo.co.uk',
'yahoo.co.jp', 'yahoo.de', 'yahoo.fr',
'yahoo.es']), 'P_emaildomain'] = 'Yahoo Mail'
train_transact... | XGB_Classifier = XGBClassifier(n_estimators = 1000,learning_rate = 0.01)
cv_XGB_score = cross_val_score(XGB_Classifier,scaled_X_temp, Y,cv = 18,scoring='accuracy' ).mean()
print(cv_XGB_score ) | Titanic - Machine Learning from Disaster |
11,108,910 | ploting_cnt_amt(train_transaction, 'R_emaildomain' )<count_values> | eclf = VotingClassifier(
estimators=[('xgb',XGB_Classifier),('lr', logistic),('rf', rf_Classifier),('dt', dt_Classifier),('svm',svm_Classifier)],
voting='hard'
)
for clf, label in zip([XGB_Classifier, logistic, rf_Classifier, dt_Classifier,svm_Classifier, eclf],
['XGBooster Classifier', 'Logistic Regression', 'Rando... | Titanic - Machine Learning from Disaster |
11,108,910 | train_transaction.loc[train_transaction.C1.isin(train_transaction.C1\
.value_counts() [train_transaction.C1.value_counts() <= 400 ]\
.index), 'C1'] = "Others"<count_values> | params = {'lr__C': [1.0, 100.0], 'rf__n_estimators': [20, 200],
'xgb__n_estimators': [500,2000],'xgb__learning_rate': [0.01,0.1]}
rands = RandomizedSearchCV(estimator=eclf, param_distributions=params, cv=5)
rands = rands.fit(scaled_X_temp, Y)
Y_pred_rands = rands.predict(X_valid)
rands_cm = confusion_matrix(Y_valid,... | Titanic - Machine Learning from Disaster |
11,108,910 | train_transaction.loc[train_transaction.C2.isin(train_transaction.C2\
.value_counts() [train_transaction.C2.value_counts() <= 350 ]\
.index), 'C2'] = "Others"<concatenate> | test_set = pd.read_csv("/kaggle/input/titanic/test.csv")
test_set | Titanic - Machine Learning from Disaster |
11,108,910 | ploting_cnt_amt(train_transaction, 'C2' )<feature_engineering> | test = test_set.copy()
test['family_Size'] = test['SibSp'] + test['Parch']
test = test.drop(['Name','SibSp','Parch','Cabin','Ticket'],axis = 1)
encoded_features = {'Sex' : {'male': 1,'female': 0 },
'Embarked':{'S': 0.,'C': 1.,'Q': 2.}}
test.replace(encoded_features, inplace = True)
test | Titanic - Machine Learning from Disaster |
11,108,910 | START_DATE = '2017-12-01'
startdate = datetime.datetime.strptime(START_DATE, "%Y-%m-%d")
train_transaction["Date"] = train_transaction['TransactionDT'].apply(lambda x:(startdate + datetime.timedelta(seconds=x)))
train_transaction['_Weekdays'] = train_transaction['Date'].dt.dayofweek
train_transaction['_Hours'] = trai... | test.Age = imputer.fit_transform(test.Age.values.reshape(-1,1))
notnull_samples = test[test.columns].dropna()
X_set = notnull_samples.loc[:,['Pclass', 'Sex', 'Age', 'Embarked','family_Size']]
Y_set = notnull_samples.loc[:,['Fare']]
linreg = LinearRegression()
linreg.fit(X_set, Y_set)
fare_predict = linreg.predict(test... | Titanic - Machine Learning from Disaster |
11,108,910 | color_op = ['
'
'
dates_temp = train_transaction.groupby(train_transaction.Date.dt.date)['TransactionAmt'].count().reset_index()
trace = go.Scatter(x=dates_temp['Date'], y=dates_temp.TransactionAmt,
opacity = 0.8, line = dict(color = color_op[7]), name= 'Total Transactions')
dates_temp_sum = train_transaction.groupby(... | scaled_test = pd.concat([test.loc[:,['PassengerId']],pd.DataFrame(sc.fit_transform(test.drop(['PassengerId'],axis = 1)) ,
columns = test.drop(['PassengerId'],axis = 1 ).columns)],axis = 1)
| Titanic - Machine Learning from Disaster |
11,108,910 | color_op = ['
'
'
tmp_amt = train_transaction.groupby([train_transaction.Date.dt.date, 'isFraud'])['TransactionAmt'].sum().reset_index()
tmp_trans = train_transaction.groupby([train_transaction.Date.dt.date, 'isFraud'])['TransactionAmt'].count().reset_index()
tmp_trans_fraud = tmp_trans[tmp_trans['isFraud'] == 1]
tmp_a... | eclf.fit(scaled_X_temp,Y)
Survived = pd.DataFrame(eclf.predict(scaled_test.drop(['PassengerId'],axis = 1)) ,columns = ['Survived'])
Survived | Titanic - Machine Learning from Disaster |
11,108,910 | def seed_everything(seed=0):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed )<find_best_model_class> | submission = pd.concat([scaled_test.loc[:,'PassengerId'],Survived],axis =1)
submission | Titanic - Machine Learning from Disaster |
11,108,910 | def make_predictions(tr_df, tt_df, features_columns, target, lgb_params, NFOLDS=6):
folds = GroupKFold(n_splits=NFOLDS)
X,y = tr_df[features_columns], tr_df[target]
P,P_y = tt_df[features_columns], tt_df[target]
split_groups = tr_df['DT_M']
tt_df = tt_df[['TransactionID',target]]
predictions = np.zeros(len(tt_df))
oof... | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,108,910 | <feature_engineering><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
4,025,645 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
4,025,645 | for df in [train_df, test_df]:
df['DT'] = df['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
df['DT_M'] =(df['DT'].dt.year-2017)*12 + df['DT'].dt.month
df['DT_W'] =(df['DT'].dt.year-2017)*52 + df['DT'].dt.weekofyear
df['DT_D'] =(df['DT'].dt.year-2017)*365 + df['DT'].dt.dayofyear
df['DT_... | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['card1']
for col in i_cols:
valid_card = pd.concat([train_df[[col]], test_df[[col]]])
valid_card = valid_card[col].value_counts()
valid_card = valid_card[valid_card>2]
valid_card = list(valid_card.index)
train_df[col] = np.where(train_df[col].isin(test_df[col]), train_df[col], np.nan)
test_df[col] = np.whe... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['M1','M2','M3','M5','M6','M7','M8','M9']
for df in [train_df, test_df]:
df['M_sum'] = df[i_cols].sum(axis=1 ).astype(np.int8)
df['M_na'] = df[i_cols].isna().sum(axis=1 ).astype(np.int8 )<data_type_conversions> | train_df.isna().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | train_df['uid'] = train_df['card1'].astype(str)+'_'+train_df['card2'].astype(str)
test_df['uid'] = test_df['card1'].astype(str)+'_'+test_df['card2'].astype(str)
train_df['uid2'] = train_df['uid'].astype(str)+'_'+train_df['card3'].astype(str)+'_'+train_df['card5'].astype(str)
test_df['uid2'] = test_df['uid'].astype(s... | test_df.isna().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | p = 'P_emaildomain'
r = 'R_emaildomain'
uknown = 'email_not_provided'
for df in [train_df, test_df]:
df[p] = df[p].fillna(uknown)
df[r] = df[r].fillna(uknown)
df['email_check'] = np.where(( df[p]==df[r])&(df[p]!=uknown),1,0)
df[p+'_prefix'] = df[p].apply(lambda x: x.split('.')[0])
df[r+'_prefix'] = df[r].apply(lamb... | train_df['source'] = 'train'
test_df['source'] = 'test' | Titanic - Machine Learning from Disaster |
4,025,645 | for df in [train_identity, test_identity]:
df['DeviceInfo'] = df['DeviceInfo'].fillna('unknown_device' ).str.lower()
df['DeviceInfo_device'] = df['DeviceInfo'].apply(lambda x: ''.join([i for i in x if i.isalpha() ]))
df['DeviceInfo_version'] = df['DeviceInfo'].apply(lambda x: ''.join([i for i in x if i.isnumeric() ]))
... | dataset = pd.concat([train_df, test_df], ignore_index=True ) | Titanic - Machine Learning from Disaster |
4,025,645 | temp_df = train_df[['TransactionID']]
temp_df = temp_df.merge(train_identity, on=['TransactionID'], how='left')
del temp_df['TransactionID']
train_df = pd.concat([train_df,temp_df], axis=1)
temp_df = test_df[['TransactionID']]
temp_df = temp_df.merge(test_identity, on=['TransactionID'], how='left')
del temp_df['Tran... | dataset.isnull().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['card1','card2','card3','card5',
'C1','C2','C3','C4','C5','C6','C7','C8','C9','C10','C11','C12','C13','C14',
'D1','D2','D3','D4','D5','D6','D7','D8',
'addr1','addr2',
'dist1','dist2',
'P_emaildomain', 'R_emaildomain',
'DeviceInfo','DeviceInfo_device','DeviceInfo_version',
'id_30','id_30_device','id_30_version... | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | for col in ['ProductCD','M4']:
temp_dict = train_df.groupby([col])[TARGET].agg(['mean'] ).reset_index().rename(
columns={'mean': col+'_target_mean'})
temp_dict.index = temp_dict[col].values
temp_dict = temp_dict[col+'_target_mean'].to_dict()
train_df[col] = train_df[col].map(temp_dict)
test_df[col] = test_df[col].ma... | train_df['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
4,025,645 | for col in list(train_df):
if train_df[col].dtype=='O':
print(col)
train_df[col] = train_df[col].fillna('unseen_before_label')
test_df[col] = test_df[col].fillna('unseen_before_label')
train_df[col] = train_df[col].astype(str)
test_df[col] = test_df[col].astype(str)
le = LabelEncoder()
le.fit(list(train_df[col])+l... | train_df.Parch.value_counts() | Titanic - Machine Learning from Disaster |
4,025,645 | rm_cols = [
'TransactionID','TransactionDT',
TARGET,
'uid','uid2','uid3',
'bank_type',
'DT','DT_M','DT_W','DT_D',
'DT_hour','DT_day_week','DT_day',
'DT_D_total','DT_W_total','DT_M_total',
'id_30','id_31','id_33',
]<init_hyperparams> | train_df.SibSp.value_counts() /891*100 | Titanic - Machine Learning from Disaster |
4,025,645 | lgb_params = {
'objective':'binary',
'boosting_type':'gbdt',
'metric':'auc',
'n_jobs':-1,
'learning_rate':0.01,
'num_leaves': 2**8,
'max_depth':-1,
'tree_learner':'serial',
'colsample_bytree': 0.85,
'subsample_freq':1,
'subsample':0.85,
'n_estimators':2**9,
'max_bin':255,
'verbose':-1,
'seed': SEED,
'early_stopping_rou... | train_df.Pclass.value_counts() /train_df.shape[0]*100 | Titanic - Machine Learning from Disaster |
4,025,645 | if LOCAL_TEST:
lgb_params['learning_rate'] = 0.01
lgb_params['n_estimators'] = 20000
lgb_params['early_stopping_rounds'] = 100
test_predictions = make_predictions(train_df, test_df, features_columns, TARGET, lgb_params)
print(metrics.roc_auc_score(test_predictions[TARGET], test_predictions['prediction']))
else:
lgb_pa... | grid_pivot1 = train_df.pivot_table(columns='Survived', values='Age', aggfunc='mean' ) | Titanic - Machine Learning from Disaster |
4,025,645 | if not LOCAL_TEST:
test_predictions['isFraud'] = test_predictions['prediction']
test_predictions[['TransactionID','isFraud']].to_csv('submission.csv', index=False )<set_options> | Titanic - Machine Learning from Disaster | |
4,025,645 | warnings.filterwarnings('ignore' )<define_variables> | grid_pivot2 = train_df.pivot_table(index='Sex', columns='Survived', values='Age', aggfunc='mean')
grid_pivot2 | Titanic - Machine Learning from Disaster |
4,025,645 | def seed_everything(seed=0):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed )<predict_on_test> | grid_pivot3 = train_df.pivot_table(index='Pclass',columns='Survived', values='Age' ) | Titanic - Machine Learning from Disaster |
4,025,645 | def make_predictions(tr_df, tt_df, features_columns, target, lgb_params, NFOLDS=2):
folds = KFold(n_splits=NFOLDS, shuffle=True, random_state=SEED)
X,y = tr_df[features_columns], tr_df[target]
P,P_y = tt_df[features_columns], tt_df[target]
tt_df = tt_df[['TransactionID',target]]
predictions = np.zeros(len(tt_df))
for ... | train_df.pivot_table(index=['Embarked','Pclass'], columns='Sex', values='Survived' ) | Titanic - Machine Learning from Disaster |
4,025,645 | SEED = 42
seed_everything(SEED)
LOCAL_TEST = False
TARGET = 'isFraud'
START_DATE = datetime.datetime.strptime('2017-11-30', '%Y-%m-%d' )<feature_engineering> | def extract_titles(name):
tit = re.findall('([A-Za-z]+)\.', name)
return tit[0] | Titanic - Machine Learning from Disaster |
4,025,645 | print('Load Data')
train_df = pd.read_pickle('.. /input/ieee-data-minification/train_transaction.pkl')
if LOCAL_TEST:
train_df['DT_M'] = train_df['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
train_df['DT_M'] =(train_df['DT_M'].dt.year-2017)*12 + train_df['DT_M'].dt.month
test_df = ... | dataset['Title'] = dataset['Name'].apply(lambda x: extract_titles(x)) | Titanic - Machine Learning from Disaster |
4,025,645 | for df in [train_df, test_df]:
df['DT'] = df['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
df['DT_M'] =(df['DT'].dt.year-2017)*12 + df['DT'].dt.month
df['DT_W'] =(df['DT'].dt.year-2017)*52 + df['DT'].dt.weekofyear
df['DT_D'] =(df['DT'].dt.year-2017)*365 + df['DT'].dt.dayofyear
df['DT_... | dataset[dataset['source'] == 'train'].isnull().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['card1']
for col in i_cols:
valid_card = pd.concat([train_df[[col]], test_df[[col]]])
valid_card = valid_card[col].value_counts()
valid_card = valid_card[valid_card>2]
valid_card = list(valid_card.index)
train_df[col] = np.where(train_df[col].isin(test_df[col]), train_df[col], np.nan)
test_df[col] = np.whe... | dataset[dataset['source'] == 'test'].isnull().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['M1','M2','M3','M5','M6','M7','M8','M9']
for df in [train_df, test_df]:
df['M_sum'] = df[i_cols].sum(axis=1 ).astype(np.int8)
df['M_na'] = df[i_cols].isna().sum(axis=1 ).astype(np.int8 )<categorify> | dataset['Title'] = dataset['Title'].replace(['Don', 'Rev', 'Dr','Major', 'Lady', 'Sir','Col', 'Capt', 'Countess',
'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace(['Ms', 'Mlle'], 'Miss')
dataset['Title'] = dataset['Title'].replace('Mme','Mrs' ) | Titanic - Machine Learning from Disaster |
4,025,645 | for col in ['ProductCD','M4']:
temp_dict = train_df.groupby([col])[TARGET].agg(['mean'] ).reset_index().rename(
columns={'mean': col+'_target_mean'})
temp_dict.index = temp_dict[col].values
temp_dict = temp_dict[col+'_target_mean'].to_dict()
train_df[col+'_target_mean'] = train_df[col].map(temp_dict)
test_df[col+'_t... | dataset[dataset['source'] == 'train'].Title.value_counts() | Titanic - Machine Learning from Disaster |
4,025,645 | train_df['uid'] = train_df['card1'].astype(str)+'_'+train_df['card2'].astype(str)
test_df['uid'] = test_df['card1'].astype(str)+'_'+test_df['card2'].astype(str)
train_df['uid2'] = train_df['uid'].astype(str)+'_'+train_df['card3'].astype(str)+'_'+train_df['card4'].astype(str)
test_df['uid2'] = test_df['uid'].astype(s... | Titanic - Machine Learning from Disaster | |
4,025,645 | p = 'P_emaildomain'
r = 'R_emaildomain'
uknown = 'email_not_provided'
for df in [train_df, test_df]:
df[p] = df[p].fillna(uknown)
df[r] = df[r].fillna(uknown)
df['email_check'] = np.where(( df[p]==df[r])&(df[p]!=uknown),1,0)
df[p+'_prefix'] = df[p].apply(lambda x: x.split('.')[0])
df[r+'_prefix'] = df[r].apply(lamb... | sex_dummy = pd.get_dummies(dataset['Sex'] ) | Titanic - Machine Learning from Disaster |
4,025,645 | for df in [train_identity, test_identity]:
df['DeviceInfo'] = df['DeviceInfo'].fillna('unknown_device' ).str.lower()
df['DeviceInfo_device'] = df['DeviceInfo'].apply(lambda x: ''.join([i for i in x if i.isalpha() ]))
df['DeviceInfo_version'] = df['DeviceInfo'].apply(lambda x: ''.join([i for i in x if i.isnumeric() ]))
... | dataset = dataset.join(sex_dummy ) | Titanic - Machine Learning from Disaster |
4,025,645 | temp_df = train_df[['TransactionID']]
temp_df = temp_df.merge(train_identity, on=['TransactionID'], how='left')
del temp_df['TransactionID']
train_df = pd.concat([train_df,temp_df], axis=1)
temp_df = test_df[['TransactionID']]
temp_df = temp_df.merge(test_identity, on=['TransactionID'], how='left')
del temp_df['Tran... | grid_pivot = dataset[dataset['source'] == 'train'].pivot_table(index='Pclass',columns='Sex', values='Age', aggfunc='median' ) | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['card1','card2','card3','card5',
'C1','C2','C3','C4','C5','C6','C7','C8','C9','C10','C11','C12','C13','C14',
'D1','D2','D3','D4','D5','D6','D7','D8',
'addr1','addr2',
'dist1','dist2',
'P_emaildomain', 'R_emaildomain',
'DeviceInfo','DeviceInfo_device','DeviceInfo_version',
'id_30','id_30_device','id_30_version... | guess_ages = np.zeros(( 2,3))
guess_ages
for i in range(0, 2):
for j in range(0, 3):
guess_df = dataset[(dataset['Sex'] == i)& \
(dataset['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_df.median()
for i in range(0, 2):
for j in range(0, 3):
dataset.loc[(dataset.Age.isnull())&(dataset.Sex == i)&(dataset.Pclass ==... | Titanic - Machine Learning from Disaster |
4,025,645 | for col in list(train_df):
if train_df[col].dtype=='O':
print(col)
train_df[col] = train_df[col].fillna('unseen_before_label')
test_df[col] = test_df[col].fillna('unseen_before_label')
train_df[col] = train_df[col].astype(str)
test_df[col] = test_df[col].astype(str)
le = LabelEncoder()
le.fit(list(train_df[col])+l... | dataset['AgeBand'] = pd.cut(dataset['Age'], 5 ) | Titanic - Machine Learning from Disaster |
4,025,645 | lgb_params = {
'objective':'binary',
'boosting_type':'gbdt',
'metric':'auc',
'n_jobs':-1,
'learning_rate':0.01,
'num_leaves': 2**8,
'max_depth':-1,
'tree_learner':'serial',
'colsample_bytree': 0.7,
'subsample_freq':1,
'subsample':0.7,
'n_estimators':800,
'max_bin':255,
'verbose':-1,
'seed': SEED,
'early_stopping_rounds... | dataset.AgeBand.value_counts() | Titanic - Machine Learning from Disaster |
4,025,645 | if LOCAL_TEST:
lgb_params['learning_rate'] = 0.01
lgb_params['n_estimators'] = 20000
lgb_params['early_stopping_rounds'] = 100
test_predictions = make_predictions(train_df, test_df, features_columns, TARGET, lgb_params)
print(metrics.roc_auc_score(test_predictions[TARGET], test_predictions['prediction']))
else:
lgb_pa... | dataset['AgeBand'] = dataset['AgeBand'].astype(str ) | Titanic - Machine Learning from Disaster |
4,025,645 | if not LOCAL_TEST:
test_predictions['isFraud'] = test_predictions['prediction']
test_predictions[['TransactionID','isFraud']].to_csv('submission.csv', index=False )<set_options> | Titanic - Machine Learning from Disaster | |
4,025,645 | warnings.filterwarnings('ignore' )<define_variables> | def ageclass(x):
if x <= 16:
return 0
elif x > 16 and x <= 32:
return 1
elif x > 32 and x <= 48:
return 2
elif x > 48 and x <= 64:
return 3
else:
x > 64
return 4 | Titanic - Machine Learning from Disaster |
4,025,645 | def seed_everything(seed=0):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
<define_variables> | dataset['AgeClass'] = dataset['Age'].apply(ageclass ) | Titanic - Machine Learning from Disaster |
4,025,645 | SEED = 42
seed_everything(SEED)
LOCAL_TEST = False
TARGET = 'isFraud'<load_pretrained> | dataset['Family_Size'] = dataset['Parch'] + dataset['SibSp'] + 1 | Titanic - Machine Learning from Disaster |
4,025,645 | print('Load Data')
train_df = pd.read_pickle('.. /input/ieee-data-minification/train_transaction.pkl')
if LOCAL_TEST:
test_df = train_df.iloc[-100000:,].reset_index(drop=True)
train_df = train_df.iloc[:400000,].reset_index(drop=True)
train_identity = pd.read_pickle('.. /input/ieee-data-minification/train_identity.p... | dataset.pivot_table(index='Family_Size', values='Survived' ).sort_values(by='Survived',ascending=False ) | Titanic - Machine Learning from Disaster |
4,025,645 | valid_card = train_df['card1'].value_counts()
valid_card = valid_card[valid_card>10]
valid_card = list(valid_card.index)
train_df['card1'] = np.where(train_df['card1'].isin(valid_card), train_df['card1'], np.nan)
test_df['card1'] = np.where(test_df['card1'].isin(valid_card), test_df['card1'], np.nan )<count_values> | def isalone(x):
if x == 1:
return 1
else:
return 0 | Titanic - Machine Learning from Disaster |
4,025,645 | i_cols = ['card1','card2','card3','card5',
'C1','C2','C3','C4','C5','C6','C7','C8','C9','C10','C11','C12','C13','C14',
'D1','D2','D3','D4','D5','D6','D7','D8','D9',
'addr1','addr2',
'dist1','dist2',
'P_emaildomain', 'R_emaildomain'
]
for col in i_cols:
temp_df = pd.concat([train_df[[col]], test_df[[col]]])
fq_encode =... | dataset['IsAlone'] = dataset['Family_Size'].apply(isalone ) | Titanic - Machine Learning from Disaster |
4,025,645 | for col in ['ProductCD','M4']:
temp_dict = train_df.groupby([col])[TARGET].agg(['mean'] ).reset_index().rename(
columns={'mean': col+'_target_mean'})
temp_dict.index = temp_dict[col].values
temp_dict = temp_dict[col+'_target_mean'].to_dict()
train_df[col+'_target_mean'] = train_df[col].map(temp_dict)
test_df[col+'_t... | dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace=True ) | Titanic - Machine Learning from Disaster |
4,025,645 | for col in list(train_df):
if train_df[col].dtype=='O':
print(col)
train_df[col] = train_df[col].fillna('unseen_before_label')
test_df[col] = test_df[col].fillna('unseen_before_label')
train_df[col] = train_df[col].astype(str)
test_df[col] = test_df[col].astype(str)
le = LabelEncoder()
le.fit(list(train_df[col])+l... | dataset.isnull().sum() | Titanic - Machine Learning from Disaster |
4,025,645 | lgb_params = {
'objective':'binary',
'boosting_type':'gbdt',
'metric':'auc',
'n_jobs':-1,
'learning_rate':0.01,
'num_leaves': 2**8,
'max_depth':-1,
'tree_learner':'serial',
'colsample_bytree': 0.7,
'subsample_freq':1,
'subsample':1,
'n_estimators':800,
'max_bin':255,
'verbose':-1,
'seed': SEED,
'early_stopping_rounds':... | embarked_dummy = pd.get_dummies(dataset['Embarked'] ) | Titanic - Machine Learning from Disaster |
4,025,645 | def make_predictions(tr_df, tt_df, features_columns, target, lgb_params, NFOLDS=2):
folds = KFold(n_splits=NFOLDS, shuffle=True, random_state=SEED)
X,y = tr_df[features_columns], tr_df[target]
P,P_y = tt_df[features_columns], tt_df[target]
tt_df = tt_df[['TransactionID',target]]
predictions = np.zeros(len(tt_df))
for ... | dataset = dataset.join(embarked_dummy ) | Titanic - Machine Learning from Disaster |
4,025,645 | if LOCAL_TEST:
test_predictions = make_predictions(train_df, test_df, features_columns, TARGET, lgb_params)
print(metrics.roc_auc_score(test_predictions[TARGET], test_predictions['prediction']))
else:
lgb_params['learning_rate'] = 0.005
lgb_params['n_estimators'] = 2000
lgb_params['early_stopping_rounds'] = 100
test_p... | dataset['Fare'].fillna(dataset['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
4,025,645 | if not LOCAL_TEST:
test_predictions['isFraud'] = test_predictions['prediction']
test_predictions[['TransactionID','isFraud']].to_csv('submission.csv', index=False )<set_options> | le = LabelEncoder() | Titanic - Machine Learning from Disaster |
4,025,645 | sns.set()
%matplotlib inline
warnings.filterwarnings('ignore' )<load_from_csv> | dataset['FareBand'] = pd.qcut(dataset['Fare'], 4 ) | Titanic - Machine Learning from Disaster |
4,025,645 | %%time
folder_path = '.. /input/'
print('Loading data...')
train_identity = pd.read_csv(f'{folder_path}train_identity.csv', index_col='TransactionID')
print('\tSuccessfully loaded train_identity!')
train_transaction = pd.read_csv(f'{folder_path}train_transaction.csv', index_col='TransactionID')
print('\tSuccessfull... | dataset['FareClass'] = le.fit_transform(dataset['FareBand'] ) | Titanic - Machine Learning from Disaster |
4,025,645 | def id_split(dataframe):
dataframe['device_name'] = dataframe['DeviceInfo'].str.split('/', expand=True)[0]
dataframe['device_version'] = dataframe['DeviceInfo'].str.split('/', expand=True)[1]
dataframe['OS_id_30'] = dataframe['id_30'].str.split(' ', expand=True)[0]
dataframe['version_id_30'] = dataframe['id_30'].str.sp... | Titanic - Machine Learning from Disaster | |
4,025,645 | train_identity = id_split(train_identity)
test_identity = id_split(test_identity )<merge> | dataset['Title'] = le.fit_transform(dataset['Title'] ) | Titanic - Machine Learning from Disaster |
4,025,645 | print('Merging data...')
train = train_transaction.merge(train_identity, how='left', left_index=True, right_index=True)
test = test_transaction.merge(test_identity, how='left', left_index=True, right_index=True)
print('Data was successfully merged!
')
del train_identity, train_transaction, test_identity, test_trans... | dataset['Age*Class'] = dataset['AgeClass'] * dataset['Pclass'] | Titanic - Machine Learning from Disaster |
4,025,645 | useful_features = ['TransactionAmt', 'ProductCD', 'card1', 'card2', 'card3', 'card4', 'card5', 'card6', 'addr1', 'addr2', 'dist1',
'P_emaildomain', 'R_emaildomain', 'C1', 'C2', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10', 'C11', 'C12', 'C13',
'C14', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D8', 'D9', 'D10', 'D11', 'D12', 'D1... | drop_these = 'Age Cabin Embarked Fare Name Parch Ticket Sex SibSp AgeBand Family_Size FareBand'.split(' ' ) | Titanic - Machine Learning from Disaster |
4,025,645 | cols_to_drop = [col for col in train.columns if col not in useful_features]
cols_to_drop.remove('isFraud')
cols_to_drop.remove('TransactionDT' )<drop_column> | dataset = dataset.drop(drop_these, axis=1 ) | Titanic - Machine Learning from Disaster |
4,025,645 | train = train.drop(cols_to_drop, axis=1)
test = test.drop(cols_to_drop, axis=1 )<categorify> | train_cleaned = dataset[dataset['source'] == 'train']
test_cleaned = dataset[dataset['source'] == 'test'] | Titanic - Machine Learning from Disaster |
4,025,645 | columns_a = ['TransactionAmt', 'id_02', 'D15']
columns_b = ['card1', 'card4', 'addr1']
for col_a in columns_a:
for col_b in columns_b:
for df in [train, test]:
df[f'{col_a}_to_mean_{col_b}'] = df[col_a] / df.groupby([col_b])[col_a].transform('mean')
df[f'{col_a}_to_std_{col_b}'] = df[col_a] / df.groupby([col_b])[col_a... | train_cleaned['Survived'] = train_cleaned['Survived'].astype(int ) | Titanic - Machine Learning from Disaster |
4,025,645 | train['TransactionAmt_Log'] = np.log(train['TransactionAmt'])
test['TransactionAmt_Log'] = np.log(test['TransactionAmt'])
train['TransactionAmt_decimal'] =(( train['TransactionAmt'] - train['TransactionAmt'].astype(int)) * 1000 ).astype(int)
test['TransactionAmt_decimal'] =(( test['TransactionAmt'] - test['Transacti... | def predict_model(dtrain, dtest, predictor, outcome, model):
model.fit(dtrain[predictor], dtrain[outcome])
dtrain_pred = model.predict(dtest[predictor])
score = model.score(dtrain[predictor], dtrain[outcome])*100
return score, dtrain_pred | Titanic - Machine Learning from Disaster |
4,025,645 | for c in ['P_emaildomain', 'R_emaildomain']:
train[c + '_bin'] = train[c].map(emails)
test[c + '_bin'] = test[c].map(emails)
train[c + '_suffix'] = train[c].map(lambda x: str(x ).split('.')[-1])
test[c + '_suffix'] = test[c].map(lambda x: str(x ).split('.')[-1])
train[c + '_suffix'] = train[c + '_suffix'].map(lambd... | predictors_var = ['Pclass','Title', 'female','male', 'AgeClass', 'IsAlone', 'C', 'Q', 'S', 'FareClass', 'Age*Class']
outcome_var = 'Survived'
traindf = train_cleaned
testdf = test_cleaned | Titanic - Machine Learning from Disaster |
4,025,645 | %%time
for col in train.columns:
if train[col].dtype == 'object':
le = LabelEncoder()
le.fit(list(train[col].astype(str ).values)+ list(test[col].astype(str ).values))
train[col] = le.transform(list(train[col].astype(str ).values))
test[col] = le.transform(list(test[col].astype(str ).values))<drop_column> | logreg = LogisticRegression() | Titanic - Machine Learning from Disaster |
4,025,645 | %%time
train = reduce_mem_usage(train)
test = reduce_mem_usage(test )<prepare_x_and_y> | predict_model(traindf, testdf, predictors_var, outcome_var, logreg ) | Titanic - Machine Learning from Disaster |
4,025,645 | X = train.sort_values('TransactionDT' ).drop(['isFraud', 'TransactionDT'], axis=1)
y = train.sort_values('TransactionDT')['isFraud']
X_test = test.drop(['TransactionDT'], axis=1)
del train, test
gc.collect()<import_modules> | coef1.sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
4,025,645 | from sklearn.model_selection import KFold
import lightgbm as lgb<init_hyperparams> | svc = SVC() | Titanic - Machine Learning from Disaster |
4,025,645 | params = {'num_leaves': 491,
'min_child_weight': 0.03454472573214212,
'feature_fraction': 0.3797454081646243,
'bagging_fraction': 0.4181193142567742,
'min_data_in_leaf': 106,
'objective': 'binary',
'max_depth': -1,
'learning_rate': 0.006883242363721497,
"boosting_type": "gbdt",
"bagging_seed": 11,
"metric": 'auc',
"ver... | predict_model(traindf, testdf, predictors_var, outcome_var, svc ) | Titanic - Machine Learning from Disaster |
4,025,645 | %%time
NFOLDS = 5
folds = KFold(n_splits=NFOLDS)
columns = X.columns
splits = folds.split(X, y)
y_preds = np.zeros(X_test.shape[0])
y_oof = np.zeros(X.shape[0])
score = 0
feature_importances = pd.DataFrame()
feature_importances['feature'] = columns
for fold_n,(train_index, valid_index)in enumerate(splits):
X_train,... | knn = KNeighborsClassifier(n_neighbors=3 ) | Titanic - Machine Learning from Disaster |
4,025,645 | sub['isFraud'] = y_preds
sub.to_csv("submission.csv", index=False )<save_to_csv> | predict_model(traindf, testdf, predictors_var, outcome_var, knn ) | Titanic - Machine Learning from Disaster |
4,025,645 | feature_importances['average'] = feature_importances[[f'fold_{fold_n + 1}' for fold_n in range(folds.n_splits)]].mean(axis=1)
feature_importances.to_csv('feature_importances.csv')
plt.figure(figsize=(16, 16))
sns.barplot(data=feature_importances.sort_values(by='average', ascending=False ).head(50), x='average', y='fe... | gaussian = GaussianNB() | Titanic - Machine Learning from Disaster |
4,025,645 | start_time = time.time()
SUBMIT_MODE = True
<compute_test_metric> | predict_model(traindf, testdf, predictors_var, outcome_var, gaussian ) | Titanic - Machine Learning from Disaster |
4,025,645 | def rmse(predicted, actual):
return np.sqrt(((predicted - actual)** 2 ).mean())
def split_cat(text):
try:
return text.split("/")
except:
return("No Label", "No Label", "No Label" )<categorify> | decision_tree = DecisionTreeClassifier() | Titanic - Machine Learning from Disaster |
4,025,645 | class TargetEncoder:
def __repr__(self):
return 'TargetEncoder'
def __init__(self, cols, smoothing=1, min_samples_leaf=1, noise_level=0, keep_original=False):
self.cols = cols
self.smoothing = smoothing
self.min_samples_leaf = min_samples_leaf
self.noise_level = noise_level
self.keep_original = keep_original
@staticmet... | predict_model(traindf, testdf, predictors_var, outcome_var, decision_tree ) | Titanic - Machine Learning from Disaster |
4,025,645 | def to_number(x):
try:
if not x.isdigit() :
return 0
x = int(x)
if x > 100:
return 100
else:
return x
except:
return 0
def sum_numbers(desc):
if not isinstance(desc, str):
return 0
try:
return sum([to_number(s)for s in desc.split() ])
except:
return 0<string_transform> | random_forest = RandomForestClassifier(n_estimators=100 ) | Titanic - Machine Learning from Disaster |
4,025,645 | stopwords = {x: 1 for x in stopwords.words('english')}
non_alphanums = re.compile(u'[^A-Za-z0-9]+')
non_alphanumpunct = re.compile(u'[^A-Za-z0-9\.?!,; \(\)\[\]'"\$]+')
RE_PUNCTUATION = '|'.join([re.escape(x)for x in string.punctuation])
def normalize_text(text):
return u" ".join(
[x for x in [y for y in non_alphanu... | predict_model(traindf, testdf, predictors_var, outcome_var, random_forest ) | Titanic - Machine Learning from Disaster |
4,025,645 | train = pd.read_table('.. /input/train.tsv', engine='c',
dtype={'item_condition_id': 'category',
'shipping': 'category',
},
converters={'category_name': split_cat})
test = pd.read_table('.. /input/test.tsv', engine='c',
dtype={'item_condition_id': 'category',
'shipping': 'category',
},
converters={'category_name': spl... | predict_model(traindf, testdf, predictors_var, outcome_var, random_forest)[1] | Titanic - Machine Learning from Disaster |
4,025,645 | train['is_train'] = 1
test['is_train'] = 0
print('[{}] Compiled train / test'.format(time.time() - start_time))
print('Train shape: ', train.shape)
print('Test shape: ', test.shape)
train = train[train.price != 0].reset_index(drop=True)
print('[{}] Removed nonzero price'.format(time.time() - start_time))
print('Trai... | results = predict_model(traindf, testdf, predictors_var, outcome_var, random_forest)[1] | Titanic - Machine Learning from Disaster |
4,025,645 | del train
del test
merge.drop(['train_id', 'test_id', 'price'], axis=1, inplace=True)
gc.collect()
print('[{}] Garbage collection'.format(time.time() - start_time))<data_type_conversions> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": results
} ) | Titanic - Machine Learning from Disaster |
4,025,645 | <categorify><EOS> | submission.to_csv('submission_updated.csv', index=False ) | 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.