kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,642,180 | check_features.append('card6' )<create_dataframe> | dt=DecisionTreeClassifier()
score= cross_val_score(dt,x,y,cv=k_fold,n_jobs=1,scoring='accuracy')
print(score ) | Titanic - Machine Learning from Disaster |
14,642,180 | M_not_done = missing['features'].apply(lambda x: x if x[0]=='M' else 0)
M_not_done = pd.DataFrame(M_not_done)
M_not_done = M_not_done[M_not_done['features']!=0]
list(M_not_done['features'] )<concatenate> | round(np.mean(score)*100,2 ) | Titanic - Machine Learning from Disaster |
14,642,180 | drop_features.append('M1' )<concatenate> | lr=LogisticRegression()
score= cross_val_score(lr,x,y,cv=k_fold,n_jobs=1,scoring='accuracy')
print(score ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('M2' )<concatenate> | round(np.mean(score)*100,2 ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('M3' )<concatenate> | rf = RandomForestClassifier(n_estimators=50,max_depth=6,random_state=0)
score = cross_val_score(rf,x,y, cv=k_fold, n_jobs=1, scoring='accuracy')
print(score ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('M5' )<concatenate> | round(np.mean(score)*100,2 ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('M6' )<create_dataframe> | rf=RandomForestClassifier(n_estimators=30,max_depth=6, random_state=0)
rf.fit(x,y)
target_pred= rf.predict(target ) | Titanic - Machine Learning from Disaster |
14,642,180 | <feature_engineering><EOS> | output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': target_pred})
output.to_csv('Titanic_RF_Final.csv', index=False)
print("submission was Successfull!" ) | Titanic - Machine Learning from Disaster |
13,078,191 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<split> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
13,078,191 | train = id_split(train)
test = id_split(test )<drop_column> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,078,191 | usefull_features = [col for col in train.columns if col not in drop_features]
train = train[usefull_features]
usefull_features.remove('isFraud')
test = test[usefull_features]<data_type_conversions> | women = train_data[train_data['Sex'] == 'female']['Survived']
rate_women = sum(women)/len(women)
print('% of women who survived:', rate_women ) | Titanic - Machine Learning from Disaster |
13,078,191 | 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... | men = train_data[train_data.Sex == 'male']['Survived']
rate_men = sum(men)/len(men)
print('% of men who survived:', rate_men ) | Titanic - Machine Learning from Disaster |
13,078,191 | emails = {'gmail': 'google', 'att.net': 'att', 'twc.com': 'spectrum', 'scranton.edu': 'other',
'optonline.net': 'other', 'hotmail.co.uk': 'microsoft', 'comcast.net': 'other',
'yahoo.com.mx': 'yahoo', 'yahoo.fr': 'yahoo', 'yahoo.es': 'yahoo',
'charter.net': 'spectrum', 'live.com': 'microsoft', 'aim.com': 'aol',
'hotmail... | train_data[['Sex', 'Survived']].groupby(['Sex'] ).mean() | Titanic - Machine Learning from Disaster |
13,078,191 | 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... | train_data[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
13,078,191 | START_DATE = datetime.datetime.strptime('2017-11-30', '%Y-%m-%d')
def setTime(df):
df['TransactionDT'] = df['TransactionDT'].fillna(df['TransactionDT'].median())
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... | women_count = 0
women_survived_count = 0
for idx, row in train_data.iterrows() :
if row['Sex'] == 'female':
women_count += 1
if row['Survived'] == 1:
women_survived_count += 1
women_survived_count / women_count | Titanic - Machine Learning from Disaster |
13,078,191 | def addNewFeatures(data):
data['uid'] = data['card1'].astype(str)+'_'+data['card2'].astype(str)
data['uid2'] = data['uid'].astype(str)+'_'+data['card3'].astype(str)+'_'+data['card5'].astype(str)
data['uid3'] = data['uid2'].astype(str)+'_'+data['addr1'].astype(str)+'_'+data['addr2'].astype(str)
return data<feature_en... | predictions = []
for idx, row in test_data.iterrows() :
if row['Sex'] == 'female':
if row['Pclass'] <3:
predictions.append(1)
elif row['Fare'] < 25:
predictions.append(1)
else:
predictions.append(0)
else:
if row['Age'] < 10:
predictions.append(1)
else:
predictions.append(0)
| Titanic - Machine Learning from Disaster |
13,078,191 | train = addNewFeatures(train)
test = addNewFeatures(test )<data_type_conversions> | test_data['Survived'] = predictions | Titanic - Machine Learning from Disaster |
13,078,191 | i_cols = ['card2','card3','card5','uid','uid2','uid3']
for col in i_cols:
for agg_type in ['mean','std']:
new_col_name = col+'_TransactionAmt_'+agg_type
temp_df = pd.concat([train[[col, 'TransactionAmt']], test[[col,'TransactionAmt']]])
temp_df = temp_df.groupby([col])['TransactionAmt'].agg([agg_type] ).reset_index().... | test_data[['PassengerId', 'Survived']].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,135,141 | train = train.replace(np.inf,999)
test = test.replace(np.inf,999 )<concatenate> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
... | Titanic - Machine Learning from Disaster |
13,135,141 | i_cols = ['card1','card2','card3','card5',
'C1','C2','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','device_name',
'id_30','id_33',
'uid','uid2','uid3',
]
for col in i_cols:
temp_df = ... | train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv')
target=train['Survived']
def detect_outlier(df,n,cols):
outlier_indices = []
for i in cols:
Q1 = np.percentile(df[i], 20)
Q3 = np.percentile(df[i], 80)
IQR = Q3 - Q1
outlier_step = 1.5*IQR
outlier_index_list = df... | Titanic - Machine Learning from Disaster |
13,135,141 | train.drop(['TransactionDT', 'uid','uid2','uid3', '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', 'D1', 'D2', 'D9'], axis = 1, inplace = True)
test.drop(['TransactionDT', 'uid','uid2','uid3', 'DT','DT_M','DT_W','DT_D', 'DT_hour','DT_day_week... | total=pd.concat([train.drop('Survived',axis=1),test])
target=train['Survived']
total.head() | Titanic - Machine Learning from Disaster |
13,135,141 | 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))<feature_engineering> | print(total.isnull().sum())
total['Age'] = total.groupby('Pclass')['Age'].transform(lambda x: x.fillna(x.median()))
total['Fare'] = total.groupby('Pclass')['Fare'].transform(lambda x: x.fillna(x.median()))
total['Embarked'].fillna('S',inplace=True)
| Titanic - Machine Learning from Disaster |
13,135,141 | def agg_features(df):
columns_a = ['TransactionAmt', 'id_02', 'D15']
columns_b = ['card1', 'card4', 'addr1']
for col_a in columns_a:
for col_b in columns_b:
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].t... | encoder=LabelEncoder()
total['Sex']=encoder.fit_transform(total['Sex'])
total['Embarked']=encoder.fit_transform(total['Embarked'])
total=pd.get_dummies(total,columns=['Pclass','Embarked'] ) | Titanic - Machine Learning from Disaster |
13,135,141 | train = reduce_mem_usage(train)
test = reduce_mem_usage(test )<prepare_x_and_y> | total['Fare_1_S']=total['Embarked_2']*total['Pclass_1']*total['Sex']
| Titanic - Machine Learning from Disaster |
13,135,141 | X = train.drop(['isFraud'], axis = 1)
y = train['isFraud']
print('Our train set have {} columns'.format(train.shape[1]))
print('Our test set have {} columns'.format(test.shape[1]))
gc.collect()<init_hyperparams> | total['Title'] =total['Name'].str.extract('([A-Za-z]+)\.', expand=False)
total['Title'] =total['Title'].replace(['Lady', 'Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
total['Title'] =total['Title'].replace('Mlle', 'Miss')
total['Title'] =total['Title'].replace('Ms', 'Miss... | Titanic - Machine Learning from Disaster |
13,135,141 | params = {
'objective':'binary',
'boosting_type':'gbdt',
'metric':'auc',
'n_jobs':-1,
'learning_rate':0.005,
'num_leaves': 2**8,
'max_depth':-1,
'tree_learner':'serial',
'colsample_bytree': 0.7,
'subsample_freq':1,
'subsample':0.7,
'n_estimators':100000,
'max_bin':255,
'verbose':-1,
'random_state': 47,
'early_stopping_... | total.drop(['Name','Ticket','Cabin'],axis=1,inplace=True)
total=pd.get_dummies(total,columns=['SibSp','Parch','Age_cat','Title','FamilySize','Fare_cat','FamilySize_cat'])
total['Age']=total['Age'].astype(int ) | Titanic - Machine Learning from Disaster |
13,135,141 | NFOLDS = 10
folds = KFold(n_splits=NFOLDS)
splits = folds.split(X, y)
y_preds = np.zeros(test.shape[0])
y_oof = np.zeros(X.shape[0])
score = 0
for fold_n,(train_index, valid_index)in enumerate(splits):
X_train, X_valid = X.iloc[train_index], X.iloc[valid_index]
y_train, y_valid = y.iloc[train_index], y.iloc[valid_i... | train=total[:len(train)]
test=total[len(train):]
np.random.seed(42)
X_train, X_test, y_train, y_test = train_test_split(train,target, test_size = 0.2)
models = {"KNN": KNeighborsClassifier() ,
"Logistic Regression": LogisticRegression(max_iter=10000),
"Random Forest": RandomForestClassifier() ,
"SVC" : SVC(probabilit... | Titanic - Machine Learning from Disaster |
13,135,141 | <load_from_csv><EOS> | leaks = {
897:1,
899:1,
930:1,
932:1,
949:1,
987:1,
995:1,
998:1,
999:1,
1016:1,
1047:1,
1083:1,
1097:1,
1099:1,
1103:1,
1115:1,
1118:1,
1135:1,
1143:1,
1152:1,
1153:1,
1171:1,
1182:1,
1192:1,
1203:1,
1233:1,
1250:1,
1264:1,
1286:1,
935:0,
957:0,
972:0,
988:0,
1004:0,
1006:0,
1011:0,
1105:0,
1130:0,
1138:0,
1173:0,
128... | Titanic - Machine Learning from Disaster |
13,310,876 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<set_options> | sns.set(style="darkgrid")
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
13,310,876 | pd.set_option('display.max_columns', 500)
train_transaction.head(5 )<feature_engineering> | data = pd.read_csv("/kaggle/input/titanic/train.csv")
data_test = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_transaction['Transaction_dow'] = np.floor(( train_transaction['TransactionDT'] /(3600 * 24)- 1)% 7)
train_transaction['Transaction_hour'] = np.floor(train_transaction['TransactionDT'] / 3600)% 24<count_missing_values> | y = data["Survived"]
X = data.copy()
X_test = data_test.copy()
X_full = pd.concat([X, X_test])
n = len(X)
n_test = len(X_test)
n_full = n + n_test | Titanic - Machine Learning from Disaster |
13,310,876 | na_columns = train_identity.isna().sum()
na_columns[na_columns==0]<count_missing_values> | ( X_full.drop(["Survived"], axis = 1 ).isna().sum() / n_full)* 100 | Titanic - Machine Learning from Disaster |
13,310,876 | na_columns = train_transaction.isna().sum()
na_columns[na_columns==0]<define_variables> | def fill_na_age(row):
row["Age"] = df_median_age_class[row["Sex"]][row["Pclass"]][0] if pd.isnull(row["Age"])else row["Age"]
return row
X_full = X_full.apply(fill_na_age, axis = 1)
X_full.info() | Titanic - Machine Learning from Disaster |
13,310,876 | categoricalCols = list(set(transaction_columns)- set(numericCols))<feature_engineering> | print(X_full[X_full["Fare"].isnull() ] ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_transaction[categoricalCols] = train_transaction[categoricalCols].replace({np.nan:'missing'})
train_transaction[numericCols] = train_transaction[numericCols].replace({np.nan:-1})
<feature_engineering> | def fill_na_fare(row):
row["Fare"] = df_median_fare_class[row["Pclass"]][0] if pd.isnull(row["Fare"])else row["Fare"]
return row
X_full = X_full.apply(fill_na_fare, axis = 1)
X_full.info()
print(X_full[X_full["PassengerId"] == 1044] ) | Titanic - Machine Learning from Disaster |
13,310,876 | false_Fraud_Amt = np.mean(train_transaction.loc[train_transaction["isFraud"]==0]['TransactionAmt'])
true_Fraud_Amt = np.mean(train_transaction.loc[train_transaction["isFraud"]==1]['TransactionAmt'])
print(false_Fraud_Amt)
print(true_Fraud_Amt)
<define_variables> | X_full[X_full["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
13,310,876 | false_Fraud_Amt_max = np.max(train_transaction.loc[train_transaction["isFraud"]==0]['TransactionAmt'])
true_Fraud_Amt_max = np.max(train_transaction.loc[train_transaction["isFraud"]==1]['TransactionAmt'])
print(false_Fraud_Amt_max)
print(true_Fraud_Amt_max )<filter> | embarked_survived = X.groupby(["Embarked", "Survived"])["PassengerId"].count()
embarked_survived.head(10 ) | Titanic - Machine Learning from Disaster |
13,310,876 | false_Fraud_Amt_min = np.min(train_transaction.loc[train_transaction["isFraud"]==0]['TransactionAmt'])
true_Fraud_Amt_min = np.min(train_transaction.loc[train_transaction["isFraud"]==1]['TransactionAmt'])
print(false_Fraud_Amt_min)
print(true_Fraud_Amt_min )<feature_engineering> | def display_embarked_prob() :
surv_counts = {
"C": {},
"Q": {},
"S": {}
}
classes = set(embarked_survived.index.get_level_values(0))
for c in classes:
for survive in range(0, 2):
surv_counts[str(c)][survive] = embarked_survived[c][survive]
df_surv = pd.DataFrame(surv_counts)
surv_percentages = {}
for col in df_surv.co... | Titanic - Machine Learning from Disaster |
13,310,876 | maxCardData = {}
minCardData = {}
meanCardData = {}
for i,i_card in enumerate(cardTypes):
cardData = eval('train_transaction.loc[train_transaction["card4"]=="'+i_card+'" ]')
maxCardData[i_card] = np.max(cardData['TransactionAmt'])
minCardData[i_card] = np.min(cardData['TransactionAmt'])
meanCardData[i_card] = np.mea... | embarked_class_passengers = X.groupby("Pclass")["Embarked"].value_counts()
print(embarked_class_passengers ) | Titanic - Machine Learning from Disaster |
13,310,876 | del fraudDataTransaction,normalDataTransaction,productData,cardData<feature_engineering> | X_full["CabinId"] = X_full["Cabin"].map(lambda cabin: cabin if pd.isnull(cabin)else cabin[0])
X["CabinId"] = X["Cabin"].map(lambda cabin: cabin if pd.isnull(cabin)else cabin[0])
X["CabinId"].sample(10)
| Titanic - Machine Learning from Disaster |
13,310,876 | identity_data_columns = train_identity.columns
numericCols = train_identity._get_numeric_data().columns
categoricalCols = list(set(identity_data_columns)- set(numericCols))
print('The categorical columns in identity data are: ',categoricalCols)
train_identity[categoricalCols] = train_identity[categoricalCols].replace(... | X.groupby(["CabinId", "Pclass"])["PassengerId"].count() | Titanic - Machine Learning from Disaster |
13,310,876 | train_identity.loc[train_identity['id_30'].str.contains('Mac', na=False), 'id_30'] = 'mac'
train_identity.loc[train_identity['id_30'].str.contains('iOS', na=False), 'id_30'] = 'iOS'
train_identity.loc[train_identity['id_30'].str.contains('Android', na=False), 'id_30'] = 'android'
train_identity.loc[train_identity['id_3... | class_cabin_passengers = X.groupby(["Pclass", "CabinId"])["PassengerId"].count()
print(class_cabin_passengers ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_identity['device_name'] = train_identity['DeviceInfo'].str.split('/', expand=True)[0]
train_identity.loc[train_identity['device_name'].str.contains('SM', na=False), 'device_name'] = 'Samsung'
train_identity.loc[train_identity['device_name'].str.contains('SAMSUNG', na=False), 'device_name'] = 'Samsung'
train_ident... | survival_by_gender = X.groupby("Sex" ).apply(lambda df: sum(df["Survived"] == 1))
survival_by_gender | Titanic - Machine Learning from Disaster |
13,310,876 | raw_train_data = pd.merge(train_transaction, train_identity, on='TransactionID', how='left')
<drop_column> | survival_by_gender["female"] /(survival_by_gender["female"] + survival_by_gender["male"] ) | Titanic - Machine Learning from Disaster |
13,310,876 | del train_identity,train_transaction<categorify> | survival_by_class = X.groupby("Pclass")["Survived"].apply(lambda x: {"Survived": sum(x == 1), "Not Survived": sum(x == 0)})
survival_by_class | Titanic - Machine Learning from Disaster |
13,310,876 | raw_train_data[categoricalCols] = raw_train_data[categoricalCols].replace({ np.nan:'missing'})
raw_train_data[numericCols] = raw_train_data[numericCols].replace({ np.nan:-1} )<categorify> | gender_by_class = X.groupby("Pclass")["Sex"].apply(lambda x: {"Male": sum(x == "male"), "Female": sum(x == "female")})
gender_by_class | Titanic - Machine Learning from Disaster |
13,310,876 | def memory_usage_mb(df, *args, **kwargs):
return df.memory_usage(*args, **kwargs ).sum() / 1024**2
def reduce_memory_usage(df, deep=True, verbose=True):
numeric2reduce = ["int16", "int32", "int64", "float64"]
start_mem = 0
if verbose:
start_mem = memory_usage_mb(df, deep=deep)
for col, col_type in df.dtypes.iteritem... | df_class_survived = X.groupby(['Pclass', "Survived", "Sex"] ).count().drop(columns=[
'Age',
'SibSp',
'Parch',
'Fare',
'Embarked',
'Cabin',
'PassengerId',
'Ticket'] ).rename(columns={'Name':'Count'} ).transpose()
df_class_survived.head(15 ) | Titanic - Machine Learning from Disaster |
13,310,876 | raw_train_data = reduce_memory_usage(raw_train_data, deep=True, verbose=True )<define_variables> | def display_gender_by_class_prob(gender):
surv_counts = {
"1": {},
"2": {},
"3": {}
}
classes = df_class_survived.columns.levels[0]
for c in classes:
for survive in range(0, 2):
surv_counts[str(c)][survive] = df_class_survived[c][survive][gender][0]
df_surv = pd.DataFrame(surv_counts)
surv_percentages = {}
for col in ... | Titanic - Machine Learning from Disaster |
13,310,876 | na_vals = np.sum(raw_train_data.loc[:,variables]==-1)/ raw_train_data.shape[0]
goodNumericVars = []
for i_var in variables:
if na_vals[i_var] < 0.85:
goodNumericVars.append(i_var)
goodNumericVars.remove('TransactionDT')
goodNumericVars.remove('TransactionID')
corrThresh = 0.9
upper = correlationMatrix.where(np.triu(... | numerical_columns = ["Age", "SibSp", "Parch", "Fare"]
categorical_columns = ["Pclass", "Embarked", "Sex"]
feature_columns = numerical_columns + categorical_columns
X = X[feature_columns]
X_test = X_test[feature_columns]
X.head() | Titanic - Machine Learning from Disaster |
13,310,876 | for i_var in to_drop:
if i_var in goodNumericVars:
goodNumericVars.remove(i_var)
<drop_column> | X_train, X_valid, y_train, y_valid = train_test_split(X, y,
train_size=0.7, test_size=0.3,
random_state=0 ) | Titanic - Machine Learning from Disaster |
13,310,876 | del to_drop,corrThresh,upper,correlationMatrix,na_vals<define_variables> | X_train.isna().sum() | Titanic - Machine Learning from Disaster |
13,310,876 | variables = list(categoricalCols)
na_vals = np.sum(raw_train_data.loc[:,variables] == 'missing')/ raw_train_data.shape[0]
goodCategoricalVars = []
for i_var in variables:
if na_vals[i_var] < 0.85:
goodCategoricalVars.append(i_var)
<prepare_x_and_y> | X_train.isna().sum() | Titanic - Machine Learning from Disaster |
13,310,876 | featureToUse = goodNumericVars + goodCategoricalVars
train_data = raw_train_data.loc[:,featureToUse]
target_data = raw_train_data['isFraud']<categorify> | numerical_transformer = SimpleImputer(strategy='mean')
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
] ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_data['TransactionAmt_to_mean_card1'] = train_data['TransactionAmt'] / train_data.groupby(['card1'])['TransactionAmt'].transform('mean')
train_data['TransactionAmt_to_mean_card4'] = train_data['TransactionAmt'] / train_data.groupby(['card4'])['TransactionAmt'].transform('mean')
train_data['TransactionAmt_to_mean... | preprocessor = ColumnTransformer(
transformers=[
('num', numerical_transformer, numerical_columns),
('cat', categorical_transformer, categorical_columns)
] ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_data['TransactionAmt_to_mean_C1'] = train_data['TransactionAmt'] / train_data.groupby(['C1'])['TransactionAmt'].transform('mean')
train_data['TransactionAmt_to_mean_C3'] = train_data['TransactionAmt'] / train_data.groupby(['C3'])['TransactionAmt'].transform('mean')
train_data['TransactionAmt_to_mean_C5'] = trai... | model = RandomForestClassifier(n_estimators = 150, max_depth = 5, random_state=0 ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_data['TransactionAmt_to_std_C1'] = train_data['TransactionAmt'] / train_data.groupby(['C1'])['TransactionAmt'].transform('std')
train_data['TransactionAmt_to_std_C3'] = train_data['TransactionAmt'] / train_data.groupby(['C3'])['TransactionAmt'].transform('std')
train_data['TransactionAmt_to_std_C5'] = train_dat... | pipeline = Pipeline(steps=[
('preprocessor', preprocessor),
('model', model)
] ) | Titanic - Machine Learning from Disaster |
13,310,876 | train_data['TransactionAmt'] = np.log(train_data['TransactionAmt'])
<define_variables> | pipeline.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
13,310,876 | scale_pos_weight = np.sqrt(len(target_data.loc[target_data==0])/len(target_data.loc[target_data==1]))
del raw_train_data<load_from_csv> | preds = pipeline.predict(X_valid)
preds | Titanic - Machine Learning from Disaster |
13,310,876 | test_identity_data = pd.read_csv(".. /input/ieee-fraud-detection/test_identity.csv")
test_transaction_data = pd.read_csv(".. /input/ieee-fraud-detection/test_transaction.csv" )<count_missing_values> | accuracy_score(y_valid, preds ) | Titanic - Machine Learning from Disaster |
13,310,876 | na_columns = test_transaction_data.isna().sum()
print(na_columns[na_columns==0])
print(na_columns[na_columns>0] / test_transaction_data.shape[0] )<feature_engineering> | recall_score(y_valid, preds ) | Titanic - Machine Learning from Disaster |
13,310,876 | test_transaction_data['Transaction_dow'] = np.floor(( test_transaction_data['TransactionDT'] /(3600 * 24)- 1)% 7)
test_transaction_data['Transaction_hour'] = np.floor(test_transaction_data['TransactionDT'] / 3600)% 24
transaction_data_columns = test_transaction_data.columns
numericCols = test_transaction_data._get_num... | preds_test = pipeline.predict(X_test)
preds_test.shape | Titanic - Machine Learning from Disaster |
13,310,876 | identity_data_columns = test_identity_data.columns
numericCols = test_identity_data._get_numeric_data().columns
categoricalCols = list(set(identity_data_columns)- set(numericCols))
test_identity_data[categoricalCols] = test_identity_data[categoricalCols].replace({ np.nan:'missing'})
test_identity_data[numericCols] = t... | output = pd.DataFrame({"PassengerId": data_test["PassengerId"],
"Survived": preds_test})
output.head() | Titanic - Machine Learning from Disaster |
13,310,876 | raw_test_data = pd.merge(test_transaction_data, test_identity_data, on='TransactionID', how='left')
transactionID = raw_test_data.loc[:,'TransactionID']
del test_identity_data,test_transaction_data<feature_engineering> | output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,310,876 | raw_test_data_columns = raw_test_data.columns
numericCols = raw_test_data._get_numeric_data().columns
categoricalCols = list(set(raw_test_data_columns)- set(numericCols))
print('The categorical columns in training data are: ',categoricalCols)
raw_test_data[categoricalCols] = raw_test_data[categoricalCols].replace({ np... | lr_model = LogisticRegression(random_state=0)
lr_pipeline = Pipeline(steps = [
('preprocessor', preprocessor),
('model', lr_model)
])
lr_pipeline.fit(X_train, y_train)
lr_preds = lr_pipeline.predict(X_valid)
accuracy_score(y_valid, lr_preds)
| Titanic - Machine Learning from Disaster |
13,310,876 | test_data = raw_test_data.loc[:,featureToUse]<categorify> | lr_preds_test = lr_pipeline.predict(X_test)
lr_output = pd.DataFrame({"PassengerId": data_test["PassengerId"],
"Survived": lr_preds_test})
lr_output.to_csv('lr_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,310,876 | test_data['TransactionAmt_to_mean_card1'] = test_data['TransactionAmt'] / test_data.groupby(['card1'])['TransactionAmt'].transform('mean')
test_data['TransactionAmt_to_mean_card4'] = test_data['TransactionAmt'] / test_data.groupby(['card4'])['TransactionAmt'].transform('mean')
test_data['TransactionAmt_to_mean_card5'... | xgb_model = XGBClassifier(n_estimators = 1000, learning_rate = 0.1, max_depth = 5, random_state=0)
xgb_pipeline = Pipeline(steps = [
('preprocessor', preprocessor),
('model', xgb_model)
])
xgb_pipeline.fit(X_train, y_train)
xgb_preds = xgb_pipeline.predict(X_valid)
accuracy_score(y_valid, xgb_preds ) | Titanic - Machine Learning from Disaster |
13,310,876 | test_data['TransactionAmt_to_mean_C1'] = test_data['TransactionAmt'] / test_data.groupby(['C1'])['TransactionAmt'].transform('mean')
test_data['TransactionAmt_to_mean_C3'] = test_data['TransactionAmt'] / test_data.groupby(['C3'])['TransactionAmt'].transform('mean')
test_data['TransactionAmt_to_mean_C5'] = test_data['... | xgb_preds_test = xgb_pipeline.predict(X_test)
xgb_output = pd.DataFrame({"PassengerId": data_test["PassengerId"],
"Survived": xgb_preds_test})
xgb_output.to_csv('xgb_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,310,876 | for i_cat in goodCategoricalVars:
le = LabelEncoder()
curData = pd.concat([train_data.loc[:,i_cat],test_data.loc[:,i_cat]],axis = 0)
le.fit(curData)
train_data.loc[:,i_cat] = le.transform(train_data.loc[:,i_cat])
test_data.loc[:,i_cat] = le.transform(test_data.loc[:,i_cat] )<choose_model_class> | svm_model = LinearSVC(dual = False, random_state=0)
svm_pipeline = Pipeline(steps = [
('preprocessor', preprocessor),
('model', svm_model)
])
svm_pipeline.fit(X_train, y_train)
svm_preds = svm_pipeline.predict(X_valid)
accuracy_score(y_valid, svm_preds ) | Titanic - Machine Learning from Disaster |
13,310,876 | cv = StratifiedKFold(n_splits=5, random_state=123, shuffle=True )<compute_train_metric> | svm_preds_test = svm_pipeline.predict(X_test)
svm_output = pd.DataFrame({"PassengerId": data_test["PassengerId"],
"Survived": svm_preds_test})
svm_output.to_csv('svm_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,372,512 | def compute_roc_auc(clf,index):
y_predict = clf.predict_proba(train_data.iloc[index])[:,1]
fpr, tpr, thresholds = roc_curve(target_data.iloc[index], y_predict)
auc_score = auc(fpr, tpr)
return fpr, tpr, auc_score<init_hyperparams> | X_full = pd.read_csv('.. /input/titanic/train.csv', index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
13,372,512 | params = {'bagging_fraction': 0.7982116702024386,
'feature_fraction': 0.1785051643813966,
'max_depth': int(49.17611603427576),
'min_child_weight': 3.2852905549011155,
'min_data_in_leaf': int(31.03480802715621),
'n_estimators': int(1491.3676131788188),
'num_leaves': int(52.851307790411965),
'reg_alpha': 0.45963319421692... | np.random.seed(0)
missing_values_count = X_full.isnull().sum()
total_cells = np.product(X_full.shape)
total_missing = missing_values_count.sum()
percent_missing =(total_missing/total_cells)
print(percent_missing)
print(total_cells)
print(total_missing ) | Titanic - Machine Learning from Disaster |
13,372,512 | fprs_lgb, tprs_lgb, scores_lgb = [], [], []
feature_importances = pd.DataFrame()
feature_importances['feature'] = train_data.columns
predictions = np.zeros(len(test_data))
for(train, test), i in zip(cv.split(train_data, target_data), range(5)) :
lgb_best = LGBMClassifier(boosting = params['boosting_type'],n_estimators ... | X_test_full = pd.read_csv('.. /input/titanic/test.csv', index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
13,372,512 | print('Mean AUC:', np.mean(scores_lgb,axis = 1))<save_to_csv> | X_full.dropna(axis=0, subset=['Survived'], inplace=True)
y = X_full.Survived
X_full.drop(['Survived'], axis=1, inplace=True)
X_full.drop(['Name', 'Ticket', 'Fare', 'SibSp'], axis=1, inplace=True)
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X_full, y, train_size=0.8, test_size=0.2, random_state=0)... | Titanic - Machine Learning from Disaster |
13,372,512 | data = {'TransactionID':transactionID,'isFraud':predictions}
submissionDF = pd.DataFrame(data)
submissionDF.to_csv('sample_submission2.csv',index=False )<set_options> | numerical_transformer = SimpleImputer(strategy='most_frequent')
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='most_frequent')) ,
('onehot', OneHotEncoder(handle_unknown='ignore'))
])
preprocessor = ColumnTransformer(
transformers=[
('num', numerical_transformer, numerical_cols),
... | Titanic - Machine Learning from Disaster |
13,372,512 | print('loading libs...')
warnings.filterwarnings("ignore")
print('done' )<load_from_csv> | print(gridF.best_params_ ) | Titanic - Machine Learning from Disaster |
13,372,512 | <define_variables><EOS> | preds_test = clf.predict(X_test)
output = pd.DataFrame({'PassengerId': X_test.index, 'Survived': preds_test})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
13,278,672 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd
import category_encoders as ce
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.impute import SimpleImputer
| Titanic - Machine Learning from Disaster |
13,278,672 | %%time
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('dropping target...')
y_train = train['isFraud'].copy()
del train_transaction, train_identi... | data = pd.read_csv('/kaggle/input/titanic/train.csv')
print(data.columns)
X_test = pd.read_csv('/kaggle/input/titanic/test.csv')
data.dropna(axis=0, subset=["Embarked"], inplace=True)
X = data.drop(columns="Survived")
y = data.Survived.copy()
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.... | Titanic - Machine Learning from Disaster |
13,278,672 | <set_options><EOS> | model = XGBClassifier(n_estimators=500)
model.fit(X_train, y_train)
predictions = model.predict(X_valid)
print(y_valid.head(20))
print(predictions[:20])
print("Accuracy:" , 1-mean_absolute_error(predictions, y_valid))
print("F1:", f1_score(predictions, y_valid))
selector = SelectKBest(f_classif, k=5)
X_new = selec... | Titanic - Machine Learning from Disaster |
12,980,839 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | SEED = 7
print("Setup complete." ) | Titanic - Machine Learning from Disaster |
12,980,839 | %%time
train_transaction = pd.read_csv('.. /input/train_transaction.csv', index_col='TransactionID')
test_transaction = pd.read_csv('.. /input/test_transaction.csv', index_col='TransactionID')
train_identity = pd.read_csv('.. /input/train_identity.csv', index_col='TransactionID')
test_identity = pd.read_csv('.. /inp... | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
datasets = [train, test]
train | Titanic - Machine Learning from Disaster |
12,980,839 | train_df = train_transaction.merge(train_identity, how='left', left_index=True, right_index=True)
test_df = test_transaction.merge(test_identity, how='left', left_index=True, right_index=True)
print("Train shape : "+str(train_df.shape))
print("Test shape : "+str(test_df.shape))<set_options> | for ds in datasets:
def rand_ages() :
np.random.seed(SEED)
return np.random.randint(low=ds['Age'].mean() - ds['Age'].std() ,
high=ds['Age'].mean() + ds['Age'].std() ,
size=ds['Age'].isnull().sum())
ds.loc[ds['Age'].isnull() , 'Age'] = rand_ages()
ds['Age'] = pd.cut(ds['Age'], 5, labels=range(5))
ds.loc[:, 'Age'] = ds... | Titanic - Machine Learning from Disaster |
12,980,839 | pd.set_option('display.max_columns', 500 )<feature_engineering> | def encode_freq_sorted(feature):
sorted_indices = feature.value_counts().index
sorted_dict = dict(zip(sorted_indices, range(len(sorted_indices))))
return feature.map(sorted_dict ).astype(int)
for ds in datasets:
ds['Sex'] = encode_freq_sorted(ds['Sex'])
ds['Embarked'] = encode_freq_sorted(ds['Embarked'])
ds['Title']... | Titanic - Machine Learning from Disaster |
12,980,839 | def missing_data(data):
total = data.isnull().sum()
percent =(data.isnull().sum() /data.isnull().count() *100)
tt = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
types = []
for col in data.columns:
dtype = str(data[col].dtype)
types.append(dtype)
tt['Types'] = types
return(np.transpose(tt))<count_m... | drop_features = ['Name', 'SibSp', 'Parch', 'Ticket', 'Cabin'] | Titanic - Machine Learning from Disaster |
12,980,839 | display(missing_data(train_df), missing_data(test_df))<drop_column> | drop_features.extend(['Pclass'])
train = train.drop(columns=drop_features)
test = test.drop(columns=drop_features)
X = train.drop(columns=['PassengerId', 'Survived'])
y = train['Survived']
X.head() | Titanic - Machine Learning from Disaster |
12,980,839 | del train_transaction, train_identity, test_transaction, test_identity<count_missing_values> | X_train, X_val, y_train, y_val = train_test_split(X, y, train_size=0.8,
random_state=SEED)
X_test = test.drop(columns=['PassengerId'] ) | Titanic - Machine Learning from Disaster |
12,980,839 | train_df['nulls1'] = train_df.isna().sum(axis=1)
test_df['nulls1'] = test_df.isna().sum(axis=1 )<feature_engineering> | cross_valid = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
def random_search(X, y, estimator, params, score="accuracy", cv=cross_valid,
n_iter=100, random_state=SEED, n_jobs=-1):
print("
classifier = RandomizedSearchCV(estimator=estimator, param_distributions=params,
scoring=score, cv=cv, n_iter=n_it... | Titanic - Machine Learning from Disaster |
12,980,839 | for c in ['P_emaildomain', 'R_emaildomain']:
train_df[c + '_bin'] = train_df[c].map(emails)
test_df[c + '_bin'] = test_df[c].map(emails)
train_df[c + '_suffix'] = train_df[c].map(lambda x: str(x ).split('.')[-1])
test_df[c + '_suffix'] = test_df[c].map(lambda x: str(x ).split('.')[-1])
train_df[c + '_suffix'] = tra... | random_forest = RandomForestClassifier(random_state=SEED)
random_forest.get_params() | Titanic - Machine Learning from Disaster |
12,980,839 | train_df = train_df.replace('nan', np.nan)
test_df = test_df.replace('nan', np.nan)
train_df = train_df.reset_index(drop=True)
test_df = test_df.reset_index(drop=True )<define_variables> | params = {
'bootstrap': [True, False],
'max_depth': [int(x)for x in np.linspace(10, 110, num = 11)],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 2, 4],
'min_samples_split': [2, 5, 10],
'n_estimators': [int(x)for x in np.linspace(200, 2000, num = 10)]
}
random_forest_tuned = random_search(
X_train, y_trai... | Titanic - Machine Learning from Disaster |
12,980,839 | labels = {np.nan: np.nan, 'nan': np.nan, 't': 1, 'f': 2, 'm2': 3, 'm0': 4, 'm1': 5, 'gmail.com': 6, 'outlook.com': 7, 'yahoo.com': 8, 'mail.com': 9, 'anonymous.com': 10, 'hotmail.com': 11, 'verizon.net': 12, 'aol.com': 13, 'me.com': 14, 'comcast.net': 15, 'optonline.net': 16, 'cox.net': 17, 'charter.net': 18, 'rocketma... | y_pred = random_forest_tuned.predict(X_val)
accuracy_random_forest = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy_random_forest ) | Titanic - Machine Learning from Disaster |
12,980,839 | for c1, c2 in train_df.dtypes.reset_index().values:
if c2=='O':
train_df[c1] = train_df[c1].map(lambda x: labels[str(x ).lower() ])
test_df[c1] = test_df[c1].map(lambda x: labels[str(x ).lower() ] )<feature_engineering> | svc = SVC(probability=True, random_state=SEED)
svc.get_params() | Titanic - Machine Learning from Disaster |
12,980,839 | def nan2mean(df):
for x in list(df.columns.values):
df[x] = df[x].fillna(df[x].mean())
return df<feature_engineering> | params = {
'C': scipy.stats.expon(scale=100),
'class_weight':['balanced', None],
'gamma': scipy.stats.expon(scale=.1),
'kernel':['rbf', 'linear']
}
svc_tuned = random_search(X_train, y_train, estimator=svc, params=params ) | Titanic - Machine Learning from Disaster |
12,980,839 | train_df=nan2mean(train_df )<feature_engineering> | y_pred = svc_tuned.predict(X_val)
accuracy_svc = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy_svc ) | Titanic - Machine Learning from Disaster |
12,980,839 | test_df=nan2mean(test_df )<categorify> | xgb = XGBClassifier(random_state=SEED, verbosity=0)
xgb.get_params() | Titanic - Machine Learning from Disaster |
12,980,839 | lb_enc = []
for f in train_df.columns:
if train_df[f].dtype=='object' and f != 'isFraud':
lb_enc.append(f)
lbl = preprocessing.LabelEncoder()
lbl.fit(list(train_df[f].values)+ list(test_df[f].values))
try:
train_df[f] = lbl.transform(list(train_df[f].values))
test_df[f] = lbl.transform(list(test_df[f].values))
except:... | params = {
'colsample_bytree': list(np.arange(0.6, 1.0, step=0.05)) ,
'gamma': list(np.arange(0.1, 15, step=0.2)) ,
'learning_rate': [0.01, 0.05, 0.1, 0.15, 0.2],
'max_depth': list(range(2, 12)) ,
'min_child_weight': list(range(1, 12)) ,
'n_estimators': [10, 100, 500, 1000],
'reg_alpha': [10**i for i in range(-5, 1)],
... | Titanic - Machine Learning from Disaster |
12,980,839 | from sklearn.preprocessing import StandardScaler, OneHotEncoder<categorify> | y_pred = xgb_tuned.predict(X_val)
accuracy_xgboost = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy_xgboost ) | Titanic - Machine Learning from Disaster |
12,980,839 | for f in lb_enc:
oh_enc = OneHotEncoder()
num_val = np.unique(list(train_df[f].values)+ list(test_df[f].values)).shape[0]
X = oh_enc.fit_transform(np.array(list(train_df[f].values)+ list(test_df[f].values)).reshape(-1, 1))
df_train_X = pd.DataFrame(X.toarray() [:train_df.shape[0]], columns=[f + str(i)for i in range(num... | decision_tree = DecisionTreeClassifier(random_state=SEED)
decision_tree.get_params() | Titanic - Machine Learning from Disaster |
12,980,839 | features = list(train_df)
features.remove('isFraud')
target = 'isFraud'<count_unique_values> | params = {
'criterion': ["gini", "entropy"],
'max_depth': list(range(1, 32)) ,
'max_features': list(range(1, X_train.shape[1]+1)) ,
'min_samples_leaf': list(range(1, 9)) ,
'min_samples_split': list(np.arange(0.1, 1.1, step=0.1))
}
decision_tree_tuned = random_search(
X_train, y_train, estimator=decision_tree, params=p... | Titanic - Machine Learning from Disaster |
12,980,839 | for col in test_df.columns:
if np.unique(train_df[col].values ).shape[0] in [1,train_df.shape[0]]:
print(col )<split> | y_pred = decision_tree_tuned.predict(X_val)
accuracy_decision_tree = accuracy_score(y_val, y_pred)
print("Accuracy:", accuracy_decision_tree ) | Titanic - Machine Learning from Disaster |
12,980,839 | bayesian_tr_idx, bayesian_val_idx = train_test_split(train_df, test_size = 0.3, random_state = 42, stratify = train_df[target])
bayesian_tr_idx = bayesian_tr_idx.index
bayesian_val_idx = bayesian_val_idx.index<concatenate> | knn = KNeighborsClassifier()
knn.get_params() | 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.