kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,464,656 | %%time
df_category=pd.DataFrame(df_train.category.unique() ,columns=['category'])
df_category['count']=df_category.category.apply(lambda x: len(df_train.category[df_train.category==x]))
df_category['rmsle']=0
df_category['skewness']=0
df_category['X_shape']=''
df_category['test_len']=0
df_predictions=pd.DataFrame(colu... | train_age = pd.get_dummies(train_data['Age_Cat'])
test_age = pd.get_dummies(test_data['Age_Cat'])
train_data.drop(['Age_Cat'],axis=1,inplace=True)
test_data.drop(['Age_Cat'],axis=1,inplace=True)
train_data = pd.concat([train_data,train_age],axis=1)
test_data = pd.concat([test_data,test_age],axis=1 ) | Titanic - Machine Learning from Disaster |
14,464,656 | df_predictions=df_predictions.sort_values(by='test_id' ).reset_index()
df_predictions=df_predictions.drop(['index'],axis=1)
df_predictions<filter> | sex1 = pd.get_dummies(train_data['Sex'])
sex2 = pd.get_dummies(test_data['Sex'])
train_data.drop(['Sex'],axis=1,inplace=True)
test_data.drop(['Sex'],axis=1,inplace=True)
train_data = pd.concat([train_data,sex1],axis=1)
test_data = pd.concat([test_data,sex2],axis=1)
| Titanic - Machine Learning from Disaster |
14,464,656 | df_predictions[df_predictions.test_id==535]<filter> | train_data.drop(['female'],axis=1,inplace=True)
test_data.drop(['female'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,464,656 | test[test.test_id==535]<sort_values> | train_data.rename(columns={'male':'gender'}, inplace = True)
test_data.rename(columns={'male':'gender'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,464,656 | df_category.sort_values(by='rmsle' )<save_to_csv> | pclass_age_map = {
1: 38,
2: 30,
3: 25,
}
def replace_age_na(x_df, fill_map):
cond=x_df['Age'].isna()
res =x_df.loc[cond,'Pclass'].map(fill_map)
x_df.loc[cond,'Age']=res
return x_df | Titanic - Machine Learning from Disaster |
14,464,656 | df_predictions.to_csv('ridge_submission.csv',index=False )<compute_test_metric> | train_data =(train_data.pipe(replace_age_na, pclass_age_map))
test_data =(test_data.pipe(replace_age_na, pclass_age_map)) | Titanic - Machine Learning from Disaster |
14,464,656 | def rmsle(y, y_pred):
assert len(y)== len(y_pred)
to_sum = [(math.log(y_pred[i] + 1)- math.log(y[i] + 1)) ** 2.0 for i,pred in enumerate(y_pred)]
return(sum(to_sum)*(1.0/len(y)))** 0.5
<load_from_csv> | Class_train = pd.get_dummies(train_data['Pclass'].astype(str))
Class_test = pd.get_dummies(test_data['Pclass'].astype(str))
train_data = pd.concat([train_data,Class_train],axis=1)
test_data = pd.concat([test_data,Class_test],axis=1)
| Titanic - Machine Learning from Disaster |
14,464,656 | print("Loading data...")
start_time = time.time()
train = pd.read_csv('.. /input/train.tsv', sep='\t')
test = pd.read_csv('.. /input/test.tsv', sep='\t')
train['target'] = np.log1p(train['price'])
print(train.shape)
print(test.shape)
test_len = test.shape[0]<categorify> | train_data.rename(columns = {'1':'Class 1', '2':'Class 2', '3':'Class 3'}, inplace = True)
test_data.rename(columns = {'1':'Class 1', '2':'Class 2', '3':'Class 3'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,464,656 | print("Handling missing values...")
def handle_missing(dataset):
dataset.category_name.fillna(value="", inplace=True)
dataset.brand_name.fillna(value="", inplace=True)
dataset.item_description.fillna(value="", inplace=True)
return(dataset)
train = handle_missing(train)
test = handle_missing(test)
print(train.sha... | Fare_0 = []
Fare_1 = []
for i in range(0,len(train_data["Fare"])) :
if train_data["Survived"][i] == 0:
Fare_0.append(train_data["Fare"][i])
else:
Fare_1.append(train_data["Fare"][i] ) | Titanic - Machine Learning from Disaster |
14,464,656 | print("Handling categorical variables...")
le = LabelEncoder()
le.fit(np.hstack([train.category_name, test.category_name]))
train['category'] = le.transform(train.category_name)
test['category'] = le.transform(test.category_name)
le.fit(np.hstack([train.brand_name, test.brand_name]))
train['brand'] = le.transform(tr... | test_data.loc[test_data['Fare'].isnull() ]
| Titanic - Machine Learning from Disaster |
14,464,656 | print("Text to seq process...")
raw_text = np.hstack([train.category_name.str.lower() ,
train.item_description.str.lower() ,
train.name.str.lower() ])
print(" Fitting tokenizer...")
tok_raw = Tokenizer()
tok_raw.fit_on_texts(raw_text)
print(" Transforming text to seq...")
train["seq_category_name"] = tok_raw.texts... | test_data.loc[test_data['Name']=='Storey, Mr.Thomas'] | Titanic - Machine Learning from Disaster |
14,464,656 | dtrain, dvalid = train_test_split(train, random_state=233, train_size=0.99)
print(dtrain.shape)
print(dvalid.shape )<define_variables> | embark1 = pd.get_dummies(train_data['Embarked'])
embark2 = pd.get_dummies(test_data['Embarked'])
train_data.drop(['Embarked'],axis=1,inplace=True)
test_data.drop(['Embarked'],axis=1,inplace=True)
train_data = pd.concat([train_data,embark1],axis=1)
test_data = pd.concat([test_data,embark2],axis=1 ) | Titanic - Machine Learning from Disaster |
14,464,656 | MAX_NAME_SEQ = max_name_seq
MAX_ITEM_DESC_SEQ = max_seq_item_description
MAX_CATEGORY_NAME_SEQ = max_seq_category_name
MAX_TEXT = np.max([np.max(train.seq_name.max())
, np.max(test.seq_name.max())
, np.max(train.seq_category_name.max())
, np.max(test.seq_category_name.max())
, np.max(train.seq_item_description.max(... | train_data.rename(columns = {'C':'Cherbourg', 'Q':'Queenstown', 'S':'Southampton'}, inplace = True)
test_data.rename(columns = {'C':'Cherbourg', 'Q':'Queenstown', 'S':'Southampton'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,464,656 | def get_keras_data(dataset):
X = {
'name': pad_sequences(dataset.seq_name, maxlen=MAX_NAME_SEQ)
,'item_desc': pad_sequences(dataset.seq_item_description
, maxlen=MAX_ITEM_DESC_SEQ)
,'brand': np.array(dataset.brand)
,'category': np.array(dataset.category)
,'category_name': pad_sequences(dataset.seq_category_name
, m... | def fam(x):
if(x['SibSp'] + x['Parch'])> 0:
return 1
else:
return 0
train_data['Family'] = train_data.apply(fam, axis = 1)
test_data['Family'] = test_data.apply(fam, axis = 1 ) | Titanic - Machine Learning from Disaster |
14,464,656 | Activation, concatenate, GRU, Embedding, Flatten
dr = 0.25
def get_model() :
dr_r = dr
name = Input(shape=[X_train["name"].shape[1]], name="name")
item_desc = Input(shape=[X_train["item_desc"].shape[1]], name="item_desc")
brand = Input(shape=[1], name="brand")
category = Input(shape=[1], name="category")
category_n... | train_data.drop(['SibSp','Parch'],axis=1, inplace = True)
test_data.drop(['SibSp','Parch'],axis=1, inplace = True ) | Titanic - Machine Learning from Disaster |
14,464,656 | def eval_model(model):
val_preds = model.predict(X_valid)
val_preds = np.expm1(val_preds)
y_true = np.array(dvalid.price.values)
y_pred = val_preds[:, 0]
v_rmsle = rmsle(y_true, y_pred)
return v_rmsle<find_best_params> | train_data["Cabin"] = pd.Series([i[0]
if not pd.isnull(i)
else 'X'
for i in train_data['Cabin'] ])
test_data["Cabin"] = pd.Series([i[0]
if not pd.isnull(i)
else 'X' for i in test_data['Cabin'] ] ) | Titanic - Machine Learning from Disaster |
14,464,656 | exp_decay = lambda init, fin, steps:(init/fin)**(1/(steps-1)) - 1
del train
gc.collect()<train_model> | Train_cabin = pd.get_dummies(train_data['Cabin'])
Test_cabin = pd.get_dummies(test_data['Cabin'])
train_data = pd.concat([train_data,Train_cabin],axis=1)
test_data = pd.concat([test_data,Test_cabin],axis=1)
| Titanic - Machine Learning from Disaster |
14,464,656 | epochs = 1
BATCH_SIZE = 512 * 3
steps = int(len(X_train['name'])/BATCH_SIZE)* epochs
lr_init, lr_fin = 0.013, 0.009
lr_decay = exp_decay(lr_init, lr_fin, steps)
model = get_model()
K.set_value(model.optimizer.lr, lr_init)
K.set_value(model.optimizer.decay, lr_decay)
history = model.fit(X_train, dtrain.target
, epoch... | train_title = [i.split(",")[1].split(".")[0].strip()
for i in train_data["Name"]]
train_data["Title"] = pd.Series(train_title)
test_title = [i.split(",")[1].split(".")[0].strip()
for i in test_data["Name"]]
test_data["Title"] = pd.Series(test_title ) | Titanic - Machine Learning from Disaster |
14,464,656 | v_rmsle = eval_model(model)
print(" RMSLE error on dev test: "+str(v_rmsle))
log_subname = '_'.join(['ep', str(epochs),
'bs', str(BATCH_SIZE),
'lrI', str(lr_init),
'lrF', str(lr_fin),
'dr', str(dr)] )<predict_on_test> | print('The list of titles for the passengers names are as follow
',train_data["Title"].value_counts() ) | Titanic - Machine Learning from Disaster |
14,464,656 | preds = model.predict(X_test, batch_size=BATCH_SIZE)
preds = np.expm1(preds)
submission = test[["test_id"]][:test_len]
submission["price"] = preds[:test_len]<save_to_csv> | print('The list of titles for the passengers names are as follow
',test_data["Title"].value_counts() ) | Titanic - Machine Learning from Disaster |
14,464,656 | submission.to_csv("sample_submission.csv", index=False)
print('[{}] Finished submission...'.format(time.time() - start_time))
<load_from_csv> | Train_title = pd.get_dummies(train_data['Title'])
Test_title = pd.get_dummies(test_data['Title'])
train_data = pd.concat([train_data,Train_title],axis=1)
test_data = pd.concat([test_data,Test_title],axis=1)
| Titanic - Machine Learning from Disaster |
14,464,656 | start_time = time.time()
df_train = pd.read_csv('.. /input/train.tsv', sep='\t')
df_test = pd.read_csv('.. /input/test.tsv', sep='\t')
df_train[df_train.price >= 3.0]
train_rows = len(df_train)
all_data = pd.concat([df_train, df_test])
print("[{}] Data concatenated.".format(time.time() - start_time))
def transform_... | Ticket1 = []
for i in list(train_data.Ticket):
if not i.isdigit() :
Ticket1.append(i.replace(".","" ).replace("/","" ).strip().split(' ')[0])
else:
Ticket1.append("X")
train_data["Ticket"] = Ticket1
Ticket2 = []
for j in list(test_data.Ticket):
if not j.isdigit() :
Ticket2.append(j.replace(".","" ).replace("/","" ).s... | Titanic - Machine Learning from Disaster |
14,464,656 | ridge_time = time.time()
data_train_X, data_val_X, data_train_Y, data_val_Y = train_test_split(train_X, Y_train)
print('[{}] Data splitted.'.format(time.time() - ridge_time))
clf1 = Ridge(alpha=5.3, fit_intercept=True, normalize=False,
copy_X=True, max_iter=None, tol=0.01, solver='auto', random_state=None)
clf1.fit(t... | Train_ticket = pd.get_dummies(train_data['Ticket'], prefix="T")
Test_ticket = pd.get_dummies(test_data['Ticket'], prefix="T")
train_data = pd.concat([train_data,Train_ticket],axis=1)
test_data = pd.concat([test_data,Test_ticket],axis=1)
| Titanic - Machine Learning from Disaster |
14,464,656 | lgb_time = time.time()
data_train_X, data_val_X, data_train_Y, data_val_Y = train_test_split(train_X, Y_train)
print('[{}] Data splitted.'.format(time.time() - lgb_time))
dataset_train = lgb.Dataset(data_train_X, label=data_train_Y)
dataset_val = lgb.Dataset(data_val_X, label=data_val_Y)
watchlist = [dataset_train, ... | train_data.drop(['Age','Cabin', 'Name', 'Title', 'Ticket'],axis=1,inplace=True)
test_data.drop(['Age','Cabin', 'Name', 'Title', 'Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,464,656 | final_time = time.time()
final_ridge_pred1 = clf1.predict(test_X)
print("[{}] First Ridge prediction completed.".format(time.time() - final_time))
final_ridge_pred2 = clf2.predict(test_X)
print("[{}] Second Ridge prediction completed.".format(time.time() - final_time))
final_lgb_pred = lgb_model.predict(test_X)
prin... | intersect_set = np.intersect1d(train_data.columns, test_data.columns)
print("Selected Features = ", intersect_set ) | Titanic - Machine Learning from Disaster |
14,464,656 |
<load_from_csv> | train_data_select = train_data[intersect_set]
print("Sum of NaN train dataset = ", train_data_select.isnull().sum().sum())
test_data_select = test_data[intersect_set]
print("Sum of NaN test dataset = ",test_data_select.isnull().sum().sum())
| Titanic - Machine Learning from Disaster |
14,464,656 | test_df=pd.read_csv('.. /input/test.tsv',sep='\t',quoting=3)
train_df=pd.read_csv('.. /input/train.tsv',sep='\t')
<count_missing_values> | X= preprocessing.StandardScaler().fit_transform(train_data_select ) | Titanic - Machine Learning from Disaster |
14,464,656 | train_df.isnull().any()<split> | y = train_data['Survived'] | Titanic - Machine Learning from Disaster |
14,464,656 | df_train=train_df
df_test=test_df<categorify> | from sklearn.pipeline import Pipeline
from sklearn import svm
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier, plot_tree
import xgboost as xgb
from sklearn.neighbors import KNeighborsClassifier
fr... | Titanic - Machine Learning from Disaster |
14,464,656 | df_train.category_name.fillna(value='missing',inplace=True)
df_train.brand_name.fillna(value='missing',inplace=True)
df_train.item_description.fillna(value='missing',inplace=True)
df_test.category_name.fillna(value='missing',inplace=True)
df_test.brand_name.fillna(value='missing',inplace=True)
df_test.item_descrip... | KFold_Score = pd.DataFrame()
classifiers = ['KNeighborsClassifier','Radial SVM', 'LogisticRegression',
'DecisionTreeClassifier', 'RandomForestClassifier', 'AdaBoostClassifier',
'XGBoostClassifier']
models = [KNeighborsClassifier() ,
svm.SVC(kernel='rbf'),
LogisticRegression(max_iter = 1000),
DecisionTreeClassifier(rand... | Titanic - Machine Learning from Disaster |
14,464,656 | def split_txt(text):
if text=='missing':
return ['missing']*3
else:
return text.split('/' )<feature_engineering> | mean = pd.DataFrame(KFold_Score.mean() , index= classifiers)
KFold_Score = pd.concat([KFold_Score,mean.T])
KFold_Score.index=['Fold 1','Fold 2','Fold 3','Fold 4','Fold 5','Mean']
KFold_Score.T.sort_values(by=['Mean'], ascending = False ) | Titanic - Machine Learning from Disaster |
14,464,656 | df_train['cat1'],df_train['cat2'],df_train['cat3']=zip(*df_train.category_name.apply(lambda x: split_txt(x)))
df_test['cat1'],df_test['cat2'],df_test['cat3']=zip(*df_test.category_name.apply(lambda x: split_txt(x)) )<import_modules> | X_test = preprocessing.StandardScaler().fit_transform(test_data_select ) | Titanic - Machine Learning from Disaster |
14,464,656 | from keras.preprocessing.text import Tokenizer
from keras.preprocessing.text import text_to_word_sequence<feature_engineering> | rfc = RandomForestClassifier(n_estimators=200, random_state=42, max_depth = 5 ) | Titanic - Machine Learning from Disaster |
14,464,656 | Token=Tokenizer()
text_all=np.hstack([df_train.item_description.str.lower() ,df_train.name.str.lower() ])
Token.fit_on_texts(text_all)
df_train['name_sequence']=Token.texts_to_sequences(df_train.name)
df_train['item_des_sequence']=Token.texts_to_sequences(df_train.item_description)
df_test['name_sequence']=Token.te... | param_grid = {
'n_estimators': [ 100, 200,300],
'max_features': ['auto', 'sqrt'],
'max_depth' : [5, 6,7,8],
'criterion' :['gini', 'entropy']
} | Titanic - Machine Learning from Disaster |
14,464,656 | from keras.models import Model
from keras.layers import Input,Embedding, Dense, Dropout,Recurrent,Flatten,concatenate,GRU<categorify> | CV_rfc = GridSearchCV(estimator=rfc, param_grid=param_grid, cv= 5)
CV_rfc.fit(X,y)
CV_rfc.best_params_ | Titanic - Machine Learning from Disaster |
14,464,656 | Le_cat1=LabelEncoder()
Le_cat2=LabelEncoder()
Le_cat3=LabelEncoder()
Le_brand=LabelEncoder()
raw_cat1=np.hstack([np.array(df_train.cat1),np.array(df_test.cat1)])
raw_cat2=np.hstack([np.array(df_train.cat2),np.array(df_test.cat2)])
raw_cat3=np.hstack([np.array(df_train.cat3),np.array(df_test.cat3)])
raw_brand=np.hsta... | select_rfc = RandomForestClassifier(random_state=42, n_estimators= 100, criterion = 'entropy',max_features = 'auto',max_depth = 8)
select_rfc.fit(X, y ) | Titanic - Machine Learning from Disaster |
14,464,656 | max_name_seq = 10
max_item_desc = 75
max_text = np.max([np.max(df_train.name_sequence.max())
, np.max(df_test.name_sequence.max())
, np.max(df_train.item_des_sequence.max())
, np.max(df_test.item_des_sequence.max())])+5
max_cat1 = np.max([df_train.cat1.max() , df_test.cat1.max() ])+1
max_cat2 = np.max([df_train.cat2... | y_test = select_rfc.predict(X_test)
print(y_test ) | Titanic - Machine Learning from Disaster |
14,464,656 | name=Input(shape=[train_keras['name'].shape[1]],name='name')
item_desc=Input(shape=[train_keras['item_desc'].shape[1]],name='item_desc')
brand_name=Input(shape=[train_keras['brand_name'].shape[1]],name='brand_name')
cat1=Input(shape=[train_keras['cat1'].shape[1]],name='cat1')
cat2=Input(shape=[train_keras['cat2'].s... | test_data2 = pd.read_csv('.. /input/titanic/test.csv')
my_submission = pd.DataFrame({'PassengerId': test_data2.PassengerId,'Survived': y_test})
my_submission.to_csv('submission.csv', index=False)
my_submission.head() | Titanic - Machine Learning from Disaster |
14,319,415 | Embed_name=Embedding(max_text,output_dim=30 )(name)
Embed_desc=Embedding(max_text,output_dim=30 )(item_desc)
Embed_brand=Embedding(max_brand,output_dim=10 )(brand_name)
Embed_cat1=Embedding(max_cat1,output_dim=10 )(cat1)
Embed_cat2=Embedding(max_cat2,output_dim=20 )(cat2)
Embed_cat3=Embedding(max_cat3,output_dim=2... | df_train = pd.read_csv("/kaggle/input/titanic/train.csv")
df_test = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
14,319,415 | rnn_name=GRU(24 )(Embed_name)
rnn_desc=GRU(24 )(Embed_desc )<concatenate> | features = ['Sex','Pclass','SibSp','Parch']
X_train = pd.get_dummies(df_train[features])
X_train['Age'] = df_train['Age']
X_test = pd.get_dummies(df_test[features])
X_test['Age'] = df_test['Age']
| Titanic - Machine Learning from Disaster |
14,319,415 | model=concatenate([rnn_name,rnn_desc,
Flatten()(Embed_brand),Flatten()(Embed_cat1),Flatten()(Embed_cat2),
Flatten()(Embed_cat3),item_condition,ship] )<choose_model_class> | X_train['Age'] = np.where(X_train['Age'].isnull() ,X_train['Age'].median() ,X_train['Age'] ) | Titanic - Machine Learning from Disaster |
14,319,415 | model1=Dropout(rate=0.1 )(Dense(128 )(model))
model2=Dropout(rate=0.1 )(Dense(16 )(model1))
output=Dense(1,activation='linear' )(model2 )<create_dataframe> | X_test['Age']= np.where(X_test['Age'].isnull() ,X_test['Age'].median() ,X_test['Age'] ) | Titanic - Machine Learning from Disaster |
14,319,415 | model_keras=Model([name,item_desc,brand_name,cat1,
cat2,cat3,item_condition,ship],output )<choose_model_class> | y_train = df_train['Survived']
X_train
X_test | Titanic - Machine Learning from Disaster |
14,319,415 | model_keras.compile(optimizer='adam',loss=['mse'],metrics=['mae'] )<prepare_x_and_y> | clf = RandomForestClassifier(max_depth=5,random_state=1)
clf.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
14,319,415 | sc_x=StandardScaler()
y=sc_x.fit_transform(np.log(x_train.price.reshape(-1,1)+1))
y_valid=sc_x.transform(np.log(x_valid.price.reshape(-1,1)+1))<train_model> | y_test = clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,319,415 | model_keras.fit(train_keras,y,batch_size=20000,epochs=5 )<predict_on_test> | output = pd.DataFrame({'PassengerId':df_test['PassengerId'],'Survived':y_test} ) | Titanic - Machine Learning from Disaster |
14,319,415 | <prepare_output><EOS> | output.to_csv("titanic_a2.csv",index=False ) | Titanic - Machine Learning from Disaster |
14,301,160 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import math
| Titanic - Machine Learning from Disaster |
14,301,160 | write_csv=pd.DataFrame({'test_id':test_df.test_id,
'price':predict_2_price.reshape(predict_2_price.shape[0])} )<create_dataframe> | gender_df= pd.read_csv('.. /input/titanic/gender_submission.csv')
train_df = pd.read_csv('.. /input/titanic/train.csv')
print(train_df.isnull().sum(axis = 0))
| Titanic - Machine Learning from Disaster |
14,301,160 | write_csv2=pd.DataFrame({'test_id':write_csv.test_id,
'price':write_csv.price} )<load_from_csv> | si = SimpleImputer(strategy="most_frequent")
inputerResult = si.fit_transform(train_df[['Embarked']])
train_df['Embarked'] = inputerResult
si = SimpleImputer(strategy="mean")
inputerResult = si.fit_transform(train_df[['Age']])
train_df['Age'] = inputerResult
train_df["Age"] = train_df['Age'].map(lambda x: '{:.2f}'.... | Titanic - Machine Learning from Disaster |
14,301,160 | sam=pd.read_csv('.. /input/sample_submission.csv' )<save_to_csv> | print(train_df.isnull().sum(axis = 0))
| Titanic - Machine Learning from Disaster |
14,301,160 | write_csv2.to_csv('sample_submission.csv',index=False )<compute_test_metric> | def binAge(row):
if row['Sex'] == 'male':
if float(row['Age'])< 16:
return 'alive'
else:
return 'dead'
else:
return 'itsFemale'
train_df['bin_male_age'] = train_df.apply(binAge, axis=1 ) | Titanic - Machine Learning from Disaster |
14,301,160 | def rmsle(y_true, yz_pred):
assert len(y_true)== len(y_pred)
return(np.square(np.log(y_pred + 1)- np.log(y_true + 1)).mean())**0.5
<load_from_csv> | def withNanny(row):
if float(row['Parch'])== 0 and float(row['Age'])< 18:
return 'with'
elif float(row['Parch'])!= 0 and float(row['Age'])< 18:
return 'without'
else:
return 'adult'
train_df['withNanny'] = train_df.apply(withNanny, axis=1 ) | Titanic - Machine Learning from Disaster |
14,301,160 | print("Loading data...")
train = pd.read_csv('.. /input/train.tsv', sep='\t')
test = pd.read_csv('.. /input/test.tsv', sep='\t')
train['target'] = np.log1p(train['price'])
print(train.shape)
print(test.shape )<categorify> | print("Only {}% of data have Cabin number".format(100 - train_df.Cabin.isnull().sum(axis = 0)*100/len(train_df.Cabin)) ) | Titanic - Machine Learning from Disaster |
14,301,160 | print("Handling missing values...")
def handle_missing(dataset):
dataset.category_name.fillna(value="missing", inplace=True)
dataset.brand_name.fillna(value="missing", inplace=True)
dataset.item_description.fillna(value="missing", inplace=True)
return(dataset)
train = handle_missing(train)
test = handle_missing(t... | features = [ 'Age', 'SibSp', 'Parch', 'Fare']
cat_features = ['Embarked', 'Sex','Pclass' , 'withNanny']
todo = ['Cabin', 'Ticket'] | Titanic - Machine Learning from Disaster |
14,301,160 | print("Handling categorical variables...")
le = LabelEncoder()
le.fit(np.hstack([train.category_name, test.category_name]))
train['category'] = le.transform(train.category_name)
test['category'] = le.transform(test.category_name)
le.fit(np.hstack([train.brand_name, test.brand_name]))
train['brand_name'] = le.transfo... | base_model = train_df[features]
cat_df = train_df[cat_features] | Titanic - Machine Learning from Disaster |
14,301,160 | print("Text to seq process...")
print(" Fitting tokenizer...")
raw_text = np.hstack([train.category_name.str.lower() ,
train.item_description.str.lower() ,
train.name.str.lower() ])
tok_raw = Tokenizer()
tok_raw.fit_on_texts(raw_text)
print(" Transforming text to seq...")
train["seq_category_name"] = tok_raw.texts... | data = pd.get_dummies(cat_df, columns=['Embarked'], prefix="Embarked", drop_first=True)
data = pd.get_dummies(data, columns=['Sex'], prefix="Sex", drop_first=True)
data = pd.get_dummies(data, columns=['Pclass'], prefix="Pclass", drop_first=True)
data = pd.get_dummies(data, columns=['withNanny'], prefix="withNanny", ... | Titanic - Machine Learning from Disaster |
14,301,160 | MAX_NAME_SEQ = 15
MAX_ITEM_DESC_SEQ = 65
MAX_CATEGORY_NAME_SEQ = 20
MAX_TEXT = np.max([np.max(train.seq_name.max())
, np.max(test.seq_name.max())
, np.max(train.seq_category_name.max())
, np.max(test.seq_category_name.max())
, np.max(train.seq_item_description.max())
, np.max(test.seq_item_description.max())])+2
M... | X_train, X_test, y_train, y_test = train_test_split(data, train_df.Survived, test_size = 0.25, random_state = 0 ) | Titanic - Machine Learning from Disaster |
14,301,160 | train["target"] = np.log(train.price+1)
target_scaler = MinMaxScaler(feature_range=(-1, 1))
train["target"] = target_scaler.fit_transform(train.target.reshape(-1,1))
pd.DataFrame(train.target ).hist()<split> | classifier = SVC(kernel='rbf', random_state = 123)
classifier.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
14,301,160 | dtrain, dvalid = train_test_split(train, random_state=123, train_size=0.985)
print(dtrain.shape)
print(dvalid.shape )<string_transform> | y_pred = classifier.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,301,160 | def get_keras_data(dataset):
X = {
'name': pad_sequences(dataset.seq_name, maxlen=MAX_NAME_SEQ)
,'item_desc': pad_sequences(dataset.seq_item_description, maxlen=MAX_ITEM_DESC_SEQ)
,'brand_name': np.array(dataset.brand_name)
,'category': np.array(dataset.category)
,'category_name': pad_sequences(dataset.seq_category... | accuracy_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
14,301,160 | def get_callbacks(filepath, patience=2):
es = EarlyStopping('val_loss', patience=patience, mode="min")
msave = ModelCheckpoint(filepath, save_best_only=True)
return [es, msave]
def rmsle_cust(y_true, y_pred):
first_log = K.log(K.clip(y_pred, K.epsilon() , None)+ 1.)
second_log = K.log(K.clip(y_true, K.epsilon() , Non... | test_df = pd.read_csv('.. /input/titanic/test.csv')
print(test_df.isnull().sum(axis = 0))
| Titanic - Machine Learning from Disaster |
14,301,160 | BATCH_SIZE = 512 * 3
epochs = 2
model = get_model()
model.fit(X_train, dtrain.target, epochs=epochs, batch_size=BATCH_SIZE
, validation_data=(X_valid, dvalid.target)
, verbose=1 )<compute_train_metric> | si = SimpleImputer(strategy="mean")
inputerResult = si.fit_transform(test_df[['Age']])
test_df['Age'] = inputerResult | Titanic - Machine Learning from Disaster |
14,301,160 | val_preds = model.predict(X_valid)
val_preds = target_scaler.inverse_transform(val_preds)
val_preds = np.exp(val_preds)+1
y_true = np.array(dvalid.price.values)
y_pred = val_preds[:,0]
v_rmsle = rmsle(y_true, y_pred)
print(" RMSLE error on dev test: "+str(v_rmsle))<predict_on_test> | test_df['bin_male_age'] = test_df.apply(binAge, axis=1)
test_df['withNanny'] = test_df.apply(withNanny, axis=1 ) | Titanic - Machine Learning from Disaster |
14,301,160 | preds = model.predict(X_test, batch_size=BATCH_SIZE)
preds = target_scaler.inverse_transform(preds)
preds = np.exp(preds)-1
submission = test[["test_id"]]
submission["price"] = preds<save_to_csv> | base_model = test_df[features]
cat_df = test_df[cat_features]
data = pd.get_dummies(cat_df, columns=['Embarked'], prefix="Embarked", drop_first=True)
data = pd.get_dummies(data, columns=['Sex'], prefix="Sex", drop_first=True)
data = pd.get_dummies(data, columns=['Pclass'], prefix="Pclass", drop_first=True)
data = pd... | Titanic - Machine Learning from Disaster |
14,301,160 | submission.to_csv("./NNsubmission.csv", index=False)
submission.price.hist()
<init_hyperparams> | y_pred = classifier.predict(data ) | Titanic - Machine Learning from Disaster |
14,301,160 | start_time = time.time()
def avg_predictions(L):
N = len(L)
f = L[0]
for p in range(1,N):
f = f + L[p]
f =(1/N)*f
return f
def define_model(data, nodes1, nodes2, drop1, drop2):
x = Input(shape =(data.shape[1],), dtype = 'float32', sparse = True)
d1 = Dense(nodes1, activation='relu' )(x)
d2 = Dropout(drop1 )(d1)
d3 ... | resultDF = pd.DataFrame(index=test_df.index ) | Titanic - Machine Learning from Disaster |
14,301,160 | import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
import xgboost as xgb
import operator<load_from_csv> | resultDF['PassengerId'] = pd.Series(test_df['PassengerId'], index=resultDF.index, dtype=int)
resultDF['Survived'] = pd.Series(y_pred, index=resultDF.index, dtype=int ) | Titanic - Machine Learning from Disaster |
14,301,160 | df_train = pd.read_csv('.. /input/train_users_2.csv')
df_test = pd.read_csv('.. /input/test_users.csv')
labels = df_train['country_destination'].values
df_train = df_train.drop(['country_destination'], axis=1)
id_test = df_test['id']
piv_train = df_train.shape[0]<concatenate> | for index, row in test_df.iterrows() :
resultDF['PassengerId'][index] = row.PassengerId | Titanic - Machine Learning from Disaster |
14,301,160 | <feature_engineering><EOS> | resultDF.to_csv('out.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,861,851 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | np.random.seed(0)
rn.seed(0)
colors = ["red", "blue", "orange", "pink"]
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
13,861,851 | tfa = np.vstack(
df_all.timestamp_first_active.astype(str ).apply(
lambda x: list(map(int, [x[:4], x[4:6], x[6:8],
x[8:10], x[10:12],
x[12:14]]))
).values
)
df_all['tfa_year'] = tfa[:,0]
df_all['tfa_month'] = tfa[:,1]
df_all['tfa_day'] = tfa[:,2]
df_all = df_all.drop(['timestamp_first_active'], axis=1 )<categorify> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head()
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,861,851 | ohe_feats = ['gender', 'signup_method', 'signup_flow', 'language',
'affiliate_channel', 'affiliate_provider',
'first_affiliate_tracked', 'signup_app',
'first_device_type', 'first_browser']
for f in ohe_feats:
df_all_dummy = pd.get_dummies(df_all[f], prefix=f)
df_all = df_all.drop([f], axis=1)
df_all = pd.concat(( df_... | print("Train data missing value count for each feature")
print(train_data.isnull().sum())
print("Test data missing value count for each feature")
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
13,861,851 | X = df_all.iloc[:piv_train,:]
le = LabelEncoder()
y = le.fit_transform(labels)
X_test = df_all.iloc[piv_train:,:]<train_model> | missing_value_fill_method = "2.3" | Titanic - Machine Learning from Disaster |
13,861,851 | params = {'eta': 0.1,
'max_depth': 8,
'nround': 100,
'subsample': 0.7,
'colsample_bytree': 0.8,
'seed': 1,
'objective': 'multi:softprob',
'eval_metric':'ndcg',
'num_class': 12,
'nthread':3}
num_boost_round = 10
dtrain = xgb.DMatrix(X, y)
clf1 = xgb.train(params=params, dtrain=dtrain, num_boost_round=num_boost_round )<... | if missing_value_fill_method == "2.2":
train_data.fillna(train_data.mean() , inplace=True)
print(train_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
13,861,851 | importance = clf1.get_fscore()
importance_df = pd.DataFrame(
sorted(importance.items() , key=operator.itemgetter(1)) ,
columns=['feature','fscore']
)<save_to_csv> | if missing_value_fill_method == "2.3":
train_data["Age"] = train_data.groupby(["Pclass", "Sex"])["Age"].apply(lambda x: x.fillna(x.mean()))
test_data["Age"] = test_data.groupby(["Pclass", "Sex"])["Age"].apply(lambda x: x.fillna(x.mean()))
| Titanic - Machine Learning from Disaster |
13,861,851 | ids = []
cts = []
for i in range(len(id_test)) :
idx = id_test[i]
ids += [idx] * 5
cts += le.inverse_transform(np.argsort(y_pred[i])[::-1])[:5].tolist()
sub = pd.DataFrame(np.column_stack(( ids, cts)) , columns=['id', 'country'])
sub.to_csv('sub.csv',index=False )<import_modules> | if missing_value_fill_method == "2.3":
train_data["Cabin"] = train_data["Cabin"].apply(lambda s: s[0] if pd.notnull(s)and s[0]!= "T" else "N")
test_data["Cabin"] = test_data["Cabin"].apply(lambda s: s[0] if pd.notnull(s)and s[0]!= "T" else "N" ) | Titanic - Machine Learning from Disaster |
13,861,851 | import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from xgboost.sklearn import XGBClassifier<define_variables> | if missing_value_fill_method == "2.3":
print(train_data.groupby(["Pclass"])["Cabin"].value_counts() ) | Titanic - Machine Learning from Disaster |
13,861,851 | np.random.seed(0 )<load_from_csv> | if missing_value_fill_method == "2.3":
train_data.loc[(train_data["Pclass"] == 1)&(train_data["Cabin"] == "N"), "Cabin"]= "C"
train_data.loc[(( train_data["Pclass"] == 2)|(train_data["Pclass"] == 3)) &(train_data["Cabin"] == "N"), "Cabin"]= "F"
test_data.loc[(test_data["Pclass"] == 1)&(test_data["Cabin"] == "N"), "Cabi... | Titanic - Machine Learning from Disaster |
13,861,851 | df_train = pd.read_csv('.. /input/train_users_2.csv')
df_test = pd.read_csv('.. /input/test_users.csv')
labels = df_train['country_destination'].values
df_train = df_train.drop(['country_destination'], axis=1)
id_test = df_test['id']
piv_train = df_train.shape[0]<concatenate> | if missing_value_fill_method == "2.3":
print(test_data.loc[test_data["Fare"].isnull() ] ) | Titanic - Machine Learning from Disaster |
13,861,851 | df_all = pd.concat(( df_train, df_test), axis=0, ignore_index=True)
df_all = df_all.drop(['id', 'date_first_booking'], axis=1)
df_all = df_all.fillna(-1 )<feature_engineering> | if missing_value_fill_method == "2.3":
sample_fare = test_data.loc[(test_data["Pclass"] == 3)&(test_data["SibSp"] == 0)&(test_data["Embarked"] == "S")][
"Fare"].mean()
print(sample_fare)
test_data.loc[test_data["Fare"].isnull() , "Fare"] = sample_fare | Titanic - Machine Learning from Disaster |
13,861,851 | dac = np.vstack(df_all.date_account_created.astype(str ).apply(lambda x: list(map(int, x.split('-')))).values)
df_all['dac_year'] = dac[:,0]
df_all['dac_month'] = dac[:,1]
df_all['dac_day'] = dac[:,2]
df_all = df_all.drop(['date_account_created'], axis=1 )<feature_engineering> | if missing_value_fill_method == "2.3":
print(train_data.loc[train_data["Embarked"].isnull() ])
print(test_data.loc[train_data["Embarked"].isnull() ] ) | Titanic - Machine Learning from Disaster |
13,861,851 | tfa = np.vstack(df_all.timestamp_first_active.astype(str ).apply(lambda x: list(map(int, [x[:4],x[4:6],x[6:8],x[8:10],x[10:12],x[12:14]])) ).values)
df_all['tfa_year'] = tfa[:,0]
df_all['tfa_month'] = tfa[:,1]
df_all['tfa_day'] = tfa[:,2]
df_all = df_all.drop(['timestamp_first_active'], axis=1 )<feature_engineering> | if missing_value_fill_method == "2.3":
print(train_data.loc[train_data["Embarked"].isnull() ].head())
print(train_data.loc[(train_data["Pclass"] == 1)&(train_data["Fare"] <= 80.0)&(train_data['Cabin'] == "B")][
"Embarked"].value_counts())
train_data.loc[train_data["Embarked"].isnull() , "Embarked"] = "S" | Titanic - Machine Learning from Disaster |
13,861,851 | av = df_all.age.values
df_all['age'] = np.where(np.logical_or(av<14, av>100), -1, av )<categorify> | print(train_data.isnull().sum())
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
13,861,851 | ohe_feats = ['gender', 'signup_method', 'signup_flow', 'language', 'affiliate_channel', 'affiliate_provider', 'first_affiliate_tracked', 'signup_app', 'first_device_type', 'first_browser']
for f in ohe_feats:
df_all_dummy = pd.get_dummies(df_all[f], prefix=f)
df_all = df_all.drop([f], axis=1)
df_all = pd.concat(( df_... | ser_age, bin_age = pd.cut(train_data["Age"].astype(int), 5, retbins=True, labels=False)
test_data["Age"] = pd.cut(test_data["Age"], bins=bin_age, labels=False, include_lowest=True)
train_data["Age"] = ser_age
train_data["Age"] = train_data["Age"].astype("category")
test_data["Age"] = test_data["Age"].astype("categor... | Titanic - Machine Learning from Disaster |
13,861,851 | vals = df_all.values
X = vals[:piv_train]
le = LabelEncoder()
y = le.fit_transform(labels)
X_test = vals[piv_train:]<train_model> | train_data["Family_Size"] = train_data["SibSp"] + train_data["Parch"]
test_data["Family_Size"] = test_data["SibSp"] + test_data["Parch"]
family_size_surv_mean = train_data.groupby(by="Family_Size")["Survived"].mean()
print(family_size_surv_mean ) | Titanic - Machine Learning from Disaster |
13,861,851 | xgb = XGBClassifier(max_depth = 8, learning_rate = 0.3, n_estimators = 25,
objective='multi:softprob', subsample=0.5, colsample_bytree=0.5, seed=0)
xgb.fit(X, y)
y_pred = xgb.predict_proba(X_test )<save_to_csv> | train_data["Travelled_Together"] = train_data.groupby(by='Ticket')['Ticket'].transform('count')
test_data["Travelled_Together"] = test_data.groupby(by='Ticket')['Ticket'].transform('count' ) | Titanic - Machine Learning from Disaster |
13,861,851 | ids = []
cts = []
for i in range(len(id_test)) :
idx = id_test[i]
ids += [idx] * 5
cts += le.inverse_transform(np.argsort(y_pred[i])[::-1])[:5].tolist()
sub = pd.DataFrame(np.column_stack(( ids, cts)) , columns=['id', 'country'])
sub.to_csv('subXgb.csv',index=False )<import_modules> | train_data["Title"] = train_data["Name"].str.split(",", expand=True)[1].str.split(".", expand=True)[0]
test_data["Title"] = test_data["Name"].str.split(",", expand=True)[1].str.split(".", expand=True)[0]
title_counts = train_data["Title"].value_counts() < 10
train_data["Title"] = train_data["Title"].apply(lambda x: "Ge... | Titanic - Machine Learning from Disaster |
13,861,851 | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import gc<load_from_csv> | train_data["Marry_Status"] = 0
train_data["Marry_Status"].loc[train_data["Title"].str.strip() == "Mrs"] = 1
train_data["Marry_Status"] = train_data["Marry_Status"].astype("category")
test_data["Marry_Status"] = 0
test_data["Marry_Status"].loc[test_data["Title"].str.strip() == "Mrs"] = 1
test_data["Marry_Status"] = tes... | Titanic - Machine Learning from Disaster |
13,861,851 | train_identity = pd.read_csv('.. /input/train_identity.csv')
train_transaction = pd.read_csv('.. /input/train_transaction.csv' )<count_values> | train_data["Pclass"] = train_data["Pclass"].astype("category")
test_data["Pclass"] = test_data["Pclass"].astype("category")
y = train_data["Survived"] | Titanic - Machine Learning from Disaster |
13,861,851 | train_transaction['isFraud'].value_counts()<merge> | features = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Cabin", "Embarked", "Family_Size",
"Travelled_Together", "Title", "Marry_Status"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features] ) | Titanic - Machine Learning from Disaster |
13,861,851 | train = train_transaction.merge(train_identity, on='TransactionID', how='left')
del train_identity, train_transaction
gc.collect()<load_from_csv> | chosed_model = "rf"
if chosed_model == "dp":
model = Sequential()
model.add(Dense(10, input_dim=36, activation='tanh'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, epochs=100, batch_size=5, verbose=0)
predictions = model.p... | Titanic - Machine Learning from Disaster |
13,861,851 | <data_type_conversions><EOS> | if(chosed_model=="rf")|(chosed_model == "xboost"):
df_xboost = pd.read_csv('/kaggle/working/my_submission_xboost.csv')
df_rf = pd.read_csv('/kaggle/working/my_submission_rf.csv')
df_ensemble = df_xboost.copy()
k = 'Survived'
df_ensemble[k] = 0.5 * df_xboost[k] + 0.7 * df_rf[k]
df_ensemble[k] = df_ensemble[k].apply(la... | Titanic - Machine Learning from Disaster |
14,420,076 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
14,420,076 | train['id_02_bins'] = train['id_02']
train['id_02_bins'] = pd.cut(train['id_02_bins'], 10, labels=False)
test['id_02_bins'] = test['id_02']
test['id_02_bins'] = pd.cut(test['id_02_bins'], 10, labels=False )<data_type_conversions> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
all_data = [train,test] | Titanic - Machine Learning from Disaster |
14,420,076 | train['id_11_flag'] = np.where(train['id_11'].isnull() ,'F','T')
test['id_11_flag'] = np.where(test['id_11'].isnull() ,'F','T')
train['id_11_flag'] = train['id_11_flag'].astype('category')
test['id_11_flag'] = test['id_11_flag'].astype('category')
train['id_11_residual'] = train['id_11']
train['id_11_residual'] = n... | print(train[['Pclass', 'Sex']].groupby(['Sex'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
14,420,076 | train['Transaction_DOW'] = np.floor(( train['TransactionDT'] /(3600 * 24)- 1)% 7)
test['Transaction_DOW'] = np.floor(( test['TransactionDT'] /(3600 * 24)- 1)% 7)
train['Transaction_H'] = np.floor(train['TransactionDT'] / 3600)% 24
test['Transaction_H'] = np.floor(test['TransactionDT'] / 3600)% 24<set_options> | print(train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
14,420,076 | warnings.filterwarnings("ignore" )<define_variables> | women = train.loc[train.Sex == 'female']['Survived']
rate_women = sum(women)/len(women)
print('The rate of survival for women is:', rate_women ) | Titanic - Machine Learning from Disaster |
14,420,076 | cat_types = ['ProductCD','card1','card2','card3','card4','card5','card6','addr1','addr2','P_emaildomain','R_emaildomain',
'M1','M2','M3','M4','M5','M6','M7','M8','M9','DeviceType','DeviceInfo','id_12','id_13','id_14','id_15','id_16',
'id_17','id_18','id_19','id_20','id_21','id_22','id_23','id_24','id_25','id_26','id_27... | men = train.loc[train.Sex == 'male']['Survived']
rate_men = sum(men)/len(men)
print('The rate of survival for men is:', rate_men ) | Titanic - Machine Learning from Disaster |
14,420,076 | train = train.fillna(-999 )<categorify> | for dataset in all_data:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1 | 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.