kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,110,105 | pred_val_y, pred_test_y = RCNN_train_pred(model_RCNN(embedding_matrix, hidden_dim_1=128, hidden_dim_2=64,max_features=max_features+1), epochs = 5)
outputs.append([pred_val_y, pred_test_y, 'RCNN'])
results = threshold_search(val_y, pred_val_y)
print(results)
print(confusion_matrix(val_y,pred_val_y>results['threshold... | X_tr_pclass =enc.fit_transform(np.array(X_train['Pclass'] ).reshape(-1,1))
X_cv_pclass =enc.transform(np.array(X_cv['Pclass'] ).reshape(-1,1))
X_te_pclass =enc.transform(np.array(test['Pclass'] ).reshape(-1,1)) | Titanic - Machine Learning from Disaster |
14,110,105 | clr = CyclicLR(base_lr=0.001, max_lr=0.003,step_size=300., mode='exp_range', gamma=0.99994 )<compute_train_metric> | X_tr_sex =vectorizer.fit_transform(X_train['Sex'])
X_cv_sex =vectorizer.transform(X_cv['Sex'])
X_te_sex =vectorizer.transform(test['Sex'] ) | Titanic - Machine Learning from Disaster |
14,110,105 | pred_val_y, pred_test_y = train_pred(model_lstm_atten(embedding_matrix), epochs = 4)
outputs.append([pred_val_y, pred_test_y, 'LSTM w/ max'])
results = threshold_search(val_y, pred_val_y)
print(results)
print(confusion_matrix(val_y,pred_val_y>results['threshold']))<choose_model_class> | X_tr_cabin =vectorizer.fit_transform(X_train['Cabin'])
X_cv_cabin =vectorizer.transform(X_cv['Cabin'])
X_te_cabin =vectorizer.transform(test['Cabin'] ) | Titanic - Machine Learning from Disaster |
14,110,105 | clr = CyclicLR(base_lr=0.001, max_lr=0.003,step_size=300., mode='exp_range', gamma=0.99994 )<compute_train_metric> | X_tr_tkt =vectorizer.fit_transform(X_train['Ticket'])
X_cv_tkt =vectorizer.transform(X_cv['Ticket'])
X_te_tkt =vectorizer.transform(test['Ticket'] ) | Titanic - Machine Learning from Disaster |
14,110,105 | pred_val_y, pred_test_y = train_pred(model_gru_conv_3(embedding_matrix), epochs = 4)
outputs.append([pred_val_y, pred_test_y, 'LSTM conv 3'])
results = threshold_search(val_y, pred_val_y)
print(results)
print(confusion_matrix(val_y,pred_val_y>results['threshold']))<choose_model_class> | X_tr_fmix =enc.fit_transform(np.array(X_train['feature_mix'] ).reshape(-1,1))
X_cv_fmix =enc.transform(np.array(X_cv['feature_mix'] ).reshape(-1,1))
X_te_fmix =enc.transform(np.array(test['feature_mix'] ).reshape(-1,1)) | Titanic - Machine Learning from Disaster |
14,110,105 | clr = CyclicLR(base_lr=0.001, max_lr=0.003,step_size=300., mode='exp_range', gamma=0.99994 )<compute_train_metric> |
X_tr = hstack(( X_tr_age,X_tr_fare,X_tr_sex,X_tr_pclass,X_tr_emb)).tocsr()
X_cv = hstack(( X_cv_age,X_cv_fare,X_cv_sex,X_cv_pclass,X_cv_emb)).tocsr()
X_te = hstack(( X_te_age,X_te_fare,X_te_sex,X_te_pclass,X_te_emb)).tocsr()
print(X_tr.shape)
print(X_te.shape)
print(X_cv.shape ) | Titanic - Machine Learning from Disaster |
14,110,105 | pred_val_y, pred_test_y = train_pred(model_lstm_max(embedding_matrix), epochs = 4)
outputs.append([pred_val_y, pred_test_y, 'LSTM w/ atten'])
results = threshold_search(val_y, pred_val_y)
print(results)
print(confusion_matrix(val_y,pred_val_y>results['threshold']))<compute_train_metric> | alpha = [10 ** x for x in range(-5, 1)]
cv_log_error_array=[]
for i in alpha:
clf = SGDClassifier(alpha=i,class_weight="balanced", penalty='l2', loss='log', random_state=42)
clf.fit(X_tr, y_train)
sig_clf = CalibratedClassifierCV(clf, method="sigmoid")
sig_clf.fit(X_tr, y_train)
predict_y = sig_clf.predict_proba(X_... | Titanic - Machine Learning from Disaster |
14,110,105 | coefs = [0.35,0.25,0.2,0.2]
pred_val_y = np.sum([outputs[i][0]*coefs[i] for i in range(len(outputs)) ], axis = 0)
results = threshold_search(val_y, pred_val_y)
print(results)
print(confusion_matrix(val_y,pred_val_y>results['threshold']))<save_to_csv> | pred=sig_clf.predict(X_te)
df=pd.DataFrame(zip(PassengerId,pred),columns=['PassengerId',"Survived"])
df
df.to_csv('/kaggle/working/output.csv',index=False ) | Titanic - Machine Learning from Disaster |
14,110,105 | <import_modules><EOS> | d=pd.read_csv('/kaggle/working/output.csv')
d | Titanic - Machine Learning from Disaster |
14,096,495 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | pd.options.display.max_rows=200
pd.set_option('mode.chained_assignment', None)
simplefilter("ignore", category=ConvergenceWarning)
simplefilter("ignore", category=RuntimeWarning)
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | Titanic - Machine Learning from Disaster |
14,096,495 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print('Train data dimension: ', train_df.shape)
display(train_df.head())
print('Test data dimension: ', test_df.shape)
display(test_df.head() )<set_options> | train = pd.read_csv('/kaggle/input/titanic/train.csv', index_col='PassengerId')
test = pd.read_csv('/kaggle/input/titanic/test.csv', index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
14,096,495 | def seed_torch(seed=1234):
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True<compute_test_metric> | y_train = train.Survived.copy()
train = train.drop('Survived', axis=1)
X_test = test | Titanic - Machine Learning from Disaster |
14,096,495 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
search_result = {'threshold': best_threshold, 'f1': best_score... | def name_labeling(df):
for i in ['Mr.', 'Mrs.', 'Miss', 'Master', 'Army', 'Revered/Important', 'rare', 'Doctor']:
if i == 'Army':
df.Name[df.Name.str.contains(pat='(Major.|Col.|Capt.) ', regex=True)] = 'Army'
elif i == 'Revered/Important':
df.Name[df.Name.str.contains(pat='(Rev.|Countess.|Jonkheer.|Sir.|Lady.) ', regex... | Titanic - Machine Learning from Disaster |
14,096,495 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<define_variables> | def ticket_labeling(df):
for label, pattern in [('ca', 'C[.]?A[.]?'),('soton', 'SOTON'),('ston', 'STON'),('wc', 'W[.]?[/]?C'),
('sc', 'S[.]?C[.]?'),('a', 'A[.]?'),('soc', 'S[.]?O[.]?[/]?C'),('pp', 'PP'),
('fc', '(F.C.|F.C.C.) '),('rest_char', '[A-Z]'),('small_serial_number', '^\d{3,5}$'),
('large_serial_number', '^\... | Titanic - Machine Learning from Disaster |
14,096,495 | embed_size = 300
max_features = 75000
maxlen = 50<define_variables> | def cabin_labeling(df):
for i in ['A', 'B', 'C', 'D', 'E', 'F', 'G']:
df.Cabin[df.Cabin.str.contains(i, na=False)] = i
df.Cabin.fillna('missing', inplace=True)
return df | Titanic - Machine Learning from Disaster |
14,096,495 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | temp = cabin_labeling(train.copy() ) | Titanic - Machine Learning from Disaster |
14,096,495 | train_df["question_text"] = train_df["question_text"].str.lower()
test_df["question_text"] = test_df["question_text"].str.lower()
train_df["question_text"] = train_df["question_text"].apply(lambda x: clean_text(x))
test_df["question_text"] = test_df["question_text"].apply(lambda x: clean_text(x))
x_train = train_df["qu... | temp = temp.groupby(['Pclass', 'Cabin'])[['Name']].count().rename(columns={'Name':'Passengers'} ) | Titanic - Machine Learning from Disaster |
14,096,495 | def load_glove(word_index):
EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')[:300]
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,e... | temp = temp.reset_index()
temp_no_missing_value = temp[temp.Cabin != 'missing']
temp_missing_value = temp[temp.Cabin == 'missing'] | Titanic - Machine Learning from Disaster |
14,096,495 | glove_embeddings = load_glove(tokenizer.word_index)
paragram_embeddings = load_para(tokenizer.word_index)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings], axis=0)
np.shape(embedding_matrix )<split> | def combined_labeling(df):
return cabin_labeling(ticket_labeling(name_labeling(df)) ) | Titanic - Machine Learning from Disaster |
14,096,495 | splits = list(StratifiedKFold(n_splits=4, shuffle=True, random_state=10 ).split(x_train, y_train))<normalization> | X_train = combined_labeling(train.copy())
X_test = combined_labeling(test.copy() ) | Titanic - Machine Learning from Disaster |
14,096,495 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | def proportions(df):
df = df.groupby(['Pclass', 'Cabin'])['Name'].count().reset_index().rename(columns={'Name':'Passengers'})
total_passengers_in_cabins = df.Passengers[df.Cabin != 'missing'].sum()
cabin_proportions = df['Passengers'][df.Cabin != 'missing'] / total_passengers_in_cabins
return cabin_proportions
def n... | Titanic - Machine Learning from Disaster |
14,096,495 | 128*4<define_variables> | X_train_imputed = imputer(X_train.copy())
X_test_imputed = imputer(X_test.copy() ) | Titanic - Machine Learning from Disaster |
14,096,495 | batch_size = 512
n_epochs = 5<choose_model_class> | class FeatureEngineering(BaseEstimator, TransformerMixin):
def __init__(self, drop_Cabin=False, drop_Name=False, Embarked_target=False, SibSp_Parch_simplify=True,
drop_Ticket=False, scaler='MinMaxScaler', smoothing=10, test=False):
self.drop_Cabin = drop_Cabin
self.drop_Name = drop_Name
self.drop_Ticket = drop_Ticket
s... | Titanic - Machine Learning from Disaster |
14,096,495 | class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self ).__init__()
hidden_size = 128
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32))
self.embedding.weight.requires_grad = False
self.embedding_dropout = nn.... | def results(cv_results_, n):
df = pd.DataFrame(cv_results_)[['params', 'mean_test_score']].nlargest(n, columns='mean_test_score')
for i in range(len(df)) :
print(f'{df.iloc[i, 0]} : {df.iloc[i, 1]}' ) | Titanic - Machine Learning from Disaster |
14,096,495 | train_preds = np.zeros(( len(train_df)))
test_preds = np.zeros(( len(test_df)))
seed_torch()
x_test_cuda = torch.tensor(x_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False)
for i,(train_idx, valid_i... | param_grid = {'feature_engineering__drop_Cabin':[True, False],
'feature_engineering__drop_Ticket':[True, False],
'feature_engineering__drop_Name':[True, False],
'feature_engineering__Embarked_target':[True, False],
'feature_engineering__SibSp_Parch_simplify':[False],
'feature_engineering__scaler':['StandardScaler'],
'f... | Titanic - Machine Learning from Disaster |
14,096,495 | search_result = threshold_search(y_train, train_preds)
search_result<save_to_csv> | grid.fit(X_train_imputed.copy() , y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | submission = test_df[['qid']].copy()
submission['prediction'] = test_preds > search_result['threshold']
submission.to_csv('submission.csv', index=False )<feature_engineering> | fe = FeatureEngineering(drop_Cabin=True, drop_Name=False, drop_Ticket=False, Embarked_target=False, SibSp_Parch_simplify=False,
scaler='StandardScaler', smoothing=5 ) | Titanic - Machine Learning from Disaster |
14,096,495 | train=pd.read_json('.. /input/train.json')
test=pd.read_json('.. /input/test.json')
train['ingredients'] = [", ".join(ingredients)for ingredients in train['ingredients']]
test['ingredients']=[", ".join(ingredients)for ingredients in test['ingredients']]
def multiclass_logloss(actual, predicted, eps=1e-15):
if len(a... | X_train_fe = fe.fit_transform(X_train_imputed.copy() ) | Titanic - Machine Learning from Disaster |
14,096,495 | warnings.filterwarnings('ignore')
sub0 = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv')
train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv', parse_dates=['Date'])
test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv', parse_dates=['Da... | fe.test = True | Titanic - Machine Learning from Disaster |
14,096,495 | know = test[test.Date <= train.Date.max() ]
not_know = test[test.Date > train.Date.max() ]
know = know.merge(train, on=['Date','Country_Region','Province_State'], how='left')
know.head()<feature_engineering> | X_test_fe = fe.transform(X_test_imputed.copy() ) | Titanic - Machine Learning from Disaster |
14,096,495 | train['days'] =(train['Date'] - train.Date.min() ).dt.days
train['location'] = train['Country_Region'] + ' ' + train['Province_State'].fillna('')
train['location'] = train['location'].str.strip()
not_know['days'] =(not_know['Date'] - train.Date.min() ).dt.days
not_know['location'] = not_know['Country_Region'] + ' ' + ... | def parameter_plot(model, X, y, n_estimators=[100, 200, 300, 400, 600, 900, 1300, 1700, 2000, 2500], hyper_param=None, **kwargs):
param_name, param_vals = hyper_param
param_grid = {'n_estimators':n_estimators,
f'{param_name}':param_vals}
grid = GridSearchCV(model(**kwargs), param_grid,
cv=RepeatedStratifiedKFold(n_spli... | Titanic - Machine Learning from Disaster |
14,096,495 | def get_param(loc):
_ = train[train.location == loc]
_['diff'] = _.ConfirmedCases.diff()
_['pct'] = _.ConfirmedCases.pct_change()
initial_speed = _.loc[_.ConfirmedCases.diff().argmax() ,'pct']
initial_mid = _.loc[_.ConfirmedCases.diff().argmax() , 'days']
initial_max = _.ConfirmedCases.max() * 2.1
return initial_speed,... | def learning_curve_plotter(Model, X, y, params_1, params_2, step=50):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
plt.figure(figsize=(16, 7))
for i,(name, params)in enumerate([params_1, params_2]):
train_score = []
val_score = []
plt.subplot(1, 2, i+1)
for j in range(100,... | Titanic - Machine Learning from Disaster |
14,096,495 | loc_list = train.location.unique()
all_param = pd.DataFrame(index=loc_list, columns=['k','x_0','y_max'])
for loc in loc_list:
_ = train[train.location == loc]
nn = not_know[not_know.location == loc]
initial_max = _.ConfirmedCases.max() *2
x = _.days
y1 = _.ConfirmedCases
try:
popt, pcov = opt.curve_fit(log_curve, x, y... | param_grid_logreg = {'penalty':['elasticnet'],
'C':[0.03],
'l1_ratio':[0.0],
'solver':['saga']} | Titanic - Machine Learning from Disaster |
14,096,495 | all_param.loc['Finland', 'y_max']<merge> | grid_logreg = GridSearchCV(LogisticRegression() , param_grid_logreg,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,096,495 | latest = train[train.Date == train.Date.max() ]
latest['DeathRate'] = latest['Fatalities'] / latest['ConfirmedCases']
not_know2 = not_know.merge(latest[['location','DeathRate']], on='location')
not_know2['Fatalities'] = not_know2['ConfirmedCases'] * not_know2['DeathRate']*1.1<feature_engineering> | grid_logreg.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | not_know2['ConfirmedCases'] = not_know2['ConfirmedCases'].round()
not_know2['Fatalities'] = not_know2['Fatalities'].round()<save_to_csv> | param_grid_knn = {'n_neighbors':[20],
'weights':['uniform'],
'algorithm':['ball_tree']} | Titanic - Machine Learning from Disaster |
14,096,495 | sub1 = pd.concat([know[['ForecastId', 'ConfirmedCases','Fatalities']],
not_know2[['ForecastId', 'ConfirmedCases','Fatalities']]])
sub1=sub1.sort_values('ForecastId' ).reset_index(drop=True)
sub1.to_csv('submission.csv', index=False )<load_from_csv> | grid_knn = GridSearchCV(KNeighborsClassifier() , param_grid_knn,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,096,495 | PATH_WEEK4='/kaggle/input/covid19-global-forecasting-week-4'
df_train = pd.read_csv(f'{PATH_WEEK4}/train.csv')
df_test = pd.read_csv(f'{PATH_WEEK4}/test.csv' )<load_from_csv> | grid_knn.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | mitigation = pd.read_csv('/kaggle/input/mitigation-day/mitigations.csv')
mitigation.loc[mitigation['Name']=="United States",'Name']='US'
mitigation['start'] = pd.to_datetime(mitigation['start'], infer_datetime_format=True )<data_type_conversions> | param_grid_svc = {'C':[0.5],
'kernel':['rbf'],
'gamma':[0.1]} | Titanic - Machine Learning from Disaster |
14,096,495 | df_train.rename(columns={'Country_Region':'Country'}, inplace=True)
df_test.rename(columns={'Country_Region':'Country'}, inplace=True)
df_train.rename(columns={'Province_State':'State'}, inplace=True)
df_test.rename(columns={'Province_State':'State'}, inplace=True)
df_train['Date'] = pd.to_datetime(df_train['Date']... | grid_svc = GridSearchCV(SVC() , param_grid_svc, cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,096,495 | NULL_VAL = "NULL_VAL"
def fillState(state, country):
if state == NULL_VAL:
return country
return state +':' + country
def fillState2(state, country):
if type(state)==str:
return country
return state +':' + country
X_Train = df_train.loc[:, ['State', 'Country', 'Date', 'ConfirmedCases', 'Fatalities']]
X_Train['State'].f... | grid_svc.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | mitigation['start_day'] =(( mitigation['start'] - firstDay ).values / 86400000000000 ).astype(int )<categorify> | param_grid_random = {'n_estimators':[200, 500],
'max_depth':[5, 9],
'max_samples':[0.5, 0.7],
'max_features':[0.5, 0.7],
'min_samples_split':[2, 5, 8]} | Titanic - Machine Learning from Disaster |
14,096,495 | le = LabelEncoder()
countries = X_Train.Country.unique()
df_out = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
for country in countries:
states = X_Train.loc[X_Train.Country == country, :].State.unique()
for state in states:
condition_train =(X_Train.Country == country)&(X_Train.State == st... | grid_random = GridSearchCV(RandomForestClassifier() , param_grid_random,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=4 ) | Titanic - Machine Learning from Disaster |
14,096,495 | df_out.to_csv('submission.csv', index=False )<load_from_csv> | grid_random.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | train = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/train.csv")
train.rename(columns={'Country_Region':'Country'}, inplace=True)
train.rename(columns={'Province_State':'State'}, inplace=True)
train['Date'] = pd.to_datetime(train['Date'], infer_datetime_format=True)
train['Date'] = train.Date.dt.str... | param_grid_gradient = {'max_depth':[3],
'n_estimators':[300, 400, 500],
'learning_rate':[0.035, 0.055],
'subsample':[0.4, 0.6],
'max_features':[0.4, 0.6],
'min_samples_split':[2, 5, 8, 12]
} | Titanic - Machine Learning from Disaster |
14,096,495 | %%time
filterwarnings('ignore')
le = LabelEncoder()
finaloutput = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
CountryState = train.CountryState.unique()
for CS in CountryState:
trainIndia = train[train["CountryState"] == CS]
testIndia = test[test["CountryState"] == CS]
trainIndia.CountryS... | grid_gradient = GridSearchCV(GradientBoostingClassifier() , param_grid_gradient,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,096,495 | finaloutput.ConfirmedCases.apply(math.floor )<save_to_csv> | grid_gradient.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | finaloutput.ForecastId = finaloutput.ForecastId.astype('int')
finaloutput.ConfirmedCases = round(finaloutput.ConfirmedCases,1)
finaloutput.Fatalities = round(finaloutput.Fatalities,1)
finaloutput = finaloutput[['ForecastId','ConfirmedCases','Fatalities']]
finaloutput.to_csv("submission.csv",index=False)
print("done... | param_grid_xgb = {'n_estimators':[300, 450],
'learning_rate':[0.02, 0.03],
'max_depth':[6],
'subsample':[0.5, 0.7],
'colsample_bylevel':[0.5, 0.7],
'reg_lambda':[1, 5, 15, ]
} | Titanic - Machine Learning from Disaster |
14,096,495 | import numpy as np
import pandas as pd<load_from_csv> | grid_xgb = GridSearchCV(XGBClassifier() , param_grid_xgb,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,096,495 | X_train = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
X_test = pd.read_csv('.. /input/covid19-global-forecasting-week-4/test.csv')
X_submission = pd.read_csv('.. /input/covid19-global-forecasting-week-4/submission.csv' )<data_type_conversions> | grid_xgb.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | X_train['Date'] = pd.to_datetime(X_train['Date'])
X_test['Date'] = pd.to_datetime(X_test['Date'])
X_test['Date']<count_unique_values> | logreg = LogisticRegression(**{'C': 0.03, 'l1_ratio': 0, 'penalty': 'elasticnet', 'solver': 'saga'})
svc = SVC(**{'C': 0.5, 'gamma': 0.1, 'kernel': 'rbf'})
knn = KNeighborsClassifier(**{'algorithm': 'ball_tree', 'n_neighbors': 20, 'weights': 'uniform'})
rfc = RandomForestClassifier(**{'max_depth': 5, 'max_features':... | Titanic - Machine Learning from Disaster |
14,096,495 | print(X_train.Country_Region.nunique() )<define_variables> | stack.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,096,495 | countries_no_province = [i for i in countries if i not in countries_with_provinces]
len(countries_no_province )<data_type_conversions> | y_preds = stack.predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,096,495 | X_train['Province_State'] = X_train['Province_State'].fillna('unknown')
X_test['Province_State'] = X_test['Province_State'].fillna('unknown' )<groupby> | submission = pd.DataFrame({'PassengerId':test.index,
'Survived':y_preds} ) | Titanic - Machine Learning from Disaster |
14,096,495 | X_train[X_train['Country_Region'].isin(countries_with_provinces)].groupby(['Country_Region'] ).agg({'Province_State':'nunique'} )<data_type_conversions> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,096,495 | X_train['Date'] = X_train['Date'].dt.strftime("%m%d")
X_train['Date'] = X_train['Date'].astype(int)
X_test['Date'] = X_test['Date'].dt.strftime("%m%d")
X_test['Date'] = X_test['Date'].astype(int )<data_type_conversions> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,096,495 | <data_type_conversions><EOS> | pd.read_csv('submission.csv' ) | Titanic - Machine Learning from Disaster |
14,142,829 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_x_and_y> | mytrainset = pd.read_csv('.. /input/titanic/train.csv')
mytrainset.head()
| Titanic - Machine Learning from Disaster |
14,142,829 | FEATURES = ['Date']
X_submission = pd.DataFrame(columns=['ForecastId', 'ConfirmedCases', 'Fatalities'])
for i in tqdm(X_train.Country_Region.unique()):
z_train = X_train[X_train['Country_Region'] == i]
z_test = X_test[X_test['Country_Region'] == i]
for k in z_train.Province_State.unique() :
p_train = z_train[z_train['... | mytestset = pd.read_csv('.. /input/titanic/test.csv')
mytestset.head()
| Titanic - Machine Learning from Disaster |
14,142,829 | X_submission.to_csv('submission.csv', index=False )<import_modules> | ages_mean_train = mytrainset['Age'].mean()
ages_mean_train = round(ages_mean_train)
ages_mean_test = mytestset['Age'].mean()
ages_mean_test = round(ages_mean_test)
| Titanic - Machine Learning from Disaster |
14,142,829 | import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.metrics import mean_squared_log_error<load_from_csv> | mytrainset['Age'] = mytrainset['Age'].replace(np.nan, ages_mean_train)
mytrainset['Age'] = mytrainset['Age'].replace(np.nan, ages_mean_train)
mytrainset = mytrainset.drop(["Cabin"], axis=1)
mytrainset = mytrainset.drop(["Name"], axis=1)
mytrainset = mytrainset.drop(["Ticket"], axis=1)
mytrainset['Embarked'].replac... | Titanic - Machine Learning from Disaster |
14,142,829 | df=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv', index_col='Id')
dtest=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv', index_col='ForecastId' )<prepare_x_and_y> | y = mytrainset['Survived']
features = ["Pclass", "Age", "Sex", "SibSp", "Parch", "Embarked"]
X = mytrainset[features]
X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=0.3, random_state=1 ) | Titanic - Machine Learning from Disaster |
14,142,829 | y1=df['ConfirmedCases']
y2=df['Fatalities']
df.drop('ConfirmedCases', axis=1, inplace=True)
df.drop('Fatalities', axis=1, inplace=True )<feature_engineering> | model= RandomForestClassifier(n_estimators=200,max_depth=5, random_state=1)
model = model.fit(X_train, Y_train)
predictions = model.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,142,829 | df['check']=1
dtest['check']=2
combo=pd.concat([df,dtest])
def date_split(date):
d=date.str.split('-', n=1, expand=True)
return d[1]
combo['MM_DD']= date_split(combo['Date'])
combo['Province_State']=combo['Province_State'].fillna(0 )<categorify> | accuracy_score(predictions, Y_test)
| Titanic - Machine Learning from Disaster |
14,142,829 | le=LabelEncoder()
combo['MM_DD']=le.fit_transform(combo['MM_DD'])
combo=pd.get_dummies(combo)
df1=combo[combo['check']==1]
dtest1=combo[combo['check']==2]<drop_column> | gnb = GaussianNB()
NB_model_predictions = gnb.fit(X_train, Y_train ).predict(X_test)
accuracy_score(NB_model_predictions, Y_test)
| Titanic - Machine Learning from Disaster |
14,142,829 | df1.drop('check', axis=1, inplace=True)
dtest1.drop('check', axis=1, inplace=True )<split> | decisiontreeModel = DecisionTreeClassifier()
decisiontreeModel = decisiontreeModel.fit(X_train, Y_train)
decisiontreePredicition = decisiontreeModel.predict(X_test)
accuracy_score(decisiontreePredicition, Y_test)
| Titanic - Machine Learning from Disaster |
14,142,829 | X_train1, X_valid1, y_train1, y_valid1 = train_test_split(df1, y1, train_size=0.8, test_size=0.2, random_state=0)
X_train2, X_valid2, y_train2, y_valid2 = train_test_split(df1, y2, train_size=0.8, test_size=0.2, random_state=0 )<compute_train_metric> | knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train, Y_train)
knnPredictions = knn.predict(X_test)
accuracy_score(Y_test, knnPredictions)
| Titanic - Machine Learning from Disaster |
14,142,829 | ef= ExtraTreesRegressor(n_estimators=15, random_state=3)
p2=ef.fit(X_train1, y_train1 ).predict(X_valid1)
rmsle2=np.sqrt(mean_squared_log_error(y_valid1 , p2))
print(rmsle2 )<compute_train_metric> | LRModel = LogisticRegression(max_iter = 200)
LRModel.fit(X_train, Y_train)
LRModel_Prediction = LRModel.predict(X_test)
accuracy_score(Y_test, LRModel_Prediction)
| Titanic - Machine Learning from Disaster |
14,142,829 | ef2= ExtraTreesRegressor(n_estimators=29,criterion='friedman_mse', random_state=7)
p3=ef2.fit(X_train2, y_train2 ).predict(X_valid2)
rmsle3=np.sqrt(mean_squared_log_error(y_valid2 , p3))
print(rmsle3 )<predict_on_test> | cv = KFold(n_splits=10, random_state=1, shuffle=True)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
print("%0.2f accuracy" %(scores.mean())) | Titanic - Machine Learning from Disaster |
14,142,829 | pre1=ef.fit(df1,y1 ).predict(dtest1)
pre2=ef2.fit(df1,y2 ).predict(dtest1 )<save_to_csv> | scores = cross_val_score(gnb, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
scores
print("%0.2f accuracy" %(scores.mean())) | Titanic - Machine Learning from Disaster |
14,142,829 | output=pd.DataFrame({'ForecastId': dtest.index, 'ConfirmedCases':pre1, 'Fatalities':pre2})
output.to_csv('submission.csv', index=False )<import_modules> | scores = cross_val_score(decisiontreeModel, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
scores
print("%0.2f accuracy" %(scores.mean())) | Titanic - Machine Learning from Disaster |
14,142,829 | 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... | scores = cross_val_score(knn, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
scores
print("%0.2f accuracy" %(scores.mean())) | Titanic - Machine Learning from Disaster |
14,142,829 | 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')
submission = pd.read_csv(dataset_path/'submission.csv' )<categorify> | scores = cross_val_score(LRModel, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
scores
print("%0.2f accuracy" %(scores.mean())) | Titanic - Machine Learning from Disaster |
14,142,829 | def fill_state(state,country):
if pd.isna(state): return country
return state<feature_engineering> | testing = mytestset[features]
testPredicitons = model.predict(testing ) | Titanic - Machine Learning from Disaster |
14,142,829 | <feature_engineering><EOS> | testPredicitons = {'PassengerId':mytestset["PassengerId"], "Survived": testPredicitons}
pd.DataFrame(testPredicitons ).to_csv("predictions.csv", index = False ) | Titanic - Machine Learning from Disaster |
13,882,987 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd
from xgboost import XGBClassifier
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier,BaggingC... | Titanic - Machine Learning from Disaster |
13,882,987 | submission=pd.DataFrame(columns=submission.columns)
l1=LabelEncoder()
l2=LabelEncoder()
l1.fit(train['Country_Region'])
l2.fit(train['Province_State'] )<categorify> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
PassengerId = test['PassengerId'] | Titanic - Machine Learning from Disaster |
13,882,987 | 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'... | train.isna().sum() | Titanic - Machine Learning from Disaster |
13,882,987 | submission
submission.to_csv('submission.csv',index=False )<define_variables> | test.isna().sum() | Titanic - Machine Learning from Disaster |
13,882,987 | datapath = '.. /input/covid19-global-forecasting-week-4/'
datapath2 = '.. /input/worldpopulationinfo/'
datapath3 = '.. /input/country-ppp/'
datapath4 = '.. /input/populationandcountryinfo/'
datapath5 = '.. /input/usstateland/'
datapath_week1 = '.. /input/covid19week1/'
add_other = True
CURVE_SMOOTHING = True
USE_NEW = ... | df = pd.concat([train, test])
df = df.reset_index(drop=True)
df['FamilySize'] = df['SibSp'] + df['Parch'] + 1
df['IsAlone'] = 0
df.loc[df['FamilySize'] == 1, 'IsAlone'] = 1
df['Fare'] = df['Fare'].fillna(df['Fare'].median())
df['Has_Cabin'] = df["Cabin"].apply(lambda x: 0 if type(x)== float else 1)
df['Title'] = df... | Titanic - Machine Learning from Disaster |
13,882,987 | population_by_age_df = pd.read_csv(datapath4 + "population_age_info.csv")
population_by_age_df.drop('ID',axis=1,inplace=True)
population_by_age_df[['ages 0-14', 'ages 15-64','Density(P/Km²)','Med.Age', 'ages 64-','Urban Pop %']] = \
population_by_age_df[['ages 0-14', 'ages 15-64','Density(P/Km²)','Med.Age', 'ages 64-... | df['Title2'] = df['Name'].apply(get_title)
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'}
df.replace({'Title2': mapping}, inplace=True)
titles = ['Dr', 'Master', 'Miss', 'Mr'... | Titanic - Machine Learning from Disaster |
13,882,987 | def add_other_info(df,istest_df,usstates_info,supp_info,population_by_age_df,CountryRegion,state_temperatures,ppp_tabel,coor_df):
df = pd.merge(df, usstates_info, on=['Country_Region','Province_State'], how='left')
df = pd.merge(df, population_by_age_df, on=['Country_Region'], how='left')
df[['ages 0-14', 'ages 15-64... | df['Last_Name'] = df['Name'].apply(lambda x: str.split(x, ",")[0])
DEFAULT_SURVIVAL_VALUE = 0.5
df['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in df[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age', 'Cabin']].groupby(['Last_Name', 'Fare']):
if(len(grp_df)!= 1):
... | Titanic - Machine Learning from Disaster |
13,882,987 | df = pd.read_csv(datapath + "train.csv")
sub_df = pd.read_csv(datapath + "test.csv")
df['Province_State'].fillna('', inplace=True)
sub_df['Province_State'].fillna('', inplace=True)
gem_targets = df[['Country_Region','Province_State','Date']+TARGETS]
gem_targets["Date"] = gem_targets["Date"].astype("datetime64[ms]")... | for _, grp_df in 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):
df.loc[df['PassengerId'] == pas... | Titanic - Machine Learning from Disaster |
13,882,987 | if CURVE_SMOOTHING:
df['Cases_m'] = df.groupby(['Country_Region', 'Province_State'])[['ConfirmedCases']].transform(lambda x: x.shift(1))
df['Cases_p'] = df.groupby(['Country_Region', 'Province_State'])[['ConfirmedCases']].transform(lambda x: x.shift(-1))
df['Cases_ave'] = 0.5*(df['ConfirmedCases']+0.5*(df['Cases_p']+df... | df.loc[ df['Age'] <= 16, 'Age'] = 0
df.loc[(df['Age'] > 16)&(df['Age'] <= 32), 'Age'] = 1
df.loc[(df['Age'] > 32)&(df['Age'] <= 48), 'Age'] = 2
df.loc[(df['Age'] > 48)&(df['Age'] <= 64), 'Age'] = 3
df.loc[ df['Age'] > 64, 'Age'] = 4 ;
df = df.drop(['PassengerId','Cabin','Name','SibSp','Parch','Embarked','Ticket','Last_... | Titanic - Machine Learning from Disaster |
13,882,987 | df = df[df["Date"] >= df["Date"].min() + timedelta(days=days_shift[NUM_SHIFT])].copy()
for col in TARGETS:
df[col] = np.log1p(df[col])/normfactor
df = df[df['days']>TRAIN_START_DAY]
<choose_model_class> | df.isna().sum() | Titanic - Machine Learning from Disaster |
13,882,987 | def nn_block(input_layer, size, dropout_rate, activation):
out_layer = KL.Dense(size, activation=None )(input_layer)
out_layer = KL.Activation(activation )(out_layer)
out_layer = KL.Dropout(dropout_rate )(out_layer)
return out_layer
def get_model(feature_length,target_length,):
inp = KL.Input(shape=(feature_length,)... | train = df[df['Survived'].notnull() ]
test = df[df['Survived'].isnull() ]
test = test.drop(['Survived'], axis=1 ) | Titanic - Machine Learning from Disaster |
13,882,987 | def rmse(y_true, y_pred):
return np.sqrt(mean_squared_error(y_true, y_pred))
def evaluate(df,targets):
error = 0
for col in targets:
error += rmse(df[col].values, df["pred_{}".format(col)].values)
return np.round(error/len(targets), 5)
def predict_one(df,features,prev_targets, models):
pred = np.zeros(( df.shape[0], ... | x = train.copy()
y = x.pop('Survived')
x_test = test.copy()
x = x.values
y = y.values
x_test = x_test.values
std_scaler = StandardScaler()
x = std_scaler.fit_transform(x)
xf_test = std_scaler.transform(x_test)
x, x_val, y, y_val = train_test_split(x, y,test_size=0.2, shuffle=False ) | Titanic - Machine Learning from Disaster |
13,882,987 | all_features = base_features + shift_features
df = fill_shift_columns(df,TARGETS)
df[all_features] = df[all_features].fillna(0)
print("Kolonner i modelller",all_features)
print("BEFORE TRAINING")
print(df[(df['Country_Region']=='Germany')&(df['days'] >75)])
final_models = train_models(df,all_features,TARGETS, save... | class Optimizer:
def __init__(self, metric, trials=30):
self.metric = metric
self.trials = trials
self.sampler = TPESampler()
def objective(self, trial):
model = create_model(trial)
model.fit(x, y)
preds = model.predict(x_val)
if self.metric == 'acc':
return accuracy_score(y_val, preds)
else:
return f1_score(y_val,... | Titanic - Machine Learning from Disaster |
13,882,987 | full_df_pred= predict(full_df,all_features,TARGETS,prev_targets,ESTIMATE_FIRST_DATE,ESTIMATE_DAYS, final_models)
for col in TARGETS:
full_df_pred[col] = np.expm1(full_df_pred[col])
<merge> | def create_model(trial):
max_depth = trial.suggest_int("max_depth", 2, 6)
n_estimators = trial.suggest_int("n_estimators", 2, 150)
min_samples_leaf = trial.suggest_int("min_samples_leaf", 1, 10)
model = RandomForestClassifier(
min_samples_leaf=min_samples_leaf,
n_estimators=n_estimators,
max_depth=max_depth,
)
re... | Titanic - Machine Learning from Disaster |
13,882,987 | gem_targets = gem_targets[gem_targets["Date"]>=SUBMISSION_FIRST_DATE]
print(gem_targets.head(15))
values_to_submit = full_df_pred[full_df_pred["Date"]>=ESTIMATE_FIRST_DATE]
values_to_submit = values_to_submit[['Date','Country_Region','Province_State','ConfirmedCases', 'Fatalities']]
print(values_to_submit.head(15))
val... | mdict = {
'RF': RandomForestClassifier() ,
'XGB': XGBClassifier() ,
'LGBM': LGBMClassifier() ,
'DT': DecisionTreeClassifier() ,
'KNN': KNeighborsClassifier() ,
'BC': BaggingClassifier() ,
'OARF': RandomForestClassifier(**rf_acc_params),
'OFRF': RandomForestClassifier(**rf_f1_params),
'OAXGB': XGBClassifier(**xgb_acc_pa... | Titanic - Machine Learning from Disaster |
13,882,987 | sub2.sort_values("ForecastId", inplace=True)
sub2.to_csv("submission.csv", index=False)
<merge> | def create_model(trial):
model_names = list()
models_list = [
'RF', 'XGB', 'LGBM', 'DT',
'KNN', 'BC', 'OARF', 'OFRF',
'OAXGB', 'OFXGB', 'OALGBM',
'OFLGBM', 'OADT', 'OFDT',
'OAKNN', 'OFKNN', 'OABC',
'OFBC', 'OAABC', 'OFABC',
'OAET', 'OFET', 'LR',
'ABC', 'SGD', 'ET',
'GB', 'RDG',
'PCP', 'PAC'
]
head_list = [
'RF',
'XGB',... | Titanic - Machine Learning from Disaster |
13,882,987 | full_df_pred['Cases_Estimate'] = full_df_pred['ConfirmedCases']
full_df_pred['Fatalities_Estimate'] = full_df_pred['Fatalities']
full_df_pred2 = full_df_pred[['Date','Country_Region','Province_State']+TARGETS]
full_df2 = full_df[['Date','Country_Region','Province_State']+TARGETS]
full_df3 = pd.merge(full_df2,full_df_pr... | model = SuperLearner(
folds=folds,
)
models = [
mdict[item] for item in result
]
model.add(models)
model.add_meta(mdict[head])
xf = train.copy()
yf = xf.pop('Survived')
xf = xf.values
xf = std_scaler.fit_transform(xf)
yf = yf.values
model.fit(xf, yf ) | Titanic - Machine Learning from Disaster |
13,882,987 | train_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
test_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
submission_csv = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv' )<data_type_conversions> | preds = model.predict(xf_test ).astype(int)
output = pd.DataFrame({ 'PassengerId': PassengerId,
'Survived': preds })
output.to_csv('boosted_tree.csv', index=False)
| Titanic - Machine Learning from Disaster |
13,795,550 | convert_dict = {'Province_State': str,'Country_Region':str,'ConfirmedCases':int,'Fatalities':int}
convert_dict_test = {'Province_State': str,'Country_Region':str}
train_data = train_data.astype(convert_dict)
test_data = test_data.astype(convert_dict_test )<data_type_conversions> | train_data_raw = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data_raw.head() | Titanic - Machine Learning from Disaster |
13,795,550 | 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> | train_data=train_data_raw.drop(columns=['PassengerId','Name','Cabin','Ticket'])
train_data.head() | Titanic - Machine Learning from Disaster |
13,795,550 | train_data.loc[:, 'Date'] = train_data.Date.dt.strftime('%m%d')
train_data.loc[:, 'Date'] = train_data['Date'].astype(int)
test_data.loc[:, 'Date'] = test_data.Date.dt.strftime('%m%d')
test_data.loc[:, 'Date'] = test_data['Date'].astype(int )<feature_engineering> | train_data=train_data.loc[pd.notna(train_data.Embarked)]
train_data | Titanic - Machine Learning from Disaster |
13,795,550 | train_data['Country_Region'] = np.where(train_data['Province_State'] == 'nan',train_data['Country_Region'],train_data['Province_State']+' '+train_data['Country_Region'])
test_data['Country_Region'] = np.where(test_data['Province_State'] == 'nan',test_data['Country_Region'],test_data['Province_State']+' '+test_data['Co... | age_arr=train_data.Age.values
bool_arr=pd.isna(train_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
train_data.replace(to_replace=train_dat... | Titanic - Machine Learning from Disaster |
13,795,550 | train_data = train_data.drop(columns=['Province_State'])
test_data = test_data.drop(columns=['Province_State'] )<define_variables> | scaled_age_arr=[round(age/avg_age,2)for age in age_arr]
train_data.Age=train_data.Age.replace(to_replace=train_data.Age.values,value=scaled_age_arr)
fare_arr=train_data.Fare.values
total_fare=0
num_fare=len(fare_arr)
for fare in fare_arr:
total_fare+=fare
avg_fare=total_fare/num_fare
scaled_fare_arr=[round(fare/avg_f... | Titanic - Machine Learning from Disaster |
13,795,550 | s =(train_data.dtypes == 'object')
object_cols = list(s[s].index )<import_modules> | d_Sex={'male':0,'female':1}
d_Embarked={'S':0,'C':1,'Q':2}
train_data.Sex = train_data.Sex.replace(d_Sex)
train_data.Embarked = train_data.Embarked.replace(d_Embarked)
train_data.Embarked=train_data.Embarked.astype(int)
train_data | Titanic - Machine Learning from Disaster |
13,795,550 | from sklearn.preprocessing import LabelEncoder<categorify> | input_data=train_data[['Pclass','Sex','Age','SibSp','Parch','Fare','Embarked']][:]
target=train_data['Survived'][:]
print(input_data.values)
| 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.