kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,886,131 | for i in train,test:
data = i
coord = data[['X','Y']]
pca = PCA(n_components=2)
pca.fit(coord)
coord_pca = pca.transform(coord)
data['coord_pca1'] = coord_pca[:, 0]
data['coord_pca2'] = coord_pca[:, 1]<categorify> | dataset_title = [i.split(",")[1].split(".")[0].strip() for i in data["Name"]]
data['Title']=data.Name.apply(lambda x: x.split('.')[0].split(',')[1].strip())
newtitles={
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer"... | Titanic - Machine Learning from Disaster |
10,886,131 |
<categorify> | grp = data.groupby(['Sex', 'Pclass', 'Title'])
data.Age = grp.Age.apply(lambda x_: x_.fillna(x_.median()))
data.Age.fillna(data.Age.median, inplace=True)
data['AgeRange'] = pd.cut(data['Age'].astype(int), 5 ) | Titanic - Machine Learning from Disaster |
10,886,131 | le1 = LabelEncoder()
train['PdDistrict'] = le1.fit_transform(train['PdDistrict'])
test['PdDistrict'] = le1.transform(test['PdDistrict'])
le2 = LabelEncoder()
X = train.drop(columns=['Category'])
y= le2.fit_transform(train['Category'] )<choose_model_class> | data['Ticket_Lett'] = data['Ticket'].apply(lambda x: str(x)[0])
data['Ticket_Lett'] = data['Ticket_Lett'].apply(lambda x: str(x))
data['Ticket_Lett'] = np.where(( data['Ticket_Lett'] ).isin(['1', '2', '3', 'S', 'P', 'C', 'A']), data['Ticket_Lett'],
np.where(( data['Ticket_Lett'] ).isin(['W', '4', '7', '6', 'L', '5', '... | Titanic - Machine Learning from Disaster |
10,886,131 |
<define_variables> | data.Fare.fillna(data.Fare.mean() , inplace = True)
| Titanic - Machine Learning from Disaster |
10,886,131 |
<train_model> | data.Embarked.fillna(data.Embarked.mode() [0], inplace = True ) | Titanic - Machine Learning from Disaster |
10,886,131 | train_data = lgb.Dataset(X, label=y, categorical_feature=['PdDistrict', ])
params = {'boosting':'gbdt',
'objective':'multiclass',
'num_class':39,
'max_delta_step':0.9,
'min_data_in_leaf': 20,
'learning_rate': 0.29,
'max_bin': 501,
'num_leaves': 41,
'verbose' : 1}
bst = lgb.train(params, train_data, 120)
predictions_l... | data.Cabin.fillna('NA', inplace=True)
data['Cabin'] = data['Cabin'].map(lambda s: s[0] ) | Titanic - Machine Learning from Disaster |
10,886,131 | train_data = lgb.Dataset(X, label=y, categorical_feature=['PdDistrict', ])
params = {'boosting':'gbdt',
'objective':'multiclass',
'num_class':39,
'max_delta_step':0.9,
'min_data_in_leaf': 4,
'learning_rate': 0.29,
'max_bin': 501,
'num_leaves': 41,
'verbose' : 1}
bst = lgb.train(params, train_data, 120)
predictions_lg... | data['Title'] = LabelEncoder().fit_transform(data['Title'])
data = pd.concat([data,
pd.get_dummies(data.Cabin, prefix="Cabin"),
pd.get_dummies(data.AgeRange, prefix="AgeRange"),
pd.get_dummies(data.Embarked, prefix="Embarked", drop_first = True),
pd.get_dummies(data.Title, prefix="Title", drop_first = True),
pd.get_du... | Titanic - Machine Learning from Disaster |
10,886,131 | con2 =(predictions_lgb + predictions_lgb1)/2
con2<prepare_x_and_y> | data.drop(['Pclass', 'Fare','Cabin', 'FareCategory','Name','Salutation', 'Ticket_Lett', 'Ticket','Embarked', 'AgeRange', 'SibSp', 'Parch', 'Age'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,886,131 |
<train_model> | X_pred = data[data.Survived.isnull() ].drop(['Survived'], axis=1)
train_data = data.dropna()
X = train_data.drop(['Survived'], axis=1)
y = train_data['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y)
| Titanic - Machine Learning from Disaster |
10,886,131 |
<save_to_csv> | clf = GradientBoostingClassifier(learning_rate=0.1,
n_estimators=700,
max_depth=2)
clf.fit(X_train, np.ravel(y_train))
print("RF Accuracy: " + repr(round(clf.score(X_test, y_test)* 100, 2)) + "%")
result_rf = cross_val_score(clf, X_train, y_train, cv=5, scoring='accuracy')
print('The cross validated score for Random... | Titanic - Machine Learning from Disaster |
10,886,131 | submission = pd.DataFrame(con2, columns=le2.inverse_transform(np.linspace(0, 38, 39, dtype='int16')) ,
index=test.index)
submission.to_csv('submission.csv', index='Id' )<load_from_csv> | clf = RandomForestClassifier(criterion='entropy',
n_estimators=700,
min_samples_split=5,
min_samples_leaf=1,
max_features = "auto",
oob_score=True,
random_state=0,
n_jobs=-1)
clf.fit(X_train, np.ravel(y_train))
print("RF Accuracy: " + repr(round(clf.score(X_test, y_test)* 100, 2)) + "%")
result_rf = cross_val_score(c... | Titanic - Machine Learning from Disaster |
10,886,131 | train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id' )<count_missing_values> | result = clf.predict(X_pred)
submission = pd.DataFrame({'PassengerId':X_pred.PassengerId,'Survived':result})
submission.Survived = submission.Survived.astype(int)
print(submission.shape)
filename = 'TitanicPredictions4.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
9,863,898 | train.isnull().sum()<count_missing_values> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
9,863,898 | train.isnull().sum()<feature_engineering> | Col_with_missing = [col for col in train_data.columns if train_data[col].isnull().any() ]
print(Col_with_missing ) | Titanic - Machine Learning from Disaster |
9,863,898 | pd.options.display.max_columns=100
train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
def feature_engineering(data):
data['Date'] = pd.to_datetime(data['Dates'].dt.date)
data['n_days'] =(data['Date'] - data['Date'].min() )... | Col_with_missing = [col for col in test_data.columns if test_data[col].isnull().any() ]
print(Col_with_missing ) | Titanic - Machine Learning from Disaster |
9,863,898 | pd.options.display.max_columns=100
train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
def feature_engineering(data):
data['Date'] = pd.to_datetime(data['Dates'].dt.date)
data['n_days'] =(data['Date'] - data['Date'].min() )... | s =(train_data.dtypes == 'object')
object_cols = list(s[s].index)
print("Categorical variables:")
print(object_cols ) | Titanic - Machine Learning from Disaster |
9,863,898 | le1 = LabelEncoder()
train['PdDistrict'] = le1.fit_transform(train['PdDistrict'])
test['PdDistrict'] = le1.transform(test['PdDistrict'])
le2 = LabelEncoder()
X = train.drop(columns=['Category'])
y= le2.fit_transform(train['Category'] )<create_dataframe> | feature_name=['Pclass','Sex','Age','SibSp','Parch','Fare','Embarked']
X=train_data[feature_name]
y=train_data["Survived"]
X_test=test_data[feature_name] | Titanic - Machine Learning from Disaster |
9,863,898 | train_data = lgb.Dataset(X, label=y, categorical_feature=['PdDistrict', ])
params = {'boosting':'gbdt',
'objective':'multiclass',
'num_class':39,
'max_delta_step':0.9,
'min_data_in_leaf': 21,
'learning_rate': 0.4,
'max_bin': 465,
'num_leaves': 41,
'verbose' : 1}
bst = lgb.train(params, train_data, 120)
predictions = ... | X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2 ) | Titanic - Machine Learning from Disaster |
9,863,898 | import pandas as pd
from shapely.geometry import Point
import geopandas as gpd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
import seaborn as sns
from matplotlib import cm
i... | my_imputer=SimpleImputer(strategy="most_frequent")
imputed_X_train= pd.DataFrame(my_imputer.fit_transform(X_train))
imputed_X_test=pd.DataFrame(my_imputer.transform(X_test))
imputed_X_valid=pd.DataFrame(my_imputer.transform(X_valid))
imputed_X_train.index = X_train.index
imputed_X_valid.index = X_valid.index
imputed_X... | Titanic - Machine Learning from Disaster |
9,863,898 | train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id' )<count_duplicates> | Col_with_missing_2 = [col for col in imputed_X_test.columns if imputed_X_test[col].isnull().any() ]
print(Col_with_missing_2 ) | Titanic - Machine Learning from Disaster |
9,863,898 | train.duplicated().sum()<categorify> | New_feature_train = imputed_X_train['Sex'] + "_" + imputed_X_train['Embarked']
New_feature_valid = imputed_X_valid['Sex'] + "_" + imputed_X_valid['Embarked']
New_feature_test = imputed_X_test['Sex'] + "_" + imputed_X_test['Embarked'] | Titanic - Machine Learning from Disaster |
9,863,898 | train.drop_duplicates(inplace=True)
train.replace({'X': -120.5, 'Y': 90.0}, np.NaN, inplace=True)
test.replace({'X': -120.5, 'Y': 90.0}, np.NaN, inplace=True)
imp = SimpleImputer(strategy='mean')
for district in train['PdDistrict'].unique() :
train.loc[train['PdDistrict'] == district, ['X', 'Y']] = imp.fit_transfor... | imputed_X_train["Sex_Embarked"]=New_feature_train
imputed_X_valid["Sex_Embarked"]=New_feature_valid
imputed_X_test["Sex_Embarked"]=New_feature_test | Titanic - Machine Learning from Disaster |
9,863,898 | url = 'https://data.sfgov.org/api/geospatial/wkhw-cjsf?method=export&format=Shapefile'
with urllib.request.urlopen(url)as response, open('pd_data.zip', 'wb')as out_file:
shutil.copyfileobj(response, out_file)
with zipfile.ZipFile('pd_data.zip', 'r')as zip_ref:
zip_ref.extractall('pd_data')
for filename in os.listdir(... | Cat_cols=['Sex','Embarked','Sex_Embarked'] | Titanic - Machine Learning from Disaster |
9,863,898 | naive_vals = train.groupby('Category' ).count().iloc[:,0]/train.shape[0]
n_rows = test.shape[0]
submission = pd.DataFrame(
np.repeat(np.array(naive_vals), n_rows ).reshape(39, n_rows ).transpose() ,
columns=naive_vals.index )<feature_engineering> | OH_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
OH_cols_train = pd.DataFrame(OH_encoder.fit_transform(imputed_X_train[Cat_cols]))
OH_cols_valid = pd.DataFrame(OH_encoder.transform(imputed_X_valid[Cat_cols]))
OH_cols_test = pd.DataFrame(OH_encoder.transform(imputed_X_test[Cat_cols]))
OH_cols_train.ind... | Titanic - Machine Learning from Disaster |
9,863,898 | def feature_engineering(data):
data['Date'] = pd.to_datetime(data['Dates'].dt.date)
data['n_days'] =(
data['Date'] - data['Date'].min() ).apply(lambda x: x.days)
data['Day'] = data['Dates'].dt.day
data['DayOfWeek'] = data['Dates'].dt.weekday
data['Month'] = data['Dates'].dt.month
data['Year'] = data['Dates'].dt.year... | OH_X_train = OH_X_train.apply(pd.to_numeric)
OH_X_valid = OH_X_valid.apply(pd.to_numeric)
OH_X_test = OH_X_test.apply(pd.to_numeric)
OH_X_train=OH_X_train.rename(columns={0:"Sex1", 1:"Sex2"})
OH_X_train=OH_X_train.rename(columns={2:"C", 3:"Q",4:"S"})
OH_X_valid=OH_X_valid.rename(columns={0:"Sex1", 1:"Sex2"})
OH_X... | Titanic - Machine Learning from Disaster |
9,863,898 | train = feature_engineering(train)
train.drop(columns=['Descript','Resolution'], inplace=True)
test = feature_engineering(test)
train.head()<categorify> | my_model = XGBClassifier(n_estimators=1000, learning_rate=0.001)
my_model.fit(OH_X_train, y_train, early_stopping_rounds=50,
eval_set=[(OH_X_valid, y_valid)], verbose=False)
my_model.fit(OH_X_train, y_train)
y_pred5 = my_model.predict(OH_X_valid)
print("Accuracy:",metrics.accuracy_score(y_valid, y_pred5)) | Titanic - Machine Learning from Disaster |
9,863,898 | le1 = LabelEncoder()
train['PdDistrict'] = le1.fit_transform(train['PdDistrict'])
test['PdDistrict'] = le1.transform(test['PdDistrict'])
le2 = LabelEncoder()
y = le2.fit_transform(train.pop('Category'))
train_X, val_X, train_y, val_y = train_test_split(train, y)
model =LGBMClassifier(objective='multiclass', num_clas... | predictions2 = my_model.predict(OH_X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions2})
output.to_csv('my_submission_02_06.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
9,465,380 | train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
train.drop_duplicates(inplace=True)
train.replace({'X': -120.5, 'Y': 90.0}, np.NaN, inplace=True)
test.replace({'X': -120.5, 'Y': 90.0}, np.NaN, inplace=True)
imp = Simp... | df = pd.read_csv("/kaggle/input/titanic/train.csv")
df_test = pd.read_csv("/kaggle/input/titanic/test.csv")
df.head() | Titanic - Machine Learning from Disaster |
9,465,380 | data_for_prediction = test.loc[[846262]]
data_for_prediction<import_modules> | y_train = df["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch", "Honoured"]
X_train = pd.get_dummies(df[features])
X_test = pd.get_dummies(df_test[features] ) | Titanic - Machine Learning from Disaster |
9,465,380 | sns.set(rc={'figure.figsize':(12,8.27)})
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<find_best_model_class> | rf = RandomForestClassifier(n_estimators=200, max_depth=3, random_state=1)
rf.fit(X_train, y_train)
scores = cross_val_score(rf, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores)
print("Mean: ", scores.mean())
print("Standard Deviation: ", scores.std())
| Titanic - Machine Learning from Disaster |
9,465,380 | def train_models(X,y,kfolds=12):
kfold = KFold(kfolds)
for model in models:
cf_result = cross_val_score(model['regressor'], X, y, cv=kfold,scoring='neg_mean_squared_log_error')
model['cv_results'] = np.sqrt(cf_result*-1)
msg = f"Regressor: {model['name']}, rmsle:{cf_result.mean().round(11)} "
print(msg)
class Avera... | lr = LogisticRegression()
lr.fit(X_train, y_train)
scores = cross_val_score(lr, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores)
print("Mean: ", scores.mean())
print("Standard Deviation: ", scores.std() ) | Titanic - Machine Learning from Disaster |
9,465,380 | models = []
models.append({'name':'XBR','regressor':XGBRegressor(random_state=0)})
models.append({'name' :'Random Forest','regressor': RandomForestRegressor(criterion='mse',max_depth=35,max_features='sqrt',n_estimators=150,random_state=0)})
models.append({'name': 'Ridge','regressor' :Ridge(alpha=2.0,copy_X=True,fit_i... | model_svm = svm.SVC()
model_svm.fit(X_train, y_train)
scores_svm = cross_val_score(model_svm, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores_svm)
print("Mean: ", scores_svm.mean())
print("Standard Deviation: ", scores_svm.std() ) | Titanic - Machine Learning from Disaster |
9,465,380 | original_train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
original_test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
y_column = 'SalePrice'
original_train.head()<drop_column> | model_gbc = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
model_gbc.fit(X_train, y_train)
scores_gbc = cross_val_score(model_gbc, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores_gbc)
print("Mean: ", scores_gbc.mean())
print("Standard Deviation... | Titanic - Machine Learning from Disaster |
9,465,380 | train = original_train.copy().drop(columns=['Id'])
test = original_test.copy()<count_missing_values> | model_bagging = BaggingClassifier()
model_bagging.fit(X_train, y_train)
scores_bagging = cross_val_score(model_bagging, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores_bagging)
print("Mean: ", scores_bagging.mean())
print("Standard Deviation: ", scores_bagging.std() ) | Titanic - Machine Learning from Disaster |
9,465,380 | train.isnull().sum().sort_values(ascending=False )<data_type_conversions> | model_gnb = GaussianNB()
model_gnb.fit(X_train, y_train)
scores_gnb = cross_val_score(model_gnb, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores_gnb)
print("Mean: ", scores_gnb.mean())
print("Standard Deviation: ", scores_gnb.std() ) | Titanic - Machine Learning from Disaster |
9,465,380 | no_missing_train = train.copy().drop(columns=['PoolQC','MiscFeature','Alley','Fence'])
no_missing_train.FireplaceQu = no_missing_train.FireplaceQu.fillna('NA')
no_missing_train.BsmtQual = no_missing_train.BsmtQual.fillna('NA')
no_missing_train.BsmtFinType1 = no_missing_train.BsmtFinType1.fillna('NA')
no_missing_tra... | model_xgb = XGBClassifier().fit(X_train, y_train)
model_xgb.score(X_train, y_train)
scores_xgb = cross_val_score(model_xgb, X_train, y_train, cv = 10, scoring = "accuracy")
print("Scores: ",scores_gnb)
print("Mean: ", scores_gnb.mean())
print("Standard Deviation: ", scores_gnb.std() ) | Titanic - Machine Learning from Disaster |
9,465,380 | no_missing_test.isnull().sum().sort_values(ascending=False )<drop_column> | eclf1 = VotingClassifier(estimators=[('rf', rf),('lr', lr),('svm', model_svm),('gbc', model_gbc),('bagging', model_bagging),('gnb', model_gnb),('xgb', model_xgb)], voting='hard')
eclf1 = eclf1.fit(X_train, y_train)
y_pred = eclf1.predict(X_test)
print(y_pred)
output = pd.DataFrame({'PassengerId': df_test.PassengerI... | Titanic - Machine Learning from Disaster |
9,125,986 | train_eng = no_missing_train.copy()
test_eng = no_missing_test.copy()
train_eng['TotalBath'] = train_eng.FullBath +(train_eng.HalfBath * 0.5)
train_eng.drop(columns=['FullBath','HalfBath'],inplace=True)
test_eng['TotalBath'] = test_eng.FullBath +(test_eng.HalfBath * 0.5)
test_eng.drop(columns=['FullBath','HalfBath']... | url="https://github.com/thisisjasonjafari/my-datascientise-handcode/raw/master/005-datavisualization/titanic.csv"
s=requests.get(url ).content
c=pd.read_csv(io.StringIO(s.decode('utf-8')))
test_data_with_labels = c
test_data = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
9,125,986 | X_train_eng = train_eng.drop(columns=[y_column] ).select_dtypes([int,float,bool])
y_train_eng = train_eng[y_column]
X_test_eng = test_eng.drop(columns=['Id'] ).select_dtypes([int,float,bool])
<categorify> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
9,125,986 | train_featured = train_eng.copy()
test_featured = test_eng.copy()
train_featured["SalePrice"] = np.log1p(train_featured["SalePrice"])
qualities = {'NA':0,'Po':1,'Fa':2,'TA':3,'Gd':4,'Ex':5}
train_featured.BsmtQual.replace(qualities,inplace=True)
train_featured.BsmtCond.replace(qualities,inplace=True)
train_featured.... | for i, name in enumerate(test_data_with_labels['name']):
if '"' in name:
test_data_with_labels['name'][i] = re.sub('"', '', name)
for i, name in enumerate(test_data['Name']):
if '"' in name:
test_data['Name'][i] = re.sub('"', '', name ) | Titanic - Machine Learning from Disaster |
9,125,986 | X_train_feat = train_featured.drop(columns=[y_column] ).select_dtypes([int,float,bool])
y_train_feat = train_featured[y_column]
X_test_feat = test_featured.drop(columns=['Id'] ).select_dtypes([int,float,bool])
print("Training model for feature transformation technique")
train_models(X_train_feat,y_train_feat )<creat... | survived = []
for name in test_data['Name']:
survived.append(int(test_data_with_labels.loc[test_data_with_labels['name'] == name]['survived'].values[-1])) | Titanic - Machine Learning from Disaster |
9,125,986 | <train_model><EOS> | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = survived
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,923,801 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
features = ["Pclass", "Sex", "SibSp", "Parch"]
X_train = pd.get_dummies(train_data[features])
y_train = train_data["Survived"]
final_X_test = pd.get_dummies(test_data[features])
input_dim = len(X_train.colu... | Titanic - Machine Learning from Disaster |
9,473,382 | train_out = train_rm.copy()
test_out = test_rm.copy()
train_out = train_out.drop(train_out[train_out.LotArea > 50000].index)
train_out = train_out.drop(train_out[train_out.GrLivArea > 4000].index )<train_model> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
print(train.shape)
train.head(5)
| Titanic - Machine Learning from Disaster |
9,473,382 | X_train_out = train_out.drop(columns=[y_column] ).select_dtypes([int,float,bool])
y_train_out = train_out[y_column]
X_test_out = test_out.drop(columns=['Id'] ).select_dtypes([int,float,bool])
print("Training model for outliers removal technique")
train_models(X_train_out,y_train_out )<categorify> | y = train['Survived'].to_frame()
train.drop('Survived',axis=1,inplace=True)
train['FamilySize'] = train['SibSp'] + train['Parch']
test['FamilySize'] = test['SibSp'] + test['Parch'] | Titanic - Machine Learning from Disaster |
9,473,382 | train_encoded = train_out.copy()
test_encoded = test_out.copy()
train_encoded[train_encoded.select_dtypes('object' ).columns] = train_encoded[train_encoded.select_dtypes('object' ).columns].astype('category')
test_encoded[test_encoded.select_dtypes('object' ).columns] = test_encoded[test_encoded.select_dtypes('object'... | col_with_missing_values = [col for col in train.columns if(train[col].isnull().any()
or test[col].isnull().any())]
numeric_col_with_missing_val = [col for col in col_with_missing_values if
np.issubdtype(train[col].dtype, np.number)]
non_numeric_col_with_missing_val = list(set(col_with_missing_values)- set(numeric_col_w... | Titanic - Machine Learning from Disaster |
9,473,382 | X_train_encoded = train_encoded.drop(columns=[y_column] ).select_dtypes([int,float,bool])
y_train_encoded = train_encoded[y_column]
X_test_encoded = test_encoded.drop(columns=['Id'] ).select_dtypes([int,float,bool])
print("Training model for encoded features technique")
train_models(X_train_encoded,y_train_encoded)
... | train['Cabin'].fillna('0',inplace=True)
test['Cabin'].fillna('0', inplace=True)
train['Cabin'] = train['Cabin'].str[0]
test['Cabin'] = test['Cabin'].str[0]
di = {'A':1,'B':2,'C':3,'D':4,'E':5,'F':6,'G':7,'T':8}
train['Cabin'].replace(di,inplace=True)
test['Cabin'].replace(di,inplace=True)
train['Cabin'].unique() | Titanic - Machine Learning from Disaster |
9,473,382 | estimator = XGBRegressor(random_state=0)
selector = RFE(estimator, n_features_to_select=25, step=1)
selector = selector.fit(X_train_encoded, y_train_encoded)
best_columns = X_train_encoded.columns[selector.support_]
train_models(X_train_encoded[best_columns],y_train_encoded )<train_on_grid> | for col in numeric_col_with_missing_val:
my_dict = train.groupby(['Pclass','Sex'])[col].agg(['median'] ).to_dict()
for(key,value)in my_dict.items() :
for(k1,v1)in value.items() :
train.loc[(( np.isnan(train[col])) |(train[col]==0)) &(train['Pclass']==k1[0])&(train['Sex']==k1[1]),col] = v1
test.loc[(( np.isnan(test[col]... | Titanic - Machine Learning from Disaster |
9,473,382 | parameters ={"alpha" : [0.05, 0.10, 0.50, 0.75, 1, 2,4,5 ] }
rdg = Ridge()
clf = GridSearchCV(rdg, parameters)
clf.fit(X_train_encoded,y_train_encoded )<find_best_params> | def get_outlier_limits(df,col):
q1 = df[col].quantile(0.25)
q3 = df[col].quantile(0.75)
iqr = q3 - q1
ul = q3 + 1.5 * iqr
ll = q1 - 1.5 * iqr
return(ul,ll)
def get_outlier_index(df,col,ul,ll):
return df[(df[col]>ul)|(df[col]<ll)].index
outlier_indices = []
outlier_columns = ['Age','FamilySize','Fare']
for col in out... | Titanic - Machine Learning from Disaster |
9,473,382 | clf.best_params_<train_model> | columns_to_drop = ['Name','PassengerId','Ticket','SibSp','Parch']
train.drop(columns_to_drop, axis=1,inplace=True)
test_passengerId = test['PassengerId']
test.drop(columns_to_drop, axis=1,inplace=True)
train.head() | Titanic - Machine Learning from Disaster |
9,473,382 | best_model = AveragingModels(models =(Ridge(alpha=2.0,copy_X=True,fit_intercept=False,max_iter=1000,normalize=True,random_state=0), RandomForestRegressor(criterion='mse',max_depth=35,max_features='sqrt',n_estimators=150,random_state=0)))
best_model.fit(X_train_encoded,y_train_encoded )<predict_on_test> | t = [('labelencoder',OrdinalEncoder() ,['Sex','IsAlone','Embarked'])]
ct = ColumnTransformer(transformers = t, remainder='passthrough')
train = ct.fit_transform(train)
test = ct.transform(test)
| Titanic - Machine Learning from Disaster |
9,473,382 | predicted = test[['Id']].copy()
predicted['SalePrice'] = np.expm1(best_model.predict(X_test_encoded))
<save_to_csv> | X_train, X_test,y_train, y_test = train_test_split(train,y['Survived'],test_size=0.2,random_state=42)
clf = LogisticRegression(max_iter=1000)
for i in range(1,train.shape[1]+1):
model = SelectKBest(chi2,i)
X_X_train = model.fit_transform(X_train,y_train)
X_X_test = model.transform(X_test)
clf.fit(X_X_train,y_train... | Titanic - Machine Learning from Disaster |
9,473,382 | predicted.to_csv('HousePricingEduardoRenz.csv',index=False )<set_options> | logreg_clf = LogisticRegression(max_iter=1000)
rf_clf = RandomForestClassifier()
dt_clf = DecisionTreeClassifier()
xgb = XGBClassifier()
svm = SVC() | Titanic - Machine Learning from Disaster |
9,473,382 | %matplotlib inline
<load_from_csv> | logreg_clf.fit(X_train,y_train)
rf_clf.fit(X_train,y_train)
dt_clf.fit(X_train,y_train)
xgb.fit(X_train,y_train)
svm.fit(X_train,y_train)
logreg_pred = logreg_clf.predict(X_test)
rf_pred = rf_clf.predict(X_test)
dt_pred = dt_clf.predict(X_test)
xgb_pred = xgb.predict(X_test)
svm_pred = svm.predict(X_test)
ave... | Titanic - Machine Learning from Disaster |
9,473,382 | train_raw=pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test_raw=pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv' )<drop_column> | voting_clf = VotingClassifier(estimators=[('LogReg',logreg_clf),
('RandomForest',rf_clf),
('DecisionTree',dt_clf),
('XGBoost',xgb),
('SVM',svm)], voting='hard')
voting_clf.fit(X_train,y_train)
voting_pred = voting_clf.predict(X_test)
acc = accuracy_score(y_test,voting_pred)
print('Accuracy of voting classifier(... | Titanic - Machine Learning from Disaster |
9,473,382 | train_raw = train_raw.drop(train_raw[(train_raw['GrLivArea']>4000)&(train_raw['SalePrice']<300000)].index )<concatenate> | voting_clf2 = VotingClassifier(estimators=[('LogReg',logreg_clf),
('RandomForest',rf_clf),
('DecisionTree',dt_clf),
('XGBoost',xgb)], voting='soft')
voting_clf2.fit(X_train,y_train)
voting_pred = voting_clf2.predict(X_test)
acc = accuracy_score(y_test,voting_pred)
print('Accuracy of voting classifier(soft)',acc*... | Titanic - Machine Learning from Disaster |
9,473,382 | <set_options><EOS> | voting_clf2.fit(train,y['Survived'])
y_pred=voting_clf.predict(test)
submit = pd.concat([pd.DataFrame(data=test_passengerId,columns=['PassengerId']),pd.DataFrame(data=y_pred, columns=['Survived'])],axis=1)
submit.to_csv('gender_submission.csv',index=False)
| Titanic - Machine Learning from Disaster |
9,507,324 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_missing_values> | import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.multioutput import MultiOutputRegressor
from sklearn.metrics import mean_absolute_error | Titanic - Machine Learning from Disaster |
9,507,324 | nullity=combine.isnull().sum() [ combine.isnull().sum() != 0]
nullity, nullity.shape<count_values> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
df=pd.concat([train,test] ).reset_index() | Titanic - Machine Learning from Disaster |
9,507,324 | combine.MSZoning.value_counts()<count_values> | df[df['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
9,507,324 | combine['MSZoning']=combine['MSZoning'].fillna('None')
combine.MSZoning.value_counts()<groupby> | df['Embarked']=df['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
9,507,324 | combine['LotFrontage']=combine.groupby('Neighborhood')['LotFrontage'].transform(lambda x:x.fillna(x.median()))<count_values> | df[df['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
9,507,324 | combine.Alley.value_counts()<count_values> | t=df[(df['Embarked']=='S')&(df['Pclass']==3)]['Fare'].median()
df['Fare']=df['Fare'].fillna(t ) | Titanic - Machine Learning from Disaster |
9,507,324 | combine['Alley']=combine['Alley'].fillna('None')
combine.Alley.value_counts()<count_values> | Y, X = dmatrices('Survived ~ Pclass+Sex+Fare', df, return_type='dataframe')
vif = pd.DataFrame()
vif["VIF Factor"] = [variance_inflation_factor(X.values, i)for i in range(X.shape[1])]
vif["features"] = X.columns
vif | Titanic - Machine Learning from Disaster |
9,507,324 | combine.Utilities.value_counts()<count_values> | y = train["Survived"]
h=train[(train['Embarked']=='S')&(train['Pclass']==3)]['Fare'].median()
train['Fare']=train['Fare'].fillna(h)
l=test[(test['Embarked']=='S')&(test['Pclass']==3)]['Fare'].median()
test['Fare']=test['Fare'].fillna(l)
features = ["Pclass", "Sex", "Fare"]
X = pd.get_dummies(train[features])
X_test ... | Titanic - Machine Learning from Disaster |
8,856,175 | test_raw.Utilities.value_counts()<count_values> | gender_submission_path = "/kaggle/input/titanic/gender_submission.csv"
train_path = "/kaggle/input/titanic/train.csv"
test_path = "/kaggle/input/titanic/test.csv"
gender_submission = pd.read_csv(gender_submission_path)
train_data = pd.read_csv(train_path)
test_data = pd.read_csv(test_path ) | Titanic - Machine Learning from Disaster |
8,856,175 | combine=combine.drop(['Utilities'],axis=1)
combine.Exterior1st.value_counts()<count_values> | rate_cabin_Nan = 1-(train_data.Cabin.count() /len(train_data.Cabin))
print("% of NaN values: " ,rate_cabin_Nan ) | Titanic - Machine Learning from Disaster |
8,856,175 | combine['Exterior1st']=combine['Exterior1st'].fillna('Other')
combine.Exterior1st.value_counts()<count_values> | combine = [train_data, test_data]
for dataset in combine:
dataset["Sex"] = dataset["Sex"].map({"female": 1, "male" : 0} ).astype(int)
train_data.head() | Titanic - Machine Learning from Disaster |
8,856,175 | combine['Exterior2nd']=combine['Exterior2nd'].fillna('Other')
combine.Exterior2nd.value_counts()<count_values> | frequent_port = train_data.Embarked.dropna().mode() [0]
frequent_port | Titanic - Machine Learning from Disaster |
8,856,175 | combine.MasVnrType.value_counts()<count_values> | for dataset in combine:
dataset["Embarked"] = dataset["Embarked"].map({"S" : 0, "C" : 1, "Q" : 2} ).astype(int)
train_data.head() | Titanic - Machine Learning from Disaster |
8,856,175 | combine['MasVnrType']=combine['MasVnrType'].fillna('None')
combine.MasVnrType.value_counts()<feature_engineering> | y = train_data.Survived
features = ["Pclass", "Sex", "Age", "SibSp", "Parch", "Fare", "Embarked"]
X = train_data[features]
X_test = test_data[features] | Titanic - Machine Learning from Disaster |
8,856,175 | combine['MasVnrArea']=combine['MasVnrArea'].fillna(0)
combine.MasVnrArea.isnull().sum()<count_values> | model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(imputed_X, y)
predictions = model.predict(imputed_X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was success... | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtQual.value_counts()<count_values> | def clean_data(data):
data["Fare"] = data["Fare"].fillna(data["Fare"].dropna().median())
data["Age"] = data["Age"].fillna(data["Age"].dropna().median())
data.loc[data["Sex"] == "male", "Sex"] = 0
data.loc[data["Sex"] == "female", "Sex"] = 1
data["Embarked"] = data["Embarked"].fillna("S")
data.loc[data["Embarked"] ==... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtQual']=combine['BsmtQual'].fillna('None')
combine.BsmtQual.value_counts()<count_values> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtCond.value_counts()<count_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train['Survived'].values
features = train[['Pclass', 'Age', 'Fare', 'Embarked', 'Sex', 'SibSp', 'Parch']].values
classifier = linear_model.LogisticRegression()
classifier_ = classifier.fit(features, target)
print(classifier_.score(feat... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtCond']=combine['BsmtCond'].fillna('None')
combine.BsmtCond.value_counts()<count_values> | poly = preprocessing.PolynomialFeatures(degree=2)
poly_features = poly.fit_transform(features)
classifier_ = classifier.fit(poly_features, target)
print(classifier_.score(poly_features, target)) | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtExposure.value_counts()<count_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train["Survived"].values
features = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]].values
decision_tree = tree.DecisionTreeClassifier(random_state = 42)
decision_tree_ = decision_tree.fit(features, target)
print... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtExposure']=combine['BsmtExposure'].fillna('None')
combine.BsmtExposure.value_counts()<count_values> | generalized_tree = tree.DecisionTreeClassifier(
random_state = 1,
max_depth = 7,
min_samples_split = 2)
generalized_tree_ = generalized_tree.fit(features, target)
scores = model_selection.cross_val_score(generalized_tree, features, target, scoring = 'accuracy', cv = 50)
print(scores)
print(scores.mean() ) | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtFinType1.value_counts()<count_values> | data = export_graphviz(DecisionTreeClassifier(max_depth=3 ).fit(features, target), out_file=None,
feature_names = ['Pclass', 'Age', 'Fare', 'Embarked', 'Sex', 'SibSp', 'Parch'],
class_names = ['Survived(0)', 'Survived(1)'],
filled = True, rounded = True, special_characters = True)
graph = graphviz.Source(data)
graph | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtFinType1']=combine['BsmtFinType1'].fillna('None')
combine.BsmtFinType1.value_counts()<filter> | forest = RandomForestClassifier(random_state = 1)
n_estimators = [1740, 1742, 1745, 1750]
max_depth = [6, 7, 8]
min_samples_split = [4, 5, 6]
min_samples_leaf = [4, 5, 6]
oob_score = ['True']
hyperF = dict(n_estimators = n_estimators, max_depth = max_depth, min_samples_split = min_samples_split, min_samples_leaf = min... | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtFinType1[combine.BsmtFinSF1.isnull() ]<count_missing_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train["Survived"].values
features = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]].values
r_forest = RandomForestClassifier(criterion='gini',bootstrap=True,
n_estimators=1745,
max_depth=7,
min_samples_split=6,
min... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtFinSF1']=combine['BsmtFinSF1'].fillna(0)
combine.BsmtFinSF1.isnull().sum()<count_values> | rf_clf.oob_score_ | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtFinType2.value_counts()<count_values> | value = 1.50
width = 0.75
clf1 = LogisticRegression(random_state=0)
clf2 = RandomForestClassifier(random_state=0)
clf3 = DecisionTreeClassifier(random_state=0)
eclf = EnsembleVoteClassifier(clfs=[clf1, clf2, clf3], weights=[1, 1, 1], voting='soft')
X_list = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp"... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtFinType2']=combine['BsmtFinType2'].fillna('None')
combine.BsmtFinType2.value_counts()<count_missing_values> | test = pd.read_csv("/kaggle/input/titanic/test.csv")
clean_data(test)
prediction = rf_clf.predict(test[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]])
output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': prediction})
output.to_csv('titanic_submission.csv', index=False)
print("Submis... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtFinSF2']=combine['BsmtFinSF2'].fillna(0)
combine.BsmtFinSF2.isnull().sum()<count_missing_values> | def clean_data(data):
data["Fare"] = data["Fare"].fillna(data["Fare"].dropna().median())
data["Age"] = data["Age"].fillna(data["Age"].dropna().median())
data.loc[data["Sex"] == "male", "Sex"] = 0
data.loc[data["Sex"] == "female", "Sex"] = 1
data["Embarked"] = data["Embarked"].fillna("S")
data.loc[data["Embarked"] ==... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtUnfSF']=combine['BsmtUnfSF'].fillna(0)
combine.BsmtUnfSF.isnull().sum()<feature_engineering> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
9,863,354 | combine['TotalBsmtSF']=combine['TotalBsmtSF'].fillna(0)
combine.TotalBsmtSF.isnull().sum()<count_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train['Survived'].values
features = train[['Pclass', 'Age', 'Fare', 'Embarked', 'Sex', 'SibSp', 'Parch']].values
classifier = linear_model.LogisticRegression()
classifier_ = classifier.fit(features, target)
print(classifier_.score(feat... | Titanic - Machine Learning from Disaster |
9,863,354 | combine.Electrical.value_counts()<filter> | poly = preprocessing.PolynomialFeatures(degree=2)
poly_features = poly.fit_transform(features)
classifier_ = classifier.fit(poly_features, target)
print(classifier_.score(poly_features, target)) | Titanic - Machine Learning from Disaster |
9,863,354 | combine.Neighborhood[combine.Electrical.isnull() ]<count_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train["Survived"].values
features = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]].values
decision_tree = tree.DecisionTreeClassifier(random_state = 42)
decision_tree_ = decision_tree.fit(features, target)
print... | Titanic - Machine Learning from Disaster |
9,863,354 | combine[combine.Neighborhood == 'Timber'].Electrical.value_counts()<count_values> | generalized_tree = tree.DecisionTreeClassifier(
random_state = 1,
max_depth = 7,
min_samples_split = 2)
generalized_tree_ = generalized_tree.fit(features, target)
scores = model_selection.cross_val_score(generalized_tree, features, target, scoring = 'accuracy', cv = 50)
print(scores)
print(scores.mean() ) | Titanic - Machine Learning from Disaster |
9,863,354 | combine['Electrical']=combine['Electrical'].fillna('SBrkr')
combine.Electrical.value_counts()<count_values> | data = export_graphviz(DecisionTreeClassifier(max_depth=3 ).fit(features, target), out_file=None,
feature_names = ['Pclass', 'Age', 'Fare', 'Embarked', 'Sex', 'SibSp', 'Parch'],
class_names = ['Survived(0)', 'Survived(1)'],
filled = True, rounded = True, special_characters = True)
graph = graphviz.Source(data)
graph | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtFullBath.value_counts()<count_values> | forest = RandomForestClassifier(random_state = 1)
n_estimators = [1740, 1742, 1745, 1750]
max_depth = [6, 7, 8]
min_samples_split = [4, 5, 6]
min_samples_leaf = [4, 5, 6]
oob_score = ['True']
hyperF = dict(n_estimators = n_estimators, max_depth = max_depth, min_samples_split = min_samples_split, min_samples_leaf = min... | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtFullBath']=combine['BsmtFullBath'].fillna(0)
combine.BsmtFullBath.value_counts()<count_values> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
clean_data(train)
target = train["Survived"].values
features = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]].values
r_forest = RandomForestClassifier(criterion='gini',bootstrap=True,
n_estimators=1745,
max_depth=7,
min_samples_split=6,
min... | Titanic - Machine Learning from Disaster |
9,863,354 | combine.BsmtHalfBath.value_counts()<count_values> | rf_clf.oob_score_ | Titanic - Machine Learning from Disaster |
9,863,354 | combine['BsmtHalfBath']=combine['BsmtHalfBath'].fillna(0)
combine.BsmtHalfBath.value_counts()<count_values> | value = 1.50
width = 0.75
clf1 = LogisticRegression(random_state=0)
clf2 = RandomForestClassifier(random_state=0)
clf3 = DecisionTreeClassifier(random_state=0)
eclf = EnsembleVoteClassifier(clfs=[clf1, clf2, clf3], weights=[1, 1, 1], voting='soft')
X_list = train[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp"... | Titanic - Machine Learning from Disaster |
9,863,354 | combine.KitchenQual.value_counts()<count_values> | test = pd.read_csv("/kaggle/input/titanic/test.csv")
clean_data(test)
prediction = rf_clf.predict(test[["Pclass", "Age", "Fare", "Embarked", "Sex", "SibSp", "Parch"]])
output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': prediction})
output.to_csv('titanic_submission.csv', index=False)
print("Submis... | Titanic - Machine Learning from Disaster |
9,390,314 | combine.KitchenAbvGr.value_counts()<filter> | %matplotlib inline
cf.go_offline() | Titanic - Machine Learning from Disaster |
9,390,314 | combine.KitchenAbvGr[combine.KitchenQual.isnull() ]<count_values> | train_data=pd.read_csv('/kaggle/input/titanic/train.csv')
test_data=pd.read_csv('/kaggle/input/titanic/test.csv')
| Titanic - Machine Learning from Disaster |
9,390,314 | combine.KitchenQual[combine.KitchenAbvGr == 1].value_counts()<count_values> | train_data.isnull().sum().sort_values(ascending = False ) | Titanic - Machine Learning from Disaster |
9,390,314 | combine['KitchenQual']=combine['KitchenQual'].fillna('TA')
combine.KitchenQual.value_counts()<count_values> | test_data.isnull().sum().sort_values(ascending = False ) | 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.