kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,808,829 | for i in range(len(data['combined_text'])) :
data['combined_text'][i] = remove_shortforms(data['combined_text'][i])
data['combined_text'][i] = remove_special_char(data['combined_text'][i])
data['combined_text'][i] = remove_wordswithnum(data['combined_text'][i])
data['combined_text'][i] = lowercase(data['combined_tex... | cosine_similarity(prediction_df.T ) | Titanic - Machine Learning from Disaster |
3,808,829 | cv = CountVectorizer(ngram_range=(1,3))
text_bow = cv.fit_transform(data['combined_text'])
print(text_bow.shape )<split> | from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.optimizers import Adam
from keras.regularizers import l2
from keras.callbacks import EarlyStopping
from sklearn import preprocessing
from keras import regularizers | Titanic - Machine Learning from Disaster |
3,808,829 | train_text = text_bow[:train.shape[0]]
test_text = text_bow[train.shape[0]:]<split> | Titanic - Machine Learning from Disaster | |
3,808,829 | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape )<compute_train_metric> | Titanic - Machine Learning from Disaster | |
3,808,829 | lr = LogisticRegression(C=1,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred))<categorify> | vote_est = [
('ada', ensemble.AdaBoostClassifier()),
('bc', ensemble.BaggingClassifier()),
('etc',ensemble.ExtraTreesClassifier()),
('gbc', ensemble.GradientBoostingClassifier()),
('rfc', ensemble.RandomForestClassifier()),
('gpc', gaussian_process.GaussianProcessClassifier()),
('lr', linear_model.LogisticRegres... | Titanic - Machine Learning from Disaster |
3,808,829 | tfidf = TfidfVectorizer(ngram_range=(1,3))
text_tfidf = tfidf.fit_transform(data['combined_text'])
print(text_tfidf.shape )<split> | vote_ests = [vote_est, vote_est] | Titanic - Machine Learning from Disaster |
3,808,829 | train_text = text_tfidf[:train.shape[0]]
test_text = text_tfidf[train.shape[0]:]<split> | Titanic - Machine Learning from Disaster | |
3,808,829 | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape )<compute_train_metric> | Titanic - Machine Learning from Disaster | |
3,808,829 | lr = LogisticRegression(C=2,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred))<feature_engineering> | best_param = [[
[
{'learning_rate': 0.25, 'n_estimators': 300, 'random_state': 0}
],
[
{'max_samples': 0.5, 'n_estimators': 300, 'random_state': 0}
],
[
{'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 50, 'random_state': 0}
],
[
{'learning_rate': 0.05, 'max_depth': 2, 'n_estimators': 300, 'random_state': 0}
],... | Titanic - Machine Learning from Disaster |
3,808,829 | print('Loading word vectors...')
word2vec = {}
with open(os.path.join('.. /input/glove-global-vectors-for-word-representation/glove.6B.200d.txt'), encoding = "utf-8")as f:
for line in f:
values = line.split()
word = values[0]
vec = np.asarray(values[1:], dtype='float32')
word2vec[word] = vec
print('Found %s word vect... | for i in range(len(vote_ests)) :
for clf, param in zip(vote_ests[i], best_param[i]):
print('The best parameter for {} is {}'.format(clf[1].__class__.__name__, param[0]))
clf[1].set_params(**param[0] ) | Titanic - Machine Learning from Disaster |
3,808,829 | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' )<prepare_x_and_y> | grid_hards = []
for i in range(len(vote_ests)) :
grid_hard = ensemble.VotingClassifier(estimators = vote_ests[i], voting = 'hard')
grid_hard_cv = model_selection.cross_validate(grid_hard, X_trains[i], y_train, cv = cv_split)
grid_hard.fit(X_trains[i], y_train)
grid_hards.append(grid_hard)
print("Hard Voting w/Tuned... | Titanic - Machine Learning from Disaster |
3,808,829 | <train_model><EOS> | alg_name = 'GridHardVoting'
feature_index = 0
prediction = grid_hards[feature_index].predict(X_tests[feature_index])
temp = {'PassengerID': passenger_id, 'Survived': prediction.astype(int)}
result = pd.DataFrame(temp)
result.to_csv('result_%s_feature%s.csv'%(alg_name, feature_index), index=False)
prediction_df[alg_n... | Titanic - Machine Learning from Disaster |
12,521,033 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_unique_values> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
12,521,033 | word2index = tokenizer.word_index
print("Number of unique tokens : ",len(word2index))<prepare_x_and_y> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,521,033 | train_pad = data_padded[:train.shape[0]]
test_pad = data_padded[train.shape[0]:]<categorify> | women = train_data[train_data['Sex'] == 'female']['Survived']
rate_women = sum(women)/len(women)
print('% of women who survived:', rate_women ) | Titanic - Machine Learning from Disaster |
12,521,033 | embedding_matrix = np.zeros(( len(word2index)+1,200))
embedding_vec=[]
for word, i in tqdm(word2index.items()):
embedding_vec = word2vec.get(word)
if embedding_vec is not None:
embedding_matrix[i] = embedding_vec<choose_model_class> | men = train_data[train_data.Sex == 'male']['Survived']
rate_men = sum(men)/len(men)
print('% of men who survived:', rate_men ) | Titanic - Machine Learning from Disaster |
12,521,033 | model1 = keras.models.Sequential([
keras.layers.Embedding(len(word2index)+1,200,weights=[embedding_matrix],input_length=100,trainable=False),
keras.layers.LSTM(100,return_sequences=True),
keras.layers.LSTM(200),
keras.layers.Dropout(0.5),
keras.layers.Dense(1,activation='sigmoid')
] )<choose_model_class> | train_data[['Sex', 'Survived']].groupby(['Sex'] ).mean() | Titanic - Machine Learning from Disaster |
12,521,033 | model1.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
)<train_model> | train_data[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
12,521,033 | history1 = model1.fit(train_pad,Y,
batch_size=64,
epochs=10,
validation_split=0.2
)<choose_model_class> | women_count = 0
women_survived_count = 0
for idx, row in train_data.iterrows() :
if row['Sex'] == 'female':
women_count += 1
if row['Survived'] == 1:
women_survived_count += 1
women_survived_count / women_count | Titanic - Machine Learning from Disaster |
12,521,033 | model2 = keras.models.Sequential([
keras.layers.Embedding(len(word2index)+1,200,weights=[embedding_matrix],input_length=100,trainable=False),
keras.layers.GRU(100,return_sequences=True),
keras.layers.GRU(200),
keras.layers.Dropout(0.5),
keras.layers.Dense(1,activation='sigmoid')
] )<choose_model_class> | predictions = []
for idx, row in test_data.iterrows() :
if(row['Pclass'] == 1 or row['Pclass'] == 2)and row['Sex'] == 'female':
predictions.append(1)
elif row['Age'] < 13 and row['Pclass'] != 3:
predictions.append(1)
else:
predictions.append(0 ) | Titanic - Machine Learning from Disaster |
12,521,033 | model2.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
)<train_model> | test_data['Survived'] = predictions | Titanic - Machine Learning from Disaster |
12,521,033 | <choose_model_class><EOS> | test_data[['PassengerId', 'Survived']].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
12,362,302 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
12,362,302 | model3.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
)<train_model> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,362,302 | history3 = model3.fit(train_pad,Y,
batch_size=64,
epochs=10,
validation_split=0.2
)<choose_model_class> | women = train_data[train_data['Sex'] == 'female']['Survived']
rate_women = sum(women)/len(women)
print('% of women who survived:', rate_women ) | Titanic - Machine Learning from Disaster |
12,362,302 | es = tf.keras.callbacks.EarlyStopping(monitor='val_accuracy',mode='max',verbose=1,patience=3 )<train_model> | men = train_data[train_data.Sex == 'male']['Survived']
rate_men = sum(men)/len(men)
print('% of men who survived:', rate_men ) | Titanic - Machine Learning from Disaster |
12,362,302 | history = model3.fit(train_pad,Y,
batch_size=64,
epochs=30,
validation_split=0.2,
callbacks=[es]
)<predict_on_test> | train_data[['Sex', 'Survived']].groupby(['Sex'] ).mean() | Titanic - Machine Learning from Disaster |
12,362,302 | submit = pd.DataFrame(test['id'],columns=['id'])
predictions = model3.predict(test_pad)
submit['target_prob'] = predictions
submit.head()<data_type_conversions> | train_data[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
12,362,302 | target = [None]*len(submit)
for i in range(len(submit)) :
target[i] = np.round(submit['target_prob'][i] ).astype(int)
submit['target'] = target
submit.head()<save_to_csv> | women_count = 0
women_survived_count = 0
for idx, row in train_data.iterrows() :
if row['Sex'] == 'female':
women_count += 1
if row['Survived'] == 1:
women_survived_count += 1
women_survived_count / women_count | Titanic - Machine Learning from Disaster |
12,362,302 | submit = submit.drop('target_prob',axis=1)
submit.to_csv('real-nlp_lstm.csv',index=False )<load_from_csv> | count1w = 0
count1m = 0
count2w = 0
count2m = 0
count3w = 0
count3m = 0
countm = 0
countw = 0
for idx, row in train_data.iterrows() :
if row['Pclass'] == 1:
if row['Sex'] == 'female':
count1w += 1
else:
count1m += 1
elif row['Pclass'] == 2:
if row['Sex'] == 'female':
count2w += 1
else:
count2m += 1
else:
if row['Sex'] ... | Titanic - Machine Learning from Disaster |
12,362,302 | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' )<prepare_x_and_y> | predictions = []
for idx, row in test_data.iterrows() :
if row['Sex'] == 'female':
if row['Pclass'] == 1 or row['Pclass'] == 2 or row['Age'] < 25.0:
predictions.append(1)
else:
predictions.append(0)
else:
if row['Age'] < 18.0 and row['Pclass'] == 1:
predictions.append(1)
else:
predictions.append(0)
print(prediction... | Titanic - Machine Learning from Disaster |
12,362,302 | Y = train['target']
train = train.drop('target',axis=1)
text_data_train = train['text']
text_data_test = test['text']<count_values> | test_data['Survived'] = predictions | Titanic - Machine Learning from Disaster |
12,362,302 | <load_pretrained><EOS> | test_data[['PassengerId', 'Survived']].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
12,424,800 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
12,424,800 | def bert_encode(data,maximum_length):
input_ids = []
attention_masks = []
for i in range(len(data)) :
encoded = tokenizer.encode_plus(
data[i],
add_special_tokens=True,
max_length=maximum_length,
pad_to_max_length=True,
return_attention_mask=True,
)
input_ids.append(encoded['input_ids'])
attention_masks.append(enco... | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,424,800 | train_input_ids,train_attention_masks = bert_encode(text_data_train,100)
test_input_ids,test_attention_masks = bert_encode(text_data_test,100 )<choose_model_class> | women = train_data[train_data['Sex'] == 'female']['Survived']
rate_women = sum(women)/len(women)
print('% of women who survived:', rate_women ) | Titanic - Machine Learning from Disaster |
12,424,800 | def create_model(bert_model):
input_ids = tf.keras.Input(shape=(100,),dtype='int32')
attention_masks = tf.keras.Input(shape=(100,),dtype='int32')
output = bert_model([input_ids,attention_masks])
output = output[1]
output = tf.keras.layers.Dense(1,activation='sigmoid' )(output)
model = tf.keras.models.Model(inputs =... | men = train_data[train_data.Sex == 'male']['Survived']
rate_men = sum(men)/len(men)
print('% of men who survived:', rate_men ) | Titanic - Machine Learning from Disaster |
12,424,800 | history = model.fit([train_input_ids,train_attention_masks],Y,
validation_split=0.2,
epochs=3,
batch_size=5 )<predict_on_test> | train_data[['Sex', 'Survived']].groupby(['Sex'] ).mean() | Titanic - Machine Learning from Disaster |
12,424,800 | result = model.predict([test_input_ids,test_attention_masks])
result = np.round(result ).astype(int)
submit = pd.DataFrame(test['id'],columns=['id'])
submit['target'] = result
submit.head()<save_to_csv> | train_data[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
12,424,800 | submit.to_csv('real_nlp_bert.csv',index=False )<load_from_csv> | women_count = 0
women_survived_count = 0
for idx, row in train_data.iterrows() :
if row['Sex'] == 'female':
women_count += 1
if row['Survived'] == 1:
women_survived_count += 1
women_survived_count / women_count | Titanic - Machine Learning from Disaster |
12,424,800 | DATA_DIR = '.. /input/aptos2019-blindness-detection'
train_dir = join(DATA_DIR, 'train_images')
label_df = pd.read_csv(join(DATA_DIR, 'train.csv'))
def train_validation_split(df, val_fraction=0.1):
val_ids = np.random.choice(df.id_code, size=int(len(df)* val_fraction))
val_df = df.query('id_code in @val_ids')
train_d... | predictions = []
for idx, row in test_data.iterrows() :
if(row['Pclass'] == 1 or row['Pclass'] == 2)and row['Sex'] == 'female':
predictions.append(1)
elif row['Age'] < 15 and row['Pclass'] == 1:
predictions.append(1)
else:
predictions.append(0 ) | Titanic - Machine Learning from Disaster |
12,424,800 | %%time
class Diabetic_Retionopathy_Data(Dataset):
def __init__(self,
image_dir: str,
label_df: pd.DataFrame,
train=True,
transform=transforms.ToTensor() ,
sample_n=None,
in_memory=False,
write_images=False):
self.image_dir = image_dir
self.transform = transform
self.train = train
self.in_memory = in_memory
if sample_... | test_data['Survived'] = predictions | Titanic - Machine Learning from Disaster |
12,424,800 | def count_parameters(model: nn.Module):
return sum([np.prod(x.shape)for x in model.parameters() ])
def print_lr_schedule(lr: float, decay: float, num_epochs=20):
print('
learning-rate schedule:')
for i in range(num_epochs):
if i % 2 == 0:
print(f'{i}\t{lr:.6f}')
lr = lr* decay
net = EfficientNet.from_name('efficient... | test_data[['PassengerId', 'Survived']].to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,637,182 | %%time
best_epoch_score = np.inf
print('epoch\ttrain-MSE\tval-MSE\tq-kappa\tlr\t\ttime [min]')
print('------------------------------------------------------------------')
for epoch in range(25):
start = time.time()
train_loss = []
for i,(X, y, id_)in enumerate(train_loader):
net.train()
optimizer.zero_grad()
out = ne... | sns.set(style="ticks", context="talk")
| Titanic - Machine Learning from Disaster |
6,637,182 | test_dir = join(DATA_DIR, 'test_images')
test_df = pd.read_csv(join(DATA_DIR, 'test.csv'))
test_df.head(3 )<categorify> | testing = pd.read_csv('/kaggle/input/titanic/test.csv')
train = pd.read_csv('/kaggle/input/titanic/train.csv')
target = 'Survived'
test = testing.copy()
test.info()
print('-'*70)
train.info()
print('-'*70)
train.tail(10 ) | Titanic - Machine Learning from Disaster |
6,637,182 | def sample_images(train_dir: str, test_dir: str, n=10):
train_files = choice(os.listdir(train_dir), size=n)
test_files = choice(os.listdir(test_dir), size=n)
images = []
for train_f, test_f in zip(train_files, test_files):
train_img = Image.open(join(train_dir, train_f))
test_img = Image.open(join(test_dir, test_f)... | print(train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ).round(2),
'
',
train[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ).round(2)) | Titanic - Machine Learning from Disaster |
6,637,182 | test_transform = transforms.Compose([
transforms.Resize(( 256, 256)) ,
transforms.RandomHorizontalFlip() ,
transforms.RandomRotation(( -20, 20)) ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
test_ds = Diabetic_Retionopathy_Data(test_dir,
test_df,
transform=test_transf... | train['agebucket'] = pd.cut(train['Age'], 5)
test['agebucket'] = pd.cut(test['Age'], 5)
train[['agebucket', 'Survived']].groupby(['agebucket'] ).mean().sort_values(by='agebucket', ascending=True ).round(2 ) | Titanic - Machine Learning from Disaster |
6,637,182 | net.load_state_dict(torch.load('state_dict_best.pt'))
net.eval()
net.cuda()
id2prediction = {}
for i,(X, id_)in enumerate(test_loader):
out = net(X.cuda())
preds = out.detach().cpu().numpy().ravel()
id2prediction = {**id2prediction, **dict(zip(id_, preds.round().astype(int ).tolist())) }<save_to_csv> | for dataset in [train, test]:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Ag... | Titanic - Machine Learning from Disaster |
6,637,182 | submission_df = pd.read_csv(join(DATA_DIR, 'sample_submission.csv'))
submission_df.diagnosis = submission_df.id_code.map(id2prediction)
submission_df.diagnosis = submission_df.diagnosis.map(lambda p: max(p, 0))
submission_df.diagnosis = submission_df.diagnosis.map(lambda p: min(p, 4))
submission_df.to_csv('submission.... | print(train[['Family', 'Survived']].groupby(['Family'], as_index=False ).mean().sort_values(by='Survived', ascending=False ).round(2),
'
',
train[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean().sort_values(by='Survived', ascending=False ).round(2)) | Titanic - Machine Learning from Disaster |
6,637,182 | !pip install -U '.. /input/install/efficientnet-0.0.3-py2.py3-none-any.whl'<load_from_csv> | train['isalone'] = [1 if x == 1 else 0 for x in train['Family']]
test['isalone'] = [1 if x == 1 else 0 for x in test['Family']]
train[['isalone', 'Survived']].groupby(['isalone'] ).mean().sort_values(by='Survived', ascending=False ).round(2 ) | Titanic - Machine Learning from Disaster |
6,637,182 | TEST_IMG_PATH = '.. /input/aptos2019-blindness-detection/test_images/'
test_df = pd.read_csv('.. /input/aptos2019-blindness-detection/test.csv')
print(test_df.shape)
original_names = test_df['id_code'].values
test_df['id_code'] = test_df['id_code'] + ".png"
test_df['diagnosis'] = np.zeros(test_df.shape[0])
display(t... | dummy_features = ['Sex','Title', 'isalone']
drop_features = ['Embarked', 'PassengerId', 'Ticket', 'Name', 'Cabin','Parch','SibSp', 'agebucket']
train = pd.concat([train, pd.get_dummies(train[dummy_features])], axis = 1, sort = False)
train.drop(columns = train[dummy_features], inplace = True)
train.drop(columns = tra... | Titanic - Machine Learning from Disaster |
6,637,182 | HEIGHT = 300
WIDTH = 300
COEFF = [0.5,1.5,2.5,3.5]
efficientnetb3 = EfficientNetB3(
weights=None,
input_shape=(HEIGHT,WIDTH,3),
include_top=False
)
def build_model() :
model = Sequential()
model.add(efficientnetb3)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(5, ... | y = train[target]
x = train.drop(columns = target)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state = 42 ) | Titanic - Machine Learning from Disaster |
6,637,182 | tta_steps = 4
predictions = []
for i in tqdm(range(tta_steps)) :
test_generator = ImageDataGenerator(rescale=1./255,
horizontal_flip=True,
rotation_range= 90,
vertical_flip=True,
brightness_range=(0.5,2),
zoom_range= 0.2,
fill_mode='constant',
cval = 0 ).flow_from_dataframe(test_df,
x_col='id_code',
y_col = 'diagnosis'... | RF = ensemble.RandomForestClassifier()
RF_params = {
'n_estimators':[n for n in range(60,140,10)],
'max_depth':[n for n in range(3, 6)],
'max_features' : ['sqrt', 'log2', None],
'random_state' : [42]
}
RF_model = GridSearchCV(RF, param_grid = RF_params, cv = 5, n_jobs = -1 ).fit(x_train, y_train)
print("Best Hyper Par... | Titanic - Machine Learning from Disaster |
6,637,182 | del model
gc.collect()<choose_model_class> | GBT = ensemble.GradientBoostingClassifier()
GBT_params = {
'n_estimators':[n for n in range(180, 240, 20)],
'max_depth':[n for n in range(3, 6)],
'learning_rate': [0.1, 0.25, 0.5],
'random_state' : [42]
}
GBT_model = GridSearchCV(GBT, param_grid = GBT_params, cv = 5, n_jobs = -1)
GBT_model.fit(x_train, y_train)
print... | Titanic - Machine Learning from Disaster |
6,637,182 | HEIGHT = 320
WIDTH = 320
COEFF = [0.53164905, 1.37748383, 2.60330927, 3.40191179]
def build_model() :
efficientnetb3 = EfficientNetB3(
weights=None,
input_shape=(HEIGHT,WIDTH,3),
include_top=False
)
model = Sequential()
model.add(efficientnetb3)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0... | print("GBT cohen_kappa_score: %.3f" % cohen_kappa_score(y_test, GBT_predictions))
print("RF cohen_kappa_score: %.3f" % cohen_kappa_score(y_test, RF_predictions))
| Titanic - Machine Learning from Disaster |
6,637,182 | tta_steps = 4
predictions = []
for i in tqdm(range(tta_steps)) :
test_generator = ImageDataGenerator(rescale=1./255,
horizontal_flip=True,
rotation_range= 90,
vertical_flip=True,
brightness_range=(0.5,2),
zoom_range= 0.2,
fill_mode='constant',
preprocessing_function=preprocess_image,
cval = 0 ).flow_from_dataframe(test... | print("GBT", classification_report(y_test, GBT_predictions))
print("-"*100)
print("RF", classification_report(y_test, RF_predictions)) | Titanic - Machine Learning from Disaster |
6,637,182 | del model
gc.collect()<define_variables> | predict_RF = RF_model.predict(test)
predict_GBT = GBT_model.predict(test)
submit_RF = pd.DataFrame({'PassengerId':testing['PassengerId'],'Survived':predict_RF})
submit_GBT = pd.DataFrame({'PassengerId':testing['PassengerId'],'Survived':predict_GBT})
filename_RF = 'Titanic Prediction RF.csv'
submit_RF.to_csv(filenam... | Titanic - Machine Learning from Disaster |
7,481,879 | tta_steps = 3
predictions = []
for i in tqdm(range(tta_steps)) :
test_generator = ImageDataGenerator(horizontal_flip=True,
vertical_flip=True,
brightness_range=(0.5,2),
zoom_range= 0.2,
fill_mode='constant',
cval = 0 ).flow_from_dataframe(test_df,
x_col='id_code',
y_col = 'diagnosis',
directory = TEST_IMG_PATH,
target_... | from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder | Titanic - Machine Learning from Disaster |
7,481,879 | K.clear_session()
cuda.select_device(0)
cuda.close()<set_options> | def extract(m):
m = m.split(',')[1]
m = m.split('.')[0]
return m[1:] | Titanic - Machine Learning from Disaster |
7,481,879 | ! nvidia-smi<set_options> | path = '/kaggle/input/titanic/train.csv'
df = pd.read_csv(path)
df['Name'] = df['Name'].apply(extract)
df['Name'] = df['Name'].apply(lambda x: x if x in ['Mr','Mrs','Miss','Master'] else 'Others')
df['Parch'] = df['Parch'].apply(lambda x: x if x in [0,1,2] else 4.5)
| Titanic - Machine Learning from Disaster |
7,481,879 | %reload_ext autoreload
%autoreload 2
%matplotlib inline
warnings.filterwarnings("ignore")
%matplotlib inline
warnings.filterwarnings('ignore')
GlobalParams = collections.namedtuple('GlobalParams', [
'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate',
'num_classes', 'width_coefficient', 'depth_coefficient',
'... | df = df.fillna(df.mean())
df['Embarked'] = df['Embarked'].apply(lambda x : x if(x=='C' or x=='Q')else 'S')
df['Embarked'].unique()
print(df.count())
le = LabelEncoder()
le.fit(df['Sex'])
df['Sex'] = le.transform(df['Sex'])
le.fit(df['Name'])
df['Name'] = le.transform(df['Name'])
le.fit(df['Embarked'])
df['Embar... | Titanic - Machine Learning from Disaster |
7,481,879 | md_ef = EfficientNet.from_pretrained('efficientnet-b5', num_classes=1)
!mkdir models
!cp '.. /input/kaggle-public/abcdef.pth' 'models'<categorify> | features = ['Pclass','Sex','SibSp','Parch','Fare','Embarked','Name']
y = df['Survived']
X = df[features] | Titanic - Machine Learning from Disaster |
7,481,879 | tta = 3
bs = 64
tfms = get_transforms(do_flip=True,flip_vert=True)
sz = 256
data =(ImageList.from_df(df=df,path='./',cols='path')
.split_by_rand_pct(0.2)
.label_from_df(cols='diagnosis',label_cls=FloatList)
.transform(tfms,size=sz,resize_method=ResizeMethod.SQUISH,padding_mode='zeros')
.databunch(bs=bs,num_workers=4)
... | for i in range(1):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = GradientBoostingClassifier(n_estimators = 200, max_depth = 3)
model.fit(X_train,y_train)
print(i,(model.predict(X_train)-y_train==0 ).sum() *100/len(y_train))
print(( model.predict(X_test)-y_test==0 )... | Titanic - Machine Learning from Disaster |
7,481,879 | y_test_4 = opt.predict(preds, coef=[0.5, 1.5, 2.5, 3.5])
y_test_4 = y_test_4.flatten()<train_model> | df3 = pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
df3 | Titanic - Machine Learning from Disaster |
7,481,879 | def train_model(tfms,bs,sz):
data =(ImageList.from_df(df=df,path='./',cols='path')
.split_by_rand_pct(0.2)
.label_from_df(cols='diagnosis',label_cls=FloatList)
.transform(tfms,size=sz,resize_method=ResizeMethod.SQUISH,padding_mode='reflection')
.databunch(bs=bs,num_workers=4)
.normalize(imagenet_stats)
)
learn = Learn... | model.fit(X,y)
df2 = pd.read_csv('/kaggle/input/titanic/test.csv')
df2['Name'] = df2['Name'].apply(extract)
df2['Name'] = df2['Name'].apply(lambda x: x if x in ['Mr','Mrs','Miss','Master'] else 'Others')
df2['Parch'] = df2['Parch'].apply(lambda x: x if x in [0,1,2] else 4.5)
df2 = df2.fillna(df.mean())
df2['Embar... | Titanic - Machine Learning from Disaster |
7,481,879 | <compute_test_metric><EOS> | sub.to_csv('Submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,759,840 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | sns.set()
%matplotlib inline
warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
1,759,840 | COEFF = [0.5, 1.5, 2.5, 3.5]
for i, pred in enumerate(y_test):
if pred < COEFF[0]:
y_test[i] = 0
elif pred >= COEFF[0] and pred < COEFF[1]:
y_test[i] = 1
elif pred >= COEFF[1] and pred < COEFF[2]:
y_test[i] = 2
elif pred >= COEFF[2] and pred < COEFF[3]:
y_test[i] = 3
else:
y_test[i] = 4<save_to_csv> | path_train = '.. /input/train.csv'
path_test = '.. /input/test.csv' | Titanic - Machine Learning from Disaster |
1,759,840 | test_df['diagnosis'] = y_test.astype(int)
test_df['id_code'] = test_df['id_code'].str.replace(r'.png$', '')
test_df.to_csv('submission.csv',index=False)
print("Submission Distribution:")
print(round(test_df.diagnosis.value_counts() /len(test_df)*100,4))<define_variables> | train_df_raw = pd.read_csv(path_train)
train_df_raw.head() | Titanic - Machine Learning from Disaster |
1,759,840 | DEVICE = torch.device("cuda:0")
DATA_SOURCE = os.path.join(".. ","input","aptos2019-blindness-detection")
MODEL_SOURCE = os.path.join(".. ","input","densenet161-1-18-v2-pth")
MODEL_SIZE = 224<prepare_x_and_y> | draw_missing_data_table(train_df_raw ) | Titanic - Machine Learning from Disaster |
1,759,840 | def crop_image(img,tol=7):
w, h = img.shape[1],img.shape[0]
gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
gray_img = cv2.blur(gray_img,(5,5))
shape = gray_img.shape
gray_img = gray_img.reshape(-1,1)
quant = quantile_transform(gray_img, n_quantiles=256, random_state=0, copy=True)
quant =(quant*256 ).astype(int)
g... | def preprocess_data(df):
processed_df = df
processed_df['Embarked'].fillna('C', inplace=True)
processed_df['Age'] = processed_df.groupby(['Pclass','Sex','Parch','SibSp'])['Age'].transform(lambda x: x.fillna(x.mean()))
processed_df['Age'] = processed_df.groupby(['Pclass','Sex','Parch'])['Age'].transform(lambda x: x.fil... | Titanic - Machine Learning from Disaster |
1,759,840 | class RetinopathyDataset(Dataset):
def __init__(self, transform, is_test=False):
self.transform = transform
self.base_transform = transforms.Resize(( MODEL_SIZE, MODEL_SIZE))
self.is_test = is_test
if not os.path.exists("cache"): os.mkdir("cache")
if is_test : file = "test.csv"
else : file = "train.csv"
csv_file = os.... | train_df = train_df_raw.copy()
X = train_df.drop(['Survived'], 1)
Y = train_df['Survived']
X = preprocess_data(X)
sc = StandardScaler()
X = pd.DataFrame(sc.fit_transform(X.values), index=X.index, columns=X.columns)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)
X_train.hea... | Titanic - Machine Learning from Disaster |
1,759,840 | NUM_FOLDS = 5
data_augmentation = transforms.Compose([
transforms.RandomRotation(( -15, 15)) ,
transforms.Resize(224),
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFlip() ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
])
DATA = RetinopathyDataset(data_augm... | lg = LogisticRegression(solver='lbfgs', random_state=42)
lg.fit(X_train, Y_train)
logistic_prediction = lg.predict(X_test)
score = metrics.accuracy_score(Y_test, logistic_prediction)
display_confusion_matrix(Y_test, logistic_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | def get_dataloader_for_fold(n, data, train_data, eval_data, batch_size):
train_sampler = SubsetRandomSampler(train_data[n])
valid_sampler = SubsetRandomSampler(eval_data[n])
data_loader_train = torch.utils.data.DataLoader(data,
batch_size=batch_size, drop_last=False,
sampler=train_sampler)
data_loader_eval = torch... | dt = DecisionTreeClassifier(min_samples_split=15, min_samples_leaf=20, random_state=42)
dt.fit(X_train, Y_train)
dt_prediction = dt.predict(X_test)
score = metrics.accuracy_score(Y_test, dt_prediction)
display_confusion_matrix(Y_test, dt_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | class Classificator0(nn.Module):
def __init__(self, size=128):
super(Classificator0, self ).__init__()
self.size = size
self.network = nn.Sequential(
nn.BatchNorm1d(size),
nn.Dropout(p=0.3),
nn.Linear(in_features=size, out_features=5, bias=True),
)
def forward(self, x):
return self.network(x)
class Classificator(... | svm = SVC(gamma='auto', random_state=42)
svm.fit(X_train, Y_train)
svm_prediction = svm.predict(X_test)
score = metrics.accuracy_score(Y_test, svm_prediction)
display_confusion_matrix(Y_test, svm_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | def get_base_model() :
model = torchvision.models.densenet161(pretrained=False)
in_features = model.classifier.in_features
model.classifier = Classificator0(in_features)
model_path = os.path.join(MODEL_SOURCE, "densenet161.1.18.v2.pth")
model.load_state_dict(torch.load(model_path))
model.classifier = Classificator... | rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X_train, Y_train)
rf_prediction = rf.predict(X_test)
score = metrics.accuracy_score(Y_test, rf_prediction)
display_confusion_matrix(Y_test, rf_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | def train_model(model, optimizer, scheduler, train_data_loader, eval_data_loader,
file_name, num_epochs = 50, patience = 7, prev_loss = 1000.00):
criterion = nn.CrossEntropyLoss()
countdown = patience
best_loss = 1000.00
since = time.time()
for epoch in range(num_epochs):
running_loss = 0.0
counter = 0
for bi, d in e... | def build_ann(optimizer='adam'):
ann = Sequential()
ann.add(Dense(units=32, kernel_initializer='glorot_uniform', activation='relu', input_shape=(13,)))
ann.add(Dense(units=64, kernel_initializer='glorot_uniform', activation='relu'))
ann.add(Dropout(rate=0.5))
ann.add(Dense(units=64, kernel_initializer='glorot_uniform'... | Titanic - Machine Learning from Disaster |
1,759,840 | batch_size = 56
num_round_per_fold = 2
for no in range(NUM_FOLDS):
print("-"*22, "fold",no)
bst_loss = 10000.00
for r in range(num_round_per_fold):
print("-"*11,"round",r)
data_loader_train, data_loader_eval = get_dataloader_for_fold(no,
DATA, data_train, data_eval, batch_size)
model = get_base_model()
plist = [{"pa... | opt = optimizers.Adam(lr=0.001)
ann = build_ann(opt)
history = ann.fit(X_train, Y_train, batch_size=16, epochs=30, validation_data=(X_test, Y_test)) | Titanic - Machine Learning from Disaster |
1,759,840 | def get_trained_model(no):
extractor = torchvision.models.densenet161(pretrained=False)
in_features = extractor.classifier.in_features
extractor.classifier = Classificator(in_features)
model_path = os.path.join("tmp"+str(no)+".pth")
extractor.load_state_dict(torch.load(model_path))
extractor = extractor.to(DEVICE)... | ann_prediction = ann.predict(X_test)
ann_prediction =(ann_prediction > 0.5)
score = metrics.accuracy_score(Y_test, ann_prediction)
display_confusion_matrix(Y_test, ann_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | def get_extractor_model(no):
extractor = get_trained_model(no)
extractor.classifier = nn.Identity()
extractor = extractor.to(DEVICE)
extractor.eval()
return extractor<categorify> | n_folds = 10
cv_score_lg = cross_val_score(estimator=lg, X=X_train, y=Y_train, cv=n_folds, n_jobs=-1)
cv_score_dt = cross_val_score(estimator=dt, X=X_train, y=Y_train, cv=n_folds, n_jobs=-1)
cv_score_svm = cross_val_score(estimator=svm, X=X_train, y=Y_train, cv=n_folds, n_jobs=-1)
cv_score_rf = cross_val_score(estim... | Titanic - Machine Learning from Disaster |
1,759,840 | def get_train_features(data_loader, extractor):
for bi, d in enumerate(data_loader):
print(".", end="")
img_tensor = d["image"].to(DEVICE)
target = d["label"].numpy()
with torch.no_grad() : feature = extractor(img_tensor)
feature = feature.cpu().detach().squeeze(0 ).numpy()
if bi == 0 :
features = feature
targets ... | cv_result = {'lg': cv_score_lg, 'dt': cv_score_dt, 'svm': cv_score_svm, 'rf': cv_score_rf, 'ann': cv_score_ann}
cv_data = {model: [score.mean() , score.std() ] for model, score in cv_result.items() }
cv_df = pd.DataFrame(cv_data, index=['Mean_accuracy', 'Variance'])
cv_df | Titanic - Machine Learning from Disaster |
1,759,840 | XGBOOST_PARAM = {
"random_state" : 42,
"n_estimators" : 200,
"objective" : "multi:softmax",
"num_class" : 5,
"eval_metric" : "mlogloss",
}<feature_engineering> | class EsemblingClassifier:
def __init__(self, verbose=True):
self.ann = build_ann(optimizer=optimizers.Adam(lr=0.001))
self.rf = RandomForestClassifier(n_estimators=300, max_depth=11, random_state=42)
self.svm = SVC(random_state=42)
self.trained = False
self.verbose = verbose
def fit(self, X, y):
if self.verbose:
pri... | Titanic - Machine Learning from Disaster |
1,759,840 | batch_size = 64
eval_set = []
for no in range(NUM_FOLDS):
print("-"*22, "fold",no)
data_loader_train, data_loader_eval = get_dataloader_for_fold(no,
DATA, data_train, data_eval, batch_size)
extractor = get_extractor_model(no)
print("...........|.............................................|")
features_eval, targets... | ens = EsemblingClassifier()
ens.fit(X_train, Y_train)
ens_prediction = ens.predict(X_test)
score = metrics.accuracy_score(Y_test, ens_prediction)
display_confusion_matrix(Y_test, ens_prediction, score=score ) | Titanic - Machine Learning from Disaster |
1,759,840 | base_transform = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
DATA.transform = base_transform<categorify> | test_df_raw = pd.read_csv(path_test)
test = test_df_raw.copy()
test = preprocess_data(test)
test = pd.DataFrame(sc.fit_transform(test.values), index=test.index, columns=test.columns)
test.head() | Titanic - Machine Learning from Disaster |
1,759,840 | <choose_model_class><EOS> | model_test = EsemblingClassifier()
model_test.fit(X, Y)
prediction = model_test.predict(test)
result_df = test_df_raw.copy()
result_df['Survived'] = prediction
result_df.to_csv('submission.csv', columns=['PassengerId', 'Survived'], index=False ) | Titanic - Machine Learning from Disaster |
7,677,885 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
7,677,885 | base_transform = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data_test = RetinopathyDataset(base_transform, is_test=True)
data_loader = torch.utils.data.DataLoader(data_test,
batch_size=16, shuffle=False,
num_workers=0, dr... | train_file_path = ".. /input/titanic/train.csv"
test_file_path = ".. /input/titanic/test.csv"
train_data = pd.read_csv(train_file_path)
test_data = pd.read_csv(test_file_path ) | Titanic - Machine Learning from Disaster |
7,677,885 | print("................................ v")
predictions = np.zeros(( len(data_test),5))
for tta in range(1):
print("............ tta"+str(tta)+"................ ")
for no in range(NUM_FOLDS):
extractor = get_extractor_model(no)
features = get_test_features(data_loader, extractor)
print("",no)
xgb_model = xgb.XGBCl... | train_data.groupby(by=['Pclass'] ).count() | Titanic - Machine Learning from Disaster |
7,677,885 | batch_size = 8
data_augmentation = transforms.Compose([
transforms.Resize(( MODEL_SIZE, MODEL_SIZE)) ,
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFlip() ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data_test = RetinopathyDataset(data_augmentation, i... | perc = train_data[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
perc*100
| Titanic - Machine Learning from Disaster |
7,677,885 | softmax = nn.Softmax(dim=1)
for tta in range(4):
print("............ tta"+str(tta)+"...............")
for no in range(NUM_FOLDS):
model = get_trained_model(no)
batch_slice =(0, 0)
for bi, d in enumerate(data_loader):
if bi %(64//batch_size)== 0 : print(".", end="")
img_tensor = d["image"].to(DEVICE, dtype=torch.fl... | def extract_title(name):
for string in name.split() :
if '.' in string:
return string[:-1]
train_data['Title'] = train_data['Name'].apply(lambda n: extract_title(n))
test_data['Title'] = test_data['Name'].apply(lambda n: extract_title(n))
print(test_data['Title'].value_counts() ,'
',train_data['Title'].value_counts()... | Titanic - Machine Learning from Disaster |
7,677,885 | prediction_final = predictions.argmax(axis=1)
csv_file = os.path.join(DATA_SOURCE, "sample_submission.csv")
df = pd.read_csv(csv_file)
df["diagnosis"] = prediction_final
df.to_csv('submission.csv',index=False )<feature_engineering> | for dataframe in [train_data, test_data]:
dataframe['Title'] = dataframe['Title'].replace('Mlle', 'Miss')
dataframe['Title'] = dataframe['Title'].replace('Ms', 'Miss')
dataframe['Title'] = dataframe['Title'].replace('Mme', 'Mrs')
dataframe['Title'] = dataframe['Title'].replace(['Lady', 'Capt', 'Col','Don', 'Dr',
'Ma... | Titanic - Machine Learning from Disaster |
7,677,885 | t_start = time.time()<define_variables> | print('% of survived females:', train_data['Survived'][train_data['Sex'] == 'female'].value_counts(normalize = True)[1]*100)
print('% of survived males:', train_data['Survived'][train_data['Sex'] == 'male'].value_counts(normalize = True)[1]*100)
| Titanic - Machine Learning from Disaster |
7,677,885 | IMG_WIDTH = 456
IMG_HEIGHT = 456
CHANNEL = 3
BATCH_SIZE = 4
EPOCHS_OLD_DATA = 10
WARMUP_EPOCHS = 3
NUM_CLASSES = 5
SEED = 2
LEARNING_RATE = 1e-4
WARMUP_LEARNING_RATE = 1e-3
ES_PATIENCE = 5
RLROP_PATIENCE = 3
DECAY_DROP = 0.5<define_variables> | train_data[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
7,677,885 | BASE_DIR = '/kaggle/input/aptos2019-blindness-detection/'
TRAIN_DIR = '/kaggle/input/aptos2019-blindness-detection/train_images'
TEST_DIR = '/kaggle/input/aptos2019-blindness-detection/test_images'
TRAIN_DIR = '/kaggle/input/diabetic-retinopathy-resized/resized_train/resized_train'<load_from_csv> | train_data['FamilySize'] = train_data['SibSp'] + train_data['Parch']
test_data['FamilySize'] = train_data['SibSp'] + train_data['Parch']
train_data['IsAlone'] = train_data['FamilySize'].apply(lambda fs: 1 if fs == 0 else 0)
test_data['IsAlone'] = test_data['FamilySize'].apply(lambda fs: 1 if fs == 0 else 0 ) | Titanic - Machine Learning from Disaster |
7,677,885 | TRAIN_DF = pd.read_csv(BASE_DIR + "train.csv",dtype='object')
TEST_DF = pd.read_csv(BASE_DIR + "test.csv",dtype='object')
TRAIN_DF = pd.read_csv("/kaggle/input/diabetic-retinopathy-resized/trainLabels.csv",dtype='object')
X_COL='id_code'
Y_COL='diagnosis'<rename_columns> | train_data[['FamilySize', 'Survived']].groupby('FamilySize', as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
7,677,885 | TRAIN_DF.columns = ['id_code', 'diagnosis']
<categorify> | train_data.drop(['Parch', 'SibSp'], axis=1, inplace=True)
test_data.drop(['Parch', 'SibSp'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
7,677,885 | def append_file_ext(file_name):
return file_name + ".png"
def append_file_ext_jpeg(file_name):
return file_name.replace(".png",".jpeg" )<feature_engineering> | train_data[['Ticket', 'PassengerId']].groupby('Ticket', as_index=False ).count().sort_values('PassengerId', ascending=False ) | Titanic - Machine Learning from Disaster |
7,677,885 | TRAIN_DF[X_COL] = TRAIN_DF[X_COL].apply(append_file_ext)
TEST_DF[X_COL] = TEST_DF[X_COL].apply(append_file_ext)
TRAIN_DF[X_COL] = TRAIN_DF[X_COL].apply(append_file_ext_jpeg )<concatenate> | train_data['TicketGroupSize'] = train_data.groupby(['Ticket'])['PassengerId'].transform('count')
test_data['TicketGroupSize'] = test_data.groupby(['Ticket'])['PassengerId'].transform('count' ) | Titanic - Machine Learning from Disaster |
7,677,885 | df0 = TRAIN_DF.loc[TRAIN_DF['diagnosis'] == '0']
df1 = TRAIN_DF.loc[TRAIN_DF['diagnosis'] == '1']
df2 = TRAIN_DF.loc[TRAIN_DF['diagnosis'] == '2']
df3 = TRAIN_DF.loc[TRAIN_DF['diagnosis'] == '3']
df4 = TRAIN_DF.loc[TRAIN_DF['diagnosis'] == '4']
df0 = df0.head(2000)
df1 = df1.head(2000)
df2 = df2.head(2000)
TRAIN_DF ... | train_data.drop('Ticket', axis=1, inplace=True)
test_data.drop('Ticket', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
7,677,885 | def create_model(input_shape, n_out):
input_tensor = Input(shape=input_shape)
base_model = EfficientNetB5(weights=None,
include_top=False,
input_tensor=input_tensor)
base_model.load_weights('/kaggle/input/efficientnet-keras-weights-b0b5/efficientnet-b5_imagenet_1000_notop.h5')
x = GlobalAveragePooling2D()(base_model... | fare_median = test_data['Fare'].median()
test_data['Fare'] = test_data['Fare'].fillna(fare_median ) | 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.