kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,119,418 | data2[data2.countries == "Russia"]<feature_engineering> | feature_importances = grid_search2.best_estimator_.feature_importances_
indices_of_top = indices_of_top_k(feature_importances, 25)
X_train_prepared = X_train_prepared[:, indices_of_top]
X_test_prepared = X_test_prepared[:, indices_of_top]
knn_model = KNeighborsClassifier()
params_grid = [
{'n_neighbors': [20, 21, 22, ... | Titanic - Machine Learning from Disaster |
8,119,418 | data2.confirmed = np.log10(data2.confirmed+1)
data2.deaths = np.log10(data2.deaths+1)
old_con = data2["confirmed"].iloc[:-1]
old_con2 = data2["deaths"].iloc[:-1]
data2 = data2.iloc[1:]
data2["pred_conf"] = old_con.values
data2["pred_deaths"] = old_con2.values
data2 = data2.iloc[1:]
data2["delta_conf1"] = old_con.valu... | print("Training dataset accuracy: ", grid_search.best_score_, sep="")
knn_model = grid_search.best_estimator_
knn_predictions = knn_model.predict(X_test_prepared)
print("Test dataset accuracy: ", accuracy_score(y_test_prepared, knn_predictions), sep="" ) | Titanic - Machine Learning from Disaster |
8,119,418 | days_x = 45
model_Confirmed, model_Death = {}, {}
data3 = data2.drop(['Quarantine','world_share', 'migrants','median_age','land_area','fertility_rate','density','Date'], axis='columns')
data3.population = data3.population/10**6
one_hot = pd.get_dummies(data3['Province_State'])
data3 = data3.join(one_hot)
data_Korea ... | knn_final_model = KNeighborsClassifier(algorithm='auto', metric='manhattan', n_neighbors=25, weights='uniform')
knn_final_model.fit(X_train_prepared, y_train_prepared ) | Titanic - Machine Learning from Disaster |
8,119,418 | def pred_score(models, data, death = False, plot = 0):
predictions_all = 0
plt.rcParams['figure.figsize'] = [20, len(models)*10]
data = data[(data.confirmed > 0)]
death_labels = 10**(data.deaths + data.pred_deaths)- 1
labels = 10**(data.confirmed + data.pred_conf)- 1
data = data.drop(['Province_State','ForecastId','con... | titanic_sub_prepared = full_pipeline.fit_transform(titanic_sub)
titanic_sub_prepared = full_pipeline2.fit_transform(titanic_sub)
titanic_sub_prepared = titanic_sub_prepared[:, indices_of_top]
titanic_sub_predictions = knn_final_model.predict(titanic_sub_prepared)
submission = pd.DataFrame({'PassengerId':titanic_sub[... | Titanic - Machine Learning from Disaster |
3,282,978 | treeDepth = 30
mdl = tree.DecisionTreeRegressor(max_depth=treeDepth)
param_grid = {
'n_estimators': [100],
'learning_rate': [0.0002],
'loss' : ["exponential"]
}
regrMdl = ensemble.AdaBoostRegressor(base_estimator=mdl)
model_Confirmed["Adaboost"] = model_selection.RandomizedSearchCV(estimator = regrMdl, param_distribu... | df = pd.read_csv('.. /input/train.csv')
df.head(2 ) | Titanic - Machine Learning from Disaster |
3,282,978 | model_Confirmed["RandomForest"] = ensemble.RandomForestRegressor(n_estimators=200, max_depth=30, random_state=42,
n_jobs = -1 ).fit(train_data, train_labels)
model_Death["RandomForest"] = ensemble.RandomForestRegressor(n_estimators=200, max_depth=30, random_state=42,
n_jobs = -1 ).fit(train_data, train_death)
<train_m... | df[df['Embarked'].isna() ] | Titanic - Machine Learning from Disaster |
3,282,978 | model_Confirmed["Xgboost"] = xgb.XGBRegressor(objective ='reg:squarederror',n_estimators=200, max_depth=20, random_state=42,
n_jobs = -1 ).fit(train_data, train_labels)
model_Death["Xgboost"] = xgb.XGBRegressor(objective ='reg:squarederror',n_estimators=200, max_depth=20, random_state=42,
n_jobs = -1 ).fit(train_data,... | titles = df['Name'].str.extract('([A-za-z]+)\.', expand=False)
titles_df = pd.DataFrame()
titles_df['Title'] = titles
titles_df['Survived'] = df['Survived'] | Titanic - Machine Learning from Disaster |
3,282,978 | pred_score(model, data_pred, death_bool, plot_type )<define_variables> | titles_df['Title'].value_counts().head(6 ) | Titanic - Machine Learning from Disaster |
3,282,978 | days_prog = 30
Matrix_confirmed,Matrix_Death ={},{}
for model_name in model_Confirmed:
new_data_list = new_data[new_data.days_mart == days_x]
labels = new_data_list.countries
predictions_confirmed = []
predictions_Death = []
new_data_list = new_data_list.drop(['Province_State', 'ForecastId','confirmed','countries','dea... | age_eda = df.groupby(['Survived', 'Age'] ).size().rename('count' ).reset_index() | Titanic - Machine Learning from Disaster |
3,282,978 | ans = Matrix_confirmed["Adaboost"].stack().reset_index()
ans_Death = Matrix_Death["Adaboost"].stack().reset_index()
ans["prediction_deaths"] = ans_Death[0]
ans["Province_State"] = new_data.groupby(["countries", "Province_State"] ).max().reset_index() ["Province_State"].tolist() *30
ans.columns = ['Date','Country_Region... | del age_eda
age_eda = df.copy()
age_eda['Age'].dropna(inplace=True)
age_eda['Age'] = age_eda['Age'].astype(int)
age_eda.loc[ age_eda['Age'] <= 11, 'Age'] = 0
age_eda.loc[(age_eda['Age'] > 11)&(age_eda['Age'] <= 18), 'Age'] = 1
age_eda.loc[(age_eda['Age'] > 18)&(age_eda['Age'] <= 22), 'Age'] = 2
age_eda.loc[(age_eda['... | Titanic - Machine Learning from Disaster |
3,282,978 | train_df = pd.read_csv(sorted(paths)[-1])
test_df = pd.read_csv(sorted(paths)[-2])
submission = pd.read_csv(sorted(paths)[-3])
sub_08_04 = pd.read_csv(sorted(paths)[-5] )<import_modules> | from sklearn import linear_model
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import ... | Titanic - Machine Learning from Disaster |
3,282,978 | from statsmodels.tsa.statespace.sarimax import SARIMAX<define_variables> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
train_test = train.append(test, sort=False)
train_test.reset_index(inplace=True)
train_test.drop(['index'], inplace=True, axis=1)
train_test.head(2 ) | Titanic - Machine Learning from Disaster |
3,282,978 | count_len = len(train_df[train_df['Country_Region'] == 'Russia'])
train_cc = []
train_f = []
count = 0
for i in range(int(len(train_df)/ count_len)) :
train_cc.append(train_df.ConfirmedCases[count:count+count_len].values.tolist())
train_f.append(train_df.Fatalities[count:count+count_len].values.tolist())
count += co... | def add_titles(data):
data['Title'] = data['Name'].str.extract('([A-za-z]+)\.', expand=False)
title_mapping = {"Mr": 'Mr',
"Miss": 'Miss',
"Mrs": 'Mrs',
"Master": 'Master',
"Rev": 'Rev',
"Dr": 'Other',
"Col": 'Other',
"Major": 'Other',
"Mlle": 'Other',
"Countess": 'Other',
"Ms": 'Other',
"Lady": 'Other',
"Jonkheer": '... | Titanic - Machine Learning from Disaster |
3,282,978 | delta =(datetime.today().date() - date(2020, 4, 2)).days<train_on_grid> | add_titles(train_test ) | Titanic - Machine Learning from Disaster |
3,282,978 | test_count = len(test_df[test_df['Country_Region'] == 'Russia'])- delta - 1
predicted_cc = []
for i in range(len(train_cc)) :
try:
data1 = train_cc[i]
model1 = SARIMAX(data1, order=(1,1,0), seasonal_order=(1,1,0,12), measurement_error=True)
model1_fit = model1.fit(disp=False)
predicted1 = model1_fit.predict(len(data1... | def clean_fare(data):
data['Fare'] = data['Fare'].fillna(data['Fare'].dropna().median() ) | Titanic - Machine Learning from Disaster |
3,282,978 | predicted_f = []
for i in range(len(train_f)) :
try:
data2 = train_f[i]
model2 = SARIMAX(data2,order=(1,1,0), seasonal_order=(1,1,0,12), measurement_error=True)
model2_fit = model2.fit(disp=False)
predicted2 = model2_fit.predict(len(data2), len(data2)+test_count)
predicted_f.append(predicted2.tolist())
except:
data... | clean_fare(train_test ) | Titanic - Machine Learning from Disaster |
3,282,978 | check_lenght = len(train_cc[0][-delta:])+ len(predicted_cc[0])
if check_lenght == 43:
print('Check OK')
else:
print('Check failed' )<define_variables> | def clean_age(data):
data["Age"] = data.groupby(['Sex','Pclass','Title'])['Age'].transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
3,282,978 | new_countries_idxs = [121, 166, 183, 210, 221, 299, 310]<define_variables> | clean_age(train_test ) | Titanic - Machine Learning from Disaster |
3,282,978 | days_from =(datetime.today().date() - date(2020, 4, 9)).days<filter> | train_test.loc[train_test['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
3,282,978 | sub_08_04[sub_08_04['Country_Region'] == 'Russia'].iloc[14:14+days_from]<filter> | train_test.loc[979, 'Age'] = train_test['Age'].median() | Titanic - Machine Learning from Disaster |
3,282,978 | train_df[train_df['Country_Region'] == 'Russia'].iloc[78:78+days_from]<define_variables> | def bin_age(dataset):
dataset['Age'] = dataset['Age'].astype(int)
dataset.loc[ dataset['Age'] <= 11, 'Age'] = 0
dataset.loc[(dataset['Age'] > 11)&(dataset['Age'] <= 18), 'Age'] = 1
dataset.loc[(dataset['Age'] > 18)&(dataset['Age'] <= 22), 'Age'] = 2
dataset.loc[(dataset['Age'] > 22)&(dataset['Age'] <= 27), 'Age'] = 3
... | Titanic - Machine Learning from Disaster |
3,282,978 | sub_count_len = len(sub_08_04[sub_08_04['Country_Region'] == 'Russia'])
sub_0804_cc_preds = []
sub_0804_f_preds = []
sub_count = 0
for i in range(int(len(sub_08_04)/ sub_count_len)) :
sub_0804_cc_preds.append(sub_08_04.ConfirmedCases[sub_count+14:sub_count+14+days_from].values.tolist())
sub_0804_f_preds.append(sub_08... | def clean_embarked(data):
data['Embarked'] = data['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
3,282,978 | train_count_len = len(train_df[train_df['Country_Region'] == 'Russia'])
train_cc_act = []
train_f_act = []
train_count = 0
for i in range(int(len(train_df)/ train_count_len)) :
train_cc_act.append(train_df.ConfirmedCases[train_count+78:train_count+78+days_from].values.tolist())
train_f_act.append(train_df.Fatalities[... | def clean_cabin(data):
data['Cabin'].fillna('U', inplace=True)
data['Cabin'] = data['Cabin'].map(lambda x: x[0] ) | Titanic - Machine Learning from Disaster |
3,282,978 | train_0804_cc_act = []
train_0804_f_act = []
for i in range(len(train_cc_act)) :
if i not in new_countries_idxs:
train_0804_cc_act.append(train_cc_act[i])
train_0804_f_act.append(train_f_act[i] )<categorify> | def clean_family(data):
data['FamilySize'] = data['SibSp'] + data['Parch'] + 1
data.drop(['SibSp', 'Parch'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
3,282,978 | div_act_sub_cc = []
div_act_sub_f = []
for i in range(len(train_0804_cc_act)) :
div_act_sub_cc.append([train_0804_cc_act[i][0] / sub_0804_cc_preds[i][0],
train_0804_cc_act[i][1] / sub_0804_cc_preds[i][1]])
div_act_sub_f.append([(train_0804_f_act[i][0]+1)/(sub_0804_f_preds[i][0]+1),
(train_0804_f_act[i][1]+1)/(sub_080... | clean_family(train_test ) | Titanic - Machine Learning from Disaster |
3,282,978 | cc_becs = []
f_becs = []
for i in range(len(div_act_sub_cc)) :
cc_becs.append(np.mean(div_act_sub_cc[i]))
f_becs.append(np.mean(div_act_sub_f[i]))<prepare_output> | def encode(data, labels):
for label in labels:
data = data.join(pd.get_dummies(data[label], prefix = label))
data.drop(label, axis=1, inplace=True)
return data | Titanic - Machine Learning from Disaster |
3,282,978 | for idx in new_countries_idxs:
cc_becs.insert(idx, 1)
f_becs.insert(idx, 1 )<sort_values> | store = train_test.copy() | Titanic - Machine Learning from Disaster |
3,282,978 | predicted_ConfirmedCases = []
predicted_Fatalities = []
for i in range(int(len(train_df)/ count_len)) :
predicted_ConfirmedCases.append(train_cc[i][-delta:])
predicted_ConfirmedCases.append(predicted_cc[i])
predicted_Fatalities.append(train_f[i][-delta:])
predicted_Fatalities.append(predicted_f[i])
predicted_Confir... | train_test = encode(train_test, ['Pclass', 'Sex', 'Embarked', 'Title', 'Cabin'])
train_test.head(1 ).T | Titanic - Machine Learning from Disaster |
3,282,978 | mod_predicted_cc = []
mod_predicted_f = []
part = 1
for i in range(len(predicted_cc)) :
mod_predicted_cc.append([x*(cc_becs[i]*part)for x in predicted_cc[i]])
mod_predicted_f.append([x*(f_becs[i]*part)for x in predicted_f[i]] )<define_variables> | train = train_test.loc[:890, :]
test = train_test.loc[891:, :] | Titanic - Machine Learning from Disaster |
3,282,978 | mean_ConfirmedCases_preds = []
mean_Fatalities_preds = []
for i in range(int(len(predicted_ConfirmedCases))):
mean_ConfirmedCases_preds.append(predicted_ConfirmedCases[i] * 0.15 + m_predicted_ConfirmedCases[i] * 0.85)
mean_Fatalities_preds.append(predicted_Fatalities[i] * 0.15 + m_predicted_Fatalities[i] * 0.85 )<prep... | def model(classifier, train, test):
target = train['Survived'].values
features = train.drop(['PassengerId', 'Survived', 'Name', 'Ticket'], axis = 1 ).values
scores = cross_val_score(classifier, features, target, cv=5)
print(f'Scores for 5 fold CV: {round(np.mean(scores*100)) }')
classifier_ = classifier.fit(features,... | Titanic - Machine Learning from Disaster |
3,282,978 | submission['ConfirmedCases'] = predicted_ConfirmedCases
submission['Fatalities'] = predicted_Fatalities<create_dataframe> | def submit(predictions):
submission = pd.read_csv('.. /input/gender_submission.csv')
submission['Survived'] = predictions
submission.to_csv('submission.csv', index=False)
return submission | Titanic - Machine Learning from Disaster |
3,282,978 | submission1 = pd.DataFrame(data=submission.ForecastId, columns=['ForecastId'])
submission1['ConfirmedCases'] = m_predicted_ConfirmedCases
submission1['Fatalities'] = m_predicted_Fatalities<create_dataframe> | classifier = linear_model.LogisticRegression(solver='liblinear')
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | submission2 = pd.DataFrame(data=submission.ForecastId, columns=['ForecastId'])
submission2['ConfirmedCases'] = mean_ConfirmedCases_preds
submission2['Fatalities'] = mean_Fatalities_preds<load_from_csv> | classifier = SVC(gamma='auto', kernel='linear')
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | concl_df = pd.read_csv(sorted(paths)[-2])
concl_feats = ['ForecastId', 'Country_Region', 'Date']
conclusion = pd.concat([concl_df[concl_feats], submission[['ConfirmedCases', 'Fatalities']]], axis=1)
concl1_df = pd.read_csv(sorted(paths)[-2])
conclusion1 = pd.concat([concl1_df[concl_feats], submission1[['ConfirmedCas... | classifier = DecisionTreeClassifier(random_state = 1, max_depth = 3)
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | region = 'Russia'
conclusion2[conclusion2['Country_Region'] == region]<feature_engineering> | classifier = GradientBoostingClassifier()
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | original_cc = conclusion[conclusion['Country_Region'] == region]['ConfirmedCases'].values
corrected_cc = conclusion1[conclusion1['Country_Region'] == region]['ConfirmedCases'].values
mean_cc = conclusion2[conclusion2['Country_Region'] == region]['ConfirmedCases'].values
original_f = conclusion[conclusion['Country_Regio... | classifier = KNeighborsClassifier(3)
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | submission2.to_csv('submission.csv', index=False )<import_modules> | classifier = GaussianNB()
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import nltk
from sklearn.preprocessing import LabelBinarizer,LabelEncoder,StandardScaler,MinMaxScaler
from sklearn.linear_model import LogisticRegression,SGDClassifier,LinearRegression
from sklearn.naive_bayes import Multinomia... | classifier = AdaBoostClassifier()
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | train_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
test_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv" )<count_missing_values> | classifier = RandomForestClassifier(n_estimators=100, max_depth = 7)
predictions = model(classifier, train, test ) | Titanic - Machine Learning from Disaster |
3,282,978 | train_df.isna().sum()<count_missing_values> | xg_test = test.drop(['PassengerId', 'Survived', 'Name', 'Ticket'], axis = 1 ).as_matrix()
xg_train = train.drop(['PassengerId', 'Survived', 'Name', 'Ticket'], axis = 1 ).as_matrix()
target = train['Survived'].values
classifier = XGBClassifier()
classifier_ = classifier.fit(xg_train, target)
classifier_.score(xg_train,... | Titanic - Machine Learning from Disaster |
3,282,978 | test_df.isna().sum()<drop_column> | predictions = classifier_.predict(xg_test ).astype(int ) | Titanic - Machine Learning from Disaster |
3,282,978 | train_df['Country_Region'] = train_df['Country_Region'] + ' ' + train_df['Province_State']
test_df['Country_Region'] = test_df['Country_Region'] + ' ' + test_df['Province_State']
del train_df['Province_State']
del test_df['Province_State']<feature_engineering> | Titanic - Machine Learning from Disaster | |
3,282,978 | def split_date(date):
date = date.split('-')
date[0] = int(date[0])
if(date[1][0] == '0'):
date[1] = int(date[1][1])
else:
date[1] = int(date[1])
if(date[2][0] == '0'):
date[2] = int(date[2][1])
else:
date[2] = int(date[2])
return date
train_df.Date = train_df.Date.apply(split_date)
test_df.Date = test_df.Date.a... | submission = submit(predictions)
submission['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
902,619 | year = []
month = []
day = []
for i in train_df.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
data = pd.concat([train, test])
train.shape | Titanic - Machine Learning from Disaster |
902,619 | train_df['Year'] = year
train_df['Month'] = month
train_df['Day'] = day
del train_df['Date']<feature_engineering> | sex_label = LabelEncoder()
cabin_label = LabelEncoder()
embarked_label = LabelEncoder()
family_name_label = LabelEncoder()
title_label = LabelEncoder()
title_remap_label = LabelEncoder()
data['Sex_Code'] = sex_label.fit_transform(data.Sex)
data['Cabin_Prefix'] = data.Cabin.str.get(0 ).fillna('Z')
data['Cabin_Code'] =... | Titanic - Machine Learning from Disaster |
902,619 | year = []
month = []
day = []
for i in test_df.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | m = data[['FamilyName', 'Survived']].groupby('FamilyName' ).max()
c = data[['FamilyName', 'PassengerId']].groupby('FamilyName' ).count()
m = m.rename(columns={'Survived': 'FamilySurvived'})
c = c.rename(columns={'PassengerId': 'FamilyMemberCount'})
m = m.where(m.join(c ).FamilyMemberCount > 1, other=-1, axis=1 ).fill... | Titanic - Machine Learning from Disaster |
902,619 | test_df['Year'] = year
test_df['Month'] = month
test_df['Day'] = day
del test_df['Date']
del train_df['Id']
del test_df['ForecastId']<drop_column> | optimal_d = 20
Z = linkage(ticket.reshape(data.shape[0], 1), 'single')
clusters = fcluster(Z, optimal_d, criterion='distance')
joined_data['Ticket_Code'] = clusters | Titanic - Machine Learning from Disaster |
902,619 | del train_df['Year']
del test_df['Year']<data_type_conversions> | joined_data[['FamilyName',
'Name',
'Age',
'Fare',
'BigFamily',
'Pclass',
'Has_Cabin',
'Embarked',
'Sex',
'Title',
'Ticket_Code',
'Ticket_Code_Remap',
'Survived']][joined_data.Ticket_Code==89].sort_values(by='FamilyName' ) | Titanic - Machine Learning from Disaster |
902,619 | train_df['ConfirmedCases'] = train_df['ConfirmedCases'].apply(int)
train_df['Fatalities'] = train_df['Fatalities'].apply(int )<drop_column> | joined_data[['FamilyName',
'Name',
'Age',
'Fare',
'BigFamily',
'Pclass',
'Has_Cabin',
'Embarked',
'Sex',
'Title',
'Ticket_Code',
'Ticket_Code_Remap',
'Survived']][joined_data.Ticket_Code==186].sort_values(by='FamilyName' ) | Titanic - Machine Learning from Disaster |
902,619 | cases = train_df.ConfirmedCases
fatalities = train_df.Fatalities
del train_df['ConfirmedCases']
del train_df['Fatalities']<categorify> | joined_data[['FamilyName',
'Name',
'Age',
'Fare',
'BigFamily',
'Pclass',
'Has_Cabin',
'Embarked',
'Sex',
'Title',
'Ticket_Code',
'Ticket_Code_Remap',
'Survived']][joined_data.Ticket_Code==127].sort_values(by='FamilyName' ) | Titanic - Machine Learning from Disaster |
902,619 | lb = LabelEncoder()
train_df['Country_Region'] = lb.fit_transform(train_df['Country_Region'])
test_df['Country_Region'] = lb.transform(test_df['Country_Region'] )<normalization> | selected_features = ['Age',
'Fare',
'BigFamily',
'Pclass',
'Has_Cabin',
'Embarked_Code',
'Sex_Code',
'Title_Remap_Code',
'Ticket_Code_Remap',
'FamilySurvived',
]
one_hot_features = ['Pclass',
'BigFamily',
'FamilySurvived',
'Embarked_Code',
'Title_Remap_Code',
'Ticket_Code_Remap',
]
selected_data = joined_data[selected_... | Titanic - Machine Learning from Disaster |
902,619 | scaler = MinMaxScaler()
x_train = scaler.fit_transform(train_df.values)
x_test = scaler.transform(test_df.values )<import_modules> | selected_data_one_hot = pd.get_dummies(selected_data,
columns = one_hot_features)
rescaling_features = ['Age', 'Fare']
std_scaler = StandardScaler()
for f in rescaling_features:
selected_data_one_hot[f] = std_scaler.fit_transform(selected_data_one_hot[f].values.reshape(-1, 1))
train_x = selected_data[:train.shape[0]]
... | Titanic - Machine Learning from Disaster |
902,619 | from xgboost import XGBRegressor<train_model> | parameters = {'n_estimators': [10,50,100,200],
'learning_rate': [0.05, 0.1],
'max_depth': [2,3,4],
'min_samples_leaf': [2,3],
'verbose': [0]}
grid_obj = GridSearchCV(GradientBoostingClassifier() , parameters, scoring = 'roc_auc', cv = 4, n_jobs = 4, verbose = 1)
grid_obj = grid_obj.fit(train_x, train_y)
gb = grid_obj... | Titanic - Machine Learning from Disaster |
902,619 | rf = XGBRegressor(n_estimators = 2500 , random_state = 0 , max_depth = 27)
rf.fit(x_train,cases )<predict_on_test> | model = gb.fit(train_x, train_y)
pred_y = gb.predict(train_x)
f1 = f1_score(train_y, pred_y)
acc = accuracy_score(train_y, pred_y ) | Titanic - Machine Learning from Disaster |
902,619 | cases_pred = rf.predict(x_test)
cases_pred<feature_engineering> | test_y = pd.Series(gb.predict(test_x), name="Survived", dtype='int32')
results = pd.concat([data[train.shape[0]:].PassengerId, test_y], axis=1 ) | Titanic - Machine Learning from Disaster |
902,619 | cases_pred = np.around(cases_pred,decimals = 0)
cases_pred<concatenate> | results.to_csv("gbdt_csv_to_submit.csv",index=False ) | Titanic - Machine Learning from Disaster |
902,619 | x_train_cas = []
for i in range(len(x_train)) :
x = list(x_train[i])
x.append(cases[i])
x_train_cas.append(x)
x_train_cas[0]<prepare_x_and_y> | training_config = {
'gbdt': {
'clf': GradientBoostingClassifier() ,
'parameters': {
'n_estimators': [10,50,100,200],
'learning_rate': [0.05, 0.1],
'max_depth': [2,3,4],
'min_samples_leaf': [2,3],
},
'n_jobs': 4,
'one_hot': False
},
'logit' : {
'clf': LogisticRegression() ,
'parameters': {
'penalty': ['l1', 'l2'],
'C': ... | Titanic - Machine Learning from Disaster |
902,619 | x_train_cas = np.array(x_train_cas )<train_model> | results = { 'name': [], 'f1': [], 'accuracy': [] }
train_pred = {}
test_pred = {}
for name in exp_to_run:
conf = training_config[name]
clf = conf['clf']
parameters = conf['parameters']
n_jobs = conf.get('n_jobs', 1)
one_hot = conf.get('one_hot', True)
print('=' * 20)
print('Starting training:', name)
grid_obj = Gri... | Titanic - Machine Learning from Disaster |
902,619 | rf = XGBRegressor(n_estimators = 2500 , random_state = 0 , max_depth = 27)
rf.fit(x_train_cas,fatalities )<concatenate> | pred_y = pd.DataFrame.from_dict(train_pred ).mean(axis=1)> 0.5
f1 = f1_score(train_y, pred_y)
acc = accuracy_score(train_y, pred_y)
results['name'].append('voting')
results['f1'].append(f1)
results['accuracy'].append(acc)
test_y = pd.Series(pd.DataFrame.from_dict(test_pred ).mean(axis=1)> 0.5,
name="Survived",
dty... | Titanic - Machine Learning from Disaster |
902,619 | <predict_on_test><EOS> | pd.DataFrame.from_dict(results ) | Titanic - Machine Learning from Disaster |
8,612,326 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | sns.set() | Titanic - Machine Learning from Disaster |
8,612,326 | fatalities_pred = np.around(fatalities_pred,decimals = 0)
fatalities_pred<prepare_output> | test = pd.read_csv(".. /input/titanic/test.csv")
train = pd.read_csv(".. /input/titanic/train.csv")
data_cleaner = [train, test] | Titanic - Machine Learning from Disaster |
8,612,326 | submission['ConfirmedCases'] = cases_pred
submission['Fatalities'] = fatalities_pred<save_to_csv> | for data in data_cleaner:
print(data.isnull().sum())
print('
' ) | Titanic - Machine Learning from Disaster |
8,612,326 | submission.to_csv("submission.csv" , index = False )<load_from_csv> | age_ref = pd.DataFrame(data=[train.groupby('Pclass')['Age'].mean() ],columns=train['Pclass'].unique())
age_ref | Titanic - Machine Learning from Disaster |
8,612,326 | train_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
test_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv" )<drop_column> | def fill_age(pclass,age):
if pd.isnull(age):
return float(age_ref[pclass])
else:
return age
for data in data_cleaner:
data['Age'] = train.apply(lambda x: fill_age(x['Pclass'],x['Age']), axis=1 ) | Titanic - Machine Learning from Disaster |
8,612,326 | train_df['Province_State'].fillna("",inplace = True)
test_df['Province_State'].fillna("",inplace = True)
train_df['Country_Region'] = train_df['Country_Region'] + ' ' + train_df['Province_State']
test_df['Country_Region'] = test_df['Country_Region'] + ' ' + test_df['Province_State']
del train_df['Province_State']
del... | def fill_fare(fare):
if pd.isnull(fare):
return train['Fare'].mean()
else:
return fare
def fill_embark(embark):
if pd.isnull(embark):
return train['Embarked'].mode().iloc[0]
else:
return embark
for data in data_cleaner:
data['Fare'] = train.apply(lambda x: fill_fare(x['Fare']), axis=1)
data['Embarked'] = train.apply(l... | Titanic - Machine Learning from Disaster |
8,612,326 | def split_date(date):
date = date.split('-')
date[0] = int(date[0])
if(date[1][0] == '0'):
date[1] = int(date[1][1])
else:
date[1] = int(date[1])
if(date[2][0] == '0'):
date[2] = int(date[2][1])
else:
date[2] = int(date[2])
return date
train_df.Date = train_df.Date.apply(split_date)
test_df.Date = test_df.Date.a... | for data in data_cleaner:
data.drop(['Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,612,326 | year = []
month = []
day = []
for i in train_df.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | for data in data_cleaner:
print(data.isnull().sum())
print('
' ) | Titanic - Machine Learning from Disaster |
8,612,326 | train_df['Year'] = year
train_df['Month'] = month
train_df['Day'] = day
del train_df['Date']<feature_engineering> | title_list = list()
for data in data_cleaner:
for title in data['Name']:
title = title.split('.')[0].split(',')[1]
title_list.append(title)
data['Title'] = title_list
title_list = list() | Titanic - Machine Learning from Disaster |
8,612,326 | year = []
month = []
day = []
for i in test_df.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | for data in data_cleaner:
print(data['Title'].value_counts())
print('
' ) | Titanic - Machine Learning from Disaster |
8,612,326 | test_df['Year'] = year
test_df['Month'] = month
test_df['Day'] = day
del test_df['Date']
del train_df['Id']
del test_df['ForecastId']<train_model> | train['Title'] = train['Title'].replace([ ' Don', ' Rev', ' Dr', ' Mme',' Ms', ' Major', ' Lady', ' Sir', ' Mlle', ' Col', ' Capt',
' the Countess', ' Jonkheer'], 'Others')
train['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,612,326 | rf = XGBRegressor(n_estimators = 1600 , random_state = 0 , max_depth = 15)
rf.fit(x_train,cases)
cases_pred = rf.predict(x_test)
cases_pred = np.around(cases_pred,decimals = 0)
x_train_cas = []
for i in range(len(x_train)) :
x = list(x_train[i])
x.append(cases[i])
x_train_cas.append(x)
x_train_cas[0]
x_train_cas... | test['Title'] = test['Title'].replace([ ' Don', ' Rev', ' Dr', ' Mme',' Ms', ' Major', ' Lady', ' Sir', ' Mlle', ' Col', ' Capt',
' the Countess', ' Jonkheer',' Dona'], 'Others')
test['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,612,326 | plt.style.use('fivethirtyeight')
le = preprocessing.LabelEncoder()
warnings.filterwarnings('ignore' )<import_modules> | def get_size(df):
if df['SibSp'] + df['Parch'] + 1 == 1:
return 'Single'
if df['SibSp'] + df['Parch'] + 1 > 1:
return 'Small'
if df['SibSp'] + df['Parch'] + 1 > 4:
return 'Big'
for data in data_cleaner:
data['FamilySize'] = data.apply(get_size,axis=1)
for data in data_cleaner:
data['IsAlone'] = 1
data['IsAlone'].loc[d... | Titanic - Machine Learning from Disaster |
8,612,326 | import plotly.io as pio
import plotly.express as px
import plotly.graph_objects as go
<load_from_csv> | sex = pd.get_dummies(train['Sex'],drop_first=True)
embark = pd.get_dummies(train['Embarked'],drop_first=True)
title = pd.get_dummies(train['Title'],drop_first=True)
Pclass = pd.get_dummies(train['Pclass'],drop_first=True)
FamilySize = pd.get_dummies(train['FamilySize'],drop_first=True)
sex2 = pd.get_dummies(test['... | Titanic - Machine Learning from Disaster |
8,612,326 | train_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
test_df = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv" )<count_missing_values> | X = train.drop('Survived',axis=1)
y = train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=101 ) | Titanic - Machine Learning from Disaster |
8,612,326 | display(train_df.isnull().sum() /len(train_df)*100)
display(test_df.isnull().sum() /len(test_df)*100 )<rename_columns> | scaler = MinMaxScaler()
scaler.fit(X_train)
scaler.transform(X_train)
scaler.transform(X_test)
scaler.transform(test ) | Titanic - Machine Learning from Disaster |
8,612,326 | train_df.rename(columns={'Province_State':'State','Country_Region':'Country'}, inplace=True)
test_df.rename(columns={'Province_State':'State','Country_Region':'Country'}, inplace=True )<compute_test_metric> | logistic_model = LogisticRegression()
logistic_model.fit(X_train, y_train)
y_pred = logistic_model.predict(X_test ) | Titanic - Machine Learning from Disaster |
8,612,326 | def missings(state, country):
return country if pd.isna(state)== True else state<feature_engineering> | print(classification_report(y_test,y_pred))
print('
')
print(confusion_matrix(y_test,y_pred)) | Titanic - Machine Learning from Disaster |
8,612,326 | <count_unique_values><EOS> | predictions = logistic_model.predict(test)
pred_list = [int(x)for x in predictions]
test2 = pd.read_csv(".. /input/titanic/test.csv")
output = pd.DataFrame({'PassengerId': test2['PassengerId'], 'Survived': pred_list})
output.to_csv('Titanic_with_logistic.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,019,551 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
| Titanic - Machine Learning from Disaster |
11,019,551 | df_plot = train_df.loc[: , ['Date', 'Country', 'ConfirmedCases', 'Fatalities']].groupby(['Date', 'Country'] ).max().reset_index()
df_plot.loc[:, 'Size'] = np.power(df_plot["ConfirmedCases"]+1,0.3)-1
fig = px.scatter_geo(df_plot,
locations="Country",
locationmode = "country names",
hover_name="Country",
color="Confirmed... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,019,551 | data_leak = pd.merge(train_df,test_df, how='inner', on='Date')['Date'].unique().tolist()
data_leak.append('2020-04-01')
data_leak.sort()
print("Both data sets contain the following dates: {}".format(data_leak))<feature_engineering> | train_len = len(train)
test_copy = test.copy() | Titanic - Machine Learning from Disaster |
11,019,551 | def create_features(df):
df['Day_num'] = le.fit_transform(df['Date'])
df['Date'] = pd.to_datetime(df['Date'])
df['Day'] = df['Date'].dt.day
df['Week'] = df['Date'].dt.week
df['Month'] = df['Date'].dt.month
df['DayOfWeek'] = df['Date'].dt.dayofweek
df['Country'] = le.fit_transform(df['Country'])
country_dict = dict(z... | total = train.append(test)
total.isnull().sum() | Titanic - Machine Learning from Disaster |
11,019,551 | df_all, country_dict, state_dict = create_features(df_all )<prepare_x_and_y> | total[total.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
11,019,551 | def train_test_split_extend(df,d,day,filter_col_confirmed,filter_col_fatalities):
df=df.loc[df['Day_num'] >= day]
df_train = df.loc[df['Day_num'] < d]
X_train = df_train
Y_train_1 = df_train['ConfirmedCases']
Y_train_2 = df_train['Fatalities']
X_train_1 = X_train.drop(columns=filter_col_fatalities ).drop(columns='Confi... | total['Fare'].fillna(value = total[total.Pclass==3]['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,019,551 | def lin_reg(X_train, Y_train, x_test):
regr = linear_model.LinearRegression()
regr.fit(X_train, Y_train)
pred = regr.predict(x_test)
return regr, pred<drop_column> | titles = list(total.Title.unique())
for title in titles:
age = total.groupby('Title')['Age'].median().loc[title]
total.loc[(total.Age.isnull())&(total.Title == title),'Age'] = age | Titanic - Machine Learning from Disaster |
11,019,551 | def country_calculation(df_all,country,date,day):
df_country = df_all.copy()
df_country = df_country.loc[df_country['Date'] >= date]
df_country = df_country.loc[df_country['Country'] == country_dict[country]]
features = ['Id', 'State', 'Country','ConfirmedCases', 'Fatalities', 'Day_num']
df_country = df_country[feature... | total['Family_Size'] = total['Parch'] + total['SibSp'] | Titanic - Machine Learning from Disaster |
11,019,551 | def country_state_calculation(df_all,country, state, date,day):
df_country = df_all.copy()
df_country = df_country.loc[df_country['Date'] >= date]
df_country = df_country.loc[df_country['Country'] == country_dict[country] &(df_country['State']==state_dict[state])]
features = ['Id', 'State', 'Country','ConfirmedCases', ... | total['Last_Name'] = total['Name'].apply(lambda x: str.split(x, ",")[0])
total['Fare'].fillna(total['Fare'].mean() , inplace=True)
default_survival_rate = 0.5
total['Family_Survival'] = default_survival_rate
for grp, grp_df in total[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', '... | Titanic - Machine Learning from Disaster |
11,019,551 |
<install_modules> | for _, grp_df in total.groupby('Ticket'):
if(len(grp_df)!= 1):
for ind, row in grp_df.iterrows() :
if(row['Family_Survival'] == 0)|(row['Family_Survival']== 0.5):
smax = grp_df.drop(ind)['Survived'].max()
smin = grp_df.drop(ind)['Survived'].min()
passID = row['PassengerId']
if(smax == 1.0):
total.loc[total['PassengerId... | Titanic - Machine Learning from Disaster |
11,019,551 | !pip install pyramid.arima
<load_from_csv> | total.Sex.replace({'male':0, 'female':1}, inplace = True)
features = ['Survived','Pclass','Sex','Family_Size','Family_Survival','Fare_Bin','Age_Bin']
total = total[features] | Titanic - Machine Learning from Disaster |
11,019,551 | def RMSLE(pred,actual):
return np.sqrt(np.mean(np.power(( np.log(pred+1)-np.log(actual+1)) ,2)))
pd.set_option('mode.chained_assignment', None)
test = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
train = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
train['Province_Stat... | train = total[:train_len]
x_train = train.drop(columns = ['Survived'])
y_train = train['Survived'].astype(int)
x_test = total[train_len:].drop(columns = ['Survived'] ) | Titanic - Machine Learning from Disaster |
11,019,551 | feature_day = [1,5,10,15,20,30,40,50,75,100,150,200,300,400,500,750,1000,1250,1500,1750,2000,2250,2500,2750,3000,3250,3500,3750,4000]
def CreateInput(data):
feature = []
for day in feature_day:
data.loc[:,'Number day from ' + str(day)+ ' case'] = 0
if(train[(train['Country_Region'] == country)&(train['Province_State'] ... | scaler = StandardScaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test ) | Titanic - Machine Learning from Disaster |
11,019,551 | pred_data_all = pd.DataFrame()
for country in train['Country_Region'].unique() :
for province in train[(train['Country_Region'] == country)]['Province_State'].unique() :
print(country + ' and ' + province)
df_train = train[(train['Country_Region'] == country)&(train['Province_State'] == province)]
df_test = test[(test... | clf = KNeighborsClassifier()
params = {'n_neighbors':[6,8,10,12,14,16,18,20],
'leaf_size':list(range(1,50,5)) }
gs = GridSearchCV(clf, param_grid= params, cv = 5,scoring = "roc_auc",verbose=1)
gs.fit(x_train, y_train)
print(gs.best_score_)
print(gs.best_estimator_)
print(gs.best_params_ ) | Titanic - Machine Learning from Disaster |
11,019,551 | <prepare_x_and_y><EOS> | preds = gs.predict(x_test)
pd.DataFrame({'PassengerId': test_copy['PassengerId'], 'Survived': preds} ).to_csv('submission.csv', index = False)
| Titanic - Machine Learning from Disaster |
3,782,114 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | sns.set()
%matplotlib inline | Titanic - Machine Learning from Disaster |
3,782,114 | def crosscheck_sarima(country):
crosscheck = train_df[(train_df['Country'] == country)&(train_df['Date'] >= '2020-04-02')].reset_index()
arima = pred_data_all[(pred_data_all['Country_Region'] == country)].reset_index()
arima['ConfirmedCases_In'] = arima['ConfirmedCases_hat']
arima['Fatalities_In'] = arima['Fatalities_h... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,782,114 | def crosscheck_sarima_cs(country,state):
crosscheck = train_df[(train_df['Country'] == country)&(train_df['State'] == state)&(train_df['Date'] >= '2020-04-02')].reset_index()
arima = pred_data_all[(pred_data_all['Country_Region'] == country)&(pred_data_all['Province_State'] == state)].reset_index()
arima['ConfirmedCase... | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | def rmsle(y, y_pred):
assert len(y)== len(y_pred)
terms_to_sum = [(math.log(y_pred[i] + 1)- math.log(y[i] + 1)) ** 2.0 for i,pred in enumerate(y_pred)]
return(sum(terms_to_sum)*(1.0/len(y)))** 0.5
def fix_target(frame, key, target, new_target_name="target"):
corrections = 0
group_keys = frame[ key].values.tolist()
tar... | test_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | fix_target(train, key, target1, new_target_name=target1)
fix_target(train, key, target2, new_target_name=target2)
rate(train, key, target1, new_target_name="rate_" +target1)
rate(train, key, target2, new_target_name="rate_" +target2)
unique_keys=train[key].unique()
print(len(unique_keys))
train<categorify> | train_df['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
3,782,114 | def get_lags(rate_array, current_index, size=20):
lag_confirmed_rate=[-1 for k in range(size)]
for j in range(0, size):
if current_index-j>=0:
lag_confirmed_rate[j]=rate_array[current_index-j]
else :
break
return lag_confirmed_rate
def days_ago_thresold_hit(full_array, indx, thresold):
days_ago_confirmed_count_10=-1
if... | train_df[["Sex", "Survived"]].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', 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.