kernel_id
int64 24.2k
23.3M
| prompt
stringlengths 8
1.85M
| completetion
stringlengths 1
182k
| comp_name
stringlengths 5
57
|
|---|---|---|---|
5,644,971 |
train_data, dev_data = train_test_split(train_data, test_size=0.25 )<filter>
|
def dice_coef(y_true, y_pred, smooth=1):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return(2.* intersection + smooth)/(K.sum(y_true_f)+ K.sum(y_pred_f)+ smooth)
def dice_loss(y_true, y_pred):
smooth = 1.
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = y_true_f * y_pred_f
score =(2.* K.sum(intersection)+ smooth)/(K.sum(y_true_f)+ K.sum(y_pred_f)+ smooth)
return 1.- score
def bce_dice_loss(y_true, y_pred):
return binary_crossentropy(y_true, y_pred)+ dice_loss(y_true, y_pred )
|
Understanding Clouds from Satellite Images
|
5,644,971 |
test_data[test_data.Fare.isnull() ]<groupby>
|
class DataGenerator(keras.utils.Sequence):
'Generates data for Keras'
def __init__(self, list_IDs, df, target_df=None, mode='fit',
base_path='.. /input/understanding_cloud_organization/train_images',
batch_size=32, dim=(1400, 2100), n_channels=3, reshape=None, gamma=None,
augment=False, n_classes=4, random_state=2019, shuffle=True):
self.dim = dim
self.batch_size = batch_size
self.df = df
self.mode = mode
self.base_path = base_path
self.target_df = target_df
self.list_IDs = list_IDs
self.reshape = reshape
self.gamma = gamma
self.n_channels = n_channels
self.augment = augment
self.n_classes = n_classes
self.shuffle = shuffle
self.random_state = random_state
self.on_epoch_end()
np.random.seed(self.random_state)
def __len__(self):
'Denotes the number of batches per epoch'
return int(np.floor(len(self.list_IDs)/ self.batch_size))
def __getitem__(self, index):
'Generate one batch of data'
indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]
list_IDs_batch = [self.list_IDs[k] for k in indexes]
X = self.__generate_X(list_IDs_batch)
if self.mode == 'fit':
y = self.__generate_y(list_IDs_batch)
if self.augment:
X, y = self.__augment_batch(X, y)
return X, y
elif self.mode == 'predict':
return X
else:
raise AttributeError('The mode parameter should be set to "fit" or "predict".')
def on_epoch_end(self):
'Updates indexes after each epoch'
self.indexes = np.arange(len(self.list_IDs))
if self.shuffle == True:
np.random.seed(self.random_state)
np.random.shuffle(self.indexes)
def __generate_X(self, list_IDs_batch):
'Generates data containing batch_size samples'
if self.reshape is None:
X = np.empty(( self.batch_size, *self.dim, self.n_channels))
else:
X = np.empty(( self.batch_size, *self.reshape, self.n_channels))
for i, ID in enumerate(list_IDs_batch):
im_name = self.df['ImageId'].iloc[ID]
img_path = f"{self.base_path}/{im_name}"
img = self.__load_rgb(img_path)
if self.reshape is not None:
img = np_resize(img, self.reshape)
if self.gamma is not None:
img = adjust_gamma(img, gamma=self.gamma)
X[i,] = img
return X
def __generate_y(self, list_IDs_batch):
if self.reshape is None:
y = np.empty(( self.batch_size, *self.dim, self.n_classes), dtype=int)
else:
y = np.empty(( self.batch_size, *self.reshape, self.n_classes), dtype=int)
for i, ID in enumerate(list_IDs_batch):
im_name = self.df['ImageId'].iloc[ID]
image_df = self.target_df[self.target_df['ImageId'] == im_name]
rles = image_df['EncodedPixels'].values
if self.reshape is not None:
masks = build_masks(rles, input_shape=self.dim, reshape=self.reshape)
else:
masks = build_masks(rles, input_shape=self.dim)
y[i, ] = masks
return y
def __load_grayscale(self, img_path):
img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
img = img.astype(np.float32)/ 255.
img = np.expand_dims(img, axis=-1)
return img
def __load_rgb(self, img_path):
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = img.astype(np.float32)/ 255.
return img
def __random_transform(self, img, masks):
composition = albu.Compose([
albu.HorizontalFlip() ,
albu.VerticalFlip() ,
albu.ShiftScaleRotate(rotate_limit=30, shift_limit=0.1)
])
composed = composition(image=img, mask=masks)
aug_img = composed['image']
aug_masks = composed['mask']
return aug_img, aug_masks
def __augment_batch(self, img_batch, masks_batch):
for i in range(img_batch.shape[0]):
img_batch[i, ], masks_batch[i, ] = self.__random_transform(
img_batch[i, ], masks_batch[i, ])
return img_batch, masks_batch
|
Understanding Clouds from Satellite Images
|
5,644,971 |
test_data[["Pclass", "Fare", "Embarked"]].groupby(["Pclass", "Embarked"] ).mean()<prepare_x_and_y>
|
BATCH_SIZE = 32
train_idx, val_idx = train_test_split(
mask_count_df.index, random_state=2019, test_size=0.2
)
train_generator = DataGenerator(
train_idx,
df=mask_count_df,
target_df=train_df,
batch_size=BATCH_SIZE,
reshape=(320, 480),
gamma=0.8,
augment=True,
n_channels=3,
n_classes=4
)
val_generator = DataGenerator(
val_idx,
df=mask_count_df,
target_df=train_df,
batch_size=BATCH_SIZE,
reshape=(320, 480),
gamma=0.8,
augment=False,
n_channels=3,
n_classes=4
)
|
Understanding Clouds from Satellite Images
|
5,644,971 |
X_train = train_data.drop(["PassengerId", "Survived", "Name", "Age", "Ticket", "Cabin"], axis=1)
Y_train = train_data["Survived"]
X_dev = dev_data.drop(["PassengerId", "Survived", "Name", "Age", "Ticket", "Cabin"], axis=1)
Y_dev = dev_data["Survived"]
X_test = test_data.drop(["PassengerId", "Name", "Age", "Ticket", "Cabin"], axis=1)
X_train.shape, Y_train.shape, X_dev.shape, Y_dev.shape, X_test.shape<data_type_conversions>
|
opt = AdamAccumulate(lr=0.002, accum_iters=8)
model = sm.Unet(
'resnet18',
classes=4,
input_shape=(320, 480, 3),
activation='sigmoid'
)
model.compile(optimizer=opt, loss=bce_dice_loss, metrics=[dice_coef])
model.summary()
|
Understanding Clouds from Satellite Images
|
5,644,971 |
X_full = [X_train, X_dev, X_test]
for dataset in X_full:
dataset["Sex"] = dataset["Sex"].map({"female": "1", "male": "0"} ).astype("int")
dataset["Embarked"] = dataset["Embarked"].fillna("S" ).map({"S": "0", "C": "1", "Q": "2"} ).astype("int")
X_test["Fare"] = X_test["Fare"].fillna(13.9 )<train_model>
|
model.load_weights('.. /input/resunet18lb598/model.h5' )
|
Understanding Clouds from Satellite Images
|
5,644,971 |
logit = LogisticRegression()
logit.fit(X_train, Y_train)
acc_logit_train = round(logit.score(X_train, Y_train)*100, 2)
acc_logit_dev = round(logit.score(X_dev, Y_dev)*100, 2)
print(f"logit: train accuracy = {acc_logit_train}, dev accuracy = {acc_logit_dev}" )<train_on_grid>
|
def post_process(probability, threshold, min_size):
mask = cv2.threshold(probability, threshold, 1, cv2.THRESH_BINARY)[1]
num_component, component = cv2.connectedComponents(mask.astype(np.uint8))
predictions = np.zeros(( 350, 525), np.float32)
num = 0
for c in range(1, num_component):
p =(component == c)
if p.sum() > min_size:
predictions[p] = 1
num += 1
return predictions, num
|
Understanding Clouds from Satellite Images
|
5,644,971 |
svc = SVC(C=1.0, kernel='rbf', gamma='auto')
svc.fit(X_train, Y_train)
acc_svc_train = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc_dev = round(svc.score(X_dev, Y_dev)* 100, 2)
print(f"svc: train accuracy = {acc_svc_train}, dev accuracy = {acc_svc_dev}" )<feature_engineering>
|
model = tta_segmentation(model, h_flip=True, h_shift=(-10, 10), merge='mean' )
|
Understanding Clouds from Satellite Images
|
5,644,971 |
combine_data = [train_data, dev_data, test_data]
for dataset in combine_data:
dataset["Title"] = dataset.Name.str.extract("([A-Za-z]+)\.", expand=False)
pd.crosstab(train_data['Title'], train_data['Sex'] )<feature_engineering>
|
best_threshold = 0.45
best_size = 15000
threshold = best_threshold
min_size = best_size
test_df = []
encoded_pixels = []
TEST_BATCH_SIZE = 500
for i in range(0, test_imgs.shape[0], TEST_BATCH_SIZE):
batch_idx = list(
range(i, min(test_imgs.shape[0], i + TEST_BATCH_SIZE))
)
test_generator = DataGenerator(
batch_idx,
df=test_imgs,
shuffle=False,
mode='predict',
dim=(350, 525),
reshape=(320, 480),
n_channels=3,
gamma=0.8,
base_path='.. /input/understanding_cloud_organization/test_images',
target_df=sub_df,
batch_size=1,
n_classes=4
)
batch_pred_masks = model.predict_generator(
test_generator,
workers=1,
verbose=1
)
for j, idx in enumerate(batch_idx):
filename = test_imgs['ImageId'].iloc[idx]
image_df = sub_df[sub_df['ImageId'] == filename].copy()
pred_masks = batch_pred_masks[j, ]
for k in range(pred_masks.shape[-1]):
pred_mask = pred_masks[...,k].astype('float32')
if pred_mask.shape !=(350, 525):
pred_mask = cv2.resize(pred_mask, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)
pred_mask, num_predict = post_process(pred_mask, threshold, min_size)
if num_predict == 0:
encoded_pixels.append('')
else:
r = mask2rle(pred_mask)
encoded_pixels.append(r)
sub_df['EncodedPixels'] = encoded_pixels
|
Understanding Clouds from Satellite Images
|
5,644,971 |
for dataset in combine_data:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
train_data[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean()<categorify>
|
def rle_decode(mask_rle, shape=(1400, 2100)) :
s = mask_rle.split()
starts, lengths = [np.asarray(x, dtype=int)for x in(s[0:][::2], s[1:][::2])]
starts -= 1
ends = starts + lengths
img = np.zeros(shape[0]*shape[1], dtype=np.uint8)
for lo, hi in zip(starts, ends):
img[lo:hi] = 1
return img.reshape(shape, order='F' )
|
Understanding Clouds from Satellite Images
|
5,644,971 |
for dataset in combine_data:
dataset['Title'] = dataset['Title'].map({"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5})
dataset['Title'] = dataset['Title'].fillna(0 )<feature_engineering>
|
sub_df.to_csv('submission.csv', columns=['Image_Label', 'EncodedPixels'], index=False)
sub_df.head(10 )
|
Understanding Clouds from Satellite Images
|
7,597,656 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<split>
|
%matplotlib inline
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
MAX_BEST_CHOICE = 5
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
submission = pd.read_csv('/kaggle/input/santas-workshop-tour-2019-optimal-solution/preference_cost_43622.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, int)
for fid, assigned_day in enumerate(assigned_days):
daily_occupancy[assigned_day-1] += N_PEOPLE[fid]
return daily_occupancy
def days_plot(assigned_days):
daily_occupancy = get_daily_occupancy(assigned_days)
best_choices = get_daily_occupancy(DESIRED[:,0])
plt.rcParams['figure.figsize'] = [20, 5]
plt.xticks(np.arange(1, 101, step=1), rotation=90)
plt.axhline(y=125, color='gray', linestyle=':')
plt.axhline(y=300, color='gray', linestyle=':')
mondays125 = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 == 1 and daily_occupancy[day] == 125])
other_mondays = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 == 1 and daily_occupancy[day] != 125])
weekends = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 in [2,3,4] or day == 0])
not_weekends = np.array([(day+1, daily_occupancy[day])for day in range(1, 100)if day % 7 in [0,5,6]])
plt.bar(*weekends.transpose() , color = 'y', label = 'Weekends')
plt.bar(*not_weekends.transpose() , color = 'b', label = 'Thu-Wed-Tue')
plt.bar(*other_mondays.transpose() , color = 'm', label = 'Mondays > 125')
plt.bar(*mondays125.transpose() , color = 'g', label = 'Mondays = 125')
plt.plot(range(1,101), best_choices, color = 'k', label = 'Best choices')
plt.ylim(0, 500)
plt.xlim(0, 101)
plt.xlabel('Days before Christmas', fontsize=14)
plt.ylabel('Occupancy', fontsize=14)
plt.legend()
plt.show()
def days_plot2(assigned_days):
daily_occupancy = get_daily_occupancy(assigned_days)
best_choices = get_daily_occupancy(DESIRED[:,0])
plt.rcParams['figure.figsize'] = [20, 5]
plt.xticks(np.arange(1, 101, step=1), rotation=90)
plt.axhline(y=125, color='gray', linestyle=':')
plt.axhline(y=300, color='gray', linestyle=':')
mondays = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 == 1])
weekends = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 in [2,3,4] or day == 0])
not_weekends = np.array([(day+1, daily_occupancy[day])for day in range(1, 100)if day % 7 in [0,5,6]])
plt.bar(*weekends.transpose() , color = 'y', label = 'Weekends')
plt.bar(*not_weekends.transpose() , color = 'b', label = 'Thu-Wed-Tue')
plt.bar(*mondays.transpose() , color = 'm', label = 'Mondays')
plt.plot(range(1,101), best_choices, color = 'k', label = 'Best choices')
plt.ylim(0, 500)
plt.xlim(0, 101)
plt.xlabel('Days before Christmas', fontsize=14)
plt.ylabel('Occupancy', fontsize=14)
plt.legend()
plt.show()
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if(v < MIN_OCCUPANCY):
penalty += 100000000
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_costs = [max(0, accounting_cost)]
diffs = [0]
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_costs.append(max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0)))
yesterday_count = today_count
return penalty, sum(accounting_costs), penalty + sum(accounting_costs)
def print_cost_function(prediction):
cfa = cost_function(prediction)
print("Preference cost: ",cfa[0])
print("Accounting penalty: ",cfa[1])
print("Score: ",cfa[2])
days_plot(assigned_days )
|
Santa's Workshop Tour 2019
|
7,597,656 |
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=1/3, random_state=0 )<find_best_model_class>
|
print_cost_function(assigned_days )
|
Santa's Workshop Tour 2019
|
7,597,656 |
class Model:
def __init__(self, model):
self.model = model
self.X, self.y = X, y
self.X_train, self.X_test, self.y_train, self.y_test = X_train, X_test, y_train, y_test
self.train()
def model_name(self):
model_name = type(self.model ).__name__
return model_name
def cross_validation(self, cv=5):
print(f"Evaluate {self.model_name() } score by cross-validation...")
CVS = cross_val_score(self.model, self.X, self.y, scoring='accuracy', cv=cv)
print(CVS)
print("="*60, "
Mean accuracy of cross-validation: ", CVS.mean())
def train(self):
print(f"Training {self.model_name() } Model...")
self.model.fit(X_train, y_train)
print("Model Trained.")
def prediction(self, test_x=None, test=False):
if test == False:
y_pred = self.model.predict(self.X_test)
else:
y_pred = self.model.predict(test_x)
return y_pred
def accuracy(self):
y_pred = self.prediction()
y_test = self.y_test
acc = accuracy_score(y_pred, y_test)
print(f"{self.model_name() } Model Accuracy: ", acc )<choose_model_class>
|
submission = pd.read_csv('/kaggle/input/santas-workshop-tour-2019-optimal-solution/accounting_penalty_313.27.csv')
assigned_days = submission['assigned_day'].values
days_plot2(assigned_days )
|
Santa's Workshop Tour 2019
|
7,597,656 |
xgb = XGBClassifier()
xgb = Model(xgb )<choose_model_class>
|
print_cost_function(assigned_days )
|
Santa's Workshop Tour 2019
|
7,597,656 |
gnb = GaussianNB()
gnb = Model(gnb )<import_modules>
|
submission = pd.read_csv('/kaggle/input/santas-workshop-tour-2019-optimal-solution/submission_68888.04.csv')
assigned_days = submission['assigned_day'].values
|
Santa's Workshop Tour 2019
|
7,597,656 |
rfc = RandomForestClassifier()
rfc = Model(rfc)
rfc.cross_validation()
rfc.accuracy()<normalization>
|
!pip install pulp
|
Santa's Workshop Tour 2019
|
7,597,656 |
test_X = test_df.values
test_X = scale.transform(test_X )<predict_on_test>
|
%%time
daily_occupancy = get_daily_occupancy(assigned_days)
lower_bounds = np.zeros(NUMBER_DAYS)
upper_bounds = np.zeros(NUMBER_DAYS)
delta = 0
for fi in range(NUMBER_DAYS):
lower_bounds[fi] = max(daily_occupancy[fi]-delta,125)
upper_bounds[fi] = min(daily_occupancy[fi]+delta,300)
prob = LpProblem("Setup occupation of days", LpMinimize)
PCOSTM, B = {}, {}
for fid in range(NUMBER_FAMILIES):
for i in range(MAX_BEST_CHOICE):
B[fid, DESIRED[fid][i]-1] = LpVariable(f'b{fid, i}', 0, 1, LpInteger)
if assigned_days[fid] == DESIRED[fid][i]:
B[fid, DESIRED[fid][i]-1].setInitialValue(1)
else:
B[fid, DESIRED[fid][i]-1].setInitialValue(0)
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
D = {}
for j in range(NUMBER_DAYS):
rj = range(int(lower_bounds[j]),int(upper_bounds[j])+1)
for i in rj:
if j<99:
rj1 = range(int(lower_bounds[j+1]),int(upper_bounds[j+1])+1)
for i1 in rj1:
D[j, i,i1] = LpVariable(f'D{j, i,i1}', 0, 1, LpInteger)
if daily_occupancy[j] == i and daily_occupancy[j+1] == i1:
D[j, i,i1].setInitialValue(1)
else:
D[j, i,i1].setInitialValue(0)
else:
D[j,i,i] = LpVariable(f'D{j, i,i}', 0, 1, LpInteger)
if daily_occupancy[j] == i:
D[j, i,i].setInitialValue(1)
else:
D[j, i,i].setInitialValue(0)
prob += lpSum(PCOSTM[i, j] * B[i, j] for i, j in B)+ lpSum(D[j,i,i1]*(int(i)-125.0)/400.0*int(i)**(0.5+abs(i-i1)/50.0)for j,i,i1 in D)
I = {}
for j in range(NUMBER_DAYS):
I[j] = LpVariable(f'I{j}', int(lower_bounds[j]), int(upper_bounds[j]), LpInteger)
I[j].setInitialValue(daily_occupancy[j])
prob += lpSum([N_PEOPLE[i] * B[i, j] for i in range(NUMBER_FAMILIES)if(i,j)in B])== I[j]
for j in range(NUMBER_DAYS):
rj = range(int(lower_bounds[j]),int(upper_bounds[j])+1)
if j<99:
rj1 = range(int(lower_bounds[j+1]),int(upper_bounds[j+1])+1)
prob += lpSum([D[j, i,i1]*i for i in rj for i1 in rj1])== I[j]
prob += lpSum([D[j, i,i1]*i1 for i in rj for i1 in rj1])== I[j+1]
else:
prob += lpSum([D[j, i,i]*i for i in rj])== I[j]
for i in range(NUMBER_FAMILIES):
prob += lpSum(B[i, j] for j in range(NUMBER_DAYS)if(i,j)in B)== 1
prob.solve()
print("Status:", LpStatus[prob.status])
print("Score = ", value(prob.objective))
|
Santa's Workshop Tour 2019
|
7,597,656 |
xgb_pred = xgb.prediction(test_x=test_X, test=True)
gnb_pred = gnb.prediction(test_x=test_X, test=True)
svc_pred = svc.prediction(test_x=test_X, test=True)
rfc_pred = rfc.prediction(test_x=test_X, test=True )<define_variables>
|
print_cost_function(assigned_days )
|
Santa's Workshop Tour 2019
|
7,597,656 |
<save_to_csv><EOS>
|
submission['assigned_day'] = assigned_days
submission.to_csv('submission_68888.04.csv', index=False )
|
Santa's Workshop Tour 2019
|
7,559,734 |
<save_to_csv><EOS>
|
%%time
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
MAX_BEST_CHOICE = 5
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
submission = pd.read_csv('/kaggle/input/c-stochastic-product-search-65ns/submission.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, int)
for fid, assigned_day in enumerate(assigned_days):
daily_occupancy[assigned_day-1] += N_PEOPLE[fid]
return daily_occupancy
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if(v < MIN_OCCUPANCY):
penalty += 100000000
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_costs = [max(0, accounting_cost)]
diffs = [0]
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_costs.append(max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0)))
yesterday_count = today_count
return penalty, sum(accounting_costs), penalty + sum(accounting_costs)
seed(2)
for f in range(100):
ad = assigned_days.copy()
days_for_fix = np.array(sample(range(1,101),50))
daily_occupancy = get_daily_occupancy(ad)
fids = np.where(np.isin(ad, days_for_fix)) [0]
solver = pywraplp.Solver('Setup occupation of days', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
PCOSTM, B = {}, {}
for fid in fids:
for i in range(MAX_BEST_CHOICE):
B[fid, DESIRED[fid][i]-1] = solver.BoolVar(f'b{fid, i}')
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
lower_bounds = np.zeros(100)
upper_bounds = np.zeros(100)
delta = 8
for fi in days_for_fix:
lower_bounds[fi-1] = max(daily_occupancy[fi-1]-delta,125)
upper_bounds[fi-1] = min(daily_occupancy[fi-1]+delta,300)
D = {}
for j in range(NUMBER_DAYS):
I = solver.IntVar(lower_bounds[j], upper_bounds[j], f'I{j}')
solver.Add(solver.Sum([N_PEOPLE[i] * B[i, j] for i in range(NUMBER_FAMILIES)if(i,j)in B])== I)
if upper_bounds[j]>124:
rj = range(int(lower_bounds[j]),int(upper_bounds[j])+1)
for i in rj:
D[j, i] = solver.BoolVar(f'd{j, i}')
solver.Add(solver.Sum([D[j, i]*i for i in rj])== I)
for i in fids:
solver.Add(solver.Sum(B[i, j] for j in range(NUMBER_DAYS)if(i,j)in B)== 1)
sM =solver.Sum(PCOSTM[i, j] * B[i, j] for i, j in B)
for i in range(NUMBER_DAYS):
if np.isin(i,days_for_fix-1):
ri = range(int(lower_bounds[i]),int(upper_bounds[i])+1)
if i<99:
sM += solver.Sum(D[i,j]*(j-125)/400*j**(0.5+abs(j-daily_occupancy[i+1])/50)for j in ri)
if i>0:
sM += solver.Sum(D[i,j]*(daily_occupancy[i-1]-125)/400*daily_occupancy[i-1]**(0.5+abs(j-daily_occupancy[i-1])/50)for j in ri)
solver.Minimize(sM)
sol = solver.Solve()
status = ['OPTIMAL', 'FEASIBLE', 'INFEASIBLE', 'UNBOUNDED', 'ABNORMAL', 'MODEL_INVALID', 'NOT_SOLVED']
if status[sol] == 'OPTIMAL':
for i, j in B:
if B[i, j].solution_value() > 0.5:
ad[i] = j+1
if cost_function(ad)[2]<cost_function(assigned_days)[2]:
submission['assigned_day'] = ad
assigned_days = ad
print(cost_function(ad))
score = cost_function(assigned_days)[2]
submission.to_csv(f'submission_{score}.csv', index=False)
|
Santa's Workshop Tour 2019
|
7,231,408 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<save_to_csv>
|
%matplotlib inline
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
submission = pd.read_csv('/kaggle/input/best-submission-31-12a/submission.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, int)
for fid, assigned_day in enumerate(assigned_days):
daily_occupancy[assigned_day-1] += N_PEOPLE[fid]
return daily_occupancy
def days_plot(assigned_days):
daily_occupancy = get_daily_occupancy(assigned_days)
best_choices = get_daily_occupancy(DESIRED[:,0])
plt.rcParams['figure.figsize'] = [20, 5]
plt.xticks(np.arange(1, 101, step=1), rotation=90)
plt.axhline(y=125, color='gray', linestyle=':')
plt.axhline(y=300, color='gray', linestyle=':')
mondays125 = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 == 1 and daily_occupancy[day] == 125])
other_mondays = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 == 1 and daily_occupancy[day] != 125])
weekends = np.array([(day+1, daily_occupancy[day])for day in range(100)if day % 7 in [2,3,4] or day == 0])
not_weekends = np.array([(day+1, daily_occupancy[day])for day in range(1, 100)if day % 7 in [0,5,6]])
plt.bar(*weekends.transpose() , color = 'y', label = 'Weekends')
plt.bar(*not_weekends.transpose() , color = 'b', label = 'Thu-Wed-Tue')
plt.bar(*other_mondays.transpose() , color = 'm', label = 'Mondays > 125')
plt.bar(*mondays125.transpose() , color = 'g', label = 'Mondays = 125')
plt.plot(range(1,101), best_choices, color = 'k', label = 'Best choices')
plt.ylim(0, 500)
plt.xlim(0, 101)
plt.xlabel('Days before Christmas', fontsize=14)
plt.ylabel('Occupancy', fontsize=14)
plt.legend()
plt.show()
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if(v < MIN_OCCUPANCY):
penalty += 100000000
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_costs = [max(0, accounting_cost)]
diffs = [0]
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_costs.append(max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0)))
yesterday_count = today_count
return penalty, sum(accounting_costs), penalty + sum(accounting_costs)
days_plot(assigned_days)
print("Score: ", cost_function(assigned_days))
|
Santa's Workshop Tour 2019
|
7,231,408 |
sub['Survived'] = gnb_pred
sub.to_csv('gnb_submission.csv', index=False)
sub.head(10 )<save_to_csv>
|
print("Day allocations:")
print(np.arange(1, 100)[np.abs(np.diff(get_daily_occupancy(assigned_days)) * -1)> 25] )
|
Santa's Workshop Tour 2019
|
7,231,408 |
sub['Survived'] = svc_pred
sub.to_csv('svc_submission.csv', index=False)
sub.head(10 )<save_to_csv>
|
days_for_fix = np.array([37])
daily_occupancy = get_daily_occupancy(assigned_days)
fids = np.where(np.isin(assigned_days, days_for_fix)) [0]
MAX_BEST_CHOICE = 3
solver = pywraplp.Solver('Setup occupation of days', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
PCOSTM, B = {}, {}
for fid in fids:
for i in range(MAX_BEST_CHOICE):
B[fid, DESIRED[fid][i]-1] = solver.BoolVar(f'b{fid, i}')
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
lower_bounds = np.zeros(100)
upper_bounds = 300.- daily_occupancy
upper_bounds[np.arange(100)%7 == 1] = 0
lower_bounds[days_for_fix-1] = 125
upper_bounds[days_for_fix-1] = 125
for j in range(NUMBER_DAYS):
I = solver.IntVar(lower_bounds[j], upper_bounds[j], f'I{j}')
solver.Add(solver.Sum([N_PEOPLE[i] * B[i, j] for i in range(NUMBER_FAMILIES)if(i,j)in B])== I)
for i in fids:
solver.Add(solver.Sum(B[i, j] for j in range(NUMBER_DAYS)if(i,j)in B)== 1)
solver.Minimize(solver.Sum(PCOSTM[i, j] * B[i, j] for i, j in B))
sol = solver.Solve()
status = ['OPTIMAL', 'FEASIBLE', 'INFEASIBLE', 'UNBOUNDED', 'ABNORMAL', 'MODEL_INVALID', 'NOT_SOLVED']
if status[sol] == 'OPTIMAL':
for i, j in B:
if B[i, j].solution_value() > 0.5:
assigned_days[i] = j+1
print('Solution: ', status[sol])
print("Score: ", cost_function(assigned_days))
days_plot(assigned_days)
submission['assigned_day'] = assigned_days
submission.to_csv('submission.csv', index=False )
|
Santa's Workshop Tour 2019
|
7,231,408 |
sub['Survived'] = rfc_pred
sub.to_csv('rfc_submission.csv', index=False)
sub.head(10 )<save_to_csv>
|
def pytorch_optimim(MAX_CHOICE = 6):
root_path = Path(r'.. /input/santa-workshop-tour-2019')
best_submit_path = Path(r'.. /input/mip-optimization-preference-cost/')
fpath = root_path / 'family_data.csv'
data = pd.read_csv(fpath, index_col='family_id')
data_choices = data.values
fpath = root_path / 'sample_submission.csv'
submission = pd.read_csv(fpath, index_col='family_id')
dummies = []
for i in range(MAX_CHOICE):
tmp = pd.get_dummies(data[f'choice_{i}'] ).values*(data['n_people'].values.reshape(-1,1))
dummies.append((
np.concatenate([tmp, tmp[:, -1].reshape(-1,1)], axis=1)
).reshape(5000, 101, 1))
dummies = np.concatenate(dummies, axis=2)
dummies = np.swapaxes(dummies, 1, 2)
penalties = {n: [0, 50, 50 + 9 * n, 100 + 9 * n, 200 + 9 * n, 200 + 18 * n, 300 + 18 * n, 300 + 36 * n, 400 + 36 * n, 500 + 36 * n + 199 * n] for n in np.unique(data['n_people'])}
mat = []
for i in range(5000):
n = data.iloc[i]['n_people']
mat.append(penalties[n][:MAX_CHOICE])
mat = np.array(mat)
def create_init(initial_sub):
fam_choices = data
a = pd.merge(initial_sub, fam_choices, on='family_id')
initial_choices = []
for i in range(MAX_CHOICE):
initial_choices.append(((a[f'choice_{i}'] == a['assigned_day'])).values.reshape(-1,1))
initial_choices = np.concatenate(initial_choices, axis=1)
initial_choices = torch.tensor(
initial_choices*10
, dtype=torch.float32)
return initial_choices
initial_sub = pd.read_csv('./submission.csv')
initial_choices = create_init(initial_sub)
family_sizes = data.n_people.values.astype(np.int8)
cost_dict = {0: [ 0, 0],
1: [ 50, 0],
2: [ 50, 9],
3: [100, 9],
4: [200, 9],
5: [200, 18],
6: [300, 18],
7: [300, 36],
8: [400, 36],
9: [500, 36 + 199],
10: [500, 36 + 398],
}
def cost(choice, members, cost_dict):
x = cost_dict[choice]
return x[0] + members * x[1]
all_costs = {k: pd.Series([cost(k, x, cost_dict)for x in range(2,9)], index=range(2,9)) for k in cost_dict.keys() }
df_all_costs = pd.DataFrame(all_costs)
family_cost_matrix = np.zeros(( 100,len(family_sizes)))
for i, el in enumerate(family_sizes):
family_cost_matrix[:, i] += all_costs[10][el]
for j, choice in enumerate(data.drop("n_people",axis=1 ).values[i,:]):
family_cost_matrix[choice-1, i] = all_costs[j][el]
def accounting(today, previous):
return(( today - 125)/ 400)* today ** (.5 +(abs(today - previous)/ 50))
acc_costs = np.zeros([176,176])
for i, x in enumerate(range(125,300+1)) :
for j, y in enumerate(range(125,300+1)) :
acc_costs[i,j] = accounting(x,y)
@njit(fastmath=True)
def cost_function(prediction, family_size, family_cost_matrix, accounting_cost_matrix):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
accounting_cost = 0
max_occ = False
daily_occupancy = np.zeros(N_DAYS + 1, dtype=np.int16)
for i,(pred, n)in enumerate(zip(prediction, family_size)) :
daily_occupancy[pred - 1] += n
penalty += family_cost_matrix[pred - 1, i]
daily_occupancy[-1] = daily_occupancy[-2]
for day in range(N_DAYS):
n_next = daily_occupancy[day + 1]
n = daily_occupancy[day]
max_occ += MIN_OCCUPANCY > n
max_occ += MAX_OCCUPANCY < n
accounting_cost += accounting_cost_matrix[n-MIN_OCCUPANCY, n_next-MIN_OCCUPANCY]
if max_occ:
return 1e11
return penalty+accounting_cost
print(cost_function(initial_sub['assigned_day'].values, family_sizes, family_cost_matrix, acc_costs))
class Model(nn.Module):
def __init__(self, mat, dummies):
super().__init__()
self.mat = torch.from_numpy(mat ).type(torch.int16)
self.dummies = torch.from_numpy(dummies ).type(torch.float32)
self.weight = torch.nn.Parameter(data=torch.Tensor(5000, MAX_CHOICE ).type(torch.float32)
, requires_grad=True)
self.weight.data.copy_(initial_choices)
def forward(self):
prob = F.softmax(self.weight,dim=1)
x =(prob * self.mat ).sum()
daily_occupancy = torch.zeros(101, dtype=torch.float32)
for i in range(MAX_CHOICE):
daily_occupancy +=(prob[:, i]@self.dummies[:, i, :])
diff = torch.abs(daily_occupancy[:-1] - daily_occupancy[1:])
daily_occupancy = daily_occupancy[:-1]
y =(
torch.relu(daily_occupancy-125.0)/ 400.0 * daily_occupancy**(0.5 + diff / 50.0)
).sum()
v =(( torch.relu(125-daily_occupancy)) **2+(torch.relu(daily_occupancy-300)) **2 ).sum()
entropy_loss = -1.0 *(prob * F.log_softmax(self.weight, dim=1)).sum()
return x, y, v*10000, entropy_loss
model = Model(mat, dummies)
best_score = 10e10
best_pos = None
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1)
for epoch in tqdm.tqdm_notebook(range(100_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = x + y + v + 0*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if epoch % 1000 == 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}')
prev_best_score = best_score
coef = 1
count_failures = 0
for _ in range(10_000):
initial_sub = pd.read_csv('submission.csv')
initial_choices = create_init(initial_sub)
model = Model(mat, dummies)
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1)
for epoch in tqdm.tqdm_notebook(range(1_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = x + coef*y + v + 0*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if(epoch % 1000 == 0)and epoch != 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}')
if best_score == prev_best_score:
count_failures += 1
if count_failures > 30:
break
coef = coef*1.01
else:
prev_best_score = best_score
count_failures = 0
coef = 1
prev_best_score = best_score
coef = 1
count_failures = 0
for _ in range(10_000):
initial_sub = pd.read_csv('submission.csv')
initial_choices = create_init(initial_sub)
model = Model(mat, dummies)
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1)
for epoch in tqdm.tqdm_notebook(range(1_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = coef*x + y + v + 10*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if(epoch % 1000 == 0)and epoch != 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}')
if best_score == prev_best_score:
count_failures += 1
if count_failures > 20:
break
coef = coef*1.05
else:
prev_best_score = best_score
count_failures = 0
coef = 1
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv' )
|
Santa's Workshop Tour 2019
|
7,231,408 |
sub['Survived'] = max_pred
sub.to_csv('max_submission.csv', index=False)
sub.head(10 )<import_modules>
|
def optimization_preference(submission, MAX_BEST_CHOICE=7, NUM_SWAP=3000, NUM_SECONDS=2000,NUM_THREADS=4):
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, int)
for fid, assigned_day in enumerate(assigned_days):
daily_occupancy[assigned_day-1] += N_PEOPLE[fid]
return daily_occupancy
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if(v < MIN_OCCUPANCY):
penalty += 100000000
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_costs = [max(0, accounting_cost)]
diffs = [0]
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_costs.append(max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0)))
yesterday_count = today_count
return penalty, sum(accounting_costs), penalty + sum(accounting_costs)
for _ in range(20):
solver = pywraplp.Solver('Optimization preference cost', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
daily_occupancy = get_daily_occupancy(assigned_days ).astype(float)
fids = np.random.choice(range(NUMBER_FAMILIES), NUM_SWAP, replace=False)
PCOSTM, B = {}, {}
for fid in range(NUMBER_FAMILIES):
if fid in fids:
for i in range(MAX_BEST_CHOICE):
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
B[ fid, DESIRED[fid][i]-1] = solver.BoolVar('')
else:
daily_occupancy[assigned_days[fid]-1] -= N_PEOPLE[fid]
solver.set_time_limit(NUM_SECONDS*NUM_THREADS*1000)
solver.SetNumThreads(NUM_THREADS)
for day in range(NUMBER_DAYS):
if daily_occupancy[day]:
solver.Add(solver.Sum([N_PEOPLE[fid] * B[fid, day] for fid in range(NUMBER_FAMILIES)if(fid,day)in B])== daily_occupancy[day])
for fid in fids:
solver.Add(solver.Sum(B[fid, day] for day in range(NUMBER_DAYS)if(fid, day)in B)== 1)
solver.Minimize(solver.Sum(PCOSTM[fid, day] * B[fid, day] for fid, day in B))
sol = solver.Solve()
status = ['OPTIMAL', 'FEASIBLE', 'INFEASIBLE', 'UNBOUNDED', 'ABNORMAL', 'MODEL_INVALID', 'NOT_SOLVED']
if status[sol] in ['OPTIMAL', 'FEASIBLE']:
tmp = assigned_days.copy()
for fid, day in B:
if B[fid, day].solution_value() > 0.5:
tmp[fid] = day+1
if cost_function(tmp)[2] < cost_function(assigned_days)[2]:
assigned_days = tmp
submission['assigned_day'] = assigned_days
submission.to_csv('submission.csv', index=False)
print('Result:', status[sol], cost_function(tmp))
else:
print('Result:', status[sol] )
|
Santa's Workshop Tour 2019
|
7,231,408 |
import os
import numpy as np
import pandas as pd
from fastai import *
from fastai.vision import *
from pathlib import Path
from PIL import Image<define_variables>
|
def mincostflow(submission, MAX_BEST_CHOICE=4):
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].astype(int ).values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, np.int32)
for i, r in enumerate(assigned_days):
daily_occupancy[r-1] += N_PEOPLE[i]
return daily_occupancy
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if v > MAX_OCCUPANCY or v < MIN_OCCUPANCY:
penalty += 100000000
accounting_cost = max(0,(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5))
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_cost += max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0))
yesterday_count = today_count
return penalty, accounting_cost, penalty + accounting_cost
_,_,reference = cost_function(submission['assigned_day'])
for num_members in range(2, 9):
daily_occupancy = get_daily_occupancy(assigned_days)
fids = np.where(N_PEOPLE == num_members)[0]
PCOSTM = {}
for fid in range(NUMBER_FAMILIES):
if fid in fids:
for i in range(MAX_BEST_CHOICE):
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
else:
daily_occupancy[assigned_days[fid]-1] -= N_PEOPLE[fid]
offset = fids.shape[0]
solver = pywrapgraph.SimpleMinCostFlow()
for day in range(NUMBER_DAYS):
solver.SetNodeSupply(offset+day, int(daily_occupancy[day]//num_members))
for i in range(offset):
fid = fids[i]
solver.SetNodeSupply(i, -1)
for j in range(MAX_BEST_CHOICE):
day = DESIRED[fid][j]-1
solver.AddArcWithCapacityAndUnitCost(int(offset+day), i, 1, int(PCOSTM[fid, day]))
solver.SolveMaxFlowWithMinCost()
for i in range(solver.NumArcs()):
if solver.Flow(i)> 0:
assigned_days[fids[solver.Head(i)]] = solver.Tail(i)- offset + 1
print(cost_function(assigned_days))
_,_,new_reference = cost_function(submission['assigned_day'])
if new_reference < reference:
submission.to_csv("submission.csv", index=False )
|
Santa's Workshop Tour 2019
|
7,231,408 |
input_root_path = Path("/kaggle/input/digit-recognizer")
output_root_path = Path("/kaggle/output" )<load_from_csv>
|
%%writefile main.cpp
using namespace std;
using namespace std::chrono;
constexpr array<uint8_t, 14> DISTRIBUTION{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5}; // You can setup how many families you need for swaps and what best choice use for each family
// {3, 5} it's mean the first random family will brute force for choices 1-2 and the second random family will brute force for choices 1-5
constexpr int MAX_OCCUPANCY = 300;
constexpr int MIN_OCCUPANCY = 125;
constexpr int BEST_N = 1000;
array<uint8_t, 5000> n_people;
array<array<uint8_t, 10>, 5000> choices;
array<array<uint16_t, 10>, 5000> PCOSTM;
array<array<double, 176>, 176> ACOSTM;
void init_data() {
ifstream in(".. /input/santa-workshop-tour-2019/family_data.csv");
assert(in && "family_data.csv");
string header;
int n,x;
char comma;
getline(in, header);
for(int j = 0; j < choices.size() ; ++j){
in >> x >> comma;
for(int i = 0; i < 10; ++i){
in >> x >> comma;
choices[j][i] = x-1;
}
in >> n;
n_people[j] = n;
}
array<int, 10> pc{0, 50, 50, 100, 200, 200, 300, 300, 400, 500};
array<int, 10> pn{0, 0, 9, 9, 9, 18, 18, 36, 36, 235};
for(int j = 0; j < PCOSTM.size() ; ++j)
for(int i = 0; i < 10; ++i)
PCOSTM[j][i] = pc[i] + pn[i] * n_people[j];
for(int i = 0; i < 176; ++i)
for(int j = 0; j < 176; ++j)
ACOSTM[i][j] = i * pow(i+125, 0.5 + abs(i-j)/ 50.0)/ 400.0;
}
array<uint8_t, 5000> read_submission(string filename){
ifstream in(filename);
assert(in && "submission.csv");
array<uint8_t, 5000> assigned_day{};
string header;
int id, x;
char comma;
getline(in, header);
for(int j = 0; j < choices.size() ; ++j){
in >> id >> comma >> x;
assigned_day[j] = x-1;
auto it = find(begin(choices[j]), end(choices[j]), assigned_day[j]);
if(it != end(choices[j]))
assigned_day[j] = distance(begin(choices[j]), it);
}
return assigned_day;
}
struct Index {
Index(array<uint8_t, 5000> assigned_days_): assigned_days(assigned_days_){
setup() ;
}
array<uint8_t, 5000> assigned_days;
array<uint16_t, 100> daily_occupancy_{};
int preference_cost_ = 0;
void setup() {
preference_cost_ = 0;
daily_occupancy_.fill(0);
for(int j = 0; j < assigned_days.size() ; ++j){
daily_occupancy_[choices[j][assigned_days[j]]] += n_people[j];
preference_cost_ += PCOSTM[j][assigned_days[j]];
}
}
double calc(const array<uint16_t, 5000>& indices, const array<uint8_t, DISTRIBUTION.size() >& change){
double accounting_penalty = 0.0;
auto daily_occupancy = daily_occupancy_;
int preference_cost = preference_cost_;
for(int i = 0; i < DISTRIBUTION.size() ; ++i){
int j = indices[i];
daily_occupancy[choices[j][assigned_days[j]]] -= n_people[j];
daily_occupancy[choices[j][ change[i]]] += n_people[j];
preference_cost += PCOSTM[j][change[i]] - PCOSTM[j][assigned_days[j]];
}
for(auto occupancy : daily_occupancy)
if(occupancy < MIN_OCCUPANCY)
return 1e12*(MIN_OCCUPANCY-occupancy);
else if(occupancy > MAX_OCCUPANCY)
return 1e12*(occupancy - MAX_OCCUPANCY);
for(int day = 0; day < 99; ++day)
accounting_penalty += ACOSTM[daily_occupancy[day]-125][daily_occupancy[day+1]-125];
accounting_penalty += ACOSTM[daily_occupancy[99]-125][daily_occupancy[99]-125];
return preference_cost + accounting_penalty;
}
void reindex(const array<uint16_t, DISTRIBUTION.size() >& indices, const array<uint8_t, DISTRIBUTION.size() >& change){
for(int i = 0; i < DISTRIBUTION.size() ; ++i){
assigned_days[indices[i]] = change[i];
}
setup() ;
}
};
double calc(const array<uint8_t, 5000>& assigned_days, bool print=false){
int preference_cost = 0;
double accounting_penalty = 0.0;
array<uint16_t, 100> daily_occupancy{};
for(int j = 0; j < assigned_days.size() ; ++j){
preference_cost += PCOSTM[j][assigned_days[j]];
daily_occupancy[choices[j][assigned_days[j]]] += n_people[j];
}
for(auto occupancy : daily_occupancy)
if(occupancy < MIN_OCCUPANCY)
return 1e12*(MIN_OCCUPANCY-occupancy);
else if(occupancy > MAX_OCCUPANCY)
return 1e12*(occupancy - MAX_OCCUPANCY);
for(int day = 0; day < 99; ++day)
accounting_penalty += ACOSTM[daily_occupancy[day]-125][daily_occupancy[day+1]-125];
accounting_penalty += ACOSTM[daily_occupancy[99]-125][daily_occupancy[99]-125];
if(print){
cout << preference_cost << " " << accounting_penalty << " " << preference_cost+accounting_penalty << endl;
}
return preference_cost + accounting_penalty;
}
void save_sub(const array<uint8_t, 5000>& assigned_day){
ofstream out("submission.csv");
out << "family_id,assigned_day" << endl;
for(int i = 0; i < assigned_day.size() ; ++i)
out << i << "," << choices[i][assigned_day[i]]+1 << endl;
}
const vector<array<uint8_t, DISTRIBUTION.size() >> changes = []() {
vector<array<uint8_t, DISTRIBUTION.size() >> arr;
array<uint8_t, DISTRIBUTION.size() > tmp{};
for(int i = 0; true; ++i){
arr.push_back(tmp);
tmp[0] += 1;
for(int j = 0; j < DISTRIBUTION.size() ; ++j)
if(tmp[j] >= DISTRIBUTION[j]){
if(j >= DISTRIBUTION.size() -1)
return arr;
tmp[j] = 0;
++tmp[j+1];
}
}
return arr;
}() ;
template<class ExitFunction>
void stochastic_product_search(Index index, ExitFunction fn){ // 15'360'000it/s 65ns/it 0.065µs/it
double best_local_score = calc(index.assigned_days);
thread_local std::mt19937 gen(std::random_device{}());
uniform_int_distribution<> dis(0, 4999);
array<uint16_t, 5000> indices;
iota(begin(indices), end(indices), 0);
array<uint16_t, DISTRIBUTION.size() > best_indices{};
array<uint8_t, DISTRIBUTION.size() > best_change{};
for(; fn() ;){
bool found_better = false;
for(int k = 0; k < BEST_N; ++k){
for(int i = 0; i < DISTRIBUTION.size() ; ++i)//random swap
swap(indices[i], indices[dis(gen)]);
for(const auto& change : changes){
auto score = index.calc(indices, change);
if(score < best_local_score){
found_better = true;
best_local_score = score;
best_change = change;
copy_n(begin(indices), DISTRIBUTION.size() , begin(best_indices)) ;
}
}
}
if(found_better){ // reindex from N best if found better
index.reindex(best_indices, best_change);
// save_sub(index.assigned_days);
calc(index.assigned_days, true);
}
}
save_sub(index.assigned_days);
}
int main() {
init_data() ;
auto assigned_day = read_submission("./submission.csv");
Index index(assigned_day);
calc(index.assigned_days, true);
// auto forever = []() { return true; };
// auto count_exit = [start = 0]() mutable { return(++start <= 1000); };
auto time_exit = [start = high_resolution_clock::now() ]() {
return duration_cast<minutes>(high_resolution_clock::now() -start ).count() < 15; //5h55
};
stochastic_product_search(index, time_exit);
return 0;
}
|
Santa's Workshop Tour 2019
|
7,231,408 |
train_df = pd.read_csv(input_root_path/'train.csv')
test_df = pd.read_csv(input_root_path/'test.csv' )<train_model>
|
!g++ -pthread -lpthread -O3 -std=c++17 -o main main.cpp
|
Santa's Workshop Tour 2019
|
7,231,408 |
def saveDigit(digit, filepath):
digit = digit.reshape(28, 28)
digit = digit.astype(np.uint8)
img = Image.fromarray(digit)
img.save(filepath)
def save_train_images(output_root_path: Path, df: pd.DataFrame, num_classes=10):
output_data_path = output_root_path/'train'
os.makedirs(output_data_path)
for i in range(num_classes):
os.makedirs(output_data_path/str(i))
for index, row in df.iterrows() :
label,digit = row[0], row[1:]
folder = output_data_path/str(label)
filename = f"{index}.jpg"
filepath = folder/filename
digit = digit.values
saveDigit(digit, filepath)
def save_test_images(output_root_path: Path, df: pd.DataFrame):
output_data_path = output_root_path/'test'
os.makedirs(output_data_path)
for index, row in df.iterrows() :
filename = f"{index}.jpg"
filepath = output_data_path/filename
saveDigit(row.values, filepath )<train_model>
|
trials = 1
for r in range(trials):
pytorch_optimim(MAX_CHOICE=6)
!./main
submission = pd.read_csv("./submission.csv")
optimization_preference(submission, MAX_BEST_CHOICE=6, NUM_SWAP=3000, NUM_SECONDS=2000, NUM_THREADS=4)
submission = pd.read_csv("./submission.csv")
mincostflow(submission, MAX_BEST_CHOICE=6)
!./main
|
Santa's Workshop Tour 2019
|
7,231,408 |
save_train_images(output_root_path, train_df)
save_test_images(output_root_path, test_df )<feature_engineering>
|
save = False
if save:
def create_download_link(title = "Download CSV file", filename = "data.csv"):
html = '<a href={filename}>{title}</a>'
html = html.format(title=title,filename=filename)
return HTML(html)
create_download_link(filename='submission.csv' )
|
Santa's Workshop Tour 2019
|
7,420,756 |
tfms = get_transforms(do_flip=False, max_rotate=20.0, max_warp=0.0 )<load_pretrained>
|
SEED = 1
random.seed(SEED)
np.random.seed(SEED)
N_DAYS = 100
N_FAMILIES = 5000
N_CHOICES = 10
MAX_POP = 300
MIN_POP = 125
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
choice_cols = [f'choice_{i}' for i in range(N_CHOICES)]
CHOICES = data[choice_cols].values - 1
COST_PER_FAMILY = [0, 50, 50, 100, 200, 200, 300, 300, 400, 500, 500]
COST_PER_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36, 235, 434]
F_COUNTS = data['n_people'].astype(int ).values
C_COSTS = np.zeros(( N_FAMILIES, N_DAYS), dtype=np.int32)
for f in range(N_FAMILIES):
for d in range(N_DAYS):
if d in CHOICES[f, :]:
c = list(CHOICES[f, :] ).index(d)
else:
c = N_CHOICES
C_COSTS[f, d] = COST_PER_FAMILY[c] + F_COUNTS[f] * COST_PER_MEMBER[c]
|
Santa's Workshop Tour 2019
|
7,420,756 |
data = ImageDataBunch.from_folder(
path=output_root_path,
train='train',
test='test',
seed=1234,
valid_pct=0.2,
size=28,
ds_tfms=tfms
).normalize()<choose_model_class>
|
@njit(fastmath=True)
def get_daily_occupancy(schedule):
daily_occupancy = np.zeros(N_DAYS, np.int32)
for f, d in enumerate(schedule):
daily_occupancy[d] += F_COUNTS[f]
return daily_occupancy
@njit(fastmath=True)
def cost_function(schedule):
choice_cost = 0
for f, d in enumerate(schedule):
choice_cost += C_COSTS[f, d]
daily_occupancy = get_daily_occupancy(schedule)
accounting_cost = 0
for d0 in range(N_DAYS):
pop0 = daily_occupancy[d0]
d1 = min(d0+1, N_DAYS-1)
pop1 = daily_occupancy[d1]
accounting_cost += max(0,(pop0-125.0)/ 400.0 * pop0**(0.5 + abs(pop0 - pop1)/ 50.0))
violations =(np.count_nonzero(daily_occupancy < MIN_POP)+
np.count_nonzero(daily_occupancy > MAX_POP))
penalty = int(violations * 10e8)
return choice_cost, accounting_cost, penalty
def fix_schedule(schedule):
daily_occupancy = get_daily_occupancy(schedule)
f_list = np.flip(np.argsort(F_COUNTS))
while(daily_occupancy.min() < MIN_POP)or \
(daily_occupancy.max() > MAX_POP):
for c in range(N_CHOICES):
for f in f_list:
n = F_COUNTS[f]
d_old = schedule[f]
d_new = CHOICES[f, c]
if(daily_occupancy[d_old] > MAX_POP)and \
(( daily_occupancy[d_new] + n)<= MAX_POP):
schedule[f] = d_new
daily_occupancy[d_new] += n
daily_occupancy[d_old] -= n
for c in range(N_CHOICES):
for f in f_list:
n = F_COUNTS[f]
d_old = schedule[f]
d_new = CHOICES[f, c]
if(daily_occupancy[d_new] < MIN_POP)and \
(( daily_occupancy[d_old] - n)>= MIN_POP):
schedule[f] = d_new
daily_occupancy[d_new] += n
daily_occupancy[d_old] -= n
return schedule
|
Santa's Workshop Tour 2019
|
7,420,756 |
learn = cnn_learner(data, models.resnet152, metrics=accuracy, callback_fns=ShowGraph ).mixup()<train_model>
|
model = Solver('SantaLinear', Solver.GLOP_LINEAR_PROGRAMMING)
set_f = range(N_FAMILIES)
set_d = range(N_DAYS)
x = {(f, d): model.BoolVar(f'x[{f},{d}]')for f in set_f for d in CHOICES[f, :]}
y = {(d): model.IntVar(0, MAX_POP-MIN_POP, f'y[{d}]')for d in set_d}
for f in set_f:
model.Add(model.Sum(x[f, d] for d in set_d if(f, d)in x.keys())== 1)
pops = [model.Sum(x[f, d] * F_COUNTS[f] for f in set_f if(f, d)in x.keys())for d in set_d]
for d0 in set_d:
pop0 = pops[d0]
model.Add(pop0 >= MIN_POP)
model.Add(pop0 <= MAX_POP)
d1 = min(d0+1, N_DAYS-1)
pop1 = pops[d1]
model.Add(pop0 - pop1 <= y[d])
model.Add(pop1 - pop0 <= y[d])
model.Add(y[d] <= 30)
DELTA_WEIGHT = 500
objective = model.Sum(x[f, d] * C_COSTS[f, d] for f, d in x.keys())
objective += model.Sum(y[d] for d in set_d)* DELTA_WEIGHT
model.Minimize(objective)
model.SetTimeLimit(5 * 60 * 1000)
status = model.Solve()
if status == Solver.OPTIMAL:
print('Found Optimal Solution')
else:
print(f'Solver Error.Status = {status}')
schedule = np.full(N_FAMILIES, -1, dtype=np.int8)
x_vals = np.zeros(( N_FAMILIES, N_DAYS))
for f, d in x.keys() :
x_vals[f, d] = x[f, d].solution_value()
for f, vals in enumerate(x_vals):
d = np.argmax(vals)
schedule[f] = d
score = cost_function(schedule)
print(sum(score), '|', score)
schedule = fix_schedule(schedule)
score = cost_function(schedule)
print(sum(score), '|', score )
|
Santa's Workshop Tour 2019
|
7,420,756 |
learn.fit_one_cycle(10 )<find_best_params>
|
def choice_search(schedule):
best_score = cost_function(schedule)
f_list = np.flip(np.argsort(F_COUNTS))
for f in f_list:
d_old = schedule[f]
for d_new in CHOICES[f, :]:
schedule[f] = d_new
score = cost_function(schedule)
if(sum(score)< sum(best_score)) or \
(sum(score)== sum(best_score)and np.random.random() < 0.5):
best_score = score
d_old = d_new
else:
schedule[f] = d_old
return schedule
|
Santa's Workshop Tour 2019
|
7,420,756 |
lrf=learn.lr_find()<save_model>
|
def min_cost_flow(schedule):
MIN_FAMILY = F_COUNTS.min()
MAX_FAMILY = F_COUNTS.max()
solver = SimpleMinCostFlow()
occupancy = np.zeros(( N_DAYS, MAX_FAMILY+1), dtype=np.int32)
for f, n in enumerate(F_COUNTS):
f_node = int(f)
f_demand = -1
solver.SetNodeSupply(f_node, f_demand)
d = schedule[f]
occupancy[d, n] += 1
for d in range(N_DAYS):
for n in range(MIN_FAMILY, MAX_FAMILY):
occ_node = int(N_FAMILIES +(n-2)* N_DAYS + d)
occ_supply = int(occupancy[d, n])
solver.SetNodeSupply(occ_node, occ_supply)
for f, n in enumerate(F_COUNTS):
f_node = int(f)
for c in range(N_CHOICES):
d = CHOICES[f, c]
c_cost = int(C_COSTS[f, d])
occ_node = int(N_FAMILIES +(n-2)* N_DAYS + d)
solver.AddArcWithCapacityAndUnitCost(occ_node, f_node, 1, c_cost)
status = solver.SolveMaxFlowWithMinCost()
if status == SimpleMinCostFlow.OPTIMAL:
for arc in range(solver.NumArcs()):
if solver.Flow(arc)> 0:
head = solver.Head(arc)
if head in range(N_FAMILIES):
f = head
n = F_COUNTS[f]
occ_node = solver.Tail(arc)
d = occ_node - N_FAMILIES -(n-2)* N_DAYS
schedule[f] = d
else:
print(f'Solver Error.Status = {status}')
return schedule
|
Santa's Workshop Tour 2019
|
7,420,756 |
learn.save('model')
learn.load('model' )<train_model>
|
def swap_search(schedule):
best_score = cost_function(schedule)
f_list = np.random.permutation(N_FAMILIES)
for f0 in f_list:
d0 = schedule[f0]
c0 = list(CHOICES[f0, :] ).index(d0)
swapped = False
for d1 in CHOICES[f0, 0:c0]:
f1_set = np.where(schedule == d1)[0]
for f1 in f1_set:
if d0 in CHOICES[f1, :]:
schedule[f0] = d1
schedule[f1] = d0
score = cost_function(schedule)
if(sum(score)< sum(best_score)) or \
(sum(score)== sum(best_score)and np.random.random() < 0.5):
best_score = score
swapped = True
break
else:
schedule[f0] = d0
schedule[f1] = d1
if swapped: break
return schedule
|
Santa's Workshop Tour 2019
|
7,420,756 |
learn.unfreeze()
learn.fit_one_cycle(10, 1e-02 )<predict_on_test>
|
def random_climb(schedule, repeats=100000):
best_score = cost_function(schedule)
for _ in range(repeats):
f = np.random.randint(N_FAMILIES)
c = np.random.randint(N_CHOICES)
d_old = schedule[f]
d_new = CHOICES[f, c]
schedule[f] = d_new
score = cost_function(schedule)
if(sum(score)< sum(best_score)) or \
(sum(score)== sum(best_score)and np.random.random() < 0.5):
best_score = score
else:
schedule[f] = d_old
return schedule
|
Santa's Workshop Tour 2019
|
7,420,756 |
class_score, _ = learn.get_preds(DatasetType.Test)
class_score = np.argmax(class_score, axis=1 )<define_variables>
|
best_score = cost_function(schedule)
no_improvement = 0
while no_improvement < 5:
improved = False
while True:
schedule = random_climb(schedule)
score = cost_function(schedule)
print('Random :', sum(score), '|', score)
if sum(score)< sum(best_score):
best_score = score
improved = True
else:
break
while True:
schedule = swap_search(schedule)
score = cost_function(schedule)
print('Swaps :', sum(score), '|', score)
if sum(score)< sum(best_score):
best_score = score
improved = True
else:
break
while True:
schedule = choice_search(schedule)
score = cost_function(schedule)
print('Choice :', sum(score), '|', score)
if sum(score)< sum(best_score):
best_score = score
improved = True
else:
break
if not improved:
schedule = min_cost_flow(schedule)
score = cost_function(schedule)
print('MinCost :', sum(score), '|', score)
if sum(score)< sum(best_score):
best_score = score
improved = True
no_improvement = 0 if improved else no_improvement + 1
|
Santa's Workshop Tour 2019
|
7,420,756 |
ImageId = [os.path.splitext(path)[0] for path in os.listdir(output_root_path/'test')]
ImageId = [int(path)for path in ImageId]
ImageId = [ID+1 for ID in ImageId]<save_to_csv>
|
submission = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/sample_submission.csv')
submission['assigned_day'] = schedule + 1
submission.to_csv('submission.csv', index=False )
|
Santa's Workshop Tour 2019
|
7,420,756 |
pd.DataFrame({
"ImageId": ImageId,
"Label": class_score
} ).to_csv("submission.csv", index=False )<load_from_csv>
|
%%writefile main.cpp
using namespace std;
using namespace std::chrono;
constexpr array<uint8_t, 21> DISTRIBUTION{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5};
// {2, 5} it's mean the first random family will brute force for choices 1-2 and the second random family will brute force for choices 1-5
constexpr int MAX_OCCUPANCY = 300;
constexpr int MIN_OCCUPANCY = 125;
constexpr int BEST_N = 10;
array<uint8_t, 5000> n_people;
array<array<uint8_t, 10>, 5000> choices;
array<array<uint16_t, 10>, 5000> PCOSTM;
array<array<double, 176>, 176> ACOSTM;
static std::atomic<bool> flag(false);
static array<uint8_t, 5000> global_assigned_days = {};
auto START_TIME = high_resolution_clock::now() ;
int END_TIME = 515; //475
int N_JOBS = 4;
struct Index {
Index(array<uint8_t, 5000> assigned_days_): assigned_days(assigned_days_){
setup() ;
}
array<uint8_t, 5000> assigned_days;
array<uint16_t, 100> daily_occupancy_{};
int preference_cost_ = 0;
void setup() {
preference_cost_ = 0;
daily_occupancy_.fill(0);
for(int j = 0; j < assigned_days.size() ; ++j){
daily_occupancy_[choices[j][assigned_days[j]]] += n_people[j];
preference_cost_ += PCOSTM[j][assigned_days[j]];
}
}
double calc(const array<uint16_t, 5000>& indices, const array<uint8_t, DISTRIBUTION.size() >& change){
double accounting_penalty = 0.0;
auto daily_occupancy = daily_occupancy_;
int preference_cost = preference_cost_;
for(int i = 0; i < DISTRIBUTION.size() ; ++i){
int j = indices[i];
daily_occupancy[choices[j][assigned_days[j]]] -= n_people[j];
daily_occupancy[choices[j][ change[i]]] += n_people[j];
preference_cost += PCOSTM[j][change[i]] - PCOSTM[j][assigned_days[j]];
}
for(auto occupancy : daily_occupancy)
if(occupancy < MIN_OCCUPANCY)
return 1e12 *(MIN_OCCUPANCY - occupancy);
else if(occupancy > MAX_OCCUPANCY)
return 1e12 *(occupancy - MAX_OCCUPANCY);
for(int day = 0; day < 99; ++day)
accounting_penalty += ACOSTM[daily_occupancy[day] - 125][daily_occupancy[day + 1] - 125];
accounting_penalty += ACOSTM[daily_occupancy[99] - 125][daily_occupancy[99] - 125];
return preference_cost + accounting_penalty;
}
void reindex(const array<uint16_t, DISTRIBUTION.size() >& indices, const array<uint8_t, DISTRIBUTION.size() >& change){
for(int i = 0; i < DISTRIBUTION.size() ; ++i){
assigned_days[indices[i]] = change[i];
}
setup() ;
}
};
void init_data() {
ifstream in("/kaggle/input/santa-workshop-tour-2019/family_data.csv");
assert(in && "family_data.csv");
string header;
int n, x;
char comma;
getline(in, header);
for(int j = 0; j < choices.size() ; ++j){
in >> x >> comma;
for(int i = 0; i < 10; ++i){
in >> x >> comma;
choices[j][i] = x - 1;
}
in >> n;
n_people[j] = n;
}
array<int, 10> pc{0, 50, 50, 100, 200, 200, 300, 300, 400, 500};
array<int, 10> pn{0, 0, 9, 9, 9, 18, 18, 36, 36, 235};
for(int j = 0; j < PCOSTM.size() ; ++j)
for(int i = 0; i < 10; ++i)
PCOSTM[j][i] = pc[i] + pn[i] * n_people[j];
for(int i = 0; i < 176; ++i)
for(int j = 0; j < 176; ++j)
ACOSTM[i][j] = i * pow(i + 125, 0.5 + abs(i - j)/ 50.0)/ 400.0;
}
array<uint8_t, 5000> read_submission(string filename){
ifstream in(filename);
assert(in && "submission.csv");
array<uint8_t, 5000> assigned_day{};
string header;
int id, x;
char comma;
getline(in, header);
for(int j = 0; j < choices.size() ; ++j){
in >> id >> comma >> x;
assigned_day[j] = x - 1;
auto it = find(begin(choices[j]), end(choices[j]), assigned_day[j]);
if(it != end(choices[j]))
assigned_day[j] = distance(begin(choices[j]), it);
}
return assigned_day;
}
double calc(const array<uint8_t, 5000>& assigned_days, bool print = false){
int preference_cost = 0;
double accounting_penalty = 0.0;
array<uint16_t, 100> daily_occupancy{};
for(int j = 0; j < assigned_days.size() ; ++j){
preference_cost += PCOSTM[j][assigned_days[j]];
daily_occupancy[choices[j][assigned_days[j]]] += n_people[j];
}
for(auto occupancy : daily_occupancy)
if(occupancy < MIN_OCCUPANCY)
return 1e12 *(MIN_OCCUPANCY - occupancy);
else if(occupancy > MAX_OCCUPANCY)
return 1e12 *(occupancy - MAX_OCCUPANCY);
for(int day = 0; day < 99; ++day)
accounting_penalty += ACOSTM[daily_occupancy[day] - 125][daily_occupancy[day + 1] - 125];
accounting_penalty += ACOSTM[daily_occupancy[99] - 125][daily_occupancy[99] - 125];
if(print){
cout << preference_cost << " " << accounting_penalty << " " << preference_cost + accounting_penalty << endl;
}
return preference_cost + accounting_penalty;
}
bool time_exit_fn() {
return duration_cast<minutes>(high_resolution_clock::now() -START_TIME ).count() < END_TIME;
}
const vector<array<uint8_t, DISTRIBUTION.size() >> changes = []() {
vector<array<uint8_t, DISTRIBUTION.size() >> arr;
array<uint8_t, DISTRIBUTION.size() > tmp{};
for(int i = 0; true; ++i){
arr.push_back(tmp);
tmp[0] += 1;
for(int j = 0; j < DISTRIBUTION.size() ; ++j)
if(tmp[j] >= DISTRIBUTION[j]){
if(j >= DISTRIBUTION.size() - 1)
return arr;
tmp[j] = 0;
++tmp[j + 1];
}
}
return arr;
}() ;
void stochastic_product_search(array<uint8_t, 5000> assigned_days, double best_local_score){ // 15'360'000it/s 65ns/it 0.065µs/it
Index index(assigned_days);
thread_local std::mt19937 gen(std::random_device{}());
uniform_int_distribution<> dis(0, 4999);
array<uint16_t, 5000> indices;
iota(begin(indices), end(indices), 0);
array<uint16_t, DISTRIBUTION.size() > best_indices{};
array<uint8_t, DISTRIBUTION.size() > best_change{};
for(;time_exit_fn() ;){
bool found_better = false;
for(int k = 0; k < BEST_N; ++k){
for(int i = 0; i < DISTRIBUTION.size() ; ++i)//random swap
swap(indices[i], indices[dis(gen)]);
for(const auto& change : changes){
auto score = index.calc(indices, change);
if(score < best_local_score){
found_better = true;
best_local_score = score;
best_change = change;
copy_n(begin(indices), DISTRIBUTION.size() , begin(best_indices)) ;
}
}
}
if(flag.load() == true){
return;
}
if(found_better && flag.load() == false){ // reindex from N best if found better
flag = true;
index.reindex(best_indices, best_change);
global_assigned_days = index.assigned_days;
return;
}
}
}
array<uint16_t, 5000> sort_indexes(const array<uint8_t, 5000> v){
// initialize original index locations
array<uint16_t, 5000> idx;
iota(idx.begin() , idx.end() , 0);
// sort indexes based on comparing values in v
sort(idx.begin() , idx.end() ,
[v](size_t i1, size_t i2){return v[i1] > v[i2];});
return idx;
}
void seed_finding(array<uint8_t, 5000> assigned_days, double best_local_score, int order){ // 15'360'000it/s 65ns/it 0.065µs/it
thread_local std::mt19937 gen(std::random_device{}());
uniform_real_distribution<> dis(0.0, 1.0);
auto original_score = best_local_score;
auto indices = sort_indexes(n_people); // sort by descending
if(order == 0){ // sort by ascending
reverse(begin(indices), end(indices)) ;
}
for(;time_exit_fn() ;){
auto local_assigned_days = assigned_days;
if(order == 1){ // sort by random
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count() ;
shuffle(indices.begin() , indices.end() , std::default_random_engine(seed)) ;
}
for(int t = 0; t < 700; t++){
for(auto& i : indices){
for(int j = 0; j < 10; j++){
auto di = local_assigned_days[i];
local_assigned_days[i] = j;
auto cur_score = calc(local_assigned_days, false);
double KT = 1;
if(t < 5){
KT = 1.5;
}
else if(t < 10){
KT = 4.5;
}
else {
if(cur_score > best_local_score + 100){
KT = 3;
}
else if(cur_score > best_local_score + 50){
KT = 2.75;
}
else if(cur_score > best_local_score + 20){
KT = 2.5;
}
else if(cur_score > best_local_score + 10){
KT = 2;
}
else if(cur_score > best_local_score){
KT = 1.5;
}
else {
KT = 1;
}
}
if(cur_score <= best_local_score){
best_local_score = cur_score;
}
else {
auto prob = exp(-(cur_score - best_local_score)/ KT);
if(dis(gen)< prob){
best_local_score = cur_score;
}
else {
local_assigned_days[i] = di;
}
}
}
}
if(flag.load() == true){
return;
}
if(best_local_score < original_score && flag.load() == false){
flag = true;
global_assigned_days = local_assigned_days;
return;
}
}
if(best_local_score <= original_score && flag.load() == false){
flag = true;
global_assigned_days = local_assigned_days;
return;
}
}
}
void save_sub(const array<uint8_t, 5000>& assigned_day){
ofstream out("submission.csv");
out << "family_id,assigned_day" << endl;
for(int i = 0; i < assigned_day.size() ; ++i)
out << i << "," << choices[i][assigned_day[i]] + 1 << endl;
}
int main() {
init_data() ;
auto assigned_days = read_submission("submission.csv");
double best_score = calc(assigned_days, true);
for(;time_exit_fn() ;){
std::thread threads[N_JOBS];
for(int i = 0; i < N_JOBS; i++){
//threads[i] = std::thread(stochastic_product_search, assigned_days, best_score);
if(i < 2){
threads[i] = std::thread(stochastic_product_search, assigned_days, best_score);
}
else {
int order = i % 3;
threads[i] = std::thread(seed_finding, assigned_days, best_score, order);
}
//int order = i % 3;
//threads[i] = std::thread(seed_finding, assigned_days, best_score, order);
}
for(int i = 0; i < N_JOBS; i++){
threads[i].join() ;
}
// global_assigned_days return from threads
best_score = calc(global_assigned_days, true);
save_sub(global_assigned_days);
flag = false;
assigned_days = global_assigned_days;
}
return 0;
}
|
Santa's Workshop Tour 2019
|
7,420,756 |
train = pd.read_csv('.. /input/train.csv')
train.head()<load_from_csv>
|
!g++ -pthread -lpthread -O3 -std=c++17 -o main main.cpp
|
Santa's Workshop Tour 2019
|
7,420,756 |
test = pd.read_csv(".. /input/test.csv")
test.head()<count_values>
|
Santa's Workshop Tour 2019
|
|
7,420,756 |
train['label'].value_counts().sort_index()<prepare_x_and_y>
|
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
submission = pd.read_csv('submission.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, int)
for fid, assigned_day in enumerate(assigned_days):
daily_occupancy[assigned_day-1] += N_PEOPLE[fid]
return daily_occupancy
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if(v < MIN_OCCUPANCY):
penalty += 100000000
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_costs = [max(0, accounting_cost)]
diffs = [0]
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_costs.append(max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0)))
yesterday_count = today_count
return penalty, sum(accounting_costs), penalty + sum(accounting_costs )
|
Santa's Workshop Tour 2019
|
7,420,756 |
<feature_engineering><EOS>
|
MAX_BEST_CHOICE = 5
NUM_SWAP = 2500
NUM_SECONDS = 1800
NUM_THREADS = 4
for _ in range(10):
solver = pywraplp.Solver('Optimization preference cost', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
daily_occupancy = get_daily_occupancy(assigned_days ).astype(float)
fids = np.random.choice(range(NUMBER_FAMILIES), NUM_SWAP, replace=False)
PCOSTM, B = {}, {}
for fid in range(NUMBER_FAMILIES):
if fid in fids:
for i in range(MAX_BEST_CHOICE):
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
B[ fid, DESIRED[fid][i]-1] = solver.BoolVar('')
else:
daily_occupancy[assigned_days[fid]-1] -= N_PEOPLE[fid]
solver.set_time_limit(NUM_SECONDS*NUM_THREADS*1000)
solver.SetNumThreads(NUM_THREADS)
for day in range(NUMBER_DAYS):
if daily_occupancy[day]:
solver.Add(solver.Sum([N_PEOPLE[fid] * B[fid, day] for fid in range(NUMBER_FAMILIES)if(fid,day)in B])== daily_occupancy[day])
for fid in fids:
solver.Add(solver.Sum(B[fid, day] for day in range(NUMBER_DAYS)if(fid, day)in B)== 1)
solver.Minimize(solver.Sum(PCOSTM[fid, day] * B[fid, day] for fid, day in B))
sol = solver.Solve()
status = ['OPTIMAL', 'FEASIBLE', 'INFEASIBLE', 'UNBOUNDED', 'ABNORMAL', 'MODEL_INVALID', 'NOT_SOLVED']
if status[sol] in ['OPTIMAL', 'FEASIBLE']:
tmp = assigned_days.copy()
for fid, day in B:
if B[fid, day].solution_value() > 0.5:
tmp[fid] = day+1
if cost_function(tmp)[2] < cost_function(assigned_days)[2]:
assigned_days = tmp
submission['assigned_day'] = assigned_days
submission.to_csv('submission.csv', index=False)
print('Result:', status[sol], cost_function(tmp))
else:
print('Result:', status[sol] )
|
Santa's Workshop Tour 2019
|
7,249,357 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<prepare_x_and_y>
|
NUMBER_DAYS = 100
NUMBER_FAMILIES = 5000
MAX_BEST_CHOICE = 5
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv')
submission = pd.read_csv('/kaggle/input/c-stochastic-product-search-65ns/submission.csv')
assigned_days = submission['assigned_day'].values
columns = data.columns[1:11]
DESIRED = data[columns].values
COST_PER_FAMILY = [0,50,50,100,200,200,300,300,400,500]
COST_PER_FAMILY_MEMBER = [0, 0, 9, 9, 9, 18, 18, 36, 36,235]
N_PEOPLE = data['n_people'].astype(int ).values
def get_daily_occupancy(assigned_days):
daily_occupancy = np.zeros(100, np.int32)
for i, r in enumerate(assigned_days):
daily_occupancy[r-1] += N_PEOPLE[i]
return daily_occupancy
def cost_function(prediction):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
days = list(range(N_DAYS,0,-1))
tmp = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
family_size_dict = tmp[['n_people']].to_dict() ['n_people']
cols = [f'choice_{i}' for i in range(10)]
choice_dict = tmp[cols].to_dict()
daily_occupancy = {k:0 for k in days}
for f, d in enumerate(prediction):
n = family_size_dict[f]
choice_0 = choice_dict['choice_0'][f]
choice_1 = choice_dict['choice_1'][f]
choice_2 = choice_dict['choice_2'][f]
choice_3 = choice_dict['choice_3'][f]
choice_4 = choice_dict['choice_4'][f]
choice_5 = choice_dict['choice_5'][f]
choice_6 = choice_dict['choice_6'][f]
choice_7 = choice_dict['choice_7'][f]
choice_8 = choice_dict['choice_8'][f]
choice_9 = choice_dict['choice_9'][f]
daily_occupancy[d] += n
if d == choice_0:
penalty += 0
elif d == choice_1:
penalty += 50
elif d == choice_2:
penalty += 50 + 9 * n
elif d == choice_3:
penalty += 100 + 9 * n
elif d == choice_4:
penalty += 200 + 9 * n
elif d == choice_5:
penalty += 200 + 18 * n
elif d == choice_6:
penalty += 300 + 18 * n
elif d == choice_7:
penalty += 300 + 36 * n
elif d == choice_8:
penalty += 400 + 36 * n
elif d == choice_9:
penalty += 500 + 36 * n + 199 * n
else:
penalty += 500 + 36 * n + 398 * n
for _, v in daily_occupancy.items() :
if v > MAX_OCCUPANCY or v < MIN_OCCUPANCY:
penalty += 100000000
accounting_cost = max(0,(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5))
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_cost += max(0,(today_count-125.0)/ 400.0 * today_count**(0.5 + diff / 50.0))
yesterday_count = today_count
return penalty, accounting_cost, penalty + accounting_cost
|
Santa's Workshop Tour 2019
|
7,249,357 |
y = np.array(y )<import_modules>
|
%%time
for num_members in range(2, 9):
daily_occupancy = get_daily_occupancy(assigned_days)
fids = np.where(N_PEOPLE == num_members)[0]
PCOSTM = {}
for fid in range(NUMBER_FAMILIES):
if fid in fids:
for i in range(MAX_BEST_CHOICE):
PCOSTM[fid, DESIRED[fid][i]-1] = COST_PER_FAMILY[i] + N_PEOPLE[fid] * COST_PER_FAMILY_MEMBER[i]
else:
daily_occupancy[assigned_days[fid]-1] -= N_PEOPLE[fid]
offset = fids.shape[0]
solver = pywrapgraph.SimpleMinCostFlow()
for day in range(NUMBER_DAYS):
solver.SetNodeSupply(offset+day, int(daily_occupancy[day]//num_members))
for i in range(offset):
fid = fids[i]
solver.SetNodeSupply(i, -1)
for j in range(MAX_BEST_CHOICE):
day = DESIRED[fid][j]-1
solver.AddArcWithCapacityAndUnitCost(int(offset+day), i, 1, int(PCOSTM[fid, day]))
solver.SolveMaxFlowWithMinCost()
for i in range(solver.NumArcs()):
if solver.Flow(i)> 0:
assigned_days[fids[solver.Head(i)]] = solver.Tail(i)- offset + 1
print(cost_function(assigned_days))
|
Santa's Workshop Tour 2019
|
7,249,357 |
<choose_model_class><EOS>
|
submission['assigned_day'] = assigned_days
submission.to_csv('submission.csv', index=False )
|
Santa's Workshop Tour 2019
|
7,087,660 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<choose_model_class>
|
root_path = Path(r'.. /input/santa-workshop-tour-2019')
best_submit_path = Path(r'.. /input/mip-optimization-preference-cost/')
MAX_CHOICE = 5
|
Santa's Workshop Tour 2019
|
7,087,660 |
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] )<train_model>
|
fpath = root_path / 'family_data.csv'
data = pd.read_csv(fpath, index_col='family_id')
data_choices = data.values
fpath = root_path / 'sample_submission.csv'
submission = pd.read_csv(fpath, index_col='family_id' )
|
Santa's Workshop Tour 2019
|
7,087,660 |
k_fold = StratifiedKFold(n_splits=12, random_state=12, shuffle=True)
for k_train_index, k_test_index in k_fold.split(X, y):
model.fit(X[k_train_index,:], y[k_train_index], epochs=5 )<compute_test_metric>
|
dummies = []
for i in range(MAX_CHOICE):
tmp = pd.get_dummies(data[f'choice_{i}'] ).values*(data['n_people'].values.reshape(-1,1))
dummies.append((
np.concatenate([tmp, tmp[:, -1].reshape(-1,1)], axis=1)
).reshape(5000, 101, 1))
dummies = np.concatenate(dummies, axis=2)
dummies = np.swapaxes(dummies, 1, 2)
penalties = {n: [0, 50, 50 + 9 * n, 100 + 9 * n, 200 + 9 * n, 200 + 18 * n, 300 + 18 * n, 300 + 36 * n, 400 + 36 * n, 500 + 36 * n + 199 * n] for n in np.unique(data['n_people'])}
mat = []
for i in range(5000):
n = data.iloc[i]['n_people']
mat.append(penalties[n][:MAX_CHOICE])
mat = np.array(mat)
def create_init(initial_sub):
fam_choices = data
a = pd.merge(initial_sub, fam_choices, on='family_id')
initial_choices = []
for i in range(MAX_CHOICE):
initial_choices.append(((a[f'choice_{i}'] == a['assigned_day'])).values.reshape(-1,1))
initial_choices = np.concatenate(initial_choices, axis=1)
initial_choices = torch.tensor(
initial_choices*10
, dtype=torch.float32)
return initial_choices
initial_sub = pd.read_csv(best_submit_path / 'submission.csv')
initial_choices = create_init(initial_sub )
|
Santa's Workshop Tour 2019
|
7,087,660 |
val_loss, val_acc = model.evaluate(X, y)
val_acc<save_model>
|
family_sizes = data.n_people.values.astype(np.int8)
cost_dict = {0: [ 0, 0],
1: [ 50, 0],
2: [ 50, 9],
3: [100, 9],
4: [200, 9],
5: [200, 18],
6: [300, 18],
7: [300, 36],
8: [400, 36],
9: [500, 36 + 199],
10: [500, 36 + 398],
}
def cost(choice, members, cost_dict):
x = cost_dict[choice]
return x[0] + members * x[1]
all_costs = {k: pd.Series([cost(k, x, cost_dict)for x in range(2,9)], index=range(2,9)) for k in cost_dict.keys() }
df_all_costs = pd.DataFrame(all_costs)
family_cost_matrix = np.zeros(( 100,len(family_sizes)))
for i, el in enumerate(family_sizes):
family_cost_matrix[:, i] += all_costs[10][el]
for j, choice in enumerate(data.drop("n_people",axis=1 ).values[i,:]):
family_cost_matrix[choice-1, i] = all_costs[j][el]
def accounting(today, previous):
return(( today - 125)/ 400)* today ** (.5 +(abs(today - previous)/ 50))
acc_costs = np.zeros([176,176])
for i, x in enumerate(range(125,300+1)) :
for j, y in enumerate(range(125,300+1)) :
acc_costs[i,j] = accounting(x,y)
@njit(fastmath=True)
def cost_function(prediction, family_size, family_cost_matrix, accounting_cost_matrix):
N_DAYS = 100
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
penalty = 0
accounting_cost = 0
max_occ = False
daily_occupancy = np.zeros(N_DAYS + 1, dtype=np.int16)
for i,(pred, n)in enumerate(zip(prediction, family_size)) :
daily_occupancy[pred - 1] += n
penalty += family_cost_matrix[pred - 1, i]
daily_occupancy[-1] = daily_occupancy[-2]
for day in range(N_DAYS):
n_next = daily_occupancy[day + 1]
n = daily_occupancy[day]
max_occ += MIN_OCCUPANCY > n
max_occ += MAX_OCCUPANCY < n
accounting_cost += accounting_cost_matrix[n-MIN_OCCUPANCY, n_next-MIN_OCCUPANCY]
if max_occ:
return 1e11
return penalty+accounting_cost
|
Santa's Workshop Tour 2019
|
7,087,660 |
model.save("dr_cnn_model.h5" )<predict_on_test>
|
cost_function(initial_sub['assigned_day'].values, family_sizes, family_cost_matrix, acc_costs )
|
Santa's Workshop Tour 2019
|
7,087,660 |
test_pred = model.predict(test )<create_dataframe>
|
class Model(nn.Module):
def __init__(self, mat, dummies):
super().__init__()
self.mat = torch.from_numpy(mat ).type(torch.int16)
self.dummies = torch.from_numpy(dummies ).type(torch.float32)
self.weight = torch.nn.Parameter(data=torch.Tensor(5000, MAX_CHOICE ).type(torch.float32)
, requires_grad=True)
self.weight.data.copy_(initial_choices)
def forward(self):
prob = F.softmax(self.weight,dim=1)
x =(prob * self.mat ).sum()
daily_occupancy = torch.zeros(101, dtype=torch.float32)
for i in range(MAX_CHOICE):
daily_occupancy +=(prob[:, i]@self.dummies[:, i, :])
diff = torch.abs(daily_occupancy[:-1] - daily_occupancy[1:])
daily_occupancy = daily_occupancy[:-1]
y =(
torch.relu(daily_occupancy-125.0)/ 400.0 * daily_occupancy**(0.5 + diff / 50.0)
).sum()
v =(( torch.relu(125-daily_occupancy)) **2+(torch.relu(daily_occupancy-300)) **2 ).sum()
entropy_loss = -1.0 *(prob * F.log_softmax(self.weight, dim=1)).sum()
return x, y, v*10000, entropy_loss
|
Santa's Workshop Tour 2019
|
7,087,660 |
submission = pd.DataFrame()
submission['ImageId'] = range(1,(len(test)+1))
submission['Label'] = np.argmax(test_pred, axis=1 )<save_to_csv>
|
model = Model(mat, dummies)
best_score = 10e10
best_pos = None
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1 )
|
Santa's Workshop Tour 2019
|
7,087,660 |
submission.to_csv("submission.csv", index=False )<save_to_csv>
|
for epoch in tqdm.tqdm_notebook(range(1_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = x + y + v + 0*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if epoch % 1000 == 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}' )
|
Santa's Workshop Tour 2019
|
7,087,660 |
submission.to_csv("submission.csv", index=False )<import_modules>
|
prev_best_score = best_score
coef = 1
count_failures = 0
for _ in range(10_000):
initial_sub = pd.read_csv('submission.csv')
initial_choices = create_init(initial_sub)
model = Model(mat, dummies)
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1)
for epoch in tqdm.tqdm_notebook(range(1_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = x + coef*y + v + 0*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if(epoch % 1000 == 0)and epoch != 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}')
if best_score == prev_best_score:
count_failures += 1
if count_failures > 10:
break
coef = coef*1.05
else:
prev_best_score = best_score
count_failures = 0
coef = 1
|
Santa's Workshop Tour 2019
|
7,087,660 |
training_data = pd.read_csv(".. /input/titanic/train.csv")
test_data = pd.read_csv(".. /input/titanic/test.csv")
gender_data = pd.read_csv(".. /input/titanic/gender_submission.csv")
<prepare_x_and_y>
|
prev_best_score = best_score
coef = 1
count_failures = 0
for _ in range(10_000):
initial_sub = pd.read_csv('submission.csv')
initial_choices = create_init(initial_sub)
model = Model(mat, dummies)
optimizer = torch.optim.Adam(model.parameters() , lr = 0.1)
for epoch in tqdm.tqdm_notebook(range(1_001)) :
optimizer.zero_grad()
x, y, v, ent = model()
loss = coef*x + y + v + 10*ent
loss.backward()
optimizer.step()
pos = model.weight.argmax(1 ).cpu().numpy()
pred = []
for i in range(5000):
pred.append(data_choices[i, pos[i]])
pred = np.array(pred)
score = cost_function(pred, family_sizes, family_cost_matrix, acc_costs)
if(score < best_score):
best_score = score
best_pos = pred
print(best_score)
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv')
if(epoch % 1000 == 0)and epoch != 0:
x = np.round(x.item() ,1)
y = np.round(y.item() ,1)
print(f'{epoch}\t{x}\t{y} \t{np.round(score, 2)}')
if best_score == prev_best_score:
count_failures += 1
if count_failures > 10:
break
coef = coef*1.01
else:
prev_best_score = best_score
count_failures = 0
coef = 1
|
Santa's Workshop Tour 2019
|
7,087,660 |
<count_missing_values><EOS>
|
submission['assigned_day'] = best_pos
submission.to_csv(f'submission.csv' )
|
Santa's Workshop Tour 2019
|
7,021,414 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<feature_engineering>
|
import numpy as np
import pandas as pd
import scipy.special
import matplotlib.pyplot as plt
import os
|
Santa's Workshop Tour 2019
|
7,021,414 |
datasets = [X_train, X_test]
titles = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in datasets:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False)
dataset['Title'] = dataset['Title'].replace(['Don', 'Rev', 'Dr', 'Major', 'Sir', 'Col', 'Capt', 'Jonkheer', 'Countess', 'Lady', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace(['Ms', 'Mlle'], 'Miss')
dataset['Title'] = dataset['Title'].replace('Mme', 'Miss')
dataset['Title'] = dataset['Title'].map(titles)
dataset['Title'] = dataset['Title'].astype(int)
dataset.drop('Name', axis=1, inplace=True )<categorify>
|
path_in = '.. /input/santa-workshop-tour-2019/'
path_start_solution = '.. /input/santa-workshop-tour-start-solution/'
print('input_data:', os.listdir(path_in))
print('start solution:', os.listdir(path_start_solution))
|
Santa's Workshop Tour 2019
|
7,021,414 |
dep = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'U': 8}
for dataset in datasets:
dataset['Cabin'] = dataset['Cabin'].fillna("U0")
dataset['Deck'] = dataset['Cabin'].map(lambda x: re.compile('([a-zA-Z])+' ).search(x ).group())
dataset['Deck'] = dataset['Deck'].map(dep)
dataset['Deck'].fillna(0, inplace=True)
dataset['Deck'] = dataset['Deck'].astype(int)
dataset.drop('Cabin', axis=1, inplace=True )<data_type_conversions>
|
data = pd.read_csv(path_in+'family_data.csv')
data.index = data['family_id']
samp_subm = pd.read_csv(path_in+'sample_submission.csv')
start_solution = pd.read_csv(path_start_solution+'santa_workshop_tour_start_solution_01.csv', index_col=0 )
|
Santa's Workshop Tour 2019
|
7,021,414 |
for dataset in datasets:
dataset['relatives'] = dataset['SibSp'] + dataset['Parch']
dataset.loc[dataset['relatives'] > 0, 'is_alone'] = 0
dataset.loc[dataset['relatives'] == 0, 'is_alone'] = 1
dataset['is_alone'] = dataset['is_alone'].astype(int )<feature_engineering>
|
num_days = 100
lower = 125
upper = 300
days = list(range(num_days, 0, -1))
|
Santa's Workshop Tour 2019
|
7,021,414 |
for dataset in datasets:
dataset.loc[(dataset.Sex == "male"), 'Sex'] = 0
dataset.loc[(dataset.Sex == "female"), 'Sex'] = 1<feature_engineering>
|
def calc_family_costs(family):
assigned_day = family['assigned_day']
number_member = family['n_people']
if assigned_day == family['choice_0']:
penalty = 0
elif assigned_day == family['choice_1']:
penalty = 50
elif assigned_day == family['choice_2']:
penalty = 50 + 9 * number_member
elif assigned_day == family['choice_3']:
penalty = 100 + 9 * number_member
elif assigned_day == family['choice_4']:
penalty = 200 + 9 * number_member
elif assigned_day == family['choice_5']:
penalty = 200 + 18 * number_member
elif assigned_day == family['choice_6']:
penalty = 300 + 18 * number_member
elif assigned_day == family['choice_7']:
penalty = 300 + 36 * number_member
elif assigned_day == family['choice_8']:
penalty = 400 + 36 * number_member
elif assigned_day == family['choice_9']:
penalty = 500 + 36 * number_member + 199 * number_member
else:
penalty = 500 + 36 * number_member + 398 * number_member
return penalty
|
Santa's Workshop Tour 2019
|
7,021,414 |
for dataset in datasets:
dataset["Embarked"].fillna("S", inplace=True)
dataset.loc[(dataset.Embarked == "S"), "Embarked"] = 0
dataset.loc[(dataset.Embarked == "Q"), "Embarked"] = 1
dataset.loc[(dataset.Embarked == "C"), "Embarked"] = 2<data_type_conversions>
|
def calc_accounting_cost(data):
accounting_cost = 0
daily_occupancy = {k:0 for k in days}
family_size_dict = data[['n_people']].to_dict() ['n_people']
for f, d in enumerate(data['assigned_day']):
n = family_size_dict[f]
daily_occupancy[d] += n
accounting_cost =(daily_occupancy[days[0]]-125.0)/ 400.0 * daily_occupancy[days[0]]**(0.5)
accounting_cost = max(0, accounting_cost)
yesterday_count = daily_occupancy[days[0]]
for day in days[1:]:
today_count = daily_occupancy[day]
diff = abs(today_count - yesterday_count)
accounting_cost += max(0,(daily_occupancy[day]-125.0)/ 400.0 * daily_occupancy[day]**(0.5 + diff / 50.0))
yesterday_count = today_count
return accounting_cost
|
Santa's Workshop Tour 2019
|
7,021,414 |
for dataset in datasets:
Age_avg = dataset['Age'].mean()
Age_std = dataset['Age'].std()
Age_null_count = dataset['Age'].isnull().sum()
Age_null_random_list = np.random.randint(Age_avg - Age_std, Age_avg + Age_std, size=Age_null_count)
dataset['Age'][np.isnan(dataset['Age'])] = Age_null_random_list
dataset['Age'] = dataset['Age'].astype(int)
dataset.loc[(dataset.Age <= 18), 'Age'] = 0
dataset.loc[(dataset.Age > 18)&(dataset.Age <= 23), 'Age'] = 1
dataset.loc[(dataset.Age > 23)&(dataset.Age <= 29), 'Age'] = 2
dataset.loc[(dataset.Age > 29)&(dataset.Age <= 35), 'Age'] = 3
dataset.loc[(dataset.Age > 35)&(dataset.Age <= 42), 'Age'] = 4
dataset.loc[(dataset.Age > 42), 'Age'] = 5<feature_engineering>
|
def check_day(data, day):
group_data = data.groupby('assigned_day' ).sum() ['n_people'].to_frame()
if(125 <= group_data.loc[day, 'n_people'])&(group_data.loc[day, 'n_people'] <= 300):
return True
else:
return False
|
Santa's Workshop Tour 2019
|
7,021,414 |
X_test['Fare'].fillna(X_test['Fare'].mean() , inplace=True)
for dataset in datasets:
dataset.loc[(dataset.Fare <= 7.775), 'Fare'] = 0
dataset.loc[(dataset.Fare > 7.775)&(dataset.Fare <= 8.662), 'Fare'] = 1
dataset.loc[(dataset.Fare > 8.662)&(dataset.Fare <= 14.454), 'Fare'] = 2
dataset.loc[(dataset.Fare > 14.454)&(dataset.Fare <= 26), 'Fare'] = 3
dataset.loc[(dataset.Fare > 26)&(dataset.Fare <= 52.369), 'Fare'] = 4
dataset.loc[(dataset.Fare > 52.369), 'Fare'] = 5
dataset['Fare'] = dataset['Fare'].astype(int)
dataset.drop(['Ticket', 'PassengerId'], axis=1, inplace=True )<count_missing_values>
|
for i in range(num_days):
data.loc[i*50:(i+1)*50-1, 'assigned_day'] = i+1
data['assigned_day'] = data['assigned_day'].astype(int )
|
Santa's Workshop Tour 2019
|
7,021,414 |
print("----- After cleaning -----")
print(missing_data(X_train))
print(missing_data(X_test))<train_on_grid>
|
data['assigned_day'] = start_solution['assigned_day']
|
Santa's Workshop Tour 2019
|
7,021,414 |
SVC_model = SVC(gamma='scale')
SVC_model.fit(X_train, y_train)
SVC_score = round(accuracy_score(SVC_model.predict(X_train), y_train)* 100, 2)
KNN_model = KNeighborsClassifier()
KNN_model.fit(X_train, y_train)
KNN_score = round(accuracy_score(KNN_model.predict(X_train), y_train)* 100, 2)
DC_model = DecisionTreeClassifier()
DC_model.fit(X_train, y_train)
DC_score = round(accuracy_score(DC_model.predict(X_train), y_train)* 100, 2)
XGB_model = XGBClassifier()
XGB_model.fit(X_train, y_train)
XGB_score = round(accuracy_score(XGB_model.predict(X_train), y_train)* 100, 2)
RF_model = RandomForestClassifier(n_estimators=100)
RF_model.fit(X_train, y_train)
RF_score = round(accuracy_score(RF_model.predict(X_train), y_train)* 100, 2)
GNB_model = GaussianNB()
GNB_model.fit(X_train, y_train)
GNB_score = round(accuracy_score(GNB_model.predict(X_train), y_train)* 100, 2 )<create_dataframe>
|
data['penalty_cost'] = data.apply(calc_family_costs, axis=1 )
|
Santa's Workshop Tour 2019
|
7,021,414 |
ranking = pd.DataFrame({'Model': ['Support Vector Classification', 'KNN', 'Decision Classifier', 'Random Forest', 'Naive Bayes', 'XGBClassifer'], 'Score': [SVC_score, KNN_score, DC_score, RF_score, GNB_score, XGB_score]})
ranking = ranking.sort_values(by='Score', ascending=False ).set_index('Score')
ranking<compute_train_metric>
|
acc_costs = calc_accounting_cost(data)
acc_costs
|
Santa's Workshop Tour 2019
|
7,021,414 |
rf = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=1, n_jobs=-1)
rf.fit(X_train, y_train)
print("Cross val score:", round(cross_val_score(rf, X_train, y_train, cv=8, scoring='accuracy' ).mean() , 3), '(+/-', round(cross_val_score(rf, X_train, y_train, cv=8, scoring='accuracy' ).std() , 2), '%)')
print("Oob score:", round(rf.oob_score_, 4)*100, "%" )<train_model>
|
print('Total costs:', data['penalty_cost'].sum() + acc_costs )
|
Santa's Workshop Tour 2019
|
7,021,414 |
rf = RandomForestClassifier(criterion="gini", min_samples_leaf=1, min_samples_split=35, n_estimators=1000, oob_score=True, random_state=1, n_jobs=-1)
rf.fit(X_train, y_train)
print("oob score:", round(rf.oob_score_, 4)*100, '%' )<predict_on_test>
|
def check_swap_day(data, family, choice):
data_copy = data.copy()
data_copy.loc[family, 'assigned_day'] = data_copy.loc[family, 'choice_'+str(choice)]
data_copy.loc[family, 'penalty_cost'] = calc_family_costs(data_copy.iloc[family])
penalty_before = data.loc[family, 'penalty_cost']
accounting_before = calc_accounting_cost(data)
penalty_after = data_copy.loc[family, 'penalty_cost']
accounting_after = calc_accounting_cost(data_copy)
day_before = check_day(data_copy, data.loc[family, 'assigned_day'])
day_after = check_day(data_copy, data_copy.loc[family, 'assigned_day'])
if(day_before==True and day_after==True):
improvement =(penalty_before-penalty_after)+(accounting_before-accounting_after)
else:
improvement = -1
return improvement
|
Santa's Workshop Tour 2019
|
7,021,414 |
predictions = cross_val_predict(rf, X_train, y_train, cv=5)
print("Precision:", precision_score(y_train, predictions))
print("Recall:", recall_score(y_train, predictions))
print("F1:", f1_score(y_train, predictions))
y_scores = rf.predict_proba(X_train)
y_scores = y_scores[:, 1]<save_to_csv>
|
family_id = 386
check_swap_day(data, family_id, 0 )
|
Santa's Workshop Tour 2019
|
7,021,414 |
r_a_score = roc_auc_score(y_train, y_scores)
print("ROC-AUC-Score:", r_a_score)
preds = rf.predict(X_test)
submission = pd.DataFrame({'PassengerId': test_data['PassengerId'], 'Survived': preds})
submission.to_csv('Titanic Predictions Final Submission.csv', index=False )<load_from_csv>
|
def check_swap_family(data, family, choice):
family1 = family
day_family1 = data.loc[family1, 'assigned_day']
penalty1 = data.loc[family1, 'penalty_cost']
member_family1 = data.loc[family1, 'n_people']
day_member_list = data.groupby('assigned_day')['family_id'].apply(list ).to_frame()
improvements = {}
for member in day_member_list.loc[data.loc[family1, 'choice_'+str(choice)], 'family_id']:
family2 = member
day_family2 = data.loc[family2, 'assigned_day']
member_family2 = data.loc[family2, 'n_people']
penalty2 = data.loc[family2, 'penalty_cost']
data_copy = data.copy()
data_copy.loc[family2, 'assigned_day'] = data_copy.loc[family1, 'assigned_day']
data_copy.loc[family1, 'assigned_day'] = data_copy.loc[family1, 'choice_'+str(choice)]
new_penalty1 = calc_family_costs(data_copy.iloc[family1])
new_penalty2 = calc_family_costs(data_copy.iloc[family2])
day_before = check_day(data_copy, data.loc[family1, 'assigned_day'])
day_after = check_day(data_copy, data_copy.loc[family1, 'choice_'+str(choice)])
accounting_before = calc_accounting_cost(data)
accounting_after = calc_accounting_cost(data_copy)
if(day_before==True and day_after==True):
improvement =(penalty1-new_penalty1)+(penalty2-new_penalty2)+(accounting_before-accounting_after)
else:
improvement = -1
improvements.update({member:improvement})
maximum = max(zip(improvements.values() , improvements.keys()))
family_swap = maximum[1]
return improvement, family_swap
|
Santa's Workshop Tour 2019
|
7,021,414 |
train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
test_df = pd.read_csv("/kaggle/input/titanic/test.csv")
train_df.shape, test_df.shape<prepare_x_and_y>
|
family_id = 386
check_swap_family(data, family_id, 0 )
|
Santa's Workshop Tour 2019
|
7,021,414 |
y = train_df['Survived']
train_df.Age[train_df.Age.isnull() ] = train_df.Age.median()
train_df.Age = train_df.Age.astype(str)
train_df.Fare[train_df.Fare.isnull() ] = train_df.Fare.median()
train_df.Fare = train_df.Fare.astype(str)
train_df.Cabin[train_df.Cabin.isnull() ] = 'NA'
MaxPassEmbarked = train_df.groupby('Embarked' ).count() ['PassengerId']
train_df.Embarked[train_df.Embarked.isnull() ] = 'NAA'
X = train_df.drop(columns=['Survived','Name','PassengerId'])
X.head(100 )<define_variables>
|
family_id = 386
choice = 0
improvement_day = check_swap_day(data, family_id, choice)
improvement_family, family_swap = check_swap_family(data, family_id, choice)
improvement_day, improvement_family, family_swap
|
Santa's Workshop Tour 2019
|
7,021,414 |
SEED = 1<split>
|
def go_to_bazaar(data, family):
family1 = family
day_family1 = data.loc[family1, 'assigned_day']
penalty1 = data.loc[family1, 'penalty_cost']
member_family1 = data.loc[family1, 'n_people']
status = False
for choice in range(10):
improvement_day = check_swap_day(data, family1, choice)
improvement_family, family2 = check_swap_family(data, family1, choice)
if(improvement_day >= 0 or improvement_family >= 0):
if(improvement_day > improvement_family):
data.loc[family, 'assigned_day'] = data.loc[family, 'choice_'+str(choice)]
data.loc[family, 'penalty_cost'] = calc_family_costs(data.iloc[family])
status = True
else:
data.loc[family2, 'assigned_day'] = data.loc[family1, 'assigned_day']
data.loc[family1, 'assigned_day'] = data.loc[family1, 'choice_'+str(choice)]
data.loc[family1, 'penalty_cost'] = calc_family_costs(data.iloc[family1])
data.loc[family2, 'penalty_cost'] = calc_family_costs(data.iloc[family2])
status = True
if(status==True):
break
|
Santa's Workshop Tour 2019
|
7,021,414 |
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.40, random_state=SEED)
cat_features = list(range(X.shape[1]))<create_dataframe>
|
results = results.reindex(sorted(results.columns), axis=1 )
|
Santa's Workshop Tour 2019
|
7,021,414 |
train_data = Pool(data=X_train,
label=y_train,
cat_features=cat_features
)
valid_data = Pool(data=X_valid,
label=y_valid,
cat_features=cat_features
)<train_model>
|
print('Total costs:', data['penalty_cost'].sum() + calc_accounting_cost(data))
|
Santa's Workshop Tour 2019
|
7,021,414 |
%%time
params = {'loss_function':'Logloss',
'eval_metric':'AUC',
'early_stopping_rounds': 200,
'verbose': 200,
'random_seed': SEED
}
cbc_7 = CatBoostClassifier(**params)
cbc_7.fit(train_data,
eval_set=valid_data,
use_best_model=True,
plot=True
);<compute_test_metric>
|
data = data.sort_index()
output = pd.DataFrame({'family_id': samp_subm.index,
'assigned_day': data['assigned_day']})
output.to_csv('submission.csv', index=False )
|
Santa's Workshop Tour 2019
|
7,021,414 |
<data_type_conversions><EOS>
|
santa_workshop_tour_start_solution_01 = pd.read_csv(".. /input/santa-workshop-tour-start-solution/santa_workshop_tour_start_solution_01.csv" )
|
Santa's Workshop Tour 2019
|
6,942,227 |
<SOS> metric: SantaWorkshopSchedule2019 Kaggle data source: santas-workshop-tour-2019<define_variables>
|
from itertools import product
import random
import numpy as np
import pandas as pd
from numba import njit
import matplotlib.pylab as plt
import seaborn as sns
from ortools.linear_solver import pywraplp
|
Santa's Workshop Tour 2019
|
6,942,227 |
%%time
n_fold = 10
folds = StratifiedKFold(n_splits=n_fold, shuffle=True, random_state=SEED)
params = {'loss_function':'Logloss',
'eval_metric':'AUC',
'early_stopping_rounds': 200,
'verbose': False,
'random_seed': SEED
}
test_data = Pool(data=X_test,
cat_features=cat_features)
scores = []
prediction = np.zeros(X_test.shape[0])
for fold_n,(train_index, valid_index)in enumerate(folds.split(X, y)) :
X_train, X_valid = X.iloc[train_index], X.iloc[valid_index]
y_train, y_valid = y[train_index], y[valid_index]
train_data = Pool(data=X_train,
label=y_train,
cat_features=cat_features)
valid_data = Pool(data=X_valid,
label=y_valid,
cat_features=cat_features)
model = CatBoostClassifier(**params)
model.fit(train_data,
eval_set=valid_data,
use_best_model=True
)
score = model.get_best_score() ['validation']['AUC']
scores.append(score)
y_pred = model.predict_proba(test_data)[:, 1]
prediction += y_pred
prediction /= n_fold
print('CV mean: {:.4f}, CV std: {:.4f}'.format(np.mean(scores), np.std(scores)) )<save_to_csv>
|
def get_penalty(n, choice):
penalty = None
if choice == 0:
penalty = 0
elif choice == 1:
penalty = 50
elif choice == 2:
penalty = 50 + 9 * n
elif choice == 3:
penalty = 100 + 9 * n
elif choice == 4:
penalty = 200 + 9 * n
elif choice == 5:
penalty = 200 + 18 * n
elif choice == 6:
penalty = 300 + 18 * n
elif choice == 7:
penalty = 300 + 36 * n
elif choice == 8:
penalty = 400 + 36 * n
elif choice == 9:
penalty = 500 + 36 * n + 199 * n
else:
penalty = 500 + 36 * n + 398 * n
return penalty
def GetPreferenceCostMatrix(data):
cost_matrix = np.zeros(( N_FAMILIES, N_DAYS), dtype=np.int64)
for i in range(N_FAMILIES):
desired = data.values[i, :-1]
cost_matrix[i, :] = get_penalty(FAMILY_SIZE[i], 9)
for j, day in enumerate(desired):
cost_matrix[i, day-1] = get_penalty(FAMILY_SIZE[i], j)
return cost_matrix
def GetAccountingCostMatrix() :
ac = np.zeros(( 1000, 1000), dtype=np.float64)
for n in range(ac.shape[0]):
for n_p1 in range(ac.shape[1]):
diff = abs(n - n_p1)
ac[n, n_p1] = max(0,(n - 125)/ 400 * n**(0.5 + diff / 50.0))
return ac
|
Santa's Workshop Tour 2019
|
6,942,227 |
prediction = np.round(prediction,decimals=0)
prediction = prediction.astype(int)
output = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': prediction})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" )<set_options>
|
label_size = 22
mpl.rcParams['xtick.labelsize'] = label_size
mpl.rcParams['ytick.labelsize'] = label_size
sns.set_style("whitegrid")
ax = plt.figure(figsize=(16,8))
for patch in ax.artists:
r, g, b, a = patch.get_facecolor()
patch.set_facecolor(( r, g, b,.9))
ax = sns.lineplot(x="Family_Size", y="Penalty", data=penalty_values,linewidth=4,hue="Choice",color='
marker='o',markersize=14,palette="Oranges")
plt.title("Penalty
", loc="center",size=32,color='
plt.xlabel('Family Size',color='
plt.ylabel('Penalty',color='
plt.xticks(size=15,color='
plt.yticks(size=15,color='
plt.ylim(0,2500)
plt.legend(loc='best', labels=['Choice 0','Choice 1','Choice 2','Choice 3','Choice 4','Choice 5','Choice 6','Choice 7',
'Choice 8','Choice 9'],
handlelength=6,fontsize=10,ncol=2,framealpha=0.99 )
|
Santa's Workshop Tour 2019
|
6,942,227 |
%matplotlib inline
print(os.listdir(".. /input"))
pd.set_option('display.max_columns', None)
pd.options.display.float_format = '{:.4f}'.format
if not sys.warnoptions:
warnings.simplefilter("ignore")
<load_from_csv>
|
del penalty_values
|
Santa's Workshop Tour 2019
|
6,942,227 |
test = pd.read_csv('.. /input/test.csv')
train = pd.read_csv('.. /input/train.csv')
test.shape,train.shape<count_missing_values>
|
@njit(fastmath=True)
def pcost(prediction):
daily_occupancy = np.zeros(N_DAYS+1, dtype=np.int64)
penalty = 0
for(i, p)in enumerate(prediction):
n = FAMILY_SIZE[i]
penalty += PCOSTM[i, p]
daily_occupancy[p] += n
return penalty, daily_occupancy
@njit(fastmath=True)
def acost(daily_occupancy):
accounting_cost = 0
n_out_of_range = 0
daily_occupancy[-1] = daily_occupancy[-2]
for day in range(N_DAYS):
n_p1 = daily_occupancy[day + 1]
n = daily_occupancy[day]
n_out_of_range +=(n > MAX_OCCUPANCY)or(n < MIN_OCCUPANCY)
accounting_cost += ACOSTM[n, n_p1]
return accounting_cost, n_out_of_range
@njit(fastmath=True)
def acostd(daily_occupancy):
accounting_cost = np.zeros(N_DAYS, dtype=np.float64)
n_out_of_range = 0
daily_occupancy[-1] = daily_occupancy[-2]
for day in range(N_DAYS):
n_p1 = daily_occupancy[day + 1]
n = daily_occupancy[day]
n_out_of_range +=(n > MAX_OCCUPANCY)or(n < MIN_OCCUPANCY)
accounting_cost[day] = ACOSTM[n, n_p1]
return accounting_cost, n_out_of_range
@njit(fastmath=True)
def pcostd(prediction):
daily_occupancy = np.zeros(N_DAYS+1, dtype=np.int64)
penalty = np.empty_like(prediction)
for(i, p)in enumerate(prediction):
n = FAMILY_SIZE[i]
penalty[i] = PCOSTM[i, p]
daily_occupancy[p] += n
return penalty, daily_occupancy
@njit(fastmath=True)
def cost_stats(prediction):
penalty, daily_occupancy = pcostd(prediction)
accounting_cost, n_out_of_range = acostd(daily_occupancy)
return penalty, accounting_cost, n_out_of_range, daily_occupancy[:-1]
@njit(fastmath=True)
def cost_function(prediction):
penalty, daily_occupancy = pcost(prediction)
accounting_cost, n_out_of_range = acost(daily_occupancy)
return penalty + accounting_cost + n_out_of_range*100000000
|
Santa's Workshop Tour 2019
|
6,942,227 |
train.isnull().sum()<count_missing_values>
|
@njit(fastmath=True)
def cost_function_(prediction):
penalty, daily_occupancy = pcost(prediction)
accounting_cost, n_out_of_range = acost(daily_occupancy)
return penalty + accounting_cost, n_out_of_range
@njit(fastmath=True)
def findAnotherDay4Fam(prediction, fam, occupancy):
old_day = prediction[fam]
best_cost = np.inf
best_day = fam
n = FAMILY_SIZE[fam]
daysrange = list(range(0,old_day)) +list(range(old_day+1,N_DAYS))
for day in daysrange:
prediction[fam] = day
new_cost, _ = cost_function_(prediction)
if(new_cost<best_cost)and(occupancy[day]+n<=MAX_OCCUPANCY):
best_cost = new_cost
best_day = day
prediction[fam] = old_day
return best_day, best_cost
@njit(fastmath=True)
def bestFamAdd(prediction, day, occupancy):
best_cost = np.inf
best_fam = prediction[day]
for fam in np.where(prediction!=day)[0]:
old_day = prediction[fam]
prediction[fam] = day
new_cost, _ = cost_function_(prediction)
prediction[fam] = old_day
n = FAMILY_SIZE[fam]
if(new_cost<best_cost)and(occupancy[old_day]-n>=MIN_OCCUPANCY):
best_cost = new_cost
best_fam = fam
return best_fam
@njit(fastmath=True)
def bestFamRemoval(prediction, day, occupancy):
best_cost = np.inf
best_day = day
for fam in np.where(prediction==day)[0]:
new_day, new_cost = findAnotherDay4Fam(prediction, fam, occupancy)
if new_cost<best_cost:
best_cost = new_cost
best_fam = fam
best_day = new_day
return best_fam, best_day
@njit(fastmath=True)
def fixMaxOccupancy(prediction):
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction)
for day in np.where(occupancy>MAX_OCCUPANCY)[0]:
while occupancy[day]>MAX_OCCUPANCY:
fam, new_day = bestFamRemoval(prediction, day, occupancy)
prediction[fam] = new_day
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction)
@njit(fastmath=True)
def fixMinOccupancy(prediction):
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction)
for day in np.where(occupancy<MIN_OCCUPANCY)[0]:
while occupancy[day]<MIN_OCCUPANCY:
fam = bestFamAdd(prediction, day, occupancy)
prediction[fam] = day
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction )
|
Santa's Workshop Tour 2019
|
6,942,227 |
test.isnull().sum()<count_missing_values>
|
def findBetterDay4Family(pred):
fobs = np.argsort(FAMILY_SIZE)
score = cost_function(pred)
original_score = np.inf
while original_score>score:
original_score = score
for family_id in fobs:
for pick in range(9):
day = DESIRED[family_id, pick]
oldvalue = pred[family_id]
pred[family_id] = day
new_score = cost_function(pred)
if new_score<score:
score = new_score
else:
pred[family_id] = oldvalue
print(score, end='\r')
print(score)
def stochastic_product_search(top_k, fam_size, original,
verbose=1000, verbose2=50000,
n_iter=500, random_state=2019):
best = original.copy()
print('best',best)
best_score = cost_function(best)
print('best_score',best_score)
np.random.seed(random_state)
print('np.random.seed(random_state)',np.random.seed(random_state))
for i in range(n_iter):
fam_indices = np.random.choice(range(DESIRED.shape[0]), size=fam_size)
changes = np.array(list(product(*DESIRED[fam_indices, :top_k].tolist())))
for change in changes:
new = best.copy()
new[fam_indices] = change
new_score = cost_function(new)
if new_score < best_score:
best_score = new_score
best = new
if verbose and i % verbose == 0:
print(f"Iteration
if verbose2 and i % verbose2 == 0:
print(f"Iteration
print(f"Final best score is {best_score:.2f}")
return best
|
Santa's Workshop Tour 2019
|
6,942,227 |
print('Train','
',(train.isnull().sum() /len(train)) *100)
print('-'*20)
print('Test','
',(test.isnull().sum() /len(test)) *100 )<groupby>
|
def solveSantaLP() :
S = pywraplp.Solver('SolveAssignmentProblem', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
x = {}
for i in range(N_FAMILIES):
for j in range(N_DAYS):
x[i, j] = S.BoolVar('x[%i,%i]' %(i, j))
daily_occupancy = [S.Sum([x[i, j] * FAMILY_SIZE[i] for i in range(N_FAMILIES)])
for j in range(N_DAYS)]
family_presence = [S.Sum([x[i, j] for j in range(N_DAYS)])
for i in range(N_FAMILIES)]
preference_cost = S.Sum([PCOSTM[i, j] * x[i,j] for i in range(N_FAMILIES)
for j in range(N_DAYS)])
S.Minimize(preference_cost)
for j in range(N_DAYS-1):
S.Add(daily_occupancy[j] - daily_occupancy[j+1] <= 32)
S.Add(daily_occupancy[j+1] - daily_occupancy[j] <= 31)
for i in range(N_FAMILIES):
S.Add(family_presence[i] == 1)
for j in range(N_DAYS):
S.Add(daily_occupancy[j] >= MIN_OCCUPANCY)
S.Add(daily_occupancy[j] <= MAX_OCCUPANCY)
res = S.Solve()
resdict = {0:'OPTIMAL', 1:'FEASIBLE', 2:'INFEASIBLE', 3:'UNBOUNDED',
4:'ABNORMAL', 5:'MODEL_INVALID', 6:'NOT_SOLVED'}
print('Result:', resdict[res])
l = []
for i in range(N_FAMILIES):
for j in range(N_DAYS):
s = x[i, j].solution_value()
if s>0:
l.append(( i, j, s))
df = pd.DataFrame(l, columns=['family_id', 'day', 'n'])
if len(df)!=N_FAMILIES:
df = df.sort_values(['family_id', 'n'] ).drop_duplicates('family_id', keep='last')
return df.day.values
|
Santa's Workshop Tour 2019
|
6,942,227 |
train.groupby(['Pclass'], as_index = False)['Age'].median()<categorify>
|
N_DAYS = 100
N_FAMILIES = 5000
MAX_OCCUPANCY = 300
MIN_OCCUPANCY = 125
data = pd.read_csv('/kaggle/input/santa-workshop-tour-2019/family_data.csv', index_col='family_id')
FAMILY_SIZE = data.n_people.values
DESIRED = data.values[:, :-1] - 1
PCOSTM = GetPreferenceCostMatrix(data)
ACOSTM = GetAccountingCostMatrix()
|
Santa's Workshop Tour 2019
|
6,942,227 |
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<feature_engineering>
|
pivot_data = data.groupby(['choice_0'])['n_people'].agg(['sum'])
pivot_data = pd.DataFrame(pivot_data)
pivot_data.columns = ['Occupancy for all First Choices']
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Age'] = train[['Age','Pclass']].apply(lambda x: impute_age(x), axis = 1)
test['Age'] = test[['Age','Pclass']].apply(lambda x: impute_age(x), axis = 1 )<count_values>
|
prediction = solveSantaLP()
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction)
print('{}, {:.2f},({}, {})'.format(penalty.sum() ,
accounting_cost.sum() ,
occupancy.min() ,
occupancy.max()))
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Embarked'].value_counts()<feature_engineering>
|
fixMinOccupancy(prediction)
fixMaxOccupancy(prediction)
penalty, accounting_cost, n_out_of_range, occupancy = cost_stats(prediction)
print('{}, {:.2f},({}, {})'.format(penalty.sum() ,
accounting_cost.sum() ,
occupancy.min() ,
occupancy.max()))
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Embarked'] = np.where(~train['Embarked'].isnull() ,train['Embarked'],'S' )<feature_engineering>
|
round2 = stochastic_product_search(
top_k=2,
fam_size=6,
original=prediction,
n_iter=350000,
verbose=1000,
verbose2=50000,
random_state=2019
)
|
Santa's Workshop Tour 2019
|
6,942,227 |
test['Fare'] = np.where(~test['Fare'].isnull() ,test['Fare'],test['Fare'].median() )<count_missing_values>
|
round3 = stochastic_product_search(
top_k=2,
fam_size=7,
original=round2,
n_iter=350000,
verbose=1000,
verbose2=50000,
random_state=2019
)
|
Santa's Workshop Tour 2019
|
6,942,227 |
print('Train','
',(train.isnull().sum() /len(train)) *100)
print('-'*20)
print('Test','
',(test.isnull().sum() /len(test)) *100 )<feature_engineering>
|
round4 = stochastic_product_search(
top_k=2,
fam_size=8,
original=round3,
n_iter=350000,
verbose=1000,
verbose2=50000,
random_state=2019
)
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Cabinknown'] = 0
train['Cabinknown'] = np.where(( train['Cabin'].isnull()),train['Cabinknown'],1)
test['Cabinknown'] = 0
test['Cabinknown'] = np.where(( test['Cabin'].isnull()),test['Cabinknown'],1)
train[['Cabinknown','Survived']].groupby('Cabinknown' ).mean()<feature_engineering>
|
round5 = stochastic_product_search(
top_k=2,
fam_size=9,
original=round4,
n_iter=350000,
verbose=1000,
verbose2=50000,
random_state=2019
)
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Cabinletter'] = train['Cabin'].str[0]
test['Cabinletter'] = test['Cabin'].str[0]<feature_engineering>
|
final = stochastic_product_search(
top_k=2,
fam_size=12,
original=round5,
n_iter=150000,
verbose=1000,
verbose2=50000,
random_state=2019
)
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Title'] = train['Name'].str.split(r'\s*,\s*|\s*\.\s*' ).str[1]
test['Title'] = test['Name'].str.split(r'\s*,\s*|\s*\.\s*' ).str[1]<feature_engineering>
|
sub = pd.DataFrame(range(N_FAMILIES), columns=['family_id'])
sub['assigned_day'] = final+1
sub.to_csv('submission_5.csv', index=False )
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Family'] = train['SibSp'] + train['Parch'] + 1
test['Family'] = test['SibSp'] + test['Parch'] + 1<feature_engineering>
|
df0 = data[['choice_0','n_people']]
df0.columns = ['choice_0','n_people']
df0
|
Santa's Workshop Tour 2019
|
6,942,227 |
train['Agegroup'] = np.where(train['Age']<17,0,(np.where(( train['Age']>17)&(train['Age']<55),1,2)))
test['Agegroup'] = np.where(test['Age']<17,0,(np.where(( test['Age']>17)&(test['Age']<55),1,2)) )<feature_engineering>
|
df1 = pd.DataFrame([prediction] ).transpose()
df1.columns = ['Prediction']
df1
|
Santa's Workshop Tour 2019
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.