kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,773,137 | temp_data1=std_data
pca.n_components=450
pca_data=pca.fit_transform(temp_data1)
pca_data_new=np.vstack(( pca_data1.T,label)).T
new_data=pca_data<import_modules> | logreg = LogisticRegression()
logreg.fit(x_train, y_train)
y_pred = logreg.predict(x_val)
acc_logreg = round(accuracy_score(y_pred, y_val)*100, 2)
acc_logreg | Titanic - Machine Learning from Disaster |
13,773,137 | from sklearn.model_selection import RandomizedSearchCV
from sklearn.model_selection import cross_val_score,cross_val_predict
from sklearn.metrics import accuracy_score,confusion_matrix,classification_report
from scipy.stats import uniform,truncnorm,randint<compute_train_metric> | svc = SVC()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_val)
acc_svc = round(accuracy_score(y_pred, y_val)*100, 2)
acc_svc | Titanic - Machine Learning from Disaster |
13,773,137 | clf=LogisticRegression(multi_class='multinomial',n_jobs=-1)
cv_scores=cross_val_score(clf,new_data,label,cv=10)
print(f'we can expect accuracy between {cv_scores.min() } and {cv_scores.max() } with avg accuracy of {cv_scores.mean() }' )<compute_train_metric> | linear_svc = LinearSVC()
linear_svc.fit(x_train, y_train)
y_pred = linear_svc.predict(x_val)
acc_linear_svc = round(accuracy_score(y_pred, y_val)*100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
13,773,137 | class_pred=cross_val_predict(clf,new_data,label,cv=10)
accLR=accuracy_score(label,class_pred)
print(f'accuracy of our model is {accLR}')
print(f' confusion matrix is ')
print(confusion_matrix(label,class_pred))
print(f'classification report is ')
print(classification_report(label,class_pred))<compute_train_metric> | perceptron = Perceptron()
perceptron.fit(x_train, y_train)
y_pred = perceptron.predict(x_val)
acc_perceptron = round(accuracy_score(y_pred, y_val)*100, 2)
acc_perceptron | Titanic - Machine Learning from Disaster |
13,773,137 | for kernel in('poly','rbf'):
clf=svm.SVC(kernel=kernel)
cv_scores=cross_val_score(clf,new_data,label,n_jobs=-1,cv=10)
print(f'accuracy of {kernel} kernel varies between {cv_scores.min() } and {cv_scores.max() } with mean {cv_scores.mean() }')
<find_best_params> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(x_train, y_train)
y_pred = decision_tree.predict(x_val)
acc_decision_tree = round(accuracy_score(y_pred, y_val)*100 ,2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
13,773,137 | for C in(1,10,100):
clf=svm.SVC(kernel='rbf',C=C)
cv_scores=cross_val_score(clf,new_data,label,n_jobs=-1,cv=10)
print(f'accuracy of rbf kernel with C={C} varies between {cv_scores.min() } and {cv_scores.max() } with mean {cv_scores.mean() }')
<find_best_params> | random_forest = RandomForestClassifier()
random_forest.fit(x_train, y_train)
y_pred = random_forest.predict(x_val)
acc_random_forest = round(accuracy_score(y_pred, y_val)*100, 2)
acc_random_forest | Titanic - Machine Learning from Disaster |
13,773,137 | for gamma in(0.001,0.01):
clf=svm.SVC(kernel='rbf',C=10,gamma=gamma)
cv_scores=cross_val_score(clf,new_data,label,n_jobs=-1,cv=10)
print(f'accuracy of rbf kernel with C=10 and gamma={gamma} varies between {cv_scores.min() } and {cv_scores.max() } with mean {cv_scores.mean() }')
<compute_train_metric> | knn = KNeighborsClassifier()
knn.fit(x_train, y_train)
y_pred = knn.predict(x_val)
acc_knn = round(accuracy_score(y_pred, y_val)*100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
13,773,137 | clf=svm.SVC(kernel='rbf',C=10,gamma=0.001)
cv_scores=cross_val_score(clf,new_data,label,n_jobs=-1,cv=10)
print(f'accuracy of rbf kernel with C=10 and gamma= 0.001 varies between {cv_scores.min() } and {cv_scores.max() } with mean {cv_scores.mean() }' )<compute_train_metric> | gbc = GradientBoostingClassifier()
gbc.fit(x_train, y_train)
y_pred = gbc.predict(x_val)
acc_gbc = round(accuracy_score(y_pred, y_val)*100, 2)
acc_gbc | Titanic - Machine Learning from Disaster |
13,773,137 | class_pred=cross_val_predict(clf,new_data,label,cv=10)
accSVM=accuracy_score(label,class_pred)
print(f'accuracy of our model is {accSVM}')
print(f' confusion matrix is ')
print(confusion_matrix(label,class_pred))
print(f'classification report is ')
print(classification_report(label,class_pred))<compute_train_metri... | ada = AdaBoostClassifier()
ada.fit(x_train, y_train)
y_pred = ada.predict(x_val)
acc_ada = round(accuracy_score(y_pred, y_val)*100, 2)
acc_ada | Titanic - Machine Learning from Disaster |
13,773,137 | clf=KNeighborsClassifier(n_neighbors=5,n_jobs=-1)
cv_score=cross_val_score(clf,new_data,label,cv=10)
print(f' we can expect accuracy bwetween {cv_score.min() } and {cv_score.max() } with a mean of {cv_score.mean() }')
<compute_train_metric> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron', 'Linear SVC',
'Decision Tree', 'Gradient Boosting Classifier', 'AdaBoost Classifier'],
'Score': [acc_svc, acc_knn, acc_logreg,
acc_random_forest, acc_gaussian, acc_perceptron,acc_line... | Titanic - Machine Learning from Disaster |
13,773,137 | <compute_train_metric><EOS> | ids = test['PassengerId']
predictions = ada.predict(test.drop('PassengerId', axis=1))
output = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions })
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,773,786 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | Image(".. /input/negotiation/negotiation.jpg" ) | Titanic - Machine Learning from Disaster |
13,773,786 | clf=DecisionTreeClassifier(max_depth=best_n,random_state=0)
clf.fit(new_data,label )<save_to_csv> | from sklearn.ensemble import ExtraTreesClassifier
import seaborn as sns
import pandas as pd
import numpy as np
import os
from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
13,773,786 | cn=['0','1','2','3','4','5','6','7','8','9']
dot_data = tree.export_graphviz(clf, out_file=None,
class_names=cn,
filled=True)
graph = graphviz.Source(dot_data,format="png")
graph
<compute_train_metric> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
union = [train, test]
passenger_id = [] | Titanic - Machine Learning from Disaster |
13,773,786 | class_pred=cross_val_predict(clf,new_data,label,cv=10)
accDT=accuracy_score(label,class_pred)
print(f'accuracy of our model is {accDT}')
print(f' confusion matrix is ')
print(confusion_matrix(label,class_pred))
print(f'classification report is ')
print(classification_report(label,class_pred))<compute_train_metric> | for i, df in enumerate(union):
name = df['Name'].str.split('.', n=1, expand = True)
name = name[1].str.split(expand = True)[0]
name.replace(['(\() ','(\)) '],'',regex=True, inplace = True)
df['Name'] = name
del name
mean_age = df[['Name','Age']].groupby(['Name'] ).mean()
df = df.merge(mean_age, on='Name')
df['Age'] ... | Titanic - Machine Learning from Disaster |
13,773,786 | clf=RandomForestClassifier(n_estimators=600,max_depth=best_n,random_state=0,n_jobs=-1)
cv_score=cross_val_score(clf,new_data,label,cv=10,scoring='accuracy',n_jobs=-1)
print(f' with {best_n} as depth of trees and {600} as no of trees we can expect accuracy bwetween {cv_score.min() } and {cv_score.max() } with a mean o... | x_train = union[0].drop("Survived", axis=1)
y_train = union[0]["Survived"]
x_test = union[1]
x_train.shape, y_train.shape, x_test.shape | Titanic - Machine Learning from Disaster |
13,773,786 | class_pred=cross_val_predict(clf,new_data,label,cv=10)
accRF=accuracy_score(label,class_pred)
print(f'accuracy of our model is {accRF}')
print(f' confusion matrix is ')
print(confusion_matrix(label,class_pred))
print(f'classification report is ')
print(classification_report(label,class_pred))<import_modules> | ex = ExtraTreesClassifier(random_state = 6, bootstrap=True, oob_score=True)
ex.fit(x_train, y_train)
y_pred = ex.predict(x_test)
ex.score(x_train, y_train)
score = round(ex.score(x_train, y_train)* 100, 2)
print('Extremely Randomized Trees', score ) | Titanic - Machine Learning from Disaster |
13,773,786 | import tensorflow as tf
import keras
from keras import backend as k
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Activation, BatchNormalization
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator
from keras.utils i... | for i,j in enumerate(x_train.head(1)) :
print('%s: %s' %(j, int(ex.feature_importances_[i]*100)) + '%' ) | Titanic - Machine Learning from Disaster |
13,773,786 | test_x=test<define_variables> | submission = pd.DataFrame({
"PassengerId": passenger_id[1],
"Survived": y_pred
})
submission.to_csv('/kaggle/working/submission.csv', index=False)
| Titanic - Machine Learning from Disaster |
13,756,684 | img_cols=28
img_rows=28<prepare_x_and_y> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.prepr... | Titanic - Machine Learning from Disaster |
13,756,684 | if k.image_data_format=='channels_first':
train_x = train_x.values.reshape(train_x.shape[0], 1,img_cols,img_rows)
test = test.values.reshape(test.shape[0], 1,img_cols,img_rows)
train_x=train_x/255.0
test=test/255.0
input_shape =(1,img_cols,img_rows)
else:
train_x=train_x.values.reshape(train_x.shape[0],img_cols,img_... | df_train = pd.read_csv(".. /input/titanic/train.csv")
df_test = pd.read_csv(".. /input/titanic/test.csv")
df_train.head() | Titanic - Machine Learning from Disaster |
13,756,684 | earlystopping = EarlyStopping(monitor ="val_accuracy",
mode = 'auto', patience = 10,
restore_best_weights = True)
modelacc = []
nfilters = [32, 64, 128,256]
conv_layers = [1, 2, 3,4]
dense_layers = [0, 1, 2,3]
dp=0.5
for filters in nfilters:
for conv_layer in conv_layers:
for dense_layer in dense_layers:
cnnsays = 'No... | df_train = df_train.drop(["Name","PassengerId","Ticket","Cabin"],axis=1)
df_test = df_test.drop(["Name","Ticket","Cabin"],axis=1)
df_train.info() | Titanic - Machine Learning from Disaster |
13,756,684 | print("Highest Validation Accuracy so far : {}%".format(round(100*max(history.history['val_accuracy']), 2)) )<sort_values> | df_test.isna().sum() | Titanic - Machine Learning from Disaster |
13,756,684 | modelacc.sort(reverse=True)
modelacc<predict_on_test> | df_train.isna().sum() | Titanic - Machine Learning from Disaster |
13,756,684 | pred=model.predict([test])
soln=[]
for i in range(len(pred)) :
soln.append(np.argmax(pred[i]))<save_to_csv> | df_train.Age.fillna(df_train.Age.mean() ,inplace = True)
df_test.Age.fillna(df_test.Age.mean() ,inplace = True)
df_test.Fare.fillna(df_test["Fare"].mean() ,inplace = True)
df_train.dropna(axis=0,inplace = True)
df_train.head() | Titanic - Machine Learning from Disaster |
13,756,684 | final = pd.DataFrame()
final['ImageId']=[i+1 for i in test_x.index]
final['Label']=soln
final.to_csv('mnistcnn.csv', index=False )<set_options> | le = LabelEncoder()
df_train.Sex = le.fit_transform(df_train.Sex)
df_test.Sex = le.fit_transform(df_test.Sex ) | Titanic - Machine Learning from Disaster |
13,756,684 | %matplotlib inline
if torch.cuda.is_available() :
torch.backends.cudnn.deterministic = True<load_from_csv> | embarked_column_train = pd.get_dummies(df_train["Embarked"])
embarked_column_test = pd.get_dummies(df_test["Embarked"])
df_test.drop(["Embarked"],axis=1,inplace = True)
df_train.drop(["Embarked"],axis=1,inplace = True)
df_train = pd.concat([df_train,embarked_column_train],axis=1)
df_test= pd.concat([df_test,embark... | Titanic - Machine Learning from Disaster |
13,756,684 | train_df = pd.read_csv(".. /input/digit-recognizer/train.csv")
test_df = pd.read_csv(".. /input/digit-recognizer/test.csv" )<filter> | y = df_train.iloc[:,0]
X = df_train.iloc[:,1:] | Titanic - Machine Learning from Disaster |
13,756,684 | train_df.iloc[:,1:]<create_dataframe> | X_train,X_valid,y_train,y_valid = train_test_split(X,y,test_size = 0.3,random_state = 42 ) | Titanic - Machine Learning from Disaster |
13,756,684 | class MNISTDataset(Dataset):
def __init__(self, dataframe,
transform = transforms.Compose([transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=(0.5,), std=(0.5,)) ])
):
df = dataframe
self.n_pixels = 784
if len(df.columns)== self.n_pixels:
self.X = df.values.reshape(( -1,28,28)).astype(np.uint... | name = []
metric = []
def trainModel(alg,X_train,y_train,X_valid,y_valid):
model = alg().fit(X_train,y_train)
y_pred = model.predict(X_valid)
name.append(alg.__name__)
metric.append(accuracy_score(y_valid,y_pred))
print(alg.__name__ , " Accuracy ", accuracy_score(y_valid,y_pred)) | Titanic - Machine Learning from Disaster |
13,756,684 | class MNISTResNet(ResNet):
def __init__(self):
super().__init__(BasicBlock, [2, 2, 2, 2], num_classes=10)
self.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=1, padding=3,bias=False)
model = MNISTResNet()
print(model )<train_on_grid> | models = [RandomForestClassifier,GradientBoostingClassifier,DecisionTreeClassifier,SVC,XGBClassifier]
for i in models:
trainModel(i,X_train,y_train,X_valid,y_valid ) | Titanic - Machine Learning from Disaster |
13,756,684 | def train(train_loader, model, criterion, optimizer, epoch):
model.train()
loss_train = 0
for batch_idx,(data, target)in enumerate(train_loader):
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
output = model(data)
loss = criterion(output, target)
optimizer.zero_grad()
loss.backward()
optimiz... | status = pd.DataFrame({"name" : name,
"training_metric" :metric
})
status | Titanic - Machine Learning from Disaster |
13,756,684 | def validate(val_loader, model, criterion):
model.eval()
loss = 0
correct = 0
for _,(data, target)in enumerate(val_loader):
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
output = model(data)
loss += criterion(output, target ).data.item()
pred = output.data.max(1, keepdim=True)[1]
correct += ... | Gradient_boosting = GradientBoostingClassifier().fit(X,y ) | Titanic - Machine Learning from Disaster |
13,756,684 | train_transforms = transforms.Compose(
[transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=(0.5,), std=(0.5,)) ])
val_test_transforms = transforms.Compose(
[transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=(0.5,), std=(0.5,)) ] )<choose_model_class> | sub = pd.DataFrame({"PassengerId":df_test.PassengerId, "Survived":Gradient_boosting.predict(df_test.drop("PassengerId", axis = 1)) })
sub.to_csv("submission.csv", index = None ) | Titanic - Machine Learning from Disaster |
13,875,924 | total_epoches = 20
step_size = 5
base_lr = 0.01
batch_size = 64
optimizer = optim.Adam(model.parameters() , lr=base_lr)
criterion = nn.CrossEntropyLoss()
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=0.1)
if torch.cuda.is_available() :
model = model.cuda()
criterion = criterion.cuda()<c... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
13,875,924 | def split_dataframe(dataframe=None, fraction=0.9, rand_seed=1):
df_1 = dataframe.sample(frac=fraction, random_state=rand_seed)
df_2 = dataframe.drop(df_1.index)
return df_1, df_2<train_model> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,875,924 | for epoch in range(total_epoches):
print("
Train Epoch {}: lr = {}".format(epoch, exp_lr_scheduler.get_lr() [0]))
train_df_new, val_df = split_dataframe(dataframe=train_df, fraction=0.9, rand_seed=epoch)
train_dataset = MNISTDataset(train_df_new, transform=train_transforms)
val_dataset = MNISTDataset(val_df, transfor... | def fill_age_random(df, age_column):
if age_column+"_filled" not in df:
df.insert(( df.columns.get_loc(age_column)+1), age_column+"_filled", df[age_column])
keys = []
values = []
for key, value in df[age_column].value_counts().items() :
keys.append(key)
values.append(value)
indices = [idx for idx, b in enumerate(d... | Titanic - Machine Learning from Disaster |
13,875,924 | def prediciton(test_loader, model):
model.eval()
test_pred = torch.LongTensor()
for i, data in enumerate(test_loader):
if torch.cuda.is_available() :
data = data.cuda()
output = model(data)
pred = output.cpu().data.max(1, keepdim=True)[1]
test_pred = torch.cat(( test_pred, pred), dim=0)
return test_pred<create_datafr... | fill_age_random(test_data, "Age")
test_data.info() | Titanic - Machine Learning from Disaster |
13,875,924 | <save_to_csv><EOS> | y_train = train_data["Survived"]
train_data["Sex_cat"] = train_data["Sex"].astype("category")
train_data["Sex_code"] = train_data["Sex_cat"].cat.codes
test_data["Sex_cat"] = test_data["Sex"].astype("category")
test_data["Sex_code"] = test_data["Sex_cat"].cat.codes
features = ["Pclass", "Sex_code", "Age_filled"]
X_tes... | Titanic - Machine Learning from Disaster |
13,964,502 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing
from sklearn.model_selection import GridSearchCV,StratifiedKFold,cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from skle... | Titanic - Machine Learning from Disaster |
13,964,502 | test_pred_df.to_csv('submission.csv', index=False )<import_modules> | sns.set(rc={'figure.figsize':(8,6)})
sns.set_style("darkgrid" ) | Titanic - Machine Learning from Disaster |
13,964,502 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
13,964,502 | CFG = {
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 512,
'valid_bs': 16,
'device': 'cuda' if torch.cuda.is_available() else 'cpu'
}<load_from_csv> | test_ids = test['PassengerId'] | Titanic - Machine Learning from Disaster |
13,964,502 | df = pd.read_csv('/kaggle/input/cassava-leaf-disease-classification/sample_submission.csv')
df_torch = df.copy()
df_tf = df.copy()
<define_variables> | rng = np.random.RandomState(42)
clf = IsolationForest(max_samples=100, random_state=rng,contamination = 0.05)
clf.fit(train[["Age","SibSp","Parch","Fare"]].dropna())
prediction = clf.predict(train[["Age","SibSp","Parch","Fare"]].dropna())
df_outliers = train[["Age","SibSp","Parch","Fare"]].dropna()
df_outliers['Out... | Titanic - Machine Learning from Disaster |
13,964,502 | PATH = '/kaggle/input/cassava-leaf-disease-classification/test_images/'<choose_model_class> | df = pd.concat(objs=[train, test], axis=0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
13,964,502 | class CassavaImageClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.... | df.isnull().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | class DiseaseDatasetInference(torch.utils.data.Dataset):
def __init__(self, df, transform=None, opt_label=True):
self.df = df.reset_index(drop=True ).copy()
self.transform = transform
self.opt_label = opt_label
if self.opt_label:
self.data = [(row['image_id'], row['label'])for _, row in self.df.iterrows() ]
else:
self.... | df["Fare"].isnull().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | trained_model = torch.load('/kaggle/input/cassava-effecientnet-b3/model_6.pt', map_location=torch.device(CFG['device']))<load_from_csv> | df["Fare"].fillna(df["Fare"].median() ,inplace=True ) | Titanic - Machine Learning from Disaster |
13,964,502 | test_csv = df.copy()
test_csv['image_id'] = PATH + test_csv['image_id']
test_ds = DiseaseDatasetInference(test_csv, transform=get_inference_transforms() , opt_label=False)
test_loader = torch.utils.data.DataLoader(test_ds, batch_size=CFG['valid_bs'], shuffle=False, pin_memory=False )<concatenate> | df["Fare"] = np.log(df["Fare"] ).replace(-np.inf, 0 ) | Titanic - Machine Learning from Disaster |
13,964,502 | torch_outcomes = pd.concat([df_torch['image_id'], pd.DataFrame(preds_torch)], axis=1 ).sort_values(['image_id'] )<import_modules> | df["Embarked"].isnull().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | import tensorflow as tf
import pandas as pd
import numpy as np
import os
from PIL import Image<load_pretrained> | df["Embarked"] = df["Embarked"].fillna("S" ) | Titanic - Machine Learning from Disaster |
13,964,502 | model = tf.keras.models.load_model('/kaggle/input/plantdiseaseresnet50/resnet50.h5' )<concatenate> | df.isna().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | tf_outcomes = pd.concat([pd.DataFrame(test_images, columns=['image_id']), pd.DataFrame(preds_tf)], axis=1 ).sort_values(['image_id'] )<data_type_conversions> | df["Sex"] = df["Sex"].map({"male": 0, "female":1} ) | Titanic - Machine Learning from Disaster |
13,964,502 | final_preds =(torch_outcomes.drop('image_id', axis=1)*0.7 + tf_outcomes.drop('image_id', axis=1)*0.3 ).to_numpy().argmax(1 )<save_to_csv> | ages=[]
for i in range(1,4):
ages.append(((df[df['Pclass'] == i].Age ).median()))
for index, row in df.iterrows() :
if(np.isnan(row['Age'])) :
df.loc[index,'Age'] = ages[row['Pclass'] - 1] | Titanic - Machine Learning from Disaster |
13,964,502 | submit = pd.DataFrame({'image_id': torch_outcomes['image_id'].values, 'label': final_preds})
submit.to_csv('submission.csv', index=False )<install_modules> | df.isna().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | !pip install.. /input/easydict/easydict-1.9-py2.py3-none-any.whl
<set_options> | df["Cabin"].isnull().sum() | Titanic - Machine Learning from Disaster |
13,964,502 | sys.path.insert(1, '.. /input/snapmix/')
def set_env(seed=0):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
def predict(model,testloader,midlevel=False):
model.eval()
time_start = time.time()
pbar = tqdm(testloader, dynamic_ncols=True,... | for index,row in df.iterrows() :
if "nan" != str(df.loc[index,"Cabin"]):
df.loc[index,"Cabin"] = df.loc[index,"Cabin"][0]
else:
df.loc[index,"Cabin"] = "X" | Titanic - Machine Learning from Disaster |
13,964,502 | set_env(seed=0)
foldid = 2
conf = edict({
'depth':50,
'pretrained':True,
'num_class':5,
'midlevel':False,
'datadir':'.. /input/cassava-leaf-disease-classification',
'dataset':'cassava',
'testing':False,
'tta': None,
'foldid':foldid,
'cropsize':448,
'netname':'resnet50',
'net_type':'resnet_ft',
'prams_group':['ftlayer'... | df = pd.get_dummies(df, columns = ["Cabin"],prefix="Cabin" ) | Titanic - Machine Learning from Disaster |
13,964,502 | !pip install --quiet /kaggle/input/kerasapplications
!pip install --quiet /kaggle/input/efficientnet-git<set_options> | for index, row in df.iterrows() :
df.loc[index,'Title'] = row['Name'].split(".")[0].split(", ")[1]
| Titanic - Machine Learning from Disaster |
13,964,502 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
seed = 0
seed_everything(seed)
warnings.filterwarnings('ignore' )<define_variables> | frequent_titles = ['Mr','Mrs','Miss','Master']
for index, row in df.iterrows() :
if df.loc[index,'Title'] not in frequent_titles:
df.loc[index,'Title'] = "Rare" | Titanic - Machine Learning from Disaster |
13,964,502 | BATCH_SIZE = 4 * REPLICAS
HEIGHT = 512
WIDTH = 512
CHANNELS = 3
N_CLASSES = 5
TTA_STEPS = 3<normalization> | df.drop(labels = ["Name"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
13,964,502 | def get_name(file_path):
parts = tf.strings.split(file_path, os.path.sep)
name = parts[-1]
return name
def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
return image
def center_crop(image):
image = tf.reshape(image, [600, 800, CHANNELS])
h, w... | for index,row in df.iterrows() :
if df.loc[index,"Ticket"].isdigit() :
df.loc[index,"Ticket"] = "X"
else:
df.loc[index,"Ticket"] = df.loc[index,"Ticket"].replace(".","" ).replace("/","" ).strip().split(' ')[0]
df = pd.get_dummies(df, columns = ["Ticket"], prefix="T" ) | Titanic - Machine Learning from Disaster |
13,964,502 | model_path_list = glob.glob('/kaggle/input/cassava-leaf-disease-tpu-tensorflow-training/*.h5')
model_path_list.sort()
print('Models to predict:')
print(*model_path_list, sep='
' )<train_model> | df = pd.get_dummies(df, columns = ["Pclass"],prefix="Pc")
df = pd.get_dummies(df, columns = ["Embarked"],prefix="Embarked")
df = pd.get_dummies(df, columns = ["Title"],prefix="Title")
df.drop(labels = ["PassengerId"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
13,964,502 | model_path_list_2 = glob.glob('/kaggle/input/cassava-leaf-disease-training-with-tpu-v2-pods/*.h5')
model_path_list_2.sort()
print('Models to predict:')
print(*model_path_list_2, sep='
' )<choose_model_class> | train = df[:train.shape[0]]
test = df[train.shape[0]:]
test.drop(labels=["Survived"],axis = 1,inplace=True)
Y_train = train["Survived"]
X_train = train.drop(labels = ["Survived"],axis = 1 ) | Titanic - Machine Learning from Disaster |
13,964,502 | def model_fn(input_shape, N_CLASSES):
inputs = L.Input(shape=input_shape, name='inputs')
base_model = efn.EfficientNetB3(input_tensor=inputs,
include_top=False,
weights=None,
pooling='avg')
model = tf.keras.Sequential([
base_model,
L.Dropout (.25),
L.Dense(N_CLASSES, activation='softmax', name='output')
])
return m... | random_state = 2
clf = ['SVC','RandomForest','GradientBoosting','KNeighbors','LogisticRegression']
classifiers = []
classifiers.append(SVC(random_state=random_state))
classifiers.append(RandomForestClassifier(random_state=random_state))
classifiers.append(GradientBoostingClassifier(random_state=random_state))
classifie... | Titanic - Machine Learning from Disaster |
13,964,502 | files_path = f'{database_base_path}test_images/'
test_preds = np.zeros(( len(os.listdir(files_path)) , N_CLASSES))
print('First model')
for model_path in model_path_list:
print(model_path)
K.clear_session()
model.load_weights(model_path)
if TTA_STEPS > 0:
test_ds = get_dataset(files_path, tta=True)
for step in rang... | clf_scores = []
for i in range(len(classifiers)) :
scores = cross_val_score(classifiers[i], X_train, y = Y_train, scoring = "accuracy", n_jobs=-1)
clf_scores.append([clf[i],scores.mean() ,scores.std() ] ) | Titanic - Machine Learning from Disaster |
13,964,502 | submission = pd.DataFrame({'image_id': image_names, 'label': test_preds})
submission.to_csv('submission.csv', index=False)
display(submission.head() )<install_modules> | df_scores = pd.DataFrame(clf_scores)
df_scores.columns = ['Model','Acc_Mean','Acc_Std']
df_scores | Titanic - Machine Learning from Disaster |
13,964,502 | !pip install.. /input/timm031/timm-0.3.1-py3-none-any.whl
sub = 0
if sub==0:
!pip install --upgrade pip adabound<import_modules> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001, 0.01, 0.1, 1],
'C': [1, 10, 50, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid,scoring="accuracy", n_jobs= -1, verbose = 1)
gsSVMC.fit(X_train,Y_train)
SVMC_best = gsSVMC.best_estimator_
gsSVMC.best_score_ | Titanic - Machine Learning from Disaster |
13,964,502 | import numpy as np
import pandas as pd
import timm
import os
import matplotlib.pyplot as plt
import cv2
import sys
from sklearn import model_selection, metrics
import torch
from PIL import Image
from tensorflow.keras import models, layers
from PIL import ImageEnhance, ImageOps
import pdb
import torchvision.transforms a... | GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [100,200,300],
'learning_rate': [0.1, 0.05, 0.01],
'max_depth': [4, 8],
'min_samples_leaf': [100,150],
'max_features': [0.3, 0.1]
}
gsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, scoring="accuracy", n_jobs= -1, verbose = 1... | Titanic - Machine Learning from Disaster |
13,964,502 | BASE_DIR = '.. /input/cassava-leaf-disease-classification'
TRAIN_PATH = BASE_DIR+"/train_images/"
TEST_PATH = BASE_DIR+"/test_images/"<train_model> | RFC = RandomForestClassifier()
rf_param_grid = {"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_param_grid,scoring="accuracy", n_jobs= -1, ve... | Titanic - Machine Learning from Disaster |
13,964,502 | def read_image(path,label):
image_data = cv2.imread(path)
plt.title('label:{}'.format(label))
plt.imshow(image_data)
return image_data
class CassavaDataset(torch.utils.data.Dataset):
def __init__(self, df, data_path, mode="train", transforms=None):
super().__init__()
self.df_data = df.values
self.data_path = data_p... | votingC = VotingClassifier(estimators=[('RandomForest', RFC_best),('SVC', SVMC_best),('GradientBoosting',GBC_best)], voting='soft', n_jobs=-1)
votingC = votingC.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
13,964,502 | def train(net, epoch, trainLoader, optimizer, criterion):
sum_loss = 0
total = 0
correct = 0
net.train()
for i, data in enumerate(trainLoader, 0):
length = len(data)
input, target = data
input, target = input.to(device), target.to(device)
optimizer.zero_grad()
output= net(input)
loss = criterion(output, target)
los... | predictions = pd.Series(votingC.predict(test),name="Survived")
results = pd.concat([test_ids,predictions],axis=1)
results = results.astype(int ) | Titanic - Machine Learning from Disaster |
13,964,502 | lr = 1e-4
BATCH_SIZE=8
IMG_SIZE=512
EPOCH=10
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
df = pd.read_csv(os.path.join(BASE_DIR,'train.csv'))
df.image_id = df.image_id.apply(lambda x : TRAIN_PATH+x)
LOG_FOUT = open(os.path.join('./', 'log_train.txt'), 'w')
if os.path.exists('./models')==0:
... | results.to_csv("submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
13,947,810 | def one_epoch(fold):
log_string('fold:%d, batch_size:%d,lr:%f,fold_epech:%d,device:%s' %(fold , BATCH_SIZE,lr,2,device))
folds= StratifiedKFold(n_splits=fold ).split(df['image_id'],df['label'])
acc_train_all= []
acc_valid_all= []
best_acc = 0
for i,(train_index,valid_index)in enumerate(folds):
train_df = df.loc[train_... | 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 |
13,947,810 |
<load_from_csv> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
13,947,810 | def test_one(model_name , file_name):
net = CassvaImgClassifier(model_name,5, False)
net.to(device)
net.load_state_dict(torch.load(filename ).state_dict())
net.eval()
preds = []
submit = pd.read_csv(os.path.join(BASE_DIR, "sample_submission.csv"))
for image_id in submit.image_id:
img = Image.open(BASE_DIR+"/test_ima... | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch"]
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_flat = pd.DataFram... | Titanic - Machine Learning from Disaster |
13,947,810 | file_name = ['a','b','c']
model_name = ['a','b','c']
transform1 = transforms.Compose([
transforms.CenterCrop(IMG_SIZE),
transforms.ToTensor() ,
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
all_preds = []
for i in range(3):
all_preds.append(test_one(model_name[i],file_name[i]))
submit... | y = train_data["Survived"]
bins= [0,3,13,18,45,120]
labels = ['Infant','Child','Teen','Adolt','Senior']
train_data['AgeGroup'] = pd.cut(train_data['Age'], bins=bins, labels=labels, right=False)
test_data['AgeGroup'] = pd.cut(train_data['Age'], bins=bins, labels=labels, right=False)
features = ["Pclass", "Sex", "SibSp... | Titanic - Machine Learning from Disaster |
13,947,810 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
<import_modules> | processed_train_data = train_data.dropna(subset=['Cabin'] ) | Titanic - Machine Learning from Disaster |
13,898,362 | from glob import glob
from sklearn.model_selection import GroupKFold, StratifiedKFold
import cv2
from skimage import io
import torch
from torch import nn
import os
from datetime import datetime
import time
import random
import cv2
import torchvision
from torchvision import transforms
import pandas as pd
import numpy as... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
13,898,362 | CFG = {
'fold_num': 10,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 512,
'epochs': 32,
'train_bs': 32,
'valid_bs': 32,
'lr': 0.03*1e-4,
'num_workers': 4,
'accum_iter': 2,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 1,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1],
'PseEpochs':3,
'weight_decay':1e... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
13,898,362 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train<count_values> | def fill_age_random(df, age_column):
if age_column+"_filled" not in df:
df.insert(( df.columns.get_loc(age_column)+1), age_column+"_filled", df[age_column])
keys = []
values = []
for key, value in df[age_column].value_counts().items() :
keys.append(key)
values.append(value)
indices = [idx for idx, b in enumerate(d... | Titanic - Machine Learning from Disaster |
13,898,362 | train.label.value_counts()<load_from_csv> | y_train = train_data["Survived"]
train_data["Sex_cat"] = train_data["Sex"].astype("category")
test_data["Sex_cat"] = test_data["Sex"].astype("category")
features = ["Pclass", "Sex_cat", "Age_filled"]
X_train = train_data[features].copy()
X_test = test_data[features].copy()
X_train["Sex_cat"] = train_data["Sex_cat"].c... | Titanic - Machine Learning from Disaster |
13,921,351 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<categorify> | import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd | Titanic - Machine Learning from Disaster |
13,921,351 | class CassavaDataset(Dataset):
def __init__(
self, df, data_root, transforms=None, output_label=True
):
super().__init__()
self.df = df.reset_index(drop=True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(sel... | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
train = train_data.copy()
test = test_data.copy()
| Titanic - Machine Learning from Disaster |
13,921,351 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | train.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
13,921,351 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.mod... | test.drop('PassengerId', axis = 1, inplace = True)
pred = train['Survived'] | Titanic - Machine Learning from Disaster |
13,921,351 | if __name__ == '__main__':
seed_everything(CFG['seed'])
folds = StratifiedKFold(n_splits=CFG['fold_num'] ).split(np.arange(train.shape[0]), train.label.values)
for fold,(trn_idx, val_idx)in enumerate(folds):
if fold > 0:
break
print('Inference fold {} started'.format(fold))
valid_ = train.loc[val_idx,:].reset_index(d... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | test['label'] = np.argmax(tst_preds, axis=1)
<feature_engineering> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | def rect_path(path):
return '.. /input/cassava-leaf-disease-classification/train_images/'+path
train['image_id'] = train['image_id'].apply(rect_path )<concatenate> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | train = pd.concat([train,test] ).reset_index()
train<create_dataframe> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | class CassavaPseDataset(Dataset):
def __init__(self, df, data_root,
transforms=None,
output_label=True,
one_hot_label=False,
do_fmix=False,
fmix_params={
'alpha': 1.,
'decay_power': 3.,
'shape':(CFG['img_size'], CFG['img_size']),
'max_soft': True,
'reformulate': False
},
do_cutmix=False,
cutmix_params={
'alpha': 1,
}
... | train['Age'].fillna(train['Age'].quantile(0.5), inplace = True)
test['Age'].fillna(test['Age'].quantile(0.5), inplace = True ) | Titanic - Machine Learning from Disaster |
13,921,351 | def prepare_dataloader(df, trn_idx, val_idx, data_root='.. /input/cassava-leaf-disease-classification/train_images/'):
train_ = df.loc[trn_idx,:].reset_index(drop=True)
valid_ = df.loc[val_idx,:].reset_index(drop=True)
train_ds = CassavaPseDataset(train_, data_root, transforms=get_train_transforms() , output_label=Tr... | train['Embarked'].fillna('S', inplace = True)
test['Embarked'].fillna('S', inplace = True ) | Titanic - Machine Learning from Disaster |
13,921,351 | if __name__ == '__main__':
seed_everything(CFG['seed'])
folds = StratifiedKFold(n_splits=CFG['fold_num'], shuffle=True, random_state=CFG['seed'] ).split(np.arange(train.shape[0]), train.label.values)
for fold,(trn_idx, val_idx)in enumerate(folds):
if fold>0:
break
test = pd.DataFrame()
test['image_id'] = list(os.list... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | test['label'] = np.argmax(tst_preds, axis=1)
test.head()<save_to_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | test.to_csv('submission.csv', index=False )<install_modules> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | !pip install --quiet /kaggle/input/kerasapplications
!pip install --quiet /kaggle/input/efficientnet-git<import_modules> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | print("Tensorflow version " + tf.__version__ )<define_variables> | test['Fare'].fillna(test['Fare'].quantile(0.5), inplace = True ) | Titanic - Machine Learning from Disaster |
13,921,351 | strategy = tf.distribute.get_strategy()
AUTOTUNE = tf.data.experimental.AUTOTUNE
GCS_PATH = ".. /input/cassava-leaf-disease-classification"
IMAGE_SIZE = [512, 512]
RESIZE_IMAGE_SIZE = [512, 512]
CLASSES = ['0', '1', '2', '3', '4']
WEIGHTS_PATH = ".. /input/cassava-leaf-disease-resnet-weights/EfficientNetB4-best-08-0.88... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
seed = 0
seed_everything(seed)
warnings.filterwarnings('ignore' )<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,921,351 | def decode_image(image):
image = tf.image.decode_jpeg(image, channels=3)
image = tf.cast(image, tf.float32)
image = tf.reshape(image, [*IMAGE_SIZE, 3])
return image<create_dataframe> | sex1 = pd.get_dummies(train['Sex'])
sex2 = pd.get_dummies(test['Sex'] ) | 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.