kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,067,724 | data["MSSubClass"] = data["MSSubClass"].astype(str )<feature_engineering> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2)
acc_log | Titanic - Machine Learning from Disaster |
9,067,724 | data["LotGeometry"] = data["LotArea"] / data["LotFrontage"]
analyse_numeric("LotGeometry" )<feature_engineering> | svc = SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc | Titanic - Machine Learning from Disaster |
9,067,724 | data['LotGeometry'].fillna(0, inplace=True)
data['LotGeometry'] = make_quantile_bins('LotGeometry', 6 )<data_type_conversions> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
9,067,724 | analyse_numeric("LotFrontage" )<feature_engineering> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian | Titanic - Machine Learning from Disaster |
9,067,724 | data['LotFrontage'].fillna(0, inplace=True)
data['LotFrontage'] = make_quantile_bins('LotFrontage', 6 )<data_type_conversions> | perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2)
acc_perceptron | Titanic - Machine Learning from Disaster |
9,067,724 | analyse_numeric("LotArea" )<drop_column> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
9,067,724 | data.drop("Utilities", axis=1, inplace=True )<drop_column> | sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
acc_sgd | Titanic - Machine Learning from Disaster |
9,067,724 | data["LandTopology"] = data["LandContour"] + data["LandSlope"]
data.drop("LandSlope", axis=1, inplace=True)
analyse_categorical("LandTopology" )<concatenate> | decision_tree = DecisionTreeClassifier(random_state = 0, criterion="gini", max_depth = 13)
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
9,067,724 | data = expand_categorical(data, ["Condition1", "Condition2"] )<feature_engineering> | random_forest = RandomForestClassifier(criterion='gini',
n_estimators=500,
max_depth=10,
min_samples_split=5,
min_samples_leaf=1,
max_features='auto',
oob_score=True,
random_state=2,
n_jobs=-1)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_rando... | Titanic - Machine Learning from Disaster |
9,067,724 | data["YearsLastRemod"] = data["YearRemodAdd"] - data["YearBuilt"]
data["YearsLastRemod"] = make_quantile_bins("YearsLastRemod", 3)
analyse_categorical("YearsLastRemod" )<data_type_conversions> | XGBClassifier
xg = XGBClassifier(n_estimators=300, max_depth=13, random_state=2)
xg.fit(X_train, Y_train)
Y_pred_xg = xg.predict(X_test)
xg.score(X_train, Y_train)
acc_xg = round(xg.score(X_train, Y_train)* 100, 2)
acc_xg | Titanic - Machine Learning from Disaster |
9,067,724 | analyse_numeric("YearBuilt" )<feature_engineering> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron',
'Stochastic Gradient Decent', 'Linear SVC',
'Decision Tree'],
'Score': [acc_svc, acc_knn, acc_log,
acc_random_forest, acc_gaussian, acc_perceptron,
acc_sgd, acc_linear_svc, acc_decisi... | Titanic - Machine Learning from Disaster |
9,067,724 | <data_type_conversions><EOS> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": Y_pred
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,770,216 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
8,770,216 | data["YearRemodAdd"] = make_quantile_bins("YearRemodAdd", 8)
analyse_categorical("YearRemodAdd" )<categorify> | train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
train_df.info()
| Titanic - Machine Learning from Disaster |
8,770,216 | data["Exterior1st"].replace(["WdShing"], "Wd Shng", inplace=True)
data["Exterior2nd"].replace(["CmentBd"], "CemntBd", inplace=True)
data["Exterior2nd"].replace(["Brk Cmn"], "BrkComm", inplace=True)
data = expand_categorical(data, ["Exterior1st", "Exterior2nd"] )<data_type_conversions> | test_df = pd.read_csv("/kaggle/input/titanic/test.csv")
test_df.info() | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("MasVnrArea" )<drop_column> | train_df["Age"].isnull().sum() | Titanic - Machine Learning from Disaster |
8,770,216 | data.drop("MasVnrArea", axis=1, inplace=True )<concatenate> | test_df["Age"].isnull().sum() | Titanic - Machine Learning from Disaster |
8,770,216 | data = expand_categorical(data, ["BsmtFinType1", "BsmtFinType2"] )<data_type_conversions> | data = [train_df, test_df]
for dataset in data:
mean = train_df["Age"].mean()
dataset['Age'] = dataset['Age'].fillna(mean)
dataset["Age"] = train_df["Age"].astype(float)
for dataset in data:
dataset.loc[ dataset['Age'] <= 15, 'Age'] = 0
dataset.loc[(dataset['Age'] > 15)&(dataset['Age'] <= 25), 'Age'] = 1
dataset.loc[... | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("BsmtFinSF1")
data["BsmtFinSF1"].fillna(0, inplace=True )<feature_engineering> | train_df.Cabin.value_counts()
| Titanic - Machine Learning from Disaster |
8,770,216 | data['BsmtFinSF1'] = make_quantile_bins('BsmtFinSF1', 3)
analyse_categorical("BsmtFinSF1" )<feature_engineering> | deck = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7, "O": 8}
data = [train_df, test_df]
for dataset in data:
dataset['CabinDeck'] = dataset['Cabin'].fillna("O")
dataset['CabinDeck'] = dataset['Cabin'].astype(str ).str[0]
dataset['CabinDeck'] = dataset['CabinDeck'].map(deck)
dataset['CabinDeck'] = dataset['... | Titanic - Machine Learning from Disaster |
8,770,216 | data["BsmtFinSF2"].fillna(0, inplace=True)
data['BsmtFinSF2'] = np.where(data["BsmtFinSF2"] == 0, 0, 1)
analyse_categorical("BsmtFinSF2" )<drop_column> | train_df = train_df.drop(['Cabin'], axis=1)
test_df.drop(['Cabin'], axis=1, inplace = True ) | Titanic - Machine Learning from Disaster |
8,770,216 | data.drop('BsmtFinSF2', axis=1, inplace=True )<feature_engineering> | test_df['CabinDeck'].value_counts() | Titanic - Machine Learning from Disaster |
8,770,216 | data["BsmtUnfSF"].fillna(0, inplace=True)
data['BsmtUnfSF'] = np.where(data["BsmtUnfSF"] == 0, 0, 1)
analyse_categorical("BsmtUnfSF" )<feature_engineering> | train_df.Embarked.value_counts()
| Titanic - Machine Learning from Disaster |
8,770,216 | data['TotalSF'] = data['TotalBsmtSF'] + data['1stFlrSF'] + data['2ndFlrSF']
analyse_numeric("TotalSF" )<data_type_conversions> | for dataset in data:
dataset['Fare'] = dataset['Fare'].fillna(0)
for dataset in data:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31), 'Fare'] = 2
dataset.loc[(dataset['Fare'] ... | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("1stFlrSF" )<data_type_conversions> | train_df.Embarked.value_counts() | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("2ndFlrSF" )<feature_engineering> | train_df.Sex.value_counts() | Titanic - Machine Learning from Disaster |
8,770,216 | data['has2ndFlr'] = np.where(data["2ndFlrSF"] > 0, 1, 0)
analyse_categorical("has2ndFlr" )<feature_engineering> | embarkedMap = {"S": 0, "C": 1, "Q": 2}
genderMap = {"male": 0, "female": 1}
for dataset in data:
dataset['Embarked'] = dataset['Embarked'].map(embarkedMap)
dataset['Sex'] = dataset['Sex'].map(genderMap ) | Titanic - Machine Learning from Disaster |
8,770,216 | data["LowQualFinSF"].fillna(0, inplace=True)
data['LowQualFinSF'] = np.where(data["LowQualFinSF"] == 0, 0, 1)
analyse_categorical("LowQualFinSF" )<drop_column> | data = [train_df, test_df]
titles = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in data:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.')
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr',\
'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')... | Titanic - Machine Learning from Disaster |
8,770,216 | data.drop("LowQualFinSF", axis=1, inplace=True )<data_type_conversions> | train_df['Ticket'].value_counts()
train_df = train_df.drop(['Ticket'], axis=1)
test_df = test_df.drop(['Ticket'], axis=1 ) | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("GrLivArea" )<drop_column> | train_df = train_df.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
8,770,216 | data["BathroomsBasement"] = data["BsmtFullBath"] + 0.5 * data["BsmtHalfBath"]
analyse_categorical("BathroomsBasement")
data.drop(["BsmtFullBath", "BsmtHalfBath"], axis=1, inplace=True )<drop_column> | X_train = train_df.drop('Survived', axis=1)
Y_train = train_df['Survived'] | Titanic - Machine Learning from Disaster |
8,770,216 | data["Bathrooms"] = data["FullBath"] + 0.5 * data["HalfBath"]
analyse_categorical("Bathrooms")
data.drop(["FullBath", "HalfBath"], axis=1, inplace=True )<drop_column> | X_test = test_df.drop("PassengerId", axis=1 ).copy()
X_test.head(10 ) | Titanic - Machine Learning from Disaster |
8,770,216 | data.drop("KitchenAbvGr", axis=1, inplace=True )<data_type_conversions> | clf_dt = DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='entropy',
max_depth=None, max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=10, min_samples_split=35,
min_weight_fraction_leaf=0.0, presort='deprecated',
random_state=None, splitter='b... | Titanic - Machine Learning from Disaster |
8,770,216 | analyse_numeric("GarageYrBlt" )<feature_engineering> | output = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': Y_pred})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
14,272,371 | data['GarageYrBlt'] = make_quantile_bins('GarageYrBlt', 10)
analyse_categorical("GarageYrBlt", fillnan=5.0 )<data_type_conversions> | train_data= pd.read_csv('.. /input/titanic/train.csv')
train_data.head(10 ) | Titanic - Machine Learning from Disaster |
14,272,371 | analyse_numeric("GarageArea" )<feature_engineering> | test_data=pd.read_csv('.. /input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
14,272,371 | data['GarageArea_Bin'] = make_quantile_bins('GarageArea', 10)
analyse_categorical('GarageArea_Bin' )<data_type_conversions> | print(train_data.isnull().sum())
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
14,272,371 | analyse_numeric('WoodDeckSF' )<feature_engineering> | features=['Pclass', 'Sex' ,'Age', 'SibSp', 'Parch' ,'Fare' ,'Embarked']
y=train_data.Survived
| Titanic - Machine Learning from Disaster |
14,272,371 | data["WoodDeckSF"] = np.where(data["WoodDeckSF"] == 0, 0, 1)
analyse_categorical("WoodDeckSF" )<data_type_conversions> | train_data['Age']=train_data['Age'].fillna(train_data['Age'].mode() [0])
train_data['Embarked']=train_data['Embarked'].fillna(train_data['Embarked'].mode() [0])
test_data['Age']=test_data['Age'].fillna(test_data['Age'].mode() [0])
test_data['Fare']=test_data['Fare'].fillna(test_data['Fare'].median() ) | Titanic - Machine Learning from Disaster |
14,272,371 | analyse_numeric('OpenPorchSF' )<feature_engineering> | train_data.isnull().sum()
test_data.isnull().sum()
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
X.head() | Titanic - Machine Learning from Disaster |
14,272,371 | data["OpenPorchSF"] = np.where(data["OpenPorchSF"] == 0, 0, 1)
analyse_categorical("OpenPorchSF" )<feature_engineering> | x_train,x_test,y_train,y_test = train_test_split(X,y,test_size=0.25,random_state=6)
sc= StandardScaler()
x_train= sc.fit_transform(x_train)
x_test =sc.transform(x_test)
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(x_train, y_train)
predictions = model.score(x_test,y_test)... | Titanic - Machine Learning from Disaster |
14,272,371 | data["EnclosedPorch"] = np.where(data["EnclosedPorch"] == 0, 0, 1)
analyse_categorical("EnclosedPorch" )<feature_engineering> | sc= StandardScaler()
X= sc.fit_transform(X)
X_test =sc.transform(X_test)
shuffle(X, y,random_state=6 ) | Titanic - Machine Learning from Disaster |
14,272,371 | data["3SsnPorch"] = np.where(data["3SsnPorch"] == 0, 0, 1)
analyse_categorical("3SsnPorch" )<feature_engineering> | 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)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
13,870,647 | data["ScreenPorch"] = np.where(data["ScreenPorch"] == 0, 0, 1)
analyse_categorical("ScreenPorch" )<feature_engineering> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
13,870,647 | data["PoolArea"] = np.where(data["PoolArea"] == 0, 0, 1)
analyse_categorical("PoolArea" )<drop_column> | Sib = train_data.groupby(['SibSp','Survived'])
Sibf = pd.DataFrame(Sib.count() ['PassengerId'])
print(Sibf)
Par = train_data.groupby(['Parch','Survived'])
Parf = pd.DataFrame(Par.count() ['PassengerId'])
print(Parf ) | Titanic - Machine Learning from Disaster |
13,870,647 | data.drop("PoolQC", axis=1, inplace=True )<drop_column> | train_data.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
13,870,647 | data.drop("MiscVal", axis=1, inplace=True )<drop_column> | train_data['Embarked'] = train_data['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
13,870,647 | data.drop("MoSold", axis=1, inplace=True )<drop_column> | train_data['Title'] = train_data['Name'].map(lambda x:x.split(',')[1].split('.')[0].strip())
train_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
13,870,647 | data.drop("YrSold", axis=1, inplace=True )<categorify> | TitleDict={}
TitleDict['Mr']='Mr'
TitleDict['Mlle']='Miss'
TitleDict['Miss']='Miss'
TitleDict['Master']='Master'
TitleDict['Jonkheer']='Master'
TitleDict['Mme']='Mrs'
TitleDict['Ms']='Mrs'
TitleDict['Mrs']='Mrs'
TitleDict['Don']='Royalty'
TitleDict['Sir']='Royalty'
TitleDict['the Countess']='Royalty'
TitleDict['Dona']=... | Titanic - Machine Learning from Disaster |
13,870,647 | def generate_dummies(data):
features = data.columns[data.dtypes == "object"].to_list()
data = pd.concat([data, pd.get_dummies(data[features])], axis=1)
data.drop(features, axis=1, inplace=True)
return data<categorify> | def fare_category(fare):
if fare <= 4:
return 0
elif fare <= 10:
return 1
elif fare <= 30:
return 2
elif fare <= 45:
return 3
else:
return 4
train_data['Fare_Category'] = train_data['Fare'].map(fare_category ) | Titanic - Machine Learning from Disaster |
13,870,647 | data = generate_dummies(data)
data.head(1 )<prepare_x_and_y> | Ticket_Count = train_data.groupby('Ticket', as_index = False)['PassengerId'].count()
Ticket_Count_0 = Ticket_Count[Ticket_Count.PassengerId == 1]['Ticket']
train_data['GroupTicket'] = np.where(train_data.Ticket.isin(Ticket_Count_0), 0, 1)
| Titanic - Machine Learning from Disaster |
13,870,647 | X_train = data.loc[data_train.index].drop("SalePrice", axis=1)
y_train = data.loc[data_train.index, "SalePrice"]
X_test = data.loc[data_test.index].drop("SalePrice", axis=1)
cv=KFold(10, shuffle=True, random_state=random_state )<train_on_grid> | def file_missing(document):
age_features = ['Age','Fare','Parch','SibSp','Pclass', 'Title']
age_features_dummies = pd.get_dummies(document[age_features])
known_age = age_features_dummies[age_features_dummies.Age.notnull() ].values
unknown_age = age_features_dummies[age_features_dummies.Age.isnull() ].values
X = known_... | Titanic - Machine Learning from Disaster |
13,870,647 | model = KNeighborsRegressor()
pipe = Pipeline([("scaler", RobustScaler()),("knn", model)])
params = {
'knn__n_neighbors': [3, 5, 7, 8, 9, 10, 11, 15, 20,],
'knn__weights': ['uniform', 'distance'],
}
knn_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, n_jobs=-1, scoring='neg_root_mean_squared_error')
kn... | get_features = ["Pclass", "Sex","Age", "Cabin", "Fare", "Embarked","Title", "Familysize", 'GroupTicket','Fare_Category' ]
get_features_dummies = pd.get_dummies(train_data[get_features])
print(get_features_dummies)
| Titanic - Machine Learning from Disaster |
13,870,647 | MODEL_0 = knn_grid.best_estimator_
print(f"Model train / CV score is {train_score:.5f} / {knn_grid.best_score_:.5f}")
<save_to_csv> | scaler = preprocessing.StandardScaler()
age_scale = scaler.fit(get_features_dummies['Age'].values.reshape(-1,1))
get_features_dummies['Age_scaled'] = scaler.fit_transform(get_features_dummies['Age'].values.reshape(-1,1), age_scale)
fare_scale = scaler.fit(get_features_dummies['Fare'].values.reshape(-1,1))
get_features... | Titanic - Machine Learning from Disaster |
13,870,647 | prediction_0 = MODEL_0.predict(X_test)
prediction_0 = np.e ** prediction_0
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_0})
submit.to_csv("MODEL_0.csv",index=False )<train_on_grid> | train_df = get_features_dummies.filter(regex='Age_.*|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*|Title_.*|Familysize|GroupTicket|Fare_Category')
X = train_df.values
y = train_data.Survived
train_X, val_X, train_y, val_y = train_test_split(X, y,test_size=0.2, random_state = 1)
rf_est = ensemble.RandomForestClassifie... | Titanic - Machine Learning from Disaster |
13,870,647 | model = Ridge()
pipe = Pipeline([("scaler", RobustScaler()),("ridge", model)])
params = {
'ridge__alpha': [0.01, 0.1, 1, 10, 100, 1000]
}
ridge_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, n_jobs=-1, scoring='neg_root_mean_squared_error')
ridge_grid.fit(X_train, y_train)
train_score = ridge_grid.sc... | forest = RandomForestClassifier()
cross_validation = StratifiedKFold(n_splits=10)
parameter_grid = {
'max_depth' : [8],
'n_estimators': [30],
'max_features': ['sqrt'],
'min_samples_split': [10],
'min_samples_leaf':[1],
'bootstrap': [True],
}
grid_search = GridSearchCV(forest,
scoring='accuracy',
param_grid=parameter_g... | Titanic - Machine Learning from Disaster |
13,870,647 | MODEL_1 = ridge_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {ridge_grid.best_score_:.5f}")
<save_to_csv> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,870,647 | prediction_1 = MODEL_1.predict(X_test)
prediction_1 = np.e ** prediction_1
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_1})
submit.to_csv("MODEL_1.csv",index=False )<train_on_grid> | test_data['Title'] = test_data['Name'].map(lambda x:x.split(',')[1].split('.')[0].strip())
test_data['Title']=test_data['Title'].map(TitleDict)
test_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
13,870,647 | model = Lasso(max_iter=100000)
pipe = Pipeline([("scaler", MinMaxScaler()),("lasso", model)])
params = {
'lasso__alpha': [0.00001, 0.0001, 0.001, 0.01, 0.1]
}
lasso_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, n_jobs=-1, scoring='neg_root_mean_squared_error')
lasso_grid.fit(X_train, y_train)
train... | test_data, model = file_missing(test_data ) | Titanic - Machine Learning from Disaster |
13,870,647 | MODEL_2 = lasso_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {lasso_grid.best_score_:.5f}")
<save_to_csv> | test_data['Familynum']=test_data['Parch']+test_data['SibSp']+1
test_data['Familysize'] = test_data['Familynum'].map(Family_size ) | Titanic - Machine Learning from Disaster |
13,870,647 | prediction_2 = MODEL_2.predict(X_test)
prediction_2 = np.e ** prediction_2
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_2})
submit.to_csv("MODEL_2.csv",index=False )<train_on_grid> | Ticket_Count = test_data.groupby('Ticket', as_index = False)['PassengerId'].count()
Ticket_Count_0 = Ticket_Count[Ticket_Count.PassengerId == 1]['Ticket']
test_data['GroupTicket'] = np.where(test_data.Ticket.isin(Ticket_Count_0), 0, 1 ) | Titanic - Machine Learning from Disaster |
13,870,647 | model = ElasticNet(max_iter=100000)
pipe = Pipeline([("scaler", MinMaxScaler()),("elastic", model)])
params = {
'elastic__alpha': [0.0001, 0.001, 0.01, 0.1],
'elastic__l1_ratio': [0.001, 0.01, 0.1, 0.5, 1, 10]
}
elastic_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, n_jobs=-1, scoring='neg_root_mean_s... | test_data['Fare_Category'] = test_data['Fare'].map(fare_category ) | Titanic - Machine Learning from Disaster |
13,870,647 | MODEL_3 = elastic_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {elastic_grid.best_score_:.5f}")
<save_to_csv> | test_features_dummies = pd.get_dummies(test_data[get_features])
test_features_dummies['Age_scaled'] = scaler.fit_transform(test_features_dummies['Age'].values.reshape(-1,1), age_scale)
test_features_dummies['Fare_scaled'] = scaler.fit_transform(test_features_dummies['Fare'].values.reshape(-1,1), fare_scale)
test_fea... | Titanic - Machine Learning from Disaster |
13,870,647 | <train_on_grid><EOS> | test = test_features_dummies.filter(regex='Age_.*|Fare_.*|Cabin_.*|Embarked_.*|Sex_.*|Pclass_.*|Title_.*|Familysize|GroupTicket|Fare_Category')
predictions = grid_search.predict(test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions},)
output = output.round(0 ).astype(int)
output... | Titanic - Machine Learning from Disaster |
7,407,205 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_params> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/test.csv")
| Titanic - Machine Learning from Disaster |
7,407,205 | MODEL_4 = svr_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {svr_grid.best_score_:.5f}")
<save_to_csv> | %matplotlib inline
sns.set() | Titanic - Machine Learning from Disaster |
7,407,205 | prediction_4 = MODEL_4.predict(X_test)
prediction_4 = np.e ** prediction_4
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_4})
submit.to_csv("MODEL_4.csv",index=False )<train_on_grid> | train_test_dataset = [train, test]
for dataset in train_test_dataset:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
7,407,205 | model = catboost.CatBoostRegressor(random_seed=random_state, verbose=False)
pipe = Pipeline([("catboost", model)])
params = {
'catboost__learning_rate':[0.01, 0.1, 0.2],
'catboost__depth': [5, 6]
}
catboost_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, scoring='neg_root_mean_squared_error')
catboost... | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
for dataset in train_test_dataset:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
7,407,205 | MODEL_5 = catboost_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {catboost_grid.best_score_:.5f}")
<save_to_csv> | train['Title'].value_counts() | Titanic - Machine Learning from Disaster |
7,407,205 | prediction_5 = MODEL_5.predict(X_test)
prediction_5 = np.e ** prediction_5
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_5})
submit.to_csv("MODEL_5.csv",index=False )<train_on_grid> | train.drop('Name', axis=1, inplace=True)
test.drop('Name', axis=1, inplace=True)
train.drop('Embarked', axis=1, inplace=True)
test.drop('Embarked', axis=1, inplace=True)
train.drop('Cabin', axis=1, inplace=True)
test.drop('Cabin', axis=1, inplace=True)
train.drop('SibSp', axis=1, inplace=True)
test.drop('SibSp',... | Titanic - Machine Learning from Disaster |
7,407,205 | model = XGBRegressor(n_estimators=1000)
pipe = Pipeline([("xgb", model)])
params = {
'xgb__learning_rate': [.01,.02,.03,.05,.07],
'xgb__max_depth': [3, 4, 5]
}
xgb_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, scoring='neg_root_mean_squared_error')
xgb_grid.fit(X_train, y_train)
train_score = xgb_g... | sex_mapping = {"male": 0, "female": 1}
for dataset in train_test_dataset:
dataset['Sex'] = dataset['Sex'].map(sex_mapping ) | Titanic - Machine Learning from Disaster |
7,407,205 | MODEL_6 = xgb_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {xgb_grid.best_score_:.5f}")
<save_to_csv> | train["Age"].fillna(train.groupby("Title")["Age"].transform("median"), inplace=True)
test["Age"].fillna(test.groupby("Title")["Age"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
7,407,205 | prediction_6 = MODEL_6.predict(X_test)
prediction_6 = np.e ** prediction_6
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_6})
submit.to_csv("MODEL_6.csv",index=False )<train_on_grid> | for dataset in train_test_dataset:
dataset.loc[ dataset['Age'] <= 12, 'Age'] = 0,
dataset.loc[(dataset['Age'] > 12)&(dataset['Age'] <= 19), 'Age'] = 1,
dataset.loc[(dataset['Age'] > 19)&(dataset['Age'] <= 30), 'Age'] = 2,
dataset.loc[(dataset['Age'] > 30)&(dataset['Age'] <= 45), 'Age'] = 3,
dataset.loc[(dataset['Age'] ... | Titanic - Machine Learning from Disaster |
7,407,205 | model = lgb.LGBMRegressor(n_estimators=1000)
pipe = Pipeline([("lgb", model)])
params = {
'lgb__num_leaves': [2, 3, 4, 5],
'lgb__max_depth': [3, 4, 5]
}
lgb_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=1, scoring='neg_root_mean_squared_error')
lgb_grid.fit(X_train, y_train)
train_score = lgb_grid.sco... | train["Fare"].fillna(train.groupby("Pclass")["Fare"].transform("median"), inplace=True)
test["Fare"].fillna(test.groupby("Pclass")["Fare"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
7,407,205 | MODEL_7 = lgb_grid.best_estimator_
print(f"Model CV score is {train_score:.5f} / {lgb_grid.best_score_:.5f}")
<save_to_csv> | for dataset in train_test_dataset:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31), 'Fare'] = 2
dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3
| Titanic - Machine Learning from Disaster |
7,407,205 | prediction_7 = MODEL_7.predict(X_test)
prediction_7 = np.e ** prediction_7
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction_7})
submit.to_csv("MODEL_7.csv",index=False )<save_to_csv> | train = train.drop(['PassengerId'], axis=1)
train_data = train.drop('Survived', axis=1)
target = train['Survived'] | Titanic - Machine Learning from Disaster |
7,407,205 | prediction = np.mean([prediction_1, prediction_2, prediction_5, prediction_6, prediction_7], axis=0)
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction})
submit.to_csv("MODEL_8.csv",index=False )<save_to_csv> | from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
import numpy as np | Titanic - Machine Learning from Disaster |
7,407,205 | prediction = np.mean([prediction_2, prediction_3, prediction_5, prediction_6, prediction_7], axis=0)
submit = pd.DataFrame({"Id": data_test.index,"SalePrice": prediction})
submit.to_csv("MODEL_9.csv",index=False )<save_to_csv> | k_fold = KFold(n_splits=10, shuffle=True, random_state=0 ) | Titanic - Machine Learning from Disaster |
7,407,205 | def save_file(predictions):
output = pd.DataFrame({'Id': sample_submission_file.Id,
'SalePrice': predictions})
output.to_csv('submission.csv', index=False)
print("Submission file is saved")
def calculate_root_mean_squared_log_error(y_true, y_pred):
if len(y_pred)!=len(y_true): return 'error_mismatch'
y_pred_new ... | classifier = KNeighborsClassifier(n_neighbors = 15)
scoring = 'accuracy'
score = cross_val_score(classifier, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score)
round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,407,205 | train_data = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv',
index_col='Id')
X_test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv',
index_col='Id')
X = train_data.copy()
X.dropna(axis=0, subset=['SalePrice'], inplace=True)
y = X.SalePrice
X.drop(... | classifier = DecisionTreeClassifier()
scoring = 'accuracy'
score = cross_val_score(classifier, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,407,205 | categorical_cols = [cname for cname in X_train.columns if X_train[cname].dtype == "object"]
numerical_cols = [cname for cname in X_train.columns if X_train[cname].dtype in ['int64',
'float64']]
missing_val_count_by_column_train =(X_train.isnull().sum())
print("Number of missing values in each column:")
print(missing_... | classifier = RandomForestClassifier(n_estimators=100)
scoring = 'accuracy'
score = cross_val_score(classifier, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score)
round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,407,205 | missing_val_count_by_column_numeric =(X_train[numerical_cols].isnull().sum())
print("Number of missing values in numerical columns:")
print(missing_val_count_by_column_numeric[missing_val_count_by_column_numeric > 0] )<define_variables> | classifier = RandomForestClassifier()
classifier.fit(train_data, target)
test_data = test.drop("PassengerId", axis=1 ).copy()
prediction = classifier.predict(test_data ) | Titanic - Machine Learning from Disaster |
7,407,205 | constant_num_cols = ['GarageYrBlt', 'MasVnrArea']
mean_num_cols = list(set(numerical_cols ).difference(set(constant_num_cols)))
constant_categorical_cols = ['Alley', 'MasVnrType', 'BsmtQual', 'BsmtCond', 'BsmtExposure',
'BsmtFinType1', 'BsmtFinType2', 'FireplaceQu','GarageType',
'GarageFinish', 'GarageQual', 'GarageCo... | submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": prediction
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,074,051 | numerical_transformer_m = Pipeline(steps=[
('imputer', SimpleImputer(strategy='mean')) ,
('scaler', StandardScaler())])
numerical_transformer_c = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value=0)) ,
('scaler', StandardScaler())])
categorical_transformer_mf = Pipeline(steps=[
('imputer... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data["Fare"].fillna(train_data.Fare.mean() ,inplace=True)
train_data["Embarked"].fillna(train_data.Embarked.mode() ,inplace=True)
print(train_data.query('PassengerId == 889'))
| Titanic - Machine Learning from Disaster |
14,074,051 | model = XGBRegressor(learning_rate = 0.01,
n_estimators=2500,
max_depth=4,
min_child_weight=1,
gamma=0,
subsample=0.7,
colsample_bytree=0.6,
reg_alpha = 0.1,
reg_lambda = 1.25 )<train_model> | by_sex_class_train = train_data.groupby(['Sex', 'Pclass'])
def impute_median(series):
return series.fillna(series.median())
train_data["Age"].fillna(by_sex_class_train['Age'].transform(impute_median),inplace=True)
print(train_data.query('PassengerId == 889')) | Titanic - Machine Learning from Disaster |
14,074,051 | X_valid_eval = preprocessor.fit(X_train, y_train ).transform(X_valid )<train_model> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
by_sex_class_test = test_data.groupby(['Sex', 'Pclass'])
test_data["Fare"].fillna(test_data.Fare.mean() ,inplace=True)
test_data["Embarked"].fillna(test_data.Embarked.mode() ,inplace=True)
test_data["Age"].fillna(by_sex_class_test['Age'].transform(impute_med... | Titanic - Machine Learning from Disaster |
14,074,051 | fit_params = {"model__early_stopping_rounds": 50,
"model__eval_set": [(X_valid_eval, y_valid)],
"model__verbose": False,
"model__eval_metric" : "rmsle"}<train_model> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
14,074,051 | my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
('model', model)
])
my_pipeline.fit(X_train, y_train, **fit_params)
preds = my_pipeline.predict(X_valid)
score = calculate_root_mean_squared_log_error(y_valid,preds)
print("Score: {}".format(score))
<prepare_output> | men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men ) | Titanic - Machine Learning from Disaster |
14,074,051 | <compute_train_metric><EOS> | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch","Age", "Embarked"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output ... | Titanic - Machine Learning from Disaster |
13,480,826 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
get_ipython().run_line_magic('config', "InlineBackend.figure_format ='retina'")
sns.set(style='white', context='notebook', palette='deep')
sns.set(rc={'figure.figsize':(11.7,8.27)})
| Titanic - Machine Learning from Disaster |
13,480,826 | my_pipeline.fit(X_cv, y)
preds = my_pipeline.predict(X_sub )<save_model> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0 ) | Titanic - Machine Learning from Disaster |
13,480,826 | save_file(preds )<set_options> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
X_train = train.drop('Survived',axis=1 ).copy()
y_train = train['Survived'].copy()
X_test = test.copy()
X = pd.concat([X_train, X_test], axis=0)
X.fillna(-999, inplace=True)
X = pd.get_dummi... | Titanic - Machine Learning from Disaster |
13,480,826 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<install_modules> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
X_train = train.drop('Survived',axis=1 ).copy()
y_train = train['Survived'].copy()
X_test = test.copy()
X = pd.concat([X_train, X_test], axis=0)
X.fillna(-999, inplace=True)
X = pd.get_dummi... | Titanic - Machine Learning from Disaster |
13,480,826 | !pip install git+https://github.com/fastai/fastai<import_modules> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
X_train = train.drop('Survived',axis=1 ).copy()
y_train = train['Survived'].copy()
X_test = test.copy()
X_train.fillna(-999, inplace=True)
X_test.fillna(-999, inplace=True)
def getModelCat()... | Titanic - Machine Learning from Disaster |
13,480,826 | from fastai.vision import *<set_options> | skf = StratifiedKFold(n_splits=5)
scores = np.array([])
for train_idx, val_idx in skf.split(X_train, y_train):
cv_train_x = X_train.iloc[train_idx]
cv_train_y = y_train.iloc[train_idx]
cv_val_x = X_train.iloc[val_idx]
cv_val_y = y_train.iloc[val_idx]
model = getModelXGB()
model = fitModelXGB(model, cv_train_x, cv_tra... | Titanic - Machine Learning from Disaster |
13,480,826 | fastai.utils.collect_env.show_install(1)
<define_variables> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
X = pd.concat([train.copy() , test.copy() ],axis=0)
X = X.drop(['Survived','Name', 'Ticket', 'Cabin'], axis=1)
X['Pclass'] = X['Pclass'] * -1
X['Age'] = X['Age'].fillna(X['Age'].median())
X... | Titanic - Machine Learning from Disaster |
13,480,826 | path = Path('/kaggle/input/')
path.ls()<load_from_csv> | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
X = pd.concat([train.copy() , test.copy() ],axis=0)
X = X.drop(['Survived','Name', 'Ticket', 'Cabin'], axis=1)
X['Pclass'] = X['Pclass'] * -1
X['Age'] = X['Age'].fillna(X['Age'].median())
X... | Titanic - Machine Learning from Disaster |
13,480,826 | df = pd.read_csv(path/'train_v2.csv')
df.head()<feature_engineering> | preds_nn = preds_nn.reshape(418, ).astype('int')
preds = preds_nn + preds_cat + preds_svm + preds_xgb + preds_lgb
preds = np.round(preds / 5)
test['Survived'] = preds_xgb.astype('int' ) | Titanic - Machine Learning from Disaster |
13,480,826 | tfms = get_transforms(flip_vert=True, max_lighting=0.1, max_zoom=1.05, max_warp=0., max_rotate=15.)<load_from_csv> | test['Survived'] = preds_xgb.astype('int' ) | Titanic - Machine Learning from Disaster |
13,480,826 | np.random.seed(42)
src =(ImageList.from_csv(path, 'train_v2.csv', folder='train-jpg', suffix='.jpg')
.split_by_rand_pct(0.2)
.label_from_df(label_delim=' '))
data =(src.transform(tfms, size=128)
.databunch(num_workers=0 ).normalize(imagenet_stats))<define_variables> | test['Survived'] = preds_lgb.astype('int' ) | 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.