kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,249,093 | def aug_data(df):
target_df = df.copy()
new_df = aug_df[aug_df['id'].isin(target_df['id'])]
del target_df['structure']
del target_df['predicted_loop_type']
new_df = new_df.merge(target_df, on=['id','sequence'], how='left')
df['cnt'] = df['id'].map(new_df[['id','cnt']].set_index('id' ).to_dict() ['cnt'])
df['log_gamma... | clf = xgb.XGBClassifier(
learning_rate = 0.02,
n_estimators= 2000,
max_depth= 4,
min_child_weight= 2,
gamma=0.9,
subsample=0.8,
colsample_bytree=0.8,
objective= 'binary:logistic',
nthread= -1,
scale_pos_weight=1 ) | Titanic - Machine Learning from Disaster |
2,249,093 | if debug:
train = train[:200]
test = test[:200]<split> | xgbm = clf.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
2,249,093 | def train_and_predict(type = 0, FOLD_N = 5):
gkf = GroupKFold(n_splits=FOLD_N)
public_df = test.query("seq_length == 107" ).copy()
private_df = test.query("seq_length == 130" ).copy()
public_inputs = preprocess_inputs(public_df)
private_inputs = preprocess_inputs(private_df)
holdouts = []
holdout_preds = []
for cv,(... | predictions = xgbm.predict(x_test ) | Titanic - Machine Learning from Disaster |
2,249,093 | <prepare_output><EOS> | submissionStacking = pd.DataFrame({ 'PassengerId': test_df["PassengerId"],'Survived': predictions })
submissionStacking.to_csv("submission_ensamble.csv", index=False ) | Titanic - Machine Learning from Disaster |
570,499 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
570,499 | submission = preds_df[['id_seqpos', 'reactivity', 'deg_Mg_pH10', 'deg_pH10', 'deg_Mg_50C', 'deg_50C']]
submission.to_csv(f'submission.csv', index=False)
print(f'wrote to submission.csv' )<load_from_disk> | test_df = pd.read_csv(".. /input/test.csv")
train_df = pd.read_csv(".. /input/train.csv" ) | Titanic - Machine Learning from Disaster |
570,499 | def print_mse(prd):
val = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines=True)
val_data = []
for mol_id in val['id'].unique() :
sample_data = val.loc[val['id'] == mol_id]
sample_seq_length = sample_data.seq_length.values[0]
for i in range(68):
sample_dict = {
'id_seqpos' : sample_data['id'].values[0... | total = train_df.isnull().sum().sort_values(ascending=False)
percent_1 = train_df.isnull().sum() /train_df.isnull().count() *100
percent_2 =(round(percent_1, 1)).sort_values(ascending=False)
missing_data = pd.concat([total, percent_2], axis=1, keys=['Total', '%'])
missing_data.head(5 ) | Titanic - Machine Learning from Disaster |
570,499 | print_mse(holdouts_df )<compute_test_metric> | data = [train_df, test_df]
for dataset in data:
dataset['relatives'] = dataset['SibSp'] + dataset['Parch']
dataset.loc[dataset['relatives'] > 0, 'not_alone'] = 0
dataset.loc[dataset['relatives'] == 0, 'not_alone'] = 1
dataset['not_alone'] = dataset['not_alone'].astype(int ) | Titanic - Machine Learning from Disaster |
570,499 | print_mse(holdouts_df[holdouts_df.SN_filter == 1] )<define_variables> | train_df['not_alone'].value_counts() | Titanic - Machine Learning from Disaster |
570,499 | debug = False<set_options> | train_df = train_df.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
570,499 | warnings.filterwarnings('ignore')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
SEED = 2020
def seed_everything(seed=2020):
random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
seed_everything(SEED )<compute_t... | deck = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6, "G": 7, "U": 8}
data = [train_df, test_df]
for dataset in data:
dataset['Cabin'] = dataset['Cabin'].fillna("U0")
dataset['Deck'] = dataset['Cabin'].map(lambda x: re.compile("([a-zA-Z]+)" ).search(x ).group())
dataset['Deck'] = dataset['Deck'].map(deck)
dataset[... | Titanic - Machine Learning from Disaster |
570,499 | class RMSELoss(nn.Module):
def __init__(self, eps=1e-6):
super().__init__()
self.mse = nn.MSELoss()
self.eps = eps
def forward(self, yhat, y):
loss = torch.sqrt(self.mse(yhat, y)+ self.eps)
return loss
class MCRMSELoss(nn.Module):
def __init__(self, num_scored=3):
super().__init__()
self.rmse = RMSELoss()
self.num_sco... | train_df = train_df.drop(['Cabin'], axis=1)
test_df = test_df.drop(['Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
570,499 | def load_json(path):
return pd.read_json(path, lines=True)
df = load_json('/kaggle/input/stanford-covid-vaccine/train.json')
df_test = load_json('/kaggle/input/stanford-covid-vaccine/test.json')
sample_sub = pd.read_csv('/kaggle/input/stanford-covid-vaccine/sample_submission.csv')
if debug:
df = df[:200]
df_test = ... | data = [train_df, test_df]
for dataset in data:
mean = train_df["Age"].mean()
std = test_df["Age"].std()
is_null = dataset["Age"].isnull().sum()
rand_age = np.random.randint(mean - std, mean + std, size = is_null)
age_slice = dataset["Age"].copy()
age_slice[np.isnan(age_slice)] = rand_age
dataset["Age"] = age_slice
da... | Titanic - Machine Learning from Disaster |
570,499 | print(set(df["sequence"].sum()))
print(set(df["structure"].sum()))
print(set(df["predicted_loop_type"].sum()))
sequence_and_structure = [i + j for i in "GACU" for j in "()."]
sequence_and_predicted_loop_type = [i + j for i in "GACU" for j in "XEMBHSI"]
structure_and_predicted_loop_type = [i + j for i in "()." for j in ... | train_df["Age"].isnull().sum() | Titanic - Machine Learning from Disaster |
570,499 | def merge_seq_seq(seq):
half = len(seq)//2
new_seq = []
for i in range(len(seq)//2):
new_seq.append(seq[i] + seq[i+half])
return new_seq
<feature_engineering> | common_value = 'S'
data = [train_df, test_df]
for dataset in data:
dataset['Embarked'] = dataset['Embarked'].fillna(common_value ) | Titanic - Machine Learning from Disaster |
570,499 | create_feture = True
preprocess_cols=["sequence", "structure", "predicted_loop_type"]
if create_feture:
df["sequence_and_structure"] =(df["sequence"] + df["structure"] ).apply(merge_seq_seq)
df_test["sequence_and_structure"] =(df_test["sequence"] + df_test["structure"] ).apply(merge_seq_seq)
preprocess_cols=["sequenc... | data = [train_df, test_df]
for dataset in data:
dataset['Fare'] = dataset['Fare'].fillna(0)
dataset['Fare'] = dataset['Fare'].astype(int ) | Titanic - Machine Learning from Disaster |
570,499 | target_cols = ["reactivity", "deg_Mg_pH10", "deg_Mg_50C"]
tokens = [i for i in "().ACGUBEHIMSX"] + sequence_and_structure + sequence_and_predicted_loop_type + structure_and_predicted_loop_type
token2int = {x:i for i, x in enumerate(tokens)}
def preprocess_inputs(df, cols):
base_fea = np.transpose(
np.array(
df[cols].... | data = [train_df, test_df]
titles = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in data:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr',\
'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona... | Titanic - Machine Learning from Disaster |
570,499 | models = ["LSTM", "LSTM_short", "GRU", "blend1", "blend2", "blend3", "blend4"]
models = [
{"model": "LSTM", "dropout": 0.4, "embed_dim": 100, "hidden_dim": 128, "hidden_layers": 3},
{"model": "LSTM", "dropout": 0.4, "embed_dim": 100, "hidden_dim": 256, "hidden_layers": 3}
]
<define_search_model> | train_df = train_df.drop(['Name'], axis=1)
test_df = test_df.drop(['Name'], axis=1 ) | Titanic - Machine Learning from Disaster |
570,499 | class Wave_Block(nn.Module):
def __init__(self, in_channels, out_channels, dilation_rates, kernel_size):
super(Wave_Block, self ).__init__()
self.num_rates = dilation_rates
self.convs = nn.ModuleList()
self.filter_convs = nn.ModuleList()
self.gate_convs = nn.ModuleList()
self.convs.append(nn.Conv1d(in_channels, out_cha... | genders = {"male": 0, "female": 1}
data = [train_df, test_df]
for dataset in data:
dataset['Sex'] = dataset['Sex'].map(genders ) | Titanic - Machine Learning from Disaster |
570,499 | FOLDS = 4
EPOCHS = 100
if debug:
EPOCHS = 2
BATCH_SIZE = 64
VERBOSE = 2
LR = 0.016<create_dataframe> | train_df = train_df.drop(['Ticket'], axis=1)
test_df = test_df.drop(['Ticket'], axis=1 ) | Titanic - Machine Learning from Disaster |
570,499 | public_df = df_test.query("seq_length == 107" ).copy()
private_df = df_test.query("seq_length == 130" ).copy()
public_inputs = torch.tensor(preprocess_inputs(public_df, preprocess_cols)).to(device)
private_inputs = torch.tensor(preprocess_inputs(private_df, preprocess_cols)).to(device)
public_loader = DataLoader(Tens... | ports = {"S": 0, "C": 1, "Q": 2}
data = [train_df, test_df]
for dataset in data:
dataset['Embarked'] = dataset['Embarked'].map(ports ) | Titanic - Machine Learning from Disaster |
570,499 | if debug:
kmeans_model = KMeans(n_clusters=50, random_state=110 ).fit(preprocess_inputs(df, preprocess_cols)[:,:,0])
else:
kmeans_model = KMeans(n_clusters=200, random_state=110 ).fit(preprocess_inputs(df, preprocess_cols)[:,:,0])
kmeans_labels = kmeans_model.labels_<init_hyperparams> | data = [train_df, test_df]
for dataset in data:
dataset['Age'] = dataset['Age'].astype(int)
dataset.loc[ dataset['Age'] <= 11, 'Age'] = 0
dataset.loc[(dataset['Age'] > 11)&(dataset['Age'] <= 18), 'Age'] = 1
dataset.loc[(dataset['Age'] > 18)&(dataset['Age'] <= 22), 'Age'] = 2
dataset.loc[(dataset['Age'] > 22)&(dataset[... | Titanic - Machine Learning from Disaster |
570,499 | model_histories = {str(model_id): [] for model_id in models}
model_oof_preds = {str(model_id): np.zeros(( df.shape[0], 68, len(target_cols)))for model_id in models}
model_private_preds = {str(model_id): np.zeros(( private_df.shape[0], 130, len(target_cols)))for model_id in models}
model_public_preds = {str(model_id): n... | train_df['Age'].value_counts() | Titanic - Machine Learning from Disaster |
570,499 | public_df = df_test.query("seq_length == 107" ).copy()
private_df = df_test.query("seq_length == 130" ).copy()
public_inputs = preprocess_inputs(public_df, preprocess_cols)
private_inputs = preprocess_inputs(private_df, preprocess_cols )<prepare_output> | data = [train_df, test_df]
for dataset in data:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31), 'Fare'] = 2
dataset.loc[(dataset['Fare'] > 31)&(dataset['Fare'] <= 99), 'Fare'] ... | Titanic - Machine Learning from Disaster |
570,499 | preds_model = {str(model_id): [] for model_id in models}
submissions = {}
for model_dict in models:
model_id = str(model_dict)
for df, preds in [(public_df, model_public_preds[model_id]),(private_df, model_private_preds[model_id])]:
for i, uid in enumerate(df.id):
single_pred = preds[i]
single_df = pd.DataFrame(single... | data = [train_df, test_df]
for dataset in data:
dataset['Age_Class']= dataset['Age']* dataset['Pclass'] | Titanic - Machine Learning from Disaster |
570,499 | if True:
id_seqpos = submissions[str(models[0])]["id_seqpos"]
ensemble_submission = submissions[str(models[0])].drop("id_seqpos",axis=1)*best_alpha + submissions[str(models[1])].drop("id_seqpos",axis=1)*(1-best_alpha)
ensemble_submission["id_seqpos"] = id_seqpos
ensemble_submission.to_csv(f'submission_lstm_gru_ensembl... | for dataset in data:
dataset['Fare_Per_Person'] = dataset['Fare']/(dataset['relatives']+1)
dataset['Fare_Per_Person'] = dataset['Fare_Per_Person'].astype(int ) | Titanic - Machine Learning from Disaster |
570,499 | if not debug:
!curl -X POST -H 'Content-type: application/json' --data '{"text":"commit done! "}' <your_webhook_url><import_modules> | train_df.head(20 ) | Titanic - Machine Learning from Disaster |
570,499 | import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import StratifiedShuffleSplit
from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten, Convolution1D, Dropout
from keras.opt... | X_train = train_df.drop("Survived", axis=1)
Y_train = train_df["Survived"]
X_test = test_df.drop("PassengerId", axis=1 ).copy() | Titanic - Machine Learning from Disaster |
570,499 | train = pd.read_csv('.. /input/leaf-classification/train.csv.zip')
test = pd.read_csv('.. /input/leaf-classification/test.csv.zip')
<categorify> | sgd = linear_model.SGDClassifier(max_iter=5, tol=None)
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
sgd.score(X_train, Y_train)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
print(round(acc_sgd,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | def encode(train, test):
label_encoder = LabelEncoder().fit(train.species)
labels = label_encoder.transform(train.species)
classes = list(label_encoder.classes_)
train = train.drop(['species', 'id'], axis=1)
test_ids=test.id
test = test.drop('id', axis=1)
return train, labels, test, classes,test_ids<categorify> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
print(round(acc_random_forest,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | train, labels, test, classes,test_ids = encode(train, test)
<normalization> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2)
print(round(acc_log,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | scaler = StandardScaler().fit(train.values)
scaled_train = scaler.transform(train.values )<split> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
print(round(acc_knn,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | sss = StratifiedShuffleSplit(test_size=0.1, random_state=23)
for train_index, valid_index in sss.split(scaled_train, labels):
X_train, X_valid = scaled_train[train_index], scaled_train[valid_index]
y_train, y_valid = labels[train_index], labels[valid_index]
<define_variables> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
print(round(acc_gaussian,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | nb_features = 64
nb_class = len(classes )<prepare_x_and_y> | perceptron = Perceptron(max_iter=5)
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2)
print(round(acc_perceptron,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | X_train_r = np.zeros(( len(X_train), nb_features, 3))
X_train_r[:, :, 0] = X_train[:, :nb_features]
X_train_r[:, :, 1] = X_train[:, nb_features:128]
X_train_r[:, :, 2] = X_train[:, 128:]
X_valid_r = np.zeros(( len(X_valid), nb_features, 3))
X_valid_r[:, :, 0] = X_valid[:, :nb_features]
X_valid_r[:, :, 1] = X_valid[:, n... | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2)
print(round(acc_linear_svc,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | model = Sequential()
model.add(Convolution1D(512, 1, input_shape=(nb_features, 3)))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dropout(0.4))
model.add(Dense(2048, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(nb_class))
model.add(Activation('softmax'))<train_model> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
print(round(acc_decision_tree,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | y_train = np_utils.to_categorical(y_train, nb_class)
y_valid = np_utils.to_categorical(y_valid, nb_class)
sgd = SGD(lr=0.01, nesterov=True, decay=1e-6, momentum=0.9)
model.compile(loss='categorical_crossentropy',optimizer=sgd,metrics=['accuracy'])
nb_epoch = 15
model.fit(X_train_r, y_train, epochs=nb_epoch, validat... | rf = RandomForestClassifier(n_estimators=100)
scores = cross_val_score(rf, X_train, Y_train, cv=10, scoring = "accuracy" ) | Titanic - Machine Learning from Disaster |
570,499 | scaler = StandardScaler().fit(test.values)
scaled_test = scaler.transform(test.values )<prepare_x_and_y> | print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std() ) | Titanic - Machine Learning from Disaster |
570,499 | test_dataset = np.zeros(( len(scaled_test), nb_features, 3))
test_dataset[:, :, 0] = scaled_test[:, :nb_features]
test_dataset[:, :, 1] = scaled_test[:, nb_features:128]
test_dataset[:, :, 2] = scaled_test[:, 128:]<predict_on_test> | importances = pd.DataFrame({'feature':X_train.columns,'importance':np.round(random_forest.feature_importances_,3)})
importances = importances.sort_values('importance',ascending=False ).set_index('feature' ) | Titanic - Machine Learning from Disaster |
570,499 | preds_test = model.predict_proba(test_dataset)
preds_test<prepare_output> | train_df = train_df.drop("not_alone", axis=1)
test_df = test_df.drop("not_alone", axis=1)
train_df = train_df.drop("Parch", axis=1)
test_df = test_df.drop("Parch", axis=1 ) | Titanic - Machine Learning from Disaster |
570,499 | submission = pd.DataFrame(preds_test, columns=classes)
submission.insert(0, 'id', test_ids)
submission<save_to_csv> | random_forest = RandomForestClassifier(n_estimators=100, oob_score = True)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
print(round(acc_random_forest,2,), "%" ) | Titanic - Machine Learning from Disaster |
570,499 | submission.to_csv('submission.csv', index=False)
print('done!' )<import_modules> | print("oob score:", round(random_forest.oob_score_, 4)*100, "%" ) | Titanic - Machine Learning from Disaster |
570,499 | import pandas as pd
import numpy as np
from sklearn.model_selection import GridSearchCV
import xgboost as xgb
from sklearn.model_selection import cross_val_score
from sklearn.metrics import log_loss
from sklearn.preprocessing import LabelBinarizer
from sklearn.linear_model import LogisticRegression
from sklearn.preproc... | random_forest = RandomForestClassifier(criterion = "gini",
min_samples_leaf = 1,
min_samples_split = 10,
n_estimators=100,
max_features='auto',
oob_score=True,
random_state=1,
n_jobs=-1)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
print("oob... | Titanic - Machine Learning from Disaster |
570,499 | train = pd.read_csv('.. /input/leaf-classification/train.csv.zip' , index_col = False)
train<drop_column> | predictions = cross_val_predict(random_forest, X_train, Y_train, cv=3)
confusion_matrix(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
570,499 | x_train = train.drop(['id', 'species'], axis=1 ).values<categorify> | print("Precision:", precision_score(Y_train, predictions))
print("Recall:",recall_score(Y_train, predictions)) | Titanic - Machine Learning from Disaster |
570,499 | le = LabelEncoder().fit(train['species'])
y_train = le.transform(train['species'] )<normalization> | f1_score(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
570,499 | scaler = StandardScaler().fit(x_train)
x_train = scaler.transform(x_train )<train_model> | y_scores = random_forest.predict_proba(X_train)
y_scores = y_scores[:,1]
precision, recall, threshold = precision_recall_curve(Y_train, y_scores ) | Titanic - Machine Learning from Disaster |
570,499 | clf = LogisticRegression(solver='lbfgs', multi_class='multinomial')
clf.fit(x_train, y_train )<load_from_csv> | false_positive_rate, true_positive_rate, thresholds = roc_curve(Y_train, y_scores ) | Titanic - Machine Learning from Disaster |
570,499 | test = pd.read_csv('.. /input/leaf-classification/test.csv.zip' ,index_col = False)
test<prepare_x_and_y> | r_a_score = roc_auc_score(Y_train, y_scores)
print("ROC-AUC-Score:", r_a_score ) | Titanic - Machine Learning from Disaster |
570,499 | test_ids = test.pop('id')
x_test = test.values<prepare_x_and_y> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": Y_prediction
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
5,616,085 | x_test = test.values<predict_on_test> | make_scorer,classification_report,roc_auc_score,roc_curve,
average_precision_score,precision_recall_curve)
pd.set_option('display.max_columns', None)
warnings.filterwarnings("ignore")
RANDOM_SEED = 101
| Titanic - Machine Learning from Disaster |
5,616,085 | x_test = scaler.transform(x_test)
y_test = clf.predict_proba(x_test )<create_dataframe> | sub_file = pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
sub_file.head() | Titanic - Machine Learning from Disaster |
5,616,085 | submission = pd.DataFrame(y_test, index=test_ids, columns=le.classes_ )<save_to_csv> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
train.head() | Titanic - Machine Learning from Disaster |
5,616,085 | submission.to_csv('./submission_leaf_classification.csv')
print('Done' )<import_modules> | val = pd.read_csv("/kaggle/input/titanic/test.csv")
val.head() | Titanic - Machine Learning from Disaster |
5,616,085 | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from keras.models import Sequential
from keras.layers import Dense,Dropout,Act... | train.isnull().mean() | Titanic - Machine Learning from Disaster |
5,616,085 | data = pd.read_csv('.. /input/leaf-classification/train.csv')
parent_data = data.copy()
ID = data.pop('id')
y = data.pop('species')
y = LabelEncoder().fit(y ).transform(y)
print(y.shape)
X = StandardScaler().fit(data ).transform(data)
print(X.shape)
y_cat = to_categorical(y)
print(y_cat.shape )<train_model> | target = 'Survived' | Titanic - Machine Learning from Disaster |
5,616,085 | model = Sequential()
model.add(Dense(1500,input_dim=192, kernel_initializer = 'uniform', activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(1500, activation='sigmoid'))
model.add(Dropout(0.1))
model.add(Dense(99, activation='softmax'))
model.compile(loss='categorical_crossentropy',optimizer='rmsprop', metrics ... | def get_salutation_map(df,var,rare):
sal_dict = {}
for sal, count in df[var].value_counts().to_dict().items() :
count = int(count)
if count < 10:
sal_dict[sal] = rare
else:
sal_dict[sal] = sal
return sal_dict | Titanic - Machine Learning from Disaster |
5,616,085 | print("train/val loss ratio: ", min(history.history['loss'])/min(history.history['val_loss']))<save_to_csv> | train["Salutation"] = train["Name"].map(lambda x: x.split(',')[1].split() [0][:-1] ) | Titanic - Machine Learning from Disaster |
5,616,085 | test = pd.read_csv('.. /input/leaf-classification/test.csv')
index = test.pop('id')
test = StandardScaler().fit(test ).transform(test)
yPred = model.predict_proba(test)
yPred = pd.DataFrame(yPred,index=index,columns=sorted(parent_data.species.unique()))
fp = open('submission_nn_kernel.csv','w')
fp.write(yPred.to_c... | get_salutation_map(train,"Salutation","Rare" ) | Titanic - Machine Learning from Disaster |
5,616,085 | class Data_Clean(object):
def __init__(self):
self.numerical_data, self.num_test_data = self.read_numerical_data()
self.id, self.species, self.num_train, self.test_id, self.test_num = self.split_numerical_data()
def split_numerical_data(self):
id = self.numerical_data.pop('id')
species = self.numerical_data.pop('speci... | train["Salutation"] = train["Name"].map(lambda x: x.split(',')[1].split() [0][:-1])
train["Salutation"] = train["Salutation"].map(get_salutation_map(train,'Salutation','Rare'))
train.head(2 ) | Titanic - Machine Learning from Disaster |
5,616,085 | import csv as csv
import numpy as np
import pandas as pd
import matplotlib.cm as cm
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
from scipy import stats
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.linear_model im... | train['SibSp'].nunique() | Titanic - Machine Learning from Disaster |
5,616,085 | traindf = pd.read_csv('.. /input/train.csv', header=0)
x_train = traindf.drop(['id', 'species'], axis=1)
y_train = traindf.pop('species')
scaler = StandardScaler().fit(x_train)
x_train = scaler.transform(x_train)
<choose_model_class> | train["Family_Size"].value_counts(normalize=True)*100 | Titanic - Machine Learning from Disaster |
5,616,085 | kfold = KFold(n_splits=5, shuffle=True, random_state=4)
<train_model> | def get_family_size_map(df,var):
fam_dict = {}
for size, pct in(df[var].value_counts(normalize=True)*100 ).to_dict().items() :
if size == 0:
fam_dict[size] = "Alone"
elif(size != 0)&(pct > 10.0):
fam_dict[size] = "Small"
else:
fam_dict[size] = "Large"
return fam_dict | Titanic - Machine Learning from Disaster |
5,616,085 | rf = ExtraTreesClassifier(n_estimators=500, random_state=0)
rf_validation=[rf.fit(x_train[train], y_train[train] ).score(x_train[test], y_train[test] ).mean() \
for train, test in kfold.split(x_train)]<prepare_x_and_y> | train["Family_Size"] = train["Family_Size"].map(get_family_size_map(train,'Family_Size'))
train.head(2 ) | Titanic - Machine Learning from Disaster |
5,616,085 | np.random.seed(42)
train = pd.read_csv('.. /input/train.csv')
x_train = train.drop(['id', 'species', 'margin7', 'margin15', 'margin33', 'texture14','margin51','margin60'], axis=1 ).values
le = LabelEncoder().fit(train['species'])
y_train = le.transform(train['species'])
scaler = StandardScaler().fit(x_train)
x_tra... | train.isnull().mean() | Titanic - Machine Learning from Disaster |
5,616,085 | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape )<split> | train['had_Cabin'] = np.where(train['Cabin'].isna() ,0,1 ) | Titanic - Machine Learning from Disaster |
5,616,085 | train_df, val_df = train_test_split(train_df, test_size=0.1, random_state=2018)
embed_size = 300
max_features = 50000
maxlen = 100
train_X = train_df["question_text"].fillna("_na_" ).values
val_X = val_df["question_text"].fillna("_na_" ).values
test_X = test_df["question_text"].fillna("_na_" ).values
tokenizer = Token... | train['Cabin'].dropna().map(lambda x:x[0] ).value_counts() | Titanic - Machine Learning from Disaster |
5,616,085 | np.random.seed(2018)
trn_idx = np.random.permutation(len(train_X))
val_idx = np.random.permutation(len(val_X))
train_X = train_X[trn_idx]
val_X = val_X[val_idx]
train_y = train_y[trn_idx]
val_y = val_y[val_idx]<import_modules> | train['Cabin'] = train['Cabin'].fillna("M")
train['Cabin'] = train['Cabin'].map(lambda x: x[0] ) | Titanic - Machine Learning from Disaster |
5,616,085 | from keras.models import Sequential,Model
from keras.layers import Dense, CuDNNLSTM, Bidirectional, Input, Dropout, Embedding, CuDNNGRU, GlobalMaxPool1D
from keras.optimizers import Adam
from keras import backend as K
from keras.engine.topology import Layer
from keras import initializers, regularizers, constraints<stat... | train.groupby(['Salutation','had_Cabin'] ) | Titanic - Machine Learning from Disaster |
5,616,085 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_em... | mean_dict = {}
for k, df in train.groupby(['Salutation','Family_Size','had_Cabin']):
if df['Age'].isnull().sum() != 0:
mean_dict[k] = df["Age"].mean()
mean_dict | Titanic - Machine Learning from Disaster |
5,616,085 | filter_sizes = [1,2,3,5]
num_filters = 36
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = Reshape(( maxlen, embed_size, 1))(x)
maxpool_pool = []
for i in range(len(filter_sizes)) :
conv = Conv2D(num_filters, kernel_size=(filter_sizes[i], embed_size),
kernel_i... | for k,v in mean_dict.items() :
train.loc[(train["Salutation"] == k[0])&(train["Family_Size"] == k[1])&(train["had_Cabin"] == k[2])&(train["Age"].isna()), "Age"] = v | Titanic - Machine Learning from Disaster |
5,616,085 | model.fit(train_X, train_y, batch_size=512, epochs=3, validation_data=(val_X, val_y))<predict_on_test> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
5,616,085 | pred_cnn_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_cnn_val_y>thresh ).astype(int))))<predict_on_test> | train['Embarked'] = train['Embarked'].fillna(train['Embarked'].mode().values[0] ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_cnn_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
5,616,085 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<choose_model_class> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
5,616,085 | 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... | num_cols = ['Age','Fare']
cat_cols = ['Pclass','Sex','Embarked','Cabin','had_Cabin','Salutation','Family_Size'] | Titanic - Machine Learning from Disaster |
5,616,085 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_em... | train_data = pd.get_dummies(train,columns=cat_cols,drop_first=True)
train_data.head(2 ) | Titanic - Machine Learning from Disaster |
5,616,085 | model.fit(train_X, train_y, batch_size=512, epochs=3, validation_data=(val_X, val_y))<predict_on_test> | explore_data, validation_data = train_test_split(train_data, test_size = 0.2, random_state=RANDOM_SEED, stratify=train[target] ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_glove_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_glove_val_y>thresh ).astype(int))))<predict_on_test> | train_data, test_data = train_test_split(explore_data, test_size = 0.2, random_state=RANDOM_SEED ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_glove_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | def handle_outliers_per_target_class(df,var,target,tol):
gdf = df[df[target] == 1]
var_data = gdf[var].values
q25, q75 = np.percentile(var_data, 25), np.percentile(var_data, 75)
print('Outliers handling for {}'.format(var))
print('Quartile 25: {} | Quartile 75: {}'.format(q25, q75))
iqr = q75 - q25
print('IQR {}'.form... | Titanic - Machine Learning from Disaster |
5,616,085 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | outliers_wrt_target = []
for num_col in num_cols:
outliers_wrt_target.extend(handle_outliers_per_target_class(train_data,num_col,target,1.5))
outliers_wrt_target = list(set(outliers_wrt_target))
train_data = train_data.drop(outliers_wrt_target ) | Titanic - Machine Learning from Disaster |
5,616,085 | EMBEDDING_FILE = '.. /input/embeddings/wiki-news-300d-1M/wiki-news-300d-1M.vec'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE)if len(o)>100)
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_em... | train_data["Fare"] = np.where(train_data["Fare"] != 0,np.log(train_data["Fare"]),np.log(0.00001))
test_data["Fare"] = np.where(test_data["Fare"] != 0,np.log(test_data["Fare"]),np.log(0.00001))
validation_data["Fare"] = np.where(validation_data["Fare"] != 0,np.log(validation_data["Fare"]),np.log(0.00001)) | Titanic - Machine Learning from Disaster |
5,616,085 | model.fit(train_X, train_y, batch_size=512, epochs=3, validation_data=(val_X, val_y))<predict_on_test> | X_train = train_data.drop(['PassengerId', 'Survived', 'Name', 'SibSp', 'Parch', 'Ticket'],axis=1)
y_train = train_data[target] | Titanic - Machine Learning from Disaster |
5,616,085 | pred_fasttext_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_fasttext_val_y>thresh ).astype(int))))<predict_on_test> | X_test = test_data.drop(['PassengerId', 'Survived', 'Name', 'SibSp', 'Parch', 'Ticket'],axis=1)
y_test = test_data[target] | Titanic - Machine Learning from Disaster |
5,616,085 | pred_fasttext_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | X_val = validation_data.drop(['PassengerId', 'Survived', 'Name', 'SibSp', 'Parch', 'Ticket'],axis=1)
y_val = validation_data[target] | Titanic - Machine Learning from Disaster |
5,616,085 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<statistical_test> | y_enc = LabelEncoder()
y_train = y_enc.fit_transform(y_train)
y_test = y_enc.transform(y_test)
y_val = y_enc.transform(y_val ) | Titanic - Machine Learning from Disaster |
5,616,085 | EMBEDDING_FILE = '.. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)>100)
all_embs = np.stack(embeddings_index.... | sc = StandardScaler()
X_train[num_cols] = sc.fit_transform(X_train[num_cols])
X_test[num_cols] = sc.transform(X_test[num_cols])
X_val[num_cols] = sc.transform(X_val[num_cols] ) | Titanic - Machine Learning from Disaster |
5,616,085 | model.fit(train_X, train_y, batch_size=512, epochs=3, validation_data=(val_X, val_y))<predict_on_test> | clf = LogisticRegression() | Titanic - Machine Learning from Disaster |
5,616,085 | pred_paragram_val_y = model.predict([val_X], batch_size=1024, verbose=1)
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, metrics.f1_score(val_y,(pred_paragram_val_y>thresh ).astype(int))))<predict_on_test> | clf.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_paragram_test_y = model.predict([test_X], batch_size=1024, verbose=1 )<set_options> | y_pred = clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
5,616,085 | del word_index, embeddings_index, all_embs, embedding_matrix, model, inp, x
time.sleep(10 )<find_best_params> | confusion_matrix(y_test,y_pred ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_val_y =(4 * pred_glove_val_y + pred_fasttext_val_y + 3 * pred_paragram_val_y + 2 * pred_cnn_val_y)/ 10.0
thresholds = []
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
res = metrics.f1_score(val_y,(pred_val_y > thresh ).astype(int))
thresholds.append([thresh, res])
print("F1 score at thr... | accuracy_score(y_test,y_pred ) | Titanic - Machine Learning from Disaster |
5,616,085 | pred_test_y =(4 * pred_glove_test_y + pred_fasttext_test_y + 3 * pred_paragram_test_y + 2 * pred_cnn_test_y)/ 10.0
pred_test_y =(pred_test_y > best_thresh ).astype(int)
out_df = pd.DataFrame({"qid":test_df["qid"].values})
out_df['prediction'] = pred_test_y
out_df.to_csv("submission.csv", index=False )<load_from_csv> | classification_models = ['LogisticRegression',
'SVC',
'DecisionTreeClassifier',
'RandomForestClassifier',
'AdaBoostClassifier'] | Titanic - Machine Learning from Disaster |
5,616,085 | def load_data() :
train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape)
return train_df, test_df<split> | cm = []
acc = []
prec = []
rec = []
f1 = []
models = []
estimators = [] | Titanic - Machine Learning from Disaster |
5,616,085 | train_df, test_df = load_data()
train_df.sample()<compute_test_metric> | for classfication_model in classification_models:
model = eval(classfication_model )()
model.fit(X_train,y_train)
y_pred = model.predict(X_test)
models.append(type(model ).__name__)
estimators.append(( type(model ).__name__,model))
cm.append(confusion_matrix(y_test,y_pred))
acc.append(accuracy_score(y_test,y_pred))
... | Titanic - Machine Learning from Disaster |
5,616,085 | def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32' )<load_pretrained> | vc = VotingClassifier(estimators)
vc.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
5,616,085 | EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
print('Found %s word vectors.' % len(embeddings_index))<feature_engineering> | y_pred = vc.predict(X_test)
models.append(type(vc ).__name__)
cm.append(confusion_matrix(y_test,y_pred))
acc.append(accuracy_score(y_test,y_pred))
prec.append(precision_score(y_test,y_pred))
rec.append(recall_score(y_test,y_pred))
f1.append(f1_score(y_test,y_pred)) | Titanic - Machine Learning from Disaster |
5,616,085 | def check_coverage(vocab,embeddings_index):
a, oov, k, i = {}, {}, 0, 0
for word in vocab:
try:
a[word] = embeddings_index[word]
k += vocab[word]
except:
oov[word] = vocab[word]
i += vocab[word]
pass
print(f'Found embeddings for {(len(a)/ len(vocab)) :.2%} of vocab')
print(f'Found embeddings for {(k /(k + i)) :.2%} of... | model_dict = {"Models":models,
"CM":cm,
"Accuracy":acc,
"Precision":prec,
"Recall":rec,
"f1_score":f1} | Titanic - Machine Learning from Disaster |
5,616,085 | vocab = get_vocab(train_df["question_text"])
out_of_vocab = check_coverage(vocab, embeddings_index)
out_of_vocab[:10]<string_transform> | model_df = pd.DataFrame(model_dict)
model_df | Titanic - Machine Learning from Disaster |
5,616,085 | punct = set('?!.,"
embed_punct = punct & set(embeddings_index.keys())
def clean_punctuation(txt):
for p in "/-":
txt = txt.replace(p, ' ')
for p in "'`‘":
txt = txt.replace(p, '')
for p in punct:
txt = txt.replace(p, f' {p} ' if p in embed_punct else ' _punct_ ')
return txt<feature_engineering> | model_df.sort_values(by=['Accuracy','f1_score','Recall','Precision'],ascending=False,inplace=True)
model_df | 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.