kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,593,543 | test_path = ".. /input/test/"<save_to_csv> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,593,543 | def chunker(seq, size=32):
return(seq[pos:pos + size] for pos in range(0, len(seq), size))
submission = pd.read_csv('.. /input/sample_submission.csv')
predictions = []
for batch in tqdm(chunker(submission.img_pair.values)) :
X1 = [x.split("-")[0] for x in batch]
X1 = np.array([read_img(test_path + x)for x in X1])
X2 ... | Fare_test_series=df_test.groupby(['Pclass'])['Fare'].transform('median')
df_test['Fare']=df_test['Fare'].fillna(Fare_test_series ) | Titanic - Machine Learning from Disaster |
14,593,543 | import numpy as np
import pandas as pd
import os
from collections import defaultdict
from glob import glob
from random import choice, sample
from keras.preprocessing import image
import cv2
from tqdm import tqdm_notebook
import numpy as np
import pandas as pd
from keras.callbacks import ModelCheckpoint, ReduceLROnPlate... | df_train=pd.get_dummies(df_train,drop_first=True)
| Titanic - Machine Learning from Disaster |
14,593,543 | !pip install git+https://github.com/rcmalli/keras-vggface.git<import_modules> | df_test=pd.get_dummies(df_test,drop_first=True ) | Titanic - Machine Learning from Disaster |
14,593,543 | from keras_vggface.utils import preprocess_input
from keras_vggface.vggface import VGGFace<define_variables> | X=df_train.drop('Survived',axis=1)
y=df_train['Survived'] | Titanic - Machine Learning from Disaster |
14,593,543 | train_file_path = ".. /input/train_relationships.csv"
train_folders_path = ".. /input/train/"<define_variables> | X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42 ) | Titanic - Machine Learning from Disaster |
14,593,543 | val_famillies_list = ["F07", "F08", "F09"]
<define_variables> | from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
14,593,543 | %%time
all_images = glob(train_folders_path + "*/*/*.jpg" )<define_variables> | dt=DecisionTreeClassifier(random_state=42 ) | Titanic - Machine Learning from Disaster |
14,593,543 | def get_train_val(family_name):
val_famillies = family_name
train_images = [x for x in all_images if val_famillies not in x]
val_images = [x for x in all_images if val_famillies in x]
train_person_to_images_map = defaultdict(list)
ppl = [x.split("/")[-3] + "/" + x.split("/")[-2] for x in all_images]
for x in train_ima... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
14,593,543 | def read_img(path):
img = image.load_img(path, target_size=(197, 197))
img = np.array(img ).astype(np.float)
return preprocess_input(img, version=2)
def gen(list_tuples, person_to_images_map, batch_size=16):
ppl = list(person_to_images_map.keys())
while True:
batch_tuples = sample(list_tuples, batch_size // 2)
labe... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
14,593,543 | n_val_famillies_list = len(val_famillies_list )<train_on_grid> | params = {
'max_depth': [3,5,8,12,15],
'min_samples_leaf': [5,8,12,15,20],
'criterion': ["gini", "entropy"]
} | Titanic - Machine Learning from Disaster |
14,593,543 | for i in tqdm_notebook(range(n_val_famillies_list)) :
train, val, train_person_to_images_map, val_person_to_images_map = get_train_val(val_famillies_list[i])
file_path = f"vgg_face_{i}.h5"
checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
reduce_on_plateau = Reduce... | grid_search = GridSearchCV(estimator=dt,
param_grid=params,
cv=4, n_jobs=-1, verbose=1, scoring = "accuracy" ) | Titanic - Machine Learning from Disaster |
14,593,543 | test_path = ".. /input/test/"
submission = pd.read_csv('.. /input/sample_submission.csv')
def chunker(seq, size=32):
return(seq[pos:pos + size] for pos in range(0, len(seq), size))<predict_on_test> | grid_search.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
14,593,543 | preds_for_sub = np.zeros(submission.shape[0])
for i in tqdm_notebook(range(n_val_famillies_list)) :
file_path = f"vgg_face_{i}.h5"
model.load_weights(file_path)
predictions = []
for batch in tqdm_notebook(chunker(submission.img_pair.values)) :
X1 = [x.split("-")[0] for x in batch]
X1 = np.array([read_img(test_path + ... | grid_search.cv_results_ | Titanic - Machine Learning from Disaster |
14,593,543 | submission['is_related'] = preds_for_sub
submission.to_csv("vgg_face.csv", index=False )<load_from_csv> | score_df = pd.DataFrame(grid_search.cv_results_)
score_df.head() | Titanic - Machine Learning from Disaster |
14,593,543 | sub1 = pd.read_csv('.. /input/smiles/vgg_face.csv')
sub2 = pd.read_csv('.. /input/smiles/vgg_face(1 ).csv')
sub3 = pd.read_csv('.. /input/smiles/submission(1 ).csv')
temp=pd.read_csv('.. /input/smiles/submission(1 ).csv')
<save_to_csv> | score_df.nlargest(5,"mean_test_score" ) | Titanic - Machine Learning from Disaster |
14,593,543 | temp['is_related'] = 0.60*sub1['is_related'] + 0.22*sub2['is_related'] + 0.18*sub3['is_related']
temp.to_csv('submission4.csv', index=False )<define_variables> | grid_search.best_estimator_ | Titanic - Machine Learning from Disaster |
14,593,543 | !pip install git+https://github.com/rcmalli/keras-vggface.git
train_file_path = ".. /input/train_relationships.csv"
train_folders_path = ".. /input/train/"
val_famillies_list = ["F07", "F08", "F09"]
all_images = glob(train_folders_path + "*/*/*.jpg")
relationships = pd.read_csv(train_file_path)
def get_train_val(fami... | dt_best=grid_search.best_estimator_ | Titanic - Machine Learning from Disaster |
14,593,543 | val_acc_list = []
def train_model1() :
for i in tqdm_notebook(range(n_val_famillies_list)) :
train, val, train_person_to_images_map, val_person_to_images_map = get_train_val(val_famillies_list[i])
file_path = f"vgg_face_{i}.h5"
checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, ... | from sklearn.metrics import confusion_matrix, accuracy_score | Titanic - Machine Learning from Disaster |
14,593,543 | model_rate_list = val_acc_list / np.sum(val_acc_list)
model_rate_list<compute_test_metric> | accuracy_score(y_test,dt_best.predict(X_test)) | Titanic - Machine Learning from Disaster |
14,593,543 | model1_weight = np.matmul(val_acc_list, model_rate_list)
model1_weight<load_from_csv> | predictions=dt_best.predict(df_test ) | Titanic - Machine Learning from Disaster |
14,593,543 | test_path = ".. /input/test/"
submission = pd.read_csv('.. /input/sample_submission.csv')
def chunker(seq, size=32):
return(seq[pos:pos + size] for pos in range(0, len(seq), size))
def get_pred1() :
preds_for_sub = np.zeros(submission.shape[0])
for i in tqdm_notebook(range(n_val_famillies_list)) :
file_path = f"vgg_f... | titanic_3=pd.DataFrame({'PassengerId':PassengerId,'Survived':predictions})
titanic_3.to_csv('My_3rd_submission',index=False ) | Titanic - Machine Learning from Disaster |
14,593,543 | <import_modules><EOS> | pd.read_csv('My_3rd_submission' ) | Titanic - Machine Learning from Disaster |
14,477,874 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
import keras | Titanic - Machine Learning from Disaster |
14,477,874 | train_file_path = ".. /input/train_relationships.csv"
train_folders_path = ".. /input/train/"
val_famillies_list = ["F07", "F08", "F09"]<choose_model_class> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
train.head() | Titanic - Machine Learning from Disaster |
14,477,874 | def baseline_model() :
input_1 = Input(shape=(197, 197, 3))
input_2 = Input(shape=(197, 197, 3))
base_model = VGGFace(model='resnet50', include_top=False)
for layer in base_model.layers[:-3]:
layer.trainable = True
x1 = base_model(input_1)
x2 = base_model(input_2)
merged_add = Add()([x1, x2])
merged_sub = Subtract(... | test = pd.read_csv("/kaggle/input/titanic/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
14,477,874 | val_acc_list = []
def train_model2() :
for i in tqdm_notebook(range(n_val_famillies_list)) :
train, val, train_person_to_images_map, val_person_to_images_map = get_train_val(val_famillies_list[i])
file_path = f"vgg_face_{i}.h5"
checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, ... | original_train = train.copy()
original_test = test.copy()
original_train, original_test | Titanic - Machine Learning from Disaster |
14,477,874 | model_rate_list = val_acc_list / np.sum(val_acc_list)
model_rate_list<compute_test_metric> | train.isna().sum(axis=0), test.isna().sum(axis=0 ) | Titanic - Machine Learning from Disaster |
14,477,874 | model2_weight = np.matmul(val_acc_list, model_rate_list)
model2_weight<load_from_csv> | train.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1, inplace=True)
test.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1, inplace=True)
train.info, test.info | Titanic - Machine Learning from Disaster |
14,477,874 | test_path = ".. /input/test/"
submission = pd.read_csv('.. /input/sample_submission.csv')
def chunker(seq, size=32):
return(seq[pos:pos + size] for pos in range(0, len(seq), size))
def get_pred2() :
preds_for_sub = np.zeros(submission.shape[0])
for i in tqdm_notebook(range(n_val_famillies_list)) :
file_path = f"vgg_f... | women = train.loc[train.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
14,477,874 | gc.collect()<compute_test_metric> | men = train.loc[train.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men ) | Titanic - Machine Learning from Disaster |
14,477,874 | preds =(preds_model1 * model1_weight + preds_model2 * model2_weight)/(model1_weight + model2_weight )<save_to_csv> | embarked_s = train.loc[train.Embarked == 'S']["Survived"]
rate_embarked_s = sum(embarked_s)/len(embarked_s)
print("% of embarked people from Southampton who survived:", rate_embarked_s ) | Titanic - Machine Learning from Disaster |
14,477,874 | submission['is_related'] = preds
submission.to_csv("vgg_face.csv", index=False )<install_modules> | embarked_c = train.loc[train.Embarked == 'C']["Survived"]
rate_embarked_c = sum(embarked_c)/len(embarked_c)
print("% of embarked people from Cherbourg who survived:", rate_embarked_c ) | Titanic - Machine Learning from Disaster |
14,477,874 | !pip install git+https://github.com/rcmalli/keras-vggface.git<import_modules> | embarked_q = train.loc[train.Embarked == 'Q']["Survived"]
rate_embarked_q = sum(embarked_q)/len(embarked_q)
print("% of embarked people from Queenstown who survived:", rate_embarked_q ) | Titanic - Machine Learning from Disaster |
14,477,874 | import h5py
from collections import defaultdict
from glob import glob
from random import choice, sample
import cv2
import numpy as np
import pandas as pd
from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
from keras.layers import Input, Dense, Flatten, GlobalMaxPool2D, GlobalAvgPool2D, Concatenate, Multiply... | train.loc[:,'FamSize'] = train.loc[:,'SibSp'] + train.loc[:,'Parch']
test.loc[:,'FamSize'] = train.loc[:,'SibSp'] + train.loc[:,'Parch']
train = train.drop(['Parch', 'SibSp'], axis = 1)
test = test.drop(['Parch', 'SibSp'], axis = 1 ) | Titanic - Machine Learning from Disaster |
14,477,874 | train_file_path = ".. /input/train_relationships.csv"
train_folders_path = ".. /input/train/"
val_famillies = "F09"<define_variables> | age_imputed = train.groupby(['Pclass', 'Sex'] ).Age.transform('mean')
train.Age.fillna(age_imputed, inplace=True ) | Titanic - Machine Learning from Disaster |
14,477,874 | all_images = glob(train_folders_path + "*/*/*.jpg" )<define_variables> | age_imputed = test.groupby(['Pclass', 'Sex'] ).Age.transform('mean')
test.Age.fillna(age_imputed, inplace=True ) | Titanic - Machine Learning from Disaster |
14,477,874 | train_images = [x for x in all_images if val_famillies not in x]
val_images = [x for x in all_images if val_famillies in x]<define_variables> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,477,874 | train_person_to_images_map = defaultdict(list )<define_variables> | train.Embarked.fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
14,477,874 | ppl = [x.split("/")[-3] + "/" + x.split("/")[-2] for x in all_images]<load_from_csv> | test.Fare = test.Fare.fillna(test.Fare.mean() ) | Titanic - Machine Learning from Disaster |
14,477,874 | for x in train_images:
train_person_to_images_map[x.split("/")[-3] + "/" + x.split("/")[-2]].append(x)
val_person_to_images_map = defaultdict(list)
for x in val_images:
val_person_to_images_map[x.split("/")[-3] + "/" + x.split("/")[-2]].append(x)
relationships = pd.read_csv(train_file_path)
relationships = list(zip... | train.isna().sum(axis=0), test.isna().sum(axis=0 ) | Titanic - Machine Learning from Disaster |
14,477,874 | def read_img(path):
img = cv2.imread(path)
img = np.array(img ).astype(np.float)
return preprocess_input(img, version=2)
def gen(list_tuples, person_to_images_map, batch_size=16):
ppl = list(person_to_images_map.keys())
while True:
batch_tuples = sample(list_tuples, batch_size // 2)
labels = [1] * len(batch_tuples... | gender_mapping = {'male':1, 'female':0}
embarked_mapping = {'S':0, 'C':1, 'Q':2}
train['Sex'] = train['Sex'].map(gender_mapping)
train['Embarked'] = train['Embarked'].map(embarked_mapping)
test['Sex'] = test['Sex'].map(gender_mapping)
test['Embarked'] = test['Embarked'].map(embarked_mapping ) | Titanic - Machine Learning from Disaster |
14,477,874 | model.fit_generator(gen(train, train_person_to_images_map, batch_size=16), use_multiprocessing=True,
validation_data=gen(val, val_person_to_images_map, batch_size=16), epochs=130, verbose=1,
workers = 4, callbacks=callbacks_list, steps_per_epoch=200, validation_steps=100 )<predict_on_test> | y_train = train.Survived.values | Titanic - Machine Learning from Disaster |
14,477,874 | test_path = ".. /input/test/"
def chunker(seq, size=32):
return(seq[pos:pos + size] for pos in range(0, len(seq), size))
submission = pd.read_csv('.. /input/sample_submission.csv')
predictions = []
for batch in tqdm(chunker(submission.img_pair.values)) :
X1 = [x.split("-")[0] for x in batch]
X1 = np.array([read_img(te... | target = train['Survived'].values | Titanic - Machine Learning from Disaster |
14,477,874 | import pandas as pd
import numpy as np
import scipy
from sklearn.linear_model import Ridge, LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import LabelBinarizer
import gc<load_from_csv> | train = train.drop(['Survived'], axis=1 ) | Titanic - Machine Learning from Disaster |
14,477,874 | data = {
'train': pd.read_csv(".. /input/train.tsv", sep='\t'),
'test': pd.read_csv(".. /input/test.tsv", sep='\t'),
}<split> | lr_model = LogisticRegression(random_state=10, max_iter = 1000)
logit_params = {
"C": [1, 3, 10, 20, 30, 40],
"solver": ["lbfgs", "liblinear"]
}
logit_gs = GridSearchCV(lr_model, logit_params, scoring="accuracy", cv = 5, n_jobs=4)
logit_gs.fit(train, y_train ) | Titanic - Machine Learning from Disaster |
14,477,874 | y_train = np.log1p(data['train']['price'])
X_train, X_valid, y_train, y_valid = train_test_split(data['train'], y_train, test_size=0.2, random_state=42 )<concatenate> | print(logit_gs.best_score_ ) | Titanic - Machine Learning from Disaster |
14,477,874 | n_train = X_train.shape[0]
n_valid = X_valid.shape[0]
n_test = data['test'].shape[0]
full_data = pd.concat([X_train, X_valid, data['test']], axis=0)
del data['train']
gc.collect()<string_transform> | rf_model = RandomForestClassifier()
rf_params ={
'bootstrap': [True, False],
'max_depth': [10, None],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 2, 4],
'min_samples_split': [2, 5, 10],
'n_estimators': [5, 10, 15, 20, 25, 30]}
rf_gs = GridSearchCV(rf_model, rf_params, scoring='accuracy', cv=8, n_jobs=4)
... | Titanic - Machine Learning from Disaster |
14,477,874 | def split_cat(text):
try:
return text.split("/")
except:
return("Unknown", "Unknown", "Unknown" )<feature_engineering> | print(rf_gs.best_score_ ) | Titanic - Machine Learning from Disaster |
14,477,874 | full_data['general_cat'], full_data['subcat_1'], full_data['subcat_2'] = zip(*full_data['category_name'].apply(lambda x: split_cat(x)))
full_data["brand_name"] = full_data["brand_name"].fillna("unknown")
full_data["item_description"] = full_data["item_description"].fillna("No description yet" )<count_unique_values> | svc_model = SVC()
test_parameters = {
"C": [1, 3, 10, 30, 100],
"kernel": ["linear", "poly", "rbf" , "sigmoid"],
}
svc_gs = GridSearchCV(svc_model, test_parameters, scoring="accuracy", cv=5, n_jobs=4)
svc_gs.fit(train, y_train ) | Titanic - Machine Learning from Disaster |
14,477,874 | print("There are %d General categories." % full_data['general_cat'].nunique() )<count_unique_values> | print(svc_gs.best_score_ ) | Titanic - Machine Learning from Disaster |
14,477,874 | print("There are %d cat1 categories." % full_data['subcat_1'].nunique() )<count_unique_values> | lgb_model = LGBMClassifier()
test_parameters = {
"n_estimators": [int(x)for x in np.linspace(5, 30, 6)],
"reg_alpha": [0, 0.75, 1, 1.25],
"learning_rate": [0.5, 0.4, 0.35, 0.3, 0.25, 0.2],
"subsample": [0.5, 0.75, 1]
}
lgb_gs = GridSearchCV(lgb_model, test_parameters, scoring="accuracy", cv=8, n_jobs=4)
lgb_gs.fit(tra... | Titanic - Machine Learning from Disaster |
14,477,874 | print("There are %d cat2 categories." % full_data['subcat_2'].nunique() )<data_type_conversions> | print(lgb_gs.best_score_ ) | Titanic - Machine Learning from Disaster |
14,477,874 | full_data['general_cat'] = full_data['general_cat'].astype('category')
full_data['subcat_1'] = full_data['subcat_1'].astype('category')
full_data['subcat_2'] = full_data['subcat_2'].astype('category')
full_data['brand_name'] = full_data['brand_name'].astype('category')
full_data['item_condition_id'] = full_data['it... | ensemble_model = VotingClassifier(estimators=[
("logit", logit_gs.best_estimator_),
("rf", rf_gs.best_estimator_),
("svc", svc_gs.best_estimator_),
("lgb", lgb_gs.best_estimator_),
], voting = "hard" ) | Titanic - Machine Learning from Disaster |
14,477,874 | stopwords = {x: 1 for x in stopwords.words('english')}
non_alphanums = re.compile(u'[^A-Za-z0-9]+')
def norm_text(text):
return u" ".join(
[x for x in [y for y in non_alphanums.sub(' ', text ).lower().strip().split(" ")] if len(x)> 1 and x not in stopwords] )<choose_model_class> | ensemble_model.fit(train, y_train ) | Titanic - Machine Learning from Disaster |
14,477,874 | wb = wordbatch.WordBatch(norm_text, extractor=(WordBag, {"hash_ngrams": 2, "hash_ngrams_weights": [1.5, 1.0],
"hash_size": 2 ** 29, "norm": None, "tf": 'binary',
"idf": None,
}), procs=8)
wb.dictionary_freeze= True
X_name = wb.fit_transform(full_data['name'])
del(wb)
X_name = X_name[:, np.array(np.clip(X_name.getnnz... | ensemble_model.score(train, y_train ) | Titanic - Machine Learning from Disaster |
14,477,874 | lb = LabelBinarizer(sparse_output=True)
X_brand = lb.fit_transform(full_data['brand_name'])
X_cat = lb.fit_transform(full_data['general_cat'])
X_subcat1 = lb.fit_transform(full_data['subcat_1'])
X_subcat2 = lb.fit_transform(full_data['subcat_2'])
X_dummies = csr_matrix(pd.get_dummies(full_data[['item_condition_id'... | classifier = Sequential()
classifier.add(Dense(activation="relu", input_dim=6, units=11, kernel_initializer="uniform"))
classifier.add(Dense(activation="relu", units=11, kernel_initializer="uniform"))
classifier.add(Dropout(0.5))
classifier.add(Dense(activation="relu", units=11, kernel_initializer="uniform"))
classifie... | Titanic - Machine Learning from Disaster |
14,477,874 | ridge_model = Ridge(solver='auto', fit_intercept=True, alpha=0.4,
max_iter=200, normalize=False, tol=0.01, random_state = 42 )<train_model> | features = train[['Pclass', 'Sex', 'Age', 'Fare', 'Embarked', 'FamSize']].values
| Titanic - Machine Learning from Disaster |
14,477,874 | ridge_model.fit(X_train, y_train )<compute_test_metric> | history = classifier.fit(features, target, batch_size = 32, epochs=200, validation_split=0.1,verbose = 1,shuffle=True ) | Titanic - Machine Learning from Disaster |
14,477,874 |
def rmsle(Y, Y_pred):
assert Y.shape == Y_pred.shape
return np.sqrt(np.mean(np.square(Y_pred - Y)) )<compute_test_metric> | predictions = ensemble_model.predict(test)
predictions | Titanic - Machine Learning from Disaster |
14,477,874 | <predict_on_test><EOS> | submission = pd.DataFrame({'PassengerId': original_test.PassengerId,'Survived': predictions})
submission.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,349,124 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | import pandas as pd
from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
14,349,124 | ftrl_model = FTRL(alpha=0.01, beta=0.1, L1=0.00001, L2=1.0, D=X_train.shape[1],
iters=60, inv_link="identity", threads=1)
ftrl_model.fit(X_train, y_train.reshape(-1))<compute_test_metric> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
14,349,124 | y_valid_pred = ftrl_model.predict(X_valid)
y_valid_pred = y_valid_pred.reshape(-1, 1)
print("RMSL error on valid set:", rmsle(y_valid, y_valid_pred))
print("MAE on valid set:", mean_absolute_error(y_valid, y_valid_pred))<predict_on_test> | test.head() | Titanic - Machine Learning from Disaster |
14,349,124 | ftrl_preds = ftrl_model.predict(X_test )<train_model> |
train = train.drop(["Name", "Ticket", "Cabin"], axis=1)
test = test.drop(["Name", "Ticket", "Cabin"], axis=1 ) | Titanic - Machine Learning from Disaster |
14,349,124 | fm_ftrl_model = FM_FTRL(alpha=0.01, beta=0.1, L1=0.00001, L2=0.1, D=X_train.shape[1], alpha_fm=0.01,
L2_fm=0.0, init_fm=0.01, D_fm=200, e_noise=0.0001, iters=18, inv_link="identity", threads=4)
fm_ftrl_model.fit(X_train, y_train.reshape(-1))<compute_test_metric> | new_data_train = pd.get_dummies(train)
new_data_test = pd.get_dummies(test ) | Titanic - Machine Learning from Disaster |
14,349,124 | y_valid_pred = fm_ftrl_model.predict(X_valid)
y_valid_pred = y_valid_pred.reshape(-1, 1)
print("RMSL error on valid set:", rmsle(y_valid, y_valid_pred))
print("MAE on valid set:", mean_absolute_error(y_valid, y_valid_pred))<predict_on_test> | new_data_train["Age"].fillna(new_data_train["Age"].mean() , inplace=True)
new_data_test["Age"].fillna(new_data_test["Age"].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,349,124 | ft_ftrl_preds = fm_ftrl_model.predict(X_test )<train_model> | new_data_test["Fare"].fillna(new_data_test["Fare"].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,349,124 | lgb_label = y_train.ravel()
lgb_y_valid = y_valid.ravel()
lgb_train = lgb.Dataset(X_train, label=lgb_label)
lgb_eval = lgb.Dataset(X_valid, lgb_y_valid, reference=lgb_train)
params = {
'task': 'train',
'boosting_type': 'gbdt',
'objective': 'regression',
'metric': {'l2', 'rmse'},
'learning_rate': 0.6,
'feature_fractio... | X = new_data_train.drop("Survived", axis=1)
y = new_data_train["Survived"] | Titanic - Machine Learning from Disaster |
14,349,124 |
<categorify> | tree = DecisionTreeClassifier(max_depth = 10, random_state = 0)
tree.fit(X, y ) | Titanic - Machine Learning from Disaster |
14,349,124 |
<prepare_x_and_y> | from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,349,124 |
<save_to_csv> | Xtest = new_data_test
Xtest.head() | Titanic - Machine Learning from Disaster |
14,349,124 | lgbm_preds = gbm.predict(X_test, num_iteration=gbm.best_iteration)
lgbm_preds = lgbm_preds.reshape(-1, 1)
ftrl_preds = ftrl_preds.reshape(-1, 1)
ft_ftrl_preds = ft_ftrl_preds.reshape(-1, 1)
preds = ridge_preds*0.05 + lgbm_preds*0.06 + ftrl_preds*0.25 + ft_ftrl_preds*0.64
data['test']["price"] = np.expm1(preds)
dat... | Xtrain, Xvalidation, Ytrain, Yvalidation = train_test_split(X, y, test_size=0.2, random_state=True ) | Titanic - Machine Learning from Disaster |
14,349,124 | import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.pipeline import FeatureUnion
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from keras.preprocessin... | model = RandomForestClassifier(n_estimators=100,
max_leaf_nodes=12,
max_depth=12,
random_state=0)
model.fit(Xtrain, Ytrain)
| Titanic - Machine Learning from Disaster |
14,349,124 | def rmsle(Y, Y_pred):
assert Y.shape == Y_pred.shape
return np.sqrt(np.mean(np.square(Y_pred - Y)) )<load_from_csv> | Yprediction = model.predict(Xvalidation)
accuracy_score(Yvalidation, Yprediction ) | Titanic - Machine Learning from Disaster |
14,349,124 | %%time
train_df = pd.read_table('.. /input/train.tsv')
test_df = pd.read_table('.. /input/test.tsv')
print(train_df.shape, test_df.shape )<categorify> | submission = pd.DataFrame()
submission["PassengerId"] = Xtest["PassengerId"]
submission["Survived"] = model.predict(Xtest)
submission.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
14,594,885 | def fill_missing_values(df):
df.category_name.fillna(value="Other", inplace=True)
df.brand_name.fillna(value="missing", inplace=True)
df.item_description.fillna(value="None", inplace=True)
return df
train_df = fill_missing_values(train_df)
test_df = fill_missing_values(test_df )<prepare_x_and_y> | import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns | Titanic - Machine Learning from Disaster |
14,594,885 | train_df["target"] = np.log1p(train_df.price)
train_df, dev_df = train_test_split(train_df, random_state=347, train_size=0.99)
Y_train = train_df.target.values.reshape(-11, 1)
Y_dev = dev_df.target.values.reshape(-1, 1)
n_trains = train_df.shape[0]
n_devs = dev_df.shape[0]
n_tests = test_df.shape[0]
print("Training... | df_train=pd.read_csv('.. /input/titanic/train.csv')
df_test=pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,594,885 | full_df = pd.concat([train_df, dev_df, test_df] )<categorify> | PassengerId=df_test['PassengerId'] | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
print("Processing categorical data...")
le = LabelEncoder()
le.fit(full_df.category_name)
full_df.category_name = le.transform(full_df.category_name)
le.fit(full_df.brand_name)
full_df.brand_name = le.transform(full_df.brand_name)
del le<categorify> | df_train.drop(['PassengerId','Name','Ticket'],axis=1,inplace=True)
df_test.drop(['PassengerId','Name','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
print("Transforming text data to sequences...")
raw_text = np.hstack([full_df.item_description.str.lower() , full_df.name.str.lower() ])
print(" Fitting tokenizer...")
tok_raw = Tokenizer()
tok_raw.fit_on_texts(raw_text)
print(" Transforming text to sequences...")
full_df['seq_item_description'] = tok_raw.t... | df_train.isnull().sum() /len(df_train)*100 | Titanic - Machine Learning from Disaster |
14,594,885 | MAX_NAME_SEQ = 10
MAX_ITEM_DESC_SEQ = 75
MAX_TEXT = np.max([
np.max(full_df.seq_name.max()),
np.max(full_df.seq_item_description.max()),
])+ 4
MAX_CATEGORY = np.max(full_df.category_name.max())+ 1
MAX_BRAND = np.max(full_df.brand_name.max())+ 1
MAX_CONDITION = np.max(full_df.item_condition_id.max())+ 1<prepare_x_and_y> | df_train.drop(['Cabin'],axis=1,inplace=True)
df_test.drop(['Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
def get_keras_data(df):
X = {
'name': pad_sequences(df.seq_name, maxlen=MAX_NAME_SEQ),
'item_desc': pad_sequences(df.seq_item_description, maxlen=MAX_ITEM_DESC_SEQ),
'brand_name': np.array(df.brand_name),
'category_name': np.array(df.category_name),
'item_condition': np.array(df.item_condition_id),
'num_vars': n... | df_train.dropna(subset=['Embarked'],inplace=True)
df_train['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
14,594,885 | def new_rnn_model(lr=0.001, decay=0.0):
name = Input(shape=[X_train["name"].shape[1]], name="name")
item_desc = Input(shape=[X_train["item_desc"].shape[1]], name="item_desc")
brand_name = Input(shape=[1], name="brand_name")
category_name = Input(shape=[1], name="category_name")
item_condition = Input(shape=[1], nam... | age_train_series=df_train.groupby(['Pclass','Sex'])['Age'].transform('median' ) | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
BATCH_SIZE = 1024
epochs = 2
exp_decay = lambda init, fin, steps:(init/fin)**(1/(steps-1)) - 1
steps = int(n_trains / BATCH_SIZE)* epochs
lr_init, lr_fin = 0.007, 0.0005
lr_decay = exp_decay(lr_init, lr_fin, steps)
rnn_model = new_rnn_model(lr=lr_init, decay=lr_decay)
print("Fitting RNN model to training examp... | age_test_series=df_test.groupby(['Pclass','Sex'])['Age'].transform('median' ) | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
print("Evaluating the model on validation data...")
Y_dev_preds_rnn = rnn_model.predict(X_dev, batch_size=BATCH_SIZE)
print(" RMSLE error:", rmsle(Y_dev, Y_dev_preds_rnn))<predict_on_test> | df_train['Age']=df_train['Age'].fillna(age_train_series ) | Titanic - Machine Learning from Disaster |
14,594,885 | rnn_preds = rnn_model.predict(X_test, batch_size=BATCH_SIZE, verbose=1)
rnn_preds = np.expm1(rnn_preds )<concatenate> | df_test['Age']=df_test['Age'].fillna(age_test_series ) | Titanic - Machine Learning from Disaster |
14,594,885 | full_df = pd.concat([train_df, dev_df, test_df] )<data_type_conversions> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
full_df['shipping'] = full_df['shipping'].astype(str)
full_df['item_condition_id'] = full_df['item_condition_id'].astype(str )<feature_engineering> | Fare_test_series=df_test.groupby(['Pclass'])['Fare'].transform('median')
df_test['Fare']=df_test['Fare'].fillna(Fare_test_series ) | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
print("Vectorizing data...")
default_preprocessor = CountVectorizer().build_preprocessor()
def build_preprocessor(field):
field_idx = list(full_df.columns ).index(field)
return lambda x: default_preprocessor(x[field_idx])
vectorizer = FeatureUnion([
('name', CountVectorizer(
ngram_range=(1, 2),
max_features... | df_train=pd.get_dummies(df_train,drop_first=True)
| Titanic - Machine Learning from Disaster |
14,594,885 | %%time
print("Fitting Ridge model on training examples...")
ridge_model = Ridge(
solver='auto', fit_intercept=True, alpha=0.5,
max_iter=100, normalize=False, tol=0.05,
)
ridge_model.fit(X_train, Y_train )<predict_on_test> | df_test=pd.get_dummies(df_test,drop_first=True ) | Titanic - Machine Learning from Disaster |
14,594,885 | Y_dev_preds_ridge = ridge_model.predict(X_dev)
Y_dev_preds_ridge = Y_dev_preds_ridge.reshape(-1, 1)
print("RMSL error on dev set:", rmsle(Y_dev, Y_dev_preds_ridge))<predict_on_test> | X = df_train.drop('Survived',axis=1)
y = df_train['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)
X_train.shape, X_test.shape | Titanic - Machine Learning from Disaster |
14,594,885 | %%time
ridge_preds = ridge_model.predict(X_test)
ridge_preds = np.expm1(ridge_preds )<compute_train_metric> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
14,594,885 | def aggregate_predicts(Y1, Y2):
assert Y1.shape == Y2.shape
ratio = 0.63
return Y1 * ratio + Y2 *(1.0 - ratio)
Y_dev_preds = aggregate_predicts(Y_dev_preds_rnn, Y_dev_preds_ridge)
print("RMSL error for RNN + Ridge on dev set:", rmsle(Y_dev, Y_dev_preds))<save_to_csv> | rf=RandomForestClassifier(random_state=42,n_estimators=100,max_depth=4,min_samples_leaf=15,max_features=3)
rf.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
14,594,885 | preds = aggregate_predicts(rnn_preds, ridge_preds)
submission = pd.DataFrame({
"test_id": test_df.test_id,
"price": preds.reshape(-1),
})
submission.to_csv("./rnn_ridge_submission.csv", index=False )<load_from_csv> | accuracy_score(y_test,rf.predict(X_test)) | Titanic - Machine Learning from Disaster |
14,594,885 | train=pd.read_table('.. /input/train.tsv')
test=pd.read_table('.. /input/test.tsv' )<feature_engineering> | predictions=rf.predict(df_test)
titanic_4=pd.DataFrame({'PassengerId':PassengerId,'Survived':predictions})
titanic_4.to_csv('My_4th_submission',index=False)
| Titanic - Machine Learning from Disaster |
14,594,885 | <feature_engineering><EOS> | pd.read_csv('My_4th_submission' ) | Titanic - Machine Learning from Disaster |
14,464,656 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
%config InlineBackend.figure_format = 'svg'
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
14,464,656 | %%time
df_category=pd.DataFrame(train.category_name.unique() ,columns=['category_name'])
df_category['count']=df_category.category_name.apply(lambda x: len(train.category_name[train.category_name==x]))
df_category['category']=df_category.category_name.apply(lambda x:(x.split('/')[0]+'/'+x.split('/')[1]))
for i,cat in ... | train_data.drop(['PassengerId'],axis=1,inplace=True)
test_data.drop(['PassengerId'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,464,656 | def get_sparse(df,df1,df2,max_feature=300000):
Cvect=CountVectorizer(binary=True)
Tvect=TfidfVectorizer(stop_words='english',ngram_range=(1,2),max_features=max_feature)
vect_name=Tvect.fit(df.name)
vect_name1=vect_name.transform(df.name)
vect_name2=vect_name.transform(df1.name)
vect_name3=vect_name.transform(df2.n... | print("Train dataset
", train_data.isna().sum())
print("
Test dataset
", test_data.isna().sum() ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.