kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,795,550 | label_encoder1 = LabelEncoder()
label_encoder2 = LabelEncoder()
train_data['Country_Region'] = label_encoder2.fit_transform(train_data['Country_Region'])
test_data['Country_Region'] = label_encoder2.transform(test_data['Country_Region'] )<define_variables> | shuffled_indices = np.arange(len(input_data.values)-1)
np.random.shuffle(shuffled_indices)
shuffled_inputs = input_data.values[shuffled_indices]
shuffled_targets = target.values[shuffled_indices]
shuffled_inputs
| Titanic - Machine Learning from Disaster |
13,795,550 | Test_id = test_data.ForecastId<drop_column> | num_train_samples=int(0.8*len(shuffled_inputs))
num_validation_samples=int(len(shuffled_inputs)) -num_train_samples
train_input=shuffled_inputs[:num_train_samples]
train_target=shuffled_targets[:num_train_samples]
validation_input=shuffled_inputs[num_train_samples:]
validation_target=shuffled_targets[num_train_samples:... | Titanic - Machine Learning from Disaster |
13,795,550 | train_data.drop(['Id'], axis=1, inplace=True)
test_data.drop('ForecastId', axis=1, inplace=True )<count_missing_values> | input_size=7
output_size=2
hidden_layer_size=2700
num_hidden_layers=10
model=tf.keras.Sequential()
for i in range(num_hidden_layers):
model.add(tf.keras.layers.Dense(units=hidden_layer_size,activation='relu'))
model.add(tf.keras.layers.Dropout(0.2))
model.add(tf.keras.layers.Dense(units=output_size,activation='softmax'... | Titanic - Machine Learning from Disaster |
13,795,550 | missing_val_count_by_column =(train_data.isnull().sum())
print(missing_val_count_by_column[missing_val_count_by_column>0] )<import_modules> | test_data_raw = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data=test_data_raw.drop(['Name','Ticket','Cabin'],axis='columns')
test_data.head()
| Titanic - Machine Learning from Disaster |
13,795,550 | from xgboost.sklearn import XGBRegressor<prepare_x_and_y> | age_arr=test_data.Age.values
bool_arr=pd.isna(test_data.Age.values)
total_age=0
num_age=0
for i in range(len(age_arr)) :
if bool_arr[i]==False:
total_age+=age_arr[i]
num_age+=1
avg_age=(total_age/num_age)
for i in range(len(age_arr)) :
if bool_arr[i]==True:
age_arr[i]=avg_age
scaled_age_arr=[round(age/avg_age,2)for a... | Titanic - Machine Learning from Disaster |
13,795,550 | X_train = train_data[['Country_Region','Date']]
y_train = train_data[['ConfirmedCases', 'Fatalities']]<import_modules> | d_Sex={'male':0,'female':1}
d_Embarked={'S':0,'C':1,'Q':2}
test_data.Sex = test_data.Sex.replace(d_Sex)
test_data.Embarked = test_data.Embarked.replace(d_Embarked)
test_data.Embarked=test_data.Embarked.astype(int)
| Titanic - Machine Learning from Disaster |
13,795,550 | from sklearn.tree import DecisionTreeRegressor<choose_model_class> | test_data.drop(['PassengerId'],axis=1 ).values | Titanic - Machine Learning from Disaster |
13,795,550 | tree_regressor1 = DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=None,
max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort='deprecated',
random_state=6967, splitter='best' )<choose_mod... | probabilities = model.predict(test_data.drop(['PassengerId'],axis=1 ).values)
predictions=list()
for p in probabilities:
if p[0]>p[1]:
predictions.append(0)
else:
predictions.append(1)
print(predictions ) | Titanic - Machine Learning from Disaster |
13,795,550 | tree_regressor2 = DecisionTreeRegressor(ccp_alpha=0.0, criterion='mse', max_depth=None,
max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort='deprecated',
random_state=6967, splitter='best' )<train_mode... | output = pd.DataFrame({'PassengerId': test_data.PassengerId.values, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
13,795,550 | tree_regressor1.fit(X_train, y_train.ConfirmedCases )<train_model> | with open('my_submission.csv','r')as f:
reader=csv.reader(f)
for row in reader:
print(row ) | Titanic - Machine Learning from Disaster |
4,687,939 | tree_regressor2.fit(X_train, y_train.Fatalities )<predict_on_test> | warnings.filterwarnings("ignore")
| Titanic - Machine Learning from Disaster |
4,687,939 | best_best_estimate_1 = tree_regressor1.predict(test_data )<predict_on_test> | train=pd.read_csv('.. /input/train.csv')
test=pd.read_csv('.. /input/test.csv')
test.head() | Titanic - Machine Learning from Disaster |
4,687,939 | best_best_estimate_2 = tree_regressor2.predict(test_data )<create_dataframe> | train=train.drop('PassengerId',axis=1)
PassengerId=test['PassengerId']
test=test.drop('PassengerId',axis=1)
Survived=train['Survived']
| Titanic - Machine Learning from Disaster |
4,687,939 | df_sub = pd.DataFrame()<save_to_csv> | o=[]
c=['SibSp','Age','Parch','Fare']
for f in c:
q1=np.percentile(train[f],25)
q3=np.percentile(train[f],75)
iq=q3-q1
iqs=1.5*iq
oi=train[(train[f]<q1-iqs)|(train[f]>q3+iqs)].index
o.extend(oi)
o=Counter(o)
mo=list(k for k,v in o.items() if v>2)
train=train.drop(mo,axis=0)
train.shape
| Titanic - Machine Learning from Disaster |
4,687,939 | df_sub['ForecastId'] = Test_id
df_sub['ConfirmedCases'] = np.round(best_best_estimate_1,0)
df_sub['Fatalities'] = np.round(best_best_estimate_2,0)
df_sub.to_csv('submission.csv', index=False )<install_modules> | print(train[['Pclass','Survived']].groupby(['Pclass'],as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
4,687,939 | !pip install pycountry_convert<set_options> | tlen=len(train)
data=pd.concat(objs=[train,test],axis=0 ).reset_index(drop=True)
data['size']=data['SibSp']+data['Parch']+1
| Titanic - Machine Learning from Disaster |
4,687,939 | %matplotlib inline
warnings.filterwarnings('ignore')
%config InlineBackend.figure_format = 'retina'
<load_from_csv> | data['alone']=0
data.loc[data['size']==1,'alone']=1
data['sf']=0
data.loc[data['size']==2,'sf']=1
data['mf']=data['size'].apply(lambda s: 1 if 3<= s <= 4 else 0)
data['bf']=data['size'].apply(lambda s: 1 if s>4 else 0)
| Titanic - Machine Learning from Disaster |
4,687,939 | df_train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
df_test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv' )<data_type_conversions> | data['Sex']=data['Sex'].map({'male':1,'female':0} ).astype(int)
| Titanic - Machine Learning from Disaster |
4,687,939 | df_train['Date'] = pd.to_datetime(df_train['Date'], format = '%Y-%m-%d')
df_test['Date'] = pd.to_datetime(df_test['Date'], format = '%Y-%m-%d' )<categorify> | data.isnull().sum()
| Titanic - Machine Learning from Disaster |
4,687,939 | class country_utils() :
def __init__(self):
self.d = {}
def get_dic(self):
return self.d
def get_country_details(self,country):
try:
country_obj = pycountry.countries.get(name=country)
continent_code = pc.country_alpha2_to_continent_code(country_obj.alpha_2)
continent = pc.convert_continent_code_to_continent_name(c... | data['Embarked']=data['Embarked'].fillna('S')
| Titanic - Machine Learning from Disaster |
4,687,939 | def add_daily_measures(df):
df.loc[0,'Daily Cases'] = df.loc[0,'ConfirmedCases']
df.loc[0,'Daily Deaths'] = df.loc[0,'Fatalities']
for i in range(1,len(df)) :
df.loc[i,'Daily Cases'] = df.loc[i,'ConfirmedCases'] - df.loc[i-1,'ConfirmedCases']
df.loc[i,'Daily Deaths'] = df.loc[i,'Fatalities'] - df.loc[i-1,'Fatalities']
... | l=data[data['Age'].isnull() ].index
for i in l:
am=data['Age'].median()
ap= data["Age"][(( data['SibSp'] == data.iloc[i]["SibSp"])&(data['Parch'] == data.iloc[i]["Parch"])&(data['Pclass'] == data.iloc[i]["Pclass"])) ].median()
if not np.isnan(ap):
data['Age'].iloc[i] = ap
else :
data['Age'].iloc[i] = am | Titanic - Machine Learning from Disaster |
4,687,939 | df_world = df_train.copy()
df_world = df_world.groupby('Date',as_index=False)['ConfirmedCases','Fatalities'].sum()
df_world = add_daily_measures(df_world )<data_type_conversions> | data['title'] = data['title'].replace(['Lady', 'Countess','Capt', 'Col','Don'\
, 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
data['title'] = data['title'].replace('Mlle', 'Miss')
data['title'] = data['title'].replace('Ms', 'Miss')
data['title'] = data['title'].replace('Mme', 'Mrs')
| Titanic - Machine Learning from Disaster |
4,687,939 | df_map = df_train.copy()
df_map = df_map[:24500]
df_map['Date'] = df_map['Date'].astype(str)
df_map = df_map.groupby(['Date','Country_Region'], as_index=False)['ConfirmedCases','Fatalities'].sum()<feature_engineering> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
data['title'] = data['title'].map(title_mapping)
| Titanic - Machine Learning from Disaster |
4,687,939 | df_map['iso_alpha'] = df_map.apply(lambda x: obj.fetch_iso3(x['Country_Region']), axis=1 )<feature_engineering> | data['Embarked'] = data['Embarked'].map({'S': 0, 'C': 1, 'Q': 2})
| Titanic - Machine Learning from Disaster |
4,687,939 | df_map['ln(ConfirmedCases)'] = np.log(df_map.ConfirmedCases + 1)
df_map['ln(Fatalities)'] = np.log(df_map.Fatalities + 1 )<filter> | Ticket = []
for i in list(data.Ticket):
if not i.isdigit() :
Ticket.append(i.replace(".","" ).replace("/","" ).strip().split(' ')[0])
else:
Ticket.append("X")
data["Ticket"] = Ticket
data["Ticket"].head()
| Titanic - Machine Learning from Disaster |
4,687,939 | last_date = df_train.Date.max()
df_countries = df_train[df_train['Date']==last_date]
df_countries = df_countries.groupby('Country_Region', as_index=False)['ConfirmedCases','Fatalities'].sum()
df_countries = df_countries.nlargest(10,'ConfirmedCases')
df_trend = df_train.groupby(['Date','Country_Region'], as_index=False... | data["Pclass"] = data["Pclass"].astype("category")
data = pd.get_dummies(data, columns = ["Pclass",'Ticket','Embarked','Cabin'] ) | Titanic - Machine Learning from Disaster |
4,687,939 | df_map['Mortality Rate%'] = round(( df_map.Fatalities/df_map.ConfirmedCases)*100,2 )<define_variables> | data=data.drop(['Name'],axis=1 ) | Titanic - Machine Learning from Disaster |
4,687,939 | us_state_abbrev = {
'Alabama': 'AL',
'Alaska': 'AK',
'American Samoa': 'AS',
'Arizona': 'AZ',
'Arkansas': 'AR',
'California': 'CA',
'Colorado': 'CO',
'Connecticut': 'CT',
'Delaware': 'DE',
'District of Columbia': 'DC',
'Florida': 'FL',
'Georgia': 'GA',
'Guam': 'GU',
'Hawaii': 'HI',
'Idaho': 'ID',
'Illinois': 'IL',
'Ind... | train=data[:tlen]
test=data[tlen:]
| Titanic - Machine Learning from Disaster |
4,687,939 | df_us = df_train[df_train['Country_Region']=='US']
df_us['Date'] = df_us['Date'].astype(str)
df_us['state_code'] = df_us.apply(lambda x: us_state_abbrev.get(x.Province_State,float('nan')) , axis=1)
df_us['ln(ConfirmedCases)'] = np.log(df_us.ConfirmedCases + 1)
df_us['ln(Fatalities)'] = np.log(df_us.Fatalities + 1 )<... | xtrain=train.drop(['Survived'],axis=1 ).values
xtest=test.drop(['Survived'],axis=1 ).values
ytrain=train['Survived'].values | Titanic - Machine Learning from Disaster |
4,687,939 | df_train.Province_State.fillna('NaN', inplace=True)
df_plot = df_train.groupby(['Date','Country_Region','Province_State'], as_index=False)['ConfirmedCases','Fatalities'].sum()<groupby> | sv=SVC() | Titanic - Machine Learning from Disaster |
4,687,939 | df_train.Province_State.fillna('NaN', inplace=True)
df_plot = df_train.groupby(['Date','Country_Region','Province_State'], as_index=False)['ConfirmedCases','Fatalities'].sum()<groupby> | kf=KFold(10,True,0 ) | Titanic - Machine Learning from Disaster |
4,687,939 | df_train.Province_State.fillna('NaN', inplace=True)
df_plot = df_train.groupby(['Date','Country_Region','Province_State'], as_index=False)['ConfirmedCases','Fatalities'].sum()<load_from_csv> | cross_val_score(sv, xtrain, y = ytrain, scoring = "accuracy", cv = kf, n_jobs=4 ).mean() | Titanic - Machine Learning from Disaster |
4,687,939 | config = tf.compat.v1.ConfigProto(device_count = {'GPU': 1 , 'CPU': 10})
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
def main_for_train(save_model_train=False, save_public_test=False):
train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
train[... | scores=[]
kf=KFold(10,True,0)
for(train_index,test_index)in kf.split(xtrain):
X_train, X_test, y_train, y_test = xtrain[train_index], xtrain[test_index], ytrain[train_index], ytrain[test_index]
sv.fit(X_train, y_train)
scores.append(sv.score(X_test, y_test))
print(np.mean(scores))
| Titanic - Machine Learning from Disaster |
4,687,939 | train = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
train['Date'] = pd.to_datetime(train['Date'])
def dealing_with_null_values(dataset):
dataset = dataset
for i in dataset.columns:
replace = []
data = dataset[i].isnull()
count = 0
for j,k in zip(data,dataset[i]):
if(j==True):
count = count+1
... | from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier,ExtraTreesClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from ... | Titanic - Machine Learning from Disaster |
4,687,939 | import pandas as pd
from pathlib import Path
from pandas_profiling import ProfileReport
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder
import datetime
from sklearn.model_selection import GridSearchCV
from sklearn import preprocessing
from sklearn.model_selection import cr... | classifiers = [
SVC() ,
AdaBoostClassifier() ,
GradientBoostingClassifier() ,
LogisticRegression() ,
LinearDiscriminantAnalysis() ,
xgb.XGBClassifier() ] | Titanic - Machine Learning from Disaster |
4,687,939 | dataset_path = Path('/kaggle/input/covid19-global-forecasting-week-4')
train = pd.read_csv(dataset_path/'train.csv')
test = pd.read_csv(dataset_path/'test.csv')
dtree_sub = pd.read_csv(dataset_path/'submission.csv' )<create_dataframe> | for cf in classifiers:
print(cross_val_score(cf,xtrain,ytrain,cv=10 ).mean())
| Titanic - Machine Learning from Disaster |
4,687,939 | train_profile = ProfileReport(train, title='COVID19 WEEK 4 Profiling Report', html={'style':{'full_width':True}},progress_bar=False);
train_profile<categorify> | n=xtrain.shape[0]
| Titanic - Machine Learning from Disaster |
4,687,939 | def fill_state(state,country):
if pd.isna(state): return country
return state<feature_engineering> | kf=KFold(10,True,0)
sttrain=np.zeros(( n,1))
stest=np.zeros(( xtest.shape[0],1))
for cf in classifiers:
otr=np.zeros(( n,))
oof_test = np.zeros(( xtest.shape[0],))
oof_test_skf = np.empty(( 10, xtest.shape[0]))
for i,(train_index,test_index)in enumerate(kf.split(train)) :
X_train, X_test, y_train, y_test = xtrain[trai... | Titanic - Machine Learning from Disaster |
4,687,939 | train['Province_State'] = train.loc[:, ['Province_State', 'Country_Region']].apply(lambda x : fill_state(x['Province_State'], x['Country_Region']), axis=1)
test['Province_State'] = test.loc[:, ['Province_State', 'Country_Region']].apply(lambda x : fill_state(x['Province_State'], x['Country_Region']), axis=1)
train['D... | xgc=xgb.XGBClassifier()
xgc.fit(sttrain,ytrain)
pred=xgc.predict(stest ).astype(int ) | Titanic - Machine Learning from Disaster |
4,687,939 | dtree_sub=pd.DataFrame(columns=dtree_sub.columns)
l1=LabelEncoder()
l2=LabelEncoder()
l1.fit(train['Country_Region'])
l2.fit(train['Province_State'] )<categorify> | Titanic - Machine Learning from Disaster | |
4,687,939 | countries=train['Country_Region'].unique()
for country in countries:
country_df=train[train['Country_Region']==country]
provinces=country_df['Province_State'].unique()
for province in provinces:
train_df=country_df[country_df['Province_State']==province]
train_df.pop('Id')
x=train_df[['Province_State','Country_Region'... | FileLinks('.')
| Titanic - Machine Learning from Disaster |
4,687,939 | dtree_confirmed=dtree_sub["ConfirmedCases"]
dtree_fatal=dtree_sub["Fatalities"]
boost_confirmed = xgb_sub["ConfirmedCases"]
boost_fatal = xgb_sub["Fatalities"]
deep_confirmed = dataframe_for_submission["ConfirmedCases"]
deep_fatal = dataframe_for_submission["Fatalities"]
dataframe_for_submission["ConfirmedCases"] = 0.1... | kfold = StratifiedKFold(n_splits=10 ) | Titanic - Machine Learning from Disaster |
4,687,939 | warnings.filterwarnings('ignore')
<load_from_csv> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001, 0.01, 0.1, 1],
'C': [1, 10, 50, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=kf, scoring="accuracy", n_jobs= 4, verbose = 1)
gsSVMC.fit(xtrain,ytrain)
SVMC_best = gsSVMC.best_estimator_
gsSVMC.best_s... | Titanic - Machine Learning from Disaster |
4,687,939 | covid_cases = pd.read_csv('.. /input/novel-corona-virus-2019-dataset/covid_19_data.csv')
covid_cases.head()<load_from_csv> | RFC = RandomForestClassifier()
rf_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsRFC = GridSearchCV(RFC,param_grid = rf_param_grid, cv=kf, scoring="accuracy", n_jobs... | Titanic - Machine Learning from Disaster |
4,687,939 | training_data = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
testing_data = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv" )<data_type_conversions> | ExtC = ExtraTreesClassifier()
ex_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsExtC = GridSearchCV(ExtC,param_grid = ex_param_grid, cv=kf, scoring="accuracy", n_job... | Titanic - Machine Learning from Disaster |
4,687,939 | print(training_data.isnull().sum())
print(testing_data.isnull().sum())
print(training_data.dtypes)
print(testing_data.dtypes)
training_data['Province_State'].fillna("",inplace = True)
testing_data['Province_State'].fillna("",inplace = True )<concatenate> | GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [100,200,300],
'learning_rate': [0.1, 0.05, 0.01],
'max_depth': [4, 8],
'min_samples_leaf': [100,150],
'max_features': [0.3, 0.1]
}
gsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, cv=kfold, scoring="accuracy", n_jobs= 4, ve... | Titanic - Machine Learning from Disaster |
4,687,939 | country_list = covid_cases['Country/Region'].unique()
country_grouped_covid = covid_cases[0:1]
for country in country_list:
test_data = covid_cases['Country/Region'] == country
test_data = covid_cases[test_data]
country_grouped_covid = pd.concat([country_grouped_covid, test_data], axis=0)
country_grouped_covid.reset_i... | votingC = VotingClassifier(estimators=[('rfc', RFC_best),('extc', ExtC_best),
('svc', SVMC_best),('gbc',GBC_best)], voting='soft', n_jobs=4)
votingC = votingC.fit(xtrain, ytrain ) | Titanic - Machine Learning from Disaster |
4,687,939 | latest_data = country_grouped_covid['ObservationDate'] == '04/10/2020'
country_data = country_grouped_covid[latest_data]
country_list = country_data['Country/Region'].unique()
print("The total number of countries with COVID-19 Confirmed cases = {}".format(country_list.size))<feature_engineering> | test_Survived = pd.Series(votingC.predict(xtest), name="Survived" ).astype(int)
results = pd.concat([PassengerId,test_Survived],axis=1)
results.to_csv("ensemble_python_voting.csv",index=False ) | Titanic - Machine Learning from Disaster |
4,687,939 | py.init_notebook_mode(connected=True)
formated_gdf = covid_cases.groupby(['ObservationDate', 'Country/Region'])['Confirmed', 'Deaths', 'Recovered'].max()
formated_gdf = formated_gdf.reset_index()
formated_gdf['Date'] = pd.to_datetime(formated_gdf['ObservationDate'])
formated_gdf['Date'] = formated_gdf['Date'].dt.strf... | FileLinks('.' ) | Titanic - Machine Learning from Disaster |
4,687,939 | <load_from_csv><EOS> | StackingSubmission = pd.DataFrame({ 'PassengerId': PassengerId,
'Survived': pred })
StackingSubmission.to_csv("StackingSubmission.csv", index=False)
df=StackingSubmission | Titanic - Machine Learning from Disaster |
13,712,258 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | !pip install pycomp --upgrade --no-cache-dir | Titanic - Machine Learning from Disaster |
13,712,258 | covid_data = dataframe[['Date', 'State', 'Country', 'Cumulative_cases', 'Cumulative_death',
'Daily_cases', 'Daily_death', 'Latitude', 'Longitude', 'Temperature',
'Min_temperature', 'Max_temperature', 'Wind_speed', 'Precipitation',
'Fog_Presence', 'Population', 'Population Density/km', 'Median_Age',
'Sex_Ratio', 'Age%_6... | filterwarnings('ignore')
DATA_PATH = '.. /input/titanic'
TRAIN_FILENAME = 'train.csv'
TEST_FILENAME = 'test.csv' | Titanic - Machine Learning from Disaster |
13,712,258 | training_data['Country_Region'] = training_data['Country_Region'] + ' ' + training_data['Province_State']
testing_data['Country_Region'] = testing_data['Country_Region'] + ' ' + testing_data['Province_State']
del training_data['Province_State']
del testing_data['Province_State']
def split_date(date):
date = date.split(... | df = pd.read_csv(os.path.join(DATA_PATH, TRAIN_FILENAME))
df.head() | Titanic - Machine Learning from Disaster |
13,712,258 | year = []
month = []
day = []
for i in training_data.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2])
training_data['Year'] = year
training_data['Month'] = month
training_data['Day'] = day
del training_data['Date']
year = []
month = []
day = []
for i in testing_data.Date:
year.append(i[0])
month.append(i... | feature_adder = CustomFeaturesTitanic(name_title=True, cabin_class=True, ticket_class=True)
df_custom = feature_adder.fit_transform(df)
df_custom.head() | Titanic - Machine Learning from Disaster |
13,712,258 | latest_data = covid_data['Date'] == '30-03-2020'
country_data_detailed = covid_data[latest_data]
country_data_detailed.drop(['Daily_cases','Daily_death','Latitude','Longitude'],axis=1,inplace=True)
country_data_detailed.head(3 )<data_type_conversions> | dup_dropper = EliminaDuplicatas()
df_nodup = dup_dropper.fit_transform(df_slct)
print(f'Total of duplicates before: {df_slct.duplicated().sum() }')
print(f'Total of duplicates after: {df_nodup.duplicated().sum() }' ) | Titanic - Machine Learning from Disaster |
13,712,258 | country_data_detailed['Lung Patients(F)'].replace('Not reported',np.nan,inplace=True)
country_data_detailed['Lung Patients(F)'] = country_data_detailed['Lung Patients(F)'].astype("float" )<load_from_csv> | cat_custom_features = ['Pclass']
mod_dict = {col: str for col in cat_custom_features}
print(f'Selected columns dtype before transformation:
')
print(df_nodup.dtypes[cat_custom_features])
dtype_mod = ModificaTipoPrimitivo(mod_dict=mod_dict)
df_mod = dtype_mod.fit_transform(df_nodup)
print(f'Selected columns dtype af... | Titanic - Machine Learning from Disaster |
13,712,258 | temperature_data = pd.read_csv('.. /input/covcsd-covid19-countries-statistical-dataset/temperature_data.csv')
temperature_data.head()<compute_train_metric> | imputer = SimpleImputer(strategy='median')
X_train_num_imp = imputer.fit_transform(X_train_num)
X_train_num_imp = pd.DataFrame(X_train_num_imp, columns=num_features)
print(f'Null data before imputer: {X_train_num.isnull().sum().sum() }')
print(f'Null data after imputer: {X_train_num_imp.isnull().sum().sum() }' ) | Titanic - Machine Learning from Disaster |
13,712,258 | sample = temperature_dataset['Temperature'].sample(n=250)
test = temperature_dataset['Temperature']
stat, p = ttest_ind(sample, test)
print('Statistics=%.3f, p=%.3f' %(stat, p))<normalization> | tmp_ov = data_overview(df=X_train_num_imp)
tmp_ov['skew'] = tmp_ov.query('feature in @num_features')['feature'].apply(lambda x: skew(X_train_num_imp[x]))
tmp_ov['kurtosis'] = tmp_ov.query('feature in @num_features')['feature'].apply(lambda x: kurtosis(X_train_num_imp[x]))
tmp_ov[~tmp_ov['skew'].isnull() ].sort_values(... | Titanic - Machine Learning from Disaster |
13,712,258 | training_data['ConfirmedCases'] = training_data['ConfirmedCases'].apply(int)
training_data['Fatalities'] = training_data['Fatalities'].apply(int)
cases = training_data.ConfirmedCases
fatalities = training_data.Fatalities
del training_data['ConfirmedCases']
del training_data['Fatalities']
lb = LabelEncoder()
training_... | scaler = DynamicScaler(scaler_type='Standard')
X_train_num_scaled = scaler.fit_transform(X_train_num_log)
X_train_num_scaled = pd.DataFrame(X_train_num_scaled, columns=num_features)
X_train_num_scaled.head() | Titanic - Machine Learning from Disaster |
13,712,258 | rf = XGBRegressor(n_estimators = 1500 , max_depth = 15, learning_rate=0.1)
rf.fit(x_train,cases)
cases_pred = rf.predict(x_test)
rf = XGBRegressor(n_estimators = 1500 , max_depth = 15, learning_rate=0.1)
rf.fit(x_train,fatalities)
fatalities_pred = rf.predict(x_test )<feature_engineering> | encoder = DummiesEncoding(cat_features_ori=cat_features, dummy_na=True)
X_train_cat_enc = encoder.fit_transform(X_train_cat)
print(f'Shape before encoding: {X_train_cat.shape}')
print(f'Shape after encoding: {X_train_cat_enc.shape}')
X_train_cat_enc.head() | Titanic - Machine Learning from Disaster |
13,712,258 | cases_pred = np.around(cases_pred)
fatalities_pred = np.around(fatalities_pred)
cases_pred[cases_pred < 0] = 0
fatalities_pred[fatalities_pred < 0] = 0<load_from_csv> | TARGET = 'Survived'
INITIAL_FEATURES = ['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked', 'name_title',
'ticket_class', 'cabin_class', 'name_length', 'age_cat', 'fare_cat', 'family_size']
INITIAL_PRED_FEATURES = [col for col in INITIAL_FEATURES if col not in TARGET]
DTYPE_MODIFICATION_DICT = {'P... | Titanic - Machine Learning from Disaster |
13,712,258 | submission_dataset = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
submission_dataset['ConfirmedCases'] = cases_pred
submission_dataset['Fatalities'] = fatalities_pred
submission_dataset.head()<save_to_csv> | df = pd.read_csv(os.path.join(DATA_PATH, TRAIN_FILENAME))
df_prep = initial_train_pipeline.fit_transform(df)
X_train, X_val, y_train, y_val = train_test_split(df_prep.drop(TARGET, axis=1), df_prep[TARGET].values,
test_size=.20, random_state=42)
X_train_prep = prep_pipeline.fit_transform(X_train)
X_val_prep = prep_pi... | Titanic - Machine Learning from Disaster |
13,712,258 | submission_dataset.to_csv("submission.csv" , index = False )<load_from_csv> | df_prep = pd.DataFrame(X_train_prep, columns=MODEL_FEATURES)
df_prep['Survived'] = y_train
plot_corr_matrix(df=df_prep, corr_col='Survived', figsize=(12, 12), cbar=False, n_vars=15 ) | Titanic - Machine Learning from Disaster |
13,712,258 | test = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
train = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv" )<sort_values> | dtree = DecisionTreeClassifier()
forest = RandomForestClassifier()
lgbm = LGBMClassifier()
xgb = XGBClassifier()
adaboost = AdaBoostClassifier()
gradboost = GradientBoostingClassifier()
model_obj = [dtree, forest, lgbm, xgb, adaboost, gradboost]
model_names = [type(model ).__name__ for model in model_obj]
set_classifie... | Titanic - Machine Learning from Disaster |
13,712,258 | train[train['Country_Region'] == 'US'].sort_values('ConfirmedCases',ascending = False )<groupby> | trainer = ClassificadorBinario()
trainer.fit(set_classifiers, X_train_prep, y_train ) | Titanic - Machine Learning from Disaster |
13,712,258 | train[train['Country_Region'] == 'US'].groupby(['Date'] ).sum()<data_type_conversions> | metrics = trainer.evaluate_performance(X_train_prep, y_train, X_val_prep, y_val)
metrics | Titanic - Machine Learning from Disaster |
13,712,258 | train['Province_State'].fillna('', inplace=True)
test['Province_State'].fillna('', inplace=True)
train['Date'] = pd.to_datetime(train['Date'])
test['Date'] = pd.to_datetime(test['Date'])
train = train.sort_values(['Country_Region','Province_State','Date'])
test = test.sort_values(['Country_Region','Province_State'... | full_trainer = ClassificadorBinario()
full_trainer.training_flow(set_classifiers, X_train_prep, y_train, X_val_prep, y_val,
features=MODEL_FEATURES, random_search=True)
full_trainer.visual_analysis(features=MODEL_FEATURES, model_shap='LGBMClassifier' ) | Titanic - Machine Learning from Disaster |
13,712,258 | def RMSLE(pred,actual):
return np.sqrt(np.mean(np.power(( np.log(pred+1)-np.log(actual+1)) ,2)))
feature_day = [1,20,50,100,200,500,1000,5000,10000,15000,20000,50000,100000,200000, 500000]
def CreateInput(data):
feature = []
for day in feature_day:
data.loc[:,'Number day from ' + str(day)+ ' case'] = 0
if(train[(train... | metrics = pd.read_csv('output/metrics/metrics.csv')
metrics | Titanic - Machine Learning from Disaster |
13,712,258 | !pip install pmdarima<save_to_csv> | forest_tunning_grid = {
'bootstrap': [True, False],
'class_weight': [None, 'balanced'],
'criterion': ['gini', 'entropy'],
'max_depth': [5, 6, 7, 9, 10],
'n_estimators': np.arange(300, 600, 50),
'random_state': [42]
}
lgbm_tunning_grid = {
'boosting_type': ['gbdt'],
'class_weight': [None, 'balanced'],
'learning_rate': [... | Titanic - Machine Learning from Disaster |
13,712,258 | df_val = df_val_2
submission = df_val[['ForecastId','ConfirmedCases_hat','Fatalities_hat']]
submission.columns = ['ForecastId','ConfirmedCases','Fatalities']
submission = submission.round({'ConfirmedCases': 0, 'Fatalities': 0})
submission.to_csv('submission.csv', index=False)
submission<import_modules> | tunning_models_keys = ['RandomForestClassifier', 'LGBMClassifier', 'XGBClassifier', 'AdaBoostClassifier',
'GradientBoostingClassifier']
tunning_param_grids = [forest_tunning_grid, lgbm_tunning_grid, xgboost_tunning_grid, adaboost_tunning_grid,
gradboost_tunning_grid]
tunned_pipelines = {}
general_metrics = pd.DataFrame... | Titanic - Machine Learning from Disaster |
13,712,258 | warnings.filterwarnings('ignore')
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | FINAL_MODEL = 'RandomForestClassifier'
final_pipeline = tunned_pipelines[FINAL_MODEL] | Titanic - Machine Learning from Disaster |
13,712,258 | covid_cases = pd.read_csv('/kaggle/input/novel-corona-virus-2019-dataset/covid_19_data.csv')
covid_cases.head()<load_from_csv> | df_test = pd.read_csv(os.path.join(DATA_PATH, TEST_FILENAME))
print(f'Shape of test dataset: {df_test.shape}')
df_test.head() | Titanic - Machine Learning from Disaster |
13,712,258 | training_data = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/train.csv")
testing_data = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/test.csv" )<data_type_conversions> | model_consumer = ConsumoModelo(model=final_pipeline, features=INITIAL_PRED_FEATURES)
prediction_pipeline = Pipeline([
('initial', initial_pred_pipeline),
('prediction', model_consumer)
])
df_pred = prediction_pipeline.fit_transform(df_test)
df_pred.head() | Titanic - Machine Learning from Disaster |
13,712,258 | <concatenate><EOS> | df_sub = df_test.merge(df_pred, how='left', left_index=True, right_index=True)
df_sub = df_sub.loc[:, ['PassengerId', 'y_pred']]
df_sub.columns = ['PassengerId', 'Survived']
df_sub.to_csv('output/submission.csv', index=False)
df_sub.head() | Titanic - Machine Learning from Disaster |
10,357,342 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_unique_values> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns | Titanic - Machine Learning from Disaster |
10,357,342 | latest_data = country_grouped_covid['ObservationDate'] == '04/13/2020'
country_data = country_grouped_covid[latest_data]
country_list = country_data['Country/Region'].unique()
print("The total number of countries with COVID-19 Confirmed cases = {}".format(country_list.size))<feature_engineering> | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
train = train_data.copy()
test = test_data.copy() | Titanic - Machine Learning from Disaster |
10,357,342 | py.init_notebook_mode(connected=True)
formated_gdf = covid_cases.groupby(['ObservationDate', 'Country/Region'])['Confirmed', 'Deaths', 'Recovered'].max()
formated_gdf = formated_gdf.reset_index()
formated_gdf['Date'] = pd.to_datetime(formated_gdf['ObservationDate'])
formated_gdf['Date'] = formated_gdf['Date'].dt.strf... | train.drop(['PassengerId'], axis=1, inplace=True)
test.drop(['PassengerId'], axis=1, inplace=True)
pred = train['Survived'] | Titanic - Machine Learning from Disaster |
10,357,342 | py.init_notebook_mode(connected=True)
formated_gdf = covid_cases.groupby(['ObservationDate', 'Country/Region'])['Confirmed', 'Deaths', 'Recovered'].max()
formated_gdf = formated_gdf.reset_index()
formated_gdf['Date'] = pd.to_datetime(formated_gdf['ObservationDate'])
formated_gdf['Date'] = formated_gdf['Date'].dt.strf... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,357,342 | folder_name = '/kaggle/input/covcsd-covid19-countries-statistical-dataset/'
file_type = 'csv'
seperator =','
dataframe = pd.concat([pd.read_csv(f, sep=seperator)for f in glob.glob(folder_name + "/*."+file_type)],ignore_index=True,sort=False )<create_dataframe> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,357,342 | covid_data = dataframe[['Date', 'State', 'Country', 'Cumulative_cases', 'Cumulative_death',
'Daily_cases', 'Daily_death', 'Latitude', 'Longitude', 'Temperature',
'Min_temperature', 'Max_temperature', 'Wind_speed', 'Precipitation',
'Fog_Presence', 'Population', 'Population Density/km', 'Median_Age',
'Sex_Ratio', 'Age%_6... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,357,342 | training_data['Country_Region'] = training_data['Country_Region'] + ' ' + training_data['Province_State']
testing_data['Country_Region'] = testing_data['Country_Region'] + ' ' + testing_data['Province_State']
del training_data['Province_State']
del testing_data['Province_State']
def split_date(date):
date = date.split(... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,357,342 | year = []
month = []
day = []
for i in training_data.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2])
training_data['Year'] = year
training_data['Month'] = month
training_data['Day'] = day
del training_data['Date']<feature_engineering> | train['Age'].fillna(train['Age'].quantile(0.5), inplace=True)
test['Age'].fillna(test['Age'].quantile(0.5), inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | year = []
month = []
day = []
for i in testing_data.Date:
year.append(i[0])
month.append(i[1])
day.append(i[2])
testing_data['Year'] = year
testing_data['Month'] = month
testing_data['Day'] = day
del testing_data['Date']
del training_data['Id']
del testing_data['ForecastId']
del testing_data['Year']
del training_dat... | train['Embarked'].fillna('S', inplace=True)
test['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | latest_data = covid_data['Date'] == '30-03-2020'
country_data_detailed = covid_data[latest_data]
country_data_detailed.drop(['Daily_cases','Daily_death','Latitude','Longitude'],axis=1,inplace=True)
country_data_detailed.head(3 )<categorify> | test['Fare'].fillna(test['Fare'].quantile(0.5), inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | country_data_detailed.replace('Not Reported',np.nan,inplace=True)
country_data_detailed.replace('N/A',np.nan,inplace=True)
country_data_detailed.head(3 )<data_type_conversions> | sex1 = pd.get_dummies(train['Sex'])
sex2 = pd.get_dummies(test['Sex'] ) | Titanic - Machine Learning from Disaster |
10,357,342 | country_data_detailed['Lung Patients(F)'].replace('Not reported',np.nan,inplace=True)
country_data_detailed['Lung Patients(F)'] = country_data_detailed['Lung Patients(F)'].astype("float" )<load_from_csv> | train.drop(['Sex'], axis=1, inplace=True)
test.drop(['Sex'], axis=1, inplace=True)
train = pd.concat([train, sex1], axis=1)
test = pd.concat([test, sex2], axis=1 ) | Titanic - Machine Learning from Disaster |
10,357,342 | temperature_data = pd.read_csv('/kaggle/input/covcsd-covid19-countries-statistical-dataset/temperature_data.csv')
temperature_data.head()<compute_train_metric> | train.drop(['female'], axis=1, inplace=True)
test.drop(['female'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | sample = temperature_dataset['Temperature'].sample(n=250)
test = temperature_dataset['Temperature']
stat, p = ttest_ind(sample, test)
print('Statistics=%.3f, p=%.3f' %(stat, p))<normalization> | embark1 = pd.get_dummies(train['Embarked'])
embark2 = pd.get_dummies(test['Embarked'])
train.drop(['Embarked'], axis=1, inplace=True)
test.drop(['Embarked'], axis=1, inplace=True)
train = pd.concat([train, embark1], axis=1)
test = pd.concat([test, embark2], axis=1 ) | Titanic - Machine Learning from Disaster |
10,357,342 | training_data['ConfirmedCases'] = training_data['ConfirmedCases'].apply(int)
training_data['Fatalities'] = training_data['Fatalities'].apply(int)
cases = training_data.ConfirmedCases
fatalities = training_data.Fatalities
del training_data['ConfirmedCases']
del training_data['Fatalities']
lb = LabelEncoder()
training_... | def family(x):
if x['SibSp'] + x['Parch'] > 1:
return 1
else:
return 0
train['Family'] = train.apply(family, axis=1)
test['Family'] = test.apply(family, axis=1 ) | Titanic - Machine Learning from Disaster |
10,357,342 | rf = XGBRegressor(n_estimators = 1500 , max_depth = 15, learning_rate=0.1)
rf.fit(x_train,cases)
cases_pred = rf.predict(x_test)
rf = XGBRegressor(n_estimators = 1500 , max_depth = 15, learning_rate=0.1)
rf.fit(x_train,fatalities)
fatalities_pred = rf.predict(x_test )<feature_engineering> | train.drop(['SibSp','Parch'], axis=1, inplace=True)
test.drop(['SibSp','Parch'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | cases_pred = np.around(cases_pred)
fatalities_pred = np.around(fatalities_pred)
cases_pred[cases_pred < 0] = 0
fatalities_pred[fatalities_pred < 0] = 0<load_from_csv> | train['Cabin'] = pd.Series(i[0] if not pd.isnull(i)else 'X' for i in train['Cabin'])
test['Cabin'] = pd.Series(i[0] if not pd.isnull(i)else 'X' for i in test['Cabin'] ) | Titanic - Machine Learning from Disaster |
10,357,342 | submission_dataset = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
submission_dataset['ConfirmedCases'] = cases_pred
submission_dataset['Fatalities'] = fatalities_pred
submission_dataset.head()<save_to_csv> | train['Cabin'] = train['Cabin'].map({
'X': 0,
'A': 1,
'B': 2,
'C': 3,
'D': 4,
'E': 5,
'F': 6,
'G': 7,
'T': 0
})
train['Cabin'] = train['Cabin'].astype(int)
test['Cabin'] = test['Cabin'].map({
'X': 0,
'A': 1,
'B': 2,
'C': 3,
'D': 4,
'E': 5,
'F': 6,
'G': 7,
'T': 0
})
test['Cabin'] = test['Cabin'].astype(int ) | Titanic - Machine Learning from Disaster |
10,357,342 | submission_dataset.to_csv("submission.csv" , index = False )<save_to_csv> | train_title = [i.split(",")[1].split(".")[0].strip() for i in train["Name"]]
train["Title"] = pd.Series(train_title)
test_title = [i.split(",")[1].split(".")[0].strip() for i in test["Name"]]
test["Title"] = pd.Series(test_title ) | Titanic - Machine Learning from Disaster |
10,357,342 | submission_dataset.to_csv("submission.csv" , index = False )<set_options> | train = train.drop(['Name'], axis = 1)
test = test.drop(['Name'], axis = 1 ) | Titanic - Machine Learning from Disaster |
10,357,342 | plotly.offline.init_notebook_mode()
%matplotlib inline
def RMSLE(pred,actual):
return np.sqrt(np.mean(np.power(( np.log(pred+1)-np.log(actual+1)) ,2)) )<set_options> | train["Title"] = train["Title"].replace(['Lady', 'the Countess','Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
train["Title"] = train["Title"].map({"Master":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Mr":2, "Rare":3})
train["Title"] = train["Title"].astype(int)
te... | Titanic - Machine Learning from Disaster |
10,357,342 | warnings.filterwarnings("ignore")
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
<load_from_csv> | Ticket1 = []
for i in list(train.Ticket):
if not i.isdigit() :
Ticket1.append(i.replace(".","" ).replace("/","" ).strip().split(' ')[0])
else:
Ticket1.append("X")
train["Ticket"] = Ticket1
Ticket2 = []
for j in list(test.Ticket):
if not j.isdigit() :
Ticket2.append(j.replace(".","" ).replace("/","" ).strip().split(' ... | Titanic - Machine Learning from Disaster |
10,357,342 | 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")
region_metadata = pd.read_csv("/kaggle/input/covid19-forecasting-metadata/region_metadata.csv")
region_date_metadata = pd.read_csv("/kaggle/input/covid19-for... | train= pd.get_dummies(train, columns = ["Ticket"], prefix="T")
test = pd.get_dummies(test, columns = ["Ticket"], prefix="T" ) | Titanic - Machine Learning from Disaster |
10,357,342 | train = train.merge(test[["ForecastId", "Province_State", "Country_Region", "Date"]], on = ["Province_State", "Country_Region", "Date"], how = "left")
display(train.head())
test = test[~test.Date.isin(train.Date.unique())]
display(test.head())
df = pd.concat([train, test], sort = False)
df.head()<categorify> | train = train.drop(['T_SP','T_SOP','T_Fa','T_LINE','T_SWPP','T_SCOW','T_PPP','T_AS','T_CASOTON'],axis = 1)
test = test.drop(['T_SCA3','T_STONOQ','T_AQ4','T_A','T_LP','T_AQ3'],axis = 1 ) | Titanic - Machine Learning from Disaster |
10,357,342 | df["geo"] = df.Country_Region.astype(str)+ ": " + df.Province_State.astype(str)
df.loc[df.Province_State.isna() , "geo"] = df[df.Province_State.isna() ].Country_Region
df.ConfirmedCases = df.groupby("geo")["ConfirmedCases"].cummax()
df.Fatalities = df.groupby("geo")["Fatalities"].cummax()
df = df.merge(region_metadata... | train.drop(['Survived'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
10,357,342 | DAYS_SINCE_CASES = [1, 10, 50, 100, 500, 1000, 5000, 10000]
min_date_train = np.min(df[~df.Id.isna() ].Date)
max_date_train = np.max(df[~df.Id.isna() ].Date)
min_date_test = np.min(df[~df.ForecastId.isna() ].Date)
max_date_test = np.max(df[~df.ForecastId.isna() ].Date)
n_dates_test = len(df[~df.ForecastId.isna() ].... | print('Train:')
print(train.isnull().sum())
print('Test:')
print(test.isnull().sum() ) | 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.