kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,370,221 | print("Predicting...")
sub['is_attributed'] = model_lgb.predict(test_X[predictors])
print("Writing...")
sub.to_csv('sub_Yatsenko_01.csv',index=False)
print("Done..." )<save_to_csv> | print("The Score for SVC is: " + str(acc_svc)) | Titanic - Machine Learning from Disaster |
1,370,221 |
<load_from_csv> | linsvc_clf = LinearSVC()
parameters_linsvc = {"multi_class": ["ovr", "crammer_singer"], "fit_intercept": [True, False], "max_iter": [100, 500, 1000, 1500]}
grid_linsvc = GridSearchCV(linsvc_clf, parameters_linsvc, scoring=make_scorer(accuracy_score))
grid_linsvc.fit(X_training, y_training)
linsvc_clf = grid_linsvc.bes... | Titanic - Machine Learning from Disaster |
1,370,221 | s = pd.read_csv('.. /input/adding-to-the-blender-lb-0-9688/average_result.csv' )<save_to_csv> | rf_clf = RandomForestClassifier()
parameters_rf = {"n_estimators": [4, 5, 6, 7, 8, 9, 10, 15], "criterion": ["gini", "entropy"], "max_features": ["auto", "sqrt", "log2"],
"max_depth": [2, 3, 5, 10], "min_samples_split": [2, 3, 5, 10]}
grid_rf = GridSearchCV(rf_clf, parameters_rf, scoring=make_scorer(accuracy_score))
gr... | Titanic - Machine Learning from Disaster |
1,370,221 | s.to_csv('submission11.csv', index=False )<define_variables> | logreg_clf = LogisticRegression()
parameters_logreg = {"penalty": ["l2"], "fit_intercept": [True, False], "solver": ["newton-cg", "lbfgs", "liblinear", "sag", "saga"],
"max_iter": [50, 100, 200], "warm_start": [True, False]}
grid_logreg = GridSearchCV(logreg_clf, parameters_logreg, scoring=make_scorer(accuracy_score))
... | Titanic - Machine Learning from Disaster |
1,370,221 | is_valid = False<define_variables> | knn_clf = KNeighborsClassifier()
parameters_knn = {"n_neighbors": [3, 5, 10, 15], "weights": ["uniform", "distance"], "algorithm": ["auto", "ball_tree", "kd_tree"],
"leaf_size": [20, 30, 50]}
grid_knn = GridSearchCV(knn_clf, parameters_knn, scoring=make_scorer(accuracy_score))
grid_knn.fit(X_training, y_training)
knn_... | Titanic - Machine Learning from Disaster |
1,370,221 | start_time = time.time()
train_columns = ['ip', 'app', 'device', 'os', 'channel', 'click_time', 'is_attributed']
test_columns = ['ip', 'app', 'device', 'os', 'channel', 'click_time', 'click_id']
dtypes = {
'ip' : 'uint32',
'app' : 'uint16',
'device' : 'uint16',
'os' : 'uint16',
'channel' : 'uint16',
'is_attributed' : '... | gnb_clf = GaussianNB()
parameters_gnb = {}
grid_gnb = GridSearchCV(gnb_clf, parameters_gnb, scoring=make_scorer(accuracy_score))
grid_gnb.fit(X_training, y_training)
gnb_clf = grid_gnb.best_estimator_
gnb_clf.fit(X_training, y_training)
pred_gnb = gnb_clf.predict(X_valid)
acc_gnb = accuracy_score(y_valid, pred_gnb)
... | Titanic - Machine Learning from Disaster |
1,370,221 | def datatimeFeatures(df):
df['datetime'] = pd.to_datetime(df['click_time'])
df['dow'] = df['datetime'].dt.dayofweek
df['doy'] = df['datetime'].dt.dayofyear
df.drop(['click_time', 'datetime'], axis=1, inplace=True)
return df<prepare_x_and_y> | dt_clf = DecisionTreeClassifier()
parameters_dt = {"criterion": ["gini", "entropy"], "splitter": ["best", "random"], "max_features": ["auto", "sqrt", "log2"]}
grid_dt = GridSearchCV(dt_clf, parameters_dt, scoring=make_scorer(accuracy_score))
grid_dt.fit(X_training, y_training)
dt_clf = grid_dt.best_estimator_
dt_clf.f... | Titanic - Machine Learning from Disaster |
1,370,221 | y = train['is_attributed']
train.drop(['is_attributed'], axis=1, inplace=True)
sub = pd.DataFrame()
test.drop('click_id', axis=1, inplace=True)
gc.collect()
nrow_train = train.shape[0]
merge = pd.concat([train, test])
del train, test
gc.collect()
ip_count = merge.groupby(['ip'])['channel'].count().reset_index()
ip_c... | xg_clf = XGBClassifier()
parameters_xg = {"objective" : ["reg:linear"], "n_estimators" : [5, 10, 15, 20]}
grid_xg = GridSearchCV(xg_clf, parameters_xg, scoring=make_scorer(accuracy_score))
grid_xg.fit(X_training, y_training)
xg_clf = grid_xg.best_estimator_
xg_clf.fit(X_training, y_training)
pred_xg = xg_clf.predict(... | Titanic - Machine Learning from Disaster |
1,370,221 | params = {'eta': 0.3,
'tree_method': "hist",
'grow_policy': "lossguide",
'max_leaves': 1400,
'max_depth': 0,
'subsample': 0.9,
'colsample_bytree': 0.7,
'colsample_bylevel':0.7,
'min_child_weight':0,
'alpha':4,
'objective': 'binary:logistic',
'scale_pos_weight':9,
'eval_metric': 'auc',
'nthread':8,
'random_state': 99,
'... | model_performance = pd.DataFrame({
"Model": ["SVC", "Linear SVC", "Random Forest",
"Logistic Regression", "K Nearest Neighbors", "Gaussian Naive Bayes",
"Decision Tree", "XGBClassifier"],
"Accuracy": [acc_svc, acc_linsvc, acc_rf,
acc_logreg, acc_knn, acc_gnb, acc_dt, acc_xg]
})
model_performance.sort_values(by="Accura... | Titanic - Machine Learning from Disaster |
1,370,221 | if(is_valid == True):
x1, x2, y1, y2 = train_test_split(train, y, test_size=0.1, random_state=99)
dtrain = xgb.DMatrix(x1, y1)
dvalid = xgb.DMatrix(x2, y2)
del x1, y2, x2, y2
gc.collect()
watchlist = [(dtrain, 'train'),(dvalid, 'valid')]
model = xgb.train(params, dtrain, 200, watchlist, maximize=True, early_stopping... | svc_clf.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
1,370,221 | test = pd.read_csv(".. /input/test.csv", usecols=test_columns, dtype=dtypes)
test = pd.merge(test, ip_count, on='ip', how='left', sort=False)
del ip_count
gc.collect()<data_type_conversions> | submission_predictions = svc_clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
1,370,221 | sub['click_id'] = test['click_id'].astype('int' )<data_type_conversions> | submission = pd.DataFrame({
"PassengerId": testing["PassengerId"],
"Survived": submission_predictions
})
submission.to_csv("titanic.csv", index=False)
print(submission.shape ) | Titanic - Machine Learning from Disaster |
1,359,492 | test['clicks_by_ip'] = test['clicks_by_ip'].astype('uint16')
test = datatimeFeatures(test)
test.drop(['click_id', 'ip'], axis=1, inplace=True)
dtest = xgb.DMatrix(test)
del test
gc.collect()<save_to_csv> | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
train_original = train_df.copy()
test_original = test_df.copy()
train_df.head()
| Titanic - Machine Learning from Disaster |
1,359,492 | sub['is_attributed'] = model.predict(dtest, ntree_limit=model.best_ntree_limit)
sub.to_csv('improved_xgb_sub_today.csv',float_format='%.8f',index=False)
print('submission is done in [{}] seconds'.format(time.time() - start_time))<set_options> | train_df['Cabin'].value_counts().head() | Titanic - Machine Learning from Disaster |
1,359,492 | %matplotlib inline
<load_from_csv> | test_df['Cabin'].value_counts().head() | Titanic - Machine Learning from Disaster |
1,359,492 | train_col = ['ip', 'app', 'device', 'os', 'channel', 'click_time', 'is_attributed']
dtypes = {
'ip' : 'uint32',
'app' : 'uint16',
'device' : 'uint16',
'os' : 'uint16',
'channel' : 'uint16',
'is_attributed' : 'uint8',
'click_id' : 'uint32'
}
df = pd.read_csv('.. /input/train.csv', nrows=30000000,
usecols=train_col, dtyp... | train_df['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
1,359,492 | df['hour'] = pd.to_datetime(df.click_time ).dt.hour.astype('uint8')
df['minute'] = pd.to_datetime(df.click_time ).dt.minute.astype('uint8')
df['day'] = pd.to_datetime(df.click_time ).dt.day.astype('uint8')
df['dw'] = pd.to_datetime(df.click_time ).dt.dayofweek.astype('uint8')
df_test = pd.read_csv('.. /input/test.c... | train_df['Survived'].value_counts(normalize = True)
| Titanic - Machine Learning from Disaster |
1,359,492 | X = pd.concat(( df[['ip', 'app', 'device', 'hour', 'minute', 'os', 'channel', 'day', 'dw']],
df_test[['ip', 'app', 'device', 'hour', 'minute', 'os', 'channel', 'day', 'dw']]))
del df_test; gc.collect()
group = X[['ip','day','hour', 'minute','channel']].groupby(by=['ip','day','hour', 'minute'])['channel'].count().\
rese... | def delete_features(df):
return df.drop(['PassengerId','Ticket','Cabin'], axis=1)
def fill_value(df):
df.Embarked = df.Embarked.fillna("S")
df['Age'] = df.groupby(['Sex'],sort=False)['Age'].apply(lambda x: x.fillna(x.median()))
df['Fare'] = df.groupby(['Pclass','Embarked'],sort=False)['Fare'].apply(lambda x : x.filln... | Titanic - Machine Learning from Disaster |
1,359,492 | max_app = np.max(X.app)+1
max_device = np.max(X.device)+1
max_hour = np.max(X.hour)+1
max_minute = np.max(X.minute)+1
max_os = np.max(X.os)+1
max_channel = np.max(X.channel)+1
max_day = np.max(X.day)+1
max_dw = np.max(X.dw)+1
max_ip_day_time = np.max(X.ip_day_time)+1
max_ip_app_os = np.max(X.ip_app_os)+1<split> | display(train_df['Name'].value_counts() ) | Titanic - Machine Learning from Disaster |
1,359,492 | X_test = X[len(df):]
X = X[:len(df)]
y = df.is_attributed
X_train, X_valid, y_train, y_valid = train_test_split(X, y, random_state=42, train_size=0.95 )<count_values> |
def replace_title(df):
df['Name'] = df['Name'].replace(['Lady','Countess','Capt', 'Col','Don', 'Major','Rev','Sir','Jonkheer','Dona'], 'Special')
df['Name'] = df["Name"].replace(['Mlle','Ms','Miss'],'Miss')
df['Name'] = df['Name'].replace(['Mrs','Mme'],'Mrs')
return df
train_df = replace_title(train_df)
test_df =... | Titanic - Machine Learning from Disaster |
1,359,492 | print(np.sum(y_train)/ len(y_train))
print(np.sum(y_valid)/ len(y_valid))<prepare_x_and_y> | display(train_df['Name'].value_counts() ) | Titanic - Machine Learning from Disaster |
1,359,492 | del df; gc.collect()
def get_keras_data(data):
X = {
'app': np.array(data.app),
'device': np.array(data.device),
'hour': np.array(data.hour),
'minute': np.array(data.minute),
'os': np.array(data.os),
'channel': np.array(data.channel),
'day': np.array(data.day),
'dw': np.array(data.dw),
'ip_day_time': np.array(data.ip_d... | def encoder(df):
scaler = MinMaxScaler()
numerical = ['Age', 'Fare', 'SibSp','Parch']
features_transform = pd.DataFrame(data= df)
features_transform[numerical] = scaler.fit_transform(df[numerical])
display(features_transform.head(n = 5))
return df
train_df = encoder(train_df)
test_df = encoder(test_df)
| Titanic - Machine Learning from Disaster |
1,359,492 | def get_model() :
app = Input(shape=[1], name='app')
device = Input(shape=[1], name='device')
hour = Input(shape=[1], name='hour')
minute = Input(shape=[1], name='minute')
os = Input(shape=[1], name='os')
channel = Input(shape=[1], name='channel')
day = Input(shape=[1], name='day')
dw = Input(shape=[1], name='dw... | def convert_numerical(df):
df = pd.get_dummies(df)
encoded = list(df.columns)
print("{} total features after one-hot encoding.".format(len(encoded)))
print(encoded)
return df
train_df_final = convert_numerical(train_df)
test_df_final = convert_numerical(test_df)
| Titanic - Machine Learning from Disaster |
1,359,492 | batch_size = 20000
epochs = 1
model.fit(X_train, np.array(y_train), epochs=epochs, batch_size=batch_size, verbose=1 )<predict_on_test> | ytest = train_df_final['Survived']
xtrain = train_df_final.drop(['Survived'], axis = 1)
X_train, X_test, y_train, y_test = train_test_split(xtrain, ytest, test_size=.25, random_state=1 ) | Titanic - Machine Learning from Disaster |
1,359,492 | pred = model.predict(X_valid )<set_options> | clf = RandomForestClassifier(random_state = 1)
parameters = {'n_estimators' : [10, 20, 30,50, 100] , 'max_features' : [0.6, 0.2, 0.3], 'min_samples_leaf' :[1,2,3],
'min_samples_split':[2,3,4,6]}
acc_scorer = make_scorer(accuracy_score)
grid_obj = GridSearchCV(clf, parameters, scoring=acc_scorer, cv = 5)
grid_obj = g... | Titanic - Machine Learning from Disaster |
1,359,492 | del X; gc.collect()<predict_on_test> | pred_test = best_clf.predict(test_df_final)
submission = pd.read_csv('.. /input/gender_submission.csv')
submission['Survived']=pred_test
submission['PassengerId']=test_original['PassengerId']
pd.DataFrame(submission, columns=['PassengerId','Survived'] ).to_csv('randomforest.csv', index = False)
print(submission.head... | Titanic - Machine Learning from Disaster |
1,268,290 | pred_test = model.predict(X_test )<save_to_csv> | %matplotlib inline
data_train = pd.read_csv('.. /input/train.csv')
data_test = pd.read_csv('.. /input/test.csv')
data_train.sample(3)
| Titanic - Machine Learning from Disaster |
1,268,290 | pred_test = pd.Series(pred_test.reshape(-1), name='is_attributed')
sub = pd.concat([click_id, pred_test], axis=1)
sub.to_csv('sub.csv', index=False )<load_pretrained> | data_train.isna().sum()
| Titanic - Machine Learning from Disaster |
1,268,290 | z = zipfile.ZipFile('.. /input/train.csv.zip')
df = pd.read_csv(z.open('train.csv'))
z = zipfile.ZipFile('.. /input/test.csv.zip')
test = pd.read_csv(z.open('test.csv'))
def hr_func(ts):
return(float )(ts[11:13])
df['Dates'] = df['Dates'].apply(hr_func)
df['HourCos']=0
df['HourSin']=0
def hourtocos(ts):
ts=ts*2*mat... | features=['Age','Pclass','SibSp','Parch','Fare']
data_train_numeric=data_train[features].as_matrix()
data_test_numeric=data_test[features].as_matrix()
data_train_imputed=pd.DataFrame(KNN(6 ).complete(data_train_numeric),index=data_train.index)
data_test_imputed=pd.DataFrame(KNN(6 ).complete(data_test_numeric),index=da... | Titanic - Machine Learning from Disaster |
1,268,290 | outcomes<0.01<set_options> | data_train[data_train['Age'].isnull() ].head()
data_train=data_train.drop('Age',axis=1)
data_test=data_test.drop('Age',axis=1)
| Titanic - Machine Learning from Disaster |
1,268,290 | import pandas as pd
import numpy as np
import gc
from sklearn.metrics import roc_auc_score
from collections import defaultdict
from tqdm.notebook import tqdm
import lightgbm as lgb
import riiideducation
import matplotlib.pyplot as plt
import seaborn as sns
import random
import os
<define_variables> | data_train['Age']=data_train['Age_imputed']
data_test['Age']=data_test['Age_imputed']
data_train=data_train.drop('Age_imputed',axis=1)
data_test=data_test.drop('Age_imputed',axis=1)
data_train.head()
| Titanic - Machine Learning from Disaster |
1,268,290 | class UserFeats(object):
def __init__(
self
):
self._ans_cnt = 0
self._ans_corr_cnt = 0
self._questions_seen_id = dict()
self._part_info = dict()
self._last_container = -1
self._last_timestamp = [np.nan for i in range(4)]
self._last_correct_timestamp = [np.nan, np.nan]
self._last_incorrect_timestamp = [np.nan, np.nan... | def encode_features(df_train, df_test):
features = [ 'Sex', 'Lname', 'Title','Age','Fare']
df_combined = pd.concat([df_train[features], df_test[features]])
for feature in features:
le = preprocessing.LabelEncoder()
le = le.fit(df_combined[feature])
df_train[feature] = le.transform(df_train[feature])
df_test[feature]... | Titanic - Machine Learning from Disaster |
1,268,290 | class QuesFeats(object):
def __init__(self, feats_tuple):
self.part = feats_tuple[0]
self.crr_cnt = feats_tuple[1]
self.total_cnt = feats_tuple[2]
self.explan_false_mean = feats_tuple[4]
self.explan_true_mean = feats_tuple[5]
self.var = feats_tuple[6]
self.bundle_num = feats_tuple[7]
self.part_mean_correct = feats_tupl... | X_all = data_train.drop(['Survived','Cabin', 'PassengerId'], axis=1)
y_all = data_train['Survived']
num_test = 0.20
X_train, X_test, y_train, y_test = train_test_split(X_all, y_all, test_size=num_test, random_state=23 ) | Titanic - Machine Learning from Disaster |
1,268,290 | def df_preprocessing(df, q_tmp):
df['prior_question_had_explanation'] = df.prior_question_had_explanation.fillna(False ).astype('int8')
df['timestamp'] = df['timestamp']/(1000*1000)
df['prior_question_elapsed_time'] = df['prior_question_elapsed_time']/(1000*1000)
df['prior_question_elapsed_time'].fillna(0.013, inpla... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
1,268,290 | def handle_features(df,user_dict,content_f, add):
if add:
row = df[['user_id', 'answered_correctly', 'task_container_id', 'content_id', 'part', 'prior_question_elapsed_time', 'prior_question_had_explanation','timestamp']]
res = dict()
total = user_dict[row[0]]._ans_cnt if user_dict[row[0]]._ans_cnt !=0 else 1
if row[4]... | param_grid={'C':[0.001,0.01,0.1,1,10,100]}
clf=LogisticRegression()
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_lreg=round(accuracy_score(y_pred,y_test)*100,2)
print("Accuracy Score for Logestic Regression {0}".format(acc_lreg))
| Titanic - Machine Learning from Disaster |
1,268,290 | def process_questions(filepath):
default_list = []
q_features = [
'part',
'content_correct_num',
'content_total_num',
'content_correct_mean',
'content_explation_false_mean',
'content_explation_true_mean',
'var',
'bundle_num',
'part_mean_correct',
'part_total_correct',
'part_var',
'part_bundle_id',
'content_explan_sum',... | clf=SVC()
Cs=[0.001,0.01,0.1,1,10,]
gammas=[0.001,0.01,0.1,1]
param_grid={'C':Cs,'gamma':gammas}
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_svc=round(accuracy_score(y_pred,y_test)*100,2)
print("Accuracy Score for Support Vector Machine{0}".format(... | Titanic - Machine Learning from Disaster |
1,268,290 | def read_and_preprocess(feature_engineering = False):
train = '.. /input/riiid-test-answer-prediction/train.csv'
question_file = '.. /input/qdataset/questions_features.pkl'
feld_needed = ['timestamp', 'user_id', 'answered_correctly', 'content_id', 'content_type_id', 'prior_question_elapsed_time', 'prior_question_had_ex... | clf=DecisionTreeClassifier()
param_grid={'max_depth':[2,4,6,8,10],'max_features':[2,3,4,5,6,7]}
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_dtree=round(accuracy_score(y_pred,y_test)*100,2)
print("Accuracy score for decision tree{0}".format(acc_dtre... | Titanic - Machine Learning from Disaster |
1,268,290 | user_dict,content_f = read_and_preprocess()
model = lgb.Booster(model_file='.. /input/trainmodel/model.txt')
print('model load done.... ' )<define_variables> | clf=RandomForestClassifier()
param_grid={'max_depth':[2,4,6,8,10],'max_features':[2,3,4,5,6,7]}
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_rforest=round(accuracy_score(y_pred,y_test)*100,2)
print("RandomForestAccuracy Score{0} ".format(acc_rforest... | Titanic - Machine Learning from Disaster |
1,268,290 | TARGET = ['answered_correctly']
FEATURES = [
'timestamp',
'content_id',
'task_container_id',
'prior_question_elapsed_time',
'prior_question_had_explanation',
'part',
'u_answered_correctly_count',
'u_answered_correctly_avg',
'u_elapsed_time_avg',
'u_explanation_avg',
'timestamp_u_recency_1',
'timestamp_u_recency_2',
'ti... | clf=KNeighborsClassifier()
param_grid={'n_neighbors':[2,4,6,8,10],'weights':['uniform','distance']}
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_knn=round(accuracy_score(y_pred,y_test)*100,2)
print("KnearrestNeighbors Accuracy Score{0} ".format(acc_... | Titanic - Machine Learning from Disaster |
1,268,290 | import numpy as np
import pandas as pd
from tqdm.notebook import tqdm
import gc
from sklearn.model_selection import train_test_split
from lightgbm import LGBMClassifier
import optuna
from optuna.samplers import TPESampler
from sklearn.metrics import roc_auc_score
import riiideducation
import os<load_from_csv> | clf=GradientBoostingClassifier()
param_grid={'max_depth':[2,4,6,8,10],'max_features':[2,3,4,5,6,7]}
grid=GridSearchCV(clf,param_grid,cv=10,scoring='accuracy' ).fit(X_train,y_train)
y_pred=grid.predict(X_test)
acc_gbdtree=round(accuracy_score(y_pred,y_test)*100,2)
print("GradientboostingClassifier accuracy Score {0}"... | Titanic - Machine Learning from Disaster |
1,268,290 | %%time
used_data_types_dict = {
'question_id': 'int16',
'bundle_id': 'int16',
'correct_answer': 'int8',
'part': 'int8',
'tags': 'str',
}
questions = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/questions.csv',
usecols = used_data_types_dict.keys() , dtype=used_data_types_dict)
lectures_df = pd.read_csv('.. ... | model=pd.DataFrame({'model':['GradientboostingClassifier','KnearrestNeighbors','RandomForest','DecisionTreeClassifier','SupportVectormachine','LogisticRegression'] ,'Acc_Score':[acc_gbdtree,acc_knn,acc_rforest,acc_dtree,acc_svc,acc_lreg]})
model.sort_values('Acc_Score',ascending=False ) | Titanic - Machine Learning from Disaster |
1,268,290 | %%time
features_df = pd.read_pickle('.. /input/riiid-splitting-train-and-test-data/features_q_only.pkl.zip')
train_df = pd.read_pickle('.. /input/riiid-splitting-train-and-test-data/train_q_only.pkl.zip' )<feature_engineering> | clf = RandomForestClassifier()
parameters = {'n_estimators': [4, 6, 9,12],
'max_features': ['log2', 'sqrt','auto'],
'criterion': ['entropy', 'gini'],
'max_depth': [2, 3, 5, 10],
'min_samples_split': [2, 3, 5],
'min_samples_leaf': [1,5,8]
}
acc_scorer = make_scorer(accuracy_score)
grid_obj = GridSearchCV(clf, parameter... | Titanic - Machine Learning from Disaster |
1,268,290 | def add_seen_before_to_train_df(features_df, train_df):
train_questions_only_df = features_df[features_df['answered_correctly']!=-1]
state = dict()
for user_id in train_questions_only_df['user_id'].unique() :
state[user_id] = {}
total = len(state.keys())
user_content = train_questions_only_df.groupby('user_id')['conte... | predictions = clf.predict(X_test)
print(accuracy_score(y_test, predictions)) | Titanic - Machine Learning from Disaster |
1,268,290 | lects_df = features_df[features_df['answered_correctly']==-1]
lect_seen_df = pd.DataFrame(data=lects_df.user_id.value_counts())
lect_seen_df.columns=['lectures_seen']
lect_seen_df.lectures_seen = lect_seen_df.lectures_seen.astype(float)
lectures_df['type_of'] = lectures_df['type_of'].replace('solving question', 'solv... | def run_kfold(clf):
kf = KFold(891, n_folds=10)
outcomes = []
fold = 0
for train_index, test_index in kf:
fold += 1
X_train, X_test = X_all.values[train_index], X_all.values[test_index]
y_train, y_test = y_all.values[train_index], y_all.values[test_index]
clf.fit(X_train, y_train)
predictions = clf.predict(X_test)
a... | Titanic - Machine Learning from Disaster |
1,268,290 | train_questions_only_df = features_df[features_df['answered_correctly']!=-1]
train_questions_only_df = pd.merge(train_questions_only_df, questions[['part','tags']],
left_on='content_id', right_index=True, how = 'left')
del features_df<data_type_conversions> | ids = data_test['PassengerId']
predictions = clf.predict(data_test.drop(['PassengerId','Cabin'], axis=1))
output = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions })
output.to_csv('titanic-predictions.csv', index = False)
output.head() | Titanic - Machine Learning from Disaster |
1,018,930 | grouped_by_user_df = train_questions_only_df.groupby('user_id')
user_answers_df = grouped_by_user_df.agg({'answered_correctly': ['mean', 'count', 'sum']} ).copy()
user_answers_df.columns = [
'user_mean_accuracy',
'user_questions_answered',
'user_questions_correct',
]
user_answers_df.user_questions_correct = user_answe... | train_df=pd.read_csv('.. /input/train.csv')
gen_df=pd.read_csv('.. /input/gender_submission.csv')
test_df=pd.read_csv('.. /input/test.csv')
data_arr=[train_df,test_df] | Titanic - Machine Learning from Disaster |
1,018,930 | user_lagtime_max_dict = grouped_by_user_df.agg({'lag_time': ['max']} ).copy()
user_lagtime_max_dict.columns = [
'user_lag_time_max',
]
user_lagtime_max_dict = user_lagtime_max_dict.to_dict('index')
for pair in grouped_by_user_df.tail(1)[['user_id','lag_time']].values:
user_lagtime_max_dict[pair[0]]['last_lagtime'] = p... | colms=[col for col in train_df.columns if train_df[col].isnull().any() ]
| Titanic - Machine Learning from Disaster |
1,018,930 | grouped_by_tags_df = train_questions_only_df.groupby('tags')
tags_answers_df = grouped_by_tags_df.agg({'answered_correctly': ['mean', 'count', 'std', 'skew']} ).copy()
tags_answers_df.columns = [
'tags_mean_accuracy',
'tags_question_asked',
'tags_std_accuracy',
'tags_skew_accuracy'
]
tags_answers_df<groupby> | train_df['Cabin']=pd.Series([i[0] if pd.notnull(i)else 'X' for i in train_df['Cabin'] ])
train_df['Cabin'].replace('T','X',inplace=True)
test_df['Cabin']=pd.Series([i[0] if pd.notnull(i)else 'X' for i in test_df['Cabin'] ] ) | Titanic - Machine Learning from Disaster |
1,018,930 | grouped_by_part_df = train_questions_only_df.groupby('part')
part_answers_df = grouped_by_part_df.agg({'answered_correctly': ['mean', 'count']} ).copy()
part_answers_df.columns = [
'part_mean_accuracy',
'part_questions_answered',
]
part_answers_df<drop_column> | print(train_df.Cabin.value_counts())
| Titanic - Machine Learning from Disaster |
1,018,930 | del grouped_by_user_df
del grouped_by_tags_df
del grouped_by_part_df<load_pretrained> | for data in data_arr:
data['Title']=data.Name.str.split(', ',expand=True)[1].str.split('.',expand=True)[0]
title_cnt=data.Title.value_counts() <10
data.Title=data.Title.apply(lambda x: x if title_cnt[x]==False else 'Misc')
| Titanic - Machine Learning from Disaster |
1,018,930 | content_answers_df = pd.read_pickle('.. /input/riiid-content-answers-df-preprocessing/content_answers_df.pkl.zip')
content_answers_df<define_variables> | med_age=pd.DataFrame()
def fill_age(cols):
pclass=cols[0]
sex=cols[1]
age=cols[2]
title=cols[3]
if pd.isnull(age):
return med_age[(med_age['Pclass']==pclass)&(med_age['Title']==title)&(med_age['Sex']==sex)]['Age']
else:
return age | Titanic - Machine Learning from Disaster |
1,018,930 | features = [
'user_mean_accuracy',
'user_questions_answered',
'user_questions_correct',
'q_mean_accuracy',
'q_question_asked',
'q_question_correct',
'community',
'num_in_bundle',
'tags_mean_accuracy',
'tags_question_asked',
'tags_std_accuracy',
'tags_skew_accuracy',
'part_mean_accuracy',
'part_questions_answered',
'pri... | train_df.drop(['PassengerId','Ticket','Name','Fare','Age','SibSp','Parch'],axis=1,inplace=True)
test_df.drop(['Ticket','Name','Fare','Age','Parch','SibSp'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,018,930 | del train_questions_only_df<categorify> | train_df=pd.get_dummies(train_df,columns=['Sex','Embarked','Pclass','Title','AgeBin','FareBin','Cabin'],drop_first=True)
test_df=pd.get_dummies(test_df,columns=['Sex','Embarked','Pclass','Title','AgeBin','FareBin','Cabin'],drop_first=True ) | Titanic - Machine Learning from Disaster |
1,018,930 | def add_and_update_user_lects(user_lecture_stats_part, lectures_df, train_df):
lect_dict = lectures_df.to_dict('index')
lect_stats_part_dict = user_lecture_stats_part.to_dict('index')
part_1_list = []
part_2_list = []
part_3_list = []
part_4_list = []
part_5_list = []
part_6_list = []
part_7_list = []
type_of_concept... | y=train_df['Survived']
X=train_df.iloc[:,1:]
PassengerId=test_df['PassengerId']
test_df.drop(labels=['PassengerId'],inplace=True,axis=1 ) | Titanic - Machine Learning from Disaster |
1,018,930 | def add_and_update_user_stats(user_answers_df, train_df):
my_dict=user_answers_df.to_dict('index')
user_acc_list=[]
user_answered_list=[]
user_correct_list=[]
for pair in tqdm(train_df[['user_id','answered_correctly']].values):
if pair[0] in my_dict:
user_acc_list.append(my_dict[pair[0]]['user_mean_accuracy'])
user_a... | X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=.20,random_state=1 ) | Titanic - Machine Learning from Disaster |
1,018,930 | def add_and_update_content_stats(content_answers_df, train_df):
my_dict=content_answers_df.to_dict('index')
q_mean_accuracy_list=[]
q_question_asked=[]
q_question_correct=[]
community_list=[]
num_in_bundle_list=[]
avg_q_time_list=[]
for pair in tqdm(train_df[['content_id','answered_correctly']].values):
q_mean_accurac... | modelxgb=XGBClassifier(n_estimators=300,learning_rate=0.001,max_depth=4,n_jobs=4,)
modelxgb.fit(X_train,y_train)
ypred=modelxgb.predict(X_test)
print(modelxgb.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred))
| Titanic - Machine Learning from Disaster |
1,018,930 | def update_user_max_timestamp(user_lagtime_max_dict, train_df):
for pair in train_df[['user_id','timestamp','lag_time']].values:
if pair[0] in user_lagtime_max_dict:
user_lagtime_max_dict[pair[0]]['user_lag_time_max'] = pair[1]
user_lagtime_max_dict[pair[0]]['last_lagtime'] = pair[2]
else:
user_lagtime_max_dict[pair[0]... | logmodel=LogisticRegression(max_iter=100)
logmodel.fit(X_train,y_train)
ypred=logmodel.predict(X_test)
print(logmodel.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred)) | Titanic - Machine Learning from Disaster |
1,018,930 | %%time
lect_stats_part, train_df = add_and_update_user_lects(user_lecture_stats_part, lectures_df, train_df)
train_df = train_df[train_df[target] != -1]
user_lagtime_max_dict = update_user_max_timestamp(user_lagtime_max_dict, train_df)
user_answers_df, train_df = add_and_update_user_stats(user_answers_df, train_df)
... | modelsvc=SVC(probability=True,gamma='auto')
modelsvc.fit(X_train,y_train)
ypred=modelsvc.predict(X_test)
print(modelsvc.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred))
| Titanic - Machine Learning from Disaster |
1,018,930 | sampler = TPESampler(seed=314)
def create_model(trial):
num_leaves = trial.suggest_int("num_leaves", 20, 40)
n_estimators = trial.suggest_int("n_estimators", 50, 400)
max_depth = trial.suggest_int('max_depth', 3, 8)
min_child_samples = trial.suggest_int('min_child_samples', 100, 1200)
learning_rate = trial.suggest... | dmodel=DecisionTreeClassifier()
dmodel.fit(X_train,y_train)
ypred=dmodel.predict(X_test)
print(dmodel.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred)) | Titanic - Machine Learning from Disaster |
1,018,930 | params = {'num_leaves': 30,
'n_estimators': 300,
'max_depth': 5,
'min_child_samples': 371,
'learning_rate': 0.28285171125399805,
'min_data_in_leaf': 23,
'bagging_fraction': 0.8057106694835638,
'feature_fraction': 0.5688885590495344,
}
model = LGBMClassifier(**params)
model.fit(train_df[features], train_df[target])
<cr... | rmodel=RandomForestClassifier(n_estimators=50)
rmodel.fit(X_train,y_train)
ypred=rmodel.predict(X_test)
print(rmodel.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred)) | Titanic - Machine Learning from Disaster |
1,018,930 | print(model.feature_importances_)
print(train_df.columns[:-1])
pd.DataFrame({'col_name': model.feature_importances_},
index=train_df.columns[:-1] ).sort_values(by='col_name', ascending=False )<load_pretrained> | amodel=AdaBoostClassifier(n_estimators=100)
amodel.fit(X_train,y_train)
ypred=amodel.predict(X_test)
print(amodel.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred)) | Titanic - Machine Learning from Disaster |
1,018,930 | del train_df
all_data = pd.read_pickle('.. /input/riiid-train-df/train_df.pkl.gzip')
all_data = all_data[all_data[target] != -1]<feature_engineering> | gmodel=GradientBoostingClassifier(n_estimators=100)
gmodel.fit(X_train,y_train)
ypred=gmodel.predict(X_test)
print(gmodel.score(X_train,y_train))
print(confusion_matrix(y_test,ypred))
print(classification_report(y_test,ypred)) | Titanic - Machine Learning from Disaster |
1,018,930 | def get_me_all_seen_befores(all_data):
state = dict()
for user_id in all_data['user_id'].unique() :
state[user_id] = {}
total = len(state.keys())
user_content = all_data.groupby('user_id')['content_id'].apply(np.array ).apply(np.sort ).apply(np.unique)
user_attempts = all_data.groupby(['user_id', 'content_id'])['cont... | voting=VotingClassifier(estimators=[('logi',logmodel),('svc',modelsvc),('dtc',dmodel),('abc',amodel)],voting='soft',n_jobs=4 ) | Titanic - Machine Learning from Disaster |
1,018,930 | def update_content_stats(content_answers_df, previous_test_df):
for row in previous_test_df[['content_id','answered_correctly','content_type_id']].values:
if row[2] == 0:
content_answers_df.at[row[0],'q_question_correct'] += row[1]
content_answers_df.at[row[0],'q_question_asked'] += 1
content_answers_df['q_mean_accurac... | voting=voting.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
1,018,930 | def update_user_stats(user_answers_df, previous_test_df):
for row in previous_test_df[['user_id','answered_correctly','content_type_id']].values:
if row[2] == 0:
try:
user_answers_df.at[row[0],'user_questions_correct'] += row[1]
user_answers_df.at[row[0],'user_questions_answered'] += 1
except:
user_answers_df.at[row[0]... | pred1=voting.predict(test_df)
print(confusion_matrix(gen_df.Survived,pred1))
print(classification_report(gen_df.Survived,pred1)) | Titanic - Machine Learning from Disaster |
1,018,930 | def update_lect_stats(user_lecture_stats_part, lectures_df, previous_test_df):
for row in previous_test_df[['user_id','content_type_id', 'content_id']].values:
if row[1] == 1:
y = lectures_df.query('lecture_id == {}'.format(row[2])).drop('tag', 1 ).reset_index(drop=True)
y = y.loc[:,(y != 0 ).any(axis=0)]
if row[0] in... | prediction=modelsvc.predict(test_df ) | Titanic - Machine Learning from Disaster |
1,018,930 | def add_and_update_seen_before(train_df, state):
big_list=[]
for pair in train_df[['user_id','content_id','content_type_id']].values:
if pair[2] == 0:
if pair[0] in state:
if pair[1] in state[pair[0]]:
big_list.append(state[pair[0]][pair[1]])
state[pair[0]][pair[1]]+=1
else:
big_list.append(0)
state[pair[0]][pair[1]]... | print(confusion_matrix(gen_df.Survived,prediction))
print(classification_report(gen_df.Survived,prediction)) | Titanic - Machine Learning from Disaster |
1,018,930 | def add_and_update_lag_time(test_df, user_lagtime_max_dict):
lag_time_list = []
for pair in test_df[['user_id','timestamp']].values:
if pair[0] in user_lagtime_max_dict:
if pair[1] != user_lagtime_max_dict[pair[0]]['user_lag_time_max']:
lag_time_list.append(pair[1] -(user_lagtime_max_dict[pair[0]]['user_lag_time_max'])... | sub=pd.DataFrame({'PassengerId':PassengerId,'Survived':prediction} ) | Titanic - Machine Learning from Disaster |
1,018,930 | <merge><EOS> | sub.to_csv('Submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
555,983 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | InteractiveShell.ast_node_interactivity = "all"
| Titanic - Machine Learning from Disaster |
555,983 | import pandas as pd
import numpy as np
import gc
from sklearn.metrics import roc_auc_score
from collections import defaultdict
from tqdm.notebook import tqdm
import lightgbm as lgb<define_variables> | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
df_full = [df_train, df_test] | Titanic - Machine Learning from Disaster |
555,983 | train_pickle = '.. /input/pickle1/cv1_train.pickle'
valid_pickle = '.. /input/pickle1/cv1_valid.pickle'
question_file = '.. /input/riiid-test-answer-prediction/questions.csv'
debug = False
validaten_flg = False<categorify> | table1 = pd.pivot_table(df_train, values='Survived', index=['Pclass'])
table1 | Titanic - Machine Learning from Disaster |
555,983 | train = pd.read_pickle(train_pickle)
valid = pd.read_pickle(valid_pickle )<load_pretrained> | for dataset in df_full:
family_size = dataset.SibSp + dataset.Parch +1
dataset['FamilySize'] = family_size
table2 = pd.pivot_table(df_train, values = 'Survived', index= ['FamilySize'])
table2 | Titanic - Machine Learning from Disaster |
555,983 | question_df = pd.read_pickle('.. /input/questionspickle/question.pickle' )<load_from_csv> | port_mode = df_train.Embarked.mode() [0]
df_train['Embarked'] = df_train['Embarked'].fillna(port_mode)
fare_median = df_test.Fare.median()
df_test['Fare'] = df_test['Fare'].fillna(fare_median ) | Titanic - Machine Learning from Disaster |
555,983 |
<prepare_x_and_y> | for dataset in df_full:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int ) | Titanic - Machine Learning from Disaster |
555,983 | TARGET = 'answered_correctly'
FEATS = ['answered_correctly_avg_u','content_id', 'answered_correctly_sum_u', 'count_u', 'answered_correctly_avg_c', 'prior_question_had_explanation', 'prior_question_elapsed_time']
dro_cols = list(set(train.columns)- set(FEATS))
y_tr = train[TARGET]
y_va = valid[TARGET]
train.drop(dro_col... | for dataset in df_full:
dataset['Embarked'] = dataset['Embarked'].map({'S':0 , 'C':1 , 'Q':2} ).astype(int ) | Titanic - Machine Learning from Disaster |
555,983 | lgb_train = lgb.Dataset(train[FEATS], y_tr)
lgb_valid = lgb.Dataset(valid[FEATS], y_va)
del train, y_tr,valid,y_va
_=gc.collect()<train_model> | for dataset in df_full:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
555,983 | model = lgb.train(
{'objective': 'binary',
lgb_train,
valid_sets=[lgb_train, lgb_valid],
verbose_eval=10,
num_boost_round=10000,
early_stopping_rounds=10
)
_ = lgb.plot_importance(model )<data_type_conversions> | all_titles = df_test['Title'].append(df_train['Title'])
pd.crosstab(all_titles,'count' ) | Titanic - Machine Learning from Disaster |
555,983 | def add_user_feats_without_update(df, answered_correctly_sum_u_dict, count_u_dict):
acsu = np.zeros(len(df), dtype=np.int32)
cu = np.zeros(len(df), dtype=np.int32)
for cnt,row in enumerate(df[['user_id']].values):
acsu[cnt] = answered_correctly_sum_u_dict[row[0]]
cu[cnt] = count_u_dict[row[0]]
user_feats_df = pd.Data... | for dataset in df_full:
dataset['Title'] = dataset['Title'].replace(['Mlle','Ms'],'Miss')
dataset['Title'] = dataset['Title'].replace(['Mme'], 'Mrs')
dataset['Title'] = dataset['Title'].replace(['Capt','Col','Don','Jonkheer','Major','Sir','Rev','Dr'],'Raremale')
dataset['Title'] = dataset['Title'].replace(['Countess... | Titanic - Machine Learning from Disaster |
555,983 | content_df = pd.read_pickle('.. /input/pickle1/content.pickle' )<merge> | pd.pivot_table(df_train, index = df_train['Title'], values = 'Survived' ) | Titanic - Machine Learning from Disaster |
555,983 | env = riiideducation.make_env()
iter_test = env.iter_test()
set_predict = env.predict
for(test_df, sample_prediction_df)in iter_test:
previous_test_df = test_df.copy()
test_df = test_df[test_df['content_type_id'] == 0].reset_index(drop=True)
test_df = add_user_feats_without_update(test_df, answered_correctly_sum_u_dic... | title_map = {"Master":1, "Miss":2, "Mr":3, "Mrs":4, "Rarefemale":5, "Raremale":6}
for dataset in df_full:
dataset['Title'] = dataset['Title'].map(title_map)
| Titanic - Machine Learning from Disaster |
555,983 | answered_correctly_sum_u_dict.to_csv('answered_correctly_sum_u_dict.csv' )<save_to_csv> | for dataset in df_full:
dataset.drop(['Name','SibSp','Parch','Ticket','Cabin','Fare'], axis= 1, inplace = True ) | Titanic - Machine Learning from Disaster |
555,983 | count_u_dict.to_csv('count_u_dict.csv' )<save_model> | for dataset in df_full:
new_df = dataset[['PassengerId','Pclass','Sex','Age','Embarked','FamilySize','Fareband','Title']]
filled = KNN(k=3 ).complete(new_df)
filled = pd.DataFrame(filled, columns =['PassengerId','Pclass','Sex','Age','Embarked','FamilySize','Fareband','Title'])
dataset['Age'] = filled['Age']
dataset.h... | Titanic - Machine Learning from Disaster |
555,983 | model.save_model('modelfeats7.txt' )<import_modules> | for dataset in df_full:
dataset.drop("Age", axis= 1, inplace = True)
df_train.head()
df_test.head() | Titanic - Machine Learning from Disaster |
555,983 | import gc
import random
from tqdm.notebook 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 t... | X_train = df_train.drop(["Survived","PassengerId"], axis=1)
Y_train = df_train["Survived"]
X_test = df_test.drop(["PassengerId"], axis=1 ).copy() | Titanic - Machine Learning from Disaster |
555,983 | path = Path('/kaggle/input')
assert path.exists()<load_from_csv> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2)
acc_log | Titanic - Machine Learning from Disaster |
555,983 | %%time
data_types_dict = {
'content_type_id': 'bool',
'timestamp': 'int64',
'user_id': 'int32',
'content_id': 'int16',
'answered_correctly': 'int8',
'prior_question_elapsed_time': 'float32',
'prior_question_had_explanation': 'bool'
}
target = 'answered_correctly'
train_df = dt.fread(path/'riiid-test-answer-prediction/t... | svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc | Titanic - Machine Learning from Disaster |
555,983 | %%time
train_df = train_df[train_df.content_type_id == False]
train_df = train_df.sort_values(['timestamp'], ascending=True ).reset_index(drop = True )<drop_column> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
555,983 | del train_df['timestamp']
del train_df['content_type_id']<count_unique_values> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
555,983 | n_skill = train_df["content_id"].nunique()
print("number skills", n_skill )<groupby> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian | Titanic - Machine Learning from Disaster |
555,983 | %%time
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<define_variables> | perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2)
acc_perceptron | Titanic - Machine Learning from Disaster |
555,983 | MAX_SEQ = 200
ACCEPTED_USER_CONTENT_SIZE = 4
EMBED_SIZE = 128
BATCH_SIZE = 64
DROPOUT = 0.1<create_dataframe> | sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
acc_sgd | Titanic - Machine Learning from Disaster |
555,983 | class SAKTDataset(Dataset):
def __init__(self, group, n_skill, max_seq=100):
super(SAKTDataset, self ).__init__()
self.samples, self.n_skill, self.max_seq = {}, n_skill, max_seq
self.user_ids = []
for i, user_id in enumerate(group.index):
if(i % 10000 == 0):
print(f'Processed {i} users')
content_id, answered_correctly... | X_train.info()
xgb = XGBClassifier()
xgb.fit(X_train,Y_train)
y_pred = xgb.predict(X_test)
acc_xgb = round(sgd.score(X_train, Y_train)* 100, 2)
acc_xgb
| Titanic - Machine Learning from Disaster |
555,983 | TEST_SIZE = 0.1
train, val = train_test_split(group, test_size = TEST_SIZE )<create_dataframe> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
Y_pred
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
acc_random_forest | Titanic - Machine Learning from Disaster |
555,983 | <create_dataframe><EOS> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron',
'Stochastic Gradient Decent', 'XGBoost',
'Decision Tree'],
'Score': [acc_svc, acc_knn, acc_log,
acc_random_forest, acc_gaussian, acc_perceptron,
acc_sgd, acc_xgb, acc_decision_tree]})... | Titanic - Machine Learning from Disaster |
547,126 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
547,126 | 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 * state_size)
self.relu = nn.ReLU()
self.bn = nn.BatchNorm1d(bn_size)
self.lr2 = nn.Linear(f... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
train_len=len(train_df)
train_len
| Titanic - Machine Learning from Disaster |
547,126 | 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> | dataset=pd.concat(objs=[train_df, test_df], axis=0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
547,126 | 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... | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
547,126 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu" )<choose_model_class> | dataset.isnull().sum() | 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.