kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,773,116 | df_res[['image_name', 'pred']].groupby('image_name' ).mean().reset_index().rename({'pred': 'target'}, axis=1 ).to_csv("submission_6_20.csv", index=False )<import_modules> | modelpred2 = vot_hard.predict(y_train)
sub2 = pd.DataFrame(columns = ['PassengerId','Survived'])
sub2['PassengerId'] = result['PassengerId']
sub2['Survived'] = modelpred2
sub2.to_csv('HardVoting(NO HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | import numpy as np
import pandas as pd
import scipy.stats
import matplotlib.pyplot as plt
from scipy.stats import spearmanr
from matplotlib.colors import LogNorm
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import StratifiedKFold
import tensorflow as tf<set_options> | Accuracy = []
Estimator = [] | Titanic - Machine Learning from Disaster |
10,773,116 | orange_black = [
'
]
plt.style.use('ggplot' )<load_from_csv> | Titanic - Machine Learning from Disaster | |
10,773,116 | n_tta = 1500
file = 'tta-exploration-128x128-b0'
all_tta_test = pd.read_csv('.. /input/'+file+'/all_tta_test.csv')
all_tta_test.columns.values[0] = 'image_name'
submission = pd.read_csv('.. /input/'+file+'/submission.csv')
tta_keys = [str(i)for i in range(n_tta)]
oof = pd.read_csv('.. /input/'+file+'/oof.csv' )<conca... | lr = LogisticRegression(C = 100,penalty = 'l2', solver = 'newton-cg',class_weight = 'dict', max_iter = 900)
Estimator.append(( 'lr',LogisticRegression(C = 1,penalty = 'l2', solver = 'newton-cg',class_weight = 'dict', max_iter = 900)))
cv = cross_val_score(lr,x_train,x_test,cv=10)
Accuracy1 = cv.mean()
Accuracy.appen... | Titanic - Machine Learning from Disaster |
10,773,116 | def IQR(data,ax=1):
return np.subtract(*np.percentile(data, [75, 25],axis=ax))<define_variables> | lr.fit(x_train,x_test)
lr.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | tta_arr = np.array(tta_preds)
n_samp = tta_arr.shape[1]
average_t=[];max_t=[];std_t=[]
error_std=[]
for TTA in range(2,100):
end = int(n_tta//TTA)
samples = tta_arr[:,:TTA*end].reshape(-1,TTA)
all_avs = np.mean(samples,axis=1 ).reshape(len(tta_arr),end)
if all_avs.shape[1]>10:
all_stds = np.std(samples,axis=1 ).res... | model11pred = lr.predict(y_train)
submission11 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission11['PassengerId'] = result['PassengerId']
submission11['Survived'] = model11pred
submission11.to_csv('LogisticRegression(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | tta_preds = oof[tta_keys]
mns = dict(
amean = np.mean(tta_preds,axis=1),
gmean = scipy.stats.gmean(tta_preds,axis=1),
median = np.median(tta_preds,axis=1)
)
for mn in mns:
print('{} AUC = {}'.format(mn,roc_auc_score(oof['target'],mns[mn])) )<save_to_csv> | Titanic - Machine Learning from Disaster | |
10,773,116 | def make_sub(func,name='submission'):
submission = pd.DataFrame(dict(image_name=test_tta['0'], target=func(preds_all,axis=1)))
submission.to_csv(name+'.csv', index=False)
submission.head()
test_tta = pd.read_csv('.. /input/tta-exploration-128x128-b0/all_tta_test.csv')
FOLDS=3; n_test_tta=11
preds_all = [np.mean(test... | svc = LinearSVC(C = 0.1,penalty = 'l2', loss = 'hinge',class_weight = 'balanced')
cv = cross_val_score(svc,x_train,x_test,cv=10)
Accuracy2 = cv.mean()
Accuracy.append(Accuracy2)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,773,116 | n_tta = 11
FOLDS=3
files = ['tta-exploration-128x128-b0','tta-exploration-128x128-b3']
all_tta_list = [pd.read_csv('.. /input/'+file+'/all_tta_test.csv')for file in files]
for df in all_tta_list:
df.columns.values[0] = 'image_name'
sub_list= [pd.read_csv('.. /input/'+file+'/submission.csv')for file in files]
tta_keys =... | svc.fit(x_train,x_test)
svc.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | def set_right(df,tta_keys):
df['std']=np.std(df[tta_keys],axis=1)
return df.drop(tta_keys,axis=1)
oof1 = [set_right(df,tta_keys ).set_index('image_name')for df in oof_list]<concatenate> | model12pred = svc.predict(y_train)
submission12 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission12['PassengerId'] = result['PassengerId']
submission12['Survived'] = model12pred
submission12.to_csv('SVCLinear(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | df_oof = pd.concat(oof1,axis=1)
labels = df_oof['target'].iloc[:,0]<find_best_params> | Titanic - Machine Learning from Disaster | |
10,773,116 | roc=[]
WGTS=np.linspace(0,1,11)
for wgt in WGTS:
pred = wgt*df_oof['pred'].iloc[:,0] +(1-wgt)*df_oof['pred'].iloc[:,1]
roc+=[roc_auc_score(labels,pred)]
best_roc = max(roc)
loc = np.where(roc==best_roc)[0][0]
best_weight = WGTS[loc]
print('The best roc = {:.6f} with weights :({},{})'.format(best_roc, best_weight,(1-b... | SVM_all = svm.SVC(C = 1,degree = 2, kernel = 'poly',class_weight = 'balanced',gamma = 'scale')
cv = cross_val_score(svc,x_train,x_test,cv=10)
Accuracy3 = cv.mean()
Accuracy.append(Accuracy3)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,773,116 | from xgboost import XGBClassifier<prepare_x_and_y> | SVM_all.fit(x_train,x_test)
SVM_all.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | ids = df_oof.index
fold_finder = df_oof['fold'].iloc[:,0]
def get_oof(DATA,LABELS,folds=10,PRINT=0,SEED=42):
skf = StratifiedKFold(n_splits=FOLDS,shuffle=True,random_state=SEED)
oof_pred = []; oof_tar = []; oof_val = []; oof_names = []; oof_folds = []
for fold,(idxT,idxV)in enumerate(skf.split(DATA,LABELS)) :
X = DATA... | model13pred = SVM_all.predict(y_train)
submission13 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission13['PassengerId'] = result['PassengerId']
submission13['Survived'] = model13pred
submission13.to_csv('PolynomialSVM(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | FOLDS = 20
print('Including confidence estimate:')
get_oof(np.concatenate(( df_oof['pred'],df_oof['std']),axis=1),labels,folds=FOLDS)
print('
Only predictions:')
get_oof(np.array(df_oof['pred']),labels,folds=FOLDS )<set_options> | Titanic - Machine Learning from Disaster | |
10,773,116 | warnings.filterwarnings('ignore')
seed_val = 42
random.seed(seed_val)
np.random.seed(seed_val )<set_options> | dt = DecisionTreeClassifier(class_weight = 'balanced',criterion = 'entropy',max_depth = 5,min_samples_split = 2,splitter = 'best',random_state = 6)
Estimator.append(( 'dt',DecisionTreeClassifier(class_weight = 'balanced',criterion = 'entropy',max_depth = 5,min_samples_split = 2,splitter = 'best',random_state = 6)))
c... | Titanic - Machine Learning from Disaster |
10,773,116 | black_red = [
'
]
plt.style.use('fivethirtyeight' )<load_from_csv> | dt.fit(x_train,x_test)
dt.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | train = pd.read_csv('.. /input/melanomaextendedtabular/external_upsampled_tabular.csv')
test = pd.read_csv('.. /input/melanomaextendedtabular/test_tabular.csv')
sample = pd.read_csv('.. /input/melanomaextendedtabular/sample_submission.csv' )<rename_columns> | model14pred = SVM_all.predict(y_train)
submission14 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission14['PassengerId'] = result['PassengerId']
submission14['Survived'] = model14pred
submission14.to_csv('DecisionTrees(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | train.columns = [
'img_name', 'sex', 'age', 'location', 'target','width','height'
]
test.columns = ['img_name', 'sex', 'age', 'location','width','height']
<categorify> | Titanic - Machine Learning from Disaster | |
10,773,116 | for df in [train, test]:
df['location'].fillna('unknown', inplace=True)
train['sex'].fillna('unknown', inplace=True)
train['age'].fillna(-1, inplace=True )<statistical_test> | mnb = MultinomialNB(alpha = 1,fit_prior = True)
Estimator.append(( 'mnb',MultinomialNB(alpha = 1,fit_prior = True)))
cv = cross_val_score(mnb,x_train,x_test,cv=10)
Accuracy5 = cv.mean()
Accuracy.append(Accuracy5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,773,116 | ids_train = train.location.values
ids_test = test.location.values
ids_train_set = set(ids_train)
ids_test_set = set(ids_test)
location_not_overlap = list(ids_train_set.symmetric_difference(ids_test_set))
n_overlap = len(location_not_overlap)
if n_overlap == 0:
print(
f'There are no different body parts occuring bet... | mnb.fit(x_train,x_test)
mnb.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | train.replace(['anterior torso','lateral torso','posterior torso'], 'torso', inplace=True )<data_type_conversions> | model15pred = mnb.predict(y_train)
submission15 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission15['PassengerId'] = result['PassengerId']
submission15['Survived'] = model15pred
submission15.to_csv('MultinomialNB(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | train['res']= train['width'].astype(str)+'x'+train['height'].astype(str)
test['res']= test['width'].astype(str)+'x'+test['height'].astype(str )<drop_column> | Titanic - Machine Learning from Disaster | |
10,773,116 | train.drop(['res'], axis=1, inplace=True)
test.drop(['res'], axis=1, inplace=True )<categorify> | Titanic - Machine Learning from Disaster | |
10,773,116 | sex_dummies = pd.get_dummies(train['sex'], prefix='sex')
train = pd.concat([train, sex_dummies], axis=1)
sex_dummies = pd.get_dummies(test['sex'], prefix='sex')
test = pd.concat([test, sex_dummies], axis=1)
train.drop(['sex'], axis=1, inplace=True)
test.drop(['sex'], axis=1, inplace=True )<categorify> | rf = RandomForestClassifier(oob_score = True,n_estimators =650 ,min_samples_split = 4,max_features = 'log2',max_depth =6,criterion = 'gini',class_weight = 'balanced_subsample',bootstrap = True)
Estimator.append(( 'rf',RandomForestClassifier(oob_score = True,n_estimators =650 ,min_samples_split = 4,max_features = 'log2... | Titanic - Machine Learning from Disaster |
10,773,116 | anatom_dummies = pd.get_dummies(train['location'], prefix='anatom')
train = pd.concat([train, anatom_dummies], axis=1)
anatom_dummies = pd.get_dummies(test['location'], prefix='anatom')
test = pd.concat([test, anatom_dummies], axis=1)
train.drop('location', axis=1, inplace=True)
test.drop(['location'], axis=1, inp... | rf.fit(x_train,x_test)
rf.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | for df in [train, test]:
df.drop('img_name', axis=1, inplace=True )<import_modules> | model16pred = rf.predict(y_train)
submission16 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission16['PassengerId'] = result['PassengerId']
submission16['Survived'] = model16pred
submission16.to_csv('RandomForest(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | import xgboost as xgb
from sklearn.model_selection import StratifiedKFold, train_test_split, cross_val_score, cross_validate
from sklearn.metrics import roc_auc_score, roc_curve<prepare_x_and_y> | Titanic - Machine Learning from Disaster | |
10,773,116 | X = train.drop('target', axis=1)
y = train.target<split> | Titanic - Machine Learning from Disaster | |
10,773,116 | X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.15,
stratify=y,
random_state=42)
cv = StratifiedKFold(5, shuffle=True, random_state=42 )<choose_model_class> | gbc = GradientBoostingClassifier(loss = 'exponential',n_estimators =200 ,min_samples_split = 4,max_features = 'auto',max_depth =9,learning_rate =.01,subsample =.1)
Estimator.append(( 'gbc',GradientBoostingClassifier(loss = 'exponential',n_estimators =200 ,min_samples_split = 4,max_features = 'auto',max_depth =9,learni... | Titanic - Machine Learning from Disaster |
10,773,116 | xg = xgb.XGBClassifier(
n_estimators=750,
min_child_weight=0.81,
learning_rate=0.025,
max_depth=2,
subsample=0.80,
colsample_bytree=0.42,
gamma=0.10,
random_state=42,
n_jobs=-1,
)<define_variables> | gbc.fit(x_train,x_test)
gbc.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | estimators = [xg]<compute_train_metric> | model17pred = gbc.predict(y_train)
submission17 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission17['PassengerId'] = result['PassengerId']
submission17['Survived'] = model17pred
submission17.to_csv('GradientBoosting(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | def model_check(X_train, y_train, estimators, cv):
model_table = pd.DataFrame()
row_index = 0
for est in estimators:
MLA_name = est.__class__.__name__
model_table.loc[row_index, 'Model Name'] = MLA_name
cv_results = cross_validate(est,
X_train,
y_train,
cv=cv,
scoring='roc_auc',
return_train_score=True,
n_jobs=-1)
mod... | Titanic - Machine Learning from Disaster | |
10,773,116 | xg.fit(X_train, y_train)
validation = xg.predict_proba(X_test)[:, 1]
roc_auc_score(y_test, validation )<prepare_x_and_y> | Titanic - Machine Learning from Disaster | |
10,773,116 | adv_train = train.copy()
adv_train.drop('target', axis=1, inplace=True)
adv_test = test.copy()
adv_train['dataset_label'] = 0
adv_test['dataset_label'] = 1
adv_master = pd.concat([adv_train, adv_test], axis=0)
adv_X = adv_master.drop('dataset_label', axis=1)
adv_y = adv_master['dataset_label']<split> | xgb = XGBClassifier(colsample_bytree =.6,eta = 0.5,gamma = 1,max_depth = 5,min_child_weight = 6,subsample = 1)
Estimator.append(( 'xgb',XGBClassifier(colsample_bytree =.6,eta = 0.5,gamma = 1,max_depth = 5,min_child_weight = 6,subsample = 1)))
cv = cross_val_score(xgb,x_train,x_test,cv=10)
Accuracy8 = cv.mean()
Accur... | Titanic - Machine Learning from Disaster |
10,773,116 | adv_X_train, adv_X_test, adv_y_train, adv_y_test = train_test_split(adv_X,
adv_y,
test_size=0.4,
stratify=adv_y,
random_state=42 )<train_model> | xgb.fit(x_train,x_test)
gbc.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | xg_adv = xgb.XGBClassifier(
random_state=42,
n_jobs=-1,
)
xg_adv.fit(adv_X_train, adv_y_train)
validation = xg_adv.predict_proba(adv_X_test)[:,1]<split> | model18pred = xgb.predict(y_train)
submission18 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission18['PassengerId'] = result['PassengerId']
submission18['Survived'] = model18pred
submission18.to_csv('XGBoosting(HT ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | adv_X.drop(['sex_unknown', 'height', 'width'], axis=1, inplace=True)
adv_X_train, adv_X_test, adv_y_train, adv_y_test = train_test_split(adv_X,
adv_y,
test_size=0.4,
stratify=adv_y,
random_state=42)
xg_adv.fit(adv_X_train, adv_y_train)
validation = xg_adv.predict_proba(adv_X_test)[:,1]<drop_column> | x_train1 = final[:891]
feature_scaler = StandardScaler()
x_train1 = feature_scaler.fit_transform(x_train1)
y_train1 = final[891:]
feature_scaler = StandardScaler()
y_train1 = feature_scaler.fit_transform(y_train1 ) | Titanic - Machine Learning from Disaster |
10,773,116 | X_train.drop(['sex_unknown', 'width','height'], axis=1, inplace=True)
test.drop(['width','height'], axis=1, inplace=True )<choose_model_class> | Krange1 = range(1,20)
scores1 = {}
scores_list1 = []
for k in Krange1:
knn = KNeighborsClassifier(n_neighbors = k)
knn.fit(x_train1,x_test)
y_pred = knn.predict(y_train1)
scores1[k] = metrics.accuracy_score(result['Survived'],y_pred)
scores_list1.append(metrics.accuracy_score(result['Survived'],y_pred))
plt.plot(K... | Titanic - Machine Learning from Disaster |
10,773,116 | xg= xgb.XGBClassifier(
n_estimators=750,
learning_rate=0.015,
min_child_weight= 59,
max_delta_step= 6,
max_depth= 6,
subsample= 0.751,
colsample_bytree= 0.8595,
gamma= 0,
reg_lambda= 37,
random_state=42,
n_jobs=-1,
)<save_to_csv> | knn = KNeighborsClassifier(n_neighbors = 11)
Estimator.append(( 'knn',KNeighborsClassifier(n_neighbors = 13)))
cv = cross_val_score(knn,x_train1,x_test,cv=10)
Accuracy9 = cv.mean()
Accuracy.append(Accuracy9)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,773,116 | xg.fit(X_train, y_train)
predictions = xg.predict_proba(test)[:, 1]
meta_df = pd.DataFrame(columns=['image_name', 'target'])
meta_df['image_name'] = sample['image_name']
meta_df['target'] = predictions
meta_df.to_csv('external_tabular_predicts.csv', header=True, index=False )<save_to_csv> | knn.fit(x_train1,x_test)
knn.score(y_train1,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | effnet = pd.read_csv('.. /input/blended-effnets-from-previous-notebook/blended_effnets.csv')
meta = pd.read_csv('./external_tabular_predicts.csv')
sample['target'] =(
effnet['target'] * 0.9 +
meta['target'] * 0.1
)
sample.to_csv('external_meta_ensembled.csv', header=True, index=False )<install_modules> | model19pred = knn.predict(y_train)
submission19 = pd.DataFrame(columns = ['PassengerId','Survived'])
submission19['PassengerId'] = result['PassengerId']
submission19['Survived'] = model19pred
submission19.to_csv('KNN(StdScaler ).csv',index = False ) | Titanic - Machine Learning from Disaster |
10,773,116 | !pip install -q efficientnet >> /dev/null<import_modules> | models = ['Logistic Regression','SVM Linear Classifier','SVM Polynomial Classifier','Decision Tree','Multinomial NB','Random Forest Classifier','Gradient Boost Classifier','XG Boosting','K-Nearest Neighbors(StdScaler)']
total = list(zip(models,Accuracy))
output2 = pd.DataFrame(total, columns = ['Models after Hyperparam... | Titanic - Machine Learning from Disaster |
10,773,116 | import pandas as pd, numpy as np
from kaggle_datasets import KaggleDatasets
import tensorflow as tf, re, math
import tensorflow.keras.backend as K
import efficientnet.tfkeras as efn
from sklearn.model_selection import KFold
from sklearn.metrics import roc_auc_score
import matplotlib.pyplot as plt<load_from_csv> | vot_soft1 = VotingClassifier(estimators = Estimator, voting ='soft')
vot_soft1.fit(x_train, x_test)
y_pred = vot_soft1.predict(y_train)
vot_soft1.score(y_train,y_test)
modelpred3 = vot_soft1.predict(y_train)
sub3 = pd.DataFrame(columns = ['PassengerId','Survived'])
sub3['PassengerId'] = result['PassengerId']
sub3... | Titanic - Machine Learning from Disaster |
10,773,116 |
<load_from_csv> | vot_soft1.fit(x_train, x_test)
vot_soft1.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 |
<load_from_csv> | vot_hard1 = VotingClassifier(estimators = Estimator, voting ='hard')
vot_hard1.fit(x_train, x_test)
y_pred = vot_hard1.predict(y_train)
vot_hard1.score(y_train,y_test)
modelpred4 = vot_hard1.predict(y_train)
sub4 = pd.DataFrame(columns = ['PassengerId','Survived'])
sub4['PassengerId'] = result['PassengerId']
sub4... | Titanic - Machine Learning from Disaster |
10,773,116 | DEVICE = "TPU"
train = pd.read_csv('.. /input/siim-isic-melanoma-classification/train.csv')
test = pd.read_csv('.. /input/siim-isic-melanoma-classification/test.csv')
sub = pd.read_csv('.. /input/siim-isic-melanoma-classification/sample_submission.csv')
FOLDS = 8
IMG_SIZES = [128, 192, 256, 256, 256, 384, 384, 512]
... | vot_hard1.fit(x_train, x_test)
vot_hard1.score(y_train,y_test ) | Titanic - Machine Learning from Disaster |
10,773,116 | if DEVICE == "TPU":
print("connecting to TPU...")
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
print("Could not connect to TPU")
tpu = None
if tpu:
try:
print("initializing TPU...")
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.exp... | output = pd.concat([output1,output2],axis = 1)
output.sort_values(by=['Accuracy after HT'], inplace=True, ascending=False)
output.head(10 ) | Titanic - Machine Learning from Disaster |
9,918,480 | GCS_PATH = [None]*FOLDS; GCS_PATH2 = [None]*FOLDS
for i,k in enumerate(IMG_SIZES):
GCS_PATH[i] = KaggleDatasets().get_gcs_path('melanoma-%ix%i'%(k,k))
GCS_PATH2[i] = KaggleDatasets().get_gcs_path('isic2019-%ix%i'%(k,k))
files_train = np.sort(np.array(tf.io.gfile.glob(GCS_PATH[0] + '/train*.tfrec')))
files_test = np.so... | dataframe = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv('/kaggle/input/titanic/test.csv')
| Titanic - Machine Learning from Disaster |
9,918,480 | ROT_ = 180.0
SHR_ = 2.0
HZOOM_ = 8.0
WZOOM_ = 8.0
HSHIFT_ = 8.0
WSHIFT_ = 8.0<normalization> | sns.countplot(dataframe['Survived'], hue = dataframe['Sex'])
Dead, lives = dataframe.Survived.value_counts()
male, female = dataframe.Sex.value_counts()
print("Percentage of Male on ship:", round(male/(male+female)*100))
print("Percentage of Female on ship:", round(female/(male+female)*100)) | Titanic - Machine Learning from Disaster |
9,918,480 | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
def get_3x3_mat(lst):
return tf.reshape(tf.concat([lst],axis=0), [3,3])
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
... | dataframe.Pclass.unique()
dataframe.Pclass.value_counts()
| Titanic - Machine Learning from Disaster |
9,918,480 | def read_labeled_tfrecord(example):
tfrec_format = {
'image' : tf.io.FixedLenFeature([], tf.string),
'image_name' : tf.io.FixedLenFeature([], tf.string),
'patient_id' : tf.io.FixedLenFeature([], tf.int64),
'sex' : tf.io.FixedLenFeature([], tf.int64),
'age_approx' : tf.io.FixedLenFeature([], tf.int64),
'anatom_site_gene... | sns.countplot(dataframe['Embarked'], hue = dataframe['Survived'] ) | Titanic - Machine Learning from Disaster |
9,918,480 | def get_dataset(files, augment = False, shuffle = False, repeat = False,
labeled=True, return_image_names=True, batch_size=16, dim=256):
ds = tf.data.TFRecordDataset(files, num_parallel_reads=AUTO)
ds = ds.cache()
if repeat:
ds = ds.repeat()
if shuffle:
ds = ds.shuffle(1024*8)
opt = tf.data.Options()
opt.experimental... | dataframe.isnull().values.any()
dataframe.isnull().sum()
| Titanic - Machine Learning from Disaster |
9,918,480 | EFNS = [efn.EfficientNetB0, efn.EfficientNetB1, efn.EfficientNetB2, efn.EfficientNetB3,
efn.EfficientNetB4, efn.EfficientNetB5, efn.EfficientNetB6]
def build_model(dim=128, ef=0):
inp = tf.keras.layers.Input(shape=(dim,dim,3))
base = EFNS[ef](input_shape=(dim,dim,3),weights='imagenet',include_top=False)
x = base(inp)
... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | def get_lr_callback(batch_size=8):
lr_start = 0.000005
lr_max = 0.000020 * REPLICAS * batch_size/16
lr_min = 0.000001
lr_ramp_ep = 5
lr_sus_ep = 0
lr_decay = 0.8
def lrfn(epoch):
if epoch < lr_ramp_ep:
lr =(lr_max - lr_start)/ lr_ramp_ep * epoch + lr_start
elif epoch < lr_ramp_ep + lr_sus_ep:
lr = lr_max
else:
lr =(lr_... | dataframe.isnull().sum()
| Titanic - Machine Learning from Disaster |
9,918,480 | skf = KFold(n_splits=FOLDS,shuffle=True,random_state=42)
oof_pred = []; oof_tar = []; oof_val = []; oof_names = []
preds = np.zeros(( count_data_items(files_test),1))
for fold,(idxT,idxV)in enumerate(skf.split(np.arange(15))):
if DEVICE=='TPU':
if tpu: tf.tpu.experimental.initialize_tpu_system(tpu)
print('
print('
(... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | oof = np.concatenate(oof_pred)
names = np.concatenate(oof_names)
true = np.concatenate(oof_tar)
auc = roc_auc_score(true,oof)
print('Overall OOF AUC with TTA = %.3f'%auc)
df_oof = pd.DataFrame(dict(image_name = names, pred = oof, target=true))
df_oof.to_csv('oof.csv',index=False)
df_oof.head()<create_dataframe> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | ds = get_dataset(files_test, augment=False, repeat=False, dim=IMG_SIZES[fold],
labeled=False, return_image_names=True)
image_names = np.array([img_name.numpy().decode("utf-8")
for img, img_name in iter(ds.unbatch())] )<save_to_csv> | train_set = dataframe.drop(['Name','Cabin', 'Ticket','PassengerId', ], axis = 1)
test_set = test.drop(['Name','Cabin', 'Ticket', 'PassengerId', ], axis = 1)
| Titanic - Machine Learning from Disaster |
9,918,480 | submission = pd.DataFrame(dict(image_name=image_names, target=preds[:,0]))
submission = submission.sort_values('image_name')
submission.to_csv('submission.csv', index=False)
submission.head()<install_modules> | test_set.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | !pip install -q efficientnet
!pip install -q git+https://github.com/AmedeoBiolatti/dsqol<import_modules> | train_set['Embarked'].fillna(train_set['Embarked'].mode() [0], inplace = True)
| Titanic - Machine Learning from Disaster |
9,918,480 | import os, re, time, tqdm
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import metrics, model_selection
import tensorflow as tf
import tensorflow_addons as tfa
from tensorflow import keras
from tensorflow.keras import backend as K
from efficientnet import tfkeras as efnet
from kagg... | y = train_set.iloc[:, 0].values
X = train_set.iloc[:, train_set.columns != 'Survived'].values
print(X[0] ) | Titanic - Machine Learning from Disaster |
9,918,480 | from dsqol.tf import imgaug
from dsqol.tf.data import balance
from dsqol.tf.utils import average
from dsqol.tf import losses<define_variables> | ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [6])], remainder='passthrough')
X = np.array(ct.fit_transform(X))
print(X[2] ) | Titanic - Machine Learning from Disaster |
9,918,480 | SEED = 42
tf.random.set_seed(SEED)
np.random.seed(SEED)
TIME_BUDGET = 2.5 * 3600
FOLDS = 5
INCLUDE_2019 = 0
INCLUDE_2018 = 1
INCLUDE_MALIGNANT = 1
IMG_READ_SIZE = 384
IMG_SIZE = 384
BALANCE_POS_RATIO = False
EFF_NET = 5
LOSS_TYPE = 'BCE'
LOSS_PARAMS = dict(label_smoothing=0.05)
BATCH_SIZE = 32
EPOCHS = 10
TBM = 6
TT... | ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [6])], remainder='passthrough')
test_set = np.array(ct.fit_transform(test_set))
print(test_set[1])
| Titanic - Machine Learning from Disaster |
9,918,480 | DEVICE = "TPU"
print("connecting to TPU...")
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
print("Could not connect to TPU")
tpu = None
if tpu:
try:
print("initializing TPU...")
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experime... | le = LabelEncoder()
X[:, 4 ] = le.fit_transform(X[:,4])
print(X[1])
| Titanic - Machine Learning from Disaster |
9,918,480 | GCS_PATH1 = KaggleDatasets().get_gcs_path('melanoma-%ix%i' %(IMG_READ_SIZE, IMG_READ_SIZE))
GCS_PATH2 = KaggleDatasets().get_gcs_path('isic2019-%ix%i' %(IMG_READ_SIZE, IMG_READ_SIZE))
GCS_PATH3 = KaggleDatasets().get_gcs_path('malignant-v2-%ix%i' %(IMG_READ_SIZE, IMG_READ_SIZE))<load_from_csv> | le = LabelEncoder()
test_set[:, 4] = le.fit_transform(test_set[:,4])
print(test_set[2] ) | Titanic - Machine Learning from Disaster |
9,918,480 | df_base_train = pd.read_csv(".. /input/siim-isic-melanoma-classification/train.csv")
df_base_test = pd.read_csv(".. /input/siim-isic-melanoma-classification/test.csv" )<define_variables> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20 ) | Titanic - Machine Learning from Disaster |
9,918,480 | train_files = tf.io.gfile.glob(os.path.join(GCS_PATH1, "train*.tfrec"))
if INCLUDE_2019:
train_files += tf.io.gfile.glob([os.path.join(GCS_PATH2, "train%.2i*.tfrec" % i)for i in range(1, 30, 2)])
if INCLUDE_2018:
train_files += tf.io.gfile.glob([os.path.join(GCS_PATH2, "train%.2i*.tfrec" % i)for i in range(0, 30, 2)])... | sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test =sc.transform(X_test ) | Titanic - Machine Learning from Disaster |
9,918,480 | test_files = tf.io.gfile.glob(os.path.join(GCS_PATH1, "test*.tfrec"))
print("%d test files found" % len(test_files))<prepare_x_and_y> | rfc=RandomForestClassifier()
parameters= {'n_estimators':[ 100,200,300,400, 600],
'max_depth':[3,4,6,7],
'criterion':['entropy','gini']
}
rfc=GridSearchCV(rfc, param_grid=parameters, cv = 5)
rfc.fit(X_train,y_train)
print("The best value of leanring rate is: ",rfc.best_params_, ) | Titanic - Machine Learning from Disaster |
9,918,480 | def read_labeled_tfrecord(example):
tfrec_format = {
'image' : tf.io.FixedLenFeature([], tf.string),
'image_name' : tf.io.FixedLenFeature([], tf.string),
'target' : tf.io.FixedLenFeature([], tf.int64)
}
example = tf.io.parse_single_example(example, tfrec_format)
return example['image'], example['target']
def read_unl... | rf_model = RandomForestClassifier(criterion= 'gini', n_estimators = 100 ,max_depth = 6, random_state = 0)
rf_model.fit(X_train, y_train)
y_pred = rf_model.predict(X_test)
Random_forest_acc= accuracy_score(y_test, y_pred)
print('acc = ', Random_forest_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | def dropout(image, DIM=256, PROBABILITY = 0.75, CT = 8, SZ = 0.2):
P = tf.cast(tf.random.uniform([],0,1)<PROBABILITY, tf.int32)
if(P==0)|(CT==0)|(SZ==0):
return image
for k in range(CT):
x = tf.cast(tf.random.uniform([],0,DIM),tf.int32)
y = tf.cast(tf.random.uniform([],0,DIM),tf.int32)
WIDTH = tf.cast(SZ*DIM,tf.int3... | model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
LogisticReg_acc= accuracy_score(y_test, y_pred)
print('acc = ', LogisticReg_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | AUG_BS = 64
def base_aug(img):
img = tf.image.random_flip_left_right(img)
img = tf.image.random_saturation(img, 0.7, 1.3)
img = tf.image.random_contrast(img, 0.8, 1.2)
img = tf.image.random_brightness(img, 0.1)
return img
dropout_aug = lambda img, o: dropout(img, DIM=IMG_READ_SIZE, PROBABILITY=0.75, CT=8, SZ=0.15)
... | model = SVC(kernel = 'rbf', random_state = 0)
model.fit(X, y)
y_pred = model.predict(X_test)
SVC_acc = accuracy_score(y_test, y_pred)
print('acc = ', SVC_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | def get_dataset(files, augment=False, repeat=False, shuffle=False, labeled=True, batch_size=16, drop_remainder=False,
dim=256, read_dim=None
)-> tf.data.Dataset:
if read_dim is None:
read_dim = dim
ds = tf.data.TFRecordDataset(files, num_parallel_reads=AUTO)
ds = ds.cache()
if repeat:
ds = ds.repeat()
if shuffle:
ds ... | model = GaussianNB()
model.fit(X, y)
y_pred = model.predict(X_test)
Gaussian_acc = accuracy_score(y_test, y_pred)
print('acc = ', Gaussian_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | def show_dataset(thumb_size, cols, rows, ds):
mosaic = PIL.Image.new(mode='RGB', size=(thumb_size*cols +(cols-1),
thumb_size*rows +(rows-1)))
for idx, data in enumerate(iter(ds)) :
img, target_or_imgid = data
ix = idx % cols
iy = idx // cols
img = np.clip(img.numpy() * 255, 0, 255 ).astype(np.uint8)
img = PIL.Image.f... | model = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
DT_acc = accuracy_score(y_test, y_pred)
print('acc = ', DT_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | show_dataset(128, 8, 2, get_balanced_dataset(train_files, augment=[dropout_aug], cw_augment=[cw_mixup_aug] ).take(10 ).unbatch() )<choose_model_class> | gbc=GradientBoostingClassifier()
parameters= {'n_estimators':[ 50,100,200,300, ],
'max_depth':[3,4,6,7]
}
gbreg=GridSearchCV(gbc, param_grid=parameters, cv = 5)
gbreg.fit(X_train,y_train)
print("The best value of leanring rate is: ",gbreg.best_params_, ) | Titanic - Machine Learning from Disaster |
9,918,480 | def build_model(dim=128, ef=0):
inp = keras.layers.Input(shape=(dim,dim,3))
base = getattr(efnet, 'EfficientNetB%d' % ef )(input_shape=(dim, dim, 3), weights='imagenet', include_top=False)
x = base(inp)
x = keras.layers.GlobalAveragePooling2D()(x)
x = keras.layers.Dense(1 )(x)
x = keras.layers.Activation('sigmoid',... | model_gb = GradientBoostingClassifier(n_estimators = 100, max_depth =4, random_state = 42)
model_gb.fit(X_train, y_train)
y_pred = model_gb.predict(X_test)
GB_acc = accuracy_score(y_test, y_pred)
print('acc = ', GB_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | mult = 1
lr_start = 5e-6
lr_max = 1.25e-6 * GLOBAL_BATCH_SIZE
lr_min = 1e-6
lr_ramp_ep = 5
lr_sus_ep = 0
lr_decay = 0.8
def lrfn(epoch):
if epoch < lr_ramp_ep:
lr =(lr_max - lr_start)/ lr_ramp_ep * epoch + lr_start
elif epoch < lr_ramp_ep + lr_sus_ep:
lr = lr_max
else:
lr =(lr_max - lr_min)* lr_decay**(epoch - lr_ramp_... | classifier = XGBClassifier()
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
xgb_acc = accuracy_score(y_pred, y_test)
print('acc=',xgb_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | CKPT_FOLDER = ".. /working/ckpt"
if not os.path.exists(CKPT_FOLDER):
os.mkdir(CKPT_FOLDER)
folds = list(model_selection.KFold(n_splits=FOLDS, shuffle=True, random_state=SEED ).split(np.arange(15)))
testiness = pd.read_csv(".. /input/spicv-spicy-vi-make-your-cv-more-testy/testiness.csv")
TOTAL_POS = 581 + 2858 * INCL... | print('RF_acc=', Random_forest_acc)
print('Logistic_acc=', LogisticReg_acc)
print('SVC_acc=', SVC_acc)
print('Gaussian_acc=', Gaussian_acc)
print('DecisionTree_acc=', DT_acc)
print('GradBoost_acc=', GB_acc)
print('XGBoost_acc=', xgb_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | VERBOSE = 1
PLOT = 1
histories = []
df_oof = pd.DataFrame() ; df_res = pd.DataFrame()
t_start = time.time()
for fold,(idTrain, idValid)in enumerate(folds):
print("
print(( "
print("
if DEVICE == 'TPU':
if tpu:
tf.tpu.experimental.initialize_tpu_system(tpu)
fold_valid_files = [f for f in train_files if any([int(re.matc... | rf_model = RandomForestClassifier(criterion= 'gini', n_estimators = 100 ,max_depth = 6, random_state = 0)
rf_model.fit(X, y)
final_pred = rf_model.predict(test_set)
final_pred | Titanic - Machine Learning from Disaster |
9,918,480 | xxx = df_oof.groupby('image_name' ).mean().reset_index().merge(df_base_train, on='image_name')
print("OOF AUC(TTA %d)= %.4f" %(TTA, metrics.roc_auc_score(xxx.target, xxx.pred)) )<save_to_csv> | survivors = pd.DataFrame(final_pred, columns = ['Survived'])
len(survivors)
survivors.insert(0, 'PassengerId', test['PassengerId'], True)
survivors | Titanic - Machine Learning from Disaster |
9,918,480 | df_res.to_csv('.. /working/test_res_all.csv', index=False)
df_oof.to_csv('.. /working/oof_res_all.csv', index=False )<save_to_csv> | survivors.to_csv('Submission.csv', index = False ) | Titanic - Machine Learning from Disaster |
9,918,480 | df_res[['image_name', 'pred']].groupby('image_name' ).mean().reset_index().rename({'pred': 'target'}, axis=1 ).to_csv("submission.csv", index=False )<load_from_csv> | dataframe = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv('/kaggle/input/titanic/test.csv')
| Titanic - Machine Learning from Disaster |
9,918,480 | warnings.filterwarnings("ignore")
train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
tokenizer = Tokenizer()
tokenizer.fit_on_texts(list(train["Address"])+ list(test["Address"]))
haha = tokenizer.texts_to_sequences(train["... | sns.countplot(dataframe['Survived'], hue = dataframe['Sex'])
Dead, lives = dataframe.Survived.value_counts()
male, female = dataframe.Sex.value_counts()
print("Percentage of Male on ship:", round(male/(male+female)*100))
print("Percentage of Female on ship:", round(female/(male+female)*100)) | Titanic - Machine Learning from Disaster |
9,918,480 | For the Traveling Santa 2018 competition.All computation is done
within the Kernel, including building the list of primes and creating the TSPLIB file.
The downloaded C codes(in gzipped tar files)are left in the Kernel.
Note: The prime_thread code, built on top of the linkern code from Concorde, uses as a
random seed... | dataframe.Pclass.unique()
dataframe.Pclass.value_counts()
| Titanic - Machine Learning from Disaster |
9,918,480 | cities = pd.read_csv('.. /input/cities.csv', index_col=['CityId'], nrows=None)
cities_1000 = cities * 1000<save_to_csv> | sns.countplot(dataframe['Embarked'], hue = dataframe['Survived'] ) | Titanic - Machine Learning from Disaster |
9,918,480 | def write_tsp(nodes, filename, name='Santa Prime Paths'):
with open(filename, 'w')as f:
f.write('NAME : %s
' % name)
f.write('COMMENT : %s
' % name)
f.write('TYPE : TSP
')
f.write('DIMENSION : %d
' % len(nodes))
f.write('EDGE_WEIGHT_TYPE : EUC_2D
')
f.write('NODE_COORD_SECTION
')
for row in nodes.itertuples() :
f.... | dataframe.isnull().values.any()
dataframe.isnull().sum()
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
rm -r LKH-2.0.9
rm LKH-2.0.9.t*
wget http://akira.ruc.dk/~keld/research/LKH/LKH-2.0.9.tgz<set_options> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
tar xzvf LKH-2.0.9.tgz
cd LKH-2.0.9
make
mv LKH..
cd..
rm -r LKH-2.0.9<set_options> | dataframe.isnull().sum()
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
./LKH par0.par<set_options> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
./LKH par7.par<save_to_csv> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | def write_xy(nodes, filename):
with open(filename, 'w')as f:
f.write('%d
' % len(nodes))
for row in nodes.itertuples() :
f.write('%.12f %.12f
' %(row.X, row.Y))
f.write('EOF
')
write_xy(cities, 'kaggle.xy' )<set_options> | train_set = dataframe.drop(['Name','Cabin', 'Ticket','PassengerId', ], axis = 1)
test_set = test.drop(['Name','Cabin', 'Ticket', 'PassengerId', ], axis = 1)
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
wget http://www.math.uwaterloo.ca/tsp/pm/gen_primes.c
gcc -o gen_primes gen_primes.c -lm
./gen_primes
head primes.txt
rm gen_primes*<set_options> | test_set.isnull().sum() | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
wget http://www.math.uwaterloo.ca/tsp/pm/PM_1.tgz
tar xzvf PM_1.tgz
cd PM_1
make prime_thread
mv prime_thread..
cd..
rm -r PM_1<install_modules> | train_set['Embarked'].fillna(train_set['Embarked'].mode() [0], inplace = True)
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
rm -r PM-LKH*
wget http://www.math.uwaterloo.ca/tsp/pm/PM-LKH-3b.tgz
tar xzvf PM-LKH-3b.tgz
mv PM-LKH-3b PM-LKH
cd PM-LKH
make
rm -r PMSRC_DIV<set_options> | y = train_set.iloc[:, 0].values
X = train_set.iloc[:, train_set.columns != 'Survived'].values
print(X[0] ) | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cp kaggle.xy PM-LKH/
cp santa197769.tsp PM-LKH/
cp primes.txt PM-LKH/primes_list<load_from_csv> | ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [6])], remainder='passthrough')
X = np.array(ct.fit_transform(X))
print(X[2] ) | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
mv submission.csv.. /submission.csv
rm -r DIV
rm -r DIV_TOURS<set_options> | ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [6])], remainder='passthrough')
test_set = np.array(ct.fit_transform(test_set))
print(test_set[1])
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
./run_Segment_Optimization post.tour 5000 post2.tour<load_from_csv> | le = LabelEncoder()
X[:, 4 ] = le.fit_transform(X[:,4])
print(X[1])
| Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
mv submission.csv.. /submission.csv
rm -r DIV
rm -r DIV_TOURS<set_options> | le = LabelEncoder()
test_set[:, 4] = le.fit_transform(test_set[:,4])
print(test_set[2] ) | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
./run_Segment_Optimization post2.tour 7500 post3.tour<load_from_csv> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20 ) | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
mv submission.csv.. /submission.csv
rm -r DIV
rm -r DIV_TOURS<set_options> | sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test =sc.transform(X_test ) | Titanic - Machine Learning from Disaster |
9,918,480 | %%bash
cd PM-LKH
./run_Segment_Optimization post3.tour 6250 post4.tour<load_from_csv> | rfc=RandomForestClassifier()
parameters= {'n_estimators':[ 100,200,300,400, 600],
'max_depth':[3,4,6,7],
'criterion':['entropy','gini']
}
rfc=GridSearchCV(rfc, param_grid=parameters, cv = 5)
rfc.fit(X_train,y_train)
print("The best value of leanring rate is: ",rfc.best_params_, ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.