kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,244,389 | train_data['Date'] = pd.to_datetime(train_data['Date'], infer_datetime_format=True)
test_data['Date'] = pd.to_datetime(test_data['Date'], infer_datetime_format=True )<data_type_conversions> | print("Number of missing values for females",gender_class_group.get_group(( 'female',1)).Age.isnull().sum())
print("Total for females",gender_class_group.get_group(( 'female',1)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | train_data.loc[:, 'Date'] = train_data.Date.dt.strftime('%y%m%d')
train_data.loc[:, 'Date'] = train_data['Date'].astype(int)
test_data.loc[:, 'Date'] = test_data.Date.dt.strftime('%y%m%d')
test_data.loc[:, 'Date'] = test_data['Date'].astype(int )<feature_engineering> | Titanic - Machine Learning from Disaster | |
8,244,389 | train_data['Province_State'] = np.where(train_data['Province_State'] == 'nan',train_data['Country_Region'],train_data['Province_State'])
test_data['Province_State'] = np.where(test_data['Province_State'] == 'nan',test_data['Country_Region'],test_data['Province_State'] )<data_type_conversions> | print("Number of missing values for females",gender_class_group.get_group(( 'female',1)).Age.isnull().sum())
print("Total for females",gender_class_group.get_group(( 'female',1)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | convert_dict = {'Province_State': str}
train_data = train_data.astype(convert_dict)
test_data = test_data.astype(convert_dict )<define_variables> | num_present_gender_class_2 = dict(gender_class_group.get_group(( 'female',2)).age_group.value_counts())
survived_2 = {}
for i in num_present_gender_class_2:
value = gender_class_group.get_group(( 'female',2)).loc[gender_class_group.get_group(( 'female',2)).age_group==i]['Survived']
survived_2[i] = sum(value)
list_2 =... | Titanic - Machine Learning from Disaster |
8,244,389 | s =(train_data.dtypes == 'object')
object_cols = list(s[s].index )<import_modules> | print("Number of missing values for females",gender_class_group.get_group(( 'female',2)).Age.isnull().sum())
print("Total for females",gender_class_group.get_group(( 'female',2)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | from sklearn.preprocessing import LabelEncoder<categorify> | num_present_gender_class_3 = dict(gender_class_group.get_group(( 'female',3)).age_group.value_counts())
survived_3 = {}
for i in num_present_gender_class_3:
value = gender_class_group.get_group(( 'female',3)).loc[gender_class_group.get_group(( 'female',3)).age_group==i]['Survived']
survived_3[i] = sum(value)
list_3 =... | Titanic - Machine Learning from Disaster |
8,244,389 | label_encoder1 = LabelEncoder()
label_encoder2 = LabelEncoder()
train_data['Province_State'] = label_encoder1.fit_transform(train_data['Province_State'])
test_data['Province_State'] = label_encoder1.transform(test_data['Province_State'])
train_data['Country_Region'] = label_encoder2.fit_transform(train_data['Country_... | print("Number of missing values for females",gender_class_group.get_group(( 'female',3)).Age.isnull().sum())
print("Total for females",gender_class_group.get_group(( 'female',3)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | Test_id = test_data.ForecastId<drop_column> | num_present_gender_class_4 = dict(gender_class_group.get_group(( 'male',1)).age_group.value_counts())
survived_4 = {}
for i in num_present_gender_class_4:
value = gender_class_group.get_group(( 'male',1)).loc[gender_class_group.get_group(( 'male',1)).age_group==i]['Survived']
survived_4[i] = sum(value)
list_4 = [surv... | Titanic - Machine Learning from Disaster |
8,244,389 | train_data.drop(['Id'], axis=1, inplace=True)
test_data.drop('ForecastId', axis=1, inplace=True )<count_missing_values> | print("Number of missing values for males",gender_class_group.get_group(( 'male',1)).Age.isnull().sum())
print("Total for males",gender_class_group.get_group(( 'male',1)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | missing_val_count_by_column =(train_data.isnull().sum())
print(missing_val_count_by_column[missing_val_count_by_column>0] )<import_modules> | num_present_gender_class_5 = dict(gender_class_group.get_group(( 'male',2)).age_group.value_counts())
survived_5 = {}
for i in num_present_gender_class_5:
value = gender_class_group.get_group(( 'male',2)).loc[gender_class_group.get_group(( 'male',2)).age_group==i]['Survived']
survived_5[i] = sum(value)
list_5 = [surv... | Titanic - Machine Learning from Disaster |
8,244,389 | from xgboost import XGBRegressor<prepare_x_and_y> | print("Number of missing values for males",gender_class_group.get_group(( 'male',2)).Age.isnull().sum())
print("Total for males",gender_class_group.get_group(( 'male',2)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | X_train = train_data[['Province_State','Country_Region','Date']]
y_train = train_data[['ConfirmedCases', 'Fatalities']]<prepare_x_and_y> | num_present_gender_class_6 = dict(gender_class_group.get_group(( 'male',3)).age_group.value_counts())
survived_6 = {}
for i in num_present_gender_class_6:
value = gender_class_group.get_group(( 'male',3)).loc[gender_class_group.get_group(( 'male',3)).age_group==i]['Survived']
survived_6[i] = sum(value)
list_6 = [surv... | Titanic - Machine Learning from Disaster |
8,244,389 | y_train_confirm = y_train.ConfirmedCases
y_train_fatality = y_train.Fatalities<split> | print("Number of missing values for males",gender_class_group.get_group(( 'male',3)).Age.isnull().sum())
print("Total for males",gender_class_group.get_group(( 'male',3)).PassengerId.count() ) | Titanic - Machine Learning from Disaster |
8,244,389 | x_train = X_train.iloc[:,:].values
x_test = X_train.iloc[:,:].values<train_model> | num_2 = train_data.Parch.unique()
cnt_3 = Counter()
for num in train_data.Parch:
cnt_3.update([num])
print(cnt_3)
for num in cnt_3:
num_survived = train_data.loc[train_data.Parch == num]["Survived"]
print(sum(num_survived))
rate_survived = sum(num_survived)/cnt_3[num]
print("% of {} parent/child survived".format(num)... | Titanic - Machine Learning from Disaster |
8,244,389 | model1 = XGBRegressor(n_estimators=40000)
model1.fit(X_train, y_train_confirm)
y_pred_confirm = model1.predict(test_data )<train_model> | for i in range(len(train_data)) :
if np.isnan(train_data["Age"][i]):
if train_data["Sex"][i]=='female':
train_data.at[i,"Age"]= 80
else:
train_data.at[i,"Age"]=70
for i in range(len(test_data)) :
if np.isnan(test_data["Age"][i]):
if test_data["Sex"][i]=='female':
test_data.at[i,"Age"]= 80
else:
test_data.at[i,"Age"]=70 | Titanic - Machine Learning from Disaster |
8,244,389 | model2 = XGBRegressor(n_estimators=20000)
model2.fit(X_train,y_train_fatality)
y_pred_fat = model2.predict(test_data )<save_to_csv> | Titanic - Machine Learning from Disaster | |
8,244,389 | df_sub = pd.DataFrame()
df_sub['ForecastId'] = Test_id
df_sub['ConfirmedCases'] = y_pred_confirm
df_sub['Fatalities'] = y_pred_fat
df_sub.to_csv('submission.csv', index=False )<load_from_csv> | interaction_train_2 = train_data.Age/train_data.Pclass
interaction_test_2 = test_data.Age/test_data.Pclass
interaction_test_1 = test_data.SibSp+test_data.Parch
interaction_train_1 = train_data.SibSp+train_data.Parch
| Titanic - Machine Learning from Disaster |
8,244,389 | 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_train.head()<feature_engineering> | features = ['Sex','Age','Pclass']
X_train = train_data[features]
X_test = test_data[features]
y = train_data.Survived | Titanic - Machine Learning from Disaster |
8,244,389 | def datesplit(df):
year = []
month = []
day = []
for item in df['Date']:
x = item.split("-")
year.append(x[0])
month.append(x[1])
day.append(x[2])
df['Year'] = year
df['Month'] = month
df['Day'] = day
datesplit(df_train)
datesplit(df_test)
df_train['ConfirmedCases'] = df_train['ConfirmedCases'].apply(int)
df_tra... | X_train.insert(1,"interaction",interaction_train_1)
X_train.insert(2,"interaction_1",interaction_train_2)
X_test.insert(1,"interaction",interaction_test_1)
X_test.insert(2,"interaction_1",interaction_test_2)
| Titanic - Machine Learning from Disaster |
8,244,389 | df_train['Province_State'].fillna('',inplace=True)
df_test['Province_State'].fillna('',inplace=True)
lbe = LabelEncoder()
df_train['Country_Region'] = lbe.fit_transform(df_train['Country_Region'])
df_test['Country_Region'] = lbe.transform(df_test['Country_Region'])
df_train['Province_State'] = lbe.fit_transform(df_... | label_X_train = X_train.copy()
label_X_test = X_test.copy()
label_encoder = LabelEncoder()
label_X_train['Sex'] = label_encoder.fit_transform(X_train['Sex'])
label_X_test['Sex'] = label_encoder.transform(X_test['Sex'])
| Titanic - Machine Learning from Disaster |
8,244,389 | X_train = df_train.drop(["Id", "ConfirmedCases", "Fatalities", "Date"], axis = 1)
X_test = df_test.drop(["ForecastId","Date"], axis = 1)
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train.values)
X_test = scaler.transform(X_test.values )<prepare_x_and_y> | label_X_test.tail() | Titanic - Machine Learning from Disaster |
8,244,389 | y1 = df_train['ConfirmedCases']
y2 = df_train['Fatalities']
<define_variables> | train_X, valid_X, y_train, y_valid = train_test_split(label_X_train,y,random_state =1 ) | Titanic - Machine Learning from Disaster |
8,244,389 | y_train = y1
y_train_fat = y2<train_model> | Titanic - Machine Learning from Disaster | |
8,244,389 | xgb = XGBRegressor(n_estimators = 1500 , random_state = 0 , max_depth = 15)
xgb.fit(X_train,y_train )<predict_on_test> | model = LogisticRegression()
model.fit(train_X, y_train)
predictions_val = model.predict(valid_X)
mae = mean_absolute_error(y_valid,predictions_val)
print(mae ) | Titanic - Machine Learning from Disaster |
8,244,389 | y_pred = xgb.predict(X_test)
y_pred = np.around(y_pred,decimals = 0)
y_pred<train_model> | predictions = model.predict(label_X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
11,401,977 | xgb1 = XGBRegressor(n_estimators = 1500 , random_state = 0 , max_depth = 15)
xgb1.fit(X_train,y_train_fat )<predict_on_test> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
11,401,977 | y_pred_fat = xgb1.predict(X_test)
y_pred_fat = np.around(y_pred_fat,decimals = 0)
y_pred_fat<save_to_csv> | train=pd.read_csv("/kaggle/input/titanic/train.csv")
test=pd.read_csv('/kaggle/input/titanic/test.csv')
train.head(10 ) | Titanic - Machine Learning from Disaster |
11,401,977 | df_out = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
soln = pd.DataFrame({'ForecastId': df_test.ForecastId, 'ConfirmedCases': y_pred, 'Fatalities': y_pred_fat})
df_out = pd.concat([df_out, soln], axis=0)
df_out.ForecastId = df_out.ForecastId.astype('int')
df_out.ConfirmedCases = df_out.... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,401,977 | test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
sub = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<data_type_conversions> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
11,401,977 | 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> | all_data = train.append(test ) | Titanic - Machine Learning from Disaster |
11,401,977 | 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 )<rename_columns> | all_data['Family_Size'] = all_data['Parch'] + all_data['SibSp']
train['Family_Size'] = all_data['Family_Size'][:891]
test['Family_Size'] = all_data['Family_Size'][891:] | Titanic - Machine Learning from Disaster |
11,401,977 | train['Province_State'].fillna('nan', inplace=True)
test['Province_State'].fillna('nan', inplace=True )<import_modules> | all_data['Last_Name'] = all_data['Name'].apply(lambda x: str.split(x, ",")[0])
all_data['Fare'].fillna(all_data['Fare'].mean() , inplace=True)
DEFAULT_SURVIVAL_VALUE = 0.5
all_data['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in all_data[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',... | Titanic - Machine Learning from Disaster |
11,401,977 | from sklearn.preprocessing import LabelEncoder<define_variables> | for _, grp_df in all_data.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):
all_data.loc[all_data['Pa... | Titanic - Machine Learning from Disaster |
11,401,977 | s =(train.dtypes == 'object')
object_cols = list(s[s].index )<categorify> | all_data['Ticket_Frequency'] = all_data.groupby('Ticket')['Ticket'].transform('count')
train['Ticket_Frequency'] = all_data['Ticket_Frequency'][:891]
test['Ticket_Frequency'] = all_data['Ticket_Frequency'][891:] | Titanic - Machine Learning from Disaster |
11,401,977 | label_encoder1 = LabelEncoder()
label_encoder2 = LabelEncoder()
train['Province_State'] = label_encoder1.fit_transform(train['Province_State'])
test['Province_State'] = label_encoder1.transform(test['Province_State'])
train['Country_Region'] = label_encoder2.fit_transform(train['Country_Region'])
test['Country_Regio... | all_data["Fare"] = all_data["Fare"].fillna(test["Fare"].median())
all_data["Fare_per_one"]=all_data['Fare']/all_data['Ticket_Frequency']
all_data['FareBin'] = pd.qcut(all_data['Fare_per_one'], 16)
label = LabelEncoder()
all_data['FareBin_Code'] = label.fit_transform(all_data['FareBin'])
train['FareBin_Code'] = all_d... | Titanic - Machine Learning from Disaster |
11,401,977 | from xgboost import XGBRegressor
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.metrics import mean_squared_log_error<prepare_x_and_y> | all_data['AgeBin'] = pd.qcut(all_data['Age'], 6)
label = LabelEncoder()
all_data['AgeBin_Code'] = label.fit_transform(all_data['AgeBin'])
train['AgeBin_Code'] = all_data['AgeBin_Code'][:891]
test['AgeBin_Code'] = all_data['AgeBin_Code'][891:]
train.drop(['Age'], 1, inplace=True)
test.drop(['Age'], 1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,401,977 | X_train = train[['Province_State','Country_Region','Date']]
X_train_with_confirmed = train[['Province_State','Country_Region','Date','ConfirmedCases']]
y_train_full = train[['ConfirmedCases', 'Fatalities']]
y_train_confirmed = train['ConfirmedCases']
y_train_fatal = train['Fatalities']<create_dataframe> | train['Sex'].replace(['male','female'],[0,1],inplace=True)
test['Sex'].replace(['male','female'],[0,1],inplace=True)
train.drop(['Name', 'PassengerId', 'SibSp', 'Parch', 'Ticket', 'Cabin',
'Embarked'], axis = 1, inplace = True)
test.drop(['Name','PassengerId', 'SibSp', 'Parch', 'Ticket', 'Cabin',
'Embarked'], axis =... | Titanic - Machine Learning from Disaster |
11,401,977 | sub1 = pd.DataFrame()
sub1['ForecastID'] = test['ForecastId']<drop_column> | y = train['Survived']
train_df = train.drop('Survived', 1)
test_df = test.copy() | Titanic - Machine Learning from Disaster |
11,401,977 | del test['ForecastId']<split> | my_train, my_test, my_y, my_res = train_test_split(train_df, y, test_size=0.1, random_state=42 ) | Titanic - Machine Learning from Disaster |
11,401,977 |
<choose_model_class> | model_try = RandomForestClassifier(n_estimators=300, max_depth=5, random_state=42)
model_try.fit(my_train, my_y)
preds = model_try.predict(my_test)
print(accuracy_score(my_res, preds)) | Titanic - Machine Learning from Disaster |
11,401,977 | xgb = XGBRegressor(
n_estimators = 500,
max_depth = 20,
learning_rate = 0.1,
)<train_model> | test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,401,977 | <predict_on_test><EOS> | model = RandomForestClassifier(n_estimators=500, max_depth=5, random_state=42)
model.fit(train_df, y)
predictions = model.predict(test_df)
output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print(predictions ) | Titanic - Machine Learning from Disaster |
10,116,525 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | import numpy as np
import pandas as pd
| Titanic - Machine Learning from Disaster |
10,116,525 | test_y_conf = pd.DataFrame(test_y_conf )<rename_columns> | sns.set(style='white')
%matplotlib inline
SEED=101 | Titanic - Machine Learning from Disaster |
10,116,525 | test_y_conf.rename(columns={0: 'ConfirmedCases'}, inplace=True )<concatenate> | def concat_df(train_data, test_data):
return pd.concat([train_data, test_data], sort=True ).reset_index(drop=True)
def divide_df(all_data):
return all_data.loc[:890], all_data.loc[891:].drop(['Survived'], axis=1)
def display_missing(df):
print(df.name)
print('-'*77)
for col in df.columns:
print('the number of missi... | Titanic - Machine Learning from Disaster |
10,116,525 | sub1 = pd.concat([sub1, test_y_conf], axis=1 )<concatenate> | df_train = pd.read_csv('/kaggle/input/titanic/train.csv')
df_test = pd.read_csv('/kaggle/input/titanic/test.csv')
df_all = concat_df(df_train, df_test)
df_train.name = 'Training Set'
df_test.name = 'Testing Set'
df_all.name = 'All Set'
dfs = [df_train, df_test]
drop_list = []
passengerId = df_test['PassengerId']
pri... | Titanic - Machine Learning from Disaster |
10,116,525 | test = pd.concat([test, test_y_conf], axis=1 )<split> | for df in dfs:
display_missing(df ) | Titanic - Machine Learning from Disaster |
10,116,525 |
<choose_model_class> | age_median_by_pclass_and_sex = df_all.groupby(['Sex','Pclass'] ).median() ['Age']
for i in df_all['Pclass'].unique() :
for j in df_all['Sex'].unique() :
print('The median age of class{0} and {1} is: {2}'.format(i,j,age_median_by_pclass_and_sex[j][i]))
df_all['Age'] = df_all.groupby(['Sex','Pclass'])['Age'].apply(lambda... | Titanic - Machine Learning from Disaster |
10,116,525 | xgb1 = XGBRegressor(
n_estimators = 500,
max_depth = 20,
learning_rate = 0.1,
)<train_model> | df_all['Embarked'] = df_all['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
10,116,525 | xgb1.fit(X_train_with_confirmed, y_train_fatal )<predict_on_test> | df_all.loc[df_all['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
10,116,525 | test_y_fatal = xgb1.predict(test)
<feature_engineering> | med = df_all.groupby(['Pclass','Parch','SibSp'])['Fare'].median() [3][0][0]
df_all['Fare'] = df_all['Fare'].fillna(med ) | Titanic - Machine Learning from Disaster |
10,116,525 | test_y_fatal = pd.DataFrame(test_y_fatal)
test_y_fatal.rename(columns={0: 'Fatalities'}, inplace=True)
test_y_fatal[test_y_fatal < 0] = 0<concatenate> | df_all['Deck'] = df_all['Cabin'].apply(lambda x: x[0] if pd.notnull(x)else 'M')
df_all.groupby('Deck')['Survived'].mean() | Titanic - Machine Learning from Disaster |
10,116,525 | sub1 = pd.concat([sub1, test_y_fatal], axis=1 )<save_to_csv> | df_all_decks = df_all.groupby(['Deck','Pclass'] ).count().drop(columns=['Survived',
'Sex','SibSp','Age','Parch','Fare','Embarked', 'Cabin', 'PassengerId', 'Ticket'] ).rename(columns={'Name':'Count'} ).transpose()
df_all_decks | Titanic - Machine Learning from Disaster |
10,116,525 | sub1.to_csv("submission.csv" , index = False )<train_on_grid> | def get_pclass_dist(df):
deck_counts = {'A': {}, 'B': {}, 'C': {}, 'D': {}, 'E': {}, 'F': {}, 'G': {}, 'M': {}, 'T': {}}
decks = df.columns.levels[0]
for deck in decks:
for pclass in range(1, 4):
try:
count = df[deck][pclass][0]
deck_counts[deck][pclass] = count
except KeyError:
deck_counts[deck][pclass] = 0
df_decks =... | Titanic - Machine Learning from Disaster |
10,116,525 |
<split> | df_all['Deck'] = df_all['Deck'].replace('T','A')
df_all['Deck'] = df_all['Deck'].replace(['A','B','C'],'ABC')
df_all['Deck'] = df_all['Deck'].replace(['D','E'],'DE')
df_all['Deck'] = df_all['Deck'].replace(['F','G'],'FG')
df_all['Deck'].value_counts() | Titanic - Machine Learning from Disaster |
10,116,525 |
<compute_test_metric> | display_missing(df_all)
drop_list.append('Cabin')
drop_list.append('PassengerId' ) | Titanic - Machine Learning from Disaster |
10,116,525 | def rmsle(y, y_pred):
assert len(y)== len(y_pred)
terms_to_sum = [(math.log(y_pred[i] + 1)- math.log(y[i] + 1)) ** 2.0 for i,pred in enumerate(y_pred)]
return(sum(terms_to_sum)*(1.0/len(y)))** 0.5
def fix_target(frame, key, target, new_target_name="target"):
corrections = 0
group_keys = frame[ key].values.tolist()
tar... | df_all.drop(drop_list,axis=1,inplace=True)
df_train, df_test = divide_df(df_all)
dfs = [df_train,df_test] | Titanic - Machine Learning from Disaster |
10,116,525 | def get_lags(rate_array, current_index, size=20):
lag_confirmed_rate=[-1 for k in range(size)]
for j in range(0, size):
if current_index-j>=0:
lag_confirmed_rate[j]=rate_array[current_index-j]
else :
break
return lag_confirmed_rate
def days_ago_thresold_hit(full_array, indx, thresold):
days_ago_confirmed_count_10=-1
if... | drop_list=[] | Titanic - Machine Learning from Disaster |
10,116,525 | train_frame=[]
size=10
windows=[3]
days_back_confimed=[1,5,10,20,50,100,250,500,1000]
days_back_fatalities=[1,2,5,10,20,50]
size_group=10
windows_group=[3]
days_back_confimed_group=[1,10,100]
for unique_k in tqdm(unique_keys):
mini_frame=feature_engineering_for_single_key(train, key, unique_k, horizon=horizon, size=siz... | def corr_sort(df_train):
df_train_corr = df_train.corr().abs().unstack().sort_values(ascending=False ).reset_index()
df_train_corr.rename(columns={'level_0':'feature1','level_1':'feature2',0:'correlation'},inplace=True)
df_train_corr = df_train_corr.iloc[::2]
return df_train_corr[(df_train_corr['correlation']>0.1)&(df... | Titanic - Machine Learning from Disaster |
10,116,525 | def bagged_set_train(X_ts,y_cs,wts, seed, estimators,xtest, xt=None,yt=None, output_name=None):
baggedpred=np.array([ 0.0 for d in range(0, xtest.shape[0])])
for n in range(0, estimators):
params = {'objective': 'rmse',
'metric': 'rmse',
'boosting': 'gbdt',
'learning_rate': 0.005,
'drop_rate':0.01,
'skip_drop':0.6,
'u... | corr_train = corr_sort(df_train)
corr_test = corr_sort(df_test)
print(corr_train)
print(corr_test)
| Titanic - Machine Learning from Disaster |
10,116,525 | def predict(xtest,input_name=None):
baggedpred=np.array([ 0.0 for d in range(0, xtest.shape[0])])
model= joblib.load(input_name)
preds=model.predict(xtest)
baggedpred+=preds
return baggedpred<define_variables> | display_missing(df_all ) | Titanic - Machine Learning from Disaster |
10,116,525 | names=[]
for day in days_back_confimed:
names+=["days_ago_confirmed_count_" + str(day)]
for window in windows:
names+=["ma" + str(window)+ "_rate_confirmed" + str(k+1)for k in range(size)]
for day in days_back_fatalities:
names+=["days_ago_fatalitiescount_" + str(day)]
for window in windows:
names+=["ma" + str(window)+... | drop_list.append('Fare')
drop_list.append('Farec' ) | Titanic - Machine Learning from Disaster |
10,116,525 |
<categorify> | drop_list.append('Age')
drop_list.append('Agec' ) | Titanic - Machine Learning from Disaster |
10,116,525 | def decay_4_first_10_then_1_f(array):
arr=[1.0 for k in range(len(array)) ]
for j in range(len(array)) :
if j<10:
arr[j]=1.+(max(1,array[j])-1.) /4.
else :
arr[j]=1.
return arr
def decay_16_first_10_then_1_f(array):
arr=[1.0 for k in range(len(array)) ]
for j in range(len(array)) :
if j<10:
arr[j]=1.+(max(1,array[j... | family_map = {1: 'Alone', 2: 'Small', 3: 'Small', 4: 'Small', 5: 'Medium', 6: 'Medium', 7: 'Large', 8: 'Large', 11: 'Large'}
df_all['Family'] = df_all['FamilySize'].map(family_map)
df_all['Family'] | Titanic - Machine Learning from Disaster |
10,116,525 | key_to_confirmed_rate={}
key_to_fatality_rate={}
key_to_confirmed={}
key_to_fatality={}
print(len(features_cv), len(name_cv),len(standard_confirmed_cv),len(standard_fatalities_cv))
print(preds_confirmed_cv.shape,preds_confirmed_standard_cv.shape,preds_fatalities_cv.shape,preds_fatalities_standard_cv.shape)
for j in ra... | drop_list.append('FamilySize')
drop_list.append('Parch')
drop_list.append('SibSp' ) | Titanic - Machine Learning from Disaster |
10,116,525 | train_new=train[["Date","ConfirmedCases","Fatalities","key","rate_ConfirmedCases","rate_Fatalities"]]
test_new=pd.merge(test,train_new, how="left", left_on=["key","Date"], right_on=["key","Date"] ).reset_index(drop=True)
test_new<categorify> | def title_replace(row):
if row.Title == 'Mlle':
return 'Miss'
elif row.Title == 'Ms':
return 'Miss'
elif row.Title == 'Mme':
return 'Mrs'
elif row.Title in ['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona']:
return 'Rare'
else:
return row.Title
| Titanic - Machine Learning from Disaster |
10,116,525 | def fillin_columns(frame,key_column, original_name, training_horizon, test_horizon, unique_values, key_to_values):
keys=frame[key_column].values
original_values=frame[original_name].values.tolist()
print(len(keys), len(original_values), training_horizon ,test_horizon,len(key_to_values))
for j in range(unique_values):
c... | df_all['Title'] = df_all['Name'].str.split(',',expand=True)[1].str.split('.',expand=True)[0].str.strip()
df_all['Title'] = df_all['Title'].replace(['Miss', 'Mrs','Ms', 'Mlle', 'Lady', 'Mme', 'the Countess', 'Dona'], 'Miss/Mrs/Ms')
df_all['Title'] = df_all['Title'].replace(['Dr', 'Col', 'Major', 'Jonkheer', 'Capt', 'Si... | Titanic - Machine Learning from Disaster |
10,116,525 |
<train_model> | df_all['Is_Married'] = 0
df_all['Is_Married'].loc[df_all['Title'] == 'Mrs'] = 1 | Titanic - Machine Learning from Disaster |
10,116,525 | def bagged_set_trainc(X_ts,y_cs,wts, seed, estimators,xtest, xt=None,yt=None, output_name=None):
baggedpred=np.array([ 0.0 for d in range(0, xtest.shape[0])])
for n in range(0, estimators):
params = {'objective': 'rmse',
'metric': 'rmse',
'boosting': 'gbdt',
'learning_rate': 0.005,
'drop_rate':0.01,
'skip_drop':0.6,
'... | df_all['Title'].value_counts() | Titanic - Machine Learning from Disaster |
10,116,525 | names=[]
for day in days_back_confimed:
names+=["days_ago_confirmed_count_" + str(day)]
for window in windows:
names+=["ma" + str(window)+ "_rate_confirmed" + str(k+1)for k in range(size)]
names+=["ma" + str(window)+ "_count_confirmed" + str(k+1)for k in range(size)]
for day in days_back_fatalities:
names+=["days_ago_f... | df_all.groupby('Title')['Survived'].mean() | Titanic - Machine Learning from Disaster |
10,116,525 |
<categorify> | df_all['Surname'] = df_all['Name'].str.split(',',expand=True)[0].str.strip()
df_train, df_test = divide_df(df_all)
common_surname = [each for each in df_test['Surname'].unique() if each in df_train['Surname'].unique() ]
df_train.groupby('Surname')['Survived'].median()
train_survived_dict_surname = df_train[df_train['F... | Titanic - Machine Learning from Disaster |
10,116,525 | def decay_4_first_10_then_1_f(array):
arr=[k for k in array]
for j in range(len(array)) :
if j<10:
arr[j]*=1./4.
else :
arr[j]=0
return arr
def decay_16_first_10_then_1_f(array):
arr=[k for k in array]
for j in range(len(array)) :
if j<10:
arr[j]*=1./16.
else :
arr[j]=0
return arr
def decay_2_f(array):
arr=[k for k... | common_ticket = [each for each in df_test['Ticket'].unique() if each in df_train['Ticket'].unique() ]
train_survived_dict_ticket = df_train[df_train['Ticket_Frequency']>1].groupby('Ticket')['Survived'].median().to_dict()
new_dict_ticket = {}
for key in common_ticket:
if key in train_survived_dict_ticket.keys() :
new_di... | Titanic - Machine Learning from Disaster |
10,116,525 | key_to_confirmed_rate={}
key_to_fatality_rate={}
key_to_confirmed={}
key_to_fatality={}
print(len(features_cv), len(name_cv),len(standard_confirmed_cv),len(standard_fatalities_cv))
print(preds_confirmed_cv.shape,preds_confirmed_standard_cv.shape,preds_fatalities_cv.shape,preds_fatalities_standard_cv.shape)
for j in ra... | for df in [df_train, df_test]:
df['Survival_Rate'] =(df['tic_rate'] + df['Sur_rate'])/ 2
df['Survival_Rate_NA'] =(df['tic_count'] + df['Sur_count'])/ 2 | Titanic - Machine Learning from Disaster |
10,116,525 | train_new=train[["Date","ConfirmedCases","Fatalities","key","rate_ConfirmedCases","rate_Fatalities"]]
test_new_count=pd.merge(test,train_new, how="left", left_on=["key","Date"], right_on=["key","Date"] ).reset_index(drop=True)
test_new_count<categorify> | df_all = concat_df(df_train,df_test ) | Titanic - Machine Learning from Disaster |
10,116,525 | def fillin_columns(frame,key_column, original_name, training_horizon, test_horizon, unique_values, key_to_values):
keys=frame[key_column].values
original_values=frame[original_name].values.tolist()
print(len(keys), len(original_values), training_horizon ,test_horizon,len(key_to_values))
for j in range(unique_values):
c... | drop_list.append('tic_rate')
drop_list.append('Sur_rate')
drop_list.append('tic_count')
drop_list.append('Sur_count' ) | Titanic - Machine Learning from Disaster |
10,116,525 | submission=test_new2[["ForecastId","ConfirmedCases","Fatalities"]]
submission.to_csv("submission.csv", index=False)
<compute_test_metric> | df_all.drop(drop_list,inplace=True, axis=1)
drop_list = [] | Titanic - Machine Learning from Disaster |
10,116,525 | %matplotlib inline
def sigmoid_sqrt_func(x, a, b, c, d, e):
return c + d /(1.0 + np.exp(-a*x+b)) + e*x**0.5
def sigmoid_linear_func(x, a, b, c, d, e):
return c + d /(1.0 + np.exp(-a*x+b)) + e*0.1*x
def sigmoid_quad_func(x, a, b, c, d, e, f):
return c + d /(1.0 + np.exp(-a*x+b)) + e*0.1*x + f*0.001*x*x
def sigmoid_func(... | drop_list.append('Name')
df_all.drop(drop_list,inplace=True, axis=1)
drop_list = []
| Titanic - Machine Learning from Disaster |
10,116,525 | 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')
pred_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv')
train_data = train_data.fillna(value='NULL')
test_data =... | drop_list.append('Ticket')
drop_list.append('Surname')
df_all.drop(drop_list,inplace=True, axis=1)
drop_list = [] | Titanic - Machine Learning from Disaster |
10,116,525 | train_date_list = train_data.iloc[:, 3].unique()
print(len(train_date_list))
print(train_date_list)
test_date_list = test_data.iloc[:, 3].unique()
print(len(test_date_list))
print(test_date_list)
len(train_data.groupby(['Province_State', 'Country_Region']))
len(test_data.groupby(['Province_State', 'Country_Region']))... | def non_numeric_features(df):
alist = []
for col in df.columns:
if 'float' not in str(df[col].dtype)and 'int' not in str(df[col].dtype):
alist.append(col)
return alist
non_num_list = non_numeric_features(df_all ) | Titanic - Machine Learning from Disaster |
10,116,525 | start_date = '01/22/2020'
start_pred = 81
start_submit = 71
len_pred = 30
test_date_list = test_data.iloc[:, 3].unique()
test_data_filled = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
test_data_filled = test_data_filled.fillna(value='NULL')
test_data_filled['ConfirmedCases'] = pred_data['C... | df_train, df_test = divide_df(df_all)
dfs =[df_train,df_test]
for df in dfs:
for feature in non_num_list:
df[feature] = LabelEncoder().fit_transform(df[feature] ) | Titanic - Machine Learning from Disaster |
10,116,525 | submission = test_data_filled.loc[:,['ForecastId', 'ConfirmedCases', 'Fatalities']]<save_to_csv> | cat_features = ['Embarked', 'Sex', 'Family', 'Title','Pclass','Deck']
for i,df in enumerate(dfs):
for feature in cat_features:
df = pd.concat([df,pd.get_dummies(df[feature], prefix=feature)],axis=1 ).drop([feature],axis=1)
dfs[i] = df | Titanic - Machine Learning from Disaster |
10,116,525 | submission.to_csv("submission.csv", index=False)
submission.head(500 )<set_options> | from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import D... | Titanic - Machine Learning from Disaster |
10,116,525 | py.init_notebook_mode(connected=True)
pio.templates.default = "plotly_dark"
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | df_train = dfs[0]
df_train.name = 'training'
df_test = dfs[1]
df_test.name = 'testing'
display_missing(df_train)
display_missing(df_test ) | Titanic - Machine Learning from Disaster |
10,116,525 | 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_df = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv')
train_df = train_df.drop(['Id'],axis=1)
train_df.rename(... | X_train = StandardScaler().fit_transform(df_train.drop('Survived',axis=1))
y_train = df_train['Survived']
X_test = StandardScaler().fit_transform(df_test)
print('X_train shape: {}'.format(X_train.shape))
print('y_train shape: {}'.format(y_train.shape))
print('X_test shape: {}'.format(X_test.shape)) | Titanic - Machine Learning from Disaster |
10,116,525 | country_province_df = train_df[train_df['Country']=='United States'].groupby(['Date', 'Province_State'])[['ConfirmedCases', 'Fatalities']].sum().reset_index()
top_province_df = country_province_df.query('(Date == @target_date)' ).sort_values('ConfirmedCases', ascending=False)
top30_provinces = top_province_df.sort_val... | single_best_model = RandomForestClassifier(criterion='gini',
n_estimators=1100,
max_depth=5,
min_samples_split=4,
min_samples_leaf=5,
max_features='auto',
oob_score=True,
random_state=SEED,
n_jobs=-1,
verbose=1)
| Titanic - Machine Learning from Disaster |
10,116,525 | def get_time_series(df,country_name,insert=False):
if df[df['Country'] == country_name]['Province_State'].nunique() > 1:
country_table = df[df['Country'] == country_name]
if insert:
country_df = pd.DataFrame(pd.pivot_table(country_table, values = ['ConfirmedCases','Fatalities','Days'],
index='Date', aggfunc=sum ).to_re... | single_best_model.fit(X_train, y_train)
predictions1 = single_best_model.predict(X_test ) | Titanic - Machine Learning from Disaster |
10,116,525 | print(tf.__version__ )<feature_engineering> | submission_df = pd.DataFrame(columns=['PassengerId', 'Survived'])
submission_df['PassengerId'] = passengerId
submission_df['Survived'] = predictions1.astype(int)
submission_df.to_csv('my_submissions.csv', header=True, index=False)
submission_df.head(10 ) | Titanic - Machine Learning from Disaster |
10,116,525 | <prepare_x_and_y><EOS> | com = pd.DataFrame({'pre1':predictions1, 'pre2': predictions2} ) | Titanic - Machine Learning from Disaster |
9,075,252 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<groupby> | %matplotlib inline
def transform_dataset(ds):
transformed_dataset = ds.copy()
transformed_dataset['Age'].fillna(transformed_dataset['Age'].median() , inplace=True)
transformed_dataset['Fare'].fillna(transformed_dataset['Fare'].median() , inplace=True)
transformed_dataset['Sex'] = pd.factorize(transformed_dataset['Sex... | Titanic - Machine Learning from Disaster |
9,075,252 | test_country_df = test_df.groupby(['Date', 'Country'])[['ConfirmedCases', 'Fatalities']].sum().reset_index()
display(test_country_df[test_country_df['Country']=='Australia'][:20])
for country in [x for x in province_countries if x in top30_countries]:
present_country_df = test_country_df[test_country_df['Country']==co... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
passenger_id = test['PassengerId'] | Titanic - Machine Learning from Disaster |
9,075,252 | for country in no_province_countries:
current_considered_country_df = no_province_country_dfs[country][['ConfirmedCases','Fatalities','Days']].reset_index()
print(country)
for i in range(train_end_day-test_start_day+1):
test_df.loc[(test_df['Country']==country)&(test_df['Days']==i+test_start_day), 'ConfirmedCases'] = ... | transformed_train = transform_dataset(train)
transformed_test = transform_dataset(test ) | Titanic - Machine Learning from Disaster |
9,075,252 | test_df_copy = test_df
submission_df_copy = submission_df
submit = pd.DataFrame()
submit['ForecastId'] = test_df['ForecastId']
submit['ConfirmedCases'] = test_df['ConfirmedCases']
submit['Fatalities'] = test_df['Fatalities']
submit = submit.reset_index()
submit = submit.drop(['Date'], axis=1)
display(submit.tail())
s... | X = transformed_train.drop(['Survived'], axis=1)
Y = transformed_train['Survived'] | Titanic - Machine Learning from Disaster |
9,075,252 | pd.options.display.max_rows = 500
pd.options.display.max_columns = 500
%matplotlib inline
<load_from_csv> | X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size = 0.2, random_state = 21 ) | Titanic - Machine Learning from Disaster |
9,075,252 | 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... | param_grid =[ {'n_estimators' : [4,5,10, 15, 20, 25, 30, 35, 40], 'max_depth' : [5,10,15, 20]},]
rf = ensemble.GradientBoostingClassifier(random_state=21)
model = GridSearchCV(rf,param_grid, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,075,252 | 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... | model.fit(X_train,Y_train)
print('train score = ', model.score(X_train,Y_train), '
test score = ', model.score(X_test,Y_test), '
', model.best_params_ ) | Titanic - Machine Learning from Disaster |
9,075,252 | 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_predict = model.predict(transformed_test)
Y_p = pd.DataFrame(Y_predict, columns=['Survived'])
Y_p | Titanic - Machine Learning from Disaster |
9,075,252 | sub.to_csv('submission.csv', index=None )<merge> | res = pd.concat([passenger_id, Y_p], axis=1)
res | Titanic - Machine Learning from Disaster |
9,075,252 | <set_options><EOS> | res.to_csv('res.csv', index=None ) | Titanic - Machine Learning from Disaster |
9,074,840 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | %matplotlib inline
def transform_dataset(ds):
transformed_dataset = ds.copy()
transformed_dataset['Age'].fillna(transformed_dataset['Age'].median() , inplace=True)
transformed_dataset['Fare'].fillna(transformed_dataset['Fare'].median() , inplace=True)
transformed_dataset['Sex'] = pd.factorize(transformed_dataset['Sex... | Titanic - Machine Learning from Disaster |
9,074,840 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
train = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
test = pd.read_csv('.. /input/covid19-global-forecasting-week-4/test.csv')
Y1=train['ConfirmedCases']
Y2=train['Fataliti... | dataset = pd.read_csv('.. /input/titanic/train.csv')
dataset.info() | 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.