kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,589,439 | <groupby><EOS> | best_model.fit(x_train,y_train)
answer = pd.DataFrame(best_model.predict(test_df))
test_file = pd.read_csv('.. /input/titanic/test.csv')
answer['PassengerId']= test_file.PassengerId.tolist()
answer.set_index('PassengerId',inplace=True)
answer.columns=['Survived']
answer.Survived = answer.Survived.astype('int')
answ... | Titanic - Machine Learning from Disaster |
13,429,461 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<rename_columns> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
13,429,461 | content_explation_agg=content_explation_agg.unstack()
content_explation_agg=content_explation_agg.reset_index()
content_explation_agg.columns = ['content_id', 'content_explation_false_mean','content_explation_true_mean']<data_type_conversions> | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,429,461 | content_explation_agg.content_id=content_explation_agg.content_id.astype('int16')
content_explation_agg.content_explation_false_mean=content_explation_agg.content_explation_false_mean.astype('float16')
content_explation_agg.content_explation_true_mean=content_explation_agg.content_explation_true_mean.astype('float16'... | train_data.drop(['Cabin'], axis=1, inplace=True)
test_data.drop(['Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,429,461 | print('start handle attempt_no...' )<data_type_conversions> | whole_data = train_data.append(test_data)
whole_data['Title'] = whole_data.Name.str.extract(r'([A-Za-z]+)\.', expand=False)
whole_data.Title.value_counts() | Titanic - Machine Learning from Disaster |
13,429,461 | train_df["attempt_no"] = 1
train_df.attempt_no=train_df.attempt_no.astype('int8')
attempt_no_agg=train_df.groupby(["user_id","content_id"])["attempt_no"].agg(['sum'] ).astype('int8')
train_df["attempt_no"] = train_df[["user_id","content_id",'attempt_no']].groupby(["user_id","content_id"])["attempt_no"].cumsum()<data_... | Common_Title = ['Mr', 'Miss', 'Mrs', 'Master']
whole_data['Title'].replace(['Ms', 'Mlle', 'Mme'], 'Miss', inplace=True)
whole_data['Title'].replace(['Lady'], 'Mrs', inplace=True)
whole_data['Title'].replace(['Sir', 'Rev'], 'Mr', inplace=True)
whole_data['Title'][~whole_data.Title.isin(Common_Title)] = 'Others' | Titanic - Machine Learning from Disaster |
13,429,461 | print('start handle timestamp...')
prior_question_elapsed_time_mean=train_df['prior_question_elapsed_time'].mean()
train_df['prior_question_elapsed_time'].fillna(prior_question_elapsed_time_mean, inplace=True )<data_type_conversions> | AgeMedian_by_titles = train_data.groupby('Title')['Age'].median()
AgeMedian_by_titles | Titanic - Machine Learning from Disaster |
13,429,461 | max_timestamp_u = train_df[['user_id','timestamp']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u.columns = ['user_id', 'max_time_stamp']
max_timestamp_u.user_id=max_timestamp_u.user_id.astype('int32' )<data_type_conversions> | for title in AgeMedian_by_titles.index:
train_data['Age'][(train_data.Age.isnull())&(train_data.Title == title)] = AgeMedian_by_titles[title]
test_data['Age'][(test_data.Age.isnull())&(test_data.Title == title)] = AgeMedian_by_titles[title] | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime'] = train_df.groupby('user_id')['timestamp'].shift()
max_timestamp_u2 = train_df[['user_id','lagtime']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u2.columns = ['user_id', 'max_time_stamp2']
max_timestamp_u2.user_id=max_timestamp_u2.user_id.astype('int32' )<feature_engineering> | train_data['Embarked'].fillna(train_data.Embarked.mode() [0], inplace=True ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime']=train_df['timestamp']-train_df['lagtime']
lagtime_mean=train_df['lagtime'].mean()
train_df['lagtime'].fillna(lagtime_mean, inplace=True )<data_type_conversions> | test_data['Fare'].fillna(test_data['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime']=train_df['lagtime']/(1000*3600)
train_df.lagtime=train_df.lagtime.astype('float32' )<data_type_conversions> | train_data.loc[train_data.Fare>512, 'Fare'] = 263
train_data.Fare.sort_values(ascending=False ).head(5 ) | Titanic - Machine Learning from Disaster |
13,429,461 |
<data_type_conversions> | train_data['Sex_Code'] = train_data['Sex'].map({'female':1, 'male':0} ).astype('int')
test_data['Sex_Code'] = test_data['Sex'].map({'female':1, 'male':0} ).astype('int' ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime2'] = train_df.groupby('user_id')['timestamp'].shift(2)
max_timestamp_u3 = train_df[['user_id','lagtime2']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u3.columns = ['user_id', 'max_time_stamp3']
max_timestamp_u3.user_id=max_timestamp_u3.user_id.astype('int32')
train_df['lagtime2'... | train_data['Embarked_Code'] = train_data['Embarked'].map({'S':0, 'C':1, 'Q':2} ).astype('int')
test_data['Embarked_Code'] = test_data['Embarked'].map({'S':0, 'C':1, 'Q':2} ).astype('int' ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime2']=train_df['lagtime2']/(1000*3600)
train_df.lagtime2=train_df.lagtime2.astype('float32' )<data_type_conversions> | train_data['FareBin_5'] = pd.qcut(train_data['Fare'], 5)
test_data['FareBin_5'] = pd.qcut(test_data['Fare'], 5 ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lagtime3'] = train_df.groupby('user_id')['timestamp'].shift(3)
train_df['lagtime3']=train_df['timestamp']-train_df['lagtime3']
lagtime_mean3=train_df['lagtime3'].mean()
train_df['lagtime3'].fillna(lagtime_mean3, inplace=True)
train_df['lagtime3']=train_df['lagtime3']/(1000*3600)
train_df.lagtime3=train_df.... | label = LabelEncoder()
train_data['AgeBin_Code_5'] = label.fit_transform(train_data['AgeBin_5'])
test_data['AgeBin_Code_5'] = label.fit_transform(test_data['AgeBin_5'])
label = LabelEncoder()
train_data['FareBin_Code_5'] = label.fit_transform(train_data['FareBin_5'])
test_data['FareBin_Code_5'] = label.fit_transform... | Titanic - Machine Learning from Disaster |
13,429,461 |
<data_type_conversions> | train_data['Title_Code'] = train_data.Title.map({'Mr':0, 'Miss':1, 'Mrs':2, 'Master':3, 'Others':4} ).astype('int')
test_data['Title_Code'] = test_data.Title.map({'Mr':0, 'Miss':1, 'Mrs':2, 'Master':3, 'Others':4} ).astype('int' ) | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['timestamp']=train_df['timestamp']/(1000*3600)
train_df.timestamp=train_df.timestamp.astype('float16' )<feature_engineering> | whole_data = train_data.append(test_data)
whole_data['Surname'] = whole_data.Name.str.extract(r'([A-Za-z]+),', expand=False)
whole_data['TixPref'] = whole_data.Ticket.str.extract(r' (.*\d)', expand=False)
whole_data['SurTix'] = whole_data['Surname'] + whole_data['TixPref']
whole_data['IsFamily'] = whole_data.SurTix.... | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['delta_prior_question_elapsed_time'] = train_df.groupby('user_id')['prior_question_elapsed_time'].shift()
train_df['delta_prior_question_elapsed_time']=train_df['prior_question_elapsed_time']-train_df['delta_prior_question_elapsed_time']<data_type_conversions> | whole_data['Child'] = whole_data.Age.map(lambda x: 1 if x <=16 else 0)
FamilyWithChild = whole_data[(whole_data.IsFamily==1)&(whole_data.Child==1)]['SurTix'].unique()
len(FamilyWithChild ) | Titanic - Machine Learning from Disaster |
13,429,461 | delta_prior_question_elapsed_time_mean=train_df['delta_prior_question_elapsed_time'].mean()
train_df['delta_prior_question_elapsed_time'].fillna(delta_prior_question_elapsed_time_mean, inplace=True)
train_df.delta_prior_question_elapsed_time=train_df.delta_prior_question_elapsed_time.astype('int32' )<data_type_convers... | whole_data['FamilyId'] = 0
x = 1
for tix in FamilyWithChild:
whole_data.loc[whole_data.SurTix==tix, ['FamilyId']] = x
x += 1 | Titanic - Machine Learning from Disaster |
13,429,461 | train_df['lag'] = train_df.groupby('user_id')[target].shift()
cum = train_df.groupby('user_id')['lag'].agg(['cumsum', 'cumcount'])
user_agg = train_df.groupby('user_id')['lag'].agg(['sum', 'count'] ).astype('int16')
cum['cumsum'].fillna(0, inplace=True)
train_df['user_correctness'] = cum['cumsum'] / cum['cumcount']
... | X_train = train_data.drop(['Age', 'Embarked', 'Fare', 'Name', 'Parch', 'PassengerId', 'Sex', 'SibSp', 'Survived', 'Ticket', 'Title', 'AgeBin_5', 'FareBin_5', 'FamilySize', 'Surname', 'TixPref', 'SurTix', 'IsFamily', 'Child', 'FamilyId'], axis=1)
y_train = train_data['Survived'] | Titanic - Machine Learning from Disaster |
13,429,461 | del cum
gc.collect()<data_type_conversions> | model = RandomForestClassifier(n_estimators=200, random_state=2 ) | Titanic - Machine Learning from Disaster |
13,429,461 |
<data_type_conversions> | final = ['Title_Code', 'Sex_Code', 'ConnectedSurvival', 'Pclass', 'FareBin_Code_5'] | Titanic - Machine Learning from Disaster |
13,429,461 | train_df.prior_question_had_explanation=train_df.prior_question_had_explanation.astype('int8')
explanation_agg = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['sum', 'count'])
explanation_agg=explanation_agg.astype('int16')
<data_type_conversions> | grid_param = {
'n_estimators': [100, 200, 300],
'criterion':['gini', 'entropy'],
'min_samples_split': [2, 10, 20],
'min_samples_leaf': [1, 5],
'bootstrap': [True, False],
}
gd_sr = GridSearchCV(estimator=model,
param_grid=grid_param,
scoring='accuracy',
cv=5,
n_jobs=-1)
gd_sr.fit(X_train[final], y_train)
best_paramet... | Titanic - Machine Learning from Disaster |
13,429,461 | cum = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['cumsum', 'cumcount'])
cum['cumcount']=cum['cumcount']+1
train_df['explanation_mean'] = cum['cumsum'] / cum['cumcount']
train_df['explanation_true_count'] = cum['cumsum']
train_df['explanation_false_count'] = cum['cumcount']-cum['cumsum']
train_d... | model1 = RandomForestClassifier(n_estimators=300, bootstrap=True, criterion= 'entropy', min_samples_leaf=5, min_samples_split=2, random_state=2 ) | Titanic - Machine Learning from Disaster |
13,429,461 | del cum
gc.collect()<categorify> | all_accuracies = cross_val_score(estimator=model1, X=X_train, y=y_train, cv=5)
all_accuracies
all_accuracies.mean() | Titanic - Machine Learning from Disaster |
13,429,461 | content_agg = train_df.groupby('content_id')[target].agg(['sum', 'count','var'])
task_container_agg = train_df.groupby('task_container_id')[target].agg(['sum', 'count','var'])
content_agg=content_agg.astype('float32')
task_container_agg=task_container_agg.astype('float32' )<data_type_conversions> | X_test = test_data[final]
model.fit(X_train[final],y_train)
prediction = model.predict(X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': prediction.astype(int)})
output.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,255,729 | train_df['task_container_uncor_count'] = train_df['task_container_id'].map(task_container_agg['count']-task_container_agg['sum'] ).astype('int32')
train_df['task_container_cor_count'] = train_df['task_container_id'].map(task_container_agg['sum'] ).astype('int32')
train_df['task_container_std'] = train_df['task_contai... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data.head(5)
| Titanic - Machine Learning from Disaster |
13,255,729 | content_elapsed_time_agg=train_df.groupby('content_id')['prior_question_elapsed_time'].agg(['mean'])
content_had_explanation_agg=train_df.groupby('content_id')['prior_question_had_explanation'].agg(['mean'] )<train_model> | def outlier_detection(dataframe,features, critical=1.5):
ind = []
for column in features:
q1 = np.percentile(dataframe[column],25)
q3 = np.percentile(dataframe[column],75)
res = q3 - q1
new = critical * res
out = dataframe[(dataframe[column] < q1 - new)|(dataframe[column] > q3 + new)].index
ind.extend(out)
ind = Cou... | Titanic - Machine Learning from Disaster |
13,255,729 | print('start questions data...' )<load_from_csv> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("%.3f of women who survived" % rate_women)
men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("%.3f of men who survived" % rate_men ) | Titanic - Machine Learning from Disaster |
13,255,729 | questions_df = pd.read_csv(
'.. /input/riiid-test-answer-prediction/questions.csv',
usecols=[0, 1,3,4],
dtype={'question_id': 'int16','bundle_id': 'int16', 'part': 'int8','tags': 'str'}
)<groupby> | features = ["PassengerId", "Name", "Pclass", "Sex", "Age", "SibSp", "Parch", "Ticket", "Fare", "Cabin", "Embarked"]
num_train, num_test = len(train_data), len(test_data)
print(num_train, num_test)
merged_data = pd.concat([train_data[features], test_data[features]], axis=0, ignore_index=True)
merged_data['Age'] = mer... | Titanic - Machine Learning from Disaster |
13,255,729 | bundle_agg = questions_df.groupby('bundle_id')['question_id'].agg(['count'] )<data_type_conversions> | y = train_data["Survived"]
winsorized_X = pd.get_dummies(merged_data[["Pclass", "Name", "Sex", "Age", "SibSp", "Parch", "Ticket", "Fare", "Embarked"]])
winsorized_X.info() | Titanic - Machine Learning from Disaster |
13,255,729 | questions_df['content_sub_bundle'] = questions_df['bundle_id'].map(bundle_agg['count'] ).astype('int8' )<set_options> | X_train = winsorized_X.iloc[0:num_train]
X_test = winsorized_X.iloc[num_train:]
ros = RandomOverSampler(random_state=1)
X_ros, y_ros = ros.fit_resample(X_train, y)
x_train, x_valid, y_train, y_valid = train_test_split(X_ros, y_ros, test_size=0.2, random_state=1)
d_train = xgb.DMatrix(x_train, label=y_train)
d_valid... | Titanic - Machine Learning from Disaster |
13,255,729 | questions_df['tags'].fillna('188', inplace=True )<string_transform> | y_pred = model.predict(d_valid)
print('Accuracy :{0:0.5f}'.format(metrics.accuracy_score(y_valid, y_pred)))
print('AUC : {0:0.5f}'.format(metrics.roc_auc_score(y_valid, y_pred)))
print('Precision : {0:0.5f}'.format(metrics.precision_score(y_valid, y_pred)))
print('Recall : {0:0.5f}'.format(metrics.recall_score(y_va... | Titanic - Machine Learning from Disaster |
13,255,729 | <categorify><EOS> | predictions = model.predict(d_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions.astype('int32')})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
12,110,094 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | import numpy as np
import pandas as pd
import seaborn as sns
import os
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.sv... | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df_dict = {
'tags0': 'int8',
'tags1': 'int8',
'tags2': 'int8',
'tags3': 'int8',
'tags4': 'int8',
'tags5': 'int8',
}
questions_df = questions_df.astype(questions_df_dict )<drop_column> | ROOT_DIR = '/kaggle/input/titanic'
train_df = pd.read_csv(os.path.join(ROOT_DIR, 'train.csv'))
test_df = pd.read_csv(os.path.join(ROOT_DIR, 'test.csv'))
test_id = test_df['PassengerId']
print('Train shape: ', train_df.shape)
print('Test shape: ', test_df.shape ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df.drop(columns=['tags'], inplace=True )<data_type_conversions> | def show_null_values(df):
null_df = pd.DataFrame(
{'Column': [col for col in df.columns if df[col].isna().sum() ],
'Ratio': [df[col].isna().sum() /df.shape[0] for col in df.columns if df[col].isna().sum() ]},
)
return null_df.sort_values(by=['Ratio'], ascending=False ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df['part_bundle_id']=questions_df['part']*100000+questions_df['bundle_id']
questions_df.part_bundle_id=questions_df.part_bundle_id.astype('int32')
<load_from_csv> | show_null_values(train_df ) | Titanic - Machine Learning from Disaster |
12,110,094 |
<rename_columns> | show_null_values(test_df ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df.rename(columns={'question_id':'content_id'}, inplace=True )<merge> | train_df.drop(columns=['Cabin'], inplace=True)
test_df.drop(columns=['Cabin'], inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df = pd.merge(questions_df, content_explation_agg, on='content_id', how='left',right_index=True)
<drop_column> | train_size = train_df.shape[0] | Titanic - Machine Learning from Disaster |
12,110,094 | del content_explation_agg<data_type_conversions> | y_train = train_df['Survived']
all_data = pd.concat([train_df.drop(columns=['Survived']), test_df] ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df['content_correctness'] = questions_df['content_id'].map(content_agg['sum'] / content_agg['count'])
questions_df.content_correctness=questions_df.content_correctness.astype('float16')
questions_df['content_correctness_std'] = questions_df['content_id'].map(content_agg['var'])
questions_df.content_correct... | all_data['Age'].fillna(train_df['Age'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 | questions_df['content_elapsed_time_mean'] = questions_df['content_id'].map(content_elapsed_time_agg['mean'])
questions_df.content_elapsed_time_mean=questions_df.content_elapsed_time_mean.astype('float16')
questions_df['content_had_explanation_mean'] = questions_df['content_id'].map(content_had_explanation_agg['mean']... | all_data['Embarked'].fillna(train_df['Embarked'].mode() [0], inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 | del content_elapsed_time_agg
del content_had_explanation_agg
gc.collect()<categorify> | all_data['Fare'].fillna(train_df['Fare'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 | part_agg = questions_df.groupby('part')['content_correctness'].agg(['mean', 'var'])
questions_df['part_correctness_mean'] = questions_df['part'].map(part_agg['mean'])
questions_df['part_correctness_std'] = questions_df['part'].map(part_agg['var'])
questions_df.part_correctness_mean=questions_df.part_correctness_mean... | show_null_values(all_data ) | Titanic - Machine Learning from Disaster |
12,110,094 | part_agg = questions_df.groupby('part')['content_uncorrect_count'].agg(['sum'])
questions_df['part_uncor_count'] = questions_df['part'].map(part_agg['sum'] ).astype('int32')
part_agg = questions_df.groupby('part')['content_correct_count'].agg(['sum'])
questions_df['part_cor_count'] = questions_df['part'].map(part_ag... | all_data.drop(columns=['Name', 'Ticket'], inplace=True)
all_data.drop(columns=['PassengerId'], inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 | bundle_agg = questions_df.groupby('bundle_id')['content_correctness'].agg(['mean'])
questions_df['bundle_correctness_mean'] = questions_df['bundle_id'].map(bundle_agg['mean'])
questions_df.bundle_correctness_mean=questions_df.bundle_correctness_mean.astype('float16')
<data_type_conversions> | for col in ['Sex', 'Embarked', 'Pclass']:
dummies = pd.get_dummies(all_data[col], prefix=col)
all_data = pd.concat([all_data, dummies], axis=1)
all_data.drop(columns=col, inplace=True ) | Titanic - Machine Learning from Disaster |
12,110,094 |
<drop_column> | X_train = all_data[:train_size]
X_test = all_data[train_size:] | Titanic - Machine Learning from Disaster |
12,110,094 | del content_agg
del bundle_agg
del part_agg
gc.collect()<define_variables> | scaled_features = ['Age', 'Fare']
scaler = StandardScaler()
X_train_scaled = X_train.copy()
X_test_scaled = X_test.copy()
X_train_scaled[scaled_features] = scaler.fit_transform(X_train_scaled[scaled_features])
X_test_scaled[scaled_features] = scaler.transform(X_test_scaled[scaled_features] ) | Titanic - Machine Learning from Disaster |
12,110,094 | features_dict = {
'timestamp':'float16',
'user_interaction_count':'int16',
'user_interaction_timestamp_mean':'float32',
'lagtime':'float32',
'lagtime2':'float32',
'lagtime3':'float32',
'content_id':'int16',
'task_container_id':'int16',
'user_lecture_sum':'int16',
'user_lecture_lv':'float16',
'prior_question_elapsed_tim... | logistic_regr = LogisticRegression(max_iter=500)
param_grid = {'C': [0.01, 0.05, 0.1, 0.5], 'penalty': ['l1', 'l2']}
logistic_gcv = GridSearchCV(logistic_regr, param_grid=param_grid, scoring='accuracy', n_jobs=-1, cv=5, return_train_score=True)
logistic_gcv.fit(X_train_scaled, y_train ) | Titanic - Machine Learning from Disaster |
12,110,094 | flag_lgbm=True
clfs = list()
params = {
'num_leaves': 200,
'max_bin':450,
'feature_fraction': 0.52,
'bagging_fraction': 0.52,
'objective': 'binary',
'learning_rate': 0.05,
"boosting_type": "gbdt",
"metric": 'auc',
}
trains=list()
valids=list()
num=1
for i in range(0,num):
train_df_clf=train_df[1200*10000:2*1400*10000]
... | print('Logistic best params: ', logistic_gcv.best_params_)
print('Logistic Regression best score: ', logistic_gcv.best_score_)
print(logistic_gcv.cv_results_['mean_train_score'])
print(logistic_gcv.cv_results_['mean_test_score'] ) | Titanic - Machine Learning from Disaster |
12,110,094 | del train_df_clf
del valid_df
gc.collect()<prepare_x_and_y> | dt = DecisionTreeClassifier(random_state=2)
dt_params = {'max_depth': [3, 5, 6],
}
dt_gcv = GridSearchCV(dt, param_grid=dt_params, scoring='accuracy', n_jobs=-1, cv=5, return_train_score=True)
dt_gcv.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,110,094 | for i in range(0,num):
X_train_np = trains[i][features].values.astype(np.float32)
X_valid_np = valids[i][features].values.astype(np.float32)
tr_data = lgb.Dataset(X_train_np, label=trains[i][target], feature_name=list(features))
va_data = lgb.Dataset(X_valid_np, label=valids[i][target], feature_name=list(features))
d... | print('Decision Tree best params: ', dt_gcv.best_params_)
print('Decision Tree best score: ', dt_gcv.best_score_)
print(dt_gcv.cv_results_['mean_train_score'])
print(dt_gcv.cv_results_['mean_test_score'])
print(dt_gcv.cv_results_['std_train_score'])
print(dt_gcv.cv_results_['std_test_score'] ) | Titanic - Machine Learning from Disaster |
12,110,094 | MAX_SEQ = 280
ACCEPTED_USER_CONTENT_SIZE = 7
EMBED_SIZE = 128
BATCH_SIZE = 64
DROPOUT = 0.1
class FFN(nn.Module):
def __init__(self, state_size = 200, forward_expansion = 1, bn_size=MAX_SEQ - 1, dropout=0.2):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, forward_expansion * ... | svm = SVC()
svm_params = {'C': [0.01, 0.05, 0.1, 1]}
svm_gcv = GridSearchCV(svm, param_grid=svm_params, scoring='accuracy', n_jobs=-1, cv=5, return_train_score=True)
svm_gcv.fit(X_train_scaled, y_train ) | Titanic - Machine Learning from Disaster |
12,110,094 | def future_mask(seq_length):
future_mask =(np.triu(np.ones([seq_length, seq_length]), k = 1)).astype('bool')
return torch.from_numpy(future_mask)
future_mask(5 )<choose_model_class> | print('SVM best params: ', svm_gcv.best_params_)
print('SVM best score: ', svm_gcv.best_score_)
print(svm_gcv.cv_results_['mean_train_score'])
print(svm_gcv.cv_results_['mean_test_score'] ) | Titanic - Machine Learning from Disaster |
12,110,094 | class TransformerBlock(nn.Module):
def __init__(self, embed_dim, heads = 8, dropout = DROPOUT, forward_expansion = 1):
super(TransformerBlock, self ).__init__()
self.multi_att = nn.MultiheadAttention(embed_dim=embed_dim, num_heads=heads, dropout=dropout)
self.dropout = nn.Dropout(dropout)
self.layer_normal = nn.Layer... | gb = GradientBoostingClassifier()
gb_params = {'n_estimators': [30, 50, 60, 100]}
gb_gcv = GridSearchCV(gb, param_grid=gb_params, scoring='accuracy', n_jobs=-1, cv=5, return_train_score=True)
gb_gcv.fit(X_train_scaled, y_train ) | Titanic - Machine Learning from Disaster |
12,110,094 | user_sum_dict = user_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_count_dict = user_agg['count'].astype('int16' ).to_dict(defaultdict(int))
<data_type_conversions> | print('Gradient Boosting best params: ', gb_gcv.best_params_)
print('Gradient Boosting best score: ', gb_gcv.best_score_)
print(gb_gcv.cv_results_['mean_train_score'])
print(gb_gcv.cv_results_['mean_test_score'] ) | Titanic - Machine Learning from Disaster |
12,110,094 | del user_agg
gc.collect()
task_container_sum_dict = task_container_agg['sum'].astype('int32' ).to_dict(defaultdict(int))
task_container_count_dict = task_container_agg['count'].astype('int32' ).to_dict(defaultdict(int))
task_container_std_dict = task_container_agg['var'].astype('float16' ).to_dict(defaultdict(int))
exp... | gb = GradientBoostingClassifier(n_estimators=50)
gb.fit(X_train_scaled, y_train)
predict = gb.predict(X_test_scaled ) | Titanic - Machine Learning from Disaster |
12,110,094 | user_lecture_sum_dict = user_lecture_agg['sum'].astype('int16' ).to_dict(defaultdict(int))
user_lecture_count_dict = user_lecture_agg['count'].astype('int16' ).to_dict(defaultdict(int))
del user_lecture_agg
gc.collect()<categorify> | output = pd.DataFrame({'PassengerId': test_id, 'Survived': predict})
output.to_csv('output.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,903,329 | max_timestamp_u_dict=max_timestamp_u.set_index('user_id' ).to_dict()
max_timestamp_u_dict2=max_timestamp_u2.set_index('user_id' ).to_dict()
max_timestamp_u_dict3=max_timestamp_u3.set_index('user_id' ).to_dict()
user_prior_question_elapsed_time_dict=user_prior_question_elapsed_time.set_index('user_id' ).to_dict()
del ma... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data = pd.read_csv("/kaggle/input/titanic/train.csv" ) | Titanic - Machine Learning from Disaster |
11,903,329 | attempt_no_sum_dict = attempt_no_agg['sum'].to_dict(defaultdict(int))
del attempt_no_agg
gc.collect()<feature_engineering> | train_data['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
11,903,329 | def get_max_attempt(user_id,content_id):
k =(user_id,content_id)
if k in attempt_no_sum_dict.keys() :
attempt_no_sum_dict[k]+=1
return attempt_no_sum_dict[k]
attempt_no_sum_dict[k] = 1
return attempt_no_sum_dict[k]<feature_engineering> | cat_features = ['Pclass', 'SibSp', 'Parch', 'Embarked']
train_data[cat_features] = train_data[cat_features].astype('O')
test_data[cat_features] = test_data[cat_features].astype('O' ) | Titanic - Machine Learning from Disaster |
11,903,329 |
<define_variables> | features = ["Sex", "Pclass", "SibSp", "Parch", "Age", 'Embarked']
y = train_data["Survived"]
X = train_data[features]
X_test = test_data[features]
X.head() | Titanic - Machine Learning from Disaster |
11,903,329 | iter_test = env.iter_test()
prior_test_df = None
prev_test_df = None<define_search_space> | X = pd.get_dummies(X)
X_test = pd.get_dummies(X_test ) | Titanic - Machine Learning from Disaster |
11,903,329 | N=[0.4,0.6]<feature_engineering> | X_test.drop(columns=['Parch_9'], inplace=True ) | Titanic - Machine Learning from Disaster |
11,903,329 | %%time
for(test_df, sample_prediction_df)in iter_test:
test_df1=test_df.copy()
if(prev_test_df is not None)&(psutil.virtual_memory().percent<90):
print(psutil.virtual_memory().percent)
prev_test_df['answered_correctly'] = eval(test_df1['prior_group_answers_correct'].iloc[0])
prev_test_df = prev_test_df[prev_test_df.c... | si = SimpleImputer()
X_imp = si.fit_transform(X)
X_test_imp = si.transform(X_test ) | Titanic - Machine Learning from Disaster |
11,903,329 | import gc
import random
from tqdm import tqdm
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.utils.rnn as rnn_utils
from torch.autograd import Variable
from torch.util... | imputer = KNNImputer(n_neighbors=2 ) | Titanic - Machine Learning from Disaster |
11,903,329 | MAX_SEQ = 160
<load_from_csv> | pca = PCA(n_components = 10,random_state=42)
X_pca = pca.fit_transform(X_imp)
X_test_pca = pca.transform(X_test_imp ) | Titanic - Machine Learning from Disaster |
11,903,329 | %%time
dtype = {'timestamp':'int64',
'user_id':'int32' ,
'content_id':'int16',
'content_type_id':'int8',
'answered_correctly':'int8'}
train_df = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/train.csv', usecols=[1, 2, 3, 4, 7], dtype=dtype)
train_df.head()<sort_values> | sclr_pca = MinMaxScaler()
X_min_pca = sclr_pca.fit_transform(X_pca)
X_test_min_pca = sclr_pca.transform(X_test_pca ) | Titanic - Machine Learning from Disaster |
11,903,329 | train_df = train_df[train_df.content_type_id == False]
train_df = train_df.sort_values(['timestamp'], ascending=True ).reset_index(drop = True )<count_unique_values> | sclr = MinMaxScaler()
X_min = sclr.fit_transform(X_imp)
X_test_min = sclr.transform(X_test_imp ) | Titanic - Machine Learning from Disaster |
11,903,329 | skills = train_df["content_id"].unique()
n_skill = len(skills)
print("number skills", len(skills))<groupby> | from sklearn import svm
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import KFold
from xgboost.sklearn import XGBClassifier | Titanic - Machine Learning from Disaster |
11,903,329 | group = train_df[['user_id', 'content_id', 'answered_correctly']].groupby('user_id' ).apply(lambda r:(
r['content_id'].values,
r['answered_correctly'].values))
del train_df
gc.collect()<define_variables> | from tensorflow import keras
from tensorflow.keras import layers | Titanic - Machine Learning from Disaster |
11,903,329 | random.seed(1)
<define_variables> | X_train_pca, X_valid_pca, y_train_pca, y_valid_pca = train_test_split(X_min, keras.utils.to_categorical(y), test_size=0.20, random_state=42 ) | Titanic - Machine Learning from Disaster |
11,903,329 | class SAKTDataset(Dataset):
def __init__(self, group, n_skill, max_seq=MAX_SEQ):
super(SAKTDataset, self ).__init__()
self.max_seq = max_seq
self.n_skill = n_skill
self.samples = group
self.user_ids = []
for user_id in group.index:
q, qa = group[user_id]
if len(q)< 2:
continue
self.user_ids.append(user_id)
def __len__... | X_train_min, X_valid_min, y_train_min, y_valid_min = train_test_split(X_min, keras.utils.to_categorical(y), test_size=0.20, random_state=42 ) | Titanic - Machine Learning from Disaster |
11,903,329 | dataset = SAKTDataset(group, n_skill)
dataloader = DataLoader(dataset, batch_size=2048, shuffle=True, num_workers=8)
item = dataset.__getitem__(5)
<define_search_model> | model = keras.Sequential()
model.add(layers.Dense(500, activation='relu', input_dim=X_train_min.shape[1]))
model.add(layers.Dense(100, activation='relu'))
model.add(layers.Dense(50, activation='relu'))
model.add(layers.Dense(2, activation='softmax'))
model.summary() | Titanic - Machine Learning from Disaster |
11,903,329 | class FFN(nn.Module):
def __init__(self, state_size=200):
super(FFN, self ).__init__()
self.state_size = state_size
self.lr1 = nn.Linear(state_size, state_size)
self.relu = nn.ReLU()
self.lr2 = nn.Linear(state_size, state_size)
self.dropout = nn.Dropout(0.2)
def forward(self, x):
x = self.lr1(x)
x = self.relu(x)
x... | model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=[keras.metrics.BinaryAccuracy() ] ) | Titanic - Machine Learning from Disaster |
11,903,329 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SAKTModel(n_skill, embed_dim=128)
optimizer = torch.optim.Adam(model.parameters() , lr=1e-3)
criterion = nn.BCEWithLogitsLoss()
model.to(device)
criterion.to(device )<train_model> | history = model.fit(X_train_min, y_train_min, epochs=20, validation_data=(X_valid_min, y_valid_min), verbose=1, batch_size=32 ) | Titanic - Machine Learning from Disaster |
11,903,329 | def train_epoch(model, train_iterator, optim, criterion, device="cpu"):
model.train()
train_loss = []
num_corrects = 0
num_total = 0
labels = []
outs = []
tbar = tqdm(train_iterator)
for item in tbar:
x = item[0].to(device ).long()
target_id = item[1].to(device ).long()
label = item[2].to(device ).float()
optim.zero_g... | mdl_sqn = model.predict(X_test_min ) | Titanic - Machine Learning from Disaster |
11,903,329 | epochs = 35
for epoch in range(epochs):
loss, acc, auc = train_epoch(model, dataloader, optimizer, criterion, device)
print("epoch - {} train_loss - {:.2f} acc - {:.3f} auc - {:.3f}".format(epoch, loss, acc, auc))<save_model> | sqn_pred =(mdl_sqn[:, 0] < mdl_sqn[:, 1] ).astype(int ) | Titanic - Machine Learning from Disaster |
11,903,329 | torch.save(model.state_dict() , "SAKT-HDKIM.pt" )<set_options> | params = {
'degree' : list(range(1, 10)) ,
'gamma': ['scale', 'auto'],
'kernel':('linear', 'poly', 'rbf', 'sigmoid'),
'class_weight' :('balanced', None),
'C': list(range(1, 5))
}
gsearch = GridSearchCV(svm.SVC(random_state=42),
n_jobs=5,
cv = KFold(random_state=42, shuffle=True, n_splits=10),
param_grid=params, verbose... | Titanic - Machine Learning from Disaster |
11,903,329 | del dataset
gc.collect()<split> | params = {
'n_estimators' : list(range(50, 1000, 50)) ,
'max_depth': list(range(1, 10)) ,
'min_child_weight':[4,5,6],
'gamma':[i/10.0 for i in range(0,5)],
'n_jobs':[5],
'subsample':[i/10.0 for i in range(6,10)],
'colsample_bytree':[i/10.0 for i in range(6,10)]
}
mdl = XGBClassifier(objective= 'binary:logistic', random... | Titanic - Machine Learning from Disaster |
11,903,329 | <feature_engineering><EOS> | clf_output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': sqn_pred})
clf_output.to_csv('titanic_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,105,994 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
13,105,994 | import gc
import json
import pandas as pd
from pathlib import Path
import sqlite3
import riiideducation
import time
import xgboost as xgb<split> | 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,105,994 | env = riiideducation.make_env()
iter_test = env.iter_test()<define_variables> | 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,105,994 | PATH = Path('.. /input/riiid-submission' )<choose_model_class> | 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,105,994 | model = xgb.Booster(model_file=PATH/'model.xgb')
print('model loaded' )<define_variables> | train_data[['Sex', 'Survived']].groupby(['Sex'] ).mean() | Titanic - Machine Learning from Disaster |
13,105,994 | dtypes = {
'answered_correctly': 'int8',
'answered_correctly_content_id_cumsum': 'int16',
'answered_correctly_content_id_cumsum_pct': 'int16',
'answered_correctly_cumsum': 'int16',
'answered_correctly_cumsum_pct': 'int8',
'answered_correctly_cumsum_upto': 'int8',
'answered_correctly_rollsum': 'int8',
'answered_correctl... | train_data[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
13,105,994 | df_users_content = pd.read_pickle(PATH/'df_users_content.pkl')
df_users_content.head()<data_type_conversions> | 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,105,994 | df_users = df_users_content[['user_id', 'answered_correctly', 'answered_incorrectly']].groupby('user_id' ).sum().reset_index()
df_users = df_users.astype({'user_id': 'int32', 'answered_correctly': 'int16', 'answered_incorrectly': 'int16'})
df_users.head()<load_pretrained> | predictions = []
count = 0
for idx, row in test_data.iterrows() :
if row['Sex'] == 'female':
if row['Pclass'] == 1 or row['Pclass'] == 2:
predictions.append(1)
elif row['Pclass'] == 3 and row['Age'] <= 1:
predictions.append(1)
else:
predictions.append(0)
elif row['Sex'] == 'male':
if row['Age'] <= 18 and row['Pclass... | Titanic - Machine Learning from Disaster |
13,105,994 | df_questions = pd.read_pickle(PATH/'df_questions.pkl')
df_questions.head()<create_dataframe> | test_data['Survived'] = predictions | Titanic - Machine Learning from Disaster |
13,105,994 | <load_from_csv><EOS> | test_data[['PassengerId', 'Survived']].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
12,816,792 | <drop_column><EOS> | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv')
test_data['Survived'] = np.nan
df = pd.concat([train_data, test_data], ignore_index=True, sort=False)
df.info()
sns.barplot(x='Sex', y='Survived', data=df, palette='Set3')
plt.show()
age_df = df[['Age', 'Pclass','Sex','Par... | Titanic - Machine Learning from Disaster |
12,783,987 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
12,783,987 | %%time
pd.read_sql('SELECT * from users LIMIT 5', conn )<create_dataframe> | 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 |
12,783,987 | %%time
q_cols = [
'question_id',
'part',
'tag__0',
'part_correct_pct',
'tag__0_correct_pct',
'question_id_correct_pct'
]
df_questions[q_cols].to_sql('questions', conn, method='multi', index=False)
_ = conn.execute('CREATE UNIQUE INDEX question_id_index ON questions(question_id)')
del df_questions
gc.collect()<load_fr... | train_data['FamilySize'] = 1+train_data['Parch']+train_data['SibSp']
test_data['FamilySize'] = 1+test_data['Parch']+test_data['SibSp'] | Titanic - Machine Learning from Disaster |
12,783,987 | %%time
pd.read_sql('SELECT * from questions LIMIT 5', conn )<load_from_csv> | train_data['Age'].fillna(train_data['Age'].mean() , inplace=True)
train_data['Embarked'].value_counts()
train_data['Embarked'].fillna('S',inplace=True)
train_data.apply(lambda x: sum(x.isnull()),axis=0 ) | Titanic - Machine Learning from Disaster |
12,783,987 | db_size = pd.read_sql('SELECT page_count * page_size as size FROM pragma_page_count() , pragma_page_size() ', conn)['size'][0]
print(f'Total size of database is: {db_size/1e9:0.3f} GB' )<categorify> | test_data['Age'].fillna(test_data['Age'].mean() , inplace=True)
test_data['Fare'].fillna(test_data['Fare'].mean() , inplace=True)
test_data['Embarked'].value_counts()
test_data['Embarked'].fillna('S',inplace=True)
test_data.apply(lambda x: sum(x.isnull()),axis=0 ) | Titanic - Machine Learning from Disaster |
12,783,987 | def select_state(batch_cols, records):
return f<categorify> | features = ["Pclass", "Sex", "SibSp", "Parch", "Embarked"]
train_data = pd.get_dummies(train_data, columns=features, prefix = features)
test_data = pd.get_dummies(test_data, columns=features, prefix = features ) | 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.