kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,319,955 | pred1 = np.expm1(pred )<predict_on_test> | grid_xgb = GridSearchCV(XGBClassifier() , param_grid_xgb,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,319,955 | pred = model.predict(X_test )<prepare_output> | grid_xgb.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,319,955 | pred1 = np.expm1(pred )<save_to_csv> | params_xgb = {'colsample_bylevel': 0.7, 'learning_rate': 0.03, 'max_depth': 3,
'n_estimators': 400, 'reg_lambda': 15, 'subsample': 0.5} | Titanic - Machine Learning from Disaster |
14,319,955 | submission = pd.read_csv('.. /input/exam-for-students20200129/sample_submission.csv', index_col=0)
submission['ConvertedSalary'] = pred1
submission.to_csv('submission.csv' )<set_options> | logreg = LogisticRegression(**params_logreg)
svc = SVC(**params_svc)
knn = KNeighborsClassifier(**params_knn)
rfc = RandomForestClassifier(**params_random)
gradient = GradientBoostingClassifier(**params_gradient)
xgb = XGBClassifier(**params_xgb)
estimators = [('logreg', logreg),('knn', knn),('svc', svc),('rfc', ... | Titanic - Machine Learning from Disaster |
14,319,955 | plt.style.use('ggplot')
%matplotlib inline
pd.set_option('display.max_columns', 500 )<load_from_csv> | y_preds = logreg.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train = pd.read_csv('.. /input/exam-for-students20200129/train.csv', index_col=0)
df_test = pd.read_csv('.. /input/exam-for-students20200129/test.csv', index_col=0)
df_train.ConvertedSalary = np.log1p(df_train.ConvertedSalary )<count_missing_values> | y_preds = svc.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train.isnull().sum()<count_missing_values> | y_preds = knn.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_test.isnull().sum()<count_unique_values> | y_preds = rfc.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | cats = []
for col in df_train.columns:
if df_train[col].dtype == 'object':
cats.append(col)
print(col, df_train[col].nunique() )<groupby> | y_preds = gradient.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train.groupby(u ).size()<groupby> | y_preds = xgb.fit(X_train_fe, y_train ).predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train.groupby(u ).size()<sort_values> | submission = pd.DataFrame({'PassengerId':test.index,
'Survived':y_preds} ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train.groupby(u ).size().sort_values()
<sort_values> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_test.groupby(u ).size().sort_values()<drop_column> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,319,955 | df_train.drop('Country',axis=1,inplace=True)
df_test.drop('Country',axis=1,inplace=True )<groupby> | pd.read_csv('submission.csv' ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_train.groupby(u ).size()<groupby> | from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from mlxtend.feature_selection import SequentialFeatureSelector as SFS | Titanic - Machine Learning from Disaster |
14,653,637 | df_train.groupby(u ).size()<feature_engineering> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
14,653,637 |
<groupby> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
14,653,637 | nf = 'count_Employment'
df_train[nf] = df_train[u].map(df_train.groupby(u ).ConvertedSalary.count())
df_test[nf] = df_test[u].map(df_train.groupby(u ).ConvertedSalary.count() )<groupby> | train_data['Age'] = train_data['Age'].fillna(train_data.Age.mean())
test_data['Age'] = test_data['Age'].fillna(test_data.Age.mean())
test_data['Fare'] = test_data['Fare'].fillna(test_data.Fare.mean() ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_train.groupby(u ).size()<groupby> | train_data["Embarked"].value_counts() | Titanic - Machine Learning from Disaster |
14,653,637 | u = 'CompanySize'
df_train.groupby(u ).size()<groupby> | train_data = train_data.fillna({"Embarked": "S"} ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_test.groupby(u ).size()<groupby> | train_data.drop(['Name','Ticket','Cabin'], axis = 1, inplace = True)
test_data.drop(['Name','Ticket','Cabin'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_train.groupby(u ).size()<groupby> | train_data.isnull().sum()
test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,653,637 | u = 'YearsCoding'
df_train.groupby(u ).size()<groupby> | train_data = pd.get_dummies(train_data, columns=["Sex"])
train_data = pd.get_dummies(train_data, columns=["Embarked"])
test_data = pd.get_dummies(test_data, columns=["Sex"])
test_data = pd.get_dummies(test_data, columns=["Embarked"] ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_test.groupby(u ).size()<categorify> | X = train_data
X = train_data.drop("Survived",axis=1)
y = train_data["Survived"] | Titanic - Machine Learning from Disaster |
14,653,637 | df_train[u].replace({'0-2 years':0,
'12-14 years':12,
'15-17 years':15,
'18-20 years':18,
'21-23 years':21,
'24-26 years':24,
'27-29 years':27,
'3-5 years':3,
'30 or more years':30,
'6-8 years':6,
'9-11 years':9},inplace=True )<groupby> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 1)
X_train.shape, X_test.shape | Titanic - Machine Learning from Disaster |
14,653,637 | df_train.groupby(u ).size()<categorify> | sfs = SFS(RandomForestClassifier(n_estimators=250, max_depth=5, random_state=1, n_jobs = -1),
k_features = 6,
forward = False,
floating = False,
verbose = 2,
scoring = 'accuracy',
cv = 4,
n_jobs = -1)
sfs = sfs.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
14,653,637 | df_test[u].replace({'0-2 years':0,
'12-14 years':12,
'15-17 years':15,
'18-20 years':18,
'21-23 years':21,
'24-26 years':24,
'27-29 years':27,
'3-5 years':3,
'30 or more years':30,
'6-8 years':6,
'9-11 years':9},inplace=True )<groupby> | print(sfs.k_feature_names_)
print('Sequential Forward Selection:')
print(sfs.k_feature_idx_)
print('CV Score:')
print(sfs.k_score_ ) | Titanic - Machine Learning from Disaster |
14,653,637 | u = 'YearsCodingProf'
df_train.groupby(u ).size()<groupby> | features = ['Pclass', 'Age', 'SibSp', 'Fare', 'Sex_male', 'Embarked_S']
X = train_data[features]
X_test = test_data[features]
model = RandomForestClassifier(n_estimators=250, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, ... | Titanic - Machine Learning from Disaster |
14,452,292 | df_train.groupby(u ).size()<groupby> | from sklearn.linear_model import LogisticRegression | Titanic - Machine Learning from Disaster |
14,452,292 | u = 'Age'
df_train.groupby(u ).size()<groupby> | x_train = pd.read_csv("/kaggle/input/titanic/train.csv")
y_train = x_train['Survived']
x_train = x_train.drop(columns=['Survived'])
x_test = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
14,452,292 | df_test.groupby(u ).size()<groupby> | def preprocessing(df):
df["Fare"] =(df["Fare"] - df["Fare"].min())/(df["Fare"].max() - df["Fare"].min())
df["Fare"] = df["Fare"].fillna(-999)
df["Sex"] = df["Sex"].factorize() [0]
df["Embarked"] = df["Embarked"].factorize() [0]
for i in range(len(df["Name"])) : df["Name"][i] = df["Name"][i].split(',')[0]
df["Name"] =... | Titanic - Machine Learning from Disaster |
14,452,292 | df_train.groupby(u ).size()<groupby> | x_train_processed = preprocessing(x_train)
x_test_processed = preprocessing(x_test ) | Titanic - Machine Learning from Disaster |
14,452,292 | u = 'LastNewJob'
df_train.groupby(u ).size()<groupby> | x_train_processed = x_train.drop(columns=["Ticket"])
x_test_processed = x_test.drop(columns=["Ticket"] ) | Titanic - Machine Learning from Disaster |
14,452,292 | df_train.groupby(u)['ConvertedSalary'].mean()<groupby> | model = LogisticRegression(random_state=0, max_iter=2500 ).fit(x_train_processed, y_train)
pred = model.predict(x_test_processed)
pred | Titanic - Machine Learning from Disaster |
14,452,292 | u = 'Currency'
df_train.groupby(u ).size()<groupby> | model.score(x_train_processed, y_train ) | Titanic - Machine Learning from Disaster |
14,452,292 | df_test.groupby(u ).size().index<categorify> | df = pd.DataFrame(pred, columns=["Survived"])
df.head() | Titanic - Machine Learning from Disaster |
14,452,292 |
<count_unique_values> | df["PassengerId"] = x_test["PassengerId"].values
df | Titanic - Machine Learning from Disaster |
14,452,292 | df_train[u].nunique()<count_unique_values> | df.to_csv('predicts.csv',index=False ) | Titanic - Machine Learning from Disaster |
14,468,025 | df_test[u].nunique()<groupby> | data_train = pd.read_csv("/kaggle/input/titanic/train.csv")
data_test = pd.read_csv("/kaggle/input/titanic/test.csv")
y = data_train.Survived | Titanic - Machine Learning from Disaster |
14,468,025 | u = 'CurrencySymbol'
df_train.groupby(u ).size()<groupby> | data_train.groupby('Sex' ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,468,025 | df_test.groupby(u ).size().index<groupby> | data_train.groupby('SibSp' ).Survived.agg(['mean','count'] ) | Titanic - Machine Learning from Disaster |
14,468,025 | df_train.groupby(u)['ConvertedSalary'].mean()<groupby> | data_train.groupby('Parch' ).Survived.agg(['mean','count'] ) | Titanic - Machine Learning from Disaster |
14,468,025 | nf = 'count_CurrencySymbol'
df_train[nf] = df_train[u].map(df_train.groupby(u ).ConvertedSalary.count())
df_test[nf] = df_test[u].map(df_train.groupby(u ).ConvertedSalary.count() )<categorify> | X_train = data_train.drop(['Name','Ticket','PassengerId'],axis=1)
X_test = data_test.drop(['Name','Ticket','PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,468,025 | cats = []
for col in df_train.columns:
if df_train[col].dtype == 'object':
cats.append(col)
print(col, df_train[col].nunique())
encoder = OrdinalEncoder(cols=cats)
df_train[cats] = encoder.fit_transform(df_train[cats])
df_test[cats] = encoder.transform(df_test[cats] )<define_variables> | X_train = X_train.drop(['Cabin'],axis=1)
X_test = X_test.drop(['Cabin'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,468,025 | feature = ['CompanySize',
'LastNewJob',
'CurrencySymbol',
'YearsCoding',
'count_Employment',
'SalaryType',
'Currency',
'Employment',
'MilitaryUS',
'YearsCodingProf',
'count_CurrencySymbol',
'Age',
'RaceEthnicity',
'DevType',
'Student',
'AssessBenefits2',
'JobContactPriorities3',
'CareerSatisfaction',
'FrameworkWorkedWi... | X_train[X_train.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
14,468,025 | y_train = df_train.ConvertedSalary
X_train = df_train.drop(['ConvertedSalary'],axis=1)
X_test = df_test.copy()
<split> | X_train.groupby('Embarked' ).Embarked.count() | Titanic - Machine Learning from Disaster |
14,468,025 | scores = []
y_pred_test = 0
skf = KFold(n_splits=5, random_state=60, shuffle=True)
for i,(train_ix, test_ix)in tqdm(enumerate(skf.split(X_train, y_train))):
X_train_, y_train_ = X_train.values[train_ix], y_train.values[train_ix]
X_val, y_val = X_train.values[test_ix], y_train.values[test_ix]
clf = LGBMRegressor(boosti... | X_train.Embarked=X_train.Embarked.fillna('S' ) | Titanic - Machine Learning from Disaster |
14,468,025 | skf = KFold(n_splits=5, random_state=40, shuffle=True)
for i,(train_ix, test_ix)in tqdm(enumerate(skf.split(X_train, y_train))):
X_train_, y_train_ = X_train.values[train_ix], y_train.values[train_ix]
X_val, y_val = X_train.values[test_ix], y_train.values[test_ix]
clf = LGBMRegressor(boosting_type='gbdt', class_weight... | X_train[X_train.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
14,468,025 | y_pred = y_pred_test/10
y_pred = np.expm1(y_pred)
submission = pd.read_csv('.. /input/exam-for-students20200129/sample_submission.csv', index_col=0)
submission.ConvertedSalary = y_pred
submission.to_csv('submission.csv' )<set_options> | def impute(cols):
Age = cols[0]
Pclass = cols[1]
if(pd.isnull(Age)) :
if Pclass==1:
return 38
elif Pclass==2:
return 30
else:
return 25
return Age | Titanic - Machine Learning from Disaster |
14,468,025 | def reset_tf_session() :
curr_session = tf.get_default_session()
if curr_session is not None:
curr_session.close()
K.clear_session()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
s = tf.InteractiveSession(config=config)
K.set_session(s)
return s<load_from_csv> | X_train.Age = X_train[['Age','Pclass']].apply(impute,axis=1)
X_test.Age = X_test[['Age','Pclass']].apply(impute,axis=1 ) | Titanic - Machine Learning from Disaster |
14,468,025 | train_data_np = pd.read_csv(".. /input/train_data.txt",delimiter=' ::: ',header=None,names=['id','title','genre','desc'])
predict_data_np = pd.read_csv(".. /input/test_data.txt",delimiter=' ::: ',header=None,names=['id','title','desc'])
train_data_np.shape
<prepare_x_and_y> | X_test[X_test.Fare.isnull() ] | Titanic - Machine Learning from Disaster |
14,468,025 | lb = LabelBinarizer()
lb.fit(genres)
y = lb.transform(train_data_np.genre)
print(lb.classes_)
print(train_data_np.genre[0])
y[0]<init_hyperparams> | X_test['Fare']=X_test['Fare'].fillna(13 ) | Titanic - Machine Learning from Disaster |
14,468,025 | desc = train_data_np['desc'].values
tokenizer = Tokenizer(num_words=None,lower=True)
tokenizer.fit_on_texts(desc)
deleted = 0
high_count_words = [w for w,c in tokenizer.word_counts.items() if c > 10.0*train_data_np.shape[0]]
for w in high_count_words:
del tokenizer.word_index[w]
del tokenizer.word_docs[w]
del tokeniz... | X_train = X_train.drop(['Survived'],axis=1 ) | Titanic - Machine Learning from Disaster |
14,468,025 | maxlen = 100
X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)
X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)
print(X_train[0, :] )<choose_model_class> | X_test.groupby('Sex' ).Sex.count() | Titanic - Machine Learning from Disaster |
14,468,025 | def make_model_8() :
s = reset_tf_session()
embedding_dim = 50
model = Sequential()
model.add(layers.Embedding(input_dim=vocab_size,
output_dim=embedding_dim,
input_length=maxlen))
model.add(keras.layers.GlobalAveragePooling1D())
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(len(genres), activa... | from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder , LabelEncoder | Titanic - Machine Learning from Disaster |
14,468,025 | def make_model_9() :
s = reset_tf_session()
embedding_dim = 50
model = Sequential()
model.add(layers.Embedding(input_dim=vocab_size,
output_dim=embedding_dim,
input_length=maxlen))
model.add(layers.Bidirectional(layers.LSTM(100, return_sequences=True, dropout=0.7,recurrent_dropout=0.7)))
model.add(layers.Flatten())
m... | le =LabelEncoder()
X_train['Sex']=le.fit_transform(X_train['Sex'])
X_test['Sex'] = le.fit_transform(X_test['Sex'])
X_train.head() | Titanic - Machine Learning from Disaster |
14,468,025 | model = make_model_8()
history = model.fit(X_train, y_train,
epochs=20,
verbose=True,
validation_data=(X_test, y_test),
batch_size=1000)
plot_history(history )<predict_on_test> | onh = OneHotEncoder(handle_unknown='ignore', sparse=False)
X_train_trans = pd.DataFrame(onh.fit_transform(X_train[['Embarked']]))
X_test_trans = pd.DataFrame(onh.fit_transform(X_test[['Embarked']]))
X_train_trans.index = X_train.index
X_test_trans.index = X_test.index
X_train_conc = X_train.drop(['Embarked'],axis=1)
... | Titanic - Machine Learning from Disaster |
14,468,025 | y_predict_train = model.predict_proba(X_train )<find_best_params> | sc= StandardScaler()
X_train_final = sc.fit_transform(X_train_final)
X_test_final = sc.transform(X_test_final ) | Titanic - Machine Learning from Disaster |
14,468,025 | T=201
y_predict = y_predict_train
print(y_predict[T,:])
y_predict_max = np.argmax(y_predict[T,:])
print(y_predict_max, lb.classes_[y_predict_max], y_predict[T,y_predict_max])
print(np.argmax(y_train[T]),y_train[T])
print(train_data_np.genre[T])
<predict_on_test> | clf = SVC(kernel='rbf', degree = 5)
clf.fit(X_train_final,y ) | Titanic - Machine Learning from Disaster |
14,468,025 | <find_best_params><EOS> | pred = clf.predict(X_test_final)
output = pd.DataFrame({'PassengerId':data_test.PassengerId,'Survived':pred})
output.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
14,414,602 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.filterwarnings("ignore")
pd.set_option('max_columns',100 ) | Titanic - Machine Learning from Disaster |
14,414,602 | genres_predict = []
ids = []
for i in range(y_predict.shape[0]):
y_predict_max = np.argmax(y_predict[i,:])
genres_predict.extend([lb.classes_[y_predict_max]])
submission = pd.DataFrame({'id':predict_data_np['id'].values,
'genre':genres_predict,
'title':predict_data_np['title'].values},
columns=['id', 'genre','title']... | traindf = pd.read_csv('.. /input/titanic/train.csv' ).set_index('PassengerId')
testdf = pd.read_csv('.. /input/titanic/test.csv' ).set_index('PassengerId')
submission = pd.read_csv('.. /input/titanic/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
14,414,602 | train=pd.read_csv('.. /input/kaggle18011884/train_cabbage_price.csv')
train.avgPrice.plot()<load_from_csv> | df = pd.concat([traindf, testdf], axis=0, sort=False)
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['IsWomanOrBoy'] =(( df.Title == 'Master')|(df.Sex == 'female'))
df['LastName'] = df.Name.str.split(','... | Titanic - Machine Learning from Disaster |
14,414,602 | test=pd.read_csv('.. /input/kaggle18011884/test_cabbage_price.csv')
test<data_type_conversions> | numerics = ['int8', 'int16', 'int32', 'int64', 'float16', 'float32', 'float64']
categorical_columns = []
features = train.columns.values.tolist()
for col in features:
if train[col].dtype in numerics: continue
categorical_columns.append(col)
for col in categorical_columns:
if col in train.columns:
le = LabelEncoder()
l... | Titanic - Machine Learning from Disaster |
14,414,602 | train['yeargb']=[y[:6] for y in train['year'].astype('str')]
test['yeargb']=test['year']
train['month']=[np.int(y[4:6])for y in train['year'].astype('str')]
test['month']=[np.int(y[-2:])for y in test['year'].astype('str')]
train['year2']=[np.int(y[:4])for y in train['year'].astype('str')]
test['year2']=[np.int(y[:4])fo... | Xtrain, Xval, Ztrain, Zval = train_test_split(train, target, test_size=0.2, random_state=0)
train_set = lgbm.Dataset(Xtrain, Ztrain, silent=False)
valid_set = lgbm.Dataset(Xval, Zval, silent=False ) | Titanic - Machine Learning from Disaster |
14,414,602 | traingb.reset_index().append(test.reset_index() )<create_dataframe> | params = {
'boosting_type':'gbdt',
'objective': 'binary',
'num_leaves': 31,
'learning_rate': 0.05,
'max_depth': -1,
'subsample': 0.8,
'bagging_fraction' : 1,
'max_bin' : 50 ,
'bagging_freq': 20,
'colsample_bytree': 0.6,
'metric': 'binary',
'min_split_gain': 0.5,
'min_child_weight': 1,
'min_child_samples': 2,
'scale_pos... | Titanic - Machine Learning from Disaster |
14,414,602 | pd.DataFrame(np.dot(np.array(ymean.avgPrice ).reshape(-1,1), np.array(mmean.avgPrice ).reshape(1,-1)))/(traingb.avgPrice.mean() **2 )<prepare_x_and_y> | feature_score = pd.DataFrame(train.columns, columns = ['feature'])
feature_score['LGB'] = modelL.feature_importance() | Titanic - Machine Learning from Disaster |
14,414,602 | def clustertechniques2(dtrain,label,indexv):
print('
cols=[ci for ci in dtrain.columns if ci not in [indexv,'index',label]]
dtest=dtrain[dtrain[label].isnull() ==True][[indexv,label]]
print(dtest)
print('encodings after shape',dtrain.shape)
X_train=dtrain[dtrain[label].isnull() ==False].drop([indexv,label],axis=1 ).f... | y_preds_lgb = modelL.predict(test, num_iteration=modelL.best_iteration ) | Titanic - Machine Learning from Disaster |
14,414,602 | train=pd.read_csv('.. /input/utkml/train_final.csv')
test=pd.read_csv('.. /input/utkml/test_final.csv')
total=train.append(test,ignore_index=True)
<sort_values> | data_tr = xgb.DMatrix(Xtrain, label=Ztrain)
data_cv = xgb.DMatrix(Xval , label=Zval)
data_train = xgb.DMatrix(train)
data_test = xgb.DMatrix(test)
evallist = [(data_tr, 'train'),(data_cv, 'valid')] | Titanic - Machine Learning from Disaster |
14,414,602 | total.sort_values('user_id' )<feature_engineering> | parms = {'max_depth':5,
'objective':'reg:logistic',
'eval_metric':'error',
'learning_rate':0.01,
'subsample':0.8,
'colsample_bylevel':0.9,
'min_child_weight': 2,
'seed': 0}
modelx = xgb.train(parms, data_tr, num_boost_round=2000, evals = evallist,
early_stopping_rounds=300, maximize=False,
verbose_eval=100)
print('sco... | Titanic - Machine Learning from Disaster |
14,414,602 | datacol=total[['user_id','JOKE:5']]
datacol.columns=['user_id','rating']
datacol['item_id']=0
data=datacol.dropna()
for ci in range(2,141):
colnm=train.columns[ci]
datacol=total[['user_id',colnm]]
datacol.columns=['user_id','rating']
datacol['item_id']=ci-1
data=data.append(datacol.dropna())
data
datacoo=coo_matrix(( ... | feature_score['XGB'] = feature_score['feature'].map(modelx.get_score(importance_type='weight')) | Titanic - Machine Learning from Disaster |
14,414,602 | ratings=datacoo
TFIDFRecommender, bm25_weight)
log = logging.getLogger("implicit")
<choose_model_class> | y_preds_xgb = modelx.predict(data_test ) | Titanic - Machine Learning from Disaster |
14,414,602 | start = time.time()
output_filename='output.txt'
model_name='bpr'
min_rating=-10.0,
titles=train.columns[1:]
ratings.data[ratings.data < min_rating] = 0
ratings.eliminate_zeros()
ratings.data = np.ones(len(ratings.data))
log.info("read data file in %s", time.time() - start)
if model_name == "als":
model = AlternatingL... | Scaler_train = preprocessing.MinMaxScaler().fit(train)
train = pd.DataFrame(Scaler_train.transform(train), columns=train.columns, index=train.index)
test = pd.DataFrame(Scaler_train.transform(test), columns=test.columns, index=test.index ) | Titanic - Machine Learning from Disaster |
14,414,602 | for xi in range(10):
recommendations = model.recommend(xi, user_items)
print('USER',xi,train.iloc[xi].sort_values(ascending=False)[:3])
for ri,prob in recommendations:
print('recommended ',ri,titles[ri],prob)
<categorify> | linreg = LinearRegression()
linreg.fit(train, target ) | Titanic - Machine Learning from Disaster |
14,414,602 | test['predictions']='np.nan'
for xi in range(len(train),len(total)) :
testxi=xi-len(train)
testuserid=test.iloc[testxi]['user_id']
recommendations = model.recommend(testuserid, user_items)
test.iat[testxi,141]=titles[recommendations[0][0]]
if xi/1000==int(xi/1000):
print('USER',testxi,total.iloc[xi].sort_values(ascen... | eli5.show_weights(linreg ) | Titanic - Machine Learning from Disaster |
14,414,602 | test[['user_id','predictions']].to_csv('submit.csv',index=False )<load_from_csv> | coeff_linreg["LinRegress"] = coeff_linreg["LinRegress"].abs()
feature_score = pd.merge(feature_score, coeff_linreg, on='feature')
feature_score = feature_score.fillna(0)
feature_score = feature_score.set_index('feature')
feature_score | Titanic - Machine Learning from Disaster |
14,414,602 | train=pd.read_csv('.. /input/utkml/train_final.csv')
test=pd.read_csv('.. /input/utkml/test_final.csv')
total=train.append(test,ignore_index=True)
<sort_values> | y_preds_linreg = linreg.predict(test ) | Titanic - Machine Learning from Disaster |
14,414,602 | total.sort_values('user_id' )<feature_engineering> | feature_score = pd.DataFrame(
preprocessing.MinMaxScaler().fit_transform(feature_score),
columns=feature_score.columns,
index=feature_score.index
)
feature_score['Mean'] = feature_score.mean(axis=1 ) | Titanic - Machine Learning from Disaster |
14,414,602 | datacol=total[['user_id','JOKE:5']]
datacol.columns=['user_id','rating']
datacol['item_id']=0
data=datacol.dropna()
for ci in range(2,141):
colnm=train.columns[ci]
datacol=total[['user_id',colnm]]
datacol.columns=['user_id','rating']
datacol['item_id']=ci-1
data=data.append(datacol.dropna())
data
datacoo=coo_matrix(( ... | w_lgb = 0.4
w_xgb = 0.5
w_linreg = 1 - w_lgb - w_xgb
w_linreg
feature_score['Merging'] = w_lgb*feature_score['LGB'] + w_xgb*feature_score['XGB'] + w_linreg*feature_score['LinRegress']
feature_score.sort_values('Merging', ascending=False ) | Titanic - Machine Learning from Disaster |
14,414,602 | ratings=datacoo
TFIDFRecommender, bm25_weight)
log = logging.getLogger("implicit")
<choose_model_class> | def features_selection_by_weights(df, threshold):
features_list = df.feature.tolist()
features_best = []
for i in range(len(df)) :
feature_name = features_list[i]
feature_is_best = False
for col in feature_score_columns:
if df.loc[i, col] > threshold:
feature_is_best = True
if feature_is_best:
features_best.append(feat... | Titanic - Machine Learning from Disaster |
14,414,602 | start = time.time()
output_filename='output.txt'
model_name='bpr'
min_rating=-10.0,
titles=train.columns[1:]
ratings.data[ratings.data < min_rating] = 0
ratings.eliminate_zeros()
ratings.data = np.ones(len(ratings.data))
log.info("read data file in %s", time.time() - start)
if model_name == "als":
model = AlternatingL... | threshold_fi = 0.25
feature_score_best = features_selection_by_weights(feature_score, threshold_fi)
feature_score_best | Titanic - Machine Learning from Disaster |
14,414,602 | for xi in range(10):
recommendations = model.recommend(xi, user_items)
print('USER',xi,train.iloc[xi].sort_values(ascending=False)[:3])
for ri,prob in recommendations:
print('recommended ',ri,titles[ri],prob)
<categorify> | y_preds = w_lgb*y_preds_lgb + w_xgb*y_preds_xgb + w_linreg*y_preds_linreg
submission['Survived'] = [1 if x>0.5 else 0 for x in y_preds]
submission.head() | Titanic - Machine Learning from Disaster |
14,414,602 | test['predictions']='np.nan'
for xi in range(len(train),len(total)) :
testxi=xi-len(train)
testuserid=test.iloc[testxi]['user_id']
recommendations = model.recommend(testuserid, user_items)
test.iat[testxi,141]=titles[recommendations[0][0]]
if xi/1000==int(xi/1000):
print('USER',testxi,total.iloc[xi].sort_values(ascen... | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,414,602 | <categorify><EOS> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,398,634 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
14,398,634 | class ParaphraseClassifier(nn.Module):
def __init__(self,hidden_dim,embedding_dim):
super(ParaphraseClassifier, self ).__init__()
self.hidden_dim = hidden_dim
self.embedding_dim = embedding_dim
self.embedding = nn.Embedding(len(TEXT.vocab), embedding_dim)
self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=1,bid... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
14,398,634 | pc = ParaphraseClassifier(150,30)
pc.run_train(df_train,df_dev,50 )<load_from_csv> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,398,634 | df_test = TabularDataset(".. /input/SICK_test.txt","tsv",skip_header=True,\
fields=[('idx',INTEGER),('sentA',TEXT),('sentB',TEXT)])
pc.run_test(df_test,'submission.csv',useGPU=True )<define_variables> | train_data[train_data['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
14,398,634 | device = torch.device('cuda:0')
train_path = ".. /input/train/train/"
test_path = ".. /input/test/test/"
print(torch.cuda.get_device_name(0))<categorify> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,398,634 | class HindiDataset(Dataset):
def __init__(self, train_img_path, test_img_path, transform = None, train = True):
self.train_img_path = train_img_path
self.test_img_path = test_img_path
self.train_img_files = os.listdir(train_img_path)
self.test_img_files = os.listdir(test_img_path)
self.transform = transform
self.trai... | train_data[train_data['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
14,398,634 | class BasicBlock(nn.Module):
def __init__(self, channels = 256, stride = 1, padding = 1):
super(BasicBlock, self ).__init__()
self.channels = channels
self.stride = stride
self.padding = padding
self.conv_1 = nn.Conv2d(in_channels = self.channels, out_channels = self.channels,
kernel_size = 3, stride = self.stride, pad... | train_data[train_data['Ticket'] == '113572'] | Titanic - Machine Learning from Disaster |
14,398,634 | class ModInception(nn.Module):
def __init__(self, channels = 256, stride = 1, padding = 1):
super(ModInception, self ).__init__()
self.channels = channels
self.stride = stride
self.padding = padding
self.conv_1 = nn.Conv2d(in_channels = self.channels, out_channels = 70, kernel_size = 1,
stride = self.stride, padding = ... | Titanic - Machine Learning from Disaster | |
14,398,634 | class ResNet(nn.Module):
def __init__(self, block, incp_block):
super(ResNet, self ).__init__()
self.block = block
self.incp_block = incp_block
self.input_conv = nn.Sequential(
nn.Conv2d(in_channels = 3, out_channels = 64, kernel_size = 3, padding = 1),
nn.BatchNorm2d(64),
nn.PReLU() ,
nn.Conv2d(in_channels = 64, out_... | train_data['Age'] = train_data['Age'].fillna(train_data.groupby(['Pclass','Sex','Survived'])['Age'].transform('median'))
test_data['Age'] = test_data['Age'].fillna(test_data.groupby(['Pclass','Sex'])['Age'].transform('median')) | Titanic - Machine Learning from Disaster |
14,398,634 | data = HindiDataset(train_path, test_path, transform = transforms.Compose([transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
]),
train = True)
train_size = int(0.9 * len(data))
test_size = len(data)- train_size
train_data, validation_data = random_split(data, [train_size, test... | train_data['IsChild'] = np.where(train_data['Age'] <= 10, 'Yes', 'No')
test_data['IsChild'] = np.where(test_data['Age'] <= 10, 'Yes', 'No' ) | Titanic - Machine Learning from Disaster |
14,398,634 | deepNet = ResNet(BasicBlock, ModInception ).to(device)
cnn_ce_loss = nn.CrossEntropyLoss()
cnnet_optim = optim.Adam(deepNet.parameters() , lr = 0.0002, weight_decay=0 )<feature_engineering> | train_data = train_data[train_data['Ticket'] != '113572'] | Titanic - Machine Learning from Disaster |
14,398,634 | def get_accuracy(output, label, batch_size):
label = label.detach().cpu().numpy().squeeze()
output = output.detach().cpu()
_, indices = torch.max(output, dim=1)
output = torch.zeros_like(output)
itr = iter(indices)
for i in range(output.shape[0]):
output[i, int(next(itr)) ] = 1
label = torch.tensor(np.eye(10)[label]... | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch", "Age"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFr... | Titanic - Machine Learning from Disaster |
14,556,854 | epochs = 85
Costs = []
Accuracy = []
deepNet = deepNet.train()
for epoch in range(epochs):
acc = 0
count = 0
for i, batch in enumerate(train_loader):
count += 1
images, label = batch
images = images.to(device)
label['Vowel'] = label['Vowel'].to(device ).long()
label['Consonant'] = label['Consonant'].to(device ).long()... | %matplotlib inline | Titanic - Machine Learning from Disaster |
14,556,854 | deepNet = deepNet.eval()
count = 0
acc = 0
for i, batch in enumerate(validation_loader):
count += 1
images, label = batch
images = images.to(device)
label['Vowel'] = label['Vowel'].to(device ).long()
label['Consonant'] = label['Consonant'].to(device ).long()
out_1, out_2 = deepNet(images)
out_1, out_2 = F.log_softmax... | train= pd.read_csv('/kaggle/input/titanic/train.csv' ) | Titanic - Machine Learning from Disaster |
14,556,854 | test_data = HindiDataset(train_path, test_path, transform = transforms.Compose([transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
train = False)
testset = DataLoader(test_data, batch_size = 32, shuffle = False )<find_best_params> | def impute_age(cols):
Age = cols[0]
Pclass = cols[1]
if pd.isnull(Age):
if Pclass==1:
return 37
elif Pclass == 2:
return 29
else :
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
14,556,854 | preds = {}
img_ids = []
F_results = []
deepNet = deepNet.eval()
for i, batch in enumerate(testset):
images, img_names = batch
images = images.to(device)
out_1, out_2 = deepNet(images)
out_1, out_2 = F.log_softmax(out_1, dim = 1), F.log_softmax(out_2, dim = 1)
out_1, out_2 = torch.max(out_1, dim=1)[1].cpu() , torch.m... | train['Age']=train[['Age','Pclass']].apply(impute_age,axis = 1 ) | 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.