kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
5,103,938 | %matplotlib inline<compute_test_metric> | rf_clf = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', RandomForestClassifier(random_state=42)) ])
rf_param_grid = {
'classifier__n_estimators' : [50, 100],
'classifier__max_features' : [2, 3],
'classifier__criterion' : ['gini', 'entropy']
}
rf_grid_search = GridSearchCV(rf_clf, rf_param_grid, cv=1... | Titanic - Machine Learning from Disaster |
5,103,938 | def dS_dt(S, I, R_t, T_inf):
return -(R_t / T_inf)* I * S
def dE_dt(S, E, I, R_t, T_inf, T_inc):
return(R_t / T_inf)* I * S -(T_inc**-1)* E
def dI_dt(I, E, T_inc, T_inf):
return(T_inc**-1)* E -(T_inf**-1)* I
def dR_dt(I, T_inf):
return(T_inf**-1)* I
def SEIR_model(t, y, R_t, T_inf, T_inc):
if callable(R_t):
reproductio... | svm_clf = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', SVC(random_state=42)) ])
svm_param_grid = [
{'classifier__kernel': ['linear'], 'classifier__C': [10., 30., 100., 300.]},
{'classifier__kernel': ['rbf'], 'classifier__C': [1.0, 3.0, 10., 30., 100., 300.],
'classifier__gamma': [0.01, 0.03, 0.1, ... | Titanic - Machine Learning from Disaster |
5,103,938 | train = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
test = pd.read_csv('.. /input/covid19-global-forecasting-week-4/test.csv')
train['Date_datetime'] = train['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')) )<load_from_csv> | knn_clf = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', KNeighborsClassifier())])
knn_param_grid = {
'classifier__n_neighbors': [5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26 ],
'classifier__weights': ['uniform', 'distance' ],
'classifier__leaf_size': list(range(1,50,5)) ,
}
knn_grid_search... | Titanic - Machine Learning from Disaster |
5,103,938 | pop_info = pd.read_csv('/kaggle/input/covid19-population-data/population_data.csv')
country_pop = pop_info.query('Type == "Country/Region"')
province_pop = pop_info.query('Type == "Province/State"')
country_lookup = dict(zip(country_pop['Name'], country_pop['Population']))
province_lookup = dict(zip(province_pop['Na... | sgd_clf = Pipeline(steps=[('preprocessor', all_preprocess),
('classifier', SGDClassifier(random_state=42)) ])
sgd_param_grid = {
'classifier__max_iter': [100, 200],
'classifier__alpha': [0.0001, 0.001, 0.01, 0.1],
}
sgd_grid_search = GridSearchCV(sgd_clf, sgd_param_grid, cv=10, iid=True)
sgd_grid_search.fit(X_train,... | Titanic - Machine Learning from Disaster |
5,103,938 | Country = 'Hubei'
N = pop_info[pop_info['Name']==Country]['Population'].tolist() [0]
train_loc = train[train['Country_Region']==Country].query('ConfirmedCases > 0')
if len(train_loc)==0:
train_loc = train[train['Province_State']==Country].query('ConfirmedCases > 0')
n_infected = train_loc['ConfirmedCases'].iloc[0]
ma... | final_pipe = Pipeline(steps=[('preprocessor', all_preprocess)] ) | Titanic - Machine Learning from Disaster |
5,103,938 | from scipy.optimize import minimize
from sklearn.metrics import mean_squared_log_error, mean_squared_error<compute_train_metric> | X_final_processed = final_pipe.fit_transform(X ) | Titanic - Machine Learning from Disaster |
5,103,938 | def eval_model_const(params, data, population, return_solution=False, forecast_days=0):
R_0, cfr = params
N = population
n_infected = data['ConfirmedCases'].iloc[0]
max_days = len(data)+ forecast_days
s, e, i, r =(N - n_infected)/ N, 0, n_infected / N, 0
def time_varying_reproduction(t):
if t > 80:
return R_0 * 0.5
els... | test_final_processed = final_pipe.transform(test ) | Titanic - Machine Learning from Disaster |
5,103,938 | def eval_model_decay(params, data, population, return_solution=False, forecast_days=0):
R_0, cfr, k, L = params
N = population
n_infected = data['ConfirmedCases'].iloc[0]
max_days = len(data)+ forecast_days
s, e, i, r =(N - n_infected)/ N, 0, n_infected / N, 0
def time_varying_reproduction(t):
return R_0 /(1 +(t/L)**k)... | knn_hyperparameters = {
'n_neighbors': [6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22],
'algorithm' : ['auto'],
'weights': ['uniform', 'distance'],
'leaf_size': list(range(1,50,5)) ,
}
gd=GridSearchCV(estimator = KNeighborsClassifier() , param_grid = knn_hyperparameters,
cv=10, scoring = "roc_auc")
gd.fit(X_final_process... | Titanic - Machine Learning from Disaster |
5,103,938 | def fit_model_new(data, area_name, initial_guess=[2.2, 0.02, 2, 50],
bounds=(( 1, 20),(0, 0.15),(1, 3),(1, 100)) , make_plot=True, decay_mode = None):
if area_name in ['France']:
train = data.query('ConfirmedCases > 0' ).copy() [:-1]
else:
train = data.query('ConfirmedCases > 0' ).copy()
train_data = train
if len(train... | gd.best_estimator_.fit(X_final_processed, y)
y_pred = gd.best_estimator_.predict(test_final_processed ) | Titanic - Machine Learning from Disaster |
5,103,938 | country = 'Taiwan*'
if country not in train['Country_Region'].unique() :
country_pd_train = train[train['Province_State']==country]
else:
country_pd_train = train[train['Country_Region']==country]
a,b = fit_model_new(country_pd_train,country,make_plot=True )<split> | knn = KNeighborsClassifier(algorithm='auto', leaf_size=26, metric='minkowski',
metric_params=None, n_jobs=None, n_neighbors=6, p=2,
weights='uniform')
knn.fit(X_final_processed, y)
y_pred = knn.predict(test_final_processed ) | Titanic - Machine Learning from Disaster |
5,103,938 | country = 'Japan'
if country not in train['Country_Region'].unique() :
country_pd_train = train[train['Province_State']==country]
else:
country_pd_train = train[train['Country_Region']==country]
a,b = fit_model_new(country_pd_train,country,make_plot=True )<split> | submission = pd.DataFrame(pd.read_csv(".. /input/test.csv")['PassengerId'])
submission['Survived'] = y_pred
submission.to_csv("submission.csv", index = False ) | Titanic - Machine Learning from Disaster |
8,075,514 | country = 'Italy'
if country not in train['Country_Region'].unique() :
country_pd_train = train[train['Province_State']==country]
else:
country_pd_train = train[train['Country_Region']==country]
a,b = fit_model_new(country_pd_train,country,make_plot=True )<split> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score, roc_auc_score
from sklearn.metrics import confusion_matrix
from sklearn.ensemble import RandomForestClassifier
from collections imp... | Titanic - Machine Learning from Disaster |
8,075,514 | country = 'New York'
if country not in train['Country_Region'].unique() :
country_pd_train = train[train['Province_State']==country]
else:
country_pd_train = train[train['Country_Region']==country]
a,b = fit_model_new(country_pd_train,country,make_plot=True )<feature_engineering> | train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
8,075,514 | country = 'Afghanistan'
if country not in train['Country_Region'].unique() :
country_pd_train = train[train['Province_State']==country]
else:
country_pd_train = train[train['Country_Region']==country]
a,b = fit_model_new(country_pd_train,country,make_plot=True )<feature_engineering> | df = pd.concat([train,test] ).set_index('PassengerId' ) | Titanic - Machine Learning from Disaster |
8,075,514 | country = 'US'
country_pd_train = train[train['Country_Region']==country]
country_pd_train2 = country_pd_train.groupby(['Date'] ).sum().reset_index()
country_pd_train2['Date_datetime'] = country_pd_train2['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')))
a,b = fit_model_new(country_pd_train2,country,... | df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,075,514 | country = 'Global'
country_pd_train2 = train.groupby(['Date'] ).sum().reset_index()
country_pd_train2['Date_datetime'] = country_pd_train2['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')))
a,b = fit_model_new(country_pd_train2,country,make_plot=True )<count_unique_values> | df.Fare = df.Fare.fillna(df.Fare.loc[df.Pclass==3].median() ) | Titanic - Machine Learning from Disaster |
8,075,514 | validation_scores = []
validation_county = []
validation_country = []
for country in tqdm(train['Country_Region'].unique()):
country_pd_train = train[train['Country_Region']==country]
if len(country_pd_train['Province_State'].unique())<2:
predict_test, score = fit_model_new(country_pd_train,country,make_plot=False)
if... | Counter(df.Embarked ) | Titanic - Machine Learning from Disaster |
8,075,514 | validation_scores = pd.DataFrame({'country/state':validation_country,'country':validation_county,'MSLE':validation_scores})
validation_scores.sort_values(by=['MSLE'], ascending=False ).head(20 )<filter> | df.Embarked = df.Embarked.fillna('S' ) | Titanic - Machine Learning from Disaster |
8,075,514 | large_msle = validation_scores[validation_scores['MSLE']>1]<define_variables> | age = list()
for i in df.index:
if df.Age.isnull() [i]:
s = df['Pclass'][i]
age.append(df['Age'].loc[df['Pclass']== s].median())
else : age.append(df['Age'][i])
df.Age=age | Titanic - Machine Learning from Disaster |
8,075,514 | test_end = datetime.datetime.strptime('2020-05-14','%Y-%m-%d')
test_start = datetime.datetime.strptime('2020-04-02','%Y-%m-%d')
train_max = train.Date_datetime.max()
train_min = train.Date_datetime.min()
delta_days =(test_end - train_max ).days
all_days =(test_end - train_min ).days
delta_days,all_days<filter> | def Cabin_cla(x):
if x=='A' : return 4
elif x=='B'or'C': return 3
elif x=='D'or'D': return 2
elif x=='F'or'G': return 1
else : return 0
df['Cabin']=list(map(Cabin_cla,df.Cabin)) | Titanic - Machine Learning from Disaster |
8,075,514 | for country in large_msle['country'].unique() :
if(country!= country)==False:
country_pd_train = train[train['Country_Region']==country]
country_pd_test = test[test['Country_Region']==country]
if len(country_pd_train)==0:
country_pd_train = train[train['Province_State']==country]
country_pd_test = test[test['Province_S... | title = [i.split(' ')[1].split('.')[0].strip() for i in df.Name]
Counter(title ) | Titanic - Machine Learning from Disaster |
8,075,514 | submit = pd.read_csv('.. /input/covid19-global-forecasting-week-4/submission.csv')
submit['Fatalities'] = test['Fatalities'].astype('float')
submit['ConfirmedCases'] = test['ConfirmedCases'].astype('float')
submit.to_csv('submission.csv',index=False )<define_variables> | def Name_cla(x):
if x=='Mr': return 1
elif x=='Master': return 3
elif x=='Miss': return 4
elif x=='Mrs': return 5
else : return 2
df.Name = list(map(Name_cla,title)) | Titanic - Machine Learning from Disaster |
8,075,514 | N = 5<predict_on_test> | df=df.drop(['Parch','SibSp'],axis=1 ) | Titanic - Machine Learning from Disaster |
8,075,514 | def get_preds_lin_reg(series, pred_min, H):
regr = LinearRegression(fit_intercept=True)
pred_list = []
X_train = np.array(range(len(series)))
y_train = np.array(series)
X_train = X_train.reshape(-1, 1)
y_train = y_train.reshape(-1, 1)
regr.fit(X_train, y_train)
pred = regr.predict(np.array(range(len(series),len... | df.Embarked = [{'S':1, 'Q':2, 'C':3}[i] for i in df.Embarked] | Titanic - Machine Learning from Disaster |
8,075,514 | train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/train.csv')
train.columns = [col.lower() for col in train.columns]
train['date'] = pd.to_datetime(train['date'], format='%Y-%m-%d')
train<load_from_csv> | y_train=df.Survived.dropna()
X_train=df[df.Survived.notnull() ].drop('Survived',axis=1)
X_test=df[df.Survived.isnull() ].drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
8,075,514 | test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/test.csv')
test.columns = [col.lower() for col in test.columns]
test['date'] = pd.to_datetime(test['date'], format='%Y-%m-%d')
test<load_from_csv> | cv_score = list()
auc_score = list()
for i in [5,6,7,8,9]:
rfc=RandomForestClassifier(criterion='gini',random_state=4, max_depth=i)
rfc.fit(X_train, y_train)
tree_predicted = rfc.predict(X_train)
auc_score.append(roc_auc_score(y_train,tree_predicted))
scores = cross_val_score(rfc, X_train, y_train,cv=5)
cv_score.ap... | Titanic - Machine Learning from Disaster |
8,075,514 | submission = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-4/submission.csv')
submission<count_missing_values> | rfc=RandomForestClassifier(criterion='gini',random_state=4, max_depth=8)
rfc.fit(X_train, y_train)
tree_predicted = rfc.predict(X_train)
roc_auc_score(y_train,tree_predicted ) | Titanic - Machine Learning from Disaster |
8,075,514 | train.isnull().sum(axis=0 )<count_unique_values> | rfc=RandomForestClassifier(criterion='gini',random_state=4, max_depth=7)
rfc.fit(X_train, y_train)
tree_predicted = rfc.predict(X_train)
y_test = rfc.predict(X_test ) | Titanic - Machine Learning from Disaster |
8,075,514 | print(len(train['province_state'].unique()))
train['province_state'].unique()<count_unique_values> | sum(y_test ) | Titanic - Machine Learning from Disaster |
8,075,514 | print(len(train['country_region'].unique()))
train['country_region'].unique()<count_values> | PassengerId = list(X_test.reset_index() ['PassengerId'])
result = pd.DataFrame({'PassengerId':PassengerId,'Survived':y_test})
result['Survived']=[int(i)for i in result.Survived]
result.to_csv('result.csv', index=False ) | Titanic - Machine Learning from Disaster |
7,901,621 | train['country_region'].value_counts()<filter> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
7,901,621 | train[train['country_region']=='Singapore']<categorify> | full_train = train_data.drop(['Name', 'Parch', 'Ticket'], axis = 1)
full_train.head() | Titanic - Machine Learning from Disaster |
7,901,621 | train['province_state'] = train['province_state'].fillna(value = 'nil')
train.head()<data_type_conversions> | full_train = full_train[pd.notnull(full_train['Embarked'])] | Titanic - Machine Learning from Disaster |
7,901,621 | test['province_state'] = test['province_state'].fillna(value = 'nil')
test.head()<remove_duplicates> | full_train['Cabin'] = full_train['Cabin'].where(full_train['Cabin'].isna() , 1)
full_train['Cabin'] = full_train['Cabin'].fillna(0)
full_train['Cabin'].head() | Titanic - Machine Learning from Disaster |
7,901,621 | ps_cr_unique = train[['province_state', 'country_region']].drop_duplicates()
ps_cr_unique<define_variables> | s =(full_train.dtypes == 'object')
object_cols = list(s[s].index)
OH_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
OH_cols = pd.DataFrame(OH_encoder.fit_transform(full_train[object_cols]))
OH_cols.index = full_train.index
num = full_train.drop(object_cols, axis=1)
OH = pd.concat([num, OH_cols], axi... | Titanic - Machine Learning from Disaster |
7,901,621 | date_max_train = train[(train['province_state']=='nil')&
(train['country_region']=='Singapore')]['date'].max()
date_max_test = test[(test['province_state']=='nil')&
(test['country_region']=='Singapore')]['date'].max()
pred_days =(date_max_test - date_max_train ).days
print(date_max_train, date_max_test, pred_days )<d... | X = OH.drop('Survived', axis=1)
y = OH['Survived']
X_train, X_valid, y_train, y_valid = train_test_split(X, y,
train_size=0.8, test_size=0.2,
random_state=0 ) | Titanic - Machine Learning from Disaster |
7,901,621 | ps = 'nil'
cr = 'Singapore'<filter> | model = RandomForestRegressor(n_estimators=1500, random_state=0)
model.fit(X_train, y_train)
preds = model.predict(X_valid)
mae = mean_absolute_error(y_valid, preds)
print(mae ) | Titanic - Machine Learning from Disaster |
7,901,621 | train_sgp = train[(train['province_state']==ps)&(train['country_region']==cr)]
train_sgp[-5:]<predict_on_test> | test_data = test_data.drop(['Name', 'Parch','Ticket'], axis = 1)
test_data['Cabin'] = test_data['Cabin'].where(test_data['Cabin'].isna() , 1)
test_data['Cabin'] = test_data['Cabin'].fillna(0)
OH_cols = pd.DataFrame(OH_encoder.fit_transform(test_data[object_cols]))
OH_cols.index = test_data.index
num = test_data.drop... | Titanic - Machine Learning from Disaster |
7,901,621 | preds = get_preds_lin_reg(train_sgp['confirmedcases'][-N:], 0, pred_days)
preds<prepare_output> | prediction = model.predict(OH_test_data)
test_data['Survived'] = prediction
submission = test_data[['PassengerId','Survived']]
submission['Survived'].values[submission['Survived'] >= 0.7] = 1
submission['Survived'].values[submission['Survived'] < 0.7] = 0
submission.Survived = submission.Survived.astype(int)
submissi... | Titanic - Machine Learning from Disaster |
3,017,668 | date_list = []
date = pd.date_range(date_max_train+timedelta(days=1), date_max_test)
results = pd.DataFrame({'date': date, 'preds':preds})
results.head()<merge> | training_df = pd.read_csv(".. /input/train.csv")
testing_df = pd.read_csv(".. /input/test.csv")
combine = [training_df, testing_df] | Titanic - Machine Learning from Disaster |
3,017,668 | test_merged = test.merge(train[['province_state', 'country_region', 'date', 'confirmedcases', 'fatalities']],
left_on=['province_state', 'country_region', 'date'],
right_on=['province_state', 'country_region', 'date'],
how='left')
test_merged<merge> | training_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,017,668 | test_merged2 = test_merged.merge(results,
left_on=['province_state', 'country_region', 'date'],
right_on=['province_state', 'country_region', 'date'],
how='left')
test_merged2<drop_column> | training_df[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,017,668 | test_merged2['confirmedcases'] = test_merged2.apply(lambda row: row['confirmedcases_x'] if pd.isnull(row['confirmedcases_y'])else row['confirmedcases_y'], axis=1)
test_merged2.drop(['confirmedcases_x', 'confirmedcases_y'], axis=1, inplace=True)
test_merged2<merge> | training_df[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,017,668 | test_merged3 = test_merged2.merge(results,
left_on=['province_state', 'country_region', 'date'],
right_on=['province_state', 'country_region', 'date'],
how='left')
test_merged3<drop_column> | training_df[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,017,668 | test_merged3['fatalities'] = test_merged3.apply(lambda row: row['fatalities_x'] if pd.isnull(row['fatalities_y'])else row['fatalities_y'], axis=1)
test_merged3.drop(['fatalities_x', 'fatalities_y'], axis=1, inplace=True)
test_merged3<drop_column> | column_choice_training.Sex[column_choice_training.Sex == 'female'] = 0
column_choice_training.Sex[column_choice_training.Sex == 'male'] = 1
column_choice_test.Sex[column_choice_test.Sex == 'female'] = 0
column_choice_test.Sex[column_choice_test.Sex == 'male'] = 1
column_choice_training.head() | Titanic - Machine Learning from Disaster |
3,017,668 | submission = test_merged3.copy()
submission.drop(['country_region', 'province_state', 'date'], axis=1, inplace=True)
submission.rename(columns={'forecastid': 'ForecastId',
'fatalities': 'Fatalities',
'confirmedcases': 'ConfirmedCases'}, inplace=True)
submission<save_to_csv> | freq_port = column_choice_training.Embarked.dropna().mode() [0]
column_choice_training.Embarked = column_choice_training.Embarked.fillna(freq_port)
column_choice_test.Embarked = column_choice_test.Embarked.fillna(freq_port)
column_choice_training.Embarked[column_choice_training.Embarked == 'S'] = 0
column_choice_trai... | Titanic - Machine Learning from Disaster |
3,017,668 | submission.to_csv("submission.csv", index=False )<load_from_csv> | column_choice_training['Age_is_Null'] = column_choice_training['Age'].apply(lambda x: 1 if pd.isnull(x)else 0)
column_choice_test['Age_is_Null'] = column_choice_test['Age'].apply(lambda x: 1 if pd.isnull(x)else 0 ) | Titanic - Machine Learning from Disaster |
3,017,668 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape )<split> | column_choice_training[['Age', 'Pclass', 'Sex']].groupby(['Pclass', 'Sex'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
3,017,668 | train_df, val_df = train_test_split(train_df, test_size=0.1, random_state=2018)
embed_size = 300
max_features = 50000
maxlen = 100
train_X = train_df["question_text"].fillna("_na_" ).values
val_X = val_df["question_text"].fillna("_na_" ).values
test_X = test_df["question_text"].fillna("_na_" ).values
tokenizer = Token... | age_means = column_choice_training.groupby(['Sex', 'Pclass'])['Age']
column_choice_training.Age = age_means.transform(lambda x: x.fillna(x.mean()))
column_choice_test.Age = age_means.transform(lambda x: x.fillna(x.mean()))
column_choice_training.head(6 ) | Titanic - Machine Learning from Disaster |
3,017,668 | np.random.seed(2018)
trn_idx = np.random.permutation(len(train_X))
val_idx = np.random.permutation(len(val_X))
train_X = train_X[trn_idx]
val_X = val_X[val_idx]
train_y = train_y[trn_idx]
val_y = val_y[val_idx]<import_modules> | bins = [0, 6, 60, 80]
column_choice_training['Age_cut'] = pd.cut(column_choice_training['Age'], bins)
column_choice_test['Age_cut'] = pd.cut(column_choice_test['Age'], bins)
column_choice_training = pd.concat([column_choice_training.drop(['Age_cut'], axis=1),
pd.get_dummies(column_choice_training['Age_cut'], prefix =... | Titanic - Machine Learning from Disaster |
3,017,668 | from keras.models import Sequential,Model
from keras.layers import Dense, CuDNNLSTM, Bidirectional, Input, Dropout, Embedding, CuDNNGRU, GlobalMaxPool1D
from keras.optimizers import Adam
from keras import backend as K
from keras.engine.topology import Layer
from keras import initializers, regularizers, constraints<stat... | column_choice_training.Fare = column_choice_training.Fare.fillna(column_choice_training.Fare.mean())
column_choice_test.Fare = column_choice_test.Fare.fillna(column_choice_training.Fare.mean())
column_choice_training.head(6 ) | Titanic - Machine Learning from Disaster |
3,017,668 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_em... | column_choice_training['Name_Length'] = column_choice_training['Name'].apply(len)
column_choice_test['Name_Length'] = column_choice_test['Name'].apply(len)
column_choice_training.head(6 ) | Titanic - Machine Learning from Disaster |
3,017,668 | filter_sizes = [1,2,3,5]
num_filters = 36
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = Reshape(( maxlen, embed_size, 1))(x)
maxpool_pool = []
for i in range(len(filter_sizes)) :
conv = Conv2D(num_filters, kernel_size=(filter_sizes[i], embed_size),
kernel_i... | column_choice_training['Title'] = column_choice_training['Name'].str.split(', ' ).str[1]
column_choice_training['Title'] = column_choice_training['Title'].str.split('.' ).str[0]
column_choice_training = column_choice_training.drop(['Name'], axis=1)
column_choice_test['Title'] = column_choice_test['Name'].str.split(', ... | Titanic - Machine Learning from Disaster |
3,017,668 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | column_choice_training['Title'] = column_choice_training['Title'].replace(['the Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer'], 'Rare')
column_choice_training['Title'] = column_choice_training['Title'].replace(['Lady','Mlle', 'Ms'], 'Mrs')
column_choice_training['Title'] = column_choice_trai... | Titanic - Machine Learning from Disaster |
3,017,668 | pred_cnn_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_cnn_val_y>thresh ).astype(int))))<predict_on_test> | column_choice_training.Title[column_choice_training.Title == 'Master'] = 0
column_choice_training.Title[column_choice_training.Title == 'Miss'] = 1
column_choice_training.Title[column_choice_training.Title == 'Mr'] = 2
column_choice_training.Title[column_choice_training.Title == 'Mrs'] = 3
column_choice_training.Title[... | Titanic - Machine Learning from Disaster |
3,017,668 | pred_cnn_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | column_choice_training['Ticket_Len'] = column_choice_training['Ticket'].apply(len)
column_choice_test['Ticket_Len'] = column_choice_test['Ticket'].apply(len)
print(column_choice_test['Ticket_Len'].value_counts())
column_choice_training[['Ticket_Len', 'Survived']].groupby(['Ticket_Len'], as_index=False ).mean().sort_... | Titanic - Machine Learning from Disaster |
3,017,668 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<choose_model_class> | column_choice_training['Ticket_Letter'] = column_choice_training['Ticket'].str[0]
column_choice_test['Ticket_Letter'] = column_choice_test['Ticket'].str[0]
print(column_choice_training['Ticket_Letter'].value_counts())
print(column_choice_test['Ticket_Letter'].value_counts())
column_choice_training[['Ticket_Letter', '... | Titanic - Machine Learning from Disaster |
3,017,668 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | column_choice_training['Ticket_Letter'] = column_choice_training['Ticket_Letter'].replace(['W', '4', '7', '6', 'L', '5', '8'], 'Rare_Low_Surv')
column_choice_training['Ticket_Letter'] = column_choice_training['Ticket_Letter'].replace(['F', '9'], 'Rare_High_Surv')
column_choice_test['Ticket_Letter'] = column_choice_te... | Titanic - Machine Learning from Disaster |
3,017,668 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_em... | column_choice_training = pd.concat([column_choice_training.drop(['Ticket', 'Ticket_Letter'], axis=1),
pd.get_dummies(column_choice_training['Ticket_Letter'], prefix = 'Ticket_Letter')], axis=1)
column_choice_test = pd.concat([column_choice_test.drop(['Ticket', 'Ticket_Letter'], axis=1),
pd.get_dummies(column_choice_te... | Titanic - Machine Learning from Disaster |
3,017,668 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | column_choice_training.Cabin = column_choice_training.Cabin.fillna('N0')
column_choice_test.Cabin = column_choice_test.Cabin.fillna('N0')
column_choice_training['Cabin_Letter'] = column_choice_training['Cabin'].str[0]
column_choice_test['Cabin_Letter'] = column_choice_test['Cabin'].str[0]
print(column_choice_training... | Titanic - Machine Learning from Disaster |
3,017,668 | pred_glove_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_glove_val_y>thresh ).astype(int))))<predict_on_test> | column_choice_training['Cabin_Number'] = column_choice_training['Cabin'].str.split(' ' ).str[-1].str[1:]
column_choice_test['Cabin_Number'] = column_choice_test['Cabin'].str.split(' ' ).str[-1].str[1:]
column_choice_training['Cabin_Number'] = column_choice_training['Cabin_Number'].replace(['0'], np.NaN)
column_choice_... | Titanic - Machine Learning from Disaster |
3,017,668 | pred_glove_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | column_choice_training['Cabin_Letter'] = column_choice_training['Cabin_Letter'].replace(['T'], 'N')
column_choice_training = pd.concat([column_choice_training.drop(['Cabin', 'Cabin_Letter'], axis=1),
pd.get_dummies(column_choice_training['Cabin_Letter'], prefix = 'Cabin_Letter')], axis=1)
column_choice_test = pd.conc... | Titanic - Machine Learning from Disaster |
3,017,668 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | column_choice_training['Family'] = column_choice_training['SibSp'] + column_choice_training['Parch']
column_choice_test['Family'] = column_choice_test['SibSp'] + column_choice_test['Parch']
column_choice_training['Family'] = column_choice_training['Family'].replace([0], 'Alone')
column_choice_training['Family'] = colu... | Titanic - Machine Learning from Disaster |
3,017,668 | EMBEDDING_FILE = '.. /input/embeddings/wiki-news-300d-1M/wiki-news-300d-1M.vec'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE)if len(o)>100)
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_em... | X_train = np.asarray(column_choice_training.drop(['Survived'], axis=1))
X_train = preprocessing.StandardScaler().fit(X_train ).transform(X_train)
X_train[0:5] | Titanic - Machine Learning from Disaster |
3,017,668 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | X_test = np.asarray(column_choice_test)
X_test = preprocessing.StandardScaler().fit(X_test ).transform(X_test)
X_test[0:5] | Titanic - Machine Learning from Disaster |
3,017,668 | pred_fasttext_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_fasttext_val_y>thresh ).astype(int))))<predict_on_test> | y_train = np.asarray(column_choice_training['Survived'])
y_train[0:5] | Titanic - Machine Learning from Disaster |
3,017,668 | pred_fasttext_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | print('Train set:', X_train.shape,y_train.shape)
print('Test set:', X_test.shape ) | Titanic - Machine Learning from Disaster |
3,017,668 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | RFC = RandomForestClassifier(oob_score = True, random_state = 1)
param_grid = {'min_samples_leaf' : [1, 2, 4, 6, 8, 10],
'min_samples_split' : [2, 4, 6, 8, 10, 12, 14, 16],
'n_estimators': [200, 500, 800, 1100]}
param_distributions = param_grid,
n_iter = 100,
cv = cross_validation_split, verbose = 2, random_state = 0,... | Titanic - Machine Learning from Disaster |
3,017,668 | EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack(embeddings_index.... | param_grid = { 'criterion' : ['gini', 'entropy'],
'min_samples_leaf' : [1, 2, 3],
'min_samples_split' : [3, 4, 5],
'n_estimators': [1000, 1100, 1200]}
print(GS.best_score_)
print(GS.best_params_ ) | Titanic - Machine Learning from Disaster |
3,017,668 | model.fit(train_X, train_y, batch_size=512, epochs=2, validation_data=(val_X, val_y))<predict_on_test> | best_model = RandomForestClassifier(n_estimators=1000,
oob_score = True,
criterion = 'gini',
min_samples_leaf = 3,
min_samples_split = 8,
max_depth = None,
random_state = 1 ).fit(X_train,y_train)
yhat = best_model.predict(X_train)
print("%.4f" % best_model.oob_score_)
importance_df = pd.concat(( pd.DataFrame(column_... | Titanic - Machine Learning from Disaster |
3,017,668 | pred_paragram_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_paragram_val_y>thresh ).astype(int))))<predict_on_test> | yhat_test = best_model.predict(X_test)
submission = testing_df.copy()
submission['Survived'] = yhat_test
submission.to_csv('submission.csv', columns=['PassengerId', 'Survived'], index=False)
submission[['PassengerId', 'Survived']].head(15 ) | Titanic - Machine Learning from Disaster |
10,421,422 | pred_paragram_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | train_data=pd.read_csv('/kaggle/input/titanic/train.csv')
train_data | Titanic - Machine Learning from Disaster |
10,421,422 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<find_best_params> | test_data=pd.read_csv('/kaggle/input/titanic/test.csv')
test_data | Titanic - Machine Learning from Disaster |
10,421,422 | pred_val_y =(4 * pred_glove_val_y + pred_fasttext_val_y + 3 * pred_paragram_val_y + 2 * pred_cnn_val_y)/ 10.0
thresholds = []
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
res = metrics.f1_score(val_y,(pred_val_y > thresh ).astype(int))
thresholds.append([thresh, res])
print("F1 score at thr... | train_results = train_data["Survived"].copy()
train_data.drop("Survived", axis=1, inplace=True, errors="ignore")
titanic = pd.concat([train_data, test_data])
traindex = train_data.index
testdex = test_data.index | Titanic - Machine Learning from Disaster |
10,421,422 | pred_test_y =(4 * pred_glove_test_y + pred_fasttext_test_y + 3 * pred_paragram_test_y + 2 * pred_cnn_test_y)/ 10.0
pred_test_y =(pred_test_y > best_thresh ).astype(int)
out_df = pd.DataFrame({"qid":test_df["qid"].values})
out_df['prediction'] = pred_test_y
out_df.to_csv("submission.csv", index=False )<import_modules> | titanic[titanic['Cabin']=='B51 B53 B55']
| Titanic - Machine Learning from Disaster |
10,421,422 | tqdm.pandas()
sns.set_style('whitegrid' )<load_from_csv> | titanic.index=range(len(titanic))
| Titanic - Machine Learning from Disaster |
10,421,422 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape )<categorify> | titanic[pd.isnull(titanic['Fare'])] | Titanic - Machine Learning from Disaster |
10,421,422 | def load_embed(file):
def get_coefs(word,*arr):
return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(file, encoding='latin'))
return embeddings_index
<define_variables> | mean=titanic[titanic['Pclass']==3][titanic['Embarked']=='S'][titanic['Sex']=='male'][titanic['Age']>=40][titanic['SibSp']==0][titanic['Parch']==0]
mean['Fare'].describe() | Titanic - Machine Learning from Disaster |
10,421,422 | glove = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
<load_pretrained> | titanic[['Fare']]=titanic[['Fare']].fillna(value=7.69 ) | Titanic - Machine Learning from Disaster |
10,421,422 | embed_glove = load_embed(glove)
<feature_engineering> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,421,422 | def build_vocab(texts):
sentences = texts.apply(lambda x: x.split() ).values
vocab = {}
for sentence in sentences:
for word in sentence:
try:
vocab[word] += 1
except KeyError:
vocab[word] = 1
return vocab<define_variables> | titanic["Title"] = titanic.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(titanic['Title'], titanic['Sex'])
| Titanic - Machine Learning from Disaster |
10,421,422 | def check_coverage(vocab, embeddings_index):
known_words = {}
unknown_words = {}
nb_known_words = 0
nb_unknown_words = 0
for word in vocab.keys() :
try:
known_words[word] = embeddings_index[word]
nb_known_words += vocab[word]
except:
unknown_words[word] = vocab[word]
nb_unknown_words += vocab[word]
pass
print('Se encon... | titanic['Title'] = titanic['Title'].replace('Mlle', 'Miss')
titanic['Title'] = titanic['Title'].replace('Ms', 'Miss')
titanic['Title'] = titanic['Title'].replace('Mme', 'Mrs')
| Titanic - Machine Learning from Disaster |
10,421,422 | df = pd.concat([train_df ,test_df])
vocab = build_vocab(df['question_text'] )<compute_test_metric> | titanic['Title'] = titanic['Title'].replace(['Lady', 'Countess','Capt','Col','Don', 'Dr', 'Major','Rev', 'Sir', 'Jonkheer', 'Dona'], 'Not married' ) | Titanic - Machine Learning from Disaster |
10,421,422 | print("Glove : ")
oov_glove = check_coverage(vocab, embed_glove )<feature_engineering> | titanic['Title'] = titanic['Title'].replace(['Mr', 'Mrs'], 'Married' ) | Titanic - Machine Learning from Disaster |
10,421,422 | df['question_text'] = df['question_text'].apply(lambda x: x.lower() )<categorify> | titanic["Surname"] = titanic.Name.str.split(',' ).str.get(0 ) | Titanic - Machine Learning from Disaster |
10,421,422 | def add_lower(embedding, vocab):
count = 0
for word in vocab:
if word in embedding and word.lower() not in embedding:
embedding[word.lower() ] = embedding[word]
count += 1
print(f"Anadidas {count} palabras al embedding" )<categorify> | titanic=titanic.drop(['Name'],axis=1 ) | Titanic - Machine Learning from Disaster |
10,421,422 | print("Glove : ")
oov_glove = check_coverage(vocab, embed_glove)
add_lower(embed_glove, vocab)
oov_glove = check_coverage(vocab, embed_glove )<define_variables> | titanic.Surname.value_counts() | Titanic - Machine Learning from Disaster |
10,421,422 | contraction_mapping = {
"ain't": "is not",
"aren't": "are not",
"can't": "cannot",
"'cause": "because",
"could've": "could have",
"couldn't": "could not",
"didn't": "did not",
"doesn't": "does not",
"don't": "do not",
"hadn't": "had not",
"hasn't": "has not",
"haven't": "have not",
"he'd": "he would",
"he'll": "he will... | titanic['SurnameFreq']=titanic.groupby('Surname')['Surname'].transform('count')
| Titanic - Machine Learning from Disaster |
10,421,422 | def known_contractions(embed):
known = []
for contract in contraction_mapping:
if contract in embed:
known.append(contract)
return known<import_modules> | titanic.Ticket.value_counts()
| Titanic - Machine Learning from Disaster |
10,421,422 | print("- Contracciones Conocidas -")
print(" Glove :")
print(known_contractions(embed_glove))<string_transform> | titanic['TicketFreq']=titanic.groupby('Ticket')['Ticket'].transform('count')
| Titanic - Machine Learning from Disaster |
10,421,422 | def clean_contractions(text, mapping):
specials = ["’", "‘", "´", "`"]
for s in specials:
text = text.replace(s, "'")
text = ' '.join([mapping[t] if t in mapping else t for t in text.split(" ")])
return text<drop_column> | titanic['customizedFare']=titanic.Fare/(titanic.TicketFreq*titanic.Pclass ) | Titanic - Machine Learning from Disaster |
10,421,422 | df['question_text'] = df['question_text'].apply(lambda x: clean_contractions(x, contraction_mapping))<drop_column> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,421,422 | def unknown_punct(embed, punct):
unknown = ''
for p in punct:
if p not in embed:
unknown += p
unknown += ' '
return unknown<define_variables> | titanic.loc[(titanic.Age.isnull())&(titanic.Title=='Master'),'Age']=int(4.0 ) | Titanic - Machine Learning from Disaster |
10,421,422 | punct_mapping = {"‘": "'", "₹": "e", "´": "'", "°": "", "€": "e", "™": "tm", "√": " sqrt ", "×": "x", "²": "2", "—": "-", "–": "-", "’": "'", "_": "-", "`": "'", '“': '"', '”': '"', '“': '"', "£": "e", '∞': 'infinity', 'θ': 'theta', '÷': '/', 'α': 'alpha', '•': '.', 'à': 'a', '−': '-', 'β': 'beta', '∅': '', '³': '3', '... | titanic.loc[(titanic.Age.isnull())&(titanic.Sex=='male'),'Age']=int(30.0 ) | Titanic - Machine Learning from Disaster |
10,421,422 | def clean_special_chars(text, punct, mapping):
for p in mapping:
text = text.replace(p, mapping[p])
for p in punct:
text = text.replace(p, f' {p} ')
specials = {'\u200b': ' ', '…': '...', '\ufeff': '', 'करना': '', 'है': ''}
for s in specials:
text = text.replace(s, specials[s])
return text<feature_engineering> | titanic.loc[(titanic.Age.isnull())&(titanic.Sex=='female'),'Age']=int(27.0 ) | Titanic - Machine Learning from Disaster |
10,421,422 | df['question_text'] = df['question_text'].apply(lambda x: clean_special_chars(x, punct, punct_mapping))<compute_test_metric> | Titanic - Machine Learning from Disaster | |
10,421,422 | vocab = build_vocab(df['question_text'])
print("Glove : ")
oov_glove = check_coverage(vocab, embed_glove )<define_variables> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,421,422 | mispell_dict = {'advanatges': 'advantages',
'irrationaol': 'irrational' ,
'defferences': 'differences',
'lamboghini':'lamborghini',
'hypothical':'hypothetical',
'colour': 'color',
'centre': 'center',
'favourite': 'favorite',
'travelling': 'traveling',
'counselling': 'counseling',
'theatre': 'theater',
'cancelled': 'can... | titanic['Embarked'].fillna('S',inplace=True)
| Titanic - Machine Learning from Disaster |
10,421,422 | def correct_spelling(x, dic):
for word in dic.keys() :
x = x.replace(word, dic[word])
return x<feature_engineering> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,421,422 | df['question_text'] = df['question_text'].apply(lambda x: correct_spelling(x, mispell_dict))
<compute_test_metric> | titanic['Family']=titanic['SibSp']+titanic['Parch']+1
titanic=titanic.drop(['SibSp','Parch'],axis=1 ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.