kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,293,763 | dff=dftestefinal.sort_values(by='ConfirmedCases',ascending=False)
dff.head(20 )<merge> | train_data = pd.read_csv('.. /input/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
4,293,763 | dfm = dfm.melt('Local', var_name='Date', value_name='Fatalities')
dfat=pd.merge(dftestefinal,dfm[['Local','Fatalities','Date']],on=['Local','Date'],how='left',suffixes=('_predicted','_real'))
dfat['Fatalities_real'].fillna('Vazio',inplace=True)
dfat['Fatalities']=np.where(dfat['Fatalities_real']=='Vazio',dfat['Fatali... | test_data = pd.read_csv('.. /input/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
4,293,763 | submission=dfat[['ForecastId','ConfirmedCases','Fatalities']]
submission['ForecastId']=submission['ForecastId'].astype('int32')
submission['Fatalities']=submission['Fatalities'].astype('float')
print(submission.dtypes)
submission.sample(10)
<count_missing_values> | sns.set(style="white", palette="muted", color_codes=True ) | Titanic - Machine Learning from Disaster |
4,293,763 | df_test[df_test['ConfirmedCases'].isna() ]<create_dataframe> | def get_one_hot(array):
return np.array(( array['Pclass'] == 1, array['Pclass'] == 2,
array['Pclass'] == 3, array['Sex'] == 'male',
array['Sex'] == 'female', array['SibSp'],
array['Parch'], array['Fare'],
array['Embarked'] == 'C', array['Embarked'] == 'Q',
array['Embarked'] == 'S')).swapaxes(0, 1 ).astype('float32' ) | Titanic - Machine Learning from Disaster |
4,293,763 | dftpronto=dfat.copy()<save_to_csv> | x_train = train_data[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
x_train.head() | Titanic - Machine Learning from Disaster |
4,293,763 | submission.to_csv('submission.csv',index=None)
submission.sample(10 )<set_options> | x_train = get_one_hot(x_train)
x_train[:10] | Titanic - Machine Learning from Disaster |
4,293,763 | np.random.seed(1337)
base_folder = '/kaggle/input/'
plt.rcParams['figure.figsize'] = [15, 7]
ext_cols = ['LaborForceTotal', 'LaborForcePerCapita', 'DeathRate', 'AirTrafficPassengersTotal',
'AirTrafficPassengersPerCapita', 'HospitalBedDensity', 'Obesity', 'OldPeople',
'PhysiciansDensity', 'AlcoholConsumptionPerCapita',... | y_train = np.array(train_data['Survived'])
y_train[:10] | Titanic - Machine Learning from Disaster |
4,293,763 | def add_extra_features_from_previous_days(data_fr, tail_size=5):
cols_tmp = []
col_prefix = 'PreviousDay'
for i in range(0, tail_size):
col_cc = '{}-{}ConfirmedCases'.format(col_prefix, i)
col_f = '{}-{}Fatalities'.format(col_prefix, i)
data_fr[col_cc] = data_fr.groupby(['Country/Region', 'Province/State'])['Confirme... | x_test = get_one_hot(x_test)
x_test[:10] | Titanic - Machine Learning from Disaster |
4,293,763 | TAIL = 50
previous_days_cols = add_extra_features_from_previous_days(df, TAIL)
df<feature_engineering> | from mlxtend.classifier import StackingCVClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.impute import SimpleImputer | Titanic - Machine Learning from Disaster |
4,293,763 | def special_day_CC(org_df, number_of_cc):
print('calculating for every Country & Province days passed from the first day when ConfirmedCases >= {}'.format(number_of_cc))
col_final = 'Day_CC{}'.format(number_of_cc)
col = 'Day_CC{}_zero'.format(number_of_cc)
org_df[col] = org_df.where(
(org_df['ConfirmedCases'] >= numb... | imp = SimpleImputer(missing_values=np.nan, strategy='mean')
imp = imp.fit(x_train)
x_train_imp = imp.transform(x_train ) | Titanic - Machine Learning from Disaster |
4,293,763 | df_population = pd.read_csv(base_folder + 'worldpopulaton-ver2/all_population.csv', delimiter=';', decimal=',', na_values='N.A.')
df_population['Urban Pop'] = df_population['Urban Pop'].fillna(100.0)
df_population = pd.get_dummies(df_population, columns=['Continent'])
continent_columns = []
for c in df_population.co... | clf1 = RandomForestClassifier()
clf2 = GradientBoostingClassifier()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2], meta_classifier=lr ) | Titanic - Machine Learning from Disaster |
4,293,763 | countries_to_replace = [
('Czech Republic', 'Czechia'),
('United States of America', 'US'),
('Côte d'Ivoire(Ivory Coast)', 'Côte d'Ivoire'),
('Korea(South)', 'Korea, South'),
('Swaziland', 'Eswatini'),
('Myanmar(Burma)', 'Burma'),
('East Timor', 'Timor-Leste'),
('Macedonia', 'North Macedonia'),
('Cape Verde', ... | param_test = {'randomforestclassifier__n_estimators': [10, 120],
'randomforestclassifier__max_depth': [2, 15],
'gradientboostingclassifier__n_estimators': [10, 120],
'gradientboostingclassifier__max_depth': [2, 15],
'gradientboostingclassifier__learning_rate' : [0.01, 0.1],
'meta_classifier__C': [0.1, 10.0]} | Titanic - Machine Learning from Disaster |
4,293,763 | df_add = pd.DataFrame()
for dataset in wbm.keys() :
if df_add.shape ==(0, 0):
df_add = wbm[dataset].copy()
else:
df_add = pd.merge(df_add, wbm[dataset], on=['Country', 'State'], how='left')
df_add.rename(columns={"Country": "Country/Region", "State": "Province/State"}, inplace=True)
df_add<merge> | sclf.fit(x_train_imp, y_train ) | Titanic - Machine Learning from Disaster |
4,293,763 | df_external = pd.merge(df_population, df_add, on=['Country/Region', 'Province/State'], how='left')
def fill_missing_percapita_values(dfr, feature_total, feature_percapita):
cond =(dfr[feature_percapita].isna())&(df_external[feature_total].notna())&(df_external['Population'].notna())
ind = df_external[cond].index
df_e... | x_test_imp = imp.transform(x_test ) | Titanic - Machine Learning from Disaster |
4,293,763 | df_pop = pd.merge(df, df_external, on=['Country/Region', 'Province/State'], how='left')
df_pop<define_variables> | data = np.array([np.array(test_data['PassengerId']), sclf.predict(x_test_imp)] ).swapaxes(0, 1)
results = pd.DataFrame(data, columns=['PassengerId', 'Survived'])
results.set_index('PassengerId', inplace=True)
results.head() | Titanic - Machine Learning from Disaster |
4,293,763 | cond_ctry = [
(( df['Country/Region']=='Germany')&(df['Province/State']=='entire country'), 'blue'),
(( df['Country/Region']=='China')&(df['Province/State']=='Hubei'), 'green'),
(( df['Country/Region']=='Italy')&(df['Province/State']=='entire country'), 'cyan'),
(( df['Country/Region']=='Spain')&(df['Province/State... | results.to_csv('predict.csv' ) | Titanic - Machine Learning from Disaster |
7,860,554 | ccc = pop_cols + ext_cols
df_pop[df_pop[ccc].isnull().any(axis=1)][['Country/Region', 'Province/State'] + ccc].drop_duplicates(subset=['Country/Region', 'Province/State'])
<feature_engineering> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
7,860,554 | df_pop['ExposedDensity'] =(df_pop['Population'] - np.power(df_pop['ConfirmedCases'], 1.43)) /df_pop['Land Area']
density = df_pop.groupby(['Country/Region', 'Province/State'])['Density']
df_pop['PreviousDay-0ExposedDensity'] = df_pop.groupby(['Country/Region', 'Province/State'])['ExposedDensity'].shift(periods=1, fill_... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
7,860,554 | model_x_columns_without_dummies = add_cols + pop_cols + ext_cols + previous_days_cols + special_cols2
model_x_columns = model_x_columns_without_dummies + continent_columns
def train_test_split(X, y, test_size=0.3, random_state=0):
day_first = min(X['DayNum'])
day_last = max(X['DayNum'])
number_of_days_for_train = int... | train_data['IsMale'] = train_data['Sex'].apply(lambda x: 1 if x == 'male' else 0)
train_data.head() | Titanic - Machine Learning from Disaster |
7,860,554 | scaler0 = None
scaler1 = None
scaler2 = None
def scale_data(data):
global scaler0, scaler1, scaler2
data_bis = data.copy()
daynum = data_bis['DayNum'].copy()
memory = dict()
for c in special_cols2:
memory[c] = data_bis[c].copy()
if scaler1:
data_bis[model_x_columns_without_dummies] = scaler0.transform(data[model_x_colu... | test_data['IsMale'] = test_data['Sex'].apply(lambda x: 1 if x == 'male' else 0)
test_data.head() | Titanic - Machine Learning from Disaster |
7,860,554 | model_path = join('.')
model_file_f = join(model_path, 'nn_model_f.h5')
model_file_cc = join(model_path, 'nn_model_cc.h5' )<import_modules> | y = train_data["Survived"]
features = ["Pclass", "IsMale", "SibSp", "Parch", "Age", "Fare"]
X = train_data[features]
X.tail() | Titanic - Machine Learning from Disaster |
7,860,554 | class Swish(Activation):
def __init__(self, activation, **kwargs):
super(Swish, self ).__init__(activation, **kwargs)
self.__name__ = 'swish'
def swish(x, beta = 0.6):
return(x * sigmoid(beta * x))
get_custom_objects().update({'swish': Swish(swish)} )<choose_model_class> | X_filled = KNN(k=3 ).fit_transform(X)
X_filled[-5:] | Titanic - Machine Learning from Disaster |
7,860,554 | model_f = Sequential()
model_f.add(Dense(50, input_dim=len(model_x_columns)-1, activation='swish'))
model_f.add(Dropout(0.2))
model_f.add(Dense(15, activation='elu'))
model_f.add(Dropout(0.2))
model_f.add(Dense(1, activation='elu'))
opt_f = Adam(learning_rate=0.001, beta_1=0.94, beta_2=0.99, amsgrad=False)
model_f.com... | X_filled = pd.DataFrame(data=X_filled,columns=['Pclass','IsMale','SibSp','Parch','Age','Fare'])
X_filled.head() | Titanic - Machine Learning from Disaster |
7,860,554 | model_f = load_model(model_file_f)
tr_pred = predict_output(data_X_tr[model_x_columns].drop(columns=['DayNum']), model_f)
val_pred = predict_output(data_X_val[model_x_columns].drop(columns=['DayNum']), model_f)
test_pred = predict_output(data_X_test[model_x_columns].drop(columns=['DayNum']), model_f)
analyse3(data_... | X_train, X_valid, y_train, y_valid = train_test_split(X_filled, y, random_state=1)
model = XGBRFClassifier(n_estimators=1000, max_depth=5, random_state=1, learning_rate=0.5)
model.fit(X_train, y_train,
early_stopping_rounds=5,
eval_set=[(X_valid, y_valid)],
verbose=False)
predictions = model.predict(X_valid)
print(... | Titanic - Machine Learning from Disaster |
7,860,554 | model_cc = Sequential()
model_cc.add(Dense(28, input_dim=len(model_x_columns)-1, activation='swish'))
model_cc.add(Dropout(0.0))
model_cc.add(Dense(15, activation='elu'))
model_cc.add(Dropout(0.0))
model_cc.add(Dense(1, activation='swish'))
opt_cc = Adam(learning_rate=0.0001, beta_1=0.988, beta_2=0.99, amsgrad=False)
... | X_test = test_data[features]
X_test_filled = KNN(k=3 ).fit_transform(X_test)
X_test_filled = pd.DataFrame(data=X_test_filled,columns=['Pclass','IsMale','SibSp','Parch','Age','Fare'])
X_test_filled | Titanic - Machine Learning from Disaster |
7,860,554 | model_cc = load_model(model_file_cc)
tr_pred = predict_output(data_X_tr[model_x_columns].drop(columns=['DayNum']), model_cc)
val_pred = predict_output(data_X_val[model_x_columns].drop(columns=['DayNum']), model_cc)
test_pred = predict_output(data_X_test[model_x_columns].drop(columns=['DayNum']), model_cc)
analyse3(... | predictions_final = model.predict(X_test_filled)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions_final})
output | Titanic - Machine Learning from Disaster |
7,860,554 | <merge><EOS> | output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
8,291,989 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<merge> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
data = pd.read_csv("/kaggle/input/titanic/train.csv")
test=pd.read_csv("/kaggle/input/titanic/test.csv")
| Titanic - Machine Learning from Disaster |
8,291,989 | output_columns = ['ConfirmedCases', 'Fatalities']
tmp_output_columns = ['ConfirmedCases_y', 'Fatalities_y']
last_training_day = df['DayNum'].max()
first_test_day = df_test['DayNum'].min()
train_test_keys = ['Country/Region', 'Province/State', 'DayNum']
df_test_pop_train = pd.merge(df_test_pop, df_pop[df_pop['DayNum']>=... | name=[]
cnt=[]
for column in data.columns:
name.append(column)
cnt.append(data[column].isna().sum())
tmp=pd.DataFrame(cnt,name)
print('Count of Na values in dataset')
tmp | Titanic - Machine Learning from Disaster |
8,291,989 | df_test_final = pd.concat([df_pop[df_pop['DayNum']<first_test_day], df_test_pop_train] ).reset_index(drop=True)
df_test_final[(df_test_final['Country/Region']=='Poland')&(df_test_final['DayNum']<=last_training_day+1)&(df_test_final['DayNum']>last_training_day-10)]<prepare_output> | name=[]
cnt=[]
for column in test.columns:
name.append(column)
cnt.append(test[column].isna().sum())
tmp=pd.DataFrame(cnt,name)
print('Count of Na values in dataset')
tmp | Titanic - Machine Learning from Disaster |
8,291,989 | df_test_final['PopulationOrg'] = df_test_final['Population'].copy()
df_test_final['Land Area Org'] = df_test_final['Land Area'].copy()<feature_engineering> | data.Age=data.Age.fillna(data.Age.mean())
data.Embarked=data.Embarked.fillna(data.Embarked.mode() [0])
test.Age=test.Age.fillna(test.Age.mean() ) | Titanic - Machine Learning from Disaster |
8,291,989 | model_cc = load_model(model_file_cc)
model_f = load_model(model_file_f)
last_test_day = df_test['DayNum'].max()
for day in range(last_training_day+1, last_test_day+1):
print('predicting day {}({} to go)'.format(day, last_test_day-day))
add_extra_features_from_previous_days(df_test_final, TAIL)
df_test_final['Previou... | ( data.Cabin.isnull().sum() /(data.shape[0])) *100 | Titanic - Machine Learning from Disaster |
8,291,989 | submission_columns = ['ForecastId', 'ConfirmedCases', 'Fatalities']
df_test_final.loc[df_test_final['ForecastId'].isna() , 'ForecastId'] = 0
df_test_final[submission_columns] = df_test_final[submission_columns].astype(int)
df_test_final[df_test_final['DayNum']>=first_test_day][submission_columns].to_csv('submission.cs... | data=data.drop(['Cabin'],1)
data.sample(3 ) | Titanic - Machine Learning from Disaster |
8,291,989 | warnings.filterwarnings("ignore" )<load_from_csv> | a1=data[(data.Age <= 10)&(data.Survived == 1)].count() [0]
a2=data[(( data.Age>10)&(data.Age<=20)) &(data.Survived==1)].count() [0]
a3=data[(( data.Age>20)&(data.Age<=30)) &(data.Survived==1)].count() [0]
a4=data[(( data.Age>30)&(data.Age<=40)) &(data.Survived==1)].count() [0]
a5=data[(( data.Age>40)&(data.Age<=50)) &(... | Titanic - Machine Learning from Disaster |
8,291,989 | df_train=pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
df_test=pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
df_sub=pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
print(df_train.shape)
print(df_test.shape)
print(df_sub.shape )<count_unique_val... | data=data.drop(['Name','Ticket','Fare','Parch'],1)
test=test.drop(['Name','Ticket','Fare','Parch','Cabin'],1 ) | Titanic - Machine Learning from Disaster |
8,291,989 | print(f"Unique Countries: {len(df_train.Country_Region.unique())}" )<feature_engineering> | le = LabelEncoder()
data['Sex']= le.fit_transform(data['Sex'])
data['Embarked']= le.fit_transform(data['Embarked'])
test['Sex']= le.fit_transform(test['Sex'])
test['Embarked']= le.fit_transform(test['Embarked'])
| Titanic - Machine Learning from Disaster |
8,291,989 | train_dates=list(df_train.Date.unique())
latest_date=df_train.Date.max()
print(f"Period : {len(df_train.Date.unique())} days")
print(f"From : {df_train.Date.min() } To : {df_train.Date.max() }" )<count_unique_values> | x=data.drop(['Survived'],1)
y=data['Survived'] | Titanic - Machine Learning from Disaster |
8,291,989 | print(f"Unique Regions: {df_train.shape[0]/len(df_train.Date.unique())}" )<count_values> | model = RandomForestClassifier(n_estimators=1300, min_samples_leaf=16,bootstrap = True,
max_features = 'sqrt')
model.fit(x,y)
prediction=model.predict(test ) | Titanic - Machine Learning from Disaster |
8,291,989 | df_train.Country_Region.value_counts()<count_missing_values> | sub=pd.read_csv('.. /input/titanic/gender_submission.csv')
Yt=sub['Survived'].values | Titanic - Machine Learning from Disaster |
8,291,989 | print(f"Number of rows without Country_Region : {df_train.Country_Region.isna().sum() }" )<drop_column> | print("Accuaracy:",accuracy_score(Yt, prediction))
print("Precision:", precision_score(Yt, prediction))
| Titanic - Machine Learning from Disaster |
8,291,989 | df_train.drop(labels=["Id","Province_State","Country_Region"], axis=1, inplace=True)
df_train<feature_engineering> | testf=pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
8,291,989 | <filter><EOS> | submission = pd.DataFrame({'PassengerId':testf['PassengerId'],'Survived':prediction})
submission.head()
filename = 'Titanic1.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
7,780,401 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_x_and_y> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
7,780,401 | %%time
reg_score_list=[]
period=[]
reg=[]
for n in range(3,10):
for region in region_list:
df_temp=final_train[final_train.UniqueRegion==region]
df_temp=df_temp.tail(n ).reset_index()
date=np.arange(1,n+1)
model=LinearRegression()
X=date.reshape(-1,1)
Y=df_temp.Delta
model.fit(X,Y)
reg.append(region)
reg_score_list... | gender_submission = pd.read_csv(".. /input/titanic/gender_submission.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
train = pd.read_csv(".. /input/titanic/train.csv" ) | Titanic - Machine Learning from Disaster |
7,780,401 | print(f"Unique Countries: {len(df_test.Country_Region.unique())}")
test_dates=list(df_test.Date.unique())
size_test=len(df_test.Date.unique())
print(f"Period : {len(df_test.Date.unique())} days")
print(f"From : {df_test.Date.min() } To : {df_test.Date.max() }")
print(f"Unique Regions: {df_test.shape[0]/len(df_test... | train['FamilySize'] = train['SibSp'] + train['Parch']
test['FamilySize'] = test['SibSp'] + train['Parch'] | Titanic - Machine Learning from Disaster |
7,780,401 | df_test["UniqueRegion"]=df_test.Country_Region
df_test.UniqueRegion[df_test.Province_State.isna() ==False]=df_test.Province_State+" , "+df_test.Country_Region<drop_column> | f_file=test['PassengerId']
train=train.drop(['Cabin','PassengerId','Name', 'Ticket', 'SibSp', 'Parch'],axis=1)
test=test.drop(['Cabin','PassengerId','Name', 'Ticket', 'SibSp', 'Parch'],axis=1)
| Titanic - Machine Learning from Disaster |
7,780,401 | df_test.drop(labels=["ForecastId","Province_State","Country_Region"], axis=1, inplace=True)
df_test["ConfirmedCases"]=0
df_test["Fatalities"]=0
df_test["NewCases"]=0
df_test["Delta"]=0<prepare_x_and_y> | train['Age'].fillna(train['Age'].mean() , inplace=True)
train.dropna(inplace=True)
test['Age'].fillna(test['Age'].mean() , inplace=True)
| Titanic - Machine Learning from Disaster |
7,780,401 | df_pred=pd.DataFrame(columns=["ConfirmedCases","Fatalities"])
df_traintest=pd.DataFrame(columns=["Date","ConfirmedCases","Fatalities","UniqueRegion","NewCases","Delta"])
for region in region_list:
df_temp=final_train[final_train.UniqueRegion==region].reset_index()
n=int(best_n_df[best_n_df.Region==region].N.sum())
d... | my_label = LabelEncoder()
train['Sex'] = my_label.fit_transform(train['Sex'])
train['Embarked'] = my_label.fit_transform(train['Embarked'])
test['Sex'] = my_label.fit_transform(test['Sex'])
test['Embarked'] = my_label.fit_transform(test['Embarked'])
train.head() | Titanic - Machine Learning from Disaster |
7,780,401 | df_pred=pd.DataFrame(columns=["ConfirmedCases","Fatalities"])
df_traintest=pd.DataFrame(columns=["Date","ConfirmedCases","Fatalities","UniqueRegion","NewCases","Delta"])
for region in region_list:
df_temp=final_train[final_train.UniqueRegion==region].reset_index()
n=10
NewCasesList=df_temp.tail(n ).NewCases
death_rat... | train_X, val_X, train_y, val_y = train_test_split(train.drop(['Survived'], axis=1), train['Survived'] ) | Titanic - Machine Learning from Disaster |
7,780,401 | df_pred=pd.DataFrame(columns=["ConfirmedCases","Fatalities"])
df_traintest=pd.DataFrame(columns=["Date","ConfirmedCases","Fatalities","UniqueRegion","NewCases","Delta"])
for region in region_list:
df_temp=final_train[final_train.UniqueRegion==region].reset_index()
n=7
ConfirmedCasesList=df_temp.tail(n ).ConfirmedCase... | rf = RandomForestClassifier(random_state=1)
rf.fit(train_X, train_y)
prediction = rf.predict(val_X)
print(mean_absolute_error(val_y, prediction), accuracy_score(val_y, prediction)) | Titanic - Machine Learning from Disaster |
7,780,401 | df_sub.ConfirmedCases=df_pred.ConfirmedCases
df_sub.Fatalities=df_pred.Fatalities
<load_from_csv> | XGB = XGBClassifier()
XGB.fit(train_X, train_y)
prediction = XGB.predict(val_X)
print(mean_absolute_error(val_y, prediction), accuracy_score(val_y, prediction)) | Titanic - Machine Learning from Disaster |
7,780,401 | 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" )<count_missing_values> | test['Fare'].fillna(test['Fare'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
7,780,401 | train_df.apply(lambda col: col.isnull().value_counts() , axis=0 )<count_missing_values> | vals = rf.predict(test)
file = pd.DataFrame({'PassengerId':f_file, 'Survived':vals})
file.to_csv('submission_rf.csv', index = False)
file.head() | Titanic - Machine Learning from Disaster |
7,780,401 | <data_type_conversions><EOS> | vals = XGB.predict(test)
file = pd.DataFrame({'PassengerId':f_file, 'Survived':vals})
file.to_csv('submission_xgb.csv', index = False)
file.head() | Titanic - Machine Learning from Disaster |
5,103,938 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | print(os.listdir(".. /input"))
%matplotlib inline
mpl.rc('axes', labelsize=14)
mpl.rc('xtick', labelsize=12)
mpl.rc('ytick', labelsize=12)
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
5,103,938 | train_df["Date"] = pd.to_datetime(train_df["Date"])
test_df["Date"] = pd.to_datetime(test_df["Date"] )<feature_engineering> | train=pd.read_csv('.. /input/train.csv' ) | Titanic - Machine Learning from Disaster |
5,103,938 | train_df["NewCases"] = train_df.groupby(["Country_Region", "Province_State"])["ConfirmedCases"].diff(periods=1)
train_df["NewCases"] = train_df["NewCases"].fillna(0)
train_df["NewCases"] = np.where(train_df["NewCases"] < 0, 0, train_df["NewCases"])
train_df["NewFatalities"] = train_df.groupby(["Country_Region", "Pro... | test=pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
5,103,938 | train_df["NewCases"] = np.log(train_df["NewCases"] + 1)
train_df["NewFatalities"] = np.log(train_df["NewFatalities"] + 1 )<categorify> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
5,103,938 | def preprocess_train(n_prev, n_next):
df = train_df.copy()
input_feats, output_feats = [], []
for i in range(1, n_prev+1):
for feat in ["NewCases", "NewFatalities"]:
df["{}_prev_{}".format(feat, i)] = df.groupby(["Country_Region", "Province_State"])[feat].shift(i)
input_feats.append("{}_prev_{}".format(feat, i))
outpu... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
5,103,938 | def preprocess_test(n_prev):
input_feats = []
append_df = pd.concat([train_df, test_df[test_df["Date"] == train_df["Date"].max() + timedelta(days=1)]])
append_df.sort_values(["Country_Region", "Province_State", "Date"], ascending=[True, True, True], inplace=True)
for i in range(1, n_prev+1):
for feat in ["NewCases", ... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
5,103,938 | n_next =(test_df["Date"].max() - train_df["Date"].max() ).days
n_next<train_model> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
5,103,938 | const_df, time_df, output_df = preprocess_train(n_next, n_next )<split> | train['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
5,103,938 | const_test_df, time_test_df = preprocess_test(n_next )<import_modules> | train['Pclass'].value_counts() | Titanic - Machine Learning from Disaster |
5,103,938 | from keras.models import Model
from keras import layers
from keras import Input<choose_model_class> | train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
5,103,938 | time_input = Input(shape=(time_df.shape[1], time_df.shape[2]))
lstm = layers.LSTM(32 )(time_input)
const_input = Input(shape=(const_df.shape[1],))
combine = layers.concatenate([lstm, const_input], axis=-1)
output = layers.Dense(output_df.shape[1], activation='relu' )(combine)
model = Model([time_input, const_input],... | train['Sex'].value_counts() | Titanic - Machine Learning from Disaster |
5,103,938 | model.fit([time_df, const_df], output_df, epochs=300, batch_size=128 )<predict_on_test> | train[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
5,103,938 | output = model.predict([time_test_df, const_test_df])
output.shape<feature_engineering> | train.groupby('Pclass' ).apply(lambda x:x.groupby('Sex')['Survived'].mean() ).style.background_gradient(cmap='cool' ) | Titanic - Machine Learning from Disaster |
5,103,938 | sub_test_df = test_df[test_df["Date"] > train_df["Date"].max() ]
sub_test_df = pd.concat([sub_test_df,
pd.DataFrame(output.reshape(( -1, 2)) , columns=["NewCases", "NewFatalities"], index=sub_test_df.index)],
axis=1)
sub_test_df["NewCases"] = np.exp(sub_test_df["NewCases"])- 1
sub_test_df["NewFatalities"] = np.exp(sub... | train['Cabin'].nunique() | Titanic - Machine Learning from Disaster |
5,103,938 | fixed_test_df = test_df[test_df["Date"] <= train_df["Date"].max() ].merge(train_df[train_df["Date"] >= test_df["Date"].min() ][["Province_State","Country_Region", "Date", "ConfirmedCases", "Fatalities"]],
how="left", on=["Province_State","Country_Region", "Date"])
fixed_test_df<concatenate> | train['Ticket'].nunique() | Titanic - Machine Learning from Disaster |
5,103,938 | predict_df = pd.concat([sub_test_df, fixed_test_df] ).sort_values(["Country_Region", "Province_State", "Date"],
ascending=[True, True, True])
predict_df<feature_engineering> | train['PassengerId'].nunique() | Titanic - Machine Learning from Disaster |
5,103,938 | predict_df = predict_df.reset_index()
for i in range(len(predict_df)) :
if pd.isnull(predict_df.iloc[i]["ConfirmedCases"]):
predict_df.loc[i, "ConfirmedCases"] = predict_df.iloc[i - 1]["ConfirmedCases"] + predict_df.iloc[i]["NewCases"]
if pd.isnull(predict_df.iloc[i]["Fatalities"]):
predict_df.loc[i, "Fatalities"] = pr... | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
5,103,938 | predict_df[["ForecastId", "ConfirmedCases", "Fatalities"]].to_csv("submission.csv", index=False )<set_options> | train['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
5,103,938 | %matplotlib inline<set_options> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
5,103,938 | plt.style.use('default')
warnings.filterwarnings('ignore')
<load_from_csv> | train['FamilySize'] = train['SibSp'] + train['Parch']
test['FamilySize'] = test['SibSp'] + test['Parch'] | Titanic - Machine Learning from Disaster |
5,103,938 | 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.head()<data_type_conversions> | from sklearn.preprocessing import LabelEncoder | Titanic - Machine Learning from Disaster |
5,103,938 | pd.concat([round(100*train[catcols].isnull().sum() /train.shape[0],2 ).to_frame('train'),
round(100*test[catcols].isnull().sum() /test.shape[0],2 ).to_frame('test')],axis=1 )<feature_engineering> | test['Fare'].fillna(test['Fare'].median() , inplace = True)
train['FareCategory'] = pd.qcut(train['Fare'], 5)
test['FareCategory'] = pd.qcut(test['Fare'], 5 ) | Titanic - Machine Learning from Disaster |
5,103,938 | print(f'TRAIN -> date_min= {train["Date"].min() } ; date_max= {train["Date"].max() }')
print(f'TEST -> date_min= {test["Date"].min() } ; date_max= {test["Date"].max() }' )<count_unique_values> | train['Fare_Code'] = LabelEncoder().fit_transform(train['FareCategory'] ) | Titanic - Machine Learning from Disaster |
5,103,938 | len(set(train.Date.unique())& set(test.Date.unique()))<data_type_conversions> | test['Fare_Code'] = LabelEncoder().fit_transform(test['FareCategory'] ) | Titanic - Machine Learning from Disaster |
5,103,938 | def prepare_features(data):
data['Province_State']=data['Province_State'].str.lower()
data['Country_Region']=data['Country_Region'].str.lower()
data['UnkownProvince_State']=data['Province_State'].isnull().astype(int)
data.fillna({'Province_State':''},inplace=True)
data['Province_State']=data['Province_State'].apply(l... | train['Title'] = 0
for salut in train:
train['Title'] = train.Name.str.extract('([A-Za-z]+)\.')
test['Title'] = 0
for salut in test:
test['Title'] = test.Name.str.extract('([A-Za-z]+)\.' ) | Titanic - Machine Learning from Disaster |
5,103,938 | train=prepare_features(train)
test=prepare_features(test)
train.head(3 )<count_unique_values> | mapping = {'Mlle': 'Miss',
'Major': 'Mr',
'Col': 'Mr',
'Sir': 'Mr',
'Don': 'Mr',
'Mme': 'Miss',
'Jonkheer': 'Mr',
'Lady': 'Mrs',
'Capt': 'Mr',
'Countess': 'Mrs',
'Ms': 'Miss',
'Dona': 'Mrs'
}
train.replace({'Title': mapping}, inplace=True)
test.replace({'Title': mapping}, inplace=True ) | Titanic - Machine Learning from Disaster |
5,103,938 | train['Country_Region'].nunique()<load_from_csv> | data_df = train.append(test)
titles = ['Dr', 'Master', 'Miss', 'Mr', 'Mrs', 'Rev']
for title in titles:
age_to_impute = data_df.groupby('Title')['Age'].median() [titles.index(title)]
data_df.loc[(data_df['Age'].isnull())&(data_df['Title'] == title), 'Age'] = age_to_impute | Titanic - Machine Learning from Disaster |
5,103,938 | cols_to_keep=['Country Name','Population ages 0-14, total', 'Population ages 15-64, female','Population ages 15-64, male',
'Population ages 15-64, total','Population ages 65 and above, total',
'Population ages 80 and above, female(% of female population)',
'Population ages 80 and above, male(% of male population)','Pop... | train['Age'] = data_df['Age'][:891]
test['Age'] = data_df['Age'][891:] | Titanic - Machine Learning from Disaster |
5,103,938 | add_inf['Country Name'].replace({'bahamasthe':'bahamas','bruneidarussalam':'bahamas','czechrepublic':'czechia',
'congodemrep':'congokinshasa','congorep':'congobrazzaville','egyptarabrep':'egypt',
'gambiathe':'gambia','iranislamicrep':'iran','korearep':'koreasouth','unitedstates':'us',
'kyrgyzrepublic':'kyrgyzstan','rus... | plt.style.use('default' ) | Titanic - Machine Learning from Disaster |
5,103,938 | print('From train:{} ; From add_inf:{} ; intersection:{}'.format(train['Country_Region'].nunique() ,add_inf['Country Name'].nunique() ,
len(set(train['Country_Region'])& set(add_inf['Country Name']))))
print('From test:{} ; From add_inf:{} ; intersection:{}'.format(test['Country_Region'].nunique() ,add_inf['Country Nam... | train['AgeCategory'] = pd.qcut(train['Age'], 4)
test['AgeCategory'] = pd.qcut(test['Age'], 4 ) | Titanic - Machine Learning from Disaster |
5,103,938 | def scale_popultaion_features(data):
data['Population ages 0-14, total'].replace(0,data['Population ages 0-14, total'].mode() ,inplace=True)
data['Population ages 15-64, total'].replace(0,data['Population ages 15-64, total'].mode() ,inplace=True)
data['Population ages 65 and above, total'].replace(0,data['Population ... | train['Age_Code'] = LabelEncoder().fit_transform(train['AgeCategory'])
test['Age_Code'] = LabelEncoder().fit_transform(test['AgeCategory'] ) | Titanic - Machine Learning from Disaster |
5,103,938 | print('train shape: {} ; test shape: {}'.format(train.shape,test.shape))
train=train.merge(add_inf,left_on='Country_Region',right_on='Country Name',how='left')
test=test.merge(add_inf,left_on='Country_Region',right_on='Country Name',how='left')
print('train shape: {} ; test shape: {}'.format(train.shape,test.shape))
... | data_df['Last_Name'] = data_df['Name'].apply(lambda x: str.split(x, ",")[0])
DEFAULT_SURVIVAL_VALUE = 0.5
data_df['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in data_df[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age', 'Cabin']].groupby(['Last_Name', 'Fare']):
i... | Titanic - Machine Learning from Disaster |
5,103,938 | cols_to_keep=['country', 'total_covid_19_tests',
'total_covid_19_tests_per_million_people',
'inform_risk', 'inform_p2p_hazard_and_exposure_dimension',
'people_using_at_least_basic_sanitation_services',
'inform_vulnerability', 'inform_health_conditions',
'inform_epidemic_vulnerability', 'mortality_rate_under_5',
'preval... | for _, grp_df in data_df.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):
data_df.loc[data_df['Passe... | Titanic - Machine Learning from Disaster |
5,103,938 | who_data['country'].replace({'capeverde':'caboverde','czechrepublic':'czechia','myanmar':'burma',
'congodemrep':'congokinshasa','congorep':'congobrazzaville','guinea':'guineabissau',
'swaziland':'eswatini','southkorea':'koreasouth','macedonia':'northmacedonia',
'timor':'timorleste','unitedstates':'us','unitedstatesvirg... | train['Sex'].replace(['male','female'],[0,1],inplace=True)
test['Sex'].replace(['male','female'],[0,1],inplace=True ) | Titanic - Machine Learning from Disaster |
5,103,938 | print('From train:{} ; From who-data:{} ; intersection:{}'.format(train['Country_Region'].nunique() ,who_data['country'].nunique() ,
len(set(train['Country_Region'])& set(who_data['country']))))
print('From test:{} ; From who-data:{} ; intersection:{}'.format(test['Country_Region'].nunique() ,who_data['country'].nuniqu... | drop_elements = ['PassengerId', 'Name', 'SibSp', 'Parch','Ticket', 'Cabin', 'FareCategory', 'AgeCategory','Age', 'Fare', 'Title', 'Embarked']
| Titanic - Machine Learning from Disaster |
5,103,938 | who_data.select_dtypes(include='number' ).isnull().sum() /who_data.shape[0]<merge> | train = train.drop(drop_elements, axis=1)
test = test.drop(drop_elements, axis=1 ) | Titanic - Machine Learning from Disaster |
5,103,938 | print('train shape: {} ; test shape: {}'.format(train.shape,test.shape))
train=train.merge(who_data,left_on='Country_Region',right_on='country',how='left')
test=test.merge(who_data,left_on='Country_Region',right_on='country',how='left')
train.fillna(train.quantile (.15 ).to_dict() ,inplace=True)
test.fillna(train.qu... | y = train['Survived'] | Titanic - Machine Learning from Disaster |
5,103,938 | train['Date'] = pd.to_datetime(train['Date'], format = '%Y-%m-%d')
test['Date'] = pd.to_datetime(test['Date'], format = '%Y-%m-%d' )<feature_engineering> | X = train[train.columns[1:]]
| Titanic - Machine Learning from Disaster |
5,103,938 | def create_date_features(df):
df['day'] = df['Date'].dt.day
df['month'] = df['Date'].dt.month
df['dayofweek'] = df['Date'].dt.dayofweek
df['dayofyear'] = df['Date'].dt.dayofyear
df['weekofyear'] = df['Date'].dt.weekofyear
df['Date_day_month'] = df['Date'].dt.strftime("%m%d" ).astype(int)
return df
train=create_date_fe... | from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler | Titanic - Machine Learning from Disaster |
5,103,938 | train['Province_State']=train['Country_Region']+' '+train['Province_State']
test['Province_State']=test['Country_Region']+' '+test['Province_State']
train['Province_State']=train['Province_State'].str.replace(' ','')
test['Province_State']=test['Province_State'].str.replace(' ','')
train.drop(columns=['Country Name',... | all_features = ['Pclass', 'Sex', 'FamilySize', 'Fare_Code', 'Age_Code', 'Family_Survival'] | Titanic - Machine Learning from Disaster |
5,103,938 | train['measures_applied']=(train.Date.dt.strftime('%Y-%m-%d')>=train['entry_date'] ).astype(int)
test['measures_applied']=(test.Date.dt.strftime('%Y-%m-%d')>=test['entry_date'] ).astype(int)
train.drop(columns=['entry_date'],inplace=True)
test.drop(columns=['entry_date'],inplace=True)
train.head(3 )<categorify> | all_preprocess = ColumnTransformer(
transformers = [
('allfeatures', all_transformer, all_features),
]
) | Titanic - Machine Learning from Disaster |
5,103,938 | train=pd.get_dummies(columns=['category','measure','global-school-closures'],data=train)
test=pd.get_dummies(columns=['category','measure','global-school-closures'],data=test)
train.head(3 )<count_unique_values> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=train['Survived'] ) | Titanic - Machine Learning from Disaster |
5,103,938 | s=test.select_dtypes(include='number' ).nunique()
binary_features=s[s==2].index.values
binary_features<categorify> | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import cross_val_score | Titanic - Machine Learning from Disaster |
5,103,938 | train.fillna({col:0 for col in binary_features},inplace=True)
test.fillna({col:0 for col in binary_features},inplace=True)
filling_dict=train.median().to_dict()
train.fillna(filling_dict,inplace=True)
test.fillna(filling_dict,inplace=True)
train.head(2 )<prepare_x_and_y> | classifiers = [
LogisticRegression(random_state=42),
RandomForestClassifier(random_state=42),
SVC(random_state=42),
KNeighborsClassifier() ,
SGDClassifier(random_state=42),
] | Titanic - Machine Learning from Disaster |
5,103,938 | out = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
for province in tqdm(train['Province_State'].unique()):
train_province = train.loc[(train['Province_State'] == province)].copy()
y_Conf_true = train_province['ConfirmedCases']
y_Fat_true = train_province['Fatalities']
X_train_prov = train_p... | first_round_scores = {}
for classifier in classifiers:
pipe = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', classifier)])
pipe.fit(X_train, y_train)
print(classifier)
score = pipe.score(X_test, y_test)
first_round_scores[classifier.__class__.__name__[:10]] = score
print("model score: %.3f" % sco... | Titanic - Machine Learning from Disaster |
5,103,938 | out.to_csv('submission.csv',index=False )<set_options> | grid_scores = {}
log_clf = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', LogisticRegression(random_state=42)) ])
log_param_grid = {
'classifier__C': [0.01, 0.1, 1.0, 10],
'classifier__solver' : ['liblinear','lbfgs','sag', 'saga'],
'classifier__max_iter' : [500],
}
log_grid_search = GridSearchCV(log... | 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.