kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,062,509 | df_train['question_text'] = df_train['question_text'].progress_apply(lambda x: correct_spelling(x, mispell_dict))
df_test['question_text'] = df_test['question_text'].apply(lambda x: correct_spelling(x, mispell_dict))
sentences= df_train['question_text'].progress_apply(lambda x : x.split())
sentences = [[word for word ... | forest_clf = RandomForestClassifier(random_state=42, n_estimators=10)
forest_scores = cross_val_score(forest_clf, X_train, y_train, cv=10)
forest_scores.mean() | Titanic - Machine Learning from Disaster |
2,062,509 | oov = check_coverage(vocab,embeddings1_index )<set_options> | sgd_clf = SGDClassifier(max_iter=100, random_state=42, tol=0.001)
sgd_scores = cross_val_score(sgd_clf, X_train, y_train, cv=10)
sgd_scores.mean() | Titanic - Machine Learning from Disaster |
2,062,509 | gc.collect()<define_variables> | knn_clf = KNeighborsClassifier(n_jobs=-1, weights='distance', n_neighbors=4)
knn_scores = cross_val_score(knn_clf, X_train, y_train, cv=10)
knn_scores.mean() | Titanic - Machine Learning from Disaster |
2,062,509 | len_voc = 95000
max_len =60<import_modules> | train_data['AgeBucket'] = train_data['Age'] // 15 * 15
train_data[['AgeBucket','Survived']].groupby(['AgeBucket'] ).mean() | Titanic - Machine Learning from Disaster |
2,062,509 | from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences<categorify> | train_data["RelativesOnboard"] = train_data["SibSp"] + train_data["Parch"]
pd.pivot_table(train_data, index="RelativesOnboard", values="Survived", aggfunc="mean" ) | Titanic - Machine Learning from Disaster |
2,062,509 | t = Tokenizer(num_words=len_voc, filters='')
t.fit_on_texts(df_train['question_text'])
X = t.texts_to_sequences(df_train['question_text'])
X_test=t.texts_to_sequences(df_test['question_text'])
X = pad_sequences(X, maxlen=max_len)
X_test = pad_sequences(X_test, maxlen=max_len)
word_index=t.word_index<prepare_x_and... | age_ix, sibsp_ix, parch_ix = 1, 2, 3
class CombinedAttributesAdder(BaseEstimator, TransformerMixin):
def __init__(self, add_attributes = True):
self.add_attributes = add_attributes
def fit(self, X, y=None):
return self
def transform(self, X, y=None):
if self.add_attributes:
age_bucket = X[:, age_ix] // 15 * 15
relative... | Titanic - Machine Learning from Disaster |
2,062,509 | y = df_train['target'].values<import_modules> | num_pipeline = Pipeline([
('selector', DataFrameSelector(["Age", "SibSp", "Parch", "Fare"])) ,
('imputer', SimpleImputer(strategy="median")) ,
('attribs_adder', CombinedAttributesAdder()),
('std_scaler', StandardScaler())
] ) | Titanic - Machine Learning from Disaster |
2,062,509 | from sklearn.model_selection import train_test_split<import_modules> | num_pipeline.fit_transform(train_data ) | Titanic - Machine Learning from Disaster |
2,062,509 | from sklearn.model_selection import train_test_split<split> | preprocess_pipeline = FeatureUnion(transformer_list=[
("num_pipeline", num_pipeline),
("cat_pipeline", cat_pipeline),
] ) | Titanic - Machine Learning from Disaster |
2,062,509 | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1, random_state=420 )<drop_column> | param_grid = [
{'n_estimators': [50, 100, 150],
'max_depth':[5, 10]}
]
forest_clf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(forest_clf, param_grid, cv=10, return_train_score=True)
grid_search.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
2,062,509 | del df_train<set_options> | cvres = grid_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):
print(mean_score, params ) | Titanic - Machine Learning from Disaster |
2,062,509 | gc.collect()<categorify> | grid_search.best_params_ | Titanic - Machine Learning from Disaster |
2,062,509 | def make_embed_matrix(embeddings_index, word_index, len_voc):
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]
word_index = word_index
embedding_matrix = np.random.normal(emb_mean, emb_std,(len_voc, embed_size))
for word, i in word_index.... | param_distribs = {
'n_estimators': randint(low=20, high=150),
'max_features': randint(low=5, high=12),
'max_depth': randint(low=5, high=12)
}
forest_clf = RandomForestClassifier(random_state=42)
forest_rnd_search = RandomizedSearchCV(forest_clf, param_distributions=param_distribs, n_iter=50, cv=10, return_train_score... | Titanic - Machine Learning from Disaster |
2,062,509 | embedding = make_embed_matrix(embeddings1_index, word_index, len_voc)
del word_index
gc.collect()<choose_model_class> | forest_rnd_search.best_params_ | Titanic - Machine Learning from Disaster |
2,062,509 | early = EarlyStopping(monitor='val_loss', mode="min", patience=2 )<choose_model_class> | cvres = forest_rnd_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):
print(mean_score, params ) | Titanic - Machine Learning from Disaster |
2,062,509 | lstm = Sequential()
lstm.add(Embedding(len_voc, 300, weights=[embedding], trainable=False))
lstm.add(Bidirectional(LSTM(units = 256, return_sequences= True)))
lstm.add(Dropout(rate = 0.2))
lstm.add(Conv1D(128, kernel_size = 3, padding = "valid", kernel_initializer = "glorot_uniform"))
lstm.add(GlobalMaxPooling1D())
l... | final_model = forest_rnd_search.best_estimator_ | Titanic - Machine Learning from Disaster |
2,062,509 | epochs = 3
batch_size = 128<train_model> | X_test = preprocess_pipeline.transform(test_data ) | Titanic - Machine Learning from Disaster |
2,062,509 | hist = lstm.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(X_val,y_val),callbacks=[early] )<import_modules> | y_pred = final_model.predict(X_test)
y_pred | Titanic - Machine Learning from Disaster |
2,062,509 | <predict_on_test><EOS> | test_data["Survived"] = y_pred
test_data[["PassengerId","Survived"]].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
1,598,434 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns | Titanic - Machine Learning from Disaster |
1,598,434 | pred_val_y =(pred_val_y > 0.50 ).astype(int )<compute_test_metric> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
data = train.append(test)
| Titanic - Machine Learning from Disaster |
1,598,434 | print(classification_report(y_val,pred_val_y))<compute_test_metric> | train.select_dtypes(int ).nunique() | Titanic - Machine Learning from Disaster |
1,598,434 | print(confusion_matrix(y_val,pred_val_y))<predict_on_test> | test.select_dtypes(int ).nunique()
| Titanic - Machine Learning from Disaster |
1,598,434 | pred_test=lstm.predict([X_test], batch_size=1024, verbose=0 )<data_type_conversions> | print('Empty values by column in Train ',(train.isnull().sum()))
| Titanic - Machine Learning from Disaster |
1,598,434 | pred_test =(pred_test > 0.50 ).astype(int )<create_dataframe> | print('Empty values by column in Test ',(test.isnull().sum()))
| Titanic - Machine Learning from Disaster |
1,598,434 | out_df = pd.DataFrame({"qid":df_test["qid"].values} )<prepare_output> | data['Title'] = data['Name']
for name_string in data['Name']:
data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'M... | Titanic - Machine Learning from Disaster |
1,598,434 | out_df['prediction'] = pred_test<save_to_csv> | data['Family_Size'] = data['Parch'] + data['SibSp']
train['Family_Size'] = data['Family_Size'][:891]
test['Family_Size'] = data['Family_Size'][891:] | Titanic - Machine Learning from Disaster |
1,598,434 | out_df.to_csv("submission.csv", index=False )<import_modules> | drop_column = [ 'Cabin', 'Ticket', 'Parch', 'SibSp', 'Name', 'Embarked'] | Titanic - Machine Learning from Disaster |
1,598,434 | ps = PorterStemmer()
lc = LancasterStemmer()
sb = SnowballStemmer("english")
def read_LSTM(reset_data):
max_length = 50
if(reset_data or not os.path.exists('lstm_data_vector.npy')or not os.path.exists("lstm_labels_vector.npy")or not os.path.exists("lstm_qid_vector.npy")) :
start_time = time.time()
train = pd.read_csv(... | train.drop(drop_column, axis = 1, inplace = True)
test.drop(drop_column, axis = 1, inplace = True)
| Titanic - Machine Learning from Disaster |
1,598,434 | import pandas as pd
import numpy as np
from sklearn.model_selection import StratifiedKFold
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.layers import *
from keras.models import *
from keras import initializers, regularizers, constraints, optimizers, la... | mapping = {'male':1, 'female':0}
train['Sex'] = train['Sex'].replace(mapping ).astype(np.float64)
test['Sex'] = test['Sex'].replace(mapping ).astype(np.float64 ) | Titanic - Machine Learning from Disaster |
1,598,434 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
print("Train shape : ", train.shape)
print("Test shape : ", test.shape )<feature_engineering> | test['Fare'].fillna(value = test['Fare'].mode() [0], inplace = True)
| Titanic - Machine Learning from Disaster |
1,598,434 | train["question_text"] = train["question_text"].str.lower()
test["question_text"] = test["question_text"].str.lower()
puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', ... | def detect_outliers(df,n,features):
outlier_indices = []
for col in features:
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col],75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = df[(df[col] < Q1 - outlier_step)|(df[col] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outlier... | Titanic - Machine Learning from Disaster |
1,598,434 | embed_size = 300
max_features = None
maxlen = 72
X = train["question_text"].fillna(" " ).values
X_test = test["question_text"].fillna(" " ).values
tokenizer = Tokenizer(num_words=max_features, filters='')
tokenizer.fit_on_texts(list(X))
X = tokenizer.texts_to_sequences(X)
X_test = tokenizer.texts_to_sequences(X_test)... | features = ["Pclass", "Sex", "Age", "Fare", "Family_Size"]
X_train = train[features]
y_train = train["Survived"]
X_test = test[features]
| Titanic - Machine Learning from Disaster |
1,598,434 | del train, test
gc.collect()<statistical_test> | X_training, X_valid, y_training, y_valid = train_test_split(X_train, y_train, test_size=0.2, random_state=0)
| Titanic - Machine Learning from Disaster |
1,598,434 | word_index = tokenizer.word_index
max_features = len(word_index)+1
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')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FIL... | from sklearn.model_selection import cross_val_score
from sklearn.metrics import f1_score, make_scorer
from sklearn.ensemble import RandomForestClassifier
| Titanic - Machine Learning from Disaster |
1,598,434 | embedding_matrix_1 = load_glove(word_index)
embedding_matrix_2 = load_para(word_index)
embedding_matrix = np.mean(( embedding_matrix_1, embedding_matrix_2), axis=0)
del embedding_matrix_1, embedding_matrix_2
gc.collect()
np.shape(embedding_matrix )<normalization> | scorer = make_scorer(f1_score, greater_is_better=True, average = 'macro')
warnings.filterwarnings('ignore', category = ConvergenceWarning)
warnings.filterwarnings('ignore', category = DeprecationWarning)
warnings.filterwarnings('ignore', category = UserWarning ) | Titanic - Machine Learning from Disaster |
1,598,434 | def squash(x, axis=-1):
s_squared_norm = K.sum(K.square(x), axis, keepdims=True)
scale = K.sqrt(s_squared_norm + K.epsilon())
return x / scale
class Capsule(Layer):
def __init__(self, num_capsule, dim_capsule, routings=3, kernel_size=(9, 1), share_weights=True,
activation='default', **kwargs):
super(Capsule, self )._... | model_results = pd.DataFrame(columns = ['model', 'cv_mean', 'cv_std'])
def cv_model(X_train, y_train, model, name, model_results = None, sort = True):
cv_scores = cross_val_score(model, X_train, y_train, cv = 10,
scoring = scorer, n_jobs = -1)
print('Mean ', round(cv_scores.mean() , 5),'STd', round(cv_scores.std() , ... | Titanic - Machine Learning from Disaster |
1,598,434 | 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... | xg_clf = XGBClassifier()
parameters_rf = {'n_estimators' : [200],'learning_rate': [0.1],
'max_depth': [4], "min_child_weight":[6], "gamma":[0], "subsample":[0.80]
}
grid_rf = GridSearchCV(xg_clf, parameters_rf, scoring=make_scorer(accuracy_score))
grid_rf.fit(X_training, y_training)
xg_clf = grid_rf.best_estimator_
pr... | Titanic - Machine Learning from Disaster |
1,598,434 | def capsule() :
K.clear_session()
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix], trainable=False )(inp)
x = SpatialDropout1D(rate=0.22 )(x)
x = Bidirectional(CuDNNGRU(100, return_sequences=True,))(x)
x = Capsule(num_capsule=10, dim_capsule=10, routings=4, share_weigh... | rf_clf = RandomForestClassifier()
parameters_rf = {"n_estimators": [4, 5, 6, 7, 8, 9, 10, 15], "criterion": ["gini", "entropy"], "max_features": ["auto", "sqrt", "log2"],
"max_depth": [2, 3, 5, 10], "min_samples_split": [2, 3, 5, 10]}
grid_rf = GridSearchCV(rf_clf, parameters_rf, scoring=make_scorer(accuracy_score))
gr... | Titanic - Machine Learning from Disaster |
1,598,434 | <split><EOS> | submission_predictions = rf_clf.predict(X_test)
submission = pd.DataFrame({"PassengerId": test["PassengerId"],
"Survived": submission_predictions})
submission.to_csv("titanicprediction.csv", index=False)
print(submission.shape ) | Titanic - Machine Learning from Disaster |
1,261,350 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline | Titanic - Machine Learning from Disaster |
1,261,350 | y_test = y_test.reshape(( -1, 1))
pred_test_y =(y_test>np.mean(bestscore)).astype(int)
sub['prediction'] = pred_test_y
sub.to_csv("submission.csv", index=False )<set_options> | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv')
full_data = train_data.append(test_data, ignore_index=True, sort=False)
full_data.head() | Titanic - Machine Learning from Disaster |
1,261,350 | warnings.filterwarnings("ignore" )<load_from_csv> | full_data[['Pclass', 'Survived']].groupby(['Pclass'], as_index=True ).mean() | Titanic - Machine Learning from Disaster |
1,261,350 | train = pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
test = pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
submission = pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv" )<data_type_conversions> | pclass = pd.get_dummies(data=full_data.Pclass, prefix='Pclass', drop_first=False)
pclass.head() | Titanic - Machine Learning from Disaster |
1,261,350 | train['Date'] = pd.to_datetime(train['Date'])
test['Date'] = pd.to_datetime(test['Date'] )<feature_engineering> | full_data[['Sex', 'Survived']].groupby(['Sex'], as_index=True ).mean() | Titanic - Machine Learning from Disaster |
1,261,350 | train = train[train['Date']<='2020-04-14']
train['part'] = 'train'
test['part'] = 'test'<data_type_conversions> | sex = pd.DataFrame(data=full_data.Sex.map({'female': '1', 'male': '0'} ).astype('int'), columns=['Sex'])
sex.head() | Titanic - Machine Learning from Disaster |
1,261,350 | train['Location'] = train['Province_State'].astype(str)+ train['Country_Region'].astype(str)
test['Location'] = test['Province_State'].astype(str)+ test['Country_Region'].astype(str )<merge> | full_data[['Embarked', 'Survived']].groupby(['Embarked'], as_index=True ).mean() | Titanic - Machine Learning from Disaster |
1,261,350 | test = test.merge(train[['ConfirmedCases','Fatalities','Location','Date']],how='left',on=['Location','Date'] )<filter> | full_data.loc[full_data.Embarked.isnull() , :] | Titanic - Machine Learning from Disaster |
1,261,350 | train = train[train['Date']<='2020-04-01']<concatenate> | embarked = pd.get_dummies(data=full_data.Embarked.fillna('C'), prefix='Embarked')
embarked.head() | Titanic - Machine Learning from Disaster |
1,261,350 | data = pd.concat([train,test],axis=0)
data = data.sort_values(['Country_Region','Date'] )<categorify> | full_data['Title'] = full_data.Name.str.extract('([A-Za-z]+)\.', expand=False)
full_data[['Title', 'Sex', 'Survived']].groupby(['Sex','Title'], as_index=True ).mean() | Titanic - Machine Learning from Disaster |
1,261,350 | data = data.melt(id_vars=['ForecastId','Date','Location','part'],value_vars=['ConfirmedCases','Fatalities'],value_name='Target' ).sort_values(['Location','Date'] )<feature_engineering> | Title_Dictionary = {"Capt": "Mr",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Mr",
"Don": "Mr",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Mr",
"Countess": "Royalty",
"Dona": "Mrs",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Officer",
"Lady" : "Royalty"}
... | Titanic - Machine Learning from Disaster |
1,261,350 | data['Day'] = data['Date'].astype(str ).apply(lambda x: int(''.join(x.split('-')[1:])))
data['Month'] = data.Date.dt.month<categorify> | title = pd.get_dummies(full_data.Title)
title.head() | Titanic - Machine Learning from Disaster |
1,261,350 | data['lag_1'] = data.groupby(['Location','variable'])['Target'].transform(lambda x: x.shift(1))
data['lag_2'] = data.groupby(['Location','variable'])['Target'].transform(lambda x: x.shift(2))
data['lag_3'] = data.groupby(['Location','variable'])['Target'].transform(lambda x: x.shift(3))
data['lag_4'] = data.groupby(['L... | full_data[full_data.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
1,261,350 | data['Diff1'] = data['lag_1'] - data['lag_2']
data['Diff2'] = data['lag_2'] - data['lag_3']
data['Diff3'] = data['lag_3'] - data['lag_4']
data['Diffavg'] =(data['Diff1'] + data['Diff2'] +data['Diff3'])/3<feature_engineering> | test_data[["Pclass", "Fare", "Embarked"]].groupby(["Pclass", "Embarked"] ).mean() | Titanic - Machine Learning from Disaster |
1,261,350 | data["Inc1"] =(data['Diff1'] / data['lag_2'])*100
data["Inc2"] =(data['Diff2'] / data['lag_3'])*100
data["Inc3"] =(data['Diff3'] / data['lag_4'])*100
data['Incavg'] =(data['Inc1'] + data['Inc2'] +data['Inc3'])/3<drop_column> | fare = pd.DataFrame(data=full_data.Fare.fillna(13.9))
mu_fare = fare.Fare.mean()
sigma_fare =(((fare.Fare-mu_fare)**2 ).mean())**0.5
fare.Fare =(fare.Fare - mu_fare)/ sigma_fare | Titanic - Machine Learning from Disaster |
1,261,350 | data = data[data['Date']>'2020-02-19']
data.drop(['Diff1','Diff2','Diff3'],axis=1,inplace=True )<categorify> | age = pd.DataFrame(data=grouped.Age.apply(lambda x: x.fillna(x.median())))
mu_a = age.Age.mean()
sigma_a =(((age.Age-mu_a)**2 ).mean())**0.5
age.Age =(age.Age - mu_a)/ sigma_a | Titanic - Machine Learning from Disaster |
1,261,350 | encoderloc = LabelEncoder()
encodervar = LabelEncoder()
data['Location'] = encoderloc.fit_transform(data['Location'])
data['variable'] = encodervar.fit_transform(data['variable'])
data.head()<define_variables> | cabin = pd.DataFrame()
cabin['Cabin'] = full_data.Cabin.fillna('U')
cabin['Cabin'] = cabin.Cabin.map(lambda x: x[0])
cabin = pd.get_dummies(cabin, drop_first=False)
cabin.head() | Titanic - Machine Learning from Disaster |
1,261,350 | features = ['Day','Location','variable','lag_1','lag_2','Diffavg','Inc1','Inc2','Incavg','Month']<prepare_x_and_y> | family = pd.DataFrame()
family['FamilySize'] = full_data['Parch'] + full_data['SibSp'] + 1
family['Family_Single'] = family['FamilySize'].map(lambda s: 1 if s == 1 else 0)
family['Family_Small'] = family['FamilySize'].map(lambda s: 1 if 2 <= s <= 4 else 0)
family['Family_Large'] = family['FamilySize'].map(lambda s: 1... | Titanic - Machine Learning from Disaster |
1,261,350 | x_train = data[data['Date']<='2020-04-14']
y_train = x_train['Target']
x_val = data[(data['Date']>='2020-04-02')&(data['Date']<='2020-04-14')]
y_val = x_val['Target']
test_ = data[data['part']=='test']
<import_modules> | features = pd.concat([pclass, sex, embarked, title, fare, age, cabin, family] , axis=1)
features.head() | Titanic - Machine Learning from Disaster |
1,261,350 | from xgboost import DMatrix,train,plot_importance,XGBRegressor<init_hyperparams> | labels = train_data.Survived
train_features, val_features, train_labels, val_labels = train_test_split(features[:891],
labels,
test_size = 0.2)
test_features = features[891:]
train_features.shape, train_labels.shape, val_features.shape, val_labels.shape, test_features.shape | Titanic - Machine Learning from Disaster |
1,261,350 | params = {'objective': 'reg:squarederror',
'n_jobs': -1,
'seed': 236,
}
<import_modules> | m_train = train_features.shape[0]
m_val = val_features.shape[0]
m_test = test_features.shape[0]
n = train_features.shape[1]
print(f" m_train = {m_train} / m_val = {m_val} / m_test = {m_test}, n = {n}" ) | Titanic - Machine Learning from Disaster |
1,261,350 | from tqdm import tqdm<feature_engineering> | layer_dims = [n, 7, 7, 1] | Titanic - Machine Learning from Disaster |
1,261,350 | def feature(test_,ctr):
if ctr==1:
lags = [1]
elif ctr==2:
lags = [1,2]
elif ctr==3:
lags = [1,2,3]
else:
lags = [1,2,3,4]
for i in lags:
test_['lag_'+str(i)] = test_.groupby(['Location','variable'])['Target'].transform(lambda x: x.shift(i))
test_['Diff1'] = test_['lag_1'] - test_['lag_2']
test_['Diff2'] = test_['lag_2... | k_model = Sequential()
k_model.add(Dense(layer_dims[1], activation='relu',
kernel_regularizer=l2(0.01),
input_dim=n))
k_model.add(Dense(layer_dims[2], activation='relu',
kernel_regularizer=l2(0.01)))
k_model.add(Dense(layer_dims[3], activation='sigmoid',
kernel_regularizer=l2(0.01)))
k_model.compile(optimizer=Adam(lr... | Titanic - Machine Learning from Disaster |
1,261,350 | train_set = DMatrix(x_train[features],y_train)
val_set = DMatrix(x_val[features],y_val)
model = train(params,train_set,num_boost_round=100,evals=[(val_set,'validation')],verbose_eval=50)
ctr = 1
for j in days:
test_set = DMatrix(test_[test_['Day']==j][features])
test_.loc[test_['Day']==j,'Target'] = model.predict(t... | X_train = train_features.T.values
Y_train = train_labels.T.values.reshape(1, train_labels.shape[0])
X_val = val_features.T.values
Y_val = val_labels.T.values.reshape(1, val_labels.shape[0])
X_test = test_features.T.values
X_train.shape, Y_train.shape, X_val.shape, Y_val.shape, X_test.shape | Titanic - Machine Learning from Disaster |
1,261,350 | sub = test_[['ForecastId','variable','Target']]<create_dataframe> | def random_mini_batches(X, Y, batch_size):
m_train = X.shape[1]
mini_batches = []
permutation = list(np.random.permutation(m_train))
shuffled_X = X[:, permutation]
shuffled_Y = Y[:, permutation].reshape(( 1,m_train))
num_complete_minibatches = m_train // batch_size
for k in range(0, num_complete_minibatches):
mini_ba... | Titanic - Machine Learning from Disaster |
1,261,350 | sub = pd.pivot(sub,index='ForecastId',columns='variable',values='Target' ).reset_index()<data_type_conversions> | class Custom_model(object):
def __init__(self, layer_dims):
self.layer_dims = layer_dims
self.num_layers = len(layer_dims)
self.parameters = {}
for l in range(1, len(layer_dims)) :
self.parameters[f"W{l}"] = np.random.randn(layer_dims[l], layer_dims[l-1])*0.01
self.parameters[f"b{l}"] = np.zeros(( layer_dims[l], 1))... | Titanic - Machine Learning from Disaster |
1,261,350 | sub['ForecastId'] = sub['ForecastId'].astype(int)
sub.columns = ['ForecastId','ConfirmedCases','Fatalities']<save_to_csv> | records_list = [] | Titanic - Machine Learning from Disaster |
1,261,350 | sub.to_csv("submission.csv",index=False )<load_from_csv> | c_model = Custom_model(layer_dims)
lr = 1e-1
min_lr = 1e-7
optimizer = 'adam'
batch_size = m_train
num_epochs = 300
lambd = 5e+0
c_model.fit(X_train, Y_train, batch_size=batch_size, num_epochs=num_epochs,
lr=lr, lambd=lambd, optimizer=optimizer, print_cost=True)
predict_train = c_model.predict(X_train)
c_train_acc =... | Titanic - Machine Learning from Disaster |
1,261,350 | <create_dataframe><EOS> | c_model_final = Custom_model(layer_dims)
X = np.concatenate(( X_train, X_val), axis=1)
Y = np.concatenate(( Y_train, Y_val), axis=1)
c_model_final.fit(X, Y, batch_size=(m_train + m_val), num_epochs=num_epochs,
lr=lr, min_lr=min_lr, lambd=lambd,
optimizer=optimizer, print_cost=True)
prediction = c_model_final.predic... | Titanic - Machine Learning from Disaster |
977,015 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<data_type_conversions> | %matplotlib inline
warnings.filterwarnings("always")
| Titanic - Machine Learning from Disaster |
977,015 | trainingdate = pd.to_datetime(trainingdata["Date"])
testdate = pd.to_datetime(testdata["Date"])
print(trainingdate )<categorify> | DATASETS_DIRECTORY = ".. /input"
train_data = pd.read_csv(os.path.join(DATASETS_DIRECTORY, "train.csv"))
test_data = pd.read_csv(os.path.join(DATASETS_DIRECTORY, "test.csv"))
full_data = pd.concat([train_data,test_data])
targets = train_data["Survived"]
train_data.drop("Survived", axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
977,015 | m = []
d = []
for i in range(0,ltrainingdate):
dx =(trainingdate[i].strftime("%d"))
mx =(trainingdate[i].strftime("%m"))
m.append(int(mx))
d.append(int(dx))
mt = []
dt = []
for i in range(0,ltestdate):
dtx =(testdate[i].strftime("%d"))
mtx =(testdate[i].strftime("%m"))
mt.append(int(mtx))
dt.append(int(dtx))
<categori... | class CategoricalEncoder(BaseEstimator, TransformerMixin):
def __init__(self, encoding='onehot', categories='auto', dtype=np.float64,
handle_unknown='error'):
self.encoding = encoding
self.categories = categories
self.dtype = dtype
self.handle_unknown = handle_unknown
def fit(self, X, y=None):
if self.encoding not ... | Titanic - Machine Learning from Disaster |
977,015 | m = []
d = []
for i in range(0,ltrainingdate):
dx =(trainingdate[i].strftime("%d"))
mx =(trainingdate[i].strftime("%m"))
m.append(int(mx))
d.append(int(dx))
mt = []
dt = []
for i in range(0,ltestdate):
dtx =(testdate[i].strftime("%d"))
mtx =(testdate[i].strftime("%m"))
mt.append(int(mtx))
dt.append(int(dtx))
<feature_... | full_pipeline = Pipeline(steps=[
("features", make_union(
make_pipeline(DataFrameSelector(["Embarked"]), MostFrequentImputer() , CategoricalEncoder(encoding='onehot-dense')) ,
make_pipeline(DataFrameSelector(["Pclass", "Sex"]), CategoricalEncoder(encoding='onehot-dense')) ,
make_pipeline(DataFrameSelector(["Age", "Fa... | Titanic - Machine Learning from Disaster |
977,015 | train.insert(6,"Month",m,False)
train.insert(7,"Day",d,False)
test.insert(4,"Month",mt,False)
test.insert(5,"Day",dt,False )<count_unique_values> | X_train, X_test, y_train, y_test = train_test_split(train_data, targets, test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
977,015 | print("Training Data")
traindays = trainingdata['Date'].nunique()
print("Number of Country_Region: ", trainingdata['Country_Region'].nunique())
print("Number of Province_State: ", trainingdata['Province_State'].nunique())
print("Number of Days: ", traindays)
notrain = trainingdata['Id'].nunique()
print("Number of d... | param_grid = [
{
'clf__bootstrap':[True],
'clf__max_depth':[80],
'clf__max_features':[2],
'clf__min_samples_leaf':[4],
'clf__min_samples_split':[10],
'clf__n_estimators':[100]
},
]
grid_search = GridSearchCV(full_pipeline, param_grid, cv=5, scoring='roc_auc', refit=True)
grid_search.fit(X_train, y_train)
final_model ... | Titanic - Machine Learning from Disaster |
977,015 | print("Test Data")
testdays = testdata['Date'].nunique()
print("Number of Days: ", testdays)
notest = testdata['ForecastId'].nunique()
print("Number of datapoints in test:", notest)
lotest = int(notest/testdays)
print("L Test:", lotest)
<define_variables> | y_scores = cross_val_predict(final_model, X_test, y_test, cv=5, method="predict_proba")
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:, 1] ) | Titanic - Machine Learning from Disaster |
977,015 | zt = testdate[0]
daycount = []
for i in range(0,lotrain):
for j in range(1,traindays+1):
daycount.append(j)
<define_variables> | print('Best accuracy: %.3f' % grid_search.best_score_ ) | Titanic - Machine Learning from Disaster |
977,015 | <prepare_output><EOS> | final_predictions = final_model.predict(test_data)
output = pd.DataFrame({ 'PassengerId' : test_data["PassengerId"], 'Survived': final_predictions })
output.to_csv('titanic-predictions.csv', index = False)
output.head() | Titanic - Machine Learning from Disaster |
12,021,502 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np | Titanic - Machine Learning from Disaster |
12,021,502 | traincount = int(len(train["Date"]))
testcount = int(len(test["Date"]))
<categorify> | train = pd.read_csv('.. /input/titanic/train.csv' ) | Titanic - Machine Learning from Disaster |
12,021,502 | train.Province_State = train.Province_State.fillna(0)
empty = 0
for i in range(0,traincount):
if(train.Province_State[i] == empty):
train.Province_State[i] = train.Country_Region[i]<categorify> | train.loc[train['Age']>=18,'Adult']=1
train.loc[train['Age']<18,'Adult']=0 | Titanic - Machine Learning from Disaster |
12,021,502 | test.Province_State = test.Province_State.fillna(0)
empty = 0
for i in range(0,testcount):
if(test.Province_State[i] == empty):
test.Province_State[i] = test.Country_Region[i]<categorify> | train.loc[train['Fare']>=31,'Rich']=1
train.loc[train['Fare']<31,'Rich']=0 | Titanic - Machine Learning from Disaster |
12,021,502 | label = preprocessing.LabelEncoder()
train.Country_Region = label.fit_transform(train.Country_Region)
train.Province_State = label.fit_transform(train.Province_State )<categorify> | train.drop(['PassengerId','Name','SibSp','Parch','Ticket','Cabin','Age','Fare'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
12,021,502 | test.Country_Region = label.fit_transform(test.Country_Region)
test.Province_State = label.fit_transform(test.Province_State)
<prepare_x_and_y> | train = pd.get_dummies(train,drop_first=True ) | Titanic - Machine Learning from Disaster |
12,021,502 | X = np.c_[train["Province_State"], train["Country_Region"], train["DayCount"], train["Month"], train["Day"]]
Xt = np.c_[test["Province_State"], test["Country_Region"], test["DayCount"], test["Month"], test["Day"]]<prepare_x_and_y> | train.count() | Titanic - Machine Learning from Disaster |
12,021,502 | Y1 = train["ConfirmedCases"]
Y2 = train["Fatalities"]<choose_model_class> | train = train.astype(np.int ) | Titanic - Machine Learning from Disaster |
12,021,502 | regr = XGBRegressor(n_estimators = 1500, gamma = 0, learning_rate = 0.8, random_state = 42, max_depth = 50, subsample = 1, reg_lambda = 0, reg_alpha = 0.5)
regr1 = XGBRegressor(n_estimators = 1500, gamma = 0, learning_rate = 0.8, random_state = 42, max_depth = 50, subsample = 1, reg_lambda = 0, reg_alpha = 0.5 )<compu... | test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,021,502 | def rmsle(y_true, y_pred):
return mean_squared_log_error(y_true, y_pred)**(1/2);<train_model> | test.loc[test['Age']>=18,'Adult']=1
test.loc[test['Age']<18,'Adult']=0
test.loc[test['Fare']>=31,'Rich']=1
test.loc[test['Fare']<31,'Rich']=0 | Titanic - Machine Learning from Disaster |
12,021,502 | regr.fit(X,Y1.ravel())
yscore = regr.predict(X)
a = abs(yscore)
b=abs(Y1)
ascore =(rmsle(a,b))
print("RMSLE of Confirmed Cases is ",ascore )<predict_on_test> | test.drop(['PassengerId','Name','SibSp','Parch','Ticket','Cabin','Age','Fare'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
12,021,502 | ypred = regr.predict(Xt)
ypred = pd.DataFrame({'ConfirmedCases' : ypred})
ypred = round(ypred)
ypred.head(20 )<compute_test_metric> | test = pd.get_dummies(test,drop_first=True ) | Titanic - Machine Learning from Disaster |
12,021,502 | regr1.fit(X,Y2.ravel())
ypred2 = regr1.predict(Xt)
yptest = regr1.predict(X)
yptest = np.round(yptest)
c = abs(yptest)
d = abs(Y2)
ascore = rmsle(c,d)
print("RMSLE of Fatalities is", ascore)
<prepare_output> | test = test.astype(np.int ) | Titanic - Machine Learning from Disaster |
12,021,502 | ypred2 = pd.DataFrame({'Fatalities' : ypred2})
ypred2 = round(ypred2)
ypred2.head(20 )<create_dataframe> | test.count() | Titanic - Machine Learning from Disaster |
12,021,502 | ypc = pd.DataFrame()
forecast = test["ForecastId"]<prepare_output> | x_train = train.drop('Survived',axis=1)
y_train = train['Survived']
x_test = test | Titanic - Machine Learning from Disaster |
12,021,502 | ypc.insert(0,"ForecastId",forecast,False)
ypc.insert(1,"ConfirmedCases",ypred,False)
ypc.insert(2, "Fatalities",ypred2,False )<save_to_csv> | model = LogisticRegression() | Titanic - Machine Learning from Disaster |
12,021,502 | ypc.to_csv('submission.csv', index=False )<string_transform> | model.fit(x_train,y_train ) | Titanic - Machine Learning from Disaster |
12,021,502 | dim = 300
num_words = 50000
max_len = 100
print('Fiting tokenizer')
tokenizer = Tokenizer(num_words=num_words)
tokenizer.fit_on_texts(df['question_text'])
print('spliting data')
df_train,df_test = train_test_split(df, random_state=1)
print('text to sequence')
x_train = tokenizer.texts_to_sequences(df_train['quest... | y_pred = model.predict(x_test ) | Titanic - Machine Learning from Disaster |
12,021,502 | print('loading word2vec model...')
word2vec = gensim.models.KeyedVectors.load_word2vec_format('.. /input/embeddings/GoogleNews-vectors-negative300/GoogleNews-vectors-negative300.bin', binary=True)
print('vocab:',len(word2vec.vocab))
all_embs = word2vec.vectors
emb_mean,emb_std = all_embs.mean() , all_embs.std()
print... | s = pd.read_csv(".. /input/titanic/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
12,021,502 | print('Glove...')
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
prin... | f = {"PassengerId":s["PassengerId"],"Survived":y_pred}
f = pd.DataFrame(f ) | Titanic - Machine Learning from Disaster |
12,021,502 | <statistical_test><EOS> | f.to_csv('output.csv',index=False ) | Titanic - Machine Learning from Disaster |
11,312,907 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | !pip install pyspark | 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.