kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
715,277 | df['perc_pop_econ_ativa'] = np.where(df['perc_pop_econ_ativa'].isna() , -1, df['perc_pop_econ_ativa'] )<feature_engineering> | data['Fare'].fillna(data['Fare'].median(skipna=True), inplace=True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | df['participacao_transf_receita'] = np.where(df['participacao_transf_receita'].isna() , -1, df['participacao_transf_receita'] )<feature_engineering> | data.drop('Cabin', axis=1, inplace = True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | df['gasto_pc_saude'] = np.where(df['gasto_pc_saude'].isna() , -1, df['gasto_pc_saude'] )<feature_engineering> | data['Embarked'].fillna('S', inplace = True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | df['exp_vida'] = np.where(df['exp_vida'].isna() , df['exp_vida'].mean() , df['exp_vida'] )<feature_engineering> | na_cols = na_count(data)
print('Missing Values:')
for i in na_cols:
print(i ) | Titanic - Machine Learning from Disaster |
715,277 | df['exp_anos_estudo'] = np.where(df['exp_anos_estudo'].isna() , df['exp_anos_estudo'].mean() , df['exp_anos_estudo'] )<count_missing_values> | data[data['Fare'] == max(data['Fare'])] | Titanic - Machine Learning from Disaster |
715,277 | col_nan=df.isnull().any(axis=0)
col_nan<import_modules> | data = pd.get_dummies(data, columns=['Pclass'])
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | import seaborn as sns<split> | data.drop('Pclass_3', axis=1, inplace=True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | test = df[df['nota_mat'].isnull() ]<filter> | data = pd.get_dummies(data, columns=['Sex'])
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | df = df[~df['nota_mat'].isnull() ]<split> | data.drop('Sex_female', axis=1, inplace=True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | train, valid = train_test_split(df, random_state=42 )<define_variables> | data = pd.get_dummies(data, columns=['Embarked'])
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | removed_cols = ['nota_mat', 'municipio', 'hab_p_medico', 'capital', 'comissionados_por_servidor']<define_variables> | data.drop('Embarked_Q', axis=1, inplace=True)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | feats = [c for c in df.columns if c not in removed_cols]<import_modules> | data['is_minor'] = np.where(data['Age'] <= 16, 1, 0 ) | Titanic - Machine Learning from Disaster |
715,277 | from sklearn.ensemble import RandomForestClassifier<choose_model_class> | train_df = data.iloc[:891]
test_df = data.iloc[891:]
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | rf= RandomForestClassifier(n_estimators=200, min_samples_split=5, max_depth=4, random_state=42 )<train_model> | X_train, X_test, Y_train, Y_test = train_test_split(train_df, train['Survived'], test_size = 0.33, random_state = 0)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | rf.fit(train[feats], train['nota_mat'] )<predict_on_test> | DTC3 = tree.DecisionTreeClassifier(max_depth = 3)
DTC3.fit(X_train, Y_train)
Y_pred_DTC3 = DTC3.predict(X_test)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | preds = rf.predict(valid[feats] )<import_modules> | DTC3_mae = mean_absolute_error(Y_test, Y_pred_DTC3)
print('Decision Tree Classifier with max_depth = 3:
Mean Absolute Error: ', DTC3_mae ) | Titanic - Machine Learning from Disaster |
715,277 | from sklearn.metrics import mean_squared_error<import_modules> | DTC3_pred = DTC3.predict(test_df)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | from sklearn.metrics import mean_squared_error<compute_test_metric> | DTC3_submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':DTC3_pred})
DTC3_submission.to_csv('DTC3_submission.csv', index=False)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | mean_squared_error(valid['nota_mat'], preds )<compute_test_metric> | RFC = RandomForestClassifier(n_estimators = 100)
RFC.fit(X_train, Y_train)
Y_pred_RFC = RFC.predict(X_test)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | accuracy_score(valid['nota_mat'], preds )<predict_on_test> | RFC_mae = mean_absolute_error(Y_test, Y_pred_RFC)
print('Random Forest Classifier with max_depth = 3:
Mean Absolute Error: ', RFC_mae ) | Titanic - Machine Learning from Disaster |
715,277 | preds_test = rf.predict(test[feats] )<feature_engineering> | RFC_pred = RFC.predict(test_df)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | test['nota_mat'] = preds_test<save_to_csv> | RFC_submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':RFC_pred})
RFC_submission.to_csv('RFC_submission.csv', index=False)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | test[['codigo_mun', 'nota_mat']].to_csv('rf2.csv', index=False )<load_from_csv> | LogReg = LogisticRegression()
LogReg.fit(X_train, Y_train)
Y_pred_LogReg = LogReg.predict(X_test)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | for dirname, _, filenames in os.walk('/kaggle/input/'):
for filename in filenames:
print(os.path.join(dirname, filename))
Trainset = pd.read_csv("/kaggle/input/hackstat2k19/Trainset.csv", header = 0)
Trainset = Trainset.dropna()
xset = pd.read_csv("/kaggle/input/hackstat2k19/xtest.csv")
xset = xset.dropna()
Trainset = Trainset.replace(to_replace=['Returning_Visitor', 'New_Visitor'], value=[1, 2])
Trainset = Trainset.replace(to_replace=['Jan', 'Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'], value=[1, 2,3,4,5,6,7,8,9,10,11,12])
Trainset = Trainset.replace(to_replace=[False, True], value=[1, 2])
xset = xset.replace(to_replace=['Returning_Visitor', 'New_Visitor'], value=[1, 2])
xset = xset.replace(to_replace=['Jan', 'Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'], value=[1, 2,3,4,5,6,7,8,9,10,11,12])
xset = xset.replace(to_replace=[False, True], value=[1, 2])
print(Trainset.shape)
print(list(Trainset.columns))
print(xset.shape)
Trainset
xArray = Trainset.iloc[:, [0,1,2,3,4,5,6,7,8,9,11,12,13,14]].values
yArray = Trainset.iloc[:, 17].values
print(xArray)
print(len(yArray))
m = 10466
M =[]
xsetArray = xset.iloc[:, [0,1,2,3,4,5,6,7,8,9,11,12,13,14]].values
alpha = 0.05
class LogisticRegression:
def gradient_decent(self, x, y):
w = np.ones(( np.shape(x)[1],1))
print(type(x))
wARR = np.mat(w)
print(type(wARR))
print(type(y))
for i in range(m):
w = w - alpha * x.transpose() *(self.logistic(x * w)- y)
return w
def classify(self, x, w):
prob = self.logistic(sum(x * w))
classification = 0
if prob > 0.5: classification = 1
return classification
def logistic(self,ws):
return 1.0/(1 + np.exp(-ws))
logisticRegression = LogisticRegression()
wArray = logisticRegression.gradient_decent(np.mat(xArray), np.mat(yArray ).transpose())
print("close to window proceed")
score = xsetArray
print(score)
for p in range(1850):
M += [(p+1,logisticRegression.classify([float(score[p][0]), float(score[p][1]),float(score[p][2]), float(score[p][3]),float(score[p][4]), float(score[p][5]),float(score[p][6]),float(score[p][7]),float(score[p][8]),float(score[p][9]),float(score[p][10]), float(score[p][11]),float(score[p][12]),float(score[p][13])], wArray)) ]
print(M)
dfObj = pd.DataFrame(M, columns = ["ID","Revenue"])
<compute_test_metric> | LogReg_mae = mean_absolute_error(Y_test, Y_pred_LogReg)
print('Random Forest Classifier with max_depth = 3:
Mean Absolute Error: ', LogReg_mae ) | Titanic - Machine Learning from Disaster |
715,277 | def handle_command_line() :
flag = True
while(flag):
entry = input("input:")
if(entry != "exit"):
score = entry.split()
p = logisticRegression.classify([float(score[0]), float(score[1]),float(score[2]), float(score[3]),float(score[4]), float(score[5]),float(score[6]), float(score[7],float(score[8]), float(score[9])], wArray)
else:
flag = False<load_from_csv> | LogReg_pred = LogReg.predict(test_df)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
715,277 | <load_from_csv><EOS> | LogReg_submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':LogReg_pred})
LogReg_submission.to_csv('LogReg_submission.csv', index=False)
print('All Good!' ) | Titanic - Machine Learning from Disaster |
10,555,527 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | sns.set(style="darkgrid")
warnings.filterwarnings('ignore')
SEED = 42 | Titanic - Machine Learning from Disaster |
10,555,527 | for dirname, _, filenames in os.walk('/kaggle/input/'):
for filename in filenames:
print(os.path.join(dirname, filename))
Trainset = pd.read_csv("/kaggle/input/hackstat2k19/Trainset.csv", header = 0)
Trainset = Trainset.dropna()
sampleset = pd.read_csv("/kaggle/input/hackstat2k19/sample_submisison.csv", header = 0)
sampleset = sampleset.dropna()
Trainset = Trainset.replace(to_replace=['Jan', 'Feb','Mar','Apr','May','June','Jul','Aug','Sep','Oct','Nov','Dec'], value=[0,2,166,0,307,21,54,69,72,97,641,183])
Trainset = Trainset.replace(to_replace=['Returning_Visitor', 'New_Visitor' , 'Other'], value=[1242, 366, 11])
xset = pd.read_csv("/kaggle/input/hackstat2k19/xtest.csv")
xset = xset.dropna()
xset = xset.replace(to_replace=['Jan', 'Feb','Mar','Apr','May','June','Jul','Aug','Sep','Oct','Nov','Dec'], value=[0,2,166,0,307,21,54,69,72,97,641,183])
xset = xset.replace(to_replace=['Returning_Visitor', 'New_Visitor' , 'Other'], value=[1242, 366, 11])
print(Trainset)
Train, Test = Trainset,xset
print('Number of Training examples', len(Train))
print('Number of Testing examples', len(Test))
features = Trainset.columns[:16]
print(features)
y = Train['Revenue']
y
id_ = sampleset['ID']
clf = RandomForestClassifier(n_jobs = 2, random_state = 0)
clf.fit(Train[features],y)
clf.predict(Test[features])
clf.predict_proba(Test[features])
preds = clf.predict(Test[features])
YArray= id_.as_matrix(columns=None)
print(YArray)
df = pd.DataFrame({"ID" : YArray, "Revenue" : preds})
df.to_csv("submission.csv", index=False)
<set_options> | train=pd.read_csv("/kaggle/input/titanic/train.csv")
test=pd.read_csv("/kaggle/input/titanic/test.csv")
titanic = train.append(test, ignore_index=True)
train_idx = len(train)
test_idx = len(titanic)- len(test)
passengerId = test.PassengerId | Titanic - Machine Learning from Disaster |
10,555,527 | %matplotlib inline<load_from_csv> | titanic.isnull().sum() [titanic.isnull().sum() >0] | Titanic - Machine Learning from Disaster |
10,555,527 | dftrain = pd.read_csv('.. /input/train.csv',index_col='Id')
xtest = pd.read_csv('.. /input/Xtest.csv',index_col='Id')
dftrain.head()<prepare_x_and_y> | titanic['Title'] = titanic.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
print(titanic.Title.value_counts() ) | Titanic - Machine Learning from Disaster |
10,555,527 | xtrain = dftrain.x.values.reshape(-1,1)
ytrain = dftrain.y.values.reshape(-1,1 )<choose_model_class> | standardized_titles = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Aristorcat",
"Don": "Aristorcat",
"Sir" : "Aristorcat",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Aristorcat",
"Dona": "Aristorcat",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"Lady" : "Aristorcat"
}
titanic.Title = titanic.Title.map(standardized_titles)
print(titanic.Title.value_counts() ) | Titanic - Machine Learning from Disaster |
10,555,527 | reg = LinearRegression()<train_model> | titanic.Age = grouped.Age.apply(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
10,555,527 | reg.fit(xtrain,ytrain )<predict_on_test> | titanic.Embarked = titanic.Embarked.fillna(titanic.Embarked.mode() [0] ) | Titanic - Machine Learning from Disaster |
10,555,527 | yhat_train = reg.predict(xtrain ).ravel()
yhat_test = reg.predict(xtest ).ravel()<save_to_csv> | med_fare = titanic.groupby(['Pclass', 'Parch', 'SibSp'] ).Fare.median() [3][0][0]
titanic['Fare'] = titanic['Fare'].fillna(med_fare ) | Titanic - Machine Learning from Disaster |
10,555,527 | submission.to_csv('testsubmission.csv',header=True )<import_modules> | titanic['Cabin'] = titanic['Cabin'].fillna('U')
titanic["Cabin"] = pd.Series([i[0] if not pd.isnull(i)else 'X' for i in titanic['Cabin'] ] ) | Titanic - Machine Learning from Disaster |
10,555,527 | from fastai.vision import *
from fastai.metrics import error_rate<define_variables> | titanic.isnull().sum() [titanic.isnull().sum() >0] | Titanic - Machine Learning from Disaster |
10,555,527 | path=pathlib.Path(os.path.normpath('.. /input/car_data/car_data'))<define_variables> | grouped = titanic.groupby(['Sex'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | train=path/'train'
test=path/'test'<feature_engineering> | grouped = titanic.groupby(['Pclass'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | tfms=get_transforms()<load_pretrained> | grouped = titanic.groupby(['SibSp'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | data=ImageDataBunch.from_folder(path=path,valid='test',bs=32,ds_tfms=tfms,size=(320,320)).normalize(imagenet_stats )<define_variables> | grouped = titanic.groupby(['Parch'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | data.show_batch(rows=3,figsize=(12,12))<choose_model_class> | grouped = titanic.groupby(['Cabin'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | learn=cnn_learner(data,models.resnet50,pretrained=True,metrics=error_rate,model_dir='/tmp/model/' )<train_model> | grouped = train.groupby(['Embarked'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | learn.fit_one_cycle(10 )<save_model> | titanic['Ticket_Frequency'] = titanic.groupby('Ticket')['Ticket'].transform('count')
grouped = titanic.groupby(['Ticket_Frequency'])
grouped.Survived.mean() | Titanic - Machine Learning from Disaster |
10,555,527 | learn.save('stage-1')
<find_best_params> | titanic['Fare'] =(titanic['Fare'] / titanic['Ticket_Frequency'] ) | Titanic - Machine Learning from Disaster |
10,555,527 | learn.lr_find()<train_model> | def extract_surname(data):
families = []
for i in range(len(data)) :
name = data.iloc[i]
if '(' in name:
name_no_bracket = name.split('(')[0]
else:
name_no_bracket = name
family = name_no_bracket.split(',')[0]
title = name_no_bracket.split(',')[1].strip().split(' ')[0]
for c in string.punctuation:
family = family.replace(c, '' ).strip()
families.append(family)
return families
titanic['Family'] = extract_surname(titanic['Name'])
df_train = titanic.loc[:890]
df_test = titanic.loc[891:]
dfs = [df_train, df_test] | Titanic - Machine Learning from Disaster |
10,555,527 | learn.fit_one_cycle(10,max_lr=slice(3e-06,4e-06))<save_model> | mean_survival_rate = np.mean(df_train['Survived'])
train_family_survival_rate = []
train_family_survival_rate_NA = []
test_family_survival_rate = []
test_family_survival_rate_NA = []
for i in range(len(df_train)) :
if df_train['Family'][i] in family_rates:
train_family_survival_rate.append(family_rates[df_train['Family'][i]])
train_family_survival_rate_NA.append(1)
else:
train_family_survival_rate.append(mean_survival_rate)
train_family_survival_rate_NA.append(0)
for i in range(len(df_test)) :
if df_test['Family'].iloc[i] in family_rates:
test_family_survival_rate.append(family_rates[df_test['Family'].iloc[i]])
test_family_survival_rate_NA.append(1)
else:
test_family_survival_rate.append(mean_survival_rate)
test_family_survival_rate_NA.append(0)
df_train['Family_Survival_Rate'] = train_family_survival_rate
df_train['Family_Survival_Rate_NA'] = train_family_survival_rate_NA
df_test['Family_Survival_Rate'] = test_family_survival_rate
df_test['Family_Survival_Rate_NA'] = test_family_survival_rate_NA
train_ticket_survival_rate = []
train_ticket_survival_rate_NA = []
test_ticket_survival_rate = []
test_ticket_survival_rate_NA = []
for i in range(len(df_train)) :
if df_train['Ticket'][i] in ticket_rates:
train_ticket_survival_rate.append(ticket_rates[df_train['Ticket'][i]])
train_ticket_survival_rate_NA.append(1)
else:
train_ticket_survival_rate.append(mean_survival_rate)
train_ticket_survival_rate_NA.append(0)
for i in range(len(df_test)) :
if df_test['Ticket'].iloc[i] in ticket_rates:
test_ticket_survival_rate.append(ticket_rates[df_test['Ticket'].iloc[i]])
test_ticket_survival_rate_NA.append(1)
else:
test_ticket_survival_rate.append(mean_survival_rate)
test_ticket_survival_rate_NA.append(0)
df_train['Ticket_Survival_Rate'] = train_ticket_survival_rate
df_train['Ticket_Survival_Rate_NA'] = train_ticket_survival_rate_NA
df_test['Ticket_Survival_Rate'] = test_ticket_survival_rate
df_test['Ticket_Survival_Rate_NA'] = test_ticket_survival_rate_NA | Titanic - Machine Learning from Disaster |
10,555,527 | learn.save('stage-2' )<define_variables> | for df in [df_train, df_test]:
df['Survival_Rate'] =(df['Ticket_Survival_Rate'] + df['Family_Survival_Rate'])/ 2
df['Survival_Rate_NA'] =(df['Ticket_Survival_Rate_NA'] + df['Family_Survival_Rate_NA'])/ 2 | Titanic - Machine Learning from Disaster |
10,555,527 | root='.. /input/car_data/car_data/test/'
images=list()
for i in listofSubdirectory:
images.append(os.listdir(root+i))
images<load_pretrained> | non_numeric_features = ['Embarked', 'Sex', 'Deck', 'Title', 'Family_Size_Grouped', 'Age', 'Fare', 'NameLength']
for df in dfs:
for feature in non_numeric_features:
df[feature] = LabelEncoder().fit_transform(df[feature] ) | Titanic - Machine Learning from Disaster |
10,555,527 | learn.load('stage-2' )<import_modules> | cat_features = ['Pclass', 'Sex', 'Deck', 'Embarked', 'Title', 'Family_Size_Grouped']
encoded_features = []
for df in dfs:
for feature in cat_features:
encoded_feat = OneHotEncoder().fit_transform(df[feature].values.reshape(-1, 1)).toarray()
n = df[feature].nunique()
cols = ['{}_{}'.format(feature, n)for n in range(1, n + 1)]
encoded_df = pd.DataFrame(encoded_feat, columns=cols)
encoded_df.index = df.index
encoded_features.append(encoded_df)
df_train = pd.concat([df_train, *encoded_features[:6]], axis=1)
df_test = pd.concat([df_test, *encoded_features[6:]], axis=1 ) | Titanic - Machine Learning from Disaster |
10,555,527 | learn.export('/tmp/model/export.pkl' )<load_pretrained> | titanic = pd.concat([df_train, df_test], sort=True ).reset_index(drop=True)
drop_cols = ['Deck', 'Cabin', 'Embarked', 'Family', 'Family_Size', 'Family_Size_Grouped', 'Survived',
'Name', 'Parch', 'PassengerId', 'Pclass', 'Sex', 'SibSp', 'Ticket', 'Title',
'Ticket_Survival_Rate', 'Family_Survival_Rate', 'Ticket_Survival_Rate_NA', 'Family_Survival_Rate_NA']
titanic.drop(columns=drop_cols, inplace=True)
titanic.head() | Titanic - Machine Learning from Disaster |
10,555,527 | learn=load_learner('/tmp/model/' )<predict_on_test> | X_train = StandardScaler().fit_transform(df_train.drop(columns=drop_cols))
y_train = df_train['Survived'].values
X_test = StandardScaler().fit_transform(df_test.drop(columns=drop_cols))
print('X_train shape: {}'.format(X_train.shape))
print('y_train shape: {}'.format(y_train.shape))
print('X_test shape: {}'.format(X_test.shape)) | Titanic - Machine Learning from Disaster |
10,555,527 | columns = ['Id','Predicted']
listofprediction=list()
for i in range(len(listofSubdirectory)) :
for j in images[i]:
pt=root+listofSubdirectory[i]+'/'+j
img=open_image(pt)
name=j.replace('.jpg','')
_,pred_idx,output=learn.predict(img)
listofprediction.append([name,pred_idx.item() ])
<define_variables> | max_evals = 2
space={
'n_estimators': hp.uniform("n_estimators", 500, 2000),
'max_features': hp.choice("max_features", ["auto", "sqrt"]),
'max_depth': hp.uniform("max_depth", 2, 12),
'min_samples_split': hp.uniform("min_samples_split", 2, 11),
'min_samples_leaf': hp.uniform("min_samples_leaf", 2, 11),
}
def hyperparameter_tuning(space):
model=RandomForestClassifier(
n_estimators =int(space['n_estimators']),
max_depth =int(space['max_depth']),
max_features = space['max_features'],
min_samples_split =int(space['min_samples_split']),
min_samples_leaf =int(space['min_samples_leaf']),
random_state = SEED
)
scores = cross_val_score(model, X_train, y_train, scoring='accuracy', cv=StratifiedKFold(n_splits=5,shuffle=True))
print("SCORE: %0.2f" %(-scores.mean()))
return {'loss':-scores.mean() , 'status': STATUS_OK }
trials = Trials()
best = fmin(fn=hyperparameter_tuning,
space=space,
algo=tpe.suggest,
max_evals=max_evals,
trials=trials)
print(best ) | Titanic - Machine Learning from Disaster |
10,555,527 | array=np.array(listofprediction )<create_dataframe> | model = RandomForestClassifier(criterion='gini',
n_estimators=1750,
max_depth=7,
min_samples_split=6,
min_samples_leaf=6,
max_features='auto',
oob_score=True,
random_state=SEED,
n_jobs=-1,
verbose=1 ) | Titanic - Machine Learning from Disaster |
10,555,527 | submission=pd.DataFrame(array,columns=columns)
submission<save_to_csv> | N = 5
oob = 0
probs = pd.DataFrame(np.zeros(( len(X_test), N * 2)) , columns=['Fold_{}_Prob_{}'.format(i, j)for i in range(1, N + 1)for j in range(2)])
importances = pd.DataFrame(np.zeros(( X_train.shape[1], N)) , columns=['Fold_{}'.format(i)for i in range(1, N + 1)], index=titanic.columns)
skf = StratifiedKFold(n_splits=N, random_state=N, shuffle=True)
for fold,(trn_idx, val_idx)in enumerate(skf.split(X_train, y_train), 1):
print('Fold {}
'.format(fold))
model.fit(X_train[trn_idx], y_train[trn_idx])
probs.loc[:, 'Fold_{}_Prob_0'.format(fold)] = model.predict_proba(X_test)[:, 0]
probs.loc[:, 'Fold_{}_Prob_1'.format(fold)] = model.predict_proba(X_test)[:, 1]
importances.iloc[:, fold - 1] = model.feature_importances_
oob += model.oob_score_ / N
print('Fold {} OOB Score: {}
'.format(fold, model.oob_score_))
print('Average OOB Score: {}'.format(oob)) | Titanic - Machine Learning from Disaster |
10,555,527 | submission.to_csv('submission.csv',index=False )<load_from_csv> | class_survived = [col for col in probs.columns if col.endswith('Prob_1')]
probs['1'] = probs[class_survived].sum(axis=1)/ N
probs['0'] = probs.drop(columns=class_survived ).sum(axis=1)/ N
probs['pred'] = 0
pos = probs[probs['1'] >= 0.50].index
probs.loc[pos, 'pred'] = 1
y_pred = probs['pred'].astype(int)
submission_df = pd.DataFrame(columns=['PassengerId', 'Survived'])
submission_df['PassengerId'] = df_test['PassengerId']
submission_df['Survived'] = y_pred.values | Titanic - Machine Learning from Disaster |
10,555,527 | class CarDataset(datasets.ImageFolder):
def __init__(self,root,csv_file,transform=None):
super(CarDataset,self ).__init__(root,transform)
self.df = pd.read_csv(csv_file,header=None)
def __getitem__(self, index):
original_tuple = super(CarDataset, self ).__getitem__(index)
path = self.imgs[index][0]
label = path.split('/')[5]
if label=='Ram C-V Cargo Van Minivan 2012':
label='Ram C/V Cargo Van Minivan 2012'
name_index = self.df.index[self.df[0]==label][0]
target = torch.zeros([1,196])
target[0][name_index] = 1
path = path.split('/')[6][0:-4]
tuple_with_path =(original_tuple +(path,)+(name_index,))
return tuple_with_path<train_model> | os.chdir('/kaggle/working')
submission_df.to_csv('titanic_submissions.csv', header=True, index=False ) | Titanic - Machine Learning from Disaster |
11,471,818 | train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available.Training on CPU...')
else:
print('CUDA is available! Training on GPU...' )<load_from_csv> | train_df = pd.read_csv(".. /input/titanic/train.csv")
test_df = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
11,471,818 | names_df = pd.read_csv('.. /input/names.csv',header=None)
classes = names_df[0]<choose_model_class> | train_df.isna().sum() | Titanic - Machine Learning from Disaster |
11,471,818 | model = models.vgg16(pretrained=True)
print(model )<load_from_csv> | test_df.isna().sum() | Titanic - Machine Learning from Disaster |
11,471,818 | valid_size = 0.2
train_transform = transforms.Compose([transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor() ,
transforms.Normalize(( 0.5, 0.5, 0.5),(0.5, 0.5, 0.5))
])
test_transform = transforms.Compose([transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor()
])
train_data = CarDataset(root=".. /input/car_data/car_data/train",transform=train_transform,csv_file=".. /input/names.csv")
test_data = CarDataset(root=".. /input/car_data/car_data/test",transform=test_transform,csv_file=".. /input/names.csv")
num_train = len(train_data)
indices = list(range(num_train))
np.random.shuffle(indices)
split = int(np.floor(valid_size * num_train))
train_idx, valid_idx = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(valid_idx)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=20,
sampler=train_sampler)
valid_loader = torch.utils.data.DataLoader(train_data, batch_size=20,
sampler=valid_sampler)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=20 )<choose_model_class> | train_set = train_df.drop(columns=["Survived"])
test_set = test_df.copy(deep = True)
frame = [train_set,test_set]
final_set = pd.concat(frame,axis=0 ) | Titanic - Machine Learning from Disaster |
11,471,818 | n_inputs = model.classifier[6].in_features
last_layer = nn.Linear(n_inputs, len(classes))
model.classifier[6] = last_layer
if train_on_gpu:
model.cuda()<choose_model_class> | def fill_nan_categorical(categorical_features,data):
for i in categorical_features:
data[i] = data[i].fillna(data[i].mode() [0])
return data | Titanic - Machine Learning from Disaster |
11,471,818 | criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.classifier.parameters() , lr=0.01 )<train_model> | categorical_features = final_set.select_dtypes(exclude=["number","bool_"] ).columns.tolist()
final_set = fill_nan_categorical(categorical_features,final_set ) | Titanic - Machine Learning from Disaster |
11,471,818 | n_epochs = 10
valid_loss_min = np.Inf
for epoch in range(1, n_epochs+1):
train_loss = 0.0
valid_loss = 0.0
model.train()
for batch_i,(data, index, path,target)in enumerate(train_loader):
if train_on_gpu:
data, target = data.cuda() , target.cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
train_loss += loss.item()
if batch_i % 20 == 19:
print('Epoch %d, Batch %d Train Loss: %.16f' %
(epoch, batch_i + 1, train_loss / 20))
train_loss = 0.0
model.eval()
for batch_i,(data, index, path,target)in enumerate(valid_loader):
if train_on_gpu:
data, target = data.cuda() , target.cuda()
output = model(data)
loss = criterion(output, target)
valid_loss += loss.item()
if batch_i % 20 == 19:
print('Epoch %d, Batch %d Validation Loss: %.16f' %
(epoch, batch_i + 1, valid_loss / 20))
valid_loss = 0.0
if valid_loss <= valid_loss_min:
print('Validation loss decreased({:.6f} --> {:.6f} ).Saving model...'.format(
valid_loss_min,
valid_loss))
torch.save(model.state_dict() , 'model.pt')
valid_loss_min = valid_loss<load_from_disk> | def fill_nan_continuous(continuous_features,data):
for i in categorical_features:
data[i] = data[i].fillna(data[i].mean() [0])
return data | Titanic - Machine Learning from Disaster |
11,471,818 | model.load_state_dict(torch.load('model.pt'))<find_best_params> | continuous_features = final_set.select_dtypes(include=["number","object_"] ).columns.tolist()
final_set = fill_nan_categorical(continuous_features,final_set ) | Titanic - Machine Learning from Disaster |
11,471,818 | results = {}
for data,index,path,target in test_loader:
if train_on_gpu:
data, target = data.cuda() , target.cuda()
output = model(data)
prob = torch.nn.functional.softmax(output, dim=1)
_, pred = torch.max(prob, 1)
for k in range(len(pred)) :
name = path[k]
results[name] = pred[k].cpu().tolist()<prepare_output> | def one_hot_encoder(final_set):
df = final_set.copy(deep= True)
dummies = pd.get_dummies(df,prefix="column_",drop_first=True)
return dummies | Titanic - Machine Learning from Disaster |
11,471,818 | output = pd.DataFrame(results, index=[0] ).transpose()
output = output.reset_index()
output.rename(columns={'index':'Id',0:'Predicted'}, inplace=True)
output['Predicted'] = output['Predicted']+1
output.head()<count_values> | final_set = final_set.drop(columns = ["Name"])
ohe_set = one_hot_encoder(final_set ) | Titanic - Machine Learning from Disaster |
11,471,818 | output['Predicted'].value_counts()<save_to_csv> | train_data = pd.DataFrame(ohe_set[:891])
test_data = pd.DataFrame(ohe_set[891:])
X = train_data
y = train_df["Survived"] | Titanic - Machine Learning from Disaster |
11,471,818 | def create_download_link(df, title = "Download CSV file", filename = "data.csv"):
csv = df.to_csv(index=False)
b64 = base64.b64encode(csv.encode())
payload = b64.decode()
html = '<a download="{filename}" href="data:text/csv;base64,{payload}" target="_blank">{title}</a>'
html = html.format(payload=payload,title=title,filename=filename)
return HTML(html )<load_pretrained> | X_train, X_test, y_train, y_test = train_test_split(X,y, test_size = 0.1, random_state = 42 ) | Titanic - Machine Learning from Disaster |
11,471,818 | create_download_link(output )<save_to_csv> | xgb_classifier = xgboost.XGBRFClassifier(n_estimators=30,
learning_rate=1,
reg_lambda=0.15,
gamma=0.06,
max_depth=20)
xgb_classifier.fit(X_train, y_train)
y_test_pred = xgb_classifier.predict(X_test ).tolist()
accuracy_score(y_test_pred,y_test ) | Titanic - Machine Learning from Disaster |
11,471,818 | output.to_csv('output.csv',index=False )<set_options> | actual = y_test
predicted = y_test_pred
matrix = confusion_matrix(actual,predicted, labels=[1,0])
print('Confusion matrix :
',matrix)
tp, fn, fp, tn = confusion_matrix(actual,predicted,labels=[1,0] ).reshape(-1)
print('Outcome values :
', tp, fn, fp, tn)
matrix = classification_report(actual,predicted,labels=[1,0])
print('Classification report :
',matrix ) | Titanic - Machine Learning from Disaster |
11,471,818 | plt.style.use('seaborn')
sns.set(font_scale=2.5)
warnings.filterwarnings('ignore')
%matplotlib inline<load_from_csv> | y_pred = xgb_classifier.predict(test_data ).tolist() | Titanic - Machine Learning from Disaster |
11,471,818 | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv' )<count_missing_values> | predictions = pd.DataFrame(y_pred)
datasets = pd.concat([test_set["PassengerId"],predictions],axis=1)
datasets.columns = ["PassengerId","Survived"]
datasets.to_csv("gender_submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
10,661,381 | for col in df_train.columns:
msg = 'column: {:>10}\t Percent of NaN value: {:.2f}%'.format(col, 100 *(df_train[col].isnull().sum() / df_train[col].shape[0]))
print(msg )<count_missing_values> | import seaborn as sns
import matplotlib.pyplot as plt
import time | Titanic - Machine Learning from Disaster |
10,661,381 | for col in df_test.columns:
msg = 'column: {:>10}\t Percent of NaN value: {:.2f}%'.format(col, 100 *(df_test[col].isnull().sum() / df_test[col].shape[0]))
print(msg )<feature_engineering> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
10,661,381 | df_train['FamilySize'] = df_train['SibSp'] + df_train['Parch'] + 1
df_test['FamilySize'] = df_test['SibSp'] + df_test['Parch'] + 1<feature_engineering> | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data.head()
test_data.isna().sum() | Titanic - Machine Learning from Disaster |
10,661,381 | df_train['Initial']= df_train.Name.str.extract('([A-Za-z]+)\.')
df_test['Initial']= df_test.Name.str.extract('([A-Za-z]+)\.' )<categorify> | test_data["Fare"] = test_data["Fare"].fillna(0)
test_data["Fare"].isna().sum() | Titanic - Machine Learning from Disaster |
10,661,381 | df_train['Initial'].replace(['Mlle','Mme','Ms','Dr','Major','Lady','Countess','Jonkheer','Col','Rev','Capt','Sir','Don', 'Dona'],
['Miss','Miss','Miss','Mr','Mr','Mrs','Mrs','Other','Other','Other','Mr','Mr','Mr', 'Mr'],inplace=True)
df_test['Initial'].replace(['Mlle','Mme','Ms','Dr','Major','Lady','Countess','Jonkheer','Col','Rev','Capt','Sir','Don', 'Dona'],
['Miss','Miss','Miss','Mr','Mr','Mrs','Mrs','Other','Other','Other','Mr','Mr','Mr', 'Mr'],inplace=True )<feature_engineering> | women = train_data.loc[train_data.Sex == "female"]["Survived"]
rate_women = sum(women)/ len(women)
print("Rate of Women :",rate_women ) | Titanic - Machine Learning from Disaster |
10,661,381 | df_train.loc[(df_train.Age.isnull())&(df_train.Initial=='Mr'),'Age'] = 33
df_train.loc[(df_train.Age.isnull())&(df_train.Initial=='Mrs'),'Age'] = 36
df_train.loc[(df_train.Age.isnull())&(df_train.Initial=='Master'),'Age'] = 5
df_train.loc[(df_train.Age.isnull())&(df_train.Initial=='Miss'),'Age'] = 22
df_train.loc[(df_train.Age.isnull())&(df_train.Initial=='Other'),'Age'] = 46
df_test.loc[(df_test.Age.isnull())&(df_test.Initial=='Mr'),'Age'] = 33
df_test.loc[(df_test.Age.isnull())&(df_test.Initial=='Mrs'),'Age'] = 36
df_test.loc[(df_test.Age.isnull())&(df_test.Initial=='Master'),'Age'] = 5
df_test.loc[(df_test.Age.isnull())&(df_test.Initial=='Miss'),'Age'] = 22
df_test.loc[(df_test.Age.isnull())&(df_test.Initial=='Other'),'Age'] = 46<feature_engineering> | men = train_data.loc[train_data.Sex == "male"]["Survived"]
rate_men = sum(men)/ len(men)
print("Rate of Men :",rate_men ) | Titanic - Machine Learning from Disaster |
10,661,381 | df_train.Cabin.fillna('0', inplace=True)
df_train.loc[df_train.Cabin.str[0] == 'A', 'Cabin'] = 1
df_train.loc[df_train.Cabin.str[0] == 'B', 'Cabin'] = 2
df_train.loc[df_train.Cabin.str[0] == 'C', 'Cabin'] = 3
df_train.loc[df_train.Cabin.str[0] == 'D', 'Cabin'] = 4
df_train.loc[df_train.Cabin.str[0] == 'E', 'Cabin'] = 5
df_train.loc[df_train.Cabin.str[0] == 'F', 'Cabin'] = 6
df_train.loc[df_train.Cabin.str[0] == 'G', 'Cabin'] = 7
df_train.loc[df_train.Cabin.str[0] == 'T', 'Cabin'] = 8
df_test.Cabin.fillna('0', inplace=True)
df_test.loc[df_test.Cabin.str[0] == 'A', 'Cabin'] = 1
df_test.loc[df_test.Cabin.str[0] == 'B', 'Cabin'] = 2
df_test.loc[df_test.Cabin.str[0] == 'C', 'Cabin'] = 3
df_test.loc[df_test.Cabin.str[0] == 'D', 'Cabin'] = 4
df_test.loc[df_test.Cabin.str[0] == 'E', 'Cabin'] = 5
df_test.loc[df_test.Cabin.str[0] == 'F', 'Cabin'] = 6
df_test.loc[df_test.Cabin.str[0] == 'G', 'Cabin'] = 7
df_test.loc[df_test.Cabin.str[0] == 'T', 'Cabin'] = 8
<feature_engineering> | y = train_data["Survived"]
features = ["Sex","Pclass","SibSp","Parch","Fare"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators = 20,max_depth = 5 ,random_state=42)
model.fit(X,y)
predictions = model.predict(X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
| Titanic - Machine Learning from Disaster |
10,661,381 | <categorify><EOS> | model2 = LogisticRegression(penalty= 'none' ,random_state=42 ,max_iter=150 ).fit(X, y)
predictions2 = model2.predict(X_test)
output2 = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions2})
output2.to_csv('my_submission2.csv', index=False)
| Titanic - Machine Learning from Disaster |
10,785,592 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | ss = StandardScaler()
def model(x,y):
x, testx, y, testy = train_test_split(x, y, test_size=0.1, random_state=4355)
all_models = ['sgd','svc','knn','rf','dtc', 'lr', 'LDA', 'xgboost']
models = [sgd,SVC, knn,rf,dtc,LogisticRegression, LDA, xgboost ]
for i,j in zip(models,all_models):
try:
model = i(random_state=344,n_components=5)
except:
try:
model = i(random_state=344)
except:
model = i()
model.fit(x,y)
trsc = model.score(x,y)
sc = model.score(testx,testy)
print(f'For {j} we have train score of {trsc} and test score of {sc}')
def modelR(x,y):
x, testx, y, testy = train_test_split(x, y, test_size=0.1, random_state=4355)
all_models = ['svr','rfr','dtr', 'lreg', 'xgboostR']
models = [SVR,rfr,dtr,LinearRegression, xgboostR ]
for i,j in zip(models,all_models):
try:
model = i(random_state=344,n_components=5)
except:
try:
model = i(random_state=344)
except:
model = i()
model.fit(x,y)
trsc = model.score(x,y)
sc = model.score(testx,testy)
print(f'For {j} we have train score of {trsc} and test score of {sc}')
def scaler(df):
df = df.apply(lambda x:(x-x.mean())/x.std())
return df
def pca(xd,n):
pca = PCA(n_components=n)
xd = pca.fit(xd ).transform(xd)
print(pca.explained_variance_ratio_)
return xd
def setfig(w=10,h=7):
return plt.figure(figsize=[w,h])
def predS(model, test_data):
pred = model.predict(test_data)
test_data = pd.read_csv('.. /input/titanic/test.csv')
td = {'PassengerId':test_data.PassengerId, 'Survived':pred}
pd.DataFrame(td ).to_csv('Submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
10,785,592 | df_train['Embarked'] = df_train['Embarked'].map({'C': 0, 'Q': 1, 'S': 2})
df_test['Embarked'] = df_test['Embarked'].map({'C': 0, 'Q': 1, 'S': 2} )<categorify> | import matplotlib.pyplot as plt
import seaborn as sns | Titanic - Machine Learning from Disaster |
10,785,592 | df_train['Sex'] = df_train['Sex'].map({'female': 0, 'male': 1})
df_test['Sex'] = df_test['Sex'].map({'female': 0, 'male': 1} )<categorify> | odata = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
odata.head(3 ) | Titanic - Machine Learning from Disaster |
10,785,592 | df_train = pd.get_dummies(df_train, columns=['Initial'], prefix='Initial')
df_test = pd.get_dummies(df_test, columns=['Initial'], prefix='Initial' )<categorify> | odata.isna().sum() | Titanic - Machine Learning from Disaster |
10,785,592 | df_train = pd.get_dummies(df_train, columns=['Embarked'], prefix='Embarked')
df_test = pd.get_dummies(df_test, columns=['Embarked'], prefix='Embarked' )<drop_column> | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
10,785,592 | df_train.drop(['PassengerId', 'Name', 'SibSp', 'Parch', 'Ticket','Age'], axis=1, inplace=True)
df_test.drop(['PassengerId', 'Name', 'SibSp', 'Parch', 'Ticket','Age'], axis=1, inplace=True )<prepare_x_and_y> | odata = odata.drop(['PassengerId','Ticket','Cabin'],axis=1)
odata.isna().sum() | Titanic - Machine Learning from Disaster |
10,785,592 | X_train = df_train.drop('Survived', axis=1 ).values
target_label = df_train['Survived'].values
X_test = df_test.values<split> | data = odata.copy() | Titanic - Machine Learning from Disaster |
10,785,592 | X_tr, X_vld, y_tr, y_vld = train_test_split(X_train, target_label, test_size=0.3, random_state=2018 )<compute_train_metric> | import re | Titanic - Machine Learning from Disaster |
10,785,592 | gaussian = GaussianNB()
gaussian.fit(X_tr, y_tr)
prediction = gaussian.predict(X_vld)
acc_gaussian = round(accuracy_score(prediction,y_vld)* 100, 2)
print(acc_gaussian )<compute_train_metric> | data.Name.str.extract('(\w{1,8})\.' ).isna().sum() | Titanic - Machine Learning from Disaster |
10,785,592 | logreg = LogisticRegression()
logreg.fit(X_tr, y_tr)
prediction2 = logreg.predict(X_vld)
acc_logreg = round(accuracy_score(prediction2,y_vld)* 100, 2)
print(acc_logreg )<compute_train_metric> | data['suffix'] = data.Name.str.extract('(\w{1,8})\.')
data.drop('Name', axis=1, inplace=True)
data.head() | Titanic - Machine Learning from Disaster |
10,785,592 | svc = SVC()
svc.fit(X_tr, y_tr)
prediction3 = svc.predict(X_vld)
acc_svc = round(accuracy_score(prediction3,y_vld)* 100, 2 )<compute_train_metric> | data.suffix = data.suffix.apply(lambda x: x if(x in ['Mr', 'Miss', 'Mrs', 'Master'])else 'rare' ) | Titanic - Machine Learning from Disaster |
10,785,592 | linear_svc = LinearSVC()
linear_svc.fit(X_tr, y_tr)
prediction4 = svc.predict(X_vld)
acc_linear_svc = round(accuracy_score(prediction4,y_vld)* 100, 2 )<compute_train_metric> | data.isna().sum() | Titanic - Machine Learning from Disaster |
10,785,592 | perceptron = Perceptron()
perceptron.fit(X_tr, y_tr)
prediction5 = perceptron.predict(X_vld)
acc_perceptron = round(accuracy_score(prediction5,y_vld)* 100, 2 )<train_model> | import math | Titanic - Machine Learning from Disaster |
10,785,592 | decisiontree = DecisionTreeClassifier(criterion='gini', max_depth=5)
decisiontree.fit(X_tr, y_tr)
prediction6 = decisiontree.predict(X_vld)
acc_decisiontree = round(accuracy_score(prediction6,y_vld)* 100, 2)
<predict_on_test> | print(sorted(set(data.Fare.apply(math.ceil)))) | Titanic - Machine Learning from Disaster |
10,785,592 | rf = RandomForestClassifier()
rf.fit(X_tr, y_tr)
prediction7 = rf.predict(X_vld)
acc_rf = round(accuracy_score(prediction7,y_vld)* 100, 2 )<train_model> | data['grouped_fare'] = data.Fare.apply(faregrp ) | Titanic - Machine Learning from Disaster |
10,785,592 | knn = KNeighborsClassifier()
knn.fit(X_tr, y_tr)
prediction8 = knn.predict(X_vld)
acc_knn = round(accuracy_score(prediction8,y_vld)* 100, 2 )<predict_on_test> | narows = data[data.Age.isna() ]
narows | Titanic - Machine Learning from Disaster |
10,785,592 | sgd = SGDClassifier()
sgd.fit(X_tr, y_tr)
prediction9 = knn.predict(X_vld)
acc_sgd = round(accuracy_score(prediction9,y_vld)* 100, 2)
<train_model> | tempdata = data.dropna()
x = tempdata[['Parch', 'SibSp', 'Pclass']]
y = tempdata.Age
modelR(x,y)
agepred = rfr()
agepred.fit(x, y)
predicted = agepred.predict(narows[['Parch', 'SibSp', 'Pclass']])
data.Age.fillna(pd.Series(predicted, index=narows.index), inplace=True ) | Titanic - Machine Learning from Disaster |
10,785,592 | gbk = GradientBoostingClassifier()
gbk.fit(X_tr,y_tr)
prediction10 = gbk.predict(X_vld)
acc_gbk = round(accuracy_score(prediction10,y_vld)* 100, 2 )<train_model> | def agegrp(age):
if 0<= age <=10:
return 1
if 10< age <=18:
return 2
if 18< age <=25:
return 3
if 25< age <=35:
return 4
if 35< age <=47:
return 5
if 47< age <=60:
return 6
if 60< age <=70:
return 7
if 70< age <=80:
return 8 | Titanic - Machine Learning from Disaster |
10,785,592 | xg_boost = xgb.XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,
colsample_bytree=0.65, gamma=2, learning_rate=0.3, max_delta_step=1,
max_depth=4, min_child_weight=2, missing=None, n_estimators=280,
n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,
reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
silent=True, subsample=1)
xg_boost.fit(X_tr, y_tr)
prediction11 = gbk.predict(X_vld)
acc_xg_boost = round(accuracy_score(prediction11,y_vld)* 100, 2 )<create_dataframe> | data['age_grp'] = data.Age.apply(agegrp ) | Titanic - Machine Learning from Disaster |
10,785,592 | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron', 'Linear SVC',
'Decision Tree', 'Stochastic Gradient Descent', 'Gradient Boosting Classifier', 'XGboost'],
'Score': [acc_svc, acc_knn, acc_logreg,
acc_rf, acc_gaussian, acc_perceptron,acc_linear_svc, acc_decisiontree,
acc_sgd, acc_gbk, acc_xg_boost]})
models.sort_values(by='Score', ascending=False )<load_from_csv> | data.Age[data.Age<=18].count() | 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.