kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
7,770,899 | sub = df1
sub['reactivity'] =(df1.reactivity.values + df2.reactivity.values + df3.reactivity.values)/3
sub['deg_Mg_pH10'] =(df1.deg_Mg_pH10.values + df2.deg_Mg_pH10.values + df3.deg_Mg_pH10.values)/3
sub['deg_pH10'] =(df1.deg_pH10.values + df2.deg_pH10.values + df3.deg_pH10.values)/3
sub['deg_Mg_50C'] =(df1.deg_Mg_50C.... | list(zip(X_train.columns, rfe.support_, rfe.ranking_)) | Titanic - Machine Learning from Disaster |
7,770,899 | sub.to_csv('submission.csv', index = False )<set_options> | import statsmodels.api as sm | Titanic - Machine Learning from Disaster |
7,770,899 | warnings.filterwarnings('ignore')
<load_from_csv> | X_train_sm = sm.add_constant(X_train[col])
logm1 = sm.GLM(y_train,X_train_sm, family = sm.families.Binomial())
res = logm1.fit()
res.summary() | Titanic - Machine Learning from Disaster |
7,770,899 | FOLDS = 5
EPOCHS = 130
BATCH_SIZE = 64
LR = 0.001
VERBOSE = 2
SEED = 123
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
tf.random.set_seed(seed)
seed_everything(SEED)
train = pd.read_json('.. /input/stanford-covid-vaccine/train.json', lines = True)
test ... | y_train_pred = res.predict(X_train_sm)
y_train_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | def CMCRMSE(y_true, y_pred):
colwise_mse = tf.reduce_mean(tf.square(y_true - y_pred), axis=1)
return tf.reduce_mean(tf.sqrt(colwise_mse), axis=1)
def build_model(seq_len = 107, pred_len = 68, embed_dim = 85, dropout = 0.10):
def wave_block(x, filters, kernel_size, n):
dilation_rates = [2 ** i for i in range(n)]
x = t... | y_train_pred = y_train_pred.values.reshape(-1)
y_train_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | public_preds, private_preds = train_and_evaluate(train_inputs, train_labels, public_test, private_test )<prepare_output> | y_train_pred_final = pd.DataFrame({'Survived':y_train.values, 'Survived_Prob':y_train_pred})
y_train_pred_final['PassengerId'] = y_train.index
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | def inference_format(public_test_df, public_preds, private_test_df, private_preds, target_cols):
predictions = []
for test, preds in [(public_test_df, public_preds),(private_test_df, private_preds)]:
for index, uid in enumerate(test['id']):
single_pred = preds[index]
single_df = pd.DataFrame(single_pred, columns = targ... | y_train_pred_final['predicted'] = y_train_pred_final.Survived_Prob.map(lambda x: 1 if x > 0.5 else 0)
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | !pip install /kaggle/input/timm-package/timm-0.1.26-py3-none-any.whl
PKGPATH='.. /input/kprostate111/prostatev111'
sys.path.append(PKGPATH)
os.environ['KMP_DUPLICATE_LIB_OK']='True'
warnings.filterwarnings("ignore" )<import_modules> | from sklearn import metrics | Titanic - Machine Learning from Disaster |
7,770,899 | from utils.imageutils import rotatecrop, pairrot, cropcoords, noisecrop, Mish
from utils.imageutils import padsplit, padimg, pixctr, cropper, condenseImgls
from utils.imageutils import padsplitv2, chunk_squaresv2, condenseImglsv2, cropperv2
from utils.imageutils import chunk_squares, frame_combine, balancedSampler
from... | confusion = metrics.confusion_matrix(y_train_pred_final.Survived, y_train_pred_final.predicted)
print(confusion ) | Titanic - Machine Learning from Disaster |
7,770,899 | logger = get_logger('Sequence model :', 'INFO')
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
try:
logger.info('Device : {}'.format(torch.cuda.get_device_name(0)))
except:
logger.info('Device : Not available')
logger.info('Cuda available : {}'.format(torch.cuda.is_available()))
n_gpu = torch.c... | print(metrics.accuracy_score(y_train_pred_final.Survived, y_train_pred_final.predicted)) | Titanic - Machine Learning from Disaster |
7,770,899 | NPIXELS=20*10**6
NSAMP=300
DATATYPE = 'test'
INPATH = '.. /input/prostate-cancer-grade-assessment'
SAMPLE = f'{INPATH}/sample_submission.csv'
DATA = f'{INPATH}/{DATATYPE}_images'
subdf = pd.read_csv(f'{INPATH}/sample_submission.csv')
tstdf = pd.read_csv(f'{INPATH}/{DATATYPE}.csv')
if DATATYPE=='train':
folds= pd.read... | from statsmodels.stats.outliers_influence import variance_inflation_factor | Titanic - Machine Learning from Disaster |
7,770,899 | class options:
max_len = 36
tilesize = 224
data_path = f'{DATATYPE}_images'
bsize = 2<categorify> | vif = pd.DataFrame()
vif['Features'] = X_train[col].columns
vif['VIF'] = [variance_inflation_factor(X_train[col].values, i)for i in range(X_train[col].shape[1])]
vif['VIF'] = round(vif['VIF'], 2)
vif = vif.sort_values(by = "VIF", ascending = False)
vif | Titanic - Machine Learning from Disaster |
7,770,899 | def cropload(imname, thresh = 255):
img = MultiImage(imname)[1]
krows = np.where(np.min(img, 0)< 255)[0]
kcols = np.where(np.min(img, 1)< 255)[0]
img = img[kcols[0]: kcols[-1] + 1, krows[0]: krows[-1] + 1]
return img
val_transforms = A.Compose([
A.RandomCrop(224*6, 224*6, always_apply=True, p=1),
A.NoOp() ,
])
def get... | col = col.drop(['Parch','SibSp','FamilySize', 'Embarked_S', 'Embarked_Q'], 1)
col | Titanic - Machine Learning from Disaster |
7,770,899 | trndataargs = {'path': INPATH}
tstdataset = ProstateDataset(tstdf, modtype=DATATYPE, transform = val_transforms, **trndataargs )<data_type_conversions> | X_train_sm = sm.add_constant(X_train[col])
logm2 = sm.GLM(y_train,X_train_sm, family = sm.families.Binomial())
res = logm2.fit()
res.summary() | Titanic - Machine Learning from Disaster |
7,770,899 |
<load_pretrained> | y_train_pred = res.predict(X_train_sm)
y_train_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | loaderls = []
trnloaderargs = {'num_workers' : 4, 'collate_fn' : collatefn}
tstloader = DataLoader(tstdataset, shuffle=False, batch_size=options.bsize, **trnloaderargs )<choose_model_class> | y_train_pred = y_train_pred.values.reshape(-1)
y_train_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | class SeqNet(nn.Module):
def __init__(self, architecture = 'mixnet_m', pretrained=True, \
dense_units = 256, dropout = 0.2, isuplabels = 5, \
nblocks=4, concatfinal = 1,
glabels = 4):
super(SeqNet, self ).__init__()
logger.info('Architecture {} dense {} dropout {}'.format(\
architecture, dense_units, dropout))
self.arc... | y_train_pred_final = pd.DataFrame({'Survived':y_train.values, 'Survived_Prob':y_train_pred})
y_train_pred_final['PassengerId'] = y_train.index
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | models = []
for cpt_path in sorted(glob.glob('.. /input/mnetlv33/*')) :
logger.info(f'Load {cpt_path}')
models.append(SeqNet(architecture = 'tf_efficientnet_b0_ns', pretrained=False, nblocks=4, concatfinal = 1,\
dense_units = 256, dropout = 0.0, isuplabels = 5, glabels = 4))
cpt = torch.load(cpt_path, map_location=tor... | y_train_pred_final['predicted'] = y_train_pred_final.Survived_Prob.map(lambda x: 1 if x > 0.5 else 0)
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | ttafns = [
lambda x: x,
lambda x: x.flip(-1),
lambda x: x.flip(-2),
lambda x: x.flip(-1, -2),
lambda x: x.transpose(-1, -2),
lambda x: x.transpose(-1, -2 ).flip(-1),
lambda x: x.transpose(-1, -2 ).flip(-2),
lambda x: x.transpose(-1, -2 ).flip(-1, -2),
]
iters = 4
modlens = len(models)
if os.path.exists(f'{INPATH}/{DAT... | confusion = metrics.confusion_matrix(y_train_pred_final.Survived, y_train_pred_final.predicted)
print(confusion ) | Titanic - Machine Learning from Disaster |
7,770,899 | subdf = tstloader.df[['image_id']]
subdf['isup_grade'] =(sum(predsls)/len(predsls)).round().astype(np.int32 )<save_to_csv> | print(metrics.accuracy_score(y_train_pred_final.Survived, y_train_pred_final.predicted)) | Titanic - Machine Learning from Disaster |
7,770,899 | subdf.to_csv("submission.csv", index=False)
subdf.head(20 )<count_values> | from statsmodels.stats.outliers_influence import variance_inflation_factor | Titanic - Machine Learning from Disaster |
7,770,899 | if DATATYPE=='train':
logger.info(( subdf.isup_grade == tstloader.df.isup_grade ).value_counts() )<set_options> | vif = pd.DataFrame()
vif['Features'] = X_train[col].columns
vif['VIF'] = [variance_inflation_factor(X_train[col].values, i)for i in range(X_train[col].shape[1])]
vif['VIF'] = round(vif['VIF'], 2)
vif = vif.sort_values(by = "VIF", ascending = False)
vif | Titanic - Machine Learning from Disaster |
7,770,899 | if DATATYPE=='train':
logger.info(qwk5(subdf.isup_grade, tstloader.df.isup_grade))<import_modules> | fpr, tpr, thresholds = metrics.roc_curve(y_train_pred_final.Survived, y_train_pred_final.Survived_Prob, drop_intermediate = False ) | Titanic - Machine Learning from Disaster |
7,770,899 | from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import tensorflow as tf
from sklearn.model_selection import train_test_split<load_pretrained> | numbers = [float(x)/10 for x in range(10)]
for i in numbers:
y_train_pred_final[i]= y_train_pred_final.Survived_Prob.map(lambda x: 1 if x > i else 0)
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | zip_ref = zipfile.ZipFile('/kaggle/input/quora-insincere-questions-classification/embeddings.zip', 'r')
print(zip_ref.namelist())
embeddings = zip_ref.open('glove.840B.300d/glove.840B.300d.txt', 'r' )<compute_test_metric> | cutoff_df = pd.DataFrame(columns = ['prob','accuracy','sensi','speci'])
num = [0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
for i in num:
cm1 = metrics.confusion_matrix(y_train_pred_final.Survived, y_train_pred_final[i])
total1=sum(sum(cm1))
accuracy =(cm1[0,0]+cm1[1,1])/total1
speci = cm1[0,0]/(cm1[0,0]+cm1[0,1])
sensi... | Titanic - Machine Learning from Disaster |
7,770,899 | def get_coefs(word,*arr):
return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.decode().split(" ")) for o in embeddings )<load_from_csv> | y_train_pred_final['final_predicted'] = y_train_pred_final.Survived_Prob.map(lambda x: 1 if x > 0.56 else 0)
y_train_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | train_data = pd.read_csv('/kaggle/input/quora-insincere-questions-classification/train.csv')
test_data = pd.read_csv('/kaggle/input/quora-insincere-questions-classification/test.csv')
print('训练集维度：
',train_data.shape)
print('测试集维度：
',test_data.shape)
train_data.sample(5 )<define_variables> | metrics.accuracy_score(y_train_pred_final.Survived, y_train_pred_final.final_predicted ) | Titanic - Machine Learning from Disaster |
7,770,899 | train_input = list(train_data['question_text'])
train_label = list(train_data['target'])
test_input = list(test_data['question_text'] )<string_transform> | confusion2 = metrics.confusion_matrix(y_train_pred_final.Survived, y_train_pred_final.final_predicted)
confusion2 | Titanic - Machine Learning from Disaster |
7,770,899 | stop=stopwords.words('english')
def remove_stop_words(x):
for word in stop:
token = " " + word + " "
if(x.find(token)!= -1):
x = x.replace(token, " ")
return x
train_input_rsw = list(map(remove_stop_words, train_input))
test_input_rsw = list(map(remove_stop_words, test_input))<define_variables> | X_test_sm = sm.add_constant(X_test ) | Titanic - Machine Learning from Disaster |
7,770,899 | max_features=100000
embed_size = 300
max_length = 60<string_transform> | y_test_pred = res.predict(X_test_sm)
y_test_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | tokenizer=Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(train_input_rsw)
word_index = tokenizer.word_index
n_words=min(max_features,len(word_index))
embedding_matrix = np.zeros(( n_words+1, 300))
for word, i in word_index.items() :
if i >= max_features:
continue
embedding_vector = embeddings_index.get(word... | y_pred_1 = pd.DataFrame(y_test_pred)
y_pred_1.head() | Titanic - Machine Learning from Disaster |
7,770,899 | sequences = tokenizer.texts_to_sequences(train_input_rsw)
train_input_padded = pad_sequences(sequences, maxlen=max_length, padding='post', truncating='post')
print(train_input_padded.shape)
sequences = tokenizer.texts_to_sequences(test_input_rsw)
test_input_padded = pad_sequences(sequences, maxlen=max_length, paddi... | y_test_df = pd.DataFrame(y_test)
y_test_df['PassengerId'] = y_test_df.index
y_pred_1.reset_index(drop=True, inplace=True)
y_test_df.reset_index(drop=True, inplace=True)
y_pred_final = pd.concat([y_test_df, y_pred_1],axis=1)
y_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | train_text, cv_text, train_target, cv_target = train_test_split(train_input_padded, train_label, test_size = 0.1, random_state=2 )<import_modules> | y_pred_final= y_pred_final.rename(columns={ 0 : 'Survived_Prob'})
y_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | from keras.models import Sequential
from keras.layers import Embedding,Bidirectional,LSTM,Dropout,Conv1D,MaxPooling1D,Dense<choose_model_class> | y_pred_final['final_predicted'] = y_pred_final.Survived_Prob.map(lambda x: 1 if x > 0.47 else 0)
y_pred_final.head() | Titanic - Machine Learning from Disaster |
7,770,899 | lstm=Sequential()
lstm.add(Embedding(n_words+1,300,input_length=max_length,weights=[embedding_matrix], trainable=False))
lstm.add(Bidirectional(LSTM(256,return_sequences=True)))
lstm.add(Dropout(0.2))
lstm.add(Conv1D(100,5,activation='relu'))
lstm.add(MaxPooling1D(pool_size=4))
lstm.add(LSTM(128))
lstm.add(Dropout(0.4... | metrics.accuracy_score(y_pred_final.Survived, y_pred_final.final_predicted ) | Titanic - Machine Learning from Disaster |
7,770,899 | del embeddings_index
gc.collect()<train_model> | data_val_Id = data_val['PassengerId']
data_val = data_val[col]
data_val.head() | Titanic - Machine Learning from Disaster |
7,770,899 | history=lstm.fit(np.array(train_text), np.array(train_target), epochs = 5, validation_data=(np.array(cv_text),np.array(cv_target)) , batch_size=1024,verbose=1 )<find_best_params> | data_val_sm = sm.add_constant(data_val)
y_val_pred = res.predict(data_val_sm)
y_val_pred[:10] | Titanic - Machine Learning from Disaster |
7,770,899 | cv_predictions = lstm.predict(cv_text, batch_size=512)
thresholds = []
for thresh in np.arange(0.1, 0.501, 0.01):
thresh = np.round(thresh, 2)
result = f1_score(cv_target,(cv_predictions>thresh ).astype(int))
thresholds.append([thresh, result])
print("F1 score at threshold {} is {}".format(thresh, result))
threshold... | y_val_1 = pd.DataFrame(y_val_pred)
y_val_1.head() | Titanic - Machine Learning from Disaster |
7,770,899 | predictions = lstm.predict(cv_text)
predictions = np.around(predictions ).astype(int)
df = pd.DataFrame({'pred': predictions.flatten() , 'actual': cv_target})
df.head()
pd.crosstab(df['pred'], df['actual'], margins=True )<predict_on_test> | y_val_1= y_val_1.rename(columns={ 0 : 'Survived_Prob'})
y_val_1['PassengerId'] = data_val_Id
y_val_1['final_predicted'] = y_val_1.Survived_Prob.map(lambda x: 1 if x > 0.57 else 0)
y_val_1.head() | Titanic - Machine Learning from Disaster |
7,770,899 | predictions = lstm.predict(test_input_padded )<data_type_conversions> | output = pd.DataFrame({'PassengerId': y_val_1.PassengerId, 'Survived': y_val_1.final_predicted})
output.to_csv('my_submission_GLM.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
6,107,155 | predictions1 =(predictions>best_thresh ).astype(int )<save_to_csv> | a = pd.read_csv("/kaggle/input/titanic/train.csv")
b = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
6,107,155 | predictions =(predictions>best_thresh ).astype(int)
submission = pd.DataFrame({'qid': test_data.qid, 'prediction': predictions1[:,0]})
submission.to_csv('submission.csv', index=False )<import_modules> | na = a.shape[0]
nb = b.shape[0]
frames= [a,b]
c1=pd.concat(frames, axis=0, sort=False ).reset_index(drop=True)
target = a[['Survived']]
c1.drop(['Survived'], axis=1, inplace=True)
print("The shape of the training set is", na)
print("Total size is :",c1.shape ) | Titanic - Machine Learning from Disaster |
6,107,155 | import re
import time
import gc
import random
import os
import numpy as np
import pandas as pd
from tqdm import tqdm
from tabulate import tabulate
from sklearn.model_selection import train_test_split
from sklearn import metrics, preprocessing
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklear... | print(c1.isnull().sum() ) | Titanic - Machine Learning from Disaster |
6,107,155 | if not os.path.exists('./embeddings'):
os.mkdir('./embeddings')
os.mkdir('./embeddings/glove.840B.300d/')
os.mkdir('./embeddings/paragram_300_sl999/')
with zipfile.ZipFile('.. /input/quora-insincere-questions-classification/embeddings.zip', 'r')as z:
with z.open('glove.840B.300d/glove.840B.300d.txt')as zf, open('./e... | Survived=a['Survived'].value_counts()
Survived=pd.DataFrame(Survived)
Survived=Survived.reset_index()
pclass= a['Pclass'].value_counts()
pclass= pd.DataFrame(pclass)
pclass= pclass.reset_index()
sex= a['Sex'].value_counts()
sex= pd.DataFrame(sex)
sex= sex.reset_index()
embarked=a['Embarked'].value_counts()
embarked=... | Titanic - Machine Learning from Disaster |
6,107,155 | embed_size = 300
meta_size = 3
max_features = 30000
maxlen = 72
batch_size = 1000
train_epochs = 4
SEED = 1029
def seed_torch(seed=1029):
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<de... | c1['family_size']=c1['SibSp'] + c1['Parch'] + 1 | Titanic - Machine Learning from Disaster |
6,107,155 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | c1.isnull().sum() | Titanic - Machine Learning from Disaster |
6,107,155 | def load_and_prec() :
train_df = pd.read_csv(".. /input/quora-insincere-questions-classification/train.csv")
test_df = pd.read_csv(".. /input/quora-insincere-questions-classification/test.csv")
train_df["question_text"] = train_df["question_text"].progress_apply(lambda x: clean_and_lower_text(x))
test_df["question_te... | c=c1.drop('Cabin', axis=1 ) | Titanic - Machine Learning from Disaster |
6,107,155 | tqdm.pandas()
if not os.path.exists('./train_X.npy'):
start_time = time.time()
train_X, test_X, train_y, word_index, meta_train_X, meta_test_X = load_and_prec()
total_time =(time.time() - start_time)/ 60
print("Took {:.2f} minutes".format(total_time))
else :
train_X = np.load('./train_X.npy', allow_pickle=True)
test... | c['Age'].fillna(28, inplace=True ) | Titanic - Machine Learning from Disaster |
6,107,155 | def load_embedding(word_index, EMBEDDING_FILE):
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
if(EMBEDDING_FILE=='./embeddings/paragram_300_sl999/paragram_300_sl999.txt'):
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE, encoding="utf8", errors='ignore')if len(o)... | c['Embarked'].fillna(method='ffill', inplace=True ) | Titanic - Machine Learning from Disaster |
6,107,155 | if not os.path.exists('./embedding_matrix.npy'):
start_time = time.time()
embedding_glove = load_embedding(word_index, './embeddings/glove.840B.300d/glove.840B.300d.txt')
embedding_paragram = load_embedding(word_index, './embeddings/paragram_300_sl999/paragram_300_sl999.txt')
embedding_matrix = np.mean([embedding_glo... | c['Fare'].fillna(method='ffill', inplace=True ) | Titanic - Machine Learning from Disaster |
6,107,155 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | print(c.isnull().sum() ) | Titanic - Machine Learning from Disaster |
6,107,155 | class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self ).__init__()
hidden_size = 60
self.embedding = nn.Embedding(np.shape(embedding_matrix)[0], embed_size, padding_idx=0)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32))
self.embedding.weight.requires_grad = Fal... | c2=c[['Pclass','Sex','Age','Embarked','family_size','Parch','SibSp', 'Fare']]
c2['Pclass']=c2['Pclass'].astype(object ) | Titanic - Machine Learning from Disaster |
6,107,155 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<compute_test_metric> | c3=pd.get_dummies(c2)
print("the shape of the original dataset",c2.shape)
print("the shape of the encoded dataset",c3.shape)
print("We have ",c3.shape[1]- c2.shape[1], 'new encoded features' ) | Titanic - Machine Learning from Disaster |
6,107,155 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
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... | Train = c3[:na]
Test = c3[na:] | Titanic - Machine Learning from Disaster |
6,107,155 | splits = list(StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED ).split(train_X, train_y))
train_preds = np.zeros(( len(train_X)))
test_preds = np.zeros(( len(test_X)))
seed_torch(SEED)
x_test_cuda = torch.tensor(test_X, dtype=torch.long ).cuda()
x_meta_test_cuda = torch.tensor(meta_test_X, dtype=torch.lon... | s=a[['Pclass','Fare','Survived']]
s.sort_values(by='Fare', ascending=False ).head(10 ) | Titanic - Machine Learning from Disaster |
6,107,155 | search_result = threshold_search(train_y, train_preds)
search_result<save_to_csv> | Train1=Train[Train['Fare'] < 200] | Titanic - Machine Learning from Disaster |
6,107,155 | sub = pd.read_csv('.. /input/quora-insincere-questions-classification/sample_submission.csv')
sub.prediction = test_preds > search_result['threshold']
sub['prediction'] = sub['prediction'].apply(lambda x : int(x))
sub.to_csv("submission.csv", index=False )<set_options> | print('We dropped ',Train.shape[0] - Train1.shape[0],'fare outliers' ) | Titanic - Machine Learning from Disaster |
6,107,155 | warnings.filterwarnings('ignore' )<load_from_csv> | Train1['SibSp'].sort_values(ascending=False ).head(7 ) | Titanic - Machine Learning from Disaster |
6,107,155 | quora_train = pd.read_csv("/kaggle/input/quora-insincere-questions-classification/train.csv")
quora_test = pd.read_csv("/kaggle/input/quora-insincere-questions-classification/test.csv")
quora_train.head(1 )<create_dataframe> | train=Train1[Train1['SibSp'] <= 5] | Titanic - Machine Learning from Disaster |
6,107,155 | paragramModel = Embeddings(file_path,file="paragram" )<categorify> | print('We dropped ', Train1.shape[0]- train.shape[0], 'sibSp outliers')
print('And in total, we dropped ', Train.shape[0]-train.shape[0], 'outliers' ) | Titanic - Machine Learning from Disaster |
6,107,155 | def str_lowercase_text(text):
text = text.map(str)
for line in range(len(text.values)) :
text.values[line] = text.values[line].lower()
return text
quora_train['question_text_paragram'] = str_lowercase_text(quora_train['question_text'])
quora_test['question_text_paragram'] = str_lowercase_text(quora_test['question_tex... | x=train
y=np.array(target ) | Titanic - Machine Learning from Disaster |
6,107,155 | import tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras.backend import clear_session, maximum
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.k... | x_train, x_test, y_train, y_test = train_test_split(x, y,test_size =.33, random_state=0 ) | Titanic - Machine Learning from Disaster |
6,107,155 | y = quora_train['target']
X = quora_train.drop(columns = ['target'])
X_train, X_cv, y_train, y_cv = train_test_split(X, y, test_size=0.20, stratify=y)
print("The shape of train,cv & test dataset before conversion into vector")
print(X_train.shape, y_train.shape)
print(X_cv.shape, y_cv.shape)
print(quora_test.shape... | scaler= StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
test = scaler.transform(Test ) | Titanic - Machine Learning from Disaster |
6,107,155 | maxlength = 75
embedding_dim = 300<categorify> | from sklearn.model_selection import GridSearchCV
from sklearn.metrics import roc_curve, auc
from sklearn.metrics import classification_report
| Titanic - Machine Learning from Disaster |
6,107,155 | def TokenizationPadding(data, maxlen):
encoder_data = list()
tokens = Tokenizer()
tokens.fit_on_texts(data[0])
for idx,val in enumerate(data):
encoder_data.append(tokens.texts_to_sequences(val))
vocab_size = len(tokens.word_index)+1
seq_padding = list()
for val in encoder_data:
seq_padding.append(pad_sequences(val, ma... | lr_c=LogisticRegression(C=1, class_weight={0:0.62, 1:0.38}, max_iter=5000,
penalty='l2',
random_state=None, solver='lbfgs', verbose=0,
warm_start=True)
lr_c.fit(x_train,y_train.ravel())
lr_pred=lr_c.predict(x_test)
lr_ac=accuracy_score(y_test.ravel() , lr_pred)
print('LogisticRegression_accuracy test:',lr_ac)
prin... | Titanic - Machine Learning from Disaster |
6,107,155 | data = [X_train["question_text_paragram"], X_cv["question_text_paragram"], quora_test["question_text_paragram"]]<statistical_test> | cv = StratifiedShuffleSplit(n_splits = 15, test_size =.25, random_state = 0)
x = scaler.fit_transform(x)
accuracies = cross_val_score(LogisticRegression(solver='liblinear',class_weight={0:0.62, 1:0.38}), x,y, cv = cv)
print("CV accuracy on 15 chunks: {}".format(accuracies))
print("Mean CV accuracy: {}".format(round(... | Titanic - Machine Learning from Disaster |
6,107,155 | seq_padding, vocab_size, tokenizer = TokenizationPadding(data, maxlength)
Xtrain, Xcv, Xtest = seq_padding[0], seq_padding[1], seq_padding[2]<categorify> | svm=SVC(kernel='rbf',C=10,gamma=0.1)
svm.fit(x_train,y_train.ravel())
svm_pred=svm.predict(x_test)
print('Accuracy is ',metrics.accuracy_score(svm_pred,y_test.ravel()))
print('AUC: ',roc_auc_score(y_test.ravel() , svm_pred)) | Titanic - Machine Learning from Disaster |
6,107,155 | def embedding_matrix(vocab_size,model,dim,tokenizer):
keys = set(model.keys())
emb_matrix = np.zeros(( vocab_size,dim))
for idx,val in tokenizer.word_index.items() :
if idx in keys:
emb_vector = model[idx]
emb_matrix[val] = emb_vector
print('The shape of emdedding matrix is: ',emb_matrix.shape)
return emb_matrix<load... | SVMC = SVC(probability=True,class_weight={0:0.62, 1:0.38})
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001,0.008, 0.01,0.02,0.05, 0.1, 1],
'C': [1, 10, 12, 14, 20, 25, 30, 40,50,60, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=5, scoring="accuracy", n_jobs=-1)
gsSVMC.fit(x_trai... | Titanic - Machine Learning from Disaster |
6,107,155 | embedding_matrix_paragram = embedding_matrix(vocab_size, paragramModel, embedding_dim, tokenizer )<categorify> | rdf_c=RandomForestClassifier(n_estimators=100,criterion='entropy',random_state=0)
rdf_c.fit(x_train,y_train.ravel())
rdf_pred=rdf_c.predict(x_test)
rdf_ac=accuracy_score(rdf_pred,y_test.ravel())
print('Accuracy of random forrest classifier: ',rdf_ac)
print('AUC: ',roc_auc_score(y_test.ravel() , rdf_pred)) | Titanic - Machine Learning from Disaster |
6,107,155 | ytrain = to_categorical(y_train, 2)
ycv = to_categorical(y_cv, 2 )<prepare_x_and_y> | knn_clf = KNeighborsClassifier()
parameters_knn = {"n_neighbors": [3, 5, 10, 15], "weights": ["uniform", "distance"], "algorithm": ["auto", "ball_tree", "kd_tree"],
"leaf_size": [20, 30, 50]}
grid_knn = GridSearchCV(knn_clf, parameters_knn, scoring='accuracy', cv=5, n_jobs=-1)
grid_knn.fit(x_train, y_train)
knn_clf =... | Titanic - Machine Learning from Disaster |
6,107,155 | class accuracy_value(Callback):
def __init__(self,training_data,validation_data):
self.X_train = training_data[0]
self.y_train = training_data[1]
self.X_val = validation_data[0]
self.y_val = validation_data[1]
def on_train_begin(self, logs = {}):
self.f1_scores = []
self.precisions = []
self.recalls = []
def on_epoch_e... | xg_clf = XGBClassifier()
parameters_xg = {"objective" : ["reg:linear"], "n_estimators" : [5, 10, 15, 20]}
grid_xg = GridSearchCV(xg_clf, parameters_xg, scoring='accuracy',cv=5,n_jobs=-1)
grid_xg.fit(x_train, y_train)
xg_clf = grid_xg.best_estimator_
xg_clf.fit(x_train, y_train.ravel())
pred_xg = xg_clf.predict(x_tes... | Titanic - Machine Learning from Disaster |
6,107,155 | earlyStopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto' )<choose_model_class> | nr.seed(1115)
nn_mod = MLPClassifier(hidden_layer_sizes =(100,100,), max_iter=1750, solver='sgd')
nn_mod.fit(x_train, y_train.ravel())
scores = nn_mod.predict(x_test)
nnacc = accuracy_score(y_test.ravel() , scores)
print('The accuracy of MLP classifier: ',nnacc)
print('AUC: ',roc_auc_score(y_test.ravel() , scores... | Titanic - Machine Learning from Disaster |
6,107,155 | class Attention(tf.keras.layers.Layer):
def __init__(self, att_units):
super(Attention, self ).__init__()
self.att_units = att_units
self.W1=tf.keras.layers.Dense(att_units)
self.W2=tf.keras.layers.Dense(att_units)
self.V=tf.keras.layers.Dense(1)
def call(self,lstm_output, hidden_state):
state_with_time_axis = t... | Bagg_estimators = [10,25,50,75,100,150,250];
cv = StratifiedShuffleSplit(n_splits=10, test_size=.33, random_state=15)
parameters = {'n_estimators':Bagg_estimators }
gridBG = GridSearchCV(BaggingClassifier(base_estimator= None,
bootstrap_features=False),
param_grid=parameters,
cv=cv,
n_jobs = -1)
bg_mod=gridBG.fit(x_t... | Titanic - Machine Learning from Disaster |
6,107,155 | clear_session()
inputs = Input(shape=(maxlength,), dtype='int32', name='Input_Text')
Embedding_Layer = Embedding(vocab_size, 300, weights=[embedding_matrix_paragram], input_length=maxlength, trainable=False )(inputs)
lstm_output, fw_state_h, fw_state_c, bw_state_h, bw_state_c = Bidirectional(LSTM(64, return_sequences... | n_estimators = [100,140,145,150,160, 170,175,180,185];
cv = StratifiedShuffleSplit(n_splits=10, test_size=.30, random_state=15)
learning_rate = [0.1,1,0.01,0.5]
parameters = {'n_estimators':n_estimators,
'learning_rate':learning_rate}
gridAda = GridSearchCV(AdaBoostClassifier(base_estimator= None,
),
param_grid=param... | Titanic - Machine Learning from Disaster |
6,107,155 | threshold = dict()
ypred = model.predict(Xcv, batch_size=512,verbose=1)
for thresh in np.arange(0.1, 0.501, 0.05):
thresh = np.round(thresh, 2)
print("F1 score at threshold {0} is {1}".format(thresh, round(list(metrics.f1_score(ycv,(ypred>thresh ).astype(int), average=None)) [1],3)))
threshold[thresh] = round(list(m... | gradient_boost = GradientBoostingClassifier()
gradient_boost.fit(x_train, y_train.ravel())
ygbc_pred = gradient_boost.predict(x_test)
gradient_accy = round(accuracy_score(ygbc_pred, y_test.ravel()), 3)
print('Gradient Boosting accuracy: ',gradient_accy)
print('AUC: ',roc_auc_score(y_test.ravel() , ygbc_pred))
| Titanic - Machine Learning from Disaster |
6,107,155 | ypredict = list()
ypred = model.predict(Xtest, batch_size=512,verbose=1)
for i in ypred:
ypredict.append(( i[1]>max(threshold, key=threshold.get)).astype(int))
df_test = pd.DataFrame({"qid":quora_test["qid"].values})
df_test['prediction'] = ypredict
print("Quora Test Output:
",df_test['prediction'].value_counts() )<s... | ExtraTreesClassifier = ExtraTreesClassifier()
ExtraTreesClassifier.fit(x_train, y_train.ravel())
y_pred = ExtraTreesClassifier.predict(x_test)
extraTree_accy = accuracy_score(y_pred, y_test.ravel())
print('ExtraTrees classifier accuracy: ',extraTree_accy)
print('AUC: ',roc_auc_score(y_test.ravel() , y_pred)) | Titanic - Machine Learning from Disaster |
6,107,155 | df_test.to_csv('submission.csv', index=False )<import_modules> | GaussianProcessClassifier = GaussianProcessClassifier()
GaussianProcessClassifier.fit(x_train, y_train.ravel())
yg_pred = GaussianProcessClassifier.predict(x_test)
gau_pro_accy = accuracy_score(yg_pred, y_test.ravel())
print('Gaussian process classifier: ', gau_pro_accy)
print('AUC: ',roc_auc_score(y_test.ravel() ,... | Titanic - Machine Learning from Disaster |
6,107,155 | import math
from sklearn.model_selection import train_test_split
from sklearn import metrics
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.layers import Dense, Input, Embedding, Dropout, Activation, Conv1D
from tensorflo... | voting_classifier = VotingClassifier(estimators=[
('gradient_boosting', gradient_boost),
('bagging_classifier', bg_mod),
('ada_classifier',ada_mod),
('XGB_Classifier', xg_clf),
('gaussian_process_classifier', GaussianProcessClassifier)
],voting='hard')
voting_classifier = voting_classifier.fit(x_train,y_train.ra... | Titanic - Machine Learning from Disaster |
6,107,155 | df_train=pd.read_csv('/kaggle/input/quora-insincere-questions-classification/train.csv' )<load_from_csv> | vote_pred = voting_classifier.predict(x_test)
voting_accy = round(accuracy_score(vote_pred, y_test.ravel()), 4)
print('Voting accuracy of the combined classifiers: ',voting_accy)
print('AUC: ',round(roc_auc_score(y_test.ravel() , vote_pred), 4))
| Titanic - Machine Learning from Disaster |
6,107,155 | df_test=pd.read_csv('/kaggle/input/quora-insincere-questions-classification/test.csv' )<import_modules> | print(classification_report(y_test, vote_pred))
| Titanic - Machine Learning from Disaster |
6,107,155 | from zipfile import ZipFile
<load_pretrained> | final_pred = voting_classifier.predict(test ) | Titanic - Machine Learning from Disaster |
6,107,155 | dim=300
embeddings1_index={}
with zipfile.ZipFile(".. /input/quora-insincere-questions-classification/embeddings.zip")as zf:
with io.TextIOWrapper(zf.open("glove.840B.300d/glove.840B.300d.txt"), encoding="utf-8")as f:
for line in tqdm(f):
values=line.split(' ')
word=values[0]
vectors=np.asarray(values[1:],'float32')
... | titanic_submission = pd.DataFrame({
"PassengerId": b["PassengerId"],
"Survived": final_pred
})
titanic_submission.to_csv("titanic.csv", index=False ) | Titanic - Machine Learning from Disaster |
2,062,509 | print('Found %s word vectors.' % len(embeddings1_index))<drop_column> | def load_titanic_data(filename, titanic_path):
csv_path = os.path.join(titanic_path, filename)
return pd.read_csv(csv_path ) | Titanic - Machine Learning from Disaster |
2,062,509 | del zipfile<set_options> | train_data = load_titanic_data('train.csv',".. /input")
test_data = load_titanic_data('test.csv','.. /input' ) | Titanic - Machine Learning from Disaster |
2,062,509 | gc.collect()<feature_engineering> | %matplotlib inline
train_data[['Age','SibSp','Parch','Fare']].hist(figsize=(8,8)) | Titanic - Machine Learning from Disaster |
2,062,509 | def build_vocab(sentences,verbose=True):
vocab={}
for sentence in tqdm(sentences,disable=(not verbose)) :
for word in sentence:
try:
vocab[word] +=1
except:
vocab[word] =1
return vocab<string_transform> | train_data['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
2,062,509 | sentences=df_train['question_text'].progress_apply(lambda x : x.split() ).values
vocab=build_vocab(sentences)
print({k : vocab[k] for k in list(vocab)[:5]} )<sort_values> | train_data['Pclass'].value_counts() | Titanic - Machine Learning from Disaster |
2,062,509 | def check_coverage(vocab, embeddings_index):
oov={}
a={}
i,k=0,0
for word in tqdm(vocab):
try:
a[word]=embeddings_index[word]
k+= vocab[word]
except:
oov[word]=vocab[word]
i+=vocab[word]
pass
print('Found embeddings for {:.2%} of vocab'.format(len(a)/ len(vocab)))
print('Found embeddings for {:.2%} of all text'.format... | train_data['Sex'].value_counts() | Titanic - Machine Learning from Disaster |
2,062,509 | oov = check_coverage(vocab,embeddings1_index )<define_variables> | train_data['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
2,062,509 | contraction_mapping = {"ain't": "is not", "aren't": "are not","can't": "cannot", "'cause": "because", "could've": "could have", "couldn't": "could not", "didn't": "did not", "doesn't": "does not", "don't": "do not", "hadn't": "had not", "hasn't": "has not", "haven't": "have not", "he'd": "he would","he'll": "he will", ... | class DataFrameSelector(BaseEstimator, TransformerMixin):
def __init__(self, attribute_names):
self.attribute_names = attribute_names
def fit(self, X, y=None):
return self
def transform(self, X):
return X[self.attribute_names] | Titanic - Machine Learning from Disaster |
2,062,509 | def clean_contractions(text, mapping):
specials = ["’", "‘", "´", "`"]
for s in specials:
text = text.replace(s, "'")
text = ' '.join([mapping[t] if t in mapping else t for t in text.split(" ")])
return text<feature_engineering> | num_pipeline = Pipeline([
('select_numeric', DataFrameSelector(['Age','SibSp','Parch','Fare'])) ,
('imputer', SimpleImputer(strategy='median'))
] ) | Titanic - Machine Learning from Disaster |
2,062,509 | df_train['question_text']=df_train['question_text'].progress_apply(lambda x: clean_contractions(x,contraction_mapping))
df_test['question_text']=df_test['question_text'].progress_apply(lambda x: clean_contractions(x,contraction_mapping))
sentences= df_train['question_text'].apply(lambda x : x.split())
vocab = build_vo... | num_pipeline.fit_transform(train_data ) | Titanic - Machine Learning from Disaster |
2,062,509 | oov = check_coverage(vocab,embeddings1_index )<drop_column> | class MostFrequentImputer(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
self.most_frequent_ = pd.Series([X[c].value_counts().index[0] for c in X], index=X.columns)
return self
def transform(self, X, y=None):
return X.fillna(self.most_frequent_ ) | Titanic - Machine Learning from Disaster |
2,062,509 | def unknown_punct(embed, punct):
unknown = ''
for p in punct:
if p not in embed:
unknown += p
unknown += ' '
return unknown<define_variables> | from sklearn.preprocessing import OneHotEncoder | Titanic - Machine Learning from Disaster |
2,062,509 | punct_mapping = {"‘": "'", "₹": "e", "´": "'", "°": "", "€": "e", "™": "tm", "√": " sqrt ", "×": "x", "²": "2", "—": "-", "–": "-", "’": "'", "_": "-", "`": "'", '“': '"', '”': '"', '“': '"', "£": "e", '∞': 'infinity', 'θ': 'theta', '÷': '/', 'α': 'alpha', '•': '.', 'à': 'a', '−': '-', 'β': 'beta', '∅': '', '³': '3', '... | cat_pipeline = Pipeline([
('select_cat', DataFrameSelector(['Pclass','Sex','Embarked'])) ,
('imputer', MostFrequentImputer()),
('cat_encoder', OneHotEncoder(sparse=False))
] ) | Titanic - Machine Learning from Disaster |
2,062,509 | def clean_special_chars(text, punct, mapping):
for p in mapping:
text = text.replace(p, mapping[p])
for p in punct:
text = text.replace(p, f' {p} ')
specials = {'\u200b': ' ', '…': '...', '\ufeff': '', 'करना': '', 'है': ''}
for s in specials:
text = text.replace(s, specials[s])
return text<feature_engineering> | cat_pipeline.fit_transform(train_data ) | Titanic - Machine Learning from Disaster |
2,062,509 | df_train['question_text'] = df_train['question_text'].apply(lambda x: clean_special_chars(x, punct, punct_mapping))
df_test['question_text'] = df_test['question_text'].apply(lambda x: clean_special_chars(x, punct, punct_mapping))
sentences= df_train['question_text'].apply(lambda x : x.split())
vocab = build_vocab(sent... | preprocess_pipeline = FeatureUnion(transformer_list=[
('num_pipeline', num_pipeline),
('cat_pipeline', cat_pipeline),
] ) | Titanic - Machine Learning from Disaster |
2,062,509 | oov = check_coverage(vocab,embeddings1_index )<define_variables> | y_train = train_data['Survived'] | Titanic - Machine Learning from Disaster |
2,062,509 | mispell_dict = {'colour': 'color', 'centre': 'center', 'favourite': 'favorite', 'travelling': 'traveling', 'counselling': 'counseling', 'theatre': 'theater', 'cancelled': 'canceled', 'labour': 'labor', 'organisation': 'organization', 'wwii': 'world war 2', 'citicise': 'criticize', 'youtu ': 'youtube ', 'Qoura': 'Quora'... | svm_clf = SVC(gamma='auto')
svm_clf.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
2,062,509 | def correct_spelling(x, dic):
for word in dic.keys() :
x = x.replace(word, dic[word])
return x<feature_engineering> | svm_scores = cross_val_score(svm_clf, X_train, y_train, cv=10)
svm_scores.mean() | 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.