kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
7,000,072 | cross_val_model(X_stack, y_stack, XGB_model )<train_model> | Results = pd.DataFrame({'Model': [],'Accuracy Score': [], 'Recall':[], 'F1score':[]})
| Titanic - Machine Learning from Disaster |
7,000,072 | class Ensemble(object):
def __init__(self, n_splits, stacker, base_models):
self.n_splits = n_splits
self.stacker = stacker
self.base_models = base_models
def fit_predict(self, X, y, T):
X = np.array(X)
y = np.array(y)
T = np.array(T)
folds = list(StratifiedKFold(n_splits=self.n_splits, shuffle=True, random_state=20... | model = DecisionTreeClassifier(max_depth=4)
model.fit(trainX, trainY)
y_pred = model.predict(testX)
res = pd.DataFrame({"Model":['DecisionTreeClassifier'],
"Accuracy Score": [accuracy_score(y_pred,testY)],
"Recall": [recall_score(testY, y_pred)],
"F1score": [f1_score(testY, y_pred)]})
Results = Results.append(res ) | Titanic - Machine Learning from Disaster |
7,000,072 | rf_params = {}
rf_params['n_estimators'] = 80
rf_params['max_depth'] = 12
rf_params['min_samples_split'] = 50
rf_params['min_samples_leaf'] = 23
<init_hyperparams> | pd.crosstab(testY, y_pred, rownames=['Real data'], colnames=['Predicted'] ) | Titanic - Machine Learning from Disaster |
7,000,072 | xgb_params = {}
xgb_params['learning_rate'] =0.03660642032718193
xgb_params['n_estimators'] = 70
xgb_params['max_depth'] = 7
xgb_params['reg_alpha'] = 0.1
xgb_params['reg_lambda'] = 0.1
xgb_params['colsample_bytree'] = 0.6162725690461764
xgb_params['min_child_weight'] = 0.751826989118936
<choose_model_class> | model = RandomForestClassifier(n_estimators=2500, max_depth=4)
model.fit(trainX, trainY)
y_pred = model.predict(testX)
res = pd.DataFrame({"Model":['RandomForestClassifier'],
"Accuracy Score": [accuracy_score(y_pred,testY)],
"Recall": [recall_score(testY, y_pred)],
"F1score": [f1_score(testY, y_pred)]})
Results = R... | Titanic - Machine Learning from Disaster |
7,000,072 | rf_model = RandomForestClassifier(**rf_params, random_state=584867 )<choose_model_class> | pd.crosstab(testY, y_pred, rownames=['Real data'], colnames=['Predicted'] ) | Titanic - Machine Learning from Disaster |
7,000,072 | xgb_model = XGBClassifier(**xgb_params, random_state=2943 )<choose_model_class> | model = XGBClassifier(learning_rate=0.001,n_estimators=2500,
max_depth=4, min_child_weight=0,
gamma=0, subsample=0.7,
colsample_bytree=0.7,
scale_pos_weight=1, seed=27,
reg_alpha=0.00006)
model.fit(trainX, trainY)
y_pred = model.predict(testX)
res = pd.DataFrame({"Model":['XGBClassifier'],
"Accuracy Score": [accurac... | Titanic - Machine Learning from Disaster |
7,000,072 | log_model = LogisticRegression(random_state=29 )<choose_model_class> | pd.crosstab(testY, y_pred, rownames=['Real data'], colnames=['Predicted'] ) | Titanic - Machine Learning from Disaster |
7,000,072 | stack = Ensemble(n_splits=3,
stacker = log_model,
base_models =(rf_model, xgb_model))<predict_on_test> | trainX = data[data.Survived.isnull() ==False].drop(['Survived','train'],axis=1)
trainY = data.Survived[data.Survived.isnull() ==False]
testX = data[data.Survived.isnull() ==True].drop(['Survived','train'],axis=1)
model = XGBClassifier(learning_rate=0.001,n_estimators=2500,
max_depth=4, min_child_weight=0,
gamma=0, su... | Titanic - Machine Learning from Disaster |
13,832,044 | X_stack.fillna(-1, inplace = True)
test_stack_val.fillna(-1,inplace=True)
y_pred = stack.fit_predict(X_stack, target_stack, test_stack_val )<save_to_csv> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
13,832,044 | sub = pd.DataFrame()
sub['ids'] = test_id
sub['prob'] = y_pred
sub.to_csv('stacked_main.csv', index=False )<load_from_csv> | train_df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv')
combine = [train_df , test_df] | Titanic - Machine Learning from Disaster |
13,832,044 | data = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
data.head()<train_model> | train_df.groupby('Sex' ).Survived.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | X = data.drop(['AveragePrice'], axis=1)
y = data['AveragePrice']
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.33, random_state=42)
<save_to_csv> | train_df.groupby('Ticket' ).Survived.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | model = XGBRegressor(n_jobs=4, learning_rate=0.05, max_depth=8, min_child_weight=0.5, n_estimators=1300)
model.fit(X,
y,
verbose=True)
test_predict_optimal = model.predict(test)
new_df = pd.DataFrame({"id": test['id'] , "AveragePrice":test_predict_optimal})
new_df.to_csv("XGB_manual_custom_5.csv", index=False )<com... | train_df.groupby('Embarked' ).Survived.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | predictions = model.predict(X_val)
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=5)
print(scores)
print('Mean Absolute Error: %2f' %(-1 * scores.mean()))<compute_test_metric> | train_df.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
13,832,044 | mae = mean_absolute_error(predictions, y_val)
print("Mean Absolute Error : " + str(mae))
error_percent = mae/data['AveragePrice'].mean() *100
print(str(error_percent)+ ' %')
<import_modules> | features_df = train_df.drop('Survived', axis=1)
num_features = features_df.select_dtypes(np.number)
num_features.sample(5 ) | Titanic - Machine Learning from Disaster |
13,832,044 | import lightgbm as lgb
from sklearn.metrics import mean_squared_log_error
import matplotlib.pyplot as plt
import seaborn as sns<load_from_csv> | train_df.groupby('Pclass' ).Survived.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | train = pd.read_csv('/kaggle/input/bike-sharing-demand-for-education/train.csv')
test = pd.read_csv('/kaggle/input/bike-sharing-demand-for-education/test.csv')
sample_submission = pd.read_csv('/kaggle/input/bike-sharing-demand-for-education/sample_submission.csv' )<prepare_x_and_y> | train_df.groupby('Sex' ).Pclass.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | X = train.drop(['datetime','casual','registered','cnt'],axis = 1)
X_test = test.drop(['datetime'],axis = 1)
y = train[['year','cnt']]<train_model> | train_df.groupby('Fare' ).Survived.agg(['mean' , 'count'] ).sort_values('count' , ascending = False ) | Titanic - Machine Learning from Disaster |
13,832,044 | %%time
columns = X.columns
y_preds = np.zeros(X_test.shape[0])
feature_importances = pd.DataFrame()
feature_importances['feature'] = columns
X_train = X.query("year == 2011")
X_valid = X.query("year == 2012")
y_train = y.query("year == 2011")
y_valid = y.query("year == 2012")
y_train.drop('year',axis=1, inplace=Tr... | features_df = train_df.drop('Survived', axis=1)
FEATURE_COLUMNS = features_df.columns
NUM_FEATURES = features_df.select_dtypes(include=[np.number] ).columns
CAT_FEATURES = ['Sex', 'Ticket']
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0)) ,
(... | Titanic - Machine Learning from Disaster |
13,832,044 | submission = pd.concat([test['datetime'], pd.Series(y_preds)], axis=1)
submission = submission.rename(columns={0:'cnt'} )<save_to_csv> | x_train, x_test, y_train, y_test = train_test_split(features_df, target, test_size=0.25 ) | Titanic - Machine Learning from Disaster |
13,832,044 | submission.to_csv('base_submission.csv',header=True, index=False )<train_model> | baseline = DummyClassifier(strategy='most_frequent')
model = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
13,832,044 | pca = PCA(n_components=19)
pca.fit(data)
data = pca.transform(data)
data_for_submission = pca.transform(data_for_submission)
skf = StratifiedKFold(n_splits=5, shuffle=False)
classifier = MLPClassifier(alpha=1, learning_rate='adaptive', max_iter=750, hidden_layer_sizes=(38, 76))
accuracy_list = []
for train_index, ... | baseline.fit(x_train, y_train)
model.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
13,832,044 | class Dictionary(object):
def __init__(self):
self.token2idx = {}
self.idx2token = []
def add_token(self, token):
if token not in self.token2idx:
self.idx2token.append(token)
self.token2idx[token] = len(self.idx2token)- 1
return self.token2idx[token]
def __len__(self):
return len(self.idx2token )<string_transform> | baseline_predictions = baseline.predict(x_test)
model_predictions = model.predict(x_test ) | Titanic - Machine Learning from Disaster |
13,832,044 | char_vocab = Dictionary()
pad_token = '<pad>'
unk_token = '<unk>'
pad_index = char_vocab.add_token(pad_token)
unk_index = char_vocab.add_token(unk_token)
chars = set(''.join(x_train_full))
for char in sorted(chars):
char_vocab.add_token(char)
print("Vocabulary:", len(char_vocab), "UTF characters")
lang_vocab = Dict... | print(classification_report(y_test, baseline_predictions)) | Titanic - Machine Learning from Disaster |
13,832,044 | print('a ->', char_vocab.token2idx['a'])
print('cat ->', lang_vocab.token2idx['cat'])
print(y_train_full[0], x_train_full[0][:10])
x_train_idx = [np.array([char_vocab.token2idx[c] for c in line])for line in x_train_full]
y_train_idx = np.array([lang_vocab.token2idx[lang] for lang in y_train_full])
print(y_train_idx... | print(classification_report(y_test, model_predictions)) | Titanic - Machine Learning from Disaster |
13,832,044 | x_train, x_val, y_train, y_val = train_test_split(x_train_idx, y_train_idx, test_size=0.15, random_state=seed)
train_data = [(x, y)for x, y in zip(x_train, y_train)]
val_data = [(x, y)for x, y in zip(x_val, y_val)]
print(len(train_data), "training samples")
print(len(val_data), "validation samples" )<define_variables... | test_df = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,832,044 | def batch_generator(data, batch_size, token_size):
minibatch, sequences_so_far, tokens_so_far = [], 0, 0
for ex in data:
minibatch.append(ex)
seq_len = len(ex[0])
if seq_len > token_size:
ex =(ex[0][:token_size], ex[1])
seq_len = token_size
sequences_so_far += 1
tokens_so_far += seq_len
if sequences_so_far == batc... | sub_model = RandomForestClassifier()
sub_model.fit(features_df, target)
test_features = preprocessor.transform(test_df[train_df.drop('Survived', axis=1 ).columns])
predictions = sub_model.predict(test_features ) | Titanic - Machine Learning from Disaster |
13,832,044 | def pool_generator(data, batch_size, token_size, shuffle=False):
for p in batch_generator(data, batch_size * 100, token_size * 100):
p_batch = batch_generator(sorted(p, key=lambda t: len(t[0]), reverse=True), batch_size, token_size)
p_list = list(p_batch)
if shuffle:
for b in random.sample(p_list, len(p_list)) :
yi... | sub_df = pd.DataFrame({'PassengerId' : test_df.PassengerId, 'Survived': predictions})
sub_df.head() | Titanic - Machine Learning from Disaster |
13,832,044 | class CharRNNClassifier(torch.nn.Module):
def __init__(self, input_size, embedding_size, hidden_size, output_size, model="lstm", num_layers=1, bidirectional=False, pad_idx=0):
super().__init__()
self.model = model.lower()
self.hidden_size = hidden_size
self.embed = torch.nn.Embedding(input_size, embedding_size, padding... | sub_df.to_csv('titanic_gender_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,502,313 | if not torch.cuda.is_available() :
print("WARNING: CUDA is not available.Select 'GPU On' on kernel settings")
device = torch.device("cuda")
torch.cuda.manual_seed(seed )<choose_model_class> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
13,502,313 | criterion = torch.nn.CrossEntropyLoss(reduction='sum' )<train_model> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,502,313 | def train(model, optimizer, data, batch_size, token_size, log=False):
model.train()
total_loss = 0
ncorrect = 0
nsentences = 0
ntokens = 0
niterations = 0
for batch in pool_generator(data, batch_size, token_size, shuffle=True):
X = [torch.from_numpy(d[0])for d in batch]
X_lengths = [x.numel() for x in X]
ntokens += sum... | train_data['titles'] = train_data.Name.str.split().str[1]
test_data['titles'] = test_data.Name.str.split().str[1] | Titanic - Machine Learning from Disaster |
13,502,313 | def validate(model, data, batch_size, token_size):
model.eval()
ncorrect = 0
nsentences = 0
with torch.no_grad() :
for batch in pool_generator(data, batch_size, token_size):
X = [torch.from_numpy(d[0])for d in batch]
X_lengths = torch.tensor([x.numel() for x in X], dtype=torch.long, device=device)
y = torch.tensor([d[... | train_data[train_data.Age >12][:3] | Titanic - Machine Learning from Disaster |
13,502,313 | hidden_size = 256
embedding_size = 64
bidirectional = False
ntokens = len(char_vocab)
nlabels = len(lang_vocab )<train_model> | train_data['age_fill'] = train_data['Age']
test_data['age_fill'] = test_data['Age']
def fill_age(df):
for i, title in enumerate(df.titles):
if df.loc[i,'age_fill'] != df.loc[i,'age_fill']:
if df.loc[i,'titles'] == 'Master.':
df.loc[i,'age_fill']= round(random.uniform(0,12),1)
if df.loc[i,'titles'] == 'Miss.':
df.loc[i... | Titanic - Machine Learning from Disaster |
13,502,313 | def testParameters(model, optimizer, epochs, batch_size, token_size):
train_accuracy = []
valid_accuracy = []
for epoch in range(1, epochs + 1):
acc = train(model, optimizer, train_data, batch_size, token_size, log=epoch==1)
train_accuracy.append(acc)
acc = validate(model, val_data, batch_size, token_size)
valid_acc... | train_data['relatives'] = train_data['SibSp'] + train_data['Parch']
test_data['relatives'] = train_data['SibSp'] + train_data['Parch']
train_data.relatives.value_counts() | Titanic - Machine Learning from Disaster |
13,502,313 | Hyperparameter optimisation:
Trains and vlidates the model, then returns the accuracy to persist over iterations .<choose_model_class> | def combine_fam(df):
for i, r in enumerate(df['relatives']):
if df.loc[i,'relatives'] == 0:
df.loc[i,'relatives_code'] = 0
if df.loc[i,'relatives'] > 0 & df.loc[i,'relatives'] <= 3:
df.loc[i,'relatives_code'] = 1
if df.loc[i,'relatives'] > 3 & df.loc[i,'relatives'] <= 5:
df.loc[i,'relatives_code'] = 2
if df.loc[i,'rela... | Titanic - Machine Learning from Disaster |
13,502,313 | model = CharRNNClassifier(ntokens, embedding_size, hidden_size, nlabels, bidirectional=bidirectional, pad_idx=pad_index ).to(device)
optimizer = torch.optim.Adam(model.parameters() )<choose_model_class> | train_data['Fare_new'] = train_data['Fare']
test_data['Fare_new'] = test_data['Fare']
def find_price(df):
freqs = {}
for ticket in df.Ticket:
freqs[ticket]= freqs.get(ticket, 0)+ 1
combined_ticket = {k:v for k,v in freqs.items() if v > 1}
for i, ticket in enumerate(df['Ticket']):
if ticket in combined_ticket:
df.loc[i,... | Titanic - Machine Learning from Disaster |
13,502,313 | batch_sizes = [64, 128, 256, 512, 1024]
token_sizes = np.arange(50000, 350000, 50000)
hidden_sizes = np.arange(128, 768, 64)
embedding_sizes = np.arange(64, 256*4, 64)
embedding_size = 128
hidden_size = 512
hidden_models = []
hidden_optimizers = []
figure = 0
batch_size = 256
token_size = 150000
epochs = 20
max_acc ... | train_data["Sex"] = train_data["Sex"].astype("category")
test_data["Sex"] = test_data["Sex"].astype("category" ) | Titanic - Machine Learning from Disaster |
13,502,313 |
<choose_model_class> | embark = train_data.Embarked.unique() [:3]
train_data['Embarked_fill'] = train_data['Embarked'].fillna(random.choice(embark))
test_data['Embarked_fill'] = test_data['Embarked'].fillna(random.choice(embark))
train_data["Embarked_fill"] = train_data["Embarked_fill"].astype("category")
test_data["Embarked_fill"] = test_d... | Titanic - Machine Learning from Disaster |
13,502,313 |
<choose_model_class> | decks = train_data["Cabin"].str[0].unique() [1:]
train_data["Deck"] = train_data["Cabin"].str[0].fillna(random.choice(decks))
test_data["Deck"] = test_data["Cabin"].str[0].fillna(random.choice(decks))
train_data["Deck"] = train_data["Deck"].astype("category")
test_data["Deck"] = test_data["Deck"].astype("category")
| Titanic - Machine Learning from Disaster |
13,502,313 | model = CharRNNClassifier(ntokens, embedding_size, hidden_size, nlabels, bidirectional=bidirectional, pad_idx=pad_index ).to(device)
optimizer = torch.optim.Adam(model.parameters() )<choose_model_class> | y_train = train_data["Survived"]
features = ['age_fill','Pclass', 'Sex','Deck','Fare_new','Embarked_fill','SibSp','Parch', 'relatives_code']
X_test = test_data[features].copy()
X_train = train_data[features].copy()
| Titanic - Machine Learning from Disaster |
13,502,313 | model = CharRNNClassifier(ntokens, embedding_size, hidden_size, nlabels, bidirectional=bidirectional ).to(device)
optimizer = torch.optim.Adam(model.parameters() )<train_model> | X_train["Sex"] = X_train["Sex"].cat.codes
X_test["Sex"] = X_test["Sex"].cat.codes
X_train["Embarked_fill"] = X_train["Embarked_fill"].cat.codes
X_test["Embarked_fill"] = X_test["Embarked_fill"].cat.codes
X_train["Deck"] = X_train["Deck"].cat.codes
X_test["Deck"] = X_test["Deck"].cat.codes
| Titanic - Machine Learning from Disaster |
13,502,313 | print(f'Training final model for {epochs} epochs')
for epoch in range(1, epochs + 1):
print(f'| epoch {epoch:03d} | train accuracy={train(model, optimizer, train_data + val_data, batch_size, token_size, log=epoch==1):.3f}' )<train_model> | model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
| Titanic - Machine Learning from Disaster |
13,502,313 | def test(model, data, batch_size, token_size):
model.eval()
sindex = []
labels = []
with torch.no_grad() :
for batch in pool_generator(data, batch_size, token_size):
X = [torch.from_numpy(d[0])for d in batch]
X_lengths = torch.tensor([x.numel() for x in X], dtype=torch.long, device=device)
X = torch.nn.utils.rnn.pad_s... | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
14,025,979 | x_test_txt = open(".. /input/x_test.txt" ).read().splitlines()
x_test_idx = [np.array([char_vocab.token2idx[c] if c in char_vocab.token2idx else unk_index for c in line])for line in x_test_txt]
test_data = [(x, idx)for idx, x in enumerate(x_test_idx)]<train_model> | %matplotlib inline
warnings.filterwarnings('ignore')
train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv')
PassengerId=test['PassengerId']
all_data = pd.concat([train, test], ignore_index = True ) | Titanic - Machine Learning from Disaster |
14,025,979 | index, labels = test(model, test_data, batch_size, token_size)
order = np.argsort(index)
labels = labels[order]<save_to_csv> | all_data['Title'] = all_data['Name'].apply(lambda x:x.split(',')[1].split('.')[0].strip())
Title_Dict = {}
Title_Dict.update(dict.fromkeys(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer'))
Title_Dict.update(dict.fromkeys(['Don', 'Sir', 'the Countess', 'Dona', 'Lady'], 'Royalty'))
Title_Dict.update(dict.fromkeys(['Mme... | Titanic - Machine Learning from Disaster |
14,025,979 | with open('submission.csv', 'w')as f:
print('Id,Language', file=f)
for sentence_id, lang_id in enumerate(labels):
language = lang_vocab.idx2token[lang_id]
if sentence_id < 10:
print(f'{sentence_id},{language}')
print(f'{sentence_id},{language}', file=f )<set_options> | all_data[all_data['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
14,025,979 | %matplotlib inline
plt.style.use('seaborn-whitegrid')
warnings.filterwarnings('ignore' )<load_from_csv> | all_data[all_data['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
14,025,979 | train_data = pd.read_csv('.. /input/challenge-gh/TrainData.csv', encoding='ISO-8859-1',sep=';')
test_data = pd.read_csv('.. /input/challenge-gh/TestData.csv', encoding='ISO-8859-1',sep=';')
submission_data = pd.read_csv('.. /input/challenge-gh/Lsungstemplate.csv', encoding='ISO-8859-1' )<categorify> | def info_fill(all_data):
all_data['Embarked'] = all_data['Embarked'].fillna('C')
fare=all_data[(all_data['Embarked'] == "S")&(all_data['Pclass'] == 3)].Fare.median()
all_data['Fare']=all_data['Fare'].fillna(fare)
age_df = all_data[['Age', 'Pclass', 'Sex', 'Title', 'SibSp', 'Parch']]
age_df=pd.get_dummies(age_df)
kno... | Titanic - Machine Learning from Disaster |
14,025,979 | df_train = train_data.replace('Unbekannt', np.nan, inplace=False )<categorify> | def TrainPreprocess(train):
cols=['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Title', 'Fare', 'Embarked']
train = train[cols]
train_linear = train[['Age', 'Fare']]
train['Sex'] = train['Sex'].map({'male': 0, 'female': 1} ).astype(int)
train['Embarked'] = train['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).asty... | Titanic - Machine Learning from Disaster |
14,025,979 | def encode_categorical_features(df):
lb_make = LabelEncoder()
obj_df = df.select_dtypes(include=['object'] ).copy()
cat_col_names=obj_df.columns.tolist()
for name in cat_col_names:
df[name] = lb_make.fit_transform(df[name])
return df<train_model> | def TestPreprocess(test):
cols=['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Title', 'Fare', 'Embarked']
test = test[cols]
test_linear = test[['Age', 'Fare']]
test['Sex'] = test['Sex'].map({'male': 0, 'female': 1} ).astype(int)
test['Embarked'] = test['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
test['Title']... | Titanic - Machine Learning from Disaster |
14,025,979 |
<categorify> | batchsz = 20
_lambda = 0.1 | Titanic - Machine Learning from Disaster |
14,025,979 | columns_to_drop=columns_to_drop = ['Stammnummer', 'Anruf-ID','Tage seit letzter Kampagne','Ergebnis letzte Kampagne','Tag','Alter','Kontostand','Anzahl der Ansprachen','Anzahl Kontakte letzte Kampagne']
df_train=df_train.drop(columns_to_drop,axis=1)
df_train = df_train.apply(lambda x: x.fillna(x.value_counts().index[0... | def build_network() :
network = Sequential([
layers.Dense(64, activation='relu', kernel_regularizer=regularizers.l2(_lambda)) ,
layers.Dropout(rate=0.5),
layers.Dense(32, activation='relu', kernel_regularizer=regularizers.l2(_lambda)) ,
layers.Dropout(rate=0.5),
layers.Dense(1, activation='sigmoid')
])
network.build(... | Titanic - Machine Learning from Disaster |
14,025,979 | df_train[['Dauer']] = df_train[['Dauer']].apply(np.sqrt)
scaler = MinMaxScaler(feature_range=(0, 1))
df_train[['Dauer']] = scaler.fit_transform(df_train[['Dauer']])
train_features_all = df_train.drop(['Zielvariable'], axis=1, errors='ignore')
train_labels_all =df_train.Zielvariable<train_on_grid> | train = all_data[0:891]
test = all_data[891:len(all_data)]
x_train, y_train = TrainPreprocess(train)
x_test = TestPreprocess(test)
db_train = tf.data.Dataset.from_tensor_slices(( x_train, y_train))
db_train = db_train.shuffle(1000 ).batch(batchsz)
network = build_network()
network.fit(db_train, epochs=300)
y_test =... | Titanic - Machine Learning from Disaster |
13,824,870 | def hyper_parameter_tuning(clf_model,Xtrain,ytrain,parameters):
precision_scorer = make_scorer(precision_score)
grid_obj = GridSearchCV(estimator=clf_model, param_grid=parameters, scoring=precision_scorer,cv = 5, n_jobs = -1, verbose = 2)
grid_obj = grid_obj.fit(Xtrain, ytrain)
model = grid_obj.best_estimator_
ret... | %matplotlib inline
| Titanic - Machine Learning from Disaster |
13,824,870 | def recursiveFeature_elimination(df,model):
features = df.drop('Zielvariable', axis=1)
label = df['Zielvariable']
print('original dataset shape %s' % Counter(label))
sm = SMOTE(random_state=43,sampling_strategy='auto')
features_resampled, labels_resampled =sm.fit_resample(features, label)
print('Resampled dataset ... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
13,824,870 | def run_kfold(model,X_all,y_all):
kf = StratifiedKFold(n_splits=10, random_state=43, shuffle=True)
Precisionscore_list = []
accuracyscore_list=[]
F1_score_list= []
fold = 0
for train_index, test_index in kf.split(X_all,y_all):
fold += 1
X_train, X_test = X_all.values[train_index], X_all.values[test_index]
y_train, y... | train.set_index('PassengerId', inplace=True)
test.set_index('PassengerId', inplace=True ) | Titanic - Machine Learning from Disaster |
13,824,870 | classification_model=LogisticRegression(random_state=1)
parameters = { 'C': [0.8,0.9,1.0,1.2],
'class_weight': [None, 'balanced'],
'solver': ['liblinear','sag', 'saga'],
}
best_model=hyper_parameter_tuning(classification_model,train_features_all,train_labels_all,parameters)
features_to_use=recursiveFeature_eliminatio... | train.drop(['Ticket','Cabin'], axis=1, inplace=True)
test.drop(['Ticket','Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,824,870 | y = predictions
pred = pos_label_proba
fpr, tpr, thresholds = metrics.roc_curve(y, pred, pos_label=0)
AUC_score= metrics.auc(fpr, tpr)
df_submission=pd.DataFrame()
df_submission['ID']=submission_data['ID']
df_submission['Expected']=pos_label_proba
df_submission.to_csv('Logistc_Regression_prediction.csv',index=False)
... | train['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
13,824,870 | classification_model=GradientBoostingClassifier(random_state=1)
parameters = { 'n_estimators': [100, 200, 300],
'max_features': ['sqrt','auto'],
'max_depth': [2, 3, 5],
}
best_model=hyper_parameter_tuning(classification_model,train_features_all,train_labels_all,parameters)
features_to_use=recursiveFeature_elimination... | test[test['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
13,824,870 | y = predictions
pred = pos_label_proba
fpr, tpr, thresholds = metrics.roc_curve(y, pred, pos_label=0)
AUC_score= metrics.auc(fpr, tpr)
AUC_score
df_submission=pd.DataFrame()
df_submission['ID']=submission_data['ID']
df_submission['Expected']=pos_label_proba
df_submission.to_csv('Gradient_Boosting_prediction.csv',inde... | test['Fare'].fillna(7.9, inplace=True ) | Titanic - Machine Learning from Disaster |
13,824,870 | classification_model=DecisionTreeClassifier(random_state=1)
parameters = { 'class_weight': [None, 'balanced'],
'max_features': ['sqrt','auto','log2'],
'max_depth': [None, 2, 3, 5],
}
best_model=hyper_parameter_tuning(classification_model,train_features_all,train_labels_all,parameters)
features_to_use=recursiveFeature... | train['Sex'] = preprocessing.LabelEncoder().fit_transform(train['Sex'].values)
test['Sex'] = preprocessing.LabelEncoder().fit_transform(test['Sex'].values)
train['Embarked'] = preprocessing.LabelEncoder().fit_transform(train['Embarked'].values)
test['Embarked'] = preprocessing.LabelEncoder().fit_transform(test['Emba... | Titanic - Machine Learning from Disaster |
13,824,870 | classification_model=RandomForestClassifier(random_state=1)
parameters = { 'class_weight': [None, 'balanced'],
'n_estimators': [100, 200, 300],
'max_features': ['sqrt','auto'],
'max_depth': [None, 2, 3, 5],
}
best_model=hyper_parameter_tuning(classification_model,train_features_all,train_labels_all,parameters)
featur... | for dataset in train, test:
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, 'Fare'] = 3
dataset['Fare'] = dataset['Fare'].astype(... | Titanic - Machine Learning from Disaster |
13,824,870 | import lightgbm as lgb
from sklearn.model_selection import GroupKFold<load_from_csv> | train["Age"] = train[['Pclass', 'Sex', 'Age']].groupby(['Pclass', 'Sex'] ).transform(lambda x: x.fillna(x.median()))
test["Age"] = test[['Pclass', 'Sex', 'Age']].groupby(['Pclass', 'Sex'] ).transform(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
13,824,870 | df = pd.read_csv('.. /input/Training_data.csv')
df_test = pd.read_csv('.. /input/Testing_data.csv')
df_sub = pd.read_csv('.. /input/Submission.csv' )<prepare_x_and_y> | 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, 'Age'... | Titanic - Machine Learning from Disaster |
13,824,870 | features = df.columns[1:-1]
target = df.target<count_unique_values> | train.drop('Name', axis=1, inplace=True)
test.drop('Name', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,824,870 | def get_folds(df=None, n_splits=5, index = 'index'):
unique_vis = np.array(sorted(df[index].unique()))
folds = GroupKFold(n_splits=n_splits)
fold_ids = []
ids = np.arange(df.shape[0])
for trn_vis, val_vis in folds.split(X=unique_vis, y=unique_vis, groups=unique_vis):
fold_ids.append(
[
ids[df[index].isin(unique_vi... | y_train = train["Survived"]
train.drop('Survived', axis=1, inplace=True)
train.shape, y_train.shape, test.shape | Titanic - Machine Learning from Disaster |
13,824,870 | X = df[features]
y = target<init_hyperparams> | random_forest = RandomForestClassifier()
random_forest.fit(train, y_train)
scores = cross_validate(random_forest, train, y_train, scoring='roc_auc', cv=5, return_train_score=True)
scores | Titanic - Machine Learning from Disaster |
13,824,870 | params = {
'boosting_type': 'gbdt',
'objective': 'binary',
'metric': 'auc',
'num_leaves': 63,
'max_depth': 6,
'learning_rate': 0.03,
"bagging_fraction" : 0.9,
"feature_fraction" : 0.9,
'random_state':1
}
sub_reg_preds = np.zeros(df_test.shape[0])
folds = get_folds(df = df.reset_index() ,index = 'index', n_splits=5)
f... | n_est = [int(x)for x in np.linspace(start = 200, stop = 2000, num = 10)]
max_feat = ['auto', 'sqrt']
max_depth = [int(x)for x in np.linspace(5, 110, num = 11)]
max_depth.append(None)
min_samples_split = [2, 5, 10]
min_samples_leaf = [1, 2, 4]
bootstrap = [True, False]
random_grid = {'n_estimators': n_est,
'max_feature... | Titanic - Machine Learning from Disaster |
13,824,870 | df_sub['Probability'] = sub_reg_preds
df_sub.to_csv('sub.csv',index=False )<set_options> | model = RandomForestClassifier(bootstrap=False, criterion='entropy', max_depth=5,
min_samples_leaf=2, min_samples_split=10,
n_estimators=1800)
model.fit(train, y_train)
y_pred = model.predict(test ) | Titanic - Machine Learning from Disaster |
13,824,870 | os.environ['TF_CPP_MIN_LOG_LEVEL']='2'<init_hyperparams> | submission = pd.DataFrame({
"PassengerId": test.index,
"Survived": y_pred
})
submission.to_csv('./submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,900,391 | look_back = 7
epochs = 10
batch_size = 32<define_variables> | train= pd.read_csv('.. /input/titanic/train.csv')
test= pd.read_csv('.. /input/titanic/test.csv')
| Titanic - Machine Learning from Disaster |
13,900,391 | np.random.seed(7 )<load_from_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,900,391 | prices_dataset = pd.read_csv('.. /input/train.csv', header=0)
test_dataset = pd.read_csv('.. /input/test.csv', header=0 )<prepare_x_and_y> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,900,391 | def create_dataset(dataset, look_back):
inds = []
dataX, dataY = [], []
for i in range(len(dataset)-look_back-1):
inds.append(i)
a = dataset[i:(i+look_back), 0]
dataX.append(a)
dataY.append(dataset[i + look_back, 0])
return np.array(dataX), np.array(dataY )<normalization> | train['Embarked'].nunique() | Titanic - Machine Learning from Disaster |
13,900,391 | res_all = np.array([] ).reshape(-1, 1)
for asset in prices_dataset.asset.unique() :
apple = prices_dataset[prices_dataset['asset']==asset]
apple_stock_prices = apple.close.values.astype('float32')
apple_stock_prices = apple_stock_prices.reshape(len(apple_stock_prices), 1)
scaler = MinMaxScaler(feature_range=(0, 1))
... | def preprocess_data(data):
data= data.drop(['Name', 'Ticket'], axis=1)
data['Sex'].replace({'male':'0', 'female':'1'}, inplace= True)
data['Embarked'] = data['Embarked'].fillna(0)
data['Embarked'].replace({'S':'0', 'C':'1', 'Q':'2'}, inplace= True)
data['Sex']= data['Sex'].astype(int)
data['Embarked']= data['Embar... | Titanic - Machine Learning from Disaster |
13,900,391 | scaler = MinMaxScaler(feature_range=(-1, 1))
res_all = scaler.fit_transform(res_all )<filter> | final_train= preprocess_data(train)
final_test= preprocess_data(test ) | Titanic - Machine Learning from Disaster |
13,900,391 | res_all[res_all<-1]=-1<filter> | final_train = final_train.drop(['Cabin'], axis=1)
final_train | Titanic - Machine Learning from Disaster |
13,900,391 | res_all[res_all>1]=1<create_dataframe> | final_test= final_test.drop(['Cabin'], axis=1)
final_test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,900,391 | out_df = pd.DataFrame(res_all, columns=['expected'] )<save_to_csv> | y = final_train['Survived']
X = final_train.drop(['Survived'], axis=1 ) | Titanic - Machine Learning from Disaster |
13,900,391 | out_df.to_csv('Elastic_net.csv',index = True )<load_from_csv> | x_train, x_test, y_train, y_test = train_test_split(X, y, random_state= 42, test_size=0.20)
lin= LinearRegression() | Titanic - Machine Learning from Disaster |
13,900,391 | df_res = pd.read_csv('Elastic_net.csv')
df_res.columns = ['id', 'expected']<save_to_csv> | model= RandomForestClassifier(random_state=1, n_estimators=200, max_depth=10, criterion='entropy', verbose=1)
model.fit(x_train, y_train)
prediction= model.predict(x_test)
final_predict = model.predict(final_test)
| Titanic - Machine Learning from Disaster |
13,900,391 | df_res.to_csv('submit.csv', index=False )<save_to_csv> | X, y = make_classification(n_samples=100, n_features=7,
n_informative=2, n_redundant=0,
random_state=1, shuffle=True)
clf = BaggingClassifier(base_estimator=RandomForestClassifier() ,
n_estimators=10, random_state=1 ).fit(x_train, y_train)
clf.predict(x_test)
final_predict2= clf.predict(final_test ) | Titanic - Machine Learning from Disaster |
13,900,391 | print(os.listdir(".. /input"))
df = pd.DataFrame({'id': [1,2], 'y': [100,100]})
df.head()
df.to_csv("submission.csv", header = True, index = False)
<load_from_csv> | output = pd.DataFrame({'PassengerId': final_test.PassengerId, 'Survived': final_predict})
output.to_csv('my_submission_rf.csv', index=False)
print(output ) | Titanic - Machine Learning from Disaster |
13,900,391 | name = os.path.join(".. /input/ai-academy-intermediate-class-competition-1", "BBC News Train.csv")
data = pd.read_csv(name)
data = data[["Text", "Category"]]
<feature_engineering> | output = pd.DataFrame({'PassengerId': final_test.PassengerId, 'Survived': final_predict2})
output.to_csv('my_submission_clf.csv', index=False)
print(output ) | Titanic - Machine Learning from Disaster |
13,868,595 | vectorizer = TfidfVectorizer(sublinear_tf=True, min_df=5, norm='l2', encoding='latin-1', ngram_range=(1, 2), stop_words='english')
X = vectorizer.fit_transform(data["Text"])
print(len(vectorizer.get_feature_names()))
print(X.shape )<feature_engineering> | import seaborn as sns
import matplotlib.pyplot as plt | Titanic - Machine Learning from Disaster |
13,868,595 | data["category_id"]=data["Category"].factorize() [0]<remove_duplicates> | from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import Perceptron
from sklearn.linear_model import SGDCla... | Titanic - Machine Learning from Disaster |
13,868,595 | data = data[["Text", "category_id", "Category"]]
data
category_id_data = data[['Category', 'category_id']].drop_duplicates().sort_values('category_id')
category_to_id = dict(category_id_data.values)
id_to_category = dict(category_id_data[['category_id', 'Category']].values)
category_id_data
id_to_category<categorify... | from sklearn.ensemble import ExtraTreesClassifier | Titanic - Machine Learning from Disaster |
13,868,595 | tfidf = TfidfVectorizer(sublinear_tf=True, min_df=5, norm='l2', encoding='latin-1', ngram_range=(1, 2), stop_words='english')
features = tfidf.fit_transform(data.Text ).toarray()
print(features)
labels = data.category_id
print(labels)
features.shape<statistical_test> | df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv')
combine = [df, test_df] | Titanic - Machine Learning from Disaster |
13,868,595 | N = 5
for category, category_id in sorted(category_to_id.items()):
features_chi2 = chi2(features, labels == category_id)
indices = np.argsort(features_chi2[0])
feature_names = np.array(tfidf.get_feature_names())[indices]
unigrams = [v for v in feature_names if len(v.split(' ')) == 1]
bigrams = [v for v in feature_nam... | df.isnull().sum() | Titanic - Machine Learning from Disaster |
13,868,595 | X_train, X_test, y_train, y_test, indices_train, indices_test = train_test_split(features, labels, data.index, test_size=0.33, random_state=0)
for model in models:
model.fit(X_train, y_train)
y_pred_proba = model.predict_proba(X_test)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(a... | for dataset in combine:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle... | Titanic - Machine Learning from Disaster |
13,868,595 | model = models[2]
model.fit(features, labels)
model.coef_<load_from_csv> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0 ) | Titanic - Machine Learning from Disaster |
13,868,595 | test_data = pd.read_csv(".. /input/bbc-test/BBC News Test.csv")
test_data<predict_on_test> | emb = pd.get_dummies(df.Title)
df = df.join(emb)
df = df.rename(columns={1:"Mr", 2:"Miss", 3:"Mrs", 4:"Master", 5:"Rare"})
df = df.drop(["Title"],axis=1)
emb = pd.get_dummies(test_df.Title)
test_df = test_df.join(emb)
test_df = test_df.rename(columns={1:"Mr", 2:"Miss", 3:"Mrs", 4:"Master", 5:"Rare"})
test_df = t... | Titanic - Machine Learning from Disaster |
13,868,595 | test_data.Text.tolist()
test_features = tfidf.transform(test_data.Text.tolist())
Y_pred = model.predict(test_features)
Y_pred
submission = []
for pred in Y_pred:
submission.append(id_to_category[pred])
submission<create_dataframe> | freq_port = df.Embarked.dropna().mode() [0]
freq_port | Titanic - Machine Learning from Disaster |
13,868,595 | submission = pd.DataFrame({
"ArticleId": test_data["ArticleId"],
"Category": submission
})
submission<save_to_csv> | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
13,868,595 | submission.to_csv('submission.csv', index=False )<save_to_csv> | for dataset in combine:
dataset["Sex"] = dataset["Sex"].map({'male': 1,'female':0})
dataset["Embarked"] = dataset["Embarked"].map({'S': 1,'C':2,'Q':3})
emb = pd.get_dummies(df.Embarked)
df = df.join(emb)
df = df.rename(columns={1.0: "S", 2.0: "C", 3.0 : "Q"})
emb = pd.get_dummies(test_df.Embarked)
test_df = test_... | Titanic - Machine Learning from Disaster |
13,868,595 | submission.to_csv('submission.csv', index=False )<load_from_csv> | def status(feature):
print('Processing', feature, ': ok')
| Titanic - Machine Learning from Disaster |
13,868,595 | TRAIN_PATH = os.path.join(".. /input/ai-academy-intermediate-class-competition-1", "BBC News Train.csv")
df = pd.read_csv(TRAIN_PATH )<feature_engineering> | def process_cabin(combined):
combined.Cabin.fillna('U', inplace=True)
combined['Cabin'] = combined['Cabin'].map(lambda c: c[0])
cabin_dummies = pd.get_dummies(combined['Cabin'], prefix='Cabin')
combined = pd.concat([combined, cabin_dummies], axis=1)
combined.drop('Cabin', axis=1, inplace=True)
status('cabin')
ret... | Titanic - Machine Learning from Disaster |
13,868,595 | df['category_id'] = df['Category'].factorize() [0]
df['category_id'][0:10]<remove_duplicates> | combine = [df,test_df] | Titanic - Machine Learning from Disaster |
13,868,595 | category_id_df = df[['Category', 'category_id']].drop_duplicates().sort_values('category_id' )<define_variables> | df = df.drop('Cabin_T', axis=1)
df.head() | 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.