kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,244,686 | def get_coefs(word, *arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.rstrip().rsplit(' ')) for o in open(EMBEDDING_FILE))
word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.zeros(( nb_words, embed_size))
for word, i in word_ind... | rf = RandomForestClassifier(n_estimators=100)
scores = cross_val_score(rf, X_train, Y_train, cv=10, scoring = "accuracy")
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std() ) | Titanic - Machine Learning from Disaster |
6,244,686 | def get_model() :
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = SpatialDropout1D(0.2 )(x)
x = Bidirectional(GRU(units, return_sequences = True))(x)
x = Conv1D(64, kernel_size = 2, padding = "valid", kernel_initializer = "he_uniform" )(x)
avg_pool = Global... | random_forest = RandomForestClassifier(criterion = "gini",
min_samples_leaf = 1,
min_samples_split = 10,
n_estimators=100,
max_features='auto',
oob_score= True,
random_state=1,
n_jobs=-1)
random_forest.fit(X_train, Y_train)
print("oob score:", round(random_forest.score(X_train,Y_train), 4)*100, "%" ) | Titanic - Machine Learning from Disaster |
6,244,686 | BATCH_SIZE = 32
EPOCHS = 2
VALIDATION_SPLIT = 0.1
file_path="weights_base.best.hdf5"
list_classes = ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]
y = train[list_classes].values
checkpoint = ModelCheckpoint(file_path, monitor='val_loss', verbose=1, save_best_only=True,
mode='min')
early = Ea... | predictions = cross_val_predict(random_forest, X_train, Y_train, cv=10)
confusion_matrix(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
6,244,686 | y_pred = model.predict(x_test, batch_size=1024)
submission[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]] = y_pred
submission.to_csv('submission.csv', index=False)
print(submission.values[0] )<define_variables> | print("Precision:", precision_score(Y_train, predictions))
print("Recall:",recall_score(Y_train, predictions)) | Titanic - Machine Learning from Disaster |
6,244,686 |
<set_options> | y_scores = random_forest.predict_proba(X_train)
y_scores = y_scores[:,1] | Titanic - Machine Learning from Disaster |
6,244,686 | start_time = time.time()
np.random.seed(42)
warnings.filterwarnings('ignore')
os.environ['OMP_NUM_THREADS'] = '4'
cores = 4
train1 = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/train.csv')
train = train1
y_train = train[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"... | r_a_score = roc_auc_score(Y_train, y_scores)
print("ROC-AUC-Score:", r_a_score ) | Titanic - Machine Learning from Disaster |
6,244,686 | lemmatizer = WordNetLemmatizer()
def penn_to_wn(tag):
if tag.startswith('J'):
return wn.ADJ
elif tag.startswith('N'):
return wn.NOUN
elif tag.startswith('R'):
return wn.ADV
elif tag.startswith('V'):
return wn.VERB
return None
def clean_text(text):
text = text.replace("<br />", " ")
return text
def swn_polarity(text)... | predictionss=random_forest.predict(X_test ) | Titanic - Machine Learning from Disaster |
6,244,686 | t1 = time.time()
train = sentiment_score(train)
t2 = time.time()
print("Time taken is "+str(t2-t1))
print(train.shape )<normalization> | test_df=pd.read_csv("/kaggle/input/titanic/test.csv")
submission =pd.DataFrame({'PassengerId':test_df.PassengerId,'Survived':predictionss})
submission.head() | Titanic - Machine Learning from Disaster |
6,244,686 | <data_type_conversions><EOS> | submission.to_csv("submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
5,923,489 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
%config InlineBackend.figure_format = 'retina'
plt.style.use('ggplot')
warnings.filterwarnings('ignore')
plt.rc('font', size=18)
plt.rc('axes', titlesize=22)
plt.rc('axes', labelsize=18)
plt.rc('xtick', labelsize=12)
plt.rc('ytick', labelsize=12)
plt.rc('legend', fontsize=12)
plt.rcParams['fo... | Titanic - Machine Learning from Disaster |
5,923,489 | tokenizer = text.Tokenizer(num_words=max_features)
all_text = np.hstack([train['comment_text'].str.lower() ])
tokenizer.fit_on_texts(all_text)
print("Fitting Done...Start text to sequence transform")
train['seq_comment']= tokenizer.texts_to_sequences(train.comment_text.str.lower())
print("Transform done for train ... | df = pd.read_csv(f"{BASE_PATH}train.csv",index_col='PassengerId')
df_test = pd.read_csv(f"{BASE_PATH}test.csv",index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
5,923,489 | x_train, x_valid, y_train, y_valid = train_test_split(train, y_train, train_size=0.95, random_state=233)
print(x_train.shape, x_valid.shape)
print(y_train.shape, y_valid.shape )<normalization> | missing = [(c, df[c].isna().mean() *100)for c in df]
missing = pd.DataFrame(missing, columns=["column_name", "percentage"])
missing = missing[missing.percentage > 0]
display(missing.sort_values("percentage", ascending=False)) | Titanic - Machine Learning from Disaster |
5,923,489 | def get_keras_data(dataset):
X = {
'comment_text' : pad_sequences(dataset.seq_comment, maxlen=maxlen),
'senti_score_scaled': np.array(dataset.senti_score)
}
return X<prepare_x_and_y> | def cabin_location(df):
df['Cabin'].unique()
df['Cabin'].fillna('Unknown',inplace = True)
df['Cabin_Location'] = df['Cabin'].str[0]
df['Cabin_Location'] = np.where(( df.Pclass==1)&(df['Cabin_Location']=='U'),'C',
np.where(( df.Pclass==2)&(df['Cabin_Location']=='U'),'D',
np.where(( df.Pclass==3)&(df['Cabin_Location']==... | Titanic - Machine Learning from Disaster |
5,923,489 | X_train = get_keras_data(x_train)
X_valid = get_keras_data(x_valid )<compute_train_metric> | def is_female(df):
df['is_female']=df['Sex'].apply(lambda x: 1 if x=='female' else 0)
return df
def traveling_party(df):
df['traveling_party']=df['Parch'] + df['SibSp'] + 1
df['is_mother'] = np.where(((df['Sex']=='female')&(df['Parch'] > 0)&(df['Age'] > 30.)),1,0)
df['is_wife'] = np.where(((df['Sex']=='female')&(df['... | Titanic - Machine Learning from Disaster |
5,923,489 | class RocAucEvaluation(Callback):
def __init__(self, validation_data=() , interval=1):
super(Callback, self ).__init__()
self.interval = interval
print(self.interval)
self.X_val, self.y_val = validation_data
print(self.y_val)
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval == 0:
y_pred = self.model.p... | def catboost_encode(df,columns):
df_train = pd.read_csv(f"{BASE_PATH}train.csv",index_col='PassengerId')
df_test = pd.read_csv(f"{BASE_PATH}test.csv",index_col='PassengerId')
df_total = pd.concat([df_train, df_test] ).copy()
df_total = totally_cleaned(df_total)
df_total = feature_engineering(df_total)
cb_enc = ce.C... | Titanic - Machine Learning from Disaster |
5,923,489 | w2v = gensim.models.KeyedVectors.load_word2vec_format('.. /input/googlenews-vectors-negative300/GoogleNews-vectors-negative300.bin', binary=True)
print("Done loading model" )<categorify> | df = pd.read_csv(f"{BASE_PATH}train.csv",index_col='PassengerId')
df_test = pd.read_csv(f"{BASE_PATH}test.csv",index_col='PassengerId')
feat = pd.concat([df, df_test] ).copy() | Titanic - Machine Learning from Disaster |
5,923,489 | vocab_size = len(tokenizer.word_index)+1
EMBEDDING_DIM = 300
embedding_matrix = np.zeros(( vocab_size, EMBEDDING_DIM))
print(embedding_matrix.shape)
c = 0
c1 = 0
w_Y = []
w_No = []
for word, i in tokenizer.word_index.items() :
if word in w2v:
c +=1
embedding_vector = w2v[word]
w_Y.append(word)
else:
embedding_vector ... | df = totally_cleaned(df)
df = feature_engineering(df)
df = catboost_encode(df,['Title','Cabin_Location'])
df = bin_data(df,['Age'],5,False)
df = bin_data(df,['Fare'],10,True)
df = onehot_encode(df,['Embarked'])
df = get_dummy(df,['Ticket_Pre'])
| Titanic - Machine Learning from Disaster |
5,923,489 | del X_train, X_valid, y_valid
gc.collect()<prepare_x_and_y> | df = pd.read_csv(f"{BASE_PATH}train.csv",index_col='PassengerId')
df_test = pd.read_csv(f"{BASE_PATH}test.csv",index_col='PassengerId')
feat = totally_cleaned(feat)
feat = feature_engineering(feat)
feat = catboost_encode(feat,['Title','Cabin_Location'])
feat = bin_data(feat,['Age'],5,False)
feat = bin_data(feat,[... | Titanic - Machine Learning from Disaster |
5,923,489 | y_train = train[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]].values<load_from_csv> | X = dtrain[dtrain['Fare']<300].drop(["Survived"], axis=1)
y = dtrain[dtrain['Fare']<300].Survived
metric = 'accuracy'
rf = RandomForestClassifier()
kfold = KFold(n_splits=10, shuffle=True, random_state=1)
print(f"{cross_val_score(rf, X, y, cv=kfold, scoring=metric ).mean() *100:.4f} % Accuracy")
| Titanic - Machine Learning from Disaster |
5,923,489 | t1 = time.time()
def load_test() :
for df in pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/test.csv', chunksize= 150000):
yield df
print("Yield complete")
test_ids = np.array([], dtype=np.int32)
preds= np.zeros(( 0,6), dtype = np.int32)
print("Start Batch Prediction")
c = 0
for df in load_tes... | metric = 'accuracy'
kfold = KFold(n_splits=10, shuffle=True)
random_state = 1
classifiers = [
GaussianProcessClassifier(random_state = random_state),
Perceptron(random_state = random_state),
RidgeClassifier(random_state = random_state),
SGDClassifier(random_state = random_state),
SVC(random_state = random_state),
Rand... | Titanic - Machine Learning from Disaster |
5,923,489 | submission = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/sample_submission.csv')
submission[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]] = preds
submission.to_csv('submission.csv', index=False)
end_time = time.time()
print("Total time taken is "+str(end_time-star... | ridge = RidgeClassifier()
ridge_pg = {'alpha':[1,10,100],'tol':[0.001,0.0001,0.00001]}
gs_ridge = GridSearchCV(ridge,param_grid = ridge_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gs_ridge.fit(X,y)
ridge_best = gs_ridge.best_estimator_ | Titanic - Machine Learning from Disaster |
5,923,489 | DENSITY_COEFF = 0.1
assert DENSITY_COEFF >= 0.0 and DENSITY_COEFF <= 1.0
OVER_CORR_CUTOFF = 0.98
assert OVER_CORR_CUTOFF >= 0.0 and OVER_CORR_CUTOFF <= 1.0
INPUT_DIR = '.. /input/private-toxic-comment-sumbmissions/'
def load_submissions() :
files = os.listdir(INPUT_DIR)
csv_files = []
for f in files:
if f.endswith(".c... | lrc = LogisticRegression()
lrc_pg = {'penalty':['l1','l2','elasticnet'],'max_iter':[100,500,1000],'warm_start':[True],'tol':[0.001,0.0001,0.00001],'solver':['saga']
,'l1_ratio':[0.5]}
gs_lrc = GridSearchCV(lrc,param_grid = lrc_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gs_lrc.fit(X,y)
lrc_best = gs_lrc... | Titanic - Machine Learning from Disaster |
5,923,489 | os.environ['OMP_NUM_THREADS'] = '4'
print(os.listdir(".. /input"))
<string_transform> | RFC = RandomForestClassifier()
rf_pg = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsRFC = GridSearchCV(RFC,param_grid = rf_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose ... | Titanic - Machine Learning from Disaster |
5,923,489 | stops = set(stopwords.words('english'))<feature_engineering> | XGBC =xgb.XGBClassifier(objective="reg:squarederror",random_state = random_state)
if(debug):
XGBC_pg = {'max_depth':[2]}
else:
XGBC_pg = {'max_depth':[2,4,100],'learning_rate':[0.0001,0.001,0.005],'n_estimators':[100,250,500,1000],
'reg_alpha':[0.00001,0.00005,0.0001,0.0005],'colsample_bytree':[.5,.6,.7,.8]}
gsXGBC = ... | Titanic - Machine Learning from Disaster |
5,923,489 | def standardize_text(df, text_field):
df[text_field] = df[text_field].str.replace(r"http\S+", "")
df[text_field] = df[text_field].str.replace(r"http", "")
df[text_field] = df[text_field].str.replace(r"@\S+", "")
df[text_field] = df[text_field].str.replace(r"[^A-Za-z0-9() ,!?@'\`"\_
]", " ")
df[text_field] = df[text... | XGBDC =xgb.XGBClassifier(objective="reg:squarederror",booster = 'dart',random_state = random_state)
if(debug):
XGBDC_pg = {'max_depth':[2]}
else:
XGBDC_pg = {'max_depth':[2,4],'learning_rate':[0.0001,0.001,0.005],'n_estimators':[100,250,500],
'reg_alpha':[0.00001,0.00005,0.0001,0.0005],'colsample_bytree':[.5,.7,.8]}
g... | Titanic - Machine Learning from Disaster |
5,923,489 | def removing_stopwords(df, text_field):
for i in range(len(df[text_field])) :
df[text_field][i] = ' '.join([word for word in df[text_field][i].split() if word not in stops])
return df<define_variables> | BaggC = BaggingClassifier()
BaggC_pg = {'n_estimators':[5,10,25],'bootstrap':[False,True],'max_features':[.1,.4,.5,.7],
'max_samples':[.2,.5,.7,1]}
gsBaggC = GridSearchCV(BaggC,param_grid = BaggC_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gsBaggC.fit(X,y)
BaggC_best = gsBaggC.best_estimator_ | Titanic - Machine Learning from Disaster |
5,923,489 | EMBEDDING_FILE = '.. /input/fast-text-vector/crawl-300d-2M.vec'<load_from_csv> | adac = AdaBoostClassifier()
if(debug):
adac_pg = {'algorithm':['SAMME']}
else:
adac_pg = {'algorithm':['SAMME','SAMME.R'],'learning_rate':[.001,.00001,.01,.5,1],'n_estimators':[25,50,100,150,200]}
gsADAC = GridSearchCV(adac,param_grid = adac_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gsADAC.fit(X,y)
AD... | Titanic - Machine Learning from Disaster |
5,923,489 | train = pd.read_csv(".. /input/jigsaw-toxic-comment-classification-challenge/train.csv")
test = pd.read_csv(".. /input/jigsaw-toxic-comment-classification-challenge/test.csv" )<drop_column> | def important_features(names_classifiers):
ncols = 2
nrows = int(np.ceil(len(names_classifiers)/ncols))
nclassifier = 0
for row in range(nrows):
for col in range(ncols):
if(nclassifier == len(names_classifiers)) :
break
name = names_classifiers[nclassifier][0]
classifier = names_classifiers[nclassifier][1]
indices = np... | Titanic - Machine Learning from Disaster |
5,923,489 | train["comment_text"].fillna("fillna")
test["comment_text"].fillna("fillna")
train = removing_stopwords(train,"comment_text")
test = removing_stopwords(test,"comment_text" )<string_transform> | test_RFC = pd.Series(RFC_best.predict(dtest), name="RFC")
test_lrc = pd.Series(lrc_best.predict(dtest), name="LRC")
test_XGBC = pd.Series(XGBC_best.predict(dtest), name="XGBoost")
test_XGBDC = pd.Series(XGBDC_best.predict(dtest), name="XGBoost_Dart")
test_BaggC = pd.Series(BaggC_best.predict(dtest), name="Bagging")... | Titanic - Machine Learning from Disaster |
5,923,489 | train = standardize_text(train,"comment_text")
test = standardize_text(test,"comment_text" )<prepare_x_and_y> | lgbmc = lgb.LGBMClassifier()
if(debug):
lgbmc_pg = {'num_leaves':[30]}
else:
lgbmc_pg = {'num_leaves':[30,50,60],'max_depth':[2,3,7,-1],'learning_rate':[.001,.00001,.01,.5],'n_estimators':[100,150,200,500]}
gsLGBMC = GridSearchCV(lgbmc,param_grid = lgbmc_pg, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
ensemb... | Titanic - Machine Learning from Disaster |
5,923,489 | <define_variables><EOS> | test_Survived = pd.Series(LGBMC_best.predict(ensemble_results), name="Survived")
output = pd.DataFrame({'PassengerId': dtest.index,
'Survived': test_Survived.astype('int32')})
output.to_csv("ensemble_python_voting.csv",index=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
%matplotlib inline
rcParams['figure.figsize'] = 12, 4
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
5,766,212 | tokenizer = text.Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(train_x)+ list(test_x))<string_transform> | data_raw = pd.read_csv('.. /input/titanic/train.csv')
data_val = pd.read_csv('.. /input/titanic/test.csv')
data_train = data_raw.copy(deep = True)
data_test = data_val.copy(deep = True)
print(data_train.info())
print("
print(data_test.info())
print("
data_combine = [data_train, data_test]
| Titanic - Machine Learning from Disaster |
5,766,212 | train_x = tokenizer.texts_to_sequences(train_x)
test_x = tokenizer.texts_to_sequences(test_x )<concatenate> | data_train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | train_x = sequence.pad_sequences(train_x, maxlen=maxlen)
test_x = sequence.pad_sequences(test_x, maxlen=maxlen )<compute_test_metric> | data_train[["Sex", "Survived"]].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | def get_coefs(word, *arr): return word, np.asarray(arr, dtype='float32' )<string_transform> | data_train[["SibSp", "Survived"]].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | word_index = tokenizer.word_index<define_variables> | data_train[["Parch", "Survived"]].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | nb_words = min(max_features, len(word_index))<define_variables> | data_train[["Embarked", "Survived"]].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | embedding_matrix = np.zeros(( nb_words, embed_size))<feature_engineering> | for dataset in data_combine:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(data_train['Title'], data_train['Sex'] ) | Titanic - Machine Learning from Disaster |
5,766,212 | for word, i in word_index.items() :
if i >= max_features: continue
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None: embedding_matrix[i] = embedding_vector<compute_train_metric> | for dataset in data_combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = datas... | Titanic - Machine Learning from Disaster |
5,766,212 | class RocAucEvaluation(Callback):
def __init__(self, validation_data=() , interval=1):
super(Callback, self ).__init__()
self.interval = interval
self.X_val, self.y_val = validation_data
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval == 0:
y_pred = self.model.predict(self.X_val, verbose=0)
score = ro... | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in data_combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
data_train.head() | Titanic - Machine Learning from Disaster |
5,766,212 | def get_model() :
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = SpatialDropout1D(0.2 )(x)
x = Bidirectional(GRU(80, return_sequences=True))(x)
avg_pool = GlobalAveragePooling1D()(x)
max_pool = GlobalMaxPooling1D()(x)
conc = concatenate([avg_pool, max_poo... | data_train = data_train.drop(['Name', 'PassengerId'], axis=1)
data_test = data_test.drop(['Name'], axis=1)
data_combine = [data_train, data_test]
data_train.shape, data_test.shape | Titanic - Machine Learning from Disaster |
5,766,212 | batch_size = 32
epochs = 2<split> | for dataset in data_combine:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int)
data_train.head() | Titanic - Machine Learning from Disaster |
5,766,212 | X_tra, X_val, y_tra, y_val = train_test_split(train_x, train_y, train_size=0.95, random_state=233 )<compute_test_metric> | guess_ages = np.zeros(( 2,3))
guess_ages | Titanic - Machine Learning from Disaster |
5,766,212 | RocAuc = RocAucEvaluation(validation_data=(X_val, y_val), interval=1 )<train_model> | for dataset in data_combine:
for i in range(0, 2):
for j in range(0, 3):
guess_df = dataset[(dataset['Sex'] == i)& \
(dataset['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_df.median()
guess_ages[i,j] = int(age_guess/0.5 + 0.5)* 0.5
for i in range(0, 2):
for j in range(0, 3):
dataset.loc[(dataset.Age.isnull())&(... | Titanic - Machine Learning from Disaster |
5,766,212 | hist = model.fit(X_tra, y_tra, batch_size=batch_size, epochs=epochs, validation_data=(X_val, y_val),
callbacks=[RocAuc], verbose=2 )<predict_on_test> | data_train['AgeBand'] = pd.cut(data_train['Age'], 5)
data_train[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False ).mean().sort_values(by='AgeBand', ascending=True ) | Titanic - Machine Learning from Disaster |
5,766,212 | y_pred = model.predict(test_x, batch_size=1024 )<load_from_csv> | for dataset in data_combine:
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 |
5,766,212 | submission = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/sample_submission.csv' )<save_to_csv> | data_train = data_train.drop(['AgeBand'], axis=1)
data_combine = [data_train, data_test]
data_train.head() | Titanic - Machine Learning from Disaster |
5,766,212 | submission[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]] = y_pred
submission.to_csv('submission.csv', index=False )<save_to_csv> | for dataset in data_combine:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
data_train[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | submission.to_csv('submission.csv', index=False )<save_to_csv> | for dataset in data_combine:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
data_train[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
5,766,212 | submission.to_csv('submission.csv', index=False )<import_modules> | data_train = data_train.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
data_test = data_test.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
data_combine = [data_train, data_test]
data_train.head() | Titanic - Machine Learning from Disaster |
5,766,212 | import numpy as np
import pandas as pd
import json<load_from_csv> | for dataset in data_combine:
dataset['Age*Class'] = dataset.Age * dataset.Pclass
data_train.loc[:, ['Age*Class', 'Age', 'Pclass']].head(10 ) | Titanic - Machine Learning from Disaster |
5,766,212 | pd_train = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/train.csv')
pd_test = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv' )<prepare_x_and_y> | freq_port = data_train.Embarked.dropna().mode() [0]
for dataset in data_combine:
dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
data_train[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
5,766,212 | train = np.array(pd_train)
test = np.array(pd_test )<find_best_params> | for dataset in data_combine:
dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
data_train.head() | Titanic - Machine Learning from Disaster |
5,766,212 | def find_all(input_str, search_str):
l1 = []
length = len(input_str)
index = 0
while index < length:
i = input_str.find(search_str, index)
if i == -1:
return l1
l1.append(i)
index = i + 1
return l1<define_variables> | data_test['Fare'].fillna(data_test['Fare'].dropna().median() , inplace=True)
data_test.head() | Titanic - Machine Learning from Disaster |
5,766,212 | output = {}
output['version'] = 'v1.0'
output['data'] = []
for line in train:
paragraphs = []
context = line[1]
qas = []
question = line[-1]
qid = line[0]
answers = []
answer = line[2]
if type(answer)!= str or type(context)!= str or type(question)!= str:
print(context, type(context))
print(answer, type(answer))
print(q... | for dataset in data_combine:
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 |
5,766,212 | output = {}
output['version'] = 'v1.0'
output['data'] = []
for line in test:
paragraphs = []
context = line[1]
qas = []
question = line[-1]
qid = line[0]
if type(context)!= str or type(question)!= str:
print(context, type(context))
print(answer, type(answer))
print(question, type(question))
continue
answers = []
answer... | X_train = data_train.drop("Survived", axis=1)
Y_train = data_train["Survived"]
X_test = data_test.drop("PassengerId", axis=1 ).copy()
X_train.shape, Y_train.shape, X_test.shape | Titanic - Machine Learning from Disaster |
5,766,212 | !python /kaggle/input/pytorchtransformers/transformers-2.5.1/examples/run_squad.py \
--model_type roberta \
--model_name_or_path roberta-large \
--do_lower_case \
--do_train \
--do_eval \
--data_dir./data \
--cache_dir /kaggle/input/cached-roberta-large-pretrained/cache \
--train_file train.json \
--predict_file test.j... | print(X_train.columns)
print("
print(X_test.columns)
print("
X_train.drop("Embarked", axis=1)
X_test.drop("Embarked", axis=1 ) | Titanic - Machine Learning from Disaster |
5,766,212 | predictions = json.load(open('results_roberta_large/predictions_.json', 'r'))
submission = pd.read_csv(open('/kaggle/input/tweet-sentiment-extraction/sample_submission.csv', 'r'))
for i in range(len(submission)) :
id_ = submission['textID'][i]
if pd_test['sentiment'][i] == 'neutral':
submission.loc[i, 'selected_text'] ... | 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 |
5,766,212 | submission.to_csv('submission.csv', index=False )<import_modules> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2)
acc_log
print('Test ACC Logistic Regression -- > ', acc_log)
X_pred = logreg.predict(X_train)
X_predprob = logreg.predict_proba(X_train)[:,1]
t_lr_score = metrics.accur... | Titanic - Machine Learning from Disaster |
5,766,212 | print('TF version',tf.__version__ )<define_variables> | svc = SVC(probability=True)
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc
print('Test ACC SVM -- > ', acc_svc)
X_pred = svc.predict(X_train)
X_predprob = svc.predict_proba(X_train)[:,1]
t_svm_score = metrics.accuracy_score(Y_train, X_pred)
pri... | Titanic - Machine Learning from Disaster |
5,766,212 | MAX_LEN = 96
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
lowercase=True,
add_prefix_space=True
)
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}
train = pd.read_csv('.. /input/... | param_grid = {'C': [0.1, 1, 10, 100, 1000],
'gamma': [1, 0.1, 0.01, 0.001, 0.0001],
'kernel': ['linear', 'rbf']}
grid = LinearSVC(penalty='l2', loss='squared_hinge', dual=True, tol=0.0001, C=1.0, multi_class='ovr')
grid.fit(X_train, Y_train)
Y_pred = grid.predict(X_test)
acc_svc1 = round(grid.score(X_train, Y_train)... | Titanic - Machine Learning from Disaster |
5,766,212 | ct = train.shape[0]
input_ids = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids = np.zeros(( ct,MAX_LEN),dtype='int32')
start_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
end_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(train.shape[0]):
... | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
acc_knn
print('Test ACC KNN ', acc_knn)
X_pred = knn.predict(X_train)
X_predprob = knn.predict_proba(X_train)[:,1]
t_knn_score = metrics.accuracy_score(Y_train, X... | Titanic - Machine Learning from Disaster |
5,766,212 | test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' ).fillna('')
ct = test.shape[0]
input_ids_t = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask_t = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids_t = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(test.shape[0]):
text1 = " "+" ".join(... | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian
print('Test ACC Naive ', acc_gaussian)
X_pred = gaussian.predict(X_train)
X_predprob = gaussian.predict_proba(X_train)[:,1]
t_nb_score = metrics.accur... | Titanic - Machine Learning from Disaster |
5,766,212 | def build_model() :
ids = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
config = RobertaConfig.from_pretrained(PATH+'config-roberta-base.json')
bert_model = TFRobertaModel.from_pretrained(PATH+'pre... | perceptron = Perceptron()
perceptron.fit(X_train, Y_train)
Y_pred = perceptron.predict(X_test)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2)
acc_perceptron | Titanic - Machine Learning from Disaster |
5,766,212 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
if(len(a)==0)&(len(b)==0): return 0.5
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<define_variables> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
5,766,212 | jac = []; VER='v0'; DISPLAY=1
oof_start = np.zeros(( input_ids.shape[0],MAX_LEN))
oof_end = np.zeros(( input_ids.shape[0],MAX_LEN))
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zeros(( input_ids_t.shape[0],MAX_LEN))
skf = StratifiedKFold(n_splits=5,shuffle=True,random_state=777)
for fold,(idx... | gd = GradientBoostingClassifier()
gd.fit(X_train, Y_train)
Y_pred = gd.predict(X_test)
acc_gd = round(gd.score(X_train, Y_train)* 100, 2)
acc_gd
print('Test ACC Gradient Descent', acc_gd)
X_pred = gd.predict(X_train)
X_predprob = gd.predict_proba(X_train)[:,1]
t_gd_score = metrics.accuracy_score(Y_train, X_pred)
... | Titanic - Machine Learning from Disaster |
5,766,212 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | sgd = SGDClassifier(loss='log')
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
acc_sgd
print('Test ACC Stochastic Gradient Descent', acc_sgd)
X_pred = sgd.predict(X_train)
X_predprob = sgd.predict_proba(X_train)[:,1]
t_sgd_score = metrics.accuracy_score... | Titanic - Machine Learning from Disaster |
5,766,212 | all = []
for k in range(input_ids_t.shape[0]):
a = np.argmax(preds_start[k,])
b = np.argmax(preds_end[k,])
if a>b:
st = test.loc[k,'text']
else:
text1 = " "+" ".join(test.loc[k,'text'].split())
enc = tokenizer.encode(text1)
st = tokenizer.decode(enc.ids[a-1:b])
all.append(st )<save_to_csv> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree
print('Test ACC Decision Tree', acc_decision_tree)
X_pred = decision_tree.predict(X_train)
X_predprob = deci... | Titanic - Machine Learning from Disaster |
5,766,212 | test['selected_text'] = all
test[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test.sample(25 )<set_options> | bag_cla = BaggingClassifier()
bag_cla.fit(X_train, Y_train)
y_pred=bag_cla.predict(X_test)
acc_bag_cla = round(bag_cla.score(X_train, Y_train)* 100, 2)
print('Test ACC Bagging Classifier', acc_bag_cla)
X_pred = bag_cla.predict(X_train)
X_predprob = bag_cla.predict_proba(X_train)[:,1]
t_bc_score = round(metrics.acc... | Titanic - Machine Learning from Disaster |
5,766,212 | py.init_notebook_mode(connected=True)
nltk.download('stopwords')
stop=set(stopwords.words('english'))<load_from_csv> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
acc_random_forest
print('Test ACC Random Forest', acc_random_forest)
X_... | Titanic - Machine Learning from Disaster |
5,766,212 | def read_train() :
train=pd.read_csv(".. /input/tweet-sentiment-extraction/train.csv")
train['text']=train['text'].astype(str)
train['selected_text']=train['selected_text'].astype(str)
return train
def read_test() :
test=pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
test['text']=test['text'].astype(s... | xgb = XGBClassifier(n_estimators=100)
xgb.fit(X_train, Y_train)
Y_pred_xgb=xgb.predict(X_test)
xgb.score(X_train, Y_train)
acc_xgb = round(xgb.score(X_train, Y_train)* 100, 2)
acc_xgb
print('Test ACC XGBoost', acc_xgb)
X_pred = xgb.predict(X_train)
X_predprob = xgb.predict_proba(X_train)[:,1]
t_xgb_score = metri... | Titanic - Machine Learning from Disaster |
5,766,212 | def remove_stopwords(text):
if text is not None:
tokens = [x for x in word_tokenize(text)if x not in stop]
return " ".join(tokens)
else:
return None
def remove_URL(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'',text)
def remove_html(text):
html=re.compile(r'<.*?>')
return html.sub(r'',text)
d... | xgb_tuned = XGBClassifier(
learning_rate =0.1,
n_estimators=143,
max_depth=5,
min_child_weight=1,
gamma=0.0,
subsample=0.8,
colsample_bytree=0.8,
objective= 'binary:logistic',
nthread=4,
scale_pos_weight=1,
seed=27
)
xgb_tuned.fit(X_train, Y_train)
Y_pred_tuned=xgb_tuned.predict(X_test)
xgb_tuned.score(X_train, Y_... | Titanic - Machine Learning from Disaster |
5,766,212 | def analyze_neutral_lenght(train_df):
neutral_df = train_df[train_df["sentiment"] == "neutral"]
equal_selected_with_text = neutral_df[neutral_df['selected_text'] == neutral_df["text"]]
print("Total number of neutral: {}".format(len(neutral_df)))
print("Neutral with text equal to selected text: {}".format(len(equal_sel... | catb=CatBoostClassifier(iterations=2500, depth=5, learning_rate=0.3, verbose=0,
allow_writing_files=False, loss_function='CrossEntropy', random_strength=0.1, leaf_estimation_method='Gradient')
catb.fit(X_train, Y_train)
y_pred=catb.predict(X_test)
acc_catb = round(catb.score(X_train, Y_train)* 100, 2)
print('Test A... | Titanic - Machine Learning from Disaster |
5,766,212 | def analyze_cleaning(df, cleaning_lambda, field="selected_text"):
def diff_strings(row):
count = {}
A = row[0]
B = row[1]
if A is None:
A = "TEMP"
if B is None:
B = "TEMP"
for word in A.split() :
count[word] = count.get(word, 0)+ 1
for word in B.split() :
count[word] = count.get(word, 0)+ 1
diff = [word for word in cou... | clr = LogisticRegression()
csvc = SVC(probability=True)
cknn = KNeighborsClassifier(n_neighbors = 3)
cgau = GaussianNB()
cgb = GradientBoostingClassifier()
csgb = SGDClassifier(loss='log')
crf = RandomForestClassifier(n_estimators=100)
cxgbt = XGBClassifier(learning_rate =0.1, n_estimators=143, max_depth=5, min_chi... | Titanic - Machine Learning from Disaster |
5,766,212 |
<save_to_csv> |
for clf, label in zip([crf, cdt, cbc, ccb, eclf1], ['RandomForest', 'Decision Tree', 'Bagging Classifier',
'CatBoost', 'Voting Classifier']):
scores = cross_val_score(clf, X_train, Y_train, cv=5, scoring='accuracy')
print("Accuracy: %0.2f(+/- %0.2f)[%s]" %(round(scores.mean() *100,2), scores.std() , label)) | Titanic - Machine Learning from Disaster |
5,766,212 |
<define_variables> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron', 'Gradient Descent',
'Stochastic Gradient Descent', 'Linear SVC',
'Decision Tree', 'XgBoost', 'XgBoost_Tuned', 'Bagging Classifer', 'Cat Boost', 'Voting Classifier'],
'Score': [acc_svc... | Titanic - Machine Learning from Disaster |
5,766,212 | <install_modules><EOS> | X_pred = decision_tree.predict(X_train)
submission = pd.DataFrame({
"PassengerId": data_test["PassengerId"],
"Survived": Y_pred
})
submission.to_csv(".. /working/submission_TitanicSurvived_pred_26Feb20_1757hr.csv", index=False)
print('Validation Data Distribution:
', submission['Survived'].value_counts(normalize = T... | Titanic - Machine Learning from Disaster |
5,707,809 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<install_modules> | def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn | Titanic - Machine Learning from Disaster |
5,707,809 | !mkdir -p data
!pip install '/kaggle/input/simple-transformers-pypi/seqeval-0.0.12-py3-none-any.whl' -q
!pip install '/kaggle/input/simple-transformers-pypi/simpletransformers-0.22.1-py3-none-any.whl' -q
use_cuda = True
def find_all(input_str, search_str):
l1 = []
length = len(input_str)
index = 0
while index < length... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
5,707,809 | !mkdir -p data
!pip install '/kaggle/input/simple-transformers-pypi/seqeval-0.0.12-py3-none-any.whl' -q
!pip install '/kaggle/input/simple-transformers-pypi/simpletransformers-0.22.1-py3-none-any.whl' -q
use_cuda = True
def find_all(input_str, search_str):
l1 = []
length = len(input_str)
index = 0
while index < length... | train_ID = train['PassengerId']
test_ID = test['PassengerId']
train = train.drop('PassengerId', axis=1)
test = test.drop('PassengerId', axis=1 ) | Titanic - Machine Learning from Disaster |
5,707,809 | sentiment_analyzer = SentimentIntensityAnalyzer()
def merge_predictions(submission_distil, sumbission_albert, submission_bert):
def merge(row):
pred_1 = set(str(row[1] ).split())
pred_2 = set(str(row[2] ).split())
pred_3 = set(str(row[3] ).split())
res = []
res = list(pred_1.intersection(pred_2, pred_3))
if len(res)... | train['Sex'].value_counts() | Titanic - Machine Learning from Disaster |
5,707,809 | print('TF version',tf.__version__ )<define_variables> | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
5,707,809 | MAX_LEN = 96
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
lowercase=True,
add_prefix_space=True
)
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}
train = pd.read_csv('.. /input/... | ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train.Survived.values
all_data = pd.concat(( train, test)).reset_index(drop=True)
all_data.drop(['Survived'], axis=1, inplace=True)
print("all_data size is : {}".format(all_data.shape)) | Titanic - Machine Learning from Disaster |
5,707,809 | ct = train.shape[0]
input_ids = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids = np.zeros(( ct,MAX_LEN),dtype='int32')
start_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
end_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(train.shape[0]):
... | total = all_data.isnull().sum().sort_values(ascending=False)
percent =(all_data.isnull().sum() /all_data.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data | Titanic - Machine Learning from Disaster |
5,707,809 | test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' ).fillna('')
ct = test.shape[0]
input_ids_t = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask_t = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids_t = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(test.shape[0]):
text1 = " "+" ".join(... | all_data.drop(['Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
5,707,809 | def build_model() :
ids = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
config = RobertaConfig.from_pretrained(PATH+'config-roberta-base.json')
bert_model = TFRobertaModel.from_pretrained(PATH+'pre... | all_data['SibSp'].loc[np.isnan(all_data['Age'])].value_counts() | Titanic - Machine Learning from Disaster |
5,707,809 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
if(len(a)==0)&(len(b)==0): return 0.5
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<define_variables> | all_data["Age"] = all_data.loc[all_data["SibSp"]>1].groupby("SibSp")["Age"].transform(
lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
5,707,809 | jac = []; VER='v0'; DISPLAY=1
oof_start = np.zeros(( input_ids.shape[0],MAX_LEN))
oof_end = np.zeros(( input_ids.shape[0],MAX_LEN))
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zeros(( input_ids_t.shape[0],MAX_LEN))
skf = StratifiedKFold(n_splits=5,shuffle=True,random_state=777)
for fold,(idx... | all_data["Age"] = all_data.groupby("Pclass")["Age"].transform(
lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
5,707,809 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | all_data["Embarked"].value_counts() | Titanic - Machine Learning from Disaster |
5,707,809 | all = []
for k in range(input_ids_t.shape[0]):
a = np.argmax(preds_start[k,])
b = np.argmax(preds_end[k,])
if a>b:
st = test.loc[k,'text']
else:
text1 = " "+" ".join(test.loc[k,'text'].split())
enc = tokenizer.encode(text1)
st = tokenizer.decode(enc.ids[a-1:b])
all.append(st )<save_to_csv> | all_data["Embarked"] = all_data["Embarked"].fillna("S" ) | Titanic - Machine Learning from Disaster |
5,707,809 | test['selected_text'] = all
test[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test.sample(25 )<import_modules> | all_data["Fare"] = all_data.groupby("Pclass")["Fare"].transform(
lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
5,707,809 | print('TF version',tf.__version__ )<define_variables> | all_data["TotalRelatives"] = all_data['SibSp'] + all_data['Parch']
all_data['IsAlone'] = 1
all_data['IsAlone'].loc[all_data["TotalRelatives"] > 0] = 0
all_data['Title'] = all_data['Name'].str.split(", ", expand=True)[1].str.split(".", expand=True)[0]
all_data['FareBin'] = pd.qcut(all_data['Fare'], 4)
all_data['AgeBin'... | Titanic - Machine Learning from Disaster |
5,707,809 | MAX_LEN = 96
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
lowercase=True,
add_prefix_space=True
)
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}
train = pd.read_csv('.. /input/... | final_features = pd.get_dummies(all_data ).reset_index(drop=True)
final_features.shape | Titanic - Machine Learning from Disaster |
5,707,809 | ct = train.shape[0]
input_ids = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids = np.zeros(( ct,MAX_LEN),dtype='int32')
start_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
end_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(train.shape[0]):
... | train = final_features[:ntrain]
test = final_features[ntrain:] | Titanic - Machine Learning from Disaster |
5,707,809 | test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' ).fillna('')
ct = test.shape[0]
input_ids_t = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask_t = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids_t = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(test.shape[0]):
text1 = " "+" ".join(... | n_folds = 5
def score_cv(model):
kf = KFold(n_folds, shuffle=True, random_state=42 ).get_n_splits(train.values)
score = cross_val_score(model, train.values, y_train, cv = kf)
return("score: {:.4f}({:.4f})".format(score.mean() , score.std())) | Titanic - Machine Learning from Disaster |
5,707,809 | def build_model() :
ids = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
config = RobertaConfig.from_pretrained(PATH+'config-roberta-base.json')
bert_model = TFRobertaModel.from_pretrained(PATH+'pre... | params = {'logisticregression__C' : [0.001,0.01,0.1,1,10,100,1000]}
pipe = make_pipeline(RobustScaler() , LogisticRegression())
gridsearch_logistic = GridSearchCV(pipe, params, cv=10)
gridsearch_logistic.fit(train, y_train)
print("Meilleurs parametres: ", gridsearch_logistic.best_params_ ) | Titanic - Machine Learning from Disaster |
5,707,809 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
if(len(a)==0)&(len(b)==0): return 0.5
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<define_variables> | score_cv(gridsearch_logistic.best_estimator_ ) | Titanic - Machine Learning from Disaster |
5,707,809 | jac = []; VER='v0'; DISPLAY=1
oof_start = np.zeros(( input_ids.shape[0],MAX_LEN))
oof_end = np.zeros(( input_ids.shape[0],MAX_LEN))
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zeros(( input_ids_t.shape[0],MAX_LEN))
skf = StratifiedKFold(n_splits=5,shuffle=True,random_state=777)
for fold,(idx... | params = {'kneighborsclassifier__n_neighbors' : [3,4,5,6,7],
'kneighborsclassifier__weights' : ['uniform','distance'],
'kneighborsclassifier__algorithm' : ['auto', 'ball_tree', 'kd_tree', 'brute']}
pipe = make_pipeline(RobustScaler() , KNeighborsClassifier())
gridsearch_KNC = GridSearchCV(pipe, params, cv=5)
gridsear... | Titanic - Machine Learning from Disaster |
5,707,809 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | score_cv(gridsearch_KNC.best_estimator_ ) | 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.