kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,356,555 | df.ingredients = df.ingredients.astype('str')
df.ingredients = df.ingredients.str.replace("["," ")
df.ingredients = df.ingredients.str.replace("]"," ")
df.ingredients = df.ingredients.str.replace("'"," ")
df.ingredients = df.ingredients.str.replace(","," " )<data_type_conversions> | alldata['titles'] = pd.Categorical(alldata['titles'])
| Titanic - Machine Learning from Disaster |
14,356,555 | testset.ingredients = testset.ingredients.astype('str')
testset.ingredients = testset.ingredients.str.replace("["," ")
testset.ingredients = testset.ingredients.str.replace("]"," ")
testset.ingredients = testset.ingredients.str.replace("'"," ")
testset.ingredients = testset.ingredients.str.replace(","," " )<feature... | alldata['titles'] = alldata['titles'].cat.codes | Titanic - Machine Learning from Disaster |
14,356,555 | vect = TfidfVectorizer()<feature_engineering> | alldata.drop('titles1',axis=1 ) | Titanic - Machine Learning from Disaster |
14,356,555 | features = vect.fit_transform(df.ingredients )<categorify> | alldata.loc[alldata['Sex']=='male','Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 | testfeatures = vect.transform(testset.ingredients )<categorify> | alldata.loc[alldata['Sex']=='female','Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 | encoder = LabelEncoder()
labels = encoder.fit_transform(df.cuisine )<split> | alldata.loc[alldata['Pclass']==1,'Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 | X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2 )<compute_test_metric> | alldata.loc[alldata['Pclass']==2,'Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 |
<choose_model_class> | alldata.loc[alldata['Pclass']==3,'Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 |
<compute_test_metric> | alldata['Embarked']=alldata['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
14,356,555 |
<compute_test_metric> | alldata.isnull().sum() | Titanic - Machine Learning from Disaster |
14,356,555 |
<split> | pclass_list = list(alldata['Pclass'].unique())
df_averages = []
for classes in pclass_list:
df_averages.append(( alldata.loc[alldata['Pclass']==classes]['Age'].mean()))
averages = pd.DataFrame(df_averages,index=pclass_list,columns=['Average age in class'])
averages | Titanic - Machine Learning from Disaster |
14,356,555 |
<import_modules> | pclass_list = list(alldata['Pclass'].unique())
df_fares = []
for fares in pclass_list:
df_fares.append(( alldata.loc[alldata['Pclass']==fares]['Fare'].median()))
averages2 = pd.DataFrame(df_fares,index=pclass_list,columns=['Average fare in class'])
averages2 | Titanic - Machine Learning from Disaster |
14,356,555 |
<compute_test_metric> | alldata.loc[(alldata['Age'].isnull())&(alldata['Pclass']== 1),'Age'] = averages.loc[1,'Average age in class']
alldata.loc[(alldata['Age'].isnull())&(alldata['Pclass']== 2),'Age'] = averages.loc[2,'Average age in class']
alldata.loc[(alldata['Age'].isnull())&(alldata['Pclass']== 3),'Age'] = averages.loc[3,'Average age i... | Titanic - Machine Learning from Disaster |
14,356,555 |
<import_modules> | farebandlist = list(alldata['FareBand'].unique())
farelist =[]
for fares in farebandlist:
farelist.append(alldata.loc[(alldata['type']=='train')&(alldata['FareBand']== fares),'Survived'].value_counts())
farelist = pd.DataFrame(farelist,index=farebandlist)
farelist.columns
| Titanic - Machine Learning from Disaster |
14,356,555 | import lightgbm as lgb<train_model> | farelist[[0.0, 1.0]] = farelist[[0.0, 1.0]].apply(lambda x: x/x.sum() , axis=1)
farelist | Titanic - Machine Learning from Disaster |
14,356,555 | gbm = lgb.LGBMClassifier(objective="mutliclass",n_estimators=10000,num_leaves=512)
gbm.fit(X_train,y_train,verbose = 300 )<predict_on_test> | alldata['FareBand'] = alldata['FareBand'].astype(np.int64)
alldata.info() | Titanic - Machine Learning from Disaster |
14,356,555 | pred = gbm.predict(testfeatures )<categorify> | sex1 = pd.get_dummies(alldata['Sex'],drop_first=True)
embarked1 = pd.get_dummies(alldata['Embarked'],drop_first=True)
alldata.drop(['Sex','Embarked'],axis=1,inplace=True)
| Titanic - Machine Learning from Disaster |
14,356,555 | predconv = encoder.inverse_transform(pred )<create_dataframe> | alldata = pd.concat([alldata,sex1,embarked1],axis=1 ) | Titanic - Machine Learning from Disaster |
14,356,555 | sub = pd.DataFrame({'id':testset.id,'cuisine':predconv} )<define_variables> | alldata.drop(['Ticket','Fare','Age'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,356,555 | output = sub[['id','cuisine']]<save_to_csv> | train = alldata.loc[alldata['type']=='train']
test = alldata.loc[alldata['type']=='test'] | Titanic - Machine Learning from Disaster |
14,356,555 | output.to_csv("outputfile.csv",index = False )<import_modules> | train = train.drop(['type'],axis=1)
| Titanic - Machine Learning from Disaster |
14,356,555 | %matplotlib inline
init_notebook_mode(connected=True)
warnings.filterwarnings("ignore")
notebookstart= time.time()<load_from_disk> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
14,356,555 | train_df = pd.read_json('.. /input/train.json')
test_df = pd.read_json('.. /input/test.json')
train=train_df
train.head(15 )<sort_values> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
14,356,555 | train=train_df
total = train.isnull().sum().sort_values(ascending = False)
percent =(train.isnull().sum() /train.isnull().count() *100 ).sort_values(ascending = False)
missing_train_data = pd.concat([total, percent], axis=1, keys=['Total missing', 'Percent missing'])
print("
print(missing_train_data.head() )<categor... | test = test.drop(['type'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,356,555 | train_df['seperated_ingredients'] = train_df['ingredients'].apply(','.join)
test_df['seperated_ingredients'] = test_df['ingredients'].apply(','.join)
train_df['for ngrams']=train_df['seperated_ingredients'].str.replace(',',' ')
def generate_ngrams(text, n):
words = text.split(' ')
iterations = len(words)- n + 1
for... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,356,555 | df = pd.read_json('.. /input/train.json' ).set_index('id')
test_df = pd.read_json('.. /input/test.json' ).set_index('id')
traindex = df.index
testdex = test_df.index
y = df.cuisine.copy()
df = pd.concat([df.drop("cuisine", axis=1), test_df], axis=0)
df_index = df.index
del test_df; gc.collect() ;
vect = CountVectori... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
14,356,555 | def read_dataset(path):
return json.load(open(path))
train = read_dataset('.. /input/train.json')
test = read_dataset('.. /input/test.json')
def generate_text(data):
text_data = [" ".join(doc['ingredients'] ).lower() for doc in data]
return text_data
train_text = generate_text(train)
test_text = generate_text(test)
... | X = train.drop(['Survived','PassengerId'],axis=1)
y = train['Survived'] | Titanic - Machine Learning from Disaster |
14,356,555 | def compareAccuracy(a, b):
print('
Compare Multiple Classifiers:
')
print('K-Fold Cross-Validation Accuracy:
')
names = []
models = []
resultsAccuracy = []
models.append(( 'LR', LogisticRegression()))
models.append(( 'LSVM', LinearSVC()))
models.append(( 'RF', RandomForestClassifier()))
for name, model in models:
mod... | x_train, x_test, y_train, y_test = train_test_split(X, y, test_size =
0.25, random_state = 0 ) | Titanic - Machine Learning from Disaster |
14,356,555 | compareAccuracy(X2,y2)
defineModels()<save_to_csv> | from sklearn import preprocessing | Titanic - Machine Learning from Disaster |
14,356,555 | model = LinearSVC()
model.fit(X, y)
submission = model.predict(test_df)
submission_df = pd.Series(submission, index=testdex ).rename('cuisine')
submission_df.to_csv("recipe_submission.csv", index=True, header=True)
model.fit(X2, y2)
y_test3 = model.predict(X_test3)
y_pred = lb.inverse_transform(y_test3)
test_id ... | scaler = preprocessing.StandardScaler().fit(x_train ) | Titanic - Machine Learning from Disaster |
14,356,555 | os.environ['PYTHONHASHSEED'] = '10000'
np.random.seed(10001)
random.seed(10002)
tf.set_random_seed(10003)
wordnet_lemmatizer = WordNetLemmatizer()
stop_words = set(stopwords.words('english'))
<define_variables> | X_scaled = scaler.transform(x_train ) | Titanic - Machine Learning from Disaster |
14,356,555 | path = '.. /input/'
embedding_path = '.. /input/embeddings/'
cores = 4
max_text_length=50
do_submission = False
min_df_one=1
keep_only_words_in_embedding = True
keep_unknown_words_in_keras_sequence_as_zeros = True
contraction_mapping = {u"ain't": u"is not", u"aren't": u"are not",u"can't": u"cannot", u"'cause": u"becaus... | scaler = preprocessing.StandardScaler().fit(x_test ) | Titanic - Machine Learning from Disaster |
14,356,555 | def load_glove_words() :
EMBEDDING_FILE = embedding_path+'glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, 1
embeddings_index1 = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
EMBEDDING_FILE = embedding_path+'paragram_300_sl999/paragram_300_sl999.txt'
embeddings_index2 = dict(ge... | X_testscaled = scaler.transform(x_test ) | Titanic - Machine Learning from Disaster |
14,356,555 | def clean_str(text):
text = re.sub(u"\[math\].*\[\/math\]", u" math ", text)
text = re.sub(u"\S*@\S*\.\S*", u" email ", text)
text = u" ".join(re.sub(u"^\d+(?:[.,]\d*)?$", u"number", w)for w in text.split(" "))
specials = [u"’", u"‘", u"´", u"`", u"\u2019"]
for s in specials:
text = u" ".join(w.replace(s, u"'")for w ... | params_to_test = {
'n_estimators':[50,100,150,170,180,190,200,210],
'max_depth':[3,5,6]
}
rf_model = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(rf_model, param_grid=params_to_test, cv=10, scoring='f1_macro', n_jobs=4)
grid_search.fit(X_scaled, y_train)
best_params = grid_search.best_params_
b... | Titanic - Machine Learning from Disaster |
14,356,555 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in [i * 0.01 for i in range(10,70)]:
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
search_result = {'threshold': best_threshold, 'f1': best_score}
re... | best_model.fit(X_scaled,y_train ) | Titanic - Machine Learning from Disaster |
14,356,555 | df_sub = pd.read_csv(path+'test.csv', encoding='utf-8', engine='python')
df_sub['target'] = -99
df_sub['question_text'].fillna(u'unknownstring', inplace=True)
df_train_all = pd.read_csv(path+'train.csv', encoding='utf-8', engine='python')
df_train_all['question_text'].fillna(u'unknownstring', inplace=True)
df_sub['... | betterpred = best_model.predict(X_testscaled ) | Titanic - Machine Learning from Disaster |
14,356,555 | df_train_all['seq_question_text_in_glove'] = parallelize_dataframe(df_train_all['question_text'], preprocess_keras_df)
train_keras = get_keras_data(df_train_all)
df_sub['seq_question_text_in_glove'] = parallelize_dataframe(df_sub['question_text'], preprocess_keras_df)
sub_keras = get_keras_data(df_sub)
<train_model> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
14,356,555 | scale = 1.
BATCH_SIZE = int(scale*1024)
lr1 = scale*2e-3
lr2 = scale*1e-3
batch_size = BATCH_SIZE
epochs = 5
save_model_name='./model32.h5'
all_preds_sub = [ ]
print("Fitting RNN model...")
for bag in range(7):
train_generator = DataGenerator(train_keras, df_train_all['target'].values, shuffle=True, seed=bag)
rnn_m... | predacc = round(accuracy_score(betterpred, y_test)* 100, 2)
print(predacc,'%' ) | Titanic - Machine Learning from Disaster |
14,356,555 | subThreshold = 0.33
mean_preds = np.array(all_preds_sub ).transpose()
mean_preds = mean_preds.mean(axis=1)
sub_df = pd.DataFrame()
sub_df['qid'] = df_sub.qid.values
sub_df['prediction'] =(mean_preds>subThreshold ).astype(int)
sub_df.to_csv('submission.csv', index=False )<set_options> | scale1 = preprocessing.StandardScaler().fit(X)
X_scaled1 = scale1.transform(X ) | Titanic - Machine Learning from Disaster |
14,356,555 | warnings.filterwarnings('ignore' )<import_modules> | X_test = test.drop(['Survived','PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,356,555 | from nltk.tokenize import TweetTokenizer
from gensim.models import KeyedVectors
from sklearn.metrics import f1_score
from sklearn.model_selection import StratifiedKFold, train_test_split<import_modules> | predscale1 = preprocessing.StandardScaler().fit(X_test)
pred_scale = predscale1.transform(X_test ) | Titanic - Machine Learning from Disaster |
14,356,555 | import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch
import torchtext
from torchtext import data, vocab
from torchtext.data import Dataset<import_modules> | testpred = best_model.predict(pred_scale ) | Titanic - Machine Learning from Disaster |
14,356,555 | torchtext.vocab.tqdm = tqdm_notebook<define_variables> | output = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': testpred})
output.info()
output['Survived'] = output['Survived'].astype('int64')
output.head() | Titanic - Machine Learning from Disaster |
14,356,555 | path = ".. /input"
emb_path = ".. /input/embeddings"
n_folds = 5
bs = 512
device = 'cuda'<set_options> | output['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 | seed = 7777
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True<choose_model_class> | from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
14,356,555 | tknzr = TweetTokenizer(strip_handles=True, reduce_len=True )<define_variables> | model = SVC() | Titanic - Machine Learning from Disaster |
14,356,555 | mispell_dict = {
"can't" : "can not", "tryin'":"trying",
"'m": " am", "'ll": " 'll", "'d" : " 'd'", ".. ": " ",".": ".", ",":" , ",
"'ve" : " have", "n't": " not","'s": " 's", "'re": " are", "$": " $","’": " ' ",
"y'all": "you all", 'metoo': 'me too',
'colour': 'color', 'centre': 'center', 'favourite': 'favorite',
'tra... | model.fit(X_scaled,y_train ) | Titanic - Machine Learning from Disaster |
14,356,555 | def find_threshold(y_t, y_p, floor=-1., ceil=1., steps=41):
thresholds = np.linspace(floor, ceil, steps)
best_val = 0.0
for threshold in thresholds:
val_predict =(y_p > threshold)
score = f1_score(y_t, val_predict)
if score > best_val:
best_threshold = threshold
best_val = score
return best_threshold<split> | predictions = model.predict(X_testscaled ) | Titanic - Machine Learning from Disaster |
14,356,555 | def splits_cv(data, cv, y=None):
for indices in cv.split(range(len(data)) , y):
(train_data, val_data)= tuple([data.examples[i] for i in index] for index in indices)
yield tuple(Dataset(d, data.fields)for d in(train_data, val_data)if d )<load_from_csv> | svcacc = round(accuracy_score(predictions, y_test)* 100, 2)
print(svcacc,'%' ) | Titanic - Machine Learning from Disaster |
14,356,555 | skf = StratifiedKFold(n_splits = n_folds, shuffle = True, random_state = seed)
scores = pd.read_csv('.. /input/train.csv')
target = scores.target.values
scores = scores.set_index('qid')
scores.drop(columns=['question_text'], inplace=True)
subm = pd.read_csv('.. /input/test.csv')
subm = subm.set_index('qid')
subm.... | testpredictions = model.predict(pred_scale ) | Titanic - Machine Learning from Disaster |
14,356,555 | txt_field = data.Field(sequential=True, tokenize=tokenizer, include_lengths=False, use_vocab=True)
label_field = data.Field(sequential=False, use_vocab=False, is_target=True)
qid_field = data.RawField()
train_fields = [
('qid', qid_field),
('question_text', txt_field),
('target', label_field)
]
test_fields = [
(... | output2 = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': testpredictions})
output2.info()
output2['Survived'] = output['Survived'].astype('int64')
output2.head() | Titanic - Machine Learning from Disaster |
14,356,555 | train_ds = data.TabularDataset(path=os.path.join(path, 'train.csv'),
format='csv',
fields=train_fields,
skip_header=True)
test_ds = data.TabularDataset(path=os.path.join(path, 'test.csv'),
format='csv',
fields=test_fields,
skip_header=True )<define_variables> | output['Survived'].value_counts()
| Titanic - Machine Learning from Disaster |
14,356,555 | test_ds.fields['qid'].is_target = False
train_ds.fields['qid'].is_target = False<define_variables> | output2['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
14,356,555 | <choose_model_class><EOS> | output2.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,420,831 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_train_metric> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
13,420,831 | def OOF_preds(test_df, target, embs_vocab, epochs = 4, alias='prediction', cv=skf,
loss_fn = torch.nn.BCEWithLogitsLoss(reduction='mean', pos_weight=(torch.Tensor([2.7])).to(device)) ,
bs = 512, embedding_dim = 300, bidirectional=True, n_hidden = 64):
print('Embedding vocab size: ', embs_vocab.size() [0])
test_df[alia... | from sklearn.preprocessing import OneHotEncoder, LabelEncoder, label_binarize, StandardScaler | Titanic - Machine Learning from Disaster |
13,420,831 | def preload_gnews() :
vector_google = KeyedVectors.load_word2vec_format(os.path.join(emb_path, embs_file['gnews']), binary=True)
stoi = {s:idx for idx, s in enumerate(vector_google.index2word)}
itos = {idx:s for idx, s in enumerate(vector_google.index2word)}
cache='cache/'
path_cache = os.path.join(cache, 'GoogleNews-... | from sklearn.metrics import mean_absolute_error as MAE
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import OneHotEncoder | Titanic - Machine Learning from Disaster |
13,420,831 | def fill_unknown(vector):
data = torch.zeros_like(vector)
data.copy_(vector)
idx = torch.nonzero(data.sum(dim=1)== 0)
data[idx] = embs_vocab['glove'][idx]
idx = torch.nonzero(data.sum(dim=1)== 0)
data[idx] = embs_vocab['wiki'][idx]
idx = torch.nonzero(data.sum(dim=1)== 0)
data[idx] = embs_vocab['gnews'][idx]
retur... | from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import GradientBoostingClassifier | Titanic - Machine Learning from Disaster |
13,420,831 | %%time
subm = OOF_preds(subm, target, epochs = 5, alias='wiki',
embs_vocab=fill_unknown(embs_vocab['wiki']),
cv = StratifiedKFold(n_splits = n_folds, shuffle = True, random_state = seed),
embedding_dim = 300, bidirectional=True, n_hidden = 64 )<compute_train_metric> | from catboost import CatBoostClassifier, Pool, cv | Titanic - Machine Learning from Disaster |
13,420,831 | %%time
subm = OOF_preds(subm, target, epochs = 5, alias='glove',
embs_vocab=fill_unknown(embs_vocab['glove']),
cv = StratifiedKFold(n_splits = n_folds, shuffle = True, random_state = seed+15),
bs = 512, embedding_dim = 300, bidirectional=True, n_hidden = 64 )<compute_train_metric> | from sklearn.ensemble import VotingClassifier | Titanic - Machine Learning from Disaster |
13,420,831 | %%time
subm = OOF_preds(subm, target, epochs = 5, alias='gnews',
embs_vocab=fill_unknown(embs_vocab['gnews']),
cv = StratifiedKFold(n_splits = n_folds, shuffle = True, random_state = seed+25),
bs = 512, embedding_dim = 300, bidirectional=True, n_hidden = 64 )<feature_engineering> | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RandomizedSearchCV | Titanic - Machine Learning from Disaster |
13,420,831 | submission = np.mean(subm.values, axis = 1 )<save_to_csv> | train_data_path = ".. /input/titanic/train.csv"
test_data_path = ".. /input/titanic/test.csv" | Titanic - Machine Learning from Disaster |
13,420,831 | subm['prediction'] = submission > 0.55
subm.prediction = subm.prediction.astype('int')
subm.to_csv('submission.csv', columns=['prediction'] )<import_modules> | train_data = pd.read_csv(train_data_path)
test_data = pd.read_csv(test_data_path ) | Titanic - Machine Learning from Disaster |
13,420,831 | tqdm.pandas(desc='Progress')
<define_variables> | num_var = ['Age', 'SibSp', 'Parch', 'Fare']
cat_var = ['Survived', 'Pclass', 'Sex', 'Ticket', 'Cabin', 'Embarked'] | Titanic - Machine Learning from Disaster |
13,420,831 | embed_size = 300
max_features = 120000
maxlen = 70
batch_size = 512
n_epochs = 5
n_splits = 5
SEED = 10
debug =0<choose_model_class> | df_num = train_data[num_var]
df_cat = train_data[cat_var] | Titanic - Machine Learning from Disaster |
13,420,831 | loss_fn = torch.nn.BCEWithLogitsLoss(reduction='sum' )<set_options> | pd.pivot_table(train_data, index='Survived', values = num_var ) | Titanic - Machine Learning from Disaster |
13,420,831 | def seed_everything(seed=10):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything()<features_selection> | [i for i in cat_var if i not in ['Survived', 'Ticket']] | Titanic - Machine Learning from Disaster |
13,420,831 | def load_glove(word_index):
EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')[:300]
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,e... | train_data['cabin_count'] = train_data.Cabin.apply(lambda x: 0 if pd.isna(x)else len(x.split()))
train_data['cabin_count'].value_counts() | Titanic - Machine Learning from Disaster |
13,420,831 | def build_vocab(texts):
sentences = texts.apply(lambda x: x.split() ).values
vocab = {}
for sentence in sentences:
for word in sentence:
try:
vocab[word] += 1
except KeyError:
vocab[word] = 1
return vocab
def known_contractions(embed):
known = []
for contract in contraction_mapping:
if contract in embed:
known.append(c... | pd.pivot_table(train_data, index='Survived', columns='cabin_count', values='Ticket', aggfunc='count' ) | Titanic - Machine Learning from Disaster |
13,420,831 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | train_data['cabin_adv'] = train_data.Cabin.apply(lambda x: str(x)[0])
train_data['cabin_adv'].value_counts() | Titanic - Machine Learning from Disaster |
13,420,831 | def parallelize_apply(df,func,colname,num_process,newcolnames):
pool =Pool(processes=num_process)
arraydata = pool.map(func,tqdm(df[colname].values))
pool.close()
newdf = pd.DataFrame(arraydata,columns = newcolnames)
df = pd.concat([df,newdf],axis=1)
return df
def parallelize_dataframe(df, func):
df_split = np.array... | pd.pivot_table(train_data, index='Survived', columns='cabin_adv', values='Ticket', aggfunc='count' ) | Titanic - Machine Learning from Disaster |
13,420,831 | start = time.time()
x_train, x_test, y_train, features, test_features, word_index = load_and_prec()
print(time.time() -start )<normalization> | train_data['numeric_ticket'] = train_data.Ticket.apply(lambda x: 1 if x.isnumeric() else 0)
train_data['numeric_ticket'] | Titanic - Machine Learning from Disaster |
13,420,831 | seed_everything()
if debug:
paragram_embeddings = np.random.randn(120000,300)
glove_embeddings = np.random.randn(120000,300)
embedding_matrix = np.mean([glove_embeddings, paragram_embeddings], axis=0)
else:
glove_embeddings = load_glove(word_index)
paragram_embeddings = load_para(word_index)
embedding_matrix = np.... | pd.pivot_table(train_data, index='Survived', columns='numeric_ticket', values='Ticket', aggfunc='count' ) | Titanic - Machine Learning from Disaster |
13,420,831 | class CyclicLR(object):
def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,
step_size=2000, mode='triangular', gamma=1.,
scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):
if not isinstance(optimizer, Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(optimizer ).__name__))
self.optimizer... | print(142/88, 407/254 ) | Titanic - Machine Learning from Disaster |
13,420,831 | class MyDataset(Dataset):
def __init__(self,dataset):
self.dataset = dataset
def __getitem__(self,index):
data,target = self.dataset[index]
return data,target,index
def __len__(self):
return len(self.dataset )<compute_train_metric> | train_data['name_title'] = train_data.Name.apply(lambda x: x.split(',', 1)[1].split('.', 1)[0])
train_data['name_title'] | Titanic - Machine Learning from Disaster |
13,420,831 | def pytorch_model_run_cv(x_train,y_train,features,x_test, model_obj, feats = False,clip = True):
seed_everything()
avg_losses_f = []
avg_val_losses_f = []
train_preds = np.zeros(( len(x_train)))
test_preds = np.zeros(( len(x_test)))
splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=SEED ).sp... | train_data['name_title'].value_counts() | Titanic - Machine Learning from Disaster |
13,420,831 | class Alex_NeuralNet_Meta(nn.Module):
def __init__(self,hidden_size,lin_size, embedding_matrix=embedding_matrix):
super(Alex_NeuralNet_Meta, self ).__init__()
self.hidden_size = hidden_size
drp = 0.1
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_mat... | def feature_engineer_df(df):
print("adding column 'cabin_count'...")
df['cabin_count'] = df.Cabin.apply(lambda x: 0 if pd.isna(x)else len(x.split()))
print("adding column 'cabin_adv'...")
df['cabin_adv'] = df.Cabin.apply(lambda x: str(x)[0])
print("adding column 'numeric_ticket'...")
df['numeric_ticket'] = df.Tic... | Titanic - Machine Learning from Disaster |
13,420,831 | def sigmoid(x):
return 1 /(1 + np.exp(-x))
seed_everything()
x_test_cuda = torch.tensor(x_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False )<compute_train_metric> | def solve_mismatch(df_train, df_test):
df_train['train_data'] = 1
df_test['train_data'] = 0
df_test['Survived'] = 0
combined_df = pd.concat([df_train, df_test])
combined_df.Pclass = combined_df.Pclass.astype(str)
combined_dummy = pd.get_dummies(combined_df[['PassengerId', 'Survived', 'Pclass', 'Sex', 'Age', 'SibSp', ... | Titanic - Machine Learning from Disaster |
13,420,831 | train_preds , test_preds = pytorch_model_run_cv(x_train,y_train,features,x_test,Alex_NeuralNet_Meta(70,16, embedding_matrix=embedding_matrix), feats = True )<compute_test_metric> | def ft_splitted(df, drop=['Survived', 'PassengerId']):
X = df.drop(drop, axis=1)
y = df[drop[0]]
return([X, y] ) | Titanic - Machine Learning from Disaster |
13,420,831 | def bestThresshold(y_train,train_preds):
tmp = [0,0,0]
delta = 0
for tmp[0] in tqdm(np.arange(0.1, 0.501, 0.01)) :
tmp[1] = f1_score(y_train, np.array(train_preds)>tmp[0])
if tmp[1] > tmp[2]:
delta = tmp[0]
tmp[2] = tmp[1]
print('best threshold is {:.4f} with F1 score: {:.4f}'.format(delta, tmp[2]))
return delta , tmp... | feature_engineer_df(train_data ) | Titanic - Machine Learning from Disaster |
13,420,831 | if debug:
df_test = pd.read_csv(".. /input/test.csv")[:20000]
else:
df_test = pd.read_csv(".. /input/test.csv")
submission = df_test[['qid']].copy()
submission['prediction'] =(test_preds > delta ).astype(int)
submission.to_csv('submission.csv', index=False )<import_modules> | train_data['age_missing'].value_counts() | Titanic - Machine Learning from Disaster |
13,420,831 | from numpy import array
from numpy import asarray
from numpy import zeros
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense
from keras.layers import Flatten
from keras.lay... | feature_engineer_df(test_data ) | Titanic - Machine Learning from Disaster |
13,420,831 | df_train = pd.read_csv(".. /input/train.csv" )<load_from_csv> | test_data['age_missing'].value_counts() | Titanic - Machine Learning from Disaster |
13,420,831 | df_test = pd.read_csv(".. /input/test.csv" )<feature_engineering> | train_data, test_data = solve_mismatch(train_data, test_data ) | Titanic - Machine Learning from Disaster |
13,420,831 | tokenizer = Tokenizer()
tokenizer.fit_on_texts(df_train['question_text'] )<define_variables> | X_train, y_train = ft_splitted(train_data ) | Titanic - Machine Learning from Disaster |
13,420,831 | vocab_size = len(tokenizer.word_index)+ 1<string_transform> | def scale_data(X):
scale = StandardScaler()
X_scaled = X.copy()
X_scaled[['Age', 'SibSp', 'Parch', 'norm_fare']] = scale.fit_transform(X_scaled[['Age', 'SibSp', 'Parch', 'norm_fare']])
return(X_scaled ) | Titanic - Machine Learning from Disaster |
13,420,831 | ts_train=tokenizer.texts_to_sequences(df_train['question_text'] )<string_transform> | X_train_scaled = scale_data(X_train)
X_train_scaled.head() | Titanic - Machine Learning from Disaster |
13,420,831 | ts_test=tokenizer.texts_to_sequences(df_test['question_text'] )<concatenate> | X_test_scaled = scale_data(test_data.drop(['PassengerId'], axis=1))
X_test_scaled.head() | Titanic - Machine Learning from Disaster |
13,420,831 | X_train_vectorized=pad_sequences(ts_train,maxlen=135,padding='post' )<concatenate> | def get_model_accuracy(model, cv=5):
cv_score = cross_val_score(model, X_train_scaled, y_train, cv=cv)
print(cv_score)
print(f"{model.__class__.__name__}({format(cv_score.mean() *100, '.2f')}%)")
return(cv_score.mean() ) | Titanic - Machine Learning from Disaster |
13,420,831 | X_test_vectorized=pad_sequences(ts_test,maxlen=135,padding='post' )<prepare_x_and_y> | GNB = GaussianNB()
get_model_accuracy(GNB ) | Titanic - Machine Learning from Disaster |
13,420,831 | y_train = df_train['target']<feature_engineering> | LR = LogisticRegression()
get_model_accuracy(LR ) | Titanic - Machine Learning from Disaster |
13,420,831 | embeddings_index = {}
f = open('.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt', encoding='utf8')
for line in f:
values = line.split()
word = ''.join(values[:-300])
coefs = np.asarray(values[-300:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Loaded %s word vectors.' % len(embeddings_i... | SVC = svm.SVC(probability=True)
get_model_accuracy(SVC ) | Titanic - Machine Learning from Disaster |
13,420,831 | embedding_matrix = zeros(( vocab_size, 300))
for word, i in tokenizer.word_index.items() :
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector<choose_model_class> | KNN = KNeighborsClassifier()
get_model_accuracy(KNN ) | Titanic - Machine Learning from Disaster |
13,420,831 | model = Sequential()
e = Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=135, trainable=False)
model.add(e)
model.add(Bidirectional(LSTM(128, return_sequences=True)))
model.add(Flatten())
model.add(Dense(128, activation='sigmoid'))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid')... | RFC = RandomForestClassifier(random_state=42)
get_model_accuracy(RFC ) | Titanic - Machine Learning from Disaster |
13,420,831 | model.fit(X_train_vectorized, y_train, epochs=3, batch_size=1024, verbose=0 )<predict_on_test> | GB = GradientBoostingClassifier(random_state=42)
get_model_accuracy(GB ) | Titanic - Machine Learning from Disaster |
13,420,831 | predictions = model.predict(X_test_vectorized )<data_type_conversions> | voting_clf_all = VotingClassifier(
estimators=[('GNB', GNB),('LR', LR),('SVC', SVC),('KNN', KNN),('RFC', RFC),('GB', GB)],
voting='soft')
get_model_accuracy(voting_clf_all ) | Titanic - Machine Learning from Disaster |
13,420,831 | preds_class =(predictions > 0.33 ).astype(np.int )<define_variables> | voting_clf_best_3 = VotingClassifier(
estimators=[('SVC', SVC),('RFC', RFC),('KNN', KNN)],
voting='soft')
get_model_accuracy(voting_clf_best_3 ) | Titanic - Machine Learning from Disaster |
13,420,831 | qid = df_test['qid']<concatenate> | def clf_performance(classifier):
print(classifier.__class__.__name__)
print(f"Best Score: {classifier.best_score_}")
print(f"Best Parameters: {classifier.best_params_}" ) | Titanic - Machine Learning from Disaster |
13,420,831 | submission_df = pd.concat([qid, prediction], axis=1 )<save_to_csv> | param_grid = {
'random_state': [42],
'max_iter': [100, 500, 2000],
'penalty': ['l1', 'l2'],
'C': np.logspace(-4, 4, 20),
'solver': ['liblinear', 'lbfgs']
}
clf_LR = GridSearchCV(LR, param_grid=param_grid, cv=5, verbose=True, n_jobs=-1)
best_clf_LR = clf_LR.fit(X_train_scaled, y_train)
clf_performance(best_clf_LR ) | Titanic - Machine Learning from Disaster |
13,420,831 | submission_df.to_csv("submission.csv", columns = submission_df.columns, index=False )<import_modules> | print_valid_params("'C': 11.288378916846883, 'max_iter': 100, 'penalty': 'l1', 'random_state': 42, 'solver': 'liblinear'" ) | 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.