kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,587,551 | criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model_ft.parameters() , lr=0.00001,momentum=0.9 )<load_pretrained> | lbl = LabelEncoder()
train['Sex'] = lbl.fit_transform(train[['Sex']].values.ravel())
test['Sex'] = lbl.fit_transform(test[['Sex']].values.ravel() ) | Titanic - Machine Learning from Disaster |
13,587,551 | model_ft_wts=torch.load("best_model_resnext_16d_2048_1024_dropout_0.5_b.pkl" )<load_from_disk> | lbl2 = LabelEncoder()
train['Name'] = lbl2.fit_transform(train[['Name']].values.ravel())
test['Name'] = lbl2.fit_transform(test[['Name']].values.ravel() ) | Titanic - Machine Learning from Disaster |
13,587,551 | model_ft.load_state_dict(model_ft_wts )<find_best_params> | Titanic - Machine Learning from Disaster | |
13,587,551 | best_acc=0.84516
best_model_wts = copy.deepcopy(model_ft.state_dict() )<train_model> | train['Embarked'] = train['Embarked'].fillna(value=train['Embarked'].mode() [0])
test['Embarked'] = test['Embarked'].fillna(value=test['Embarked'].mode() [0])
| Titanic - Machine Learning from Disaster |
13,587,551 | num_epochs=0
for epoch in range(num_epochs):
print("Epoch : "+str(epoch))
print("-"*10)
running_loss = 0.0
running_corrects=0
wrong=0
model_ft.train()
for inp,labels in train_loader:
inp=inp.to(device)
labels=labels.to(device)
optimizer.zero_grad()
with torch.set_grad_enabled(True):
outputs = model_ft(inp)
loss = c... | train_ds = train[features+target]
test_ds = test[features] | Titanic - Machine Learning from Disaster |
13,587,551 | model_ft.load_state_dict(best_model_wts )<find_best_params> | Titanic - Machine Learning from Disaster | |
13,587,551 | if True:
correct=0
wrong=0
model_ft.eval()
for inp,labels in acc_loader:
inp=inp.to(device)
labels=labels.to(device)
optimizer.zero_grad()
with torch.no_grad() :
outputs = model_ft(inp)
_, preds = torch.max(outputs.data, 1)
correct += torch.sum(preds == labels)
wrong += torch.sum(preds != labels)
acc =(correct.fl... | Titanic - Machine Learning from Disaster | |
13,587,551 | submission = pd.read_csv('.. /input/sample_sub.csv')
submission.head()<load_from_csv> | torch.manual_seed(7 ) | Titanic - Machine Learning from Disaster |
13,587,551 | testset = ImageDataset(csv_file = '.. /input/sample_sub.csv', root_dir = '.. /input/data/data/', transform=transform_raw)
testloader = torch.utils.data.DataLoader(testset, batch_size=300, shuffle=False, num_workers=4)
res_predict=[]<find_best_params> | class Titanicnn(nn.Module):
def __init__(self,in_size,hidden_size1,hidden_size2,hidden_size3,hidden_size4,num_classes):
super().__init__()
self.linear1 = nn.Linear(in_size, hidden_size1)
self.linear2 = nn.Linear(hidden_size1, hidden_size2)
self.linear3 = nn.Linear(hidden_size2,hidden_size3)
self.linear4 = nn.Linear(... | Titanic - Machine Learning from Disaster |
13,587,551 | model_ft.eval()
for inp,label in testloader:
inp = inp.to(device)
label = label.to(device)
optimizer.zero_grad()
with torch.no_grad() :
outputs = model_ft(inp)
_, preds = torch.max(outputs.data, 1)
for i in range(len(preds)) :
res_predict.append(int(preds[i]))
submission['Category'] = res_predict<save_to_csv> | def accuracy(outputs, labels):
_, preds = torch.max(outputs, dim=1)
return torch.tensor(torch.sum(preds == labels ).item() / len(preds))
return preds | Titanic - Machine Learning from Disaster |
13,587,551 | submission.to_csv('submission.csv', index=False, encoding='utf-8' )<set_options> | input_size = train_ds.shape[1] -1
hidden_size1 = 128
hidden_size2 = 1024
hidden_size3 = 512
hidden_size4 = 128
num_classes = 2 | Titanic - Machine Learning from Disaster |
13,587,551 | %matplotlib inline<load_from_csv> | model = Titanicnn(input_size, hidden_size1=hidden_size1, hidden_size2= hidden_size2,hidden_size3 = hidden_size3,hidden_size4 = hidden_size4,num_classes = num_classes)
model | Titanic - Machine Learning from Disaster |
13,587,551 | df = pd.read_csv('.. /input/train.csv')
df.head()<load_from_csv> | def convert_to_tensors(ds, valid_size = 0.30,train_set=True):
scaler = StandardScaler()
batch_size = ds.shape[0]
if(train_set == True):
targets_t = ds.Survived.values
features_t = ds.drop(labels = ['Survived'],axis = 1 ).values
features_t = scaler.fit_transform(features_t)
targetsTrain = torch.from_numpy(targets_t ).t... | Titanic - Machine Learning from Disaster |
13,587,551 | class ImageDataset(Dataset):
def __init__(self, csv_file, root_dir, transform=None):
self.data_frame = pd.read_csv(csv_file)
self.root_dir = root_dir
self.transform = transform
def __len__(self):
return len(self.data_frame)
def __getitem__(self, idx):
img_name = os.path.join(self.root_dir, self.data_frame['Id'][idx... | train_loader,valid_loader = convert_to_tensors(train_ds ) | Titanic - Machine Learning from Disaster |
13,587,551 | for i in range(len(trainset)) :
sample = trainset[i]
print(i, sample[0].size() , " | Label: ", sample[1])
if i == 9:
break<train_model> | for data, labels in train_loader:
outputs = model(data)
print(labels.shape)
loss = F.cross_entropy(outputs, labels)
acc = accuracy(outputs,labels)
print('Loss:', loss.item())
print('Initial Acc:',float(acc),"%")
break
print('outputs.shape : ', outputs.shape)
print('Sample outputs :
', outputs[:5].data)
print('S... | Titanic - Machine Learning from Disaster |
13,587,551 | train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available.Training on CPU...')
else:
print('CUDA is available! Training on GPU...' )<choose_model_class> | torch.cuda.is_available() | Titanic - Machine Learning from Disaster |
13,587,551 |
dir(models)
model=models.resnext101_32x8d(pretrained=True)
model<find_best_params> | def get_default_device() :
if torch.cuda.is_available() :
return torch.device('cuda')
else:
return torch.device('cpu' ) | Titanic - Machine Learning from Disaster |
13,587,551 | for param in model.parameters() :
param.requires_grad = False<choose_model_class> | def to_device(data,device):
if isinstance(data,(list,tuple)) :
return [to_device(x,device)for x in data]
return data.to(device,non_blocking = True ) | Titanic - Machine Learning from Disaster |
13,587,551 | model.fc = nn.Sequential(
nn.Linear(2048, 512),
nn.ReLU() ,
nn.Dropout(0.05),
nn.Linear(512,67),
)
model.cuda()
model<choose_model_class> | for xd, yd in train_loader:
print(xd.shape)
xds = to_device(xd, device)
print(xds.device)
break | Titanic - Machine Learning from Disaster |
13,587,551 | criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.fc.parameters() , lr=3e-4 )<train_model> | class DeviceDataLoader() :
def __init__(self, ds, device):
self.ds = ds
self.device = device
def __iter__(self):
for d in self.ds:
yield to_device(d,self.device)
def __len__(self):
return len(self.ds ) | Titanic - Machine Learning from Disaster |
13,587,551 | total_params = sum(p.numel() for p in model.parameters())
print(f'{total_params:,} total parameters.')
total_trainable_params = sum(
p.numel() for p in model.parameters() if p.requires_grad)
print(f'{total_trainable_params:,} training parameters.' )<find_best_params> | train_loader = DeviceDataLoader(train_loader, device)
valid_loader = DeviceDataLoader(valid_loader, device ) | Titanic - Machine Learning from Disaster |
13,587,551 | epochs=4
iter=0
for epoch in range(epochs):
for i,(images,labels)in enumerate(trainloader):
images=Variable(images.cuda())
labels=Variable(labels.cuda())
optimizer.zero_grad()
outputs=model(images)
loss=criterion(outputs, labels)
loss.backward()
optimizer.step()
iter+=1
if iter%500==0:
correct=0
total=0
for images,... | for xd, yd in valid_loader:
print('xd.device:', xd.device)
print('yd:', yd)
break | Titanic - Machine Learning from Disaster |
13,587,551 | for param in model.layer4.parameters() :
param.requires_grad = True<choose_model_class> | def evaluate(model, valid_loader):
outputs = [model.validation_step(batch)for batch in valid_loader]
return model.validation_epoch_end(outputs ) | Titanic - Machine Learning from Disaster |
13,587,551 | criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters() , lr=2e-4 )<train_model> | def fit(epochs, lr, model, train_loader, valid_loader, opt_func = torch.optim.SGD):
history = []
optimizer = opt_func(model.parameters() ,lr)
for epoch in tqdm(range(epochs)) :
for batch in train_loader:
loss = model.training_step(batch)
loss.backward()
optimizer.step()
optimizer.zero_grad()
result = evaluate(model,v... | Titanic - Machine Learning from Disaster |
13,587,551 | total_params = sum(p.numel() for p in model.parameters())
print(f'{total_params:,} total parameters.')
total_trainable_params = sum(
p.numel() for p in model.parameters() if p.requires_grad)
print(f'{total_trainable_params:,} training parameters.' )<find_best_params> | model = Titanicnn(input_size,hidden_size1=hidden_size1, hidden_size2= hidden_size2, hidden_size3= hidden_size3,hidden_size4 = hidden_size4,num_classes = num_classes)
to_device(model, device ) | Titanic - Machine Learning from Disaster |
13,587,551 | for param in model.layer3.parameters() :
param.requires_grad = True<choose_model_class> | history = [evaluate(model,valid_loader)]
history | Titanic - Machine Learning from Disaster |
13,587,551 | criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters() , lr=1e-4 )<train_model> | history += fit(20, 0.2, model, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
13,587,551 | total_params = sum(p.numel() for p in model.parameters())
print(f'{total_params:,} total parameters.')
total_trainable_params = sum(
p.numel() for p in model.parameters() if p.requires_grad)
print(f'{total_trainable_params:,} training parameters.' )<create_dataframe> | history += fit(40, 0.001, model, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
13,587,551 | test_transforms = transforms.Compose([transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])])
testset = ImageDataset(csv_file = '.. /input/sample_sub.csv', root_dir = '.. /input/data/data/', transform=test_transforms)
testloader ... | history += fit(100, 0.01, model, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
13,587,551 | submission = pd.read_csv('.. /input/sample_sub.csv')
submission.head()<save_to_csv> | history += fit(300, 0.01, model, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
13,587,551 |
submission.to_csv('submission.csv', index=False, encoding='utf-8')
<set_options> | history += fit(30, 0.001, model, train_loader, valid_loader ) | Titanic - Machine Learning from Disaster |
13,587,551 | %matplotlib inline
<load_from_csv> | test_loader = convert_to_tensors(test_ds,train_set= False ) | Titanic - Machine Learning from Disaster |
13,587,551 | df = pd.read_csv('.. /input/train.csv')
df.head()<load_from_csv> | def predict(pred_x,model):
for pred in pred_x:
y = model(pred)
_, y_ = torch.max(y, dim=1)
return y_ | Titanic - Machine Learning from Disaster |
13,587,551 | class ImageDataset(Dataset):
def __init__(self, csv_file, root_dir, transform=None):
self.data_frame = pd.read_csv(csv_file)
self.root_dir = root_dir
self.transform = transform
def __len__(self):
return len(self.data_frame)
def __getitem__(self, idx):
img_name = os.path.join(self.root_dir, self.data_frame['Id'][idx... | test_loader_gpu = DeviceDataLoader(test_loader, device ) | Titanic - Machine Learning from Disaster |
13,587,551 | normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transform = transforms.Compose([transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip() ,
transforms.ToTensor() ,
normalize
])
trainset = ImageDataset(csv_file = '.. /input/train.csv', root_dir = '.. /input/data/data/... | test_preds = predict(test_loader_gpu,model ) | Titanic - Machine Learning from Disaster |
13,587,551 |
<define_variables> | passId = test[['PassengerId']].values | Titanic - Machine Learning from Disaster |
13,587,551 | for i in range(len(trainset)) :
sample = trainset[i]
print(i, sample[0].size() , " | Label: ", sample[1])
if i == 9:
break<train_model> | final_pred = final_pred.data.numpy() | Titanic - Machine Learning from Disaster |
13,587,551 | train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available.Training on CPU...')
else:
print('CUDA is available! Training on GPU...' )<choose_model_class> | sub = {'PassengerId':passId.ravel() , 'Survived':final_pred} | Titanic - Machine Learning from Disaster |
13,587,551 |
<choose_model_class> | submission_csv = pd.DataFrame(sub ) | Titanic - Machine Learning from Disaster |
13,587,551 | criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters() ,lr=0.00007)
if train_on_gpu:
criterion = criterion.cuda()
<find_best_params> | submission_csv.to_csv('final_sub_titanic_pth.csv',index=False ) | Titanic - Machine Learning from Disaster |
13,587,551 | epochs = 14
iter=0
for epoch in range(epochs):
for i,(images, labels)in enumerate(trainloader):
if train_on_gpu:
images = Variable(images.cuda())
labels = Variable(labels.cuda())
else:
images = Variable(images)
labels = Variable(labels)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels... | x = pd.read_csv("./final_sub_titanic_pth.csv" ) | Titanic - Machine Learning from Disaster |
13,587,551 | model.eval()
<load_from_csv> | filename = "./titanic_pytorch.pth" | Titanic - Machine Learning from Disaster |
13,587,551 | submission = pd.read_csv('.. /input/sample_sub.csv')
submission.head()<load_from_csv> | torch.save(model.state_dict() ,filename ) | Titanic - Machine Learning from Disaster |
13,587,551 | <find_best_params><EOS> | loaded_model = Titanicnn(input_size,hidden_size1=hidden_size1, hidden_size2= hidden_size2, hidden_size3= hidden_size3,hidden_size4 = hidden_size4,num_classes = num_classes)
to_device(model, device)
loaded_model.load_state_dict(torch.load(filename))
loaded_model.eval() | Titanic - Machine Learning from Disaster |
13,261,128 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_output> | sns.set()
%matplotlib inline | Titanic - Machine Learning from Disaster |
13,261,128 | predictions = []
for data, target in testloader:
if train_on_gpu:
data, target = data.cuda() , target.cuda()
output = model(data)
_, pred = torch.max(output, 1)
for i in range(len(pred)) :
predictions.append(int(pred[i]))
submission['Category'] = predictions
<save_to_csv> | train_data = pd.read_csv('train_prep.csv')
test_data = pd.read_csv('test_prep.csv')
train_data.columns | Titanic - Machine Learning from Disaster |
13,261,128 | submission.to_csv('submission.csv', index=False, encoding='utf-8')
<train_model> | train_data.set_index('PassengerId',inplace = True)
test_data.set_index('PassengerId',inplace = True ) | Titanic - Machine Learning from Disaster |
13,261,128 | X_train = np.load(input_dir + 'X_train.npy')
X_test = np.load(input_dir + 'X_test.npy')
y_train = np.load(input_dir + 'y_train.npy')
print("X_train shape :",X_train.shape)
print("X_test shape :",X_test.shape)
print("y_train shape :",y_train.shape )<save_to_csv> | all_data = pd.concat([train_data,test_data] ) | Titanic - Machine Learning from Disaster |
13,261,128 | pred = pd.DataFrame()
pred['Id'] = np.arange(X_test.shape[0])
pred['Prediction'] = np.zeros(X_test.shape[0],dtype = np.int)
pred.to_csv('pred.csv',index=False)
pred.head()<set_options> | label = LabelEncoder() | Titanic - Machine Learning from Disaster |
13,261,128 | warnings.filterwarnings('ignore')
np.seed = 1324
sns.set(style="white")
%matplotlib inline
<import_modules> | all_data['FareBin_Code'] = label.fit_transform(all_data['FareBin'])
all_data['AgeBin_Code'] = label.fit_transform(all_data['AgeBin'] ) | Titanic - Machine Learning from Disaster |
13,261,128 | import cv2
import sys
import os
import keras<import_modules> | all_data.drop(columns=['AgeBin'],inplace=True)
all_data.drop(columns=['FareBin'],inplace=True ) | Titanic - Machine Learning from Disaster |
13,261,128 | from keras.models import Sequential
from keras import layers
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import SpatialDropout2D
from keras.layers import Dropout
from keras.layers import Activation, BatchNormaliz... | for i in range(1,len(all_data)+1):
all_data.loc[i,'Srate']=0.5 | Titanic - Machine Learning from Disaster |
13,261,128 | def submit_file(y_pred, filename):
submit = pd.Series(y_pred.reshape(y_pred.shape[0]), name='target' ).replace({0: 'Bird', 1: 'Airplane'})
submit.to_csv(filename +'.csv', index_label='id', header=True)
print('file created' )<categorify> | for i in range(1,len(all_data)+1):
number = all_data.loc[i,'TicketNumber']
group = all_data.loc[i,'TicketGroup']
if group>1:
max = all_data.drop(i)[all_data.drop(i)['TicketNumber']==number]['Survived'].max()
if not pd.isna(max):
all_data.loc[i,'Srate']=all_data.drop(i)[all_data.drop(i)['TicketNumber']==number]['Survive... | Titanic - Machine Learning from Disaster |
13,261,128 | def flip_image(array, show=False):
image_obj = Image.fromarray(array.astype('uint8'))
rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)
flipped_array = np.array(rotated_image, dtype=np.int)
if show:
plt.imshow(flipped_array)
return flipped_array
def contrast_image(array, c_level=4.0, show=False):
image_... | train_data = all_data[:891]
test_data = all_data[891:] | Titanic - Machine Learning from Disaster |
13,261,128 | train_x = pd.read_csv('.. /input/train_x.csv', index_col=0, header=None)
train_y = pd.read_csv('.. /input/train_y.csv', index_col=0)
test_x = pd.read_csv('.. /input/test_x.csv', index_col=0, header=None )<categorify> | numerical = ["Pclass","Age","SibSp","Parch","Fare","TicketGroup","FamilySize","FareBin_Code","AgeBin_Code","Srate","TicketNumber"]
categorical = ["Embarked","Title","Sex"]
all_features = numerical + categorical | Titanic - Machine Learning from Disaster |
13,261,128 | train_y.replace(['Bird', 'Airplane'], [0,1], inplace=True)
X = train_x.values.reshape(7200, 32, 32, 3)
X_test = test_x.values.reshape(4800, 32, 32, 3)
y_train = train_y.values
<compute_test_metric> | from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import OrdinalEncoder
from sklearn.model_selection import Gr... | Titanic - Machine Learning from Disaster |
13,261,128 | viz_img(X[100], y_train[100] )<compute_test_metric> | y = train_data['Survived']
X = train_data.drop(columns = ['Survived'] ) | Titanic - Machine Learning from Disaster |
13,261,128 | viz_img(X[452], y_train[452] )<split> | log_reg = LogisticRegression(C=1.9 ) | Titanic - Machine Learning from Disaster |
13,261,128 | X = X.astype('float32')
X_test = X_test.astype('float32')
x_train, x_test, y_train, y_test = train_test_split(X, y_train, test_size=0.3, random_state=12000 )<compute_test_metric> | num_att_LR = ["Pclass","Age","TicketNumber","SibSp","Parch","Srate","Fare"]
cat_att1_LR = ["Sex"]
cat_att2_LR = ["Title"]
drop_att_LR = list(set(all_features)- set(num_att_LR+cat_att1_LR+cat_att2_LR))
full_pipline_LR = ColumnTransformer([
("toDrop",'drop',drop_att_LR),
("numerical",StandardScaler() ,num_att_LR),
("c... | Titanic - Machine Learning from Disaster |
13,261,128 | mean = np.mean(x_train, axis=(0,1,2,3))
std = np.std(x_train,axis=(0,1,2,3))
x_train =(x_train-mean)/(std + 1e-7)
x_test =(x_test-mean)/(std + 1e-7)
X_test =(X_test-mean)/(std + 1e-7 )<choose_model_class> | X_prep = full_pipline_LR.fit_transform(X)
cross_val_score(log_reg,X_prep,y,cv=10,scoring='roc_auc' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | weight_decay = 1e-4
model = Sequential()
model.add(Conv2D(32,(3,3), padding='same', kernel_regularizer=regularizers.l2(weight_decay),
input_shape=x_train.shape[1:]))
model.add(Activation('elu'))
model.add(BatchNormalization())
model.add(Conv2D(32,(3,3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))... | cat_bayes = CategoricalNB(alpha=0.05 ) | Titanic - Machine Learning from Disaster |
13,261,128 | datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
)
datagen.fit(x_train )<train_model> | num_att_NB = ["FareBin_Code","AgeBin_Code"]
cat_att_NB = ["Title"]
drop_att_NB = list(set(all_features)- set(num_att_NB+cat_att_NB))
full_pipline_NB = ColumnTransformer([
("cat",OrdinalEncoder() ,cat_att_NB),
("num",'passthrough',num_att_NB),
("drop",'drop',drop_att_NB)
] ) | Titanic - Machine Learning from Disaster |
13,261,128 | batch_size = 64
opt_rms = keras.optimizers.rmsprop(lr=0.001,decay=1e-6)
model.compile(loss='binary_crossentropy', optimizer=opt_rms, metrics=['accuracy'])
model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=x_train.shape[0] // batch_size, epochs=125,
verbose=1,validation_data=(x... | X_prep = full_pipline_NB.fit_transform(X)
cross_val_score(cat_bayes,X_prep,y,cv=10,scoring='roc_auc' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | y_pred = model.predict_classes(X_test )<set_options> | from sklearn import tree | Titanic - Machine Learning from Disaster |
13,261,128 | warnings.filterwarnings('ignore')
sns.set()
%config InlineBackend.figure_format = 'svg'
print(os.listdir('.. /input/'))<load_from_csv> | num_att_DT =["Pclass","FamilySize","Srate","AgeBin_Code","FareBin_Code"]
cat_att_DT = ["Sex"]
drop_att_DT = list(set(all_features)- set(num_att_DT + cat_att_DT))
full_pipline_DT = ColumnTransformer([
("droping",'drop',drop_att_DT),
("num",'passthrough',num_att_DT),
("cat",OrdinalEncoder() ,cat_att_DT),
] ) | Titanic - Machine Learning from Disaster |
13,261,128 | df = pd.read_csv('.. /input/train.csv')
df.head()<load_from_csv> | X_prep = full_pipline_DT.fit_transform(X ) | Titanic - Machine Learning from Disaster |
13,261,128 | test_df = pd.read_csv('.. /input/test.csv' )<feature_engineering> | criterion = ["gini", "entropy"]
max_depth = list(range(1,12,1))
max_features = [1,2,3,4,5,6]
splitter = ["best","random"]
min_samples_split = [2,3]
hyperparams = {'criterion': criterion, 'max_depth': max_depth, 'max_features': max_features,
'splitter': splitter, 'min_samples_split': min_samples_split}
gd = GridSearchCV... | Titanic - Machine Learning from Disaster |
13,261,128 | df['char_count'] = df['review'].apply(len)
df['word_count'] = df['review'].apply(lambda x: len(x.split()))
df['word_density'] = df['char_count'] /(df['word_count']+1)
df['punctuation_count'] = df['review'].apply(lambda x: len("".join(_ for _ in x if _ in string.punctuation)) )<split> | gd.fit(X_prep, y)
print(gd.best_score_)
print(gd.best_estimator_ ) | Titanic - Machine Learning from Disaster |
13,261,128 | X_train, X_val, y_train, y_val = train_test_split(df['review'], df['sentiment'], test_size=0.3,
random_state=17 )<feature_engineering> | DT_clf = tree.DecisionTreeClassifier(criterion='entropy', max_depth=5, max_features=6,
random_state=1, splitter='random' ) | Titanic - Machine Learning from Disaster |
13,261,128 | tfidf_vect = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', max_features=5000)
tfidf_vect.fit(df['review'])
xtrain_tfidf = tfidf_vect.transform(X_train)
xvalid_tfidf = tfidf_vect.transform(X_val)
tfidf_vect_ngram = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', ngram_range=(2,3), max_features=... | svm_clf = LinearSVC(C=0.1, loss = 'hinge', max_iter=100000, random_state=1, ) | Titanic - Machine Learning from Disaster |
13,261,128 | count_vect = CountVectorizer(analyzer='word', token_pattern=r'\w{1,}')
count_vect.fit(df['review'])
xtrain_count = count_vect.transform(X_train)
xvalid_count = count_vect.transform(X_val)
xtest_count = count_vect.transform(test_df['review'] )<choose_model_class> | num_att_SVM = numerical
cat_att1_SVM = ["Sex"]
cat_att2_SVM = ["Title"]
drop_att_SVM = list(set(all_features)- set(num_att_SVM + cat_att1_SVM+cat_att2_SVM))
full_pipline_SVM = ColumnTransformer([
("drop",'drop',drop_att_SVM),
("cat",OrdinalEncoder() ,cat_att1_SVM),
("num",StandardScaler() ,num_att_SVM),
("cat2",One... | Titanic - Machine Learning from Disaster |
13,261,128 | model1 = linear_model.LogisticRegression()
model1.fit(xtrain_count, y_train)
accuracy=model1.score(xvalid_count, y_val)
print('Accuracy Count LR:', accuracy)
test_pred1=model1.predict(xtest_count)
model2 = linear_model.LogisticRegression()
model2.fit(xtrain_tfidf, y_train)
accuracy=model2.score(xvalid_tfidf, y_val... | X_prep = full_pipline_SVM.fit_transform(X)
cross_val_score(svm_clf,X_prep,y,cv=10,scoring='roc_auc' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | final_pred = np.array([])
for i in range(0,len(test_df['review'])) :
final_pred = np.append(final_pred, np.argmax(np.bincount([test_pred1[i], test_pred2[i], test_pred3[i]])) )<create_dataframe> | LR_pipe = Pipeline([('logReg pipline', full_pipline_LR),
('log_reg', log_reg)])
cross_val_score(LR_pipe,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | sub_df = pd.DataFrame()
sub_df['Id'] = test_df['Id']
sub_df['sentiment'] = [int(i)for i in final_pred]<save_to_csv> | NB_pipe = Pipeline([('NaiveBayes pipline', full_pipline_NB),
('cat_bayes', cat_bayes)])
cross_val_score(NB_pipe,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | sub_df.to_csv('my_submission.csv', index=False )<import_modules> | DT_pipe = Pipeline([('DecisionTree pipline', full_pipline_DT),
('Decision Tree', DT_clf)])
cross_val_score(DT_pipe,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | random_seed = 1213
np.random.seed(random_seed)
<load_from_csv> | SVM_pipe = Pipeline([('SVM pipline', full_pipline_SVM),
('SVM', svm_clf)])
cross_val_score(SVM_pipe,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | train = pd.read_csv('.. /input/ciproject/persianMNIST_train.csv')
test = pd.read_csv('.. /input/ciproject/persianMNIST_test.csv')
Y = train['0']
X = train.drop(labels="0", axis=1)
X = X.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1)
X_train, X_val, Y_train, Y_val = train_test_split(X, Y, t... | voting_clf_4 = VotingClassifier(
estimators = [('Logistic Regresion',LR_pipe),('SVM',SVM_pipe),('Naive Bayes',NB_pipe),('Decision Tree',DT_pipe)],
voting = 'hard'
)
cross_val_score(voting_clf_4,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | learning_rate_reduction = ReduceLROnPlateau(monitor = 'val_acc',
patience = 3,
verbose = 1,
factor = 0.5,
min_lr = 0.0001)
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=15)
def new_model(hidden=512, learning_rate=0.00128):
INPUT = Input(( 28, 28, 1))
inputs = Conv2D(64,(7, 7), activation='rel... | voting_clf_SVM_DT = VotingClassifier(
estimators = [('SVM',SVM_pipe),('Decision Tree',DT_pipe)],
voting = 'hard'
)
cross_val_score(voting_clf_SVM_DT,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | datagen = ImageDataGenerator(featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=5,
zoom_range=0.05,
shear_range=0.02,
width_shift_range=0.05,
height_shift_range=0.05,
horizontal_flip=False,
vertical_flip=False )... | voting_clf_NB_DT = VotingClassifier(
estimators = [('Naive Bayes',NB_pipe),('Decision Tree',DT_pipe)],
voting = 'hard'
)
cross_val_score(voting_clf_NB_DT,X,y,cv=10,scoring='accuracy' ).mean() | Titanic - Machine Learning from Disaster |
13,261,128 | epochs = 200
batch_size = 128
print("Learning Properties: Epoch:%i \t Batch Size:%i" %(epochs, batch_size))
predict_accumulator = np.zeros(model.predict(test ).shape)
accumulated_history = []
for i in range(1, 6):
X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.20, random_state=random_seed*i)
mode... | X_test = test_data.drop(columns=['Survived'] ) | Titanic - Machine Learning from Disaster |
13,261,128 | print("Completed Training.")
results = np.argmax(predict_accumulator, axis=1)
results = pd.Series(results, name="result")
print("Saving prediction to output...")
submission = pd.concat([pd.Series(range(0, test.shape[0]), name="ids"), results], axis=1)
submission.to_csv('prediction.csv', index=False )<import_module... | voting_clf_NB_DT.fit(X,y ) | Titanic - Machine Learning from Disaster |
13,261,128 | import numpy as np
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.utils import np_utils
from skimage.transform import rescale
from sklearn import preprocessing
from keras.models import load_model
from kera... | predictions = voting_clf_NB_DT.predict(X_test)
predictions = pd.to_numeric(predictions, downcast='integer')
output = pd.DataFrame({'PassengerId': list(X_test.index), 'Survived': predictions} ) | Titanic - Machine Learning from Disaster |
13,261,128 | img_rows = 40
img_cols = 40<load_from_csv> | output.to_csv('Submission_NB_DT.csv', index=False ) | Titanic - Machine Learning from Disaster |
13,482,615 |
<categorify> | train=pd.read_csv(".. /input/titanic/train.csv")
test=pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
13,482,615 | encoder = preprocessing.LabelEncoder()
encoder.fit(np.load(".. /input/tmpfory/trainY.npy"))<load_pretrained> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
13,482,615 | T = np.load(".. /input/inputtestdata40x40/testT.npy" )<choose_model_class> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
13,482,615 | model = Sequential()
model.add(Conv2D(64, kernel_size = 3, activation='relu', input_shape =(img_rows, img_cols, 1)))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size = 3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size = 5, strides=2, padding='same', activation='r... | train.drop(columns=['PassengerId','Name','Ticket','Cabin'],inplace=True)
test.drop(columns=['PassengerId','Name','Ticket','Cabin'],inplace=True)
| Titanic - Machine Learning from Disaster |
13,482,615 | datagen = ImageDataGenerator(
rotation_range=8,
zoom_range = 0.10,
width_shift_range=0.1,
height_shift_range=0.1 )<choose_model_class> | train.drop(columns=['SibSp','Parch'],inplace=True)
test.drop(columns=['SibSp','Parch'],inplace=True)
| Titanic - Machine Learning from Disaster |
13,482,615 | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x )<categorify> | a=train.groupby('Pclass' ).median() ['Age'].iloc[0]
b=train.groupby('Pclass' ).median() ['Age'].iloc[1]
c=train.groupby('Pclass' ).median() ['Age'].iloc[2]
def fillAge_train(x):
age=x[0]
pclass=x[1]
if pd.isnull(age):
if pclass==1:
return a
elif pclass==2:
return b
else:
return c
else:
return age
a_test=test.groupby('P... | Titanic - Machine Learning from Disaster |
13,482,615 | X_train2 = np.load(".. /input/rescalinginputdata/X_train2.npy")
X_val2 = np.load(".. /input/rescalinginputdata/X_val2.npy")
Y_train2 = np_utils.to_categorical(encoder.transform(np.load(".. /input/rescalinginputdata/Y_train2.npy")))
Y_val2 = np_utils.to_categorical(encoder.transform(np.load(".. /input/rescalinginputd... | a=test.groupby('Pclass' ).median() ['Fare'].iloc[0]
b=test.groupby('Pclass' ).median() ['Fare'].iloc[1]
c=test.groupby('Pclass' ).median() ['Fare'].iloc[2]
def fillFare(x):
fare=x[0]
pclass=x[1]
if pd.isnull(fare):
if pclass==1:
return a
elif pclass==2:
return b
else:
return c
else:
return fare
test['Fare']=test[['Fare... | Titanic - Machine Learning from Disaster |
13,482,615 | history = model.fit_generator(datagen.flow(X_train2,Y_train2, batch_size=64),
epochs = 18, steps_per_epoch = X_train2.shape[0]//64,
validation_data =(X_val2,Y_val2), callbacks=[annealer], verbose=0, initial_epoch=0 )<save_to_csv> | train['Embarked'].fillna(train['Embarked'].mode() [0], inplace=True ) | Titanic - Machine Learning from Disaster |
13,482,615 | history = history.history
file = open('info.csv', 'w')
file.write(str(history))
file.close()<predict_on_test> | train=pd.get_dummies(train,columns=['Sex','Embarked','TravelAlone'],drop_first=True)
test=pd.get_dummies(test,columns=['Sex','Embarked','TravelAlone'],drop_first=True)
| Titanic - Machine Learning from Disaster |
13,482,615 | predictions = model.predict(T)
predictions = np.argmax(predictions, axis=1)
res = encoder.inverse_transform(predictions )<save_to_csv> | train['AgeCateg'] = pd.cut(train['Age'], 5)
train[['AgeCateg', 'Survived']].groupby(['AgeCateg'], as_index=False ).mean().sort_values(by='AgeCateg', ascending=True)
train['FareCateg'] = pd.qcut(train['Fare'], 4)
train[['FareCateg', 'Survived']].groupby(['FareCateg'], as_index=False ).mean().sort_values(by='FareCateg... | Titanic - Machine Learning from Disaster |
13,482,615 | file = open('ansEpochs.csv', 'w')
file.write('Id,Category
')
for i in range(res.size):
file.write('' + str(i + 1)+ ',' + str(res[i])+ '
')
file.close()<categorify> | X = train.drop('Survived',axis=1)
y = train['Survived'] | Titanic - Machine Learning from Disaster |
13,482,615 | def Education_to_numeric(bp):
if bp == 'Bachelors ':
return 4
if bp == 'Partial College':
return 3
if bp == 'High School':
return 2
if bp == 'Graduate Degree':
return 1
if bp == 'Partial High School':
return 0
edu=train_data.Education
edut=test_data.Education
edupp = edu.apply(Education_to_numeric)
edud = edut.apply(E... | np.random.seed(0)
X_train,X_test,y_train,y_test = train_test_split(X,y, test_size=0.3 ) | Titanic - Machine Learning from Disaster |
13,482,615 | train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)
xgb = XGBClassifier(n_estimators=380, learning_rate=0.049, random_state=1,min_child_weight=6)
training_start = time.perf_counter()
xgb.fit(train_X, train_y)
training_end = time.perf_counter()
prediction_start = time.perf_counter()
preds = xgb.pr... | from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
from sklearn.metrics import accuracy_score,confusion_matrix
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.linear_model import LogisticRegressio... | Titanic - Machine Learning from Disaster |
13,482,615 | !pip install --upgrade efficientnet tensorflow_addons tensorflow<import_modules> | xgbclassifier=XGBClassifier()
xgbclassifier.fit(X_train,y_train)
pred_xgb=xgbclassifier.predict(X_test)
| Titanic - Machine Learning from Disaster |
13,482,615 | import math
import re
import random
import os
import tensorflow as tf
import tensorflow_addons as tfa
import numpy as np
import tensorflow.keras.backend as K
import efficientnet.tfkeras as efn
import efficientnet
import itertools
import matplotlib
import scipy
import pandas as pd
import sklearn
from matplotlib import p... | randomfc = RandomForestClassifier(n_estimators=100)
randomfc.fit(X_train,y_train)
pred_rf=randomfc.predict(X_test)
| Titanic - Machine Learning from Disaster |
13,482,615 | print(f'Numpy version : {np.__version__}')
print(f'Tensorflow version : {tf.__version__}')
print(f'Tensorflow Addons version : {tfa.__version__}')
print(f'EfficientNet(library)version : {efficientnet.__version__}')
print(f'Matplotlib version : {matplotlib.__version__}')
print(f'Scipy version : {scipy.__version__}'... | lightgb=LGBMClassifier()
lightgb.fit(X_train,y_train)
pred_lgb=lightgb.predict(X_test)
| Titanic - Machine Learning from Disaster |
13,482,615 | !pip freeze > requirements.txt<feature_engineering> | ada=AdaBoostClassifier(n_estimators=50,learning_rate=1)
ada.fit(X_train,y_train)
pred_ada=ada.predict(X_test)
| 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.