kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,536,833 |
<prepare_x_and_y> | random_forest = RandomForestClassifier(criterion='gini',
n_estimators=1750,
max_depth=7,
min_samples_split=6,
min_samples_leaf=6,
max_features='auto',
oob_score=True,
random_state=42,
n_jobs=-1,
verbose=1)
random_forest.fit(X_train, Y_train)
Y_prediction =(random_forest.predict(X_test)).astype(int)
random_forest.sco... | Titanic - Machine Learning from Disaster |
11,536,833 | target_train = train['AdoptionSpeed']
cleaned_train = train.drop(columns=['Name', 'RescuerID', 'Description', 'PetID', 'AdoptionSpeed'])
test_pet_ID = test['PetID']
test_X = test.drop(columns=['Name', 'RescuerID', 'Description', 'PetID'])
<split> | N = 5
oob = 0
probs = pd.DataFrame(np.zeros(( len(X_test), N * 2)) , columns=['Fold_{}_Prob_{}'.format(i, j)for i in range(1, N + 1)for j in range(2)])
fprs, tprs, scores = [], [], []
skf = StratifiedKFold(n_splits=N, random_state=N, shuffle=True)
for fold,(trn_idx, val_idx)in enumerate(skf.split(X_train, Y_train), 1... | Titanic - Machine Learning from Disaster |
11,536,833 | x_train, x_valid, y_train, y_valid = train_test_split(cleaned_train,
target_train,
test_size=0.2,
random_state=seed)
<train_model> | rf = RandomForestClassifier(n_estimators=100,oob_score=True)
scores = cross_val_score(random_forest, X_train, Y_train, cv=10, scoring = "accuracy")
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std() ) | Titanic - Machine Learning from Disaster |
11,536,833 | if MODEL_USE == 1 or MODEL_USE==0:
first_model = EnsembleModel(balancing=True)
first_model.set_scorer(kappa)
first_model.tune_best_param(x_train, y_train)
first_model.validate(x_valid, y_valid )<load_pretrained> | predictions = cross_val_predict(random_forest, X_train, Y_train, cv=3)
confusion_matrix(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
11,536,833 | filename = os.listdir(".. /input/train_sentiment")[1]
filename = ".. /input/train_sentiment/"+filename
with open(filename, 'r')as f:
sentiment = json.load(f)
sentiment<create_dataframe> | print("Precision:", precision_score(Y_train, predictions))
print("Recall:",recall_score(Y_train, predictions)) | Titanic - Machine Learning from Disaster |
11,536,833 | def load_desc_sentiment(path):
all_desc_sentiment_files = os.listdir(path)
count_file = len(all_desc_sentiment_files)
desc_sentiment_df = pd.DataFrame(columns=['PetID','desc_senti_magnitude','desc_senti_score'])
current_file_index = 1
for filename in all_desc_sentiment_files:
with open(path+filename, 'r')as f:
senti... | f1_score(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
11,536,833 | tfv = TfidfVectorizer(min_df=2, max_features=None,
strip_accents='unicode', analyzer='word', token_pattern=r'(?u)\b\w+\b',
ngram_range=(1, 3), use_idf=1, smooth_idf=1, sublinear_tf=1,
)
tfv.fit(train['Description'])
desc_X_train = tfv.transform(train['Description'])
desc_X_test = tfv.transform(test['Description'])
... | r_a_score = roc_auc_score(Y_train, y_scores)
print("ROC-AUC-Score:", r_a_score ) | Titanic - Machine Learning from Disaster |
11,536,833 | train_desc_sentiment_df = load_desc_sentiment(".. /input/train_sentiment/")
test_desc_sentiment_df = load_desc_sentiment(".. /input/test_sentiment/" )<feature_engineering> | submission = pd.DataFrame({
"PassengerId": df_test["PassengerId"],
"Survived": Y_prediction
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,067,680 | train_desc_sentiment_df['score_times_mag'] = train_desc_sentiment_df['desc_senti_magnitude'] * train_desc_sentiment_df['desc_senti_score']
test_desc_sentiment_df['score_times_mag'] = test_desc_sentiment_df['desc_senti_magnitude'] * test_desc_sentiment_df['desc_senti_score']<create_dataframe> | train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
test_df = pd.read_csv("/kaggle/input/titanic/test.csv")
test_PassengerId = test_df["PassengerId"] | Titanic - Machine Learning from Disaster |
9,067,680 | desc_X_train = pd.DataFrame(desc_X_train, columns=['desc_{}'.format(i)for i in range(svd.n_components)])
desc_X_test = pd.DataFrame(desc_X_test, columns=['desc_{}'.format(i)for i in range(svd.n_components)])
train_with_desc = pd.concat([train,desc_X_train],axis=1)
test_with_desc = pd.concat([test,desc_X_test],axis=1... | category2 = ["Cabin", "Name", "Ticket"]
for c in category2:
print("{}
".format(train_df[c].value_counts())) | Titanic - Machine Learning from Disaster |
9,067,680 | target_train = train_with_desc['AdoptionSpeed']
joint_train = train_with_desc.merge(train_desc_sentiment_df, how='left',left_on=['PetID'],right_on=['PetID'])
cleaned_train = joint_train.drop(columns=['Name', 'RescuerID', 'Description', 'PetID', 'AdoptionSpeed'])
cleaned_train.fillna(0.0,inplace=True)
test_pet_ID = t... | train_df[["Pclass","Survived"]].groupby(["Pclass"], as_index = False ).mean().sort_values(by="Survived",ascending = False ) | Titanic - Machine Learning from Disaster |
9,067,680 | if MODEL_USE == 2 or MODEL_USE==0:
second_model = EnsembleModel(balancing=True)
second_model.set_scorer(kappa)
second_model.tune_best_param(x_train, y_train)
second_model.validate(x_valid,y_valid )<define_variables> | train_df[["Sex","Survived"]].groupby(["Sex"], as_index = False ).mean().sort_values(by="Survived",ascending = False ) | Titanic - Machine Learning from Disaster |
9,067,680 | def add_meta_feature(path,df):
vertex_xs = []
vertex_ys = []
bounding_confidences = []
bounding_importance_fracs = []
dominant_blues = []
dominant_greens = []
dominant_reds = []
dominant_pixel_fracs = []
dominant_scores = []
label_descriptions = []
label_scores = []
nf_count = 0
nl_count = 0
pet_id = df['PetID']
for pe... | train_df[["SibSp","Survived"]].groupby(["SibSp"], as_index = False ).mean().sort_values(by="Survived",ascending = False ) | Titanic - Machine Learning from Disaster |
9,067,680 | if MODEL_USE == 3 or MODEL_USE==0:
third_model = EnsembleModel(balancing=True)
third_model.set_scorer(kappa)
third_model.tune_best_param(x_train, y_train)
third_model.validate(x_valid,y_valid )<choose_model_class> | train_df[["Parch","Survived"]].groupby(["Parch"], as_index = False ).mean().sort_values(by="Survived",ascending = False ) | Titanic - Machine Learning from Disaster |
9,067,680 | model = None
if MODEL_USE == 1:
model = first_model
if MODEL_USE == 2:
model = second_model
if MODEL_USE == 0 or MODEL_USE == 3:
pass
model = third_model<train_model> | def detect_outliers(df,features):
outlier_indices = []
for c in features:
Q1 = np.percentile(df[c],25)
Q3 = np.percentile(df[c],75)
IQR = Q3 - Q1
outlier_step = IQR * 1.5
outlier_list_col = df[(df[c] < Q1 - outlier_step)|(df[c] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outlier_indices = Co... | Titanic - Machine Learning from Disaster |
9,067,680 | model.re_fit_with_best_param(cleaned_train,target_train )<predict_on_test> | train_df.loc[detect_outliers(train_df,["Age","SibSp","Parch","Fare"])] | Titanic - Machine Learning from Disaster |
9,067,680 | final_result = model.predict(test_X )<prepare_output> | train_df = train_df.drop(detect_outliers(train_df,["Age","SibSp","Parch","Fare"]),axis = 0 ).reset_index(drop = True ) | Titanic - Machine Learning from Disaster |
9,067,680 | submission_df = pd.DataFrame(data={'PetID' : test_pet_ID.tolist() ,
'AdoptionSpeed' : final_result})
submission_df.head(5 )<save_to_csv> | train_df_len = len(train_df)
train_df = pd.concat([train_df,test_df],axis = 0 ).reset_index(drop = True ) | Titanic - Machine Learning from Disaster |
9,067,680 | submission_df.to_csv('submission.csv', index=False )<import_modules> | train_df.columns[train_df.isnull().any() ] | Titanic - Machine Learning from Disaster |
9,067,680 | import json
import scipy as sp
import pandas as pd
import numpy as np
from functools import partial
from math import sqrt
from sklearn.metrics import cohen_kappa_score, mean_squared_error
from sklearn.metrics import confusion_matrix as sk_cmatrix
from sklearn.model_selection import StratifiedKFold
from sklearn.feature_... | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
9,067,680 | def confusion_matrix(rater_a, rater_b, min_rating=None, max_rating=None):
assert(len(rater_a)== len(rater_b))
if min_rating is None:
min_rating = min(rater_a + rater_b)
if max_rating is None:
max_rating = max(rater_a + rater_b)
num_ratings = int(max_rating - min_rating + 1)
conf_mat = [[0 for i in range(num_rating... | train_df[train_df["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | train_df["Embarked"] = train_df["Embarked"].fillna("C")
train_df[train_df["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | def rmse(actual, predicted):
return sqrt(mean_squared_error(actual, predicted))<load_from_csv> | train_df[train_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | %%time
print('Train')
train = pd.read_csv(".. /input/train/train.csv")
print(train.shape)
print('Test')
test = pd.read_csv(".. /input/test/test.csv")
print(test.shape)
print('Breeds')
breeds = pd.read_csv(".. /input/breed_labels.csv")
print(breeds.shape)
print('Colors')
colors = pd.read_csv(".. /input/color_l... | train_df["Fare"] = train_df["Fare"].fillna(np.mean(train_df[train_df["Pclass"] == 3]["Fare"])) | Titanic - Machine Learning from Disaster |
9,067,680 | target = train['AdoptionSpeed']
train_id = train['PetID']
test_id = test['PetID']
train.drop(['AdoptionSpeed', 'PetID'], axis=1, inplace=True)
test.drop(['PetID'], axis=1, inplace=True )<feature_engineering> | train_df[train_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | %%time
doc_sent_mag = []
doc_sent_score = []
nf_count = 0
for pet in train_id:
try:
with open('.. /input/train_sentiment/' + pet + '.json', 'r')as f:
sentiment = json.load(f)
doc_sent_mag.append(sentiment['documentSentiment']['magnitude'])
doc_sent_score.append(sentiment['documentSentiment']['score'])
except FileNot... | train_df[train_df["Age"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | %%time
train_desc = train.Description.fillna("none" ).values
test_desc = test.Description.fillna("none" ).values
tfv = TfidfVectorizer(min_df=3, max_features=10000,
strip_accents='unicode', analyzer='word', token_pattern=r'\w{1,}',
ngram_range=(1, 3), use_idf=1, smooth_idf=1, sublinear_tf=1,
stop_words = 'english')
tf... | index_nan_age = list(train_df["Age"][train_df["Age"].isnull() ].index)
for i in index_nan_age:
age_pred = train_df["Age"][(( train_df["SibSp"] == train_df.iloc[i]["SibSp"])&(train_df["Parch"] == train_df.iloc[i]["Parch"])&(train_df["Pclass"] == train_df.iloc[i]["Pclass"])) ].median()
age_med = train_df["Age"].median()... | Titanic - Machine Learning from Disaster |
9,067,680 | %%time
vertex_xs = []
vertex_ys = []
bounding_confidences = []
bounding_importance_fracs = []
dominant_blues = []
dominant_greens = []
dominant_reds = []
dominant_pixel_fracs = []
dominant_scores = []
label_descriptions = []
label_scores = []
nf_count = 0
nl_count = 0
for pet in train_id:
try:
with open('.. /input/trai... | train_df[train_df["Age"].isnull() ] | Titanic - Machine Learning from Disaster |
9,067,680 | %%time
train.drop(['Name', 'RescuerID', 'Description'], axis=1, inplace=True)
test.drop(['Name', 'RescuerID', 'Description'], axis=1, inplace=True )<data_type_conversions> | name = train_df["Name"]
train_df["Title"] = [i.split(".")[0].split(",")[-1].strip() for i in name] | Titanic - Machine Learning from Disaster |
9,067,680 | numeric_cols = ['Age', 'Quantity', 'Fee', 'VideoAmt', 'PhotoAmt', 'AdoptionSpeed', 'doc_sent_mag', 'doc_sent_score', 'dominant_score', 'dominant_pixel_frac', 'dominant_red', 'dominant_green', 'dominant_blue', 'bounding_importance', 'bounding_confidence', 'vertex_x', 'vertex_y', 'label_score'] + ['svd_{}'.format(i)for i... | train_df["Title"] = train_df["Title"].replace(["Lady","the Countess","Capt","Col","Don","Dr","Major","Rev","Sir","Jonkheer","Dona"],"other")
train_df["Title"] = [0 if i == "Master" else 1 if i == "Miss" or i == "Ms" or i == "Mlle" or i == "Mrs" else 2 if i == "Mr" else 3 for i in train_df["Title"]]
train_df["Title"].h... | Titanic - Machine Learning from Disaster |
9,067,680 | def run_cv_model(train, test, target, model_fn, params={}, eval_fn=None, label='model'):
kf = StratifiedKFold(n_splits=5, random_state=42, shuffle=True)
fold_splits = kf.split(train, target)
cv_scores = []
qwk_scores = []
pred_full_test = 0
pred_train = np.zeros(( train.shape[0], 5))
all_coefficients = np.zeros(( 5, ... | train_df.drop(labels = ["Name"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,067,680 | optR = OptimizedRounder()
coefficients_ = np.mean(results['coefficients'], axis=0)
print(coefficients_)
train_predictions = [r[0] for r in results['train']]
train_predictions = optR.predict(train_predictions, coefficients_ ).astype(int)
Counter(train_predictions )<predict_on_test> | train_df = pd.get_dummies(train_df,columns=["Title"])
train_df.head() | Titanic - Machine Learning from Disaster |
9,067,680 | optR = OptimizedRounder()
test_predictions = [r[0] for r in results['test']]
test_predictions = optR.predict(test_predictions, coefficients_ ).astype(int)
Counter(test_predictions )<create_dataframe> | train_df["Fsize"] = train_df["SibSp"] + train_df["Parch"] + 1 | Titanic - Machine Learning from Disaster |
9,067,680 | pd.DataFrame(sk_cmatrix(target, train_predictions), index=list(range(5)) , columns=list(range(5)) )<compute_test_metric> | train_df["family_size"] = [1 if i < 5 else 0 for i in train_df["Fsize"]] | Titanic - Machine Learning from Disaster |
9,067,680 | quadratic_weighted_kappa(target, train_predictions )<compute_test_metric> | train_df = pd.get_dummies(train_df, columns= ["family_size"])
train_df.head() | Titanic - Machine Learning from Disaster |
9,067,680 | rmse(target, [r[0] for r in results['train']] )<prepare_output> | train_df = pd.get_dummies(train_df, columns=["Embarked"])
train_df.head() | Titanic - Machine Learning from Disaster |
9,067,680 | submission = pd.DataFrame({'PetID': test_id, 'AdoptionSpeed': test_predictions})
submission.head()<save_to_csv> | a = "A/5.2151"
a.replace(".","" ).replace("/","" ).strip().split(" ")[0] | Titanic - Machine Learning from Disaster |
9,067,680 | submission.to_csv('submission.csv', index=False)
<set_options> | tickets = []
for i in list(train_df.Ticket):
if not i.isdigit() :
tickets.append(i.replace(".","" ).replace("/","" ).strip().split(" ")[0])
else:
tickets.append("x")
train_df["Ticket"] = tickets | Titanic - Machine Learning from Disaster |
9,067,680 | %matplotlib inline
<import_modules> | train_df = pd.get_dummies(train_df, columns= ["Ticket"], prefix = "T")
train_df.head(10 ) | Titanic - Machine Learning from Disaster |
9,067,680 | import scipy as sp
from collections import Counter
from functools import partial<define_variables> | train_df["Pclass"] = train_df["Pclass"].astype("category")
train_df = pd.get_dummies(train_df, columns= ["Pclass"])
train_df.head() | Titanic - Machine Learning from Disaster |
9,067,680 | data_path=".. /input/petfinder-adoption-prediction"
first_kernel_path=".. /input/pets-adoption-simple-pandas-random-forest"
image_kernel_path=".. /input/pet-adoption-only-images"
svd_kernel_path=".. /input/pet-adoption-only-text-svd"<load_from_csv> | train_df["Sex"] = train_df["Sex"].astype("category")
train_df = pd.get_dummies(train_df, columns=["Sex"])
train_df.head() | Titanic - Machine Learning from Disaster |
9,067,680 | train = pd.read_csv(data_path+"/train/train.csv")
test = pd.read_csv(data_path+"/test/test.csv")
color_labels = pd.read_csv(data_path+"/color_labels.csv")
breed_labels = pd.read_csv(data_path+"/breed_labels.csv")
state_labels = pd.read_csv(data_path+"/state_labels.csv" )<set_options> | train_df.drop(labels = ["PassengerId", "Cabin"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
9,067,680 | warnings.filterwarnings('ignore' )<load_from_csv> | from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTr... | Titanic - Machine Learning from Disaster |
9,067,680 | df_all0 = pd.read_csv(first_kernel_path+"/df_all0.csv")
df_all0.head()<load_from_csv> | test = train_df[train_df_len:]
test.drop(labels = ["Survived"],axis = 1, inplace = True)
| Titanic - Machine Learning from Disaster |
9,067,680 | txt_data = pd.read_csv(first_kernel_path+"/txt_data.csv")
txt_data.columns = ['PetID','sent_magnitude','sent_score','sent_language']
txt_data.head()<load_from_csv> | train = train_df[:train_df_len]
X_train = train.drop(labels = "Survived", axis = 1)
y_train = train["Survived"]
X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size = 0.50, random_state = 42)
print("X_train",len(X_train))
print("X_test",len(X_test))
print("y_train",len(y_train))
print("y_te... | Titanic - Machine Learning from Disaster |
9,067,680 | img_df1a = pd.read_csv(image_kernel_path+"/img_df1a_local.csv")
img_df1a.columns = ['PetID','ImageID','img_met_score','img_met_description']
img_df1a.head()<load_from_csv> | logreg = LogisticRegression()
logreg.fit(X_train, y_train)
acc_log_train = round(logreg.score(X_train, y_train)*100,2)
acc_log_test = round(logreg.score(X_test,y_test)*100,2)
print("Training Accuracy: % {}".format(acc_log_train))
print("Testing Accuracy: % {}".format(acc_log_test)) | Titanic - Machine Learning from Disaster |
9,067,680 | img_df1c = pd.read_csv(image_kernel_path+"/img_df1c_local.csv")
img_df1c.columns = ['PetID','ImageID','img_crp_x','img_crp_y','img_crp_conf','img_crp_if']
img_df1c.head()<load_from_csv> | random_state = 42
classifier = [DecisionTreeClassifier(random_state = random_state),
SVC(random_state = random_state),
RandomForestClassifier(random_state = random_state),
LogisticRegression(random_state = random_state),
KNeighborsClassifier() ]
dt_param_grid = {"min_samples_split" : range(10,500,20),
"max_depth": rang... | Titanic - Machine Learning from Disaster |
9,067,680 | img_df1p = pd.read_csv(image_kernel_path+"/img_df1p_local.csv")
img_df1p.columns = ['PetID','ImageID','img_par_red','img_par_green','img_par_blue','img_par_score','img_par_pf']
img_df1p.head()<load_from_csv> | cv_result = []
best_estimators = []
for i in range(len(classifier)) :
clf = GridSearchCV(classifier[i], param_grid=classifier_param[i], cv = StratifiedKFold(n_splits = 10), scoring = "accuracy", n_jobs = -1,verbose = 1)
clf.fit(X_train,y_train)
cv_result.append(clf.best_score_)
best_estimators.append(clf.best_estima... | Titanic - Machine Learning from Disaster |
9,067,680 | des_svd_df = pd.read_csv(svd_kernel_path+"/des_svd_df.csv")
des_svd_df.iloc[:,0:10].head()<load_from_csv> | votingC = VotingClassifier(estimators = [("dt",best_estimators[0]),
("rfc",best_estimators[2]),
("lr",best_estimators[3])],
voting = "soft", n_jobs = -1)
votingC = votingC.fit(X_train, y_train)
print(accuracy_score(votingC.predict(X_test),y_test)) | Titanic - Machine Learning from Disaster |
9,067,680 | prev_subm = pd.read_csv(".. /input/pets-adoption-simple-pandas-random-forest/submission.csv")
prev_subm.head()<prepare_output> | test_survived = pd.Series(votingC.predict(test), name = "Survived" ).astype(int)
results = pd.concat([test_PassengerId, test_survived],axis = 1)
results.to_csv("titanic.csv", index = False ) | Titanic - Machine Learning from Disaster |
8,989,402 | rescuers=df_all0.groupby(by='RescuerID')['RescuerID'].count()
df_rescuers=pd.DataFrame(rescuers)
df_rescuers.columns=['ResLev']
df_rescuers.reset_index(inplace=True)
df_rescuers.head()<merge> | submission_format = pd.read_csv("/kaggle/input/titanic/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
8,989,402 | dfm=df_all0.merge(df_rescuers,on='RescuerID')
numeric_cols=['Age','PhotoAmt','Quantity','Fee','DescriptionLength','ResLev']
categorical_cols=['Sterilized','FurLength','Breed1','State','AdoptionSpeed','Breed2','MaturitySize','Gender','Dewormed','Color1','Color2','Color3','Health']
cols=['PetID']+numeric_cols+categorica... | train_data_orig = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data=train_data_orig.copy()
train_data.head() | Titanic - Machine Learning from Disaster |
8,989,402 | dfm=dfm.merge(txt_data,on='PetID', how='left')
categorical_cols=categorical_cols+['sent_language']
dfm.shape<merge> | test_data_orig = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data=test_data_orig.copy()
test_data.head() | Titanic - Machine Learning from Disaster |
8,989,402 | n_svd=32
svd=des_svd_df.iloc[:,0:n_svd+3]
svd.drop('Description',axis=1,inplace=True)
svd.drop('AdoptionSpeed',axis=1,inplace=True)
dfm=dfm.merge(svd,on='PetID', how='left')
dfm.shape<groupby> | distinct_classes,value_counts=np.unique(train_data.Survived,return_counts=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ad=img_df1a.groupby(['PetID'])['img_met_description'].apply(', '.join ).reset_index()<feature_engineering> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ad['img_met_description1']=img_df1ad['img_met_description'].apply(lambda s:s.split(',')).apply(set ).apply(','.join )<filter> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ad['img_met_description1'].loc[0]<filter> | train_data.drop('Cabin',axis=1,inplace=True)
test_data.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ad['img_met_description'].loc[0]<drop_column> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ad.drop('img_met_description',axis=1,inplace=True)
img_df1ad.head()<import_modules> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD<train_on_grid> | train_data.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | def find_svd(df,txt_col_name,n_comp):
tfv = TfidfVectorizer(analyzer='word', stop_words = 'english', token_pattern=r'\b[a-zA-Z]\w+\b',
min_df=1, max_features=10000, strip_accents='unicode',
ngram_range=(1, 32), use_idf=1, smooth_idf=1, sublinear_tf=1,)
corpus=list(df[txt_col_name])
txt_trasf=tfv.fit_transform(corpus)... | testPIds=test_data['PassengerId']
test_data.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | nc=16
img_met_svd=find_svd(img_df1ad,'img_met_description1',nc)
img_met_svd.columns=['SVD_'+str(c)for c in range(0,nc)]
img_met_svd['PetID']=img_df1ad['PetID']<groupby> | def change_gender_num(s):
if(s=='male'):
return 1
else:
return 0
train_data['Sex']=train_data['Sex'].apply(change_gender_num)
test_data['Sex']=test_data['Sex'].apply(change_gender_num ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1ar=img_met_svd
img_df1ar['img_met_score_max']=img_df1a.groupby(by=['PetID','ImageID'],as_index=False ).agg({'img_met_score': 'max'})['img_met_score']
img_df1ar['img_met_score_min']=img_df1a.groupby(by=['PetID','ImageID'],as_index=False ).agg({'img_met_score': 'min'})['img_met_score']
img_df1ar.head()<drop_column... | train_data['relatives']=train_data['SibSp']+train_data['Parch']+1
train_data.drop(['SibSp','Parch'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1cr1=img_df1c[img_df1c['ImageID']==1]
img_df1cr1.drop('ImageID', axis=1, inplace=True)
img_df1cr1.columns=['PetID','img_crp_x1','img_crp_y1','img_crp_conf1','img_crp_if1']
img_df1cr2=img_df1c[img_df1c['ImageID']==2]
img_df1cr2.drop('ImageID', axis=1, inplace=True)
img_df1cr2.columns=['PetID','img_crp_x2','img_c... | test_data['relatives']=test_data['SibSp']+test_data['Parch']+1
test_data.drop(['SibSp','Parch'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1cr=img_df1cr.merge(img_df1cr2,on='PetID')
img_df1cr=img_df1cr.merge(img_df1cr3,on='PetID')
img_df1cr.head()<count_missing_values> | len(train_data.Ticket.unique() ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1cr.isna().sum()<correct_missing_values> | train_data.drop('Ticket',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1cr.fillna(-1, inplace=True )<groupby> | test_data.drop('Ticket',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1pg=img_df1p.groupby(by=['PetID','ImageID'],as_index=False ).agg({'img_par_score': 'max',
'img_par_red':'first',
'img_par_green':'first',
'img_par_blue':'first',
'img_par_pf':'first'})
img_df1pg.head()<drop_column> | def get_title(name):
return name.strip().split(',')[1].split('.')[0]
train_data['title']=train_data['Name'].apply(get_title)
train_data.drop('Name',axis=1,inplace=True)
test_data['title']=test_data['Name'].apply(get_title)
test_data.drop('Name',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1pr1=img_df1pg[img_df1pg['ImageID']==1]
img_df1pr1.drop('ImageID', axis=1, inplace=True)
img_df1pr1.columns=['PetID','img_par_red1','img_par_green1','img_par_blue1','img_par_pf1','img_par_score1']
img_df1pr2=img_df1pg[img_df1pg['ImageID']==2]
img_df1pr2.drop('ImageID', axis=1, inplace=True)
img_df1pr2.columns=[... | matplotlib.rcParams['figure.figsize']=(15,10 ) | Titanic - Machine Learning from Disaster |
8,989,402 | img_df1pr=img_df1pr.merge(img_df1pr2,on='PetID')
img_df1pr=img_df1pr.merge(img_df1pr3,on='PetID')
img_df1pr.head()<merge> | ( keys,values)=np.unique(train_data[train_data.Survived==1].title,return_counts=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img=img_df1ar
img=img.merge(img_df1cr,on=['PetID'], how='left')
img=img.merge(img_df1pr,on=['PetID'], how='left')
img.shape<correct_missing_values> | train_data.Age.fillna(train_data.Age.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | img.fillna(-1,inplace=True)
img.head()<merge> | test_data.Age.fillna(test_data.Age.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | dfm=dfm.merge(img,on='PetID', how='left')
dfm.shape<data_type_conversions> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | df_all['sent_magnitude'].fillna(-1, inplace=True)
df_all['sent_score'].fillna(-1, inplace=True)
df_all['sent_language'].fillna('en', inplace=True )<correct_missing_values> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | df_all.fillna(-1, inplace=True )<data_type_conversions> | train_data.fillna(train_data.Embarked.value_counts().idxmax() ,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | df_all[categorical_cols]=df_all[categorical_cols].apply(lambda c : c.astype('category'))<save_to_csv> | test_data.fillna(test_data.Fare.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | df_all.to_csv('df_all.csv')
df_all.head()<filter> | survived_train_data=train_data[train_data.Survived==1] | Titanic - Machine Learning from Disaster |
8,989,402 | df_all.dtypes[df_all.dtypes=='object']<filter> | ( keys,values)=np.unique(survived_train_data.Embarked,return_counts=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | dftrain=df_all[np.invert(df_all['AdoptionSpeed']==-1)].copy()
dftest=df_all[df_all['AdoptionSpeed']==-1].copy()<drop_column> | dummies=pd.get_dummies(train_data.Embarked ) | Titanic - Machine Learning from Disaster |
8,989,402 | dftrain = dftrain.drop(['PetID'],axis=1)
dftest = dftest.drop(['PetID'],axis=1 )<prepare_x_and_y> | dummies_test=pd.get_dummies(test_data.Embarked ) | Titanic - Machine Learning from Disaster |
8,989,402 | XT = dftest.drop('AdoptionSpeed',axis=1)
y = dftrain['AdoptionSpeed']
X = dftrain.drop('AdoptionSpeed',axis=1 )<import_modules> | train_data2=pd.concat([train_data,dummies],axis='columns' ) | Titanic - Machine Learning from Disaster |
8,989,402 | from sklearn.model_selection import train_test_split
from sklearn.metrics import cohen_kappa_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import KFold<import_modules> | test_data2=pd.concat([test_data,dummies_test],axis='columns' ) | Titanic - Machine Learning from Disaster |
8,989,402 | import lightgbm as lgb<define_variables> | train_data2.drop('Embarked',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | cat_features=[x for x in categorical_cols if x!='AdoptionSpeed']<init_hyperparams> | test_data2.drop('Embarked',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | parameters = {'application': 'regression',
'boosting': 'gbdt',
'metric': 'rmse',
'max_bin' : 8,
'num_leaves': 12,
'max_depth': 4,
'learning_rate': 0.01,
'bagging_fraction': 0.8,
'feature_fraction': 0.8,
'min_split_gain': 0.01,
'min_child_samples': 128,
'min_child_weight': 0.1,
'data_random_seed': 123,
'verbosity': -1,
... | thresh_title_counts=10
title_names=(train_data2.title.value_counts() < thresh_title_counts ) | Titanic - Machine Learning from Disaster |
8,989,402 | def qks(a,b):
return cohen_kappa_score(np.round(a), np.round(b), weights='quadratic' )<split> | train_data2['title']=train_data2.title.apply(lambda x:'Misc' if title_names.loc[x]==True else x ) | Titanic - Machine Learning from Disaster |
8,989,402 | kf_splits=10
k_fold = KFold(n_splits=kf_splits, shuffle=True)
k=0
df_qks=pd.DataFrame(columns=['best_round','qks_train','qks_valid'])
df_y=pd.DataFrame(index=XT.index)
perf_list=[]
for train_idx, valid_idx in k_fold.split(X,y):
k=k+1
print('Step k={}'.format(k))
X_train = X.iloc[train_idx, :]
X_valid = X.iloc[valid_... | distinct_keys=list(train_data2['title'].value_counts().keys() ) | Titanic - Machine Learning from Disaster |
8,989,402 | df_all[df_all['AdoptionSpeed'].astype(int)>=0]['AdoptionSpeed'].value_counts()<count_values> | distinct_keys.remove('Misc' ) | Titanic - Machine Learning from Disaster |
8,989,402 | sum(ym>3.5 )<statistical_test> | test_data2['title']=test_data2.title.apply(lambda x:'Misc' if x not in distinct_keys else x ) | Titanic - Machine Learning from Disaster |
8,989,402 | def distrib_err(coef,test_proba,train_label):
test_predictions = pd.cut(test_proba, [-np.inf] + list(np.sort(coef)) + [np.inf], labels = [0, 1, 2, 3, 4])
N_CLASS=5
freq_train=np.zeros(N_CLASS)
freq_test=np.zeros(N_CLASS)
delta_freq=np.zeros(N_CLASS)
for i in range(0,N_CLASS):
freq_train[i]=100*Counter(train_label)[... | test_data2['title'].value_counts() | Titanic - Machine Learning from Disaster |
8,989,402 | initial_coef = [2.0, 2.5, 3.0, 3.5]
distrib_err_partial = partial(distrib_err, test_proba=ym, train_label=y)
final_coef = sp.optimize.minimize(distrib_err_partial, initial_coef, method='nelder-mead')
final_coef<categorify> | dummies_embarked_train=pd.get_dummies(train_data2['title'] ) | Titanic - Machine Learning from Disaster |
8,989,402 | def apply_lim(y_calc,limits):
y_round=np.zeros(len(y_calc))
for i,yc in enumerate(y_calc):
if(yc<=limits[0]):
y_round[i]=0
if(( yc>limits[0])&(yc<=limits[1])) :
y_round[i]=1
if(( yc>limits[1])&(yc<=limits[2])) :
y_round[i]=2
if(( yc>limits[2])&(yc<=limits[3])) :
y_round[i]=3
if(yc>limits[3]):
y_round[i]=4
return y_roun... | dummies_embarked_test=pd.get_dummies(test_data2['title'] ) | Titanic - Machine Learning from Disaster |
8,989,402 | y_test_pred_r = apply_lim(ym,final_coef['x'] )<data_type_conversions> | train_data3=pd.concat([train_data2,dummies_embarked_train],axis='columns' ) | Titanic - Machine Learning from Disaster |
8,989,402 | y_pred = y_test_pred_r.astype('int' )<prepare_output> | test_data3=pd.concat([test_data2,dummies_embarked_test],axis='columns' ) | Titanic - Machine Learning from Disaster |
8,989,402 | subm=pd.DataFrame({'PetID': dftest_ids,'AdoptionSpeed': y_pred})
subm.head()<count_values> | train_data3.drop('title',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | subm['AdoptionSpeed'].value_counts()<save_to_csv> | test_data3.drop('title',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,989,402 | subm.to_csv('submission.csv', index=False )<import_modules> | train_data3.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | np.random.seed(369 )<compute_test_metric> | test_data3.isnull().sum() | Titanic - Machine Learning from Disaster |
8,989,402 | def confusion_matrix(rater_a, rater_b, min_rating=None, max_rating=None):
assert(len(rater_a)== len(rater_b))
if min_rating is None:
min_rating = min(rater_a + rater_b)
if max_rating is None:
max_rating = max(rater_a + rater_b)
num_ratings = int(max_rating - min_rating + 1)
conf_mat = [[0 for i in range(num_rating... | yTrain=train_data3.Survived
train_data4=train_data3.drop('Survived',axis=1)
xTrain=train_data4.values | Titanic - Machine Learning from Disaster |
8,989,402 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | xTest=test_data3.values | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.