kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,072,456 | def timesteps(data, steps):
results = []
for i in range(len(data)- steps):
results.append(data[i:i+steps+1].values.tolist())
return np.array(results)
def input_reshape(data, shape):
return data.reshape(shape)
def slide1_window(data, value):
data = data.reshape(-1, 2 ).tolist()
new_data = data[1:]
new_data.append(val... | data.groupby(['Sex', 'Pclass'])['Survived'].mean() | Titanic - Machine Learning from Disaster |
12,072,456 | def load_cases(df, feat):
cases = pd.DataFrame(df[feat].values, index=df['Date'])
return cases
def scale_fit(data):
scaler = MinMaxScaler()
scaler.fit(scale_reshape(data))
return scaler
def scale_transform(scaler, data):
return scaler.transform(scale_reshape(data)).reshape(data.shape)
def scale_reshape(data):
results... | train_1=train.loc[(train.Sex=='male')]
test_1=test.loc[(test.Sex=='male')]
train_2=train.loc[(( train.Pclass<=2)&(train.Sex=='female')) ]
test_2=test.loc[(( test.Pclass<=2)&(test.Sex=='female')) ]
train_3=train.loc[(( train.Pclass>2)&(train.Sex=='female')) ]
test_3=test.loc[(( test.Pclass>2)&(test.Sex=='female')) ] | Titanic - Machine Learning from Disaster |
12,072,456 | class covid19_forecaster:
def __init__(self, feat, Country, Province, random_state=0):
self.scalar = None
self.model = None
self.model_input_shape = None
self.history = None
self.last_timestep = None
self.train_date = None
self.difference_node = None
self.feat = feat
self.Country = Country
self.Province = Province
self... | col_final=['Age_T', 'Fare_T', 'Alone', 'Family_Size', 'FamSurvived', 'Title_Miss', 'Title_Mr', 'Title_Mrs'] | Titanic - Machine Learning from Disaster |
12,072,456 | def forecast(train_path, test_path):
df_train = load_csv(train_path)
df_test = load_csv(test_path)
cp = []
for i, row in df_test.iterrows() :
v = row['Country_Region'], row['Province_State']
if v not in cp:
cp.append(v)
feats = ['ConfirmedCases', 'Fatalities']
train_start = 40
train_end = 84
time_steps = 10
diff_deg... | param_lgb ={'n_estimators': [100, 500, 1000, 2000],
'max_depth':[1,2,3,4,5],
'num_leaves': [2,4,6,8,10],
'min_child_samples ': [2,5,10,15,20],
'min_child_weight': [1e-5, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3, 1e4],
'subsample':[0.4,0.5,0.6,0.7,0.8,0.9,1],
'colsample_bytree':[0.4,0.5,0.6,0.7,0.8,0.9,1],
'reg_alpha': [0, 1e... | Titanic - Machine Learning from Disaster |
12,072,456 | predictions = forecast(train_path, test_path )<save_to_csv> | def tune_stack_predict(X_train,y_train,X_test,listModels,listSearchParamM,stackModel,searchParamsModels,listSearchParamS):
models_local=[]
X_test_c=X_test.copy()
for clf, param in zip(listModels,listSearchParamM):
rs_clf=RandomizedSearchCV(estimator=clf, param_distributions=param, **searchParamsModels)
rs_clf.fit(X_tr... | Titanic - Machine Learning from Disaster |
12,072,456 | df_sub = pd.read_csv(sub_path)
feats = ['ConfirmedCases', 'Fatalities']
df_sub[feats] = predictions
df_sub.to_csv('submission.csv', index=False )<set_options> | Titanic - Machine Learning from Disaster | |
12,072,456 | pd.options.display.max_rows = 500
pd.options.display.max_columns = 500
%matplotlib inline
<load_from_csv> | param_meta1={'cv': 10,
'estimators': [['Logis',
LogisticRegression(C=0.4, class_weight=10, l1_ratio=0.5, max_iter=10000,
penalty='l1', random_state=81, solver='saga')],
['Rando',
RandomForestClassifier(max_depth=3, min_samples_leaf=5, min_samples_split=5,
n_estimators=25, random_state=81)],
['LGBMC',
LGBMClassifier(col... | Titanic - Machine Learning from Disaster |
12,072,456 | train = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
us_before = pd.read_csv('.. /input/jhu-covid19-data-with-us-state-data-prior-to-mar-9/covid19_train_data_us_states_before_march_09_new.csv')
update =(train['Country_Region'] == 'US')&(train.Date <= '2020-03-09')
df = train[update]
us_before... | stack_clf1=StackingClassifier(**param_meta1)
stack_clf3=StackingClassifier(**param_meta3 ) | Titanic - Machine Learning from Disaster |
12,072,456 | test = pd.read_csv('.. /input/covid19-global-forecasting-week-4/test.csv')
test['Province_State'].fillna('', inplace=True)
test['Date'] = pd.to_datetime(test['Date'])
test['day'] = test.Date.dt.dayofyear
test['geo'] = ['_'.join(x)for x in zip(test['Country_Region'], test['Province_State'])]
test
day_min = train['day... | stack_clf1.fit(train_1[col_final],train_1['Survived'])
stack_clf3.fit(train_3[col_final],train_3['Survived'] ) | Titanic - Machine Learning from Disaster |
12,072,456 | def get_sub(start_val_delta=0):
start_val = min_test_val_day + start_val_delta
last_train = start_val - 1
num_val = max_test_val_day - start_val + 1
first_train = last_train + 1 -(num_train)
keep_cases = cases
keep_deaths = deaths
print(dates[last_train], '%3d %3d' %(start_val, num_val), end=' ')
country_ids_base = g... | y_pred_1=stack_clf1.predict(test_1[col_final])
y_pred_3=stack_clf3.predict(test_3[col_final] ) | Titanic - Machine Learning from Disaster |
12,072,456 | known_test = train[['geo', 'day', 'ConfirmedCases', 'Fatalities']
].merge(test[['geo', 'day', 'ForecastId']], how='left', on=['geo', 'day'])
known_test = known_test[['ForecastId', 'ConfirmedCases', 'Fatalities']][known_test.ForecastId.notnull() ].copy()
known_test
unknow_test = test[test.day > max_test_val_day]
unknow... | y_pred_1=pd.DataFrame({'PassengerId':test_1['PassengerId'],'Survived':y_pred_1 }, dtype=int)
y_pred_2=pd.DataFrame({'PassengerId':test_2['PassengerId'],'Survived':1 }, dtype=int)
y_pred_3=pd.DataFrame({'PassengerId':test_3['PassengerId'],'Survived':y_pred_3 }, dtype=int ) | Titanic - Machine Learning from Disaster |
12,072,456 | <load_from_csv><EOS> | y_sub=pd.concat([y_pred_1,y_pred_2,y_pred_3], axis=0 ).sort_values('PassengerId')
y_sub.to_csv("sub.csv",index=False ) | Titanic - Machine Learning from Disaster |
12,328,591 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.feature_selection import RFECV, RFE
from sklearn.model_selection ... | Titanic - Machine Learning from Disaster |
12,328,591 | train['id_x']=train['Date'].astype(str ).values+'_'+train['State'].astype(str ).values+'_'+train['Country'].astype(str ).values+'_'+train['Type'].astype(str ).values
test['id_x']=test['Date'].astype(str ).values+'_'+test['State'].astype(str ).values+'_'+test['Country'].astype(str ).values+'_'+test['Type'].astype(str ).... | random_state = 101 | Titanic - Machine Learning from Disaster |
12,328,591 | os.environ['OMP_NUM_THREADS'] = '1'
gc.enable()
features = ['id_x','Day']
X_train = [np.array(train[train.Country_State_id== x][features])for x in list(train.Country_State_id.unique())]
X_test = [np.array(test[test.Country_State_id== x][features])for x in list(train.Country_State_id.unique())]
y_target_c = [np.array(tr... | data_train = pd.read_csv(".. /input/titanic/train.csv" ).set_index("PassengerId")
data_test = pd.read_csv(".. /input/titanic/test.csv" ).set_index("PassengerId")
data = pd.concat([data_train, data_test] ) | Titanic - Machine Learning from Disaster |
12,328,591 | import numpy as np
import pandas as pd
<load_from_csv> | data["Sex"] = OneHotEncoder(drop='if_binary' ).fit_transform(data[["Sex"]] ).toarray().astype("int" ) | Titanic - Machine Learning from Disaster |
12,328,591 | train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
train['CRPS']=train.Country_Region+train.Province_State.fillna('')
test['CRPS']=test.Country_Region+test.Province_State.fillna('')
train<feature_engineering... | FEATURES_BASELINE = ["Sex", "Pclass"] | Titanic - Machine Learning from Disaster |
12,328,591 | train['LConfirmedCases']=np.log1p(train['ConfirmedCases'])
train['LFatalities']=np.log1p(train['Fatalities'])
train['LDConfirmedCases']=train.groupby('CRPS')[['LConfirmedCases']].diff()
train['LDFatalities']=train.groupby('CRPS')[['LFatalities']].diff()
train['LConfirmedCases1']=train.groupby('CRPS')[['LConfirmedCase... | def title(name):
surname_split = name.split(", ")
title_split = surname_split[1].split(".")
title = title_split[0]
return title | Titanic - Machine Learning from Disaster |
12,328,591 | lgbm_cc=LGBMRegressor(num_leaves = 85,learning_rate =10**-1.89,n_estimators=100,min_sum_hessian_in_leaf=(10**-4.1),min_child_samples =2,subsample =0.97,subsample_freq=10,
colsample_bytree = 0.68,reg_lambda=10**1.4,random_state=1234,n_jobs=4)
lgbm_f=LGBMRegressor(num_leaves = 26,learning_rate =10**-1.63,n_estimators=10... | data["Title"] = data.Name.apply(title)
data['Title'] = data['Title'].replace(['Dona', 'Mlle', 'Ms'], 'Miss')
data['Title'] = data['Title'].replace(['Lady', 'the Countess', 'Mme'], 'Mrs')
data['Title'] = data['Title'].replace(['Jonkheer', 'Don', 'Sir', 'Capt', 'Major', 'Col'], 'Mr')
data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
12,328,591 | train['serd']=train.groupby('CRPS' ).cumcount()
trainpred = pd.concat(( train,test[test.Date>train.Date.max() ])).reset_index(drop=True)
trainpred.sort_values(['Country_Region','Province_State','Date'],inplace=True)
X=oe.transform(trainpred[['Country_Region','Province_State']].fillna(''))
trainpred['CR']=X[:,0]
train... | data["Neighbors"] = neighbors(data["Ticket"] ) | Titanic - Machine Learning from Disaster |
12,328,591 | trainpred.loc[(trainpred.Date<=max(test.Date)) &(trainpred.Date>=min(test.Date)) ,'ForecastId']=test.loc[:,'ForecastId'].values
submission=trainpred.loc[trainpred.Date>=min(test.Date)][['ForecastId','ConfirmedCases','Fatalities']]
submission.ForecastId=submission.ForecastId.astype('int')
submission.sort_values('Foreca... | print("Passengers with Embarked NaNs")
print(data[pd.isnull(data.Embarked)])
embarked_nans_fare = data.loc[(data.Pclass == 1)&(data.Neighbors == 1), "Fare"].median()
print(f"Median fare for this type of passengers: {embarked_nans_fare}" ) | Titanic - Machine Learning from Disaster |
12,328,591 | warnings.filterwarnings("ignore")
train = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/train.csv")
test = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/test.csv" )<feature_engineering> | data.loc[pd.isnull(data.Embarked), "Embarked"] = "C" | Titanic - Machine Learning from Disaster |
12,328,591 | train["Province_State"] = train["Province_State"].fillna('')
test["Province_State"] = test["Province_State"].fillna('')
train["Month"], train["Day"] = 0, 0
for i in range(len(train)) :
train["Month"][i] =(train["Date"][i] ).split("-")[1]
train["Day"][i] =(train["Date"][i] ).split("-")[2]
test["Month"], test["Day"] = ... | print(data[pd.isnull(data.Age)])
data.loc[(data["Title"] == "Mr")&(data["Age"] < 12), "Title"] = "Master"
data.Age.fillna(data.groupby(['Title', 'Pclass', 'Sex'] ).transform('median' ).Age, inplace=True ) | Titanic - Machine Learning from Disaster |
12,328,591 | for i in range(len(train)) :
if train["Province_State"][i] != '':
train["Country_Region"][i] = train["Province_State"][i] + "(" + str(train["Country_Region"][i])+ ")"
for i in range(len(test)) :
if test["Province_State"][i] != '':
test["Country_Region"][i] = test["Province_State"][i] + "(" + str(test["Country_Region"][... | print(data[(pd.isnull(data["Fare"])) |(data["Fare"] == 0)])
data.loc[data["Fare"] == 0, "Fare"] = np.NaN
data["Fare"].fillna(data.groupby(['Embarked', 'Pclass', 'Neighbors'] ).transform('median' ).Fare, inplace=True ) | Titanic - Machine Learning from Disaster |
12,328,591 | i = 0
for value in train["Country/State"].unique() :
if i < len(train):
j = 1
while(train["Country/State"][i] == value):
train["Day"][i] = j
j += 1; i += 1
if i == len(train):
break
i = 0
for value in test["Country/State"].unique() :
if i < len(test):
j = 72
while(test["Country/State"][i] == value):
test["Day"][i] = j
... | encoder = LabelEncoder()
data["Embarked"] = encoder.fit_transform(data["Embarked"] ) | Titanic - Machine Learning from Disaster |
12,328,591 | train["Country/State"].loc[train["Country/State"] == "Taiwan*"] = "Taiwan"
test["Country/State"].loc[test["Country/State"] == "Taiwan*"] = "Taiwan"
train = train.drop(columns = ["Date"])
test = test.drop(columns = ["Date"])
countriesorstates = train["Country/State"].unique()
print(len(countriesorstates))
print(countr... | FEATURES_1 = ['Sex', 'Pclass', 'Embarked'] | Titanic - Machine Learning from Disaster |
12,328,591 | random_picks = random.choices(countriesorstates, k = 9)
for value in random_picks:
train_temp = train.loc[train["Country/State"] == value]
test_temp = test.loc[test["Country/State"] == value]
train_temp_cc = train_temp["ConfirmedCases"].loc[train["Country/State"] == value]
train_temp_ft = train_temp["Fatalities"].loc[... | data['Group_Status'] = 0
ticket_grouping = data.groupby("Ticket")
for _, group in ticket_grouping:
if(len(group)> 1):
for i, row in group.iterrows() :
s_max = group.drop(i)['Survived'].max()
pass_id = row.name
if s_max == 1.0:
data.loc[pass_id, 'Group_Status'] = 1
elif s_max == 0.0:
data.loc[pass_id, 'Group_Status'] =... | Titanic - Machine Learning from Disaster |
12,328,591 | poly_reg_cc = PolynomialFeatures(degree = 4)
poly_reg_ft = PolynomialFeatures(degree = 4)
reg_cc = LinearRegression()
reg_ft = LinearRegression()
sub = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
for value in countriesorstates:
train_temp = train.loc[train["Country/State"] == value]
test... | FEATURES_2 = ['Sex', 'Pclass', 'Embarked', 'Group_Status'] | Titanic - Machine Learning from Disaster |
12,328,591 | sub.ForecastId = sub.ForecastId.astype('int')
for i in range(len(sub)) :
sub["ConfirmedCases"][i] = int(round(sub["ConfirmedCases"][i]))
sub["Fatalities"][i] = int(round(sub["Fatalities"][i]))
sub.to_csv("submission.csv", index = False )<load_from_csv> | FEATURES_3 = ['Sex', 'Pclass', 'Embarked', 'Group_Status', 'Age_Bin'] | Titanic - Machine Learning from Disaster |
12,328,591 | submission=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<load_from_csv> | data["Fare_per_Person"] = data["Fare"] /(1 + data["Neighbors"])
bins = pd.qcut(data["Fare_per_Person"], 6, labels=False, retbins=True)
data["Fare_per_Person_Bin"] = bins[0] | Titanic - Machine Learning from Disaster |
12,328,591 | submission=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<load_from_csv> | FEATURES_4 = ['Sex', 'Pclass', 'Embarked', 'Group_Status', 'Age_Bin', 'Fare_per_Person_Bin'] | Titanic - Machine Learning from Disaster |
12,328,591 | submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
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_State.fillna("None", inplace=True)
display(train.head(5))
disp... | data["Family_Size"] = data["SibSp"] + data["Parch"]
data["Connections"] = data[["Family_Size", "Neighbors"]].max(axis=1)
bins = np.array([data["Connections"].min() , 1, 4, data["Connections"].max() ])
data["Connections_Bin"] = np.digitize(data["Connections"], bins ) | Titanic - Machine Learning from Disaster |
12,328,591 | confirmed_total_date_Italy = train[train['Country_Region']=='Italy'].groupby(['Date'] ).agg({'ConfirmedCases':['sum']})
fatalities_total_date_Italy = train[train['Country_Region']=='Italy'].groupby(['Date'] ).agg({'Fatalities':['sum']})
total_date_Italy = confirmed_total_date_Italy.join(fatalities_total_date_Italy)
... | FEATURES_5 = ['Sex', 'Pclass', 'Embarked', 'Group_Status', 'Age_Bin', 'Fare_per_Person_Bin', "Connections_Bin"] | Titanic - Machine Learning from Disaster |
12,328,591 | pop_India=1377011281.
pop_US=330578810.
pop_spain = 46749696.
pop_italy = 60486683.
pop_UK = 67784927.
pop_singapore = 5837230.
total_date_India.ConfirmedCases = total_date_India.ConfirmedCases/pop_India*100.
total_date_India.Fatalities = total_date_India.ConfirmedCases/pop_India*100.
total_date_US.ConfirmedCas... | def model(X, y, features, random_state, parameters=None):
model = RandomForestClassifier(random_state=random_state,
n_estimators=500,
min_samples_split=0.05)
if parameters is not None:
model.set_params(**parameters)
model.fit(X[features], y)
score_cv = cross_val_score(model, X[features], y, cv=cv ).mean()
print(f"Mo... | Titanic - Machine Learning from Disaster |
12,328,591 | confirmed_total_date_India = train[(train['Country_Region']=='India')& train['ConfirmedCases']!=0].groupby(['Date'] ).agg({'ConfirmedCases':['sum']})
fatalities_total_date_India = train[(train['Country_Region']=='India')& train['ConfirmedCases']!=0].groupby(['Date'] ).agg({'Fatalities':['sum']})
total_date_India = co... | X_train = data.loc[data_train.index].drop("Survived", axis=1)
y_train = data.loc[data_train.index, "Survived"]
X_test = data.loc[data_test.index].drop("Survived", axis=1)
cv=KFold(10, shuffle=True, random_state=random_state ) | Titanic - Machine Learning from Disaster |
12,328,591 | le = preprocessing.LabelEncoder()
<sort_values> | MODEL_BASELINE = model(X_train, y_train, FEATURES_BASELINE, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | df = train.fillna('NA' ).groupby(['Country_Region','Province_State','Date'])['ConfirmedCases'].sum() \
.groupby(['Country_Region','Province_State'] ).max().sort_values() \
.groupby(['Country_Region'] ).sum().sort_values(ascending = False)
top20_countries = pd.DataFrame(df ).head(20)
top20_countries<data_type_conver... | MODEL_1 = model(X_train, y_train, FEATURES_1, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | train['Date'] = pd.to_datetime(train['Date'], infer_datetime_format=True)
test['Date'] = pd.to_datetime(test['Date'], infer_datetime_format=True )<data_type_conversions> | MODEL_2 = model(X_train, y_train, FEATURES_2, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | train.loc[:, 'Date'] = train.Date.dt.strftime('%y%m%d')
train.loc[:, 'Date'] = train['Date'].astype(int)
test.loc[:, 'Date'] = test.Date.dt.strftime('%y%m%d')
test.loc[:, 'Date'] = test['Date'].astype(int )<feature_engineering> | MODEL_3 = model(X_train, y_train, FEATURES_3, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | train['Province_State'] = np.where(train['Province_State'] == 'nan',train['Country_Region'],train['Province_State'])
test['Province_State'] = np.where(test['Province_State'] == 'nan',test['Country_Region'],test['Province_State'] )<data_type_conversions> | MODEL_4 = model(X_train, y_train, FEATURES_4, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | convert_dict = {'Province_State': str}
train = train.astype(convert_dict)
test = test.astype(convert_dict )<load_from_csv> | MODEL_5 = model(X_train, y_train, FEATURES_5, random_state)
| Titanic - Machine Learning from Disaster |
12,328,591 | submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
test = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
train = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv" )<count_missing_values> | FEATURES = ['Sex', 'Pclass', 'Embarked', 'Group_Status', 'Age_Bin', 'Fare_per_Person_Bin', "Connections_Bin"] | Titanic - Machine Learning from Disaster |
12,328,591 | train.isna().sum()<count_missing_values> | params = {
'n_estimators': [500, 1000],
'min_samples_split': [2, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.10]
}
results = pd.DataFrame()
gs = GridSearchCV(estimator=RandomForestClassifier(random_state), param_grid=params, cv=cv, verbose=1, n_jobs=-1)
gs.fit(X_train[FEATURES], y_train)
results = pd.DataFrame(gs.cv_results_... | Titanic - Machine Learning from Disaster |
12,328,591 | test.isna().sum()<data_type_conversions> | params = {
'n_estimators': [500, 1000],
'max_depth': [3, 4, 5, 6, 7, None],
}
results = pd.DataFrame()
gs = GridSearchCV(estimator=RandomForestClassifier(random_state), param_grid=params, cv=cv, verbose=1, n_jobs=-1)
gs.fit(X_train[FEATURES], y_train)
results = pd.DataFrame(gs.cv_results_)
table = pd.pivot_table(res... | Titanic - Machine Learning from Disaster |
12,328,591 | train['Province_State'].fillna("",inplace = True)
test['Province_State'].fillna("",inplace = True )<drop_column> | model = RandomForestClassifier(random_state=random_state)
pipe = Pipeline([("rfe", RFE(model, verbose=0)) ,("rf", model)])
params = {
'rfe__n_features_to_select': [1,2,3,4,5,6,7],
'rf__n_estimators': [500],
'rf__min_samples_split': [2, 0.01],
'rf__max_depth': [5, 6, None]
}
grid = GridSearchCV(pipe, param_grid=params... | Titanic - Machine Learning from Disaster |
12,328,591 | train['Country_Region'] = train['Country_Region'] + ' ' + train['Province_State']
test['Country_Region'] = test['Country_Region'] + ' ' + test['Province_State']
del train['Province_State']
del test['Province_State']<feature_engineering> | MODEL_6 = grid.best_estimator_
print(f"Model CV score is {grid.best_score_:.5f}")
| Titanic - Machine Learning from Disaster |
12,328,591 | 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.Date = train.Date.apply(split_date)
test.Date = test.Date.apply(split_d... | MODEL_7 = catboost.CatBoostClassifier(one_hot_max_size=4, iterations=1000, random_seed=random_state, verbose=False)
MODEL_7.fit(X_train[FEATURES_4], y_train)
score_cv = cross_val_score(MODEL_7, X_train[FEATURES_4], y_train, cv=cv ).mean()
print(f"Model CV score is {score_cv:.5f}")
| Titanic - Machine Learning from Disaster |
12,328,591 | year = []
month = []
day = []
for i in train.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | model = KNeighborsClassifier()
pipe = Pipeline([("scaler", StandardScaler()),("knn", model)])
params = {
'knn__n_neighbors': [3, 9, 15, 20, 21, 22, 25, 30],
'knn__weights': ['uniform', 'distance']
}
knn_grid = GridSearchCV(pipe, param_grid=params, cv=cv, verbose=0, n_jobs=-1)
knn_grid.fit(X_train[FEATURES], y_train)
... | Titanic - Machine Learning from Disaster |
12,328,591 | train['Year'] = year
train['Month'] = month
train['Day'] = day
del train['Date']<feature_engineering> | MODEL_8 = knn_grid.best_estimator_
print(f"Model CV score is {knn_grid.best_score_:.5f}")
| Titanic - Machine Learning from Disaster |
12,328,591 | year = []
month = []
day = []
for i in test.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2] )<feature_engineering> | MODEL_4.fit(X_train[FEATURES_4], y_train)
prediction_4 = MODEL_4.predict_proba(X_test[FEATURES_4])[:,1]
submit = pd.DataFrame({"PassengerId": X_test.index,"Survived": np.round(prediction_4, 0 ).astype(int)})
submit.to_csv("MODEL_4.csv",index=False ) | Titanic - Machine Learning from Disaster |
12,328,591 | test['Year'] = year
test['Month'] = month
test['Day'] = day
del test['Date']
del train['Id']
del test['ForecastId']<drop_column> | MODEL_6.fit(X_train[FEATURES], y_train)
prediction_6 = MODEL_6.predict_proba(X_test[FEATURES])[:,1]
submit = pd.DataFrame({"PassengerId": X_test.index,"Survived": np.round(prediction_6, 0 ).astype(int)})
submit.to_csv("MODEL_6.csv",index=False ) | Titanic - Machine Learning from Disaster |
12,328,591 | del train['Year']
del test['Year']<data_type_conversions> | MODEL_7.fit(X_train[FEATURES_4], y_train)
prediction_7 = MODEL_7.predict_proba(X_test[FEATURES_4])[:,1]
submit = pd.DataFrame({"PassengerId": data_test.index,"Survived": np.round(prediction_7, 0 ).astype(int)})
submit.to_csv("MODEL_7.csv",index=False ) | Titanic - Machine Learning from Disaster |
12,328,591 | train['ConfirmedCases'] = train['ConfirmedCases'].apply(int)
train['Fatalities'] = train['Fatalities'].apply(int )<drop_column> | MODEL_8.fit(X_train[FEATURES], y_train)
prediction_8 = MODEL_8.predict_proba(X_test[FEATURES])[:,1]
submit = pd.DataFrame({"PassengerId": data_test.index,"Survived": np.round(prediction_8, 0 ).astype(int)})
submit.to_csv("MODEL_8.csv",index=False ) | Titanic - Machine Learning from Disaster |
8,799,224 | cases = train.ConfirmedCases
fatalities = train.Fatalities
del train['ConfirmedCases']
del train['Fatalities']<categorify> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
8,799,224 | lb = LabelEncoder()
train['Country_Region'] = lb.fit_transform(train['Country_Region'])
test['Country_Region'] = lb.transform(test['Country_Region'] )<normalization> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
8,799,224 | scaler = MinMaxScaler()
x_train = scaler.fit_transform(train.values)
x_test = scaler.transform(test.values )<train_model> | def generateBaselineOutputNobodySurvives(df):
output = pd.DataFrame({'PassengerId': df.PassengerId, 'Survived': np.full(( len(df)) , 0)})
return output
output_train = generateBaselineOutputNobodySurvives(train_data)
output_test = generateBaselineOutputNobodySurvives(test_data ) | Titanic - Machine Learning from Disaster |
8,799,224 | rf = XGBRegressor(n_estimators = 2500 , random_state = 0 , max_depth = 27)
rf.fit(x_train,cases )<predict_on_test> | print("MSE baseline: ", mean_squared_error(train_data["Survived"], output_train["Survived"]))
print("LogLoss baseline", log_loss(train_data["Survived"], output_train["Survived"])) | Titanic - Machine Learning from Disaster |
8,799,224 | cases_pred = rf.predict(x_test)
cases_pred<feature_engineering> | output_test.to_csv('baseline_submission.csv', index=False)
print("Your baseline submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
8,799,224 | cases_pred = np.around(cases_pred,decimals = 0)
cases_pred<concatenate> | train_data_copy = train_data.copy()
test_data_copy = test_data.copy()
median_age = train_data["Age"].median()
train_data["Age"] = train_data["Age"].replace(np.nan, median_age)
train_data["Embarked"] = train_data["Embarked"].replace(np.nan, 'S')
for feature in ['PassengerId', 'Name','Cabin', 'Ticket']:
train_data.drop... | Titanic - Machine Learning from Disaster |
8,799,224 | 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> | Y_train = pd.DataFrame(train_data["Survived"] ).to_numpy().flatten()
train_data.drop("Survived", axis=1, inplace=True)
X_train = train_data.to_numpy() | Titanic - Machine Learning from Disaster |
8,799,224 | x_train_cas = np.array(x_train_cas )<train_model> | def build_model(input_shape, learning_rate=0.01):
tf.keras.backend.clear_session()
np.random.seed(0)
tf.compat.v1.set_random_seed(0)
model = keras.Sequential()
model.add(keras.layers.Flatten(input_shape=input_shape))
model.add(keras.layers.Dense(
units=512,
use_bias=True,
activation="relu",
))
model.add(keras.lay... | Titanic - Machine Learning from Disaster |
8,799,224 | rf = XGBRegressor(n_estimators = 2500 , random_state = 0 , max_depth = 27)
rf.fit(x_train_cas,fatalities )<concatenate> | model = build_model(input_shape=X_train[0].shape, learning_rate=0.01)
history = model.fit(
x = X_train,
y = Y_train,
epochs=5,
batch_size=64,
validation_split=0.1,
verbose=1
)
history = pd.DataFrame(history.history)
display(history)
plot_history(history ) | Titanic - Machine Learning from Disaster |
8,799,224 | x_test_cas = []
for i in range(len(x_test)) :
x = list(x_test[i])
x.append(cases_pred[i])
x_test_cas.append(x)
x_test_cas[0]<predict_on_test> | train_predictions = model.predict(X_train ).flatten()
thresholds = [0.3,0.49, 0.5, 0.51, 0.52, 0.7]
group_names = ["True Neg", "False Pos", "False Neg" , "True Pos"]
for threshold in thresholds:
train_predictions_copy = np.copy(train_predictions)
train_predictions_copy[train_predictions < threshold] = 0.0
train_predic... | Titanic - Machine Learning from Disaster |
8,799,224 | fatalities_pred = rf.predict(x_test_cas)
fatalities_pred<feature_engineering> | pd.set_option("display.max_rows", None, "display.max_columns", None)
train_data_copy['Prediction'] = train_predictions
train_data_copy['Difference'] = abs(train_data_copy['Survived'] - train_data_copy['Prediction'])
train_data_copy = train_data_copy[['Difference', 'Survived','Prediction', 'Pclass', 'Sex', 'Age', 'Far... | Titanic - Machine Learning from Disaster |
8,799,224 | fatalities_pred = np.around(fatalities_pred,decimals = 0)
fatalities_pred<prepare_output> | test_data_copy = test_data.copy()
for feature in ['PassengerId', 'Name','Cabin', 'Ticket']:
test_data.drop(feature, axis=1, inplace=True)
test_data["Age"] = test_data["Age"].replace(np.nan, median_age)
test_data["Embarked"] = test_data["Embarked"].replace(np.nan, 'S')
test_data["Fare"] = test_data["Fare"].replace(np... | Titanic - Machine Learning from Disaster |
8,799,224 | <save_to_csv><EOS> | test_predictions = model.predict(X_test ).flatten()
test_predictions_actual_values = np.array([1 if val >= 0.51 else 0 for val in test_predictions])
output_test_logit = pd.DataFrame({'PassengerId': test_data_copy.PassengerId, 'Survived': test_predictions_actual_values})
output_test_logit.to_csv('logit_submission.csv'... | Titanic - Machine Learning from Disaster |
7,637,187 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
7,637,187 | submission.to_csv('submission.csv', index=False )<set_options> | titanic_filepath =('.. /input/titanic/train.csv')
titanic_data= pd.read_csv(titanic_filepath)
test_filepath =('.. /input/titanic/test.csv')
test_data=pd.read_csv(test_filepath ) | Titanic - Machine Learning from Disaster |
7,637,187 | pio.templates.default = "plotly_dark"
<load_from_csv> | features=['Sex','Fare', 'Pclass','Parch','SibSp'] | Titanic - Machine Learning from Disaster |
7,637,187 | train_df = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
test_df = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
submission = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<count_missing_values> | x=titanic_data[features]
test_x=test_data[features] | Titanic - Machine Learning from Disaster |
7,637,187 | train_df.isna().sum()<count_missing_values> | y=titanic_data.Survived | Titanic - Machine Learning from Disaster |
7,637,187 | test_df.isna().sum()<data_type_conversions> | cleanup_nums = {"Sex": {"male": 1, "female": 2}}
cleanup_nums2 = {"Embarked": {"S": 1, "C": 2, "Q": 3}}
x.head() | Titanic - Machine Learning from Disaster |
7,637,187 | all_data = pd.concat([train_df,test_df],axis=0,sort=False)
all_data['Province_State'].fillna("None", inplace=True)
all_data['ConfirmedCases'].fillna(0, inplace=True)
all_data['Fatalities'].fillna(0, inplace=True)
all_data['Id'].fillna(-1, inplace=True)
all_data['ForecastId'].fillna(-1, inplace=True)
<categorify> | x=x.fillna(x.mean())
test_x=test_x.fillna(test_x.mean())
| Titanic - Machine Learning from Disaster |
7,637,187 | le = LabelEncoder()
all_data['Date'] = pd.to_datetime(all_data['Date'])
all_data['Day_num'] = le.fit_transform(all_data.Date)
all_data['Day'] = all_data['Date'].dt.day
all_data['Month'] = all_data['Date'].dt.month
all_data['Year'] = all_data['Date'].dt.year
<split> | model=XGBClassifier()
model.fit(x,y ) | Titanic - Machine Learning from Disaster |
7,637,187 | train = all_data[all_data['ForecastId']==-1.0]
test = all_data[all_data['ForecastId']!=-1.0]<categorify> | submission_path =('.. /input/titanic/gender_submission.csv')
submission= pd.read_csv(submission_path ) | Titanic - Machine Learning from Disaster |
7,637,187 | train['Province_State'] = le.fit_transform(train['Province_State'])
train['Country_Region'] = le.fit_transform(train['Country_Region'])
test['Province_State'] = le.fit_transform(test['Province_State'])
test['Country_Region'] = le.fit_transform(test['Country_Region'])
X = train.drop(columns=['Id','ConfirmedCases','F... | submission['Survived']=model.predict(test_x)
| Titanic - Machine Learning from Disaster |
7,637,187 | model = XGBRegressor(n_estimators = 1000 , random_state = 0 , max_depth = 15)
model.fit(X,cases)
cases_pred = model.predict(x_test)
model1 = XGBRegressor(n_estimators = 1000 , random_state = 0 , max_depth = 15)
model1.fit(X,fatalities)
fatalities_pred = model1.predict(x_test)
<compute_test_metric> | submission['PassengerId']=test_data['PassengerId'] | Titanic - Machine Learning from Disaster |
7,637,187 | MSE = mean_squared_error(cases.iloc[0:13459],cases_pred)
RMSE = sqrt(mean_squared_error(cases.iloc[0:13459],cases_pred))
MAE = mean_absolute_error(cases.iloc[0:13459],cases_pred)
R2 = r2_score(cases.iloc[0:13459],cases_pred)
print('Mean squared error :', MSE)
print('Root mean squared error :',RMSE)
print('Mean abs... | submission.columns=['PassengerId','Survived'] | Titanic - Machine Learning from Disaster |
7,637,187 | test_df_predict = test_df.copy()
test_df_predict['Confirmedcase'] = cases_pred
test_df_predict['Fatalities'] = fatalities_pred
test_df_predict = test_df_predict.drop('Province_State',axis=1)
test_df_predict.to_csv('Forecast_result.csv' )<groupby> | submission.columns=['PassengerId','Survived']
submission.head() | Titanic - Machine Learning from Disaster |
7,637,187 | US = test_df_predict[test_df_predict['Country_Region']=='US']
US.groupby('Date')['Confirmedcase','Fatalities'].sum().reset_index()<sort_values> | submission.to_csv('Submission.csv', index=False)
| Titanic - Machine Learning from Disaster |
9,234,238 | test_df_predict.groupby(['Date','Country_Region'])['Confirmedcase','Fatalities'].max().reset_index().head(10)
<sort_values> | sns.set()
| Titanic - Machine Learning from Disaster |
9,234,238 | test_df_predict.groupby('Country_Region')['Confirmedcase', 'Fatalities'].sum().reset_index().sort_values(by='Confirmedcase',ascending=False ).head(15)
<save_to_csv> | data_train = pd.read_csv('/kaggle/input/titanic/train.csv')
data_test = pd.read_csv('/kaggle/input/titanic/test.csv')
data_total = data_train.append(data_test, ignore_index=True)
data_train_length = len(data_train.index)
for c in ['Pclass', 'Sex', 'Embarked', 'SibSp', 'Parch', 'Survived']:
sns.catplot(x=c, kind='co... | Titanic - Machine Learning from Disaster |
9,234,238 | cases_pred = [round(value)for value in cases_pred ]
fatalities_pred = [round(value)for value in fatalities_pred ]
submission['ConfirmedCases'] = cases_pred
submission['Fatalities'] = fatalities_pred
submission.to_csv('submission.csv',index=False)
<set_options> | age_mean_by_pclass = data_total[['Pclass', 'Age']].groupby('Pclass' ).mean()
data_total['Age'] = data_total.apply(
lambda row: age_mean_by_pclass.loc[row['Pclass'], 'Age'] if np.isnan(row['Age'])else row['Age'], axis=1)
fare_median_by_pclass = data_total[['Pclass', 'Fare']].groupby('Pclass' ).median()
data_total['Far... | Titanic - Machine Learning from Disaster |
9,234,238 | %matplotlib inline
<define_variables> | data_total['isAlone'] =(( data_total['SibSp'] + data_total['Parch'])== 0)* 1
data_total['bigGroup'] =(( data_total['SibSp'] + data_total['Parch'])> 3)* 1
data_total['Title'] = data_total['Name'].str.extract('([A-Za-z]+)\.', expand=False)
data_total['Title'] = data_total['Title'].replace(['Lady', 'Countess','Capt', 'Co... | Titanic - Machine Learning from Disaster |
9,234,238 | PATH ='/kaggle/input/covid19-global-forecasting-week-4'<load_from_csv> | data_train = data_total[:data_train_length]
X = data_train.drop(columns=['Survived'], axis=1)
y = data_train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
scaler = StandardScaler().fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test ) | Titanic - Machine Learning from Disaster |
9,234,238 | train = pd.read_csv(f'{PATH}/train.csv')
train.head()<groupby> |
svc_params = [{'C': [0.2, 0.4, 0.5, 1, 2, 3, 4, 5], 'kernel': ['rbf'], 'gamma': [.10,.15,.20,.25,.30]}]
knn_params = [{'n_neighbors': [7, 8, 9, 10], 'weights': ['uniform'], 'algorithm': ['brute'], 'p': [2]}]
rfc_params = [{'n_estimators': [80, 90, 100, 110, 120, 130, 140], 'criterion': ['entropy']}]
classifier_names ... | Titanic - Machine Learning from Disaster |
9,234,238 | total_countries_covid = train.groupby(['Country_Region'])['ConfirmedCases'].sum()
<sort_values> | classifier_tuned = [SVC(C=best_params['SVC']['C'], gamma=best_params['SVC']['gamma'], kernel=best_params['SVC']['kernel']),
KNeighborsClassifier(algorithm=best_params['KNN']['algorithm'], n_neighbors=best_params['KNN']['n_neighbors'],
p=best_params['KNN']['p'], weights=best_params['KNN']['weights']),
LogisticRegression... | Titanic - Machine Learning from Disaster |
8,244,389 | df = train.fillna('NA' ).groupby(['Country_Region','Province_State','Date'])['ConfirmedCases'].sum() \
.groupby(['Country_Region','Province_State'] ).max().sort_values() \
.groupby(['Country_Region'] ).sum().sort_values(ascending = False)
top20_countries = pd.DataFrame(df ).head(20)
top20_countries<load_from_csv> | 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 |
8,244,389 | test = pd.read_csv(f'{PATH}/test.csv')
test.head()<correct_missing_values> | 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 |
8,244,389 | x = X.fillna('NA' )<data_type_conversions> | 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 |
8,244,389 | X_train = train
X_train['Date'] = pd.to_datetime(X_train['Date'], infer_datetime_format=True)
test['Date'] = pd.to_datetime(test['Date'], infer_datetime_format=True)
<load_pretrained> | train_data['age_group'] = pd.cut(train_data.Age, bins=[0, 10, 20, 30, 40, 50, 60, 70, 80])
Gender_grp = train_data.groupby(['Sex'])
percent_present = dict(Gender_grp.get_group('female' ).age_group.value_counts(normalize=True))
num_present = dict(Gender_grp.get_group('female' ).age_group.value_counts())
survivors = G... | Titanic - Machine Learning from Disaster |
8,244,389 | EMPTY_VAL = "EMPTY_VAL"
def fillState(Province_State, Country_Region):
if Province_State == EMPTY_VAL: return Country_Region
return Province_State<data_type_conversions> | num_present = dict(Gender_grp.get_group('male' ).age_group.value_counts())
print(num_present)
survivors_1 = Gender_grp.get_group('male')[Gender_grp.get_group('male' ).Survived == 1]
age_survived_1 = {}
for i in num_present:
age_survived[i] = survivors_1.loc[survivors_1.age_group==i]["Survived"].count()
list_of_dict =... | Titanic - Machine Learning from Disaster |
8,244,389 | X_train_new = X_train.copy()
X_train_new['Province_State'].fillna(EMPTY_VAL, inplace=True)
X_train_new['Province_State'] = X_train_new.loc[:, ['Province_State', 'Country_Region']].apply(lambda x : fillState(x['Province_State'], x['Country_Region']), axis=1)
X_train_new.loc[:, 'Date'] = X_train_new.Date.dt.strftime("%... | print("Number of missing values for females",Gender_grp.get_group('female' ).Age.isnull().sum())
print("Total for females",Gender_grp.get_group('female' ).PassengerId.count())
print("Number of missing values for males",Gender_grp.get_group('male' ).Age.isnull().sum())
print("Total for males", Gender_grp.get_group('m... | Titanic - Machine Learning from Disaster |
8,244,389 | l = preprocessing.LabelEncoder()
X_train_new.Country_Region = l.fit_transform(X_train_new.Country_Region)
X_train_new['Province_State'] = l.fit_transform(X_train_new['Province_State'])
X_train_new.head()
<data_type_conversions> | Titanic - Machine Learning from Disaster | |
8,244,389 | X_Test = test.copy()
X_Test['Province_State'].fillna(EMPTY_VAL, inplace=True)
X_Test['Province_State'] = X_Test.loc[:, ['Province_State', 'Country_Region']].apply(lambda x : fillState(x['Province_State'], x['Country_Region']), axis=1)
X_Test.loc[:, 'Date'] = X_Test.Date.dt.strftime("%m%d")
X_Test["Date"] = X_Test["D... | pclass_group = train_data.groupby('Pclass')
| Titanic - Machine Learning from Disaster |
8,244,389 | X_Test.Country_Region = l.fit_transform(X_Test.Country_Region)
X_Test['Province_State'] = l.fit_transform(X_Test['Province_State'])
X_Test.head()
<create_dataframe> | num_present_pclass_1 = dict(pclass_group.get_group(1 ).age_group.value_counts())
survived_age_pclass_1 = {}
for i in num_present_pclass_1:
value = pclass_group.get_group(1 ).loc[pclass_group.get_group(1 ).age_group == i]['Survived']
survived_age_pclass_1[i]=sum(value)
list_of_pclass_1=[survived_age_pclass_1,num_prese... | Titanic - Machine Learning from Disaster |
8,244,389 | p1_final = pd.DataFrame()
p3 = pd.DataFrame()
pred = pd.DataFrame()
p = list()
id_1 = pd.DataFrame()
id_2 = pd.DataFrame()
p1 =list()
for i in country:
id_1 = pd.concat([id_1,id_2])
state = X_train_new.loc[X_train_new.Country_Region == i, :].Province_State.unique()
for j in state:
X_train_1 = X_train_new.loc[(X_train_... | num_present_pclass_2 = dict(pclass_group.get_group(2 ).age_group.value_counts())
survived_age_pclass_2 = {}
for i in num_present_pclass_2:
value = pclass_group.get_group(2 ).loc[pclass_group.get_group(2 ).age_group == i]['Survived']
survived_age_pclass_2[i]=sum(value)
list_of_pclass_2=[survived_age_pclass_2,num_prese... | Titanic - Machine Learning from Disaster |
8,244,389 | path_week4 = '/kaggle/input/covid19-global-forecasting-week-4'
df_train = pd.read_csv(f'{path_week4}/train.csv',parse_dates=['Date'], engine='python')
df_test = pd.read_csv(f'{path_week4}/test.csv')
df_train.head()
df_test.head()
df_train.rename(columns={'Country_Region':'Country'}, inplace=True)
df_test.rename(colu... | num_present_pclass_3 = dict(pclass_group.get_group(3 ).age_group.value_counts())
survived_age_pclass_3 = {}
for i in num_present_pclass_3:
value = pclass_group.get_group(3 ).loc[pclass_group.get_group(3 ).age_group == i]['Survived']
survived_age_pclass_3[i]=sum(value)
list_of_pclass_3=[survived_age_pclass_3,num_prese... | Titanic - Machine Learning from Disaster |
8,244,389 | import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor
from sklearn.multioutput import MultiOutputRegressor
from sklearn.impute import SimpleImputer<load_from_csv> | gender_class_group = train_data.groupby(['Sex','Pclass'] ) | Titanic - Machine Learning from Disaster |
8,244,389 | train_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
test_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
submission_csv = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<data_type_conversions> | num_present_gender_class_1 = dict(gender_class_group.get_group(( 'female',1)).age_group.value_counts())
survived_1 = {}
for i in num_present_gender_class_1:
value = gender_class_group.get_group(( 'female',1)).loc[gender_class_group.get_group(( 'female',1)).age_group==i]['Survived']
survived_1[i] = sum(value)
list_1 =... | 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.