Datasets:

Abirate
/

all_write_ups

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 3.85k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

Title of Competition stringclasses 343 values	Title of Writeup stringlengths 6 139	User stringclasses 1 value	Writeup stringlengths 419 80.4k
SIIM-ISIC Melanoma Classification	139th Place Summary	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p><a href="https://www.kaggle.com/fahad7" target="_blank">@fahad7</a> : it was just averaging the predictions for ensembling. And for CV, it was stratified K Fold cross validation. </p> <p>Congrats to winners.. </p> <p>I would like to thank my teammate Sebastien (@Anhmeow) for his amazing contribution in getting this position. Our best solution was rank ensemble of 8 different models which we had created in parallel and ensembled it using stacking. </p> <p>We had created 80 models in total and selected only those models which were less correlated.</p> <ol> <li>EfficientNet B4 - Image size - 512 - Sebastien</li> <li>EfficientNet B4 - Image Size - 768 - Sebastien</li> <li>EfficientNet B6 - Image Size - 768 - Sebastien</li> <li>EfficientNet B5 - Image Size - 384 - Manoj</li> <li>EfficientNet B6 - Image Size - 512 - Including external data - Manoj</li> <li>EfficientNet B5 - Image size - 384 - without external data - Manoj</li> <li>EfficientNet B5 - Image size - 384 - Including external data - Manoj</li> <li>EfficientNet B6 - Image size - 512 - without external data - Sebastien</li> </ol> <p>The mean ensemble of these models scored around 0.9432 in private LB while rank ensemble scored 0.9406. </p> <p>Special thanks to <a href="https://www.kaggle.com/Cdeotte" target="_blank">@Cdeotte</a> for providing wonderful notebooks and discussion threads</p> <p>What we tried but couldn't complete:</p> <ol> <li><p>GAN's - Inspired by this paper <a href="https://www.paperswithcode.com/paper/melanoma-detection-using-adversarial-training-1" target="_blank">https://www.paperswithcode.com/paper/melanoma-detection-using-adversarial-training-1</a> and Rohit's post. <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F413189%2F3dd7a16f80823987e41fcd2d9f252904%2FGAN%20Sample.png?generation=1597751688287238&alt=media" alt=""></p></li> <li><p>Chipnet - Even though the performance was impressive, we couldn't complete it due to paucity of time. </p></li> </ol>
SIIM-ISIC Melanoma Classification	157th place solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Congratulations to all the winners and to everyone who took part in this. It was a great learning experience for me and I'll share what finally worked for me. There is still so much to learn by going through the solution overviews and more discussions/kernels. The best performance I was able to get was public LB: 0.9570, private LB: 0.9403.</p> <h2>Data</h2> <p>My best model is an ensemble (just the mean of the predictions) of 4 models. I am using <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a>'s Triple Stratified Split. 3 models were trained on data from 2017 + 2018 + 2020. One of the models was trained on 2017 + 2018 + 2019 + archives + 2020.</p> <h2>Image sizes</h2> <p>3 models were trained on 512x512 images and 1 model on 384x384.</p> <h2>Augmentations</h2> <p>2 models use the following augmentations (using <code>kornia</code>):</p> <pre><code>- name: Rescale params: value: 255. - name: RandomAffine params: degrees: 180 translate: - 0.02 - 0.02 - name: RandomHorizontalFlip params: p: 0.5 - name: ColorJitter params: saturation: - 0.7 - 1.3 contrast: - 0.8 - 1.2 brightness: 0.1 - name: Normalize params: mean: imagenet std: imagenet </code></pre> <p>The meaning of different params can be found from <code>kornia</code>'s <a href="https://github.com/kornia/kornia/blob/master/kornia/augmentation/augmentation.py" target="_blank">documentation</a>.</p> <p>The other 2 models additionally use <code>Cutout</code>:</p> <pre><code>- name: RandomErasing params: p: 0.5 ratio: - 0.3 - 3.3 scale: - 0.02 - 0.1 </code></pre> <h2>Sampling</h2> <p>To iterate faster, instead of upsampling the minority class, I downsample the majority class per epoch. However, to avoid wasting data, I sample different instances from the majority class per epoch.</p> <h2>Network</h2> <p>The same network architecture is used for all the 4 models - EfficientNet-B5 features followed by a Linear layer.</p> <h2>Optimization</h2> <pre><code>Optimizer: AdamW weight decay: 0.1 epochs: 20 LR scheduler: 1cycle with initial LR = 5e-6, max LR = 2e-4 (LR range test) </code></pre> <h2>Things I wanted to try but couldn't</h2> <ul> <li>Train on images of different sizes for the 3 best configs on 512x512 and ensemble</li> <li>Incorporate meta-data by stacking it with the features from the deep model</li> <li>Spend time improving my ensembles</li> <li>More augmentations</li> <li>Custom head</li> </ul> <p>Thanks, Chris. Happy to know that I could contribute an idea to your playbook! :) </p> <p>Yes, the trick is to start on the competition early enough. And I missed that too. All the best! </p> <p>Thanks <a href="https://www.kaggle.com/realsid" target="_blank">@realsid</a>. Don't worry, it's very important to ask questions! :) </p> <p>So, for my best models, I only added a single linear layer on top of the features from the backbone (to avoid overfitting). But in general, and also looking at the solutions of the winners, it is better to add more layers on top of the convolutional features. Is that clearer?</p>
SIIM-ISIC Melanoma Classification	16 Place Solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>worth a try :)</p> <p>It's possible same patient at the same time gets a different diagnosis from different doctors… <br> But we could do feature engineering in stacking, and let CV tells if this information (grouped predictions) is predictive :)</p> <p>Indeed, I believe more information about the patient might help!</p> <p>I'm confused the same as you do after doing some patient level EDA. Maybe it's the noise in the label(diagnosis)</p> <p>My intuition for this is</p> <ol> <li><p>For the same patient, model might have unstable predictions, referencing other observations by taking MEAN and STD of predictions from the same patient might help during stacking (which turns out not from CV)</p></li> <li><p>If patients get malignant at age X, they might be still having malignant in age X+5 in the same parts (which is bad for patients not getting better…). But after doing some EDA, I could tell this mostly is not the case in our dataset.</p></li> </ol> <p><a href="https://www.kaggle.com/serigne" target="_blank">@serigne</a> Congrats to you too! I understand stacking for the first time from your kernel in the house price prediction when I join Kaggle :D, and continue to learn more stacking from <a href="https://www.kaggle.com/kazanova" target="_blank">@kazanova</a> </p> <p><a href="https://www.kaggle.com/ajtryt2" target="_blank">@ajtryt2</a> Adam with LR=2e-5* tpu_replicas, constant scheduling with 15 epochs, using TTA from 11 to 15 epochs' model weights.</p> <p>Your cv is amazing for a single model, did you add external data to the validation folds or keep it the same as without external data? What is your settings for LR schedule? Thanks in advance </p> <p>Congrats to all winners! Thank you to the organizers and Kaggle for hosting this competition. We really hope that the winning models can make a difference here. Thank you <a href="https://www.kaggle.com/kazanova" target="_blank">@kazanova</a> for all the works we have tried. It was fun!</p> <p>We also want to extend our gratitude to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> (<a href="https://www.kaggle.com/cdeotte" target="_blank">https://www.kaggle.com/cdeotte</a>) for the great work that he did throughout the competition, providing very useful insights as well as preparing the datasets in a good format to make them easy to use.</p> <p>Our approach is an ensemble of 30+ different models built with various combinations of image sizes and networks. We used a 5-fold CV and we optimized for logloss. <em>We found logloss to be a bit more stable than AUC when assessing what the best model is.</em> We could run the same model with different seed and (even though there was a lot of TTA ) the differences in AUC could be +- 0.02 in a single fold, whereas logloss was much more stable.</p> <p>The augmentations that worked best for us (apart from the usual ones like rotations and flips) were (in this order):</p> <ul> <li>Coarse dropout </li> <li>Grid mask</li> <li>Cutmix</li> <li>mixup</li> </ul> <p><strong>Network-wise, we only used EfficientNet models.</strong> We experimented with other pretrained networks, but they did not perform as well. The best performing combination of model and size was EfficientNet b5 with 512. Most of our models were built in tensorflow using TPUs (in colab or Kaggle). The TPU environment made quite a big difference for us – we were able to accelerate training and experimentation which fundamentally helped us to find good training schemas for this competition. We had some models built in pytorch too. Cv-wise both frameworks were close, with the tensorflow implementation being a bit better here (in both cv and LB).</p> <p><strong>Constant scheduling, checkpoint averaging and a lot of tta (with 30 different combinations of augmentations) worked very well.</strong> Each fold prediction used 150 inferences (5 checkpoint x 30 augmentations). This helped a lot to create stability for our models. Apart from averages, for every model, we also used maximum, minimum, standard deviation and geometrical mean (of all those 150 predictions). <em>We were quite surprised that standard deviation was quite often performing better than mean in both logloss and AUC. The interpretation could be that the more uncertain we are about what the actual prediction is, the more likely it is to be malignant.</em></p> <p><strong>For our final model, we used stacking using ExtraTreesClassifier</strong> (<a href="https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html" target="_blank">https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html</a>) . Our cv was 0.9536 (and LB 0.9457). Our best performing stacking model (version 38) was (almost) the best at private LB. Our previous version (37) was the best. There is very good relationship between cv and LB for all our stacking models.</p> <p><strong>Detailed recipes that work\not work for us</strong></p> <p><strong>What works well:</strong></p> <ul> <li>2018, and external data (with 30K samples)</li> <li>Multiple Checkpoint + TTA with Mean\Max\Min\Std </li> <li>Different sized images and efficientnets (efb5, 512 is best in cv)</li> <li>Pretrain with external data, then finetune on 2020 data</li> <li>Stacking with extraTreesClassifier</li> </ul> <p><strong>What works not well:</strong></p> <ul> <li>Train a multiclassifier</li> <li>Focal loss</li> <li>Patient-level stacking: aggregate predictions by patient</li> <li>Tuning with SWA/AdamW/stochastic depth for efficientnets</li> <li>Batch accumulation for larger image sizes (768\1024)</li> </ul>
SIIM-ISIC Melanoma Classification	176th Place Write-up	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>First of all, I would like to thank kaggle and the organizers for hosting such interesting competition and thank for my team <a href="https://www.kaggle.com/seshurajup" target="_blank">@seshurajup</a> <a href="https://www.kaggle.com/shravankoninti" target="_blank">@shravankoninti</a> <a href="https://www.kaggle.com/jakkulasasikiran" target="_blank">@jakkulasasikiran</a> <a href="https://www.kaggle.com/mounikabellamkonda" target="_blank">@mounikabellamkonda</a>. This was great learning and collaboration.</p> <p>special thanks to <a href="https://www.kaggle.com/shravankoninti" target="_blank">@shravankoninti</a> we worked hard for the last two months.</p> <h2>[Summary]</h2> <ul> <li>First, we trained a simple model using <strong>E1 256X256</strong> using 5Fold <strong>CV: 0.88</strong></li> <li>Then we analyze the predictions mostly <strong>FP</strong> and <strong>FN</strong></li> </ul> <p><strong>FP</strong> <code>Target = 1 and Predict < 0.2</code><br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2058044%2F6d599f0c9466d695b86a10bad076b821%2FFP.png?generation=1597827587126099&alt=media" alt=""><br> <strong>FN</strong> <code>Target = 0 and Predict > 0.8</code><br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2058044%2Fc123c7520e87fcb326cb52a2cc3dd1c6%2FFN.png?generation=1597827662475852&alt=media" alt=""></p> <ul> <li>we removed <strong>FP</strong> and <strong>FN</strong> base on the threshold </li> <li>trained the same model for training, we exclude <strong>FP</strong> and <strong>FN</strong> cv increased to <strong>0.9012</strong></li> <li>using same <strong>E1</strong> model to find <strong>FP</strong> and <strong>FN</strong> on <strong>2017-2018-2019</strong> data</li> <li>we removed <strong>FP</strong> and <strong>FN</strong> on <strong>2017-2018-2019</strong> </li> <li>same model trained again on <strong>2017-2018-2019-2020</strong> we get CV:0.92+ LB:0.95+ PLB:0.925+</li> </ul> <h2>[PyTorch]</h2> <p>for PyTorch setup, we are used DeepFake Winners solution scripts: <a href="https://github.com/selimsef/dfdc_deepfake_challenge" target="_blank">link</a> Big thanks to <a href="https://www.kaggle.com/selimsef" target="_blank">@selimsef</a></p> <ul> <li>For CV we are used <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">Triple Stratified Leak-Free KFold CV</a> thanks to <a href="https://www.kaggle.com/cdotte" target="_blank">@cdotte</a> </li> <li>For training, we are used Pytorch 1.6 Native AMP. Notebook: <a href="https://www.kaggle.com/gopidurgaprasad/siim-pytorch-1-6-native-amp" target="_blank">link</a></li> <li>Optimizer: <code>Adam</code></li> <li>Schedule : <code>LearningRateScheduler</code> for <a href="https://www.kaggle.com/cdotte" target="_blank">@cdotte</a> notebook</li> <li>CUTMIX + MIXUP it working some time </li> <li>Sampling: Upsample(US) + Downsample(DS) + Nosampling(NS) for same model at the end we take simpleaverg for those. <br> <code>sampler = BalanceClassSampler(labels=train_dataset.__get_labels__(), mode="downsampling")</code><br> you found WeightedClassSampler from this notebook : <a href="https://www.kaggle.com/gopidurgaprasad/pytorch-weightedclasssampler" target="_blank">link</a></li> <li>Loss: simply<code>BinaryCrossentropy</code></li> <li>Augmentations:</li> </ul> <pre><code>A.Compose([ A.OneOf([ A.VerticalFlip(), A.HorizontalFlip(), A.Flip(), A.Rotate() ], p=0.5), A.Transpose(p=0.2), A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=15), A.RandomRotate90(p=0.1), A.OneOf([ A.RandomGridShuffle(p=0.1), A.Cutout(num_holes=8, max_h_size=size//8, max_w_size=size//8, fill_value=0, p=0.2), A.CoarseDropout(max_holes=4, max_height=size//8, max_width=size//8, p=0.2), A.GridDropout(p=0.2), RandomEraser(p=0.2), BitMask(size=size, p=0.1), ], p=0.11), A.RandomBrightness(limit=(-0.2,0.2), p=0.1), A.OneOf([ IsotropicResize(max_side=size, interpolation_down=cv2.INTER_AREA, interpolation_up=cv2.INTER_CUBIC), IsotropicResize(max_side=size, interpolation_down=cv2.INTER_AREA, interpolation_up=cv2.INTER_LINEAR), IsotropicResize(max_side=size, interpolation_down=cv2.INTER_LINEAR, interpolation_up=cv2.INTER_LINEAR), ], p=1), A.PadIfNeeded(min_height=size, min_width=size, border_mode=cv2.BORDER_CONSTANT) </code></pre> <h4>Pytorch Models</h4> <table> <thead> <tr> <th>Model</th> <th>SIZE</th> <th>RESIZE</th> <th>SAMPLE</th> <th>FOLDS</th> <th>CV</th> </tr> </thead> <tbody> <tr> <td>E4</td> <td>512</td> <td>380</td> <td>DS</td> <td>5</td> <td>0.9175</td> </tr> <tr> <td>Sk50</td> <td>512</td> <td>512</td> <td>DS</td> <td>5</td> <td>0.9178</td> </tr> <tr> <td>E6</td> <td>768</td> <td>528</td> <td>DS</td> <td>10</td> <td>0.9266</td> </tr> <tr> <td>E5</td> <td>512</td> <td>456</td> <td>DS</td> <td>5</td> <td>0.9288</td> </tr> <tr> <td>E7</td> <td>512</td> <td>512</td> <td>DS</td> <td>5</td> <td>0.9224</td> </tr> <tr> <td>Dpn92</td> <td>512</td> <td>512</td> <td>DS</td> <td>5</td> <td>0.9218</td> </tr> <tr> <td>E5</td> <td>512</td> <td>456</td> <td>DS</td> <td>10</td> <td>0.9229</td> </tr> <tr> <td>D201</td> <td>512</td> <td>512</td> <td>DS</td> <td>5</td> <td>0.9266</td> </tr> <tr> <td>D201</td> <td>512</td> <td>512</td> <td>US</td> <td>5</td> <td>0.9240</td> </tr> <tr> <td>E6</td> <td>768</td> <td>528</td> <td>US</td> <td>5</td> <td>0.9203</td> </tr> <tr> <td>E4</td> <td>512</td> <td>380</td> <td>US</td> <td>10</td> <td>0.9242</td> </tr> <tr> <td>E5</td> <td>512</td> <td>456</td> <td>NS</td> <td>5</td> <td>0.9153</td> </tr> <tr> <td>D201</td> <td>512</td> <td>224</td> <td>NS</td> <td>5</td> <td>0.9185</td> </tr> <tr> <td>B5</td> <td>512</td> <td>456</td> <td>US</td> <td>10</td> <td>0.9234</td> </tr> <tr> <td>D201</td> <td>512</td> <td>224</td> <td>US</td> <td>5</td> <td>0.9068</td> </tr> </tbody> </table> <h4>SimpleAverage</h4> <ul> <li>simply average all models CV:<strong>0.9372</strong> LB:<strong>0.9544</strong> PLB<strong>0.9388</strong></li> </ul> <h4>OptimizeAUC</h4> <ul> <li>for optimizing OOF AUC we are using OptimizeAUC function from <a href="https://www.amazon.in/dp/B089P13QHT/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1#:~:text=This%20book%20is%20for%20people,learning%20and%20deep%20learning%20problems." target="_blank">Approaching (Almost) Any Machine Learning Problem</a> by <a href="https://www.kaggle.com/abhishek" target="_blank">@abhishek</a> Big thanks to him.</li> <li>you found the OptimizeAUC in this notebook: <a href="https://www.kaggle.com/gopidurgaprasad/optimize-auc-using-oof" target="_blank">link</a></li> <li>CV:<strong>0.94741</strong> LB:<strong>0.9492</strong> PLB<strong>0.9344</strong></li> </ul> <p><strong>Pytorch Training Notebook:</strong> <a href="https://www.kaggle.com/gopidurgaprasad/siim-final-d201-ns" target="_blank">link</a></p> <h2>[TF]</h2> <ul> <li>we are using <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">Triple Stratified KFold with TFRecords</a> again Big thanks to <a href="https://www.kaggle.com/cdotte" target="_blank">@cdotte</a></li> <li>thanks to <a href="https://www.kaggle.com/shravankoninti" target="_blank">@shravankoninti</a> running those TF models one by one every data</li> </ul> <table> <thead> <tr> <th>Model</th> <th>SIZE</th> <th>FOLDS</th> <th>CV</th> </tr> </thead> <tbody> <tr> <td>E7</td> <td>512</td> <td>15</td> <td>0.8826</td> </tr> <tr> <td>E6</td> <td>512</td> <td>15</td> <td>0.9194</td> </tr> <tr> <td>E5</td> <td>512</td> <td>15</td> <td>0.9243</td> </tr> <tr> <td>E7</td> <td>512</td> <td>10</td> <td>0.9163</td> </tr> <tr> <td>E6</td> <td>512</td> <td>10</td> <td>0.9027</td> </tr> <tr> <td>E5</td> <td>512</td> <td>10</td> <td>0.9275</td> </tr> <tr> <td>E4</td> <td>512</td> <td>10</td> <td>0.9114</td> </tr> <tr> <td>E3</td> <td>512</td> <td>10</td> <td>0.9133</td> </tr> <tr> <td>E2</td> <td>512</td> <td>10</td> <td>0.9154</td> </tr> <tr> <td>E1</td> <td>512</td> <td>15</td> <td>0.9142</td> </tr> <tr> <td>E7</td> <td>768</td> <td>5</td> <td>0.9076</td> </tr> <tr> <td>E6</td> <td>768</td> <td>5</td> <td>0.9161</td> </tr> <tr> <td>E5</td> <td>768</td> <td>5</td> <td>0.9063</td> </tr> <tr> <td>E4</td> <td>768</td> <td>5</td> <td>0.9144</td> </tr> <tr> <td>E3</td> <td>768</td> <td>5</td> <td>0.9019</td> </tr> <tr> <td>E2</td> <td>768</td> <td>5</td> <td>0.8917</td> </tr> <tr> <td>E1</td> <td>768</td> <td>5</td> <td>0.8866</td> </tr> <tr> <td>E7</td> <td>384</td> <td>5</td> <td>0.9212</td> </tr> <tr> <td>E6</td> <td>384</td> <td>5</td> <td>0.9237</td> </tr> <tr> <td>E5</td> <td>384</td> <td>5</td> <td>0.9278</td> </tr> </tbody> </table> <h4>SimpleAverage</h4> <ul> <li>simply average all TF models CV:<strong>0.9301</strong> LB:<strong>0.9503</strong> PLB<strong>0.9376</strong></li> </ul> <h4>OptimizeAUC</h4> <ul> <li>CV:<strong>0.9446</strong> LB:<strong>0.9538</strong> PLB<strong>0.9348</strong></li> </ul> <h2>[PyTorch + TF]</h2> <h4>SimpleAverage</h4> <ul> <li>simply average all PyTorch and TF models CV:<strong>0.9402</strong> LB:<strong>0.9538</strong> PLB:<strong>0.9399</strong></li> <li>This is our <strong>best-selected submission</strong></li> </ul> <h4>OptimizeAUC</h4> <ul> <li>CV:<strong>0.949354</strong> LB:<strong>0.9496</strong> PLB:<strong>0.9362</strong></li> </ul> <h2>🎊 Congratulations to all Winners and Learners 🎊</h2> <p>Thanks brother 😍 keep rocking </p> <p>Thank you 😍</p>
SIIM-ISIC Melanoma Classification	1868th place in 1st competition!	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I joined the competition very late, just 10 days ago. So, I forked a notebook: <a href="https://www.kaggle.com/niteshx2/full-pipeline-dual-input-cnn-model-with-tpus" target="_blank">https://www.kaggle.com/niteshx2/full-pipeline-dual-input-cnn-model-with-tpus</a> </p> <p>So, what did I do differently? I tried changing epochs, not using coarse drop out, removing duplicates and finally I used a trick that gave a 0.007 improvement. The trick was to take max of past 2 predictions. </p> <p>"Kill them with success and bury them with a smile." :)</p>
SIIM-ISIC Melanoma Classification	1st place solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I'm not aware papers on this trick. (There are too many AI papers these days to keep up with)</p> <p>And it's a common trick in ML, probably not significant enough for a paper.</p> <p>Check out Chris's post about cross validation: <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175614" target="_blank">https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175614</a></p> <p>In short, there's never overlap between training and cv data</p> <p>Currently, best computer vision architectures are different version of Efficient Nets. Generally you don't need to worry about changing it, especially for beginners </p> <p>Here it probably doesn't matter. It might be better than Relu depending on the data and network.</p> <p>yeah we used 2019 data that Chris shared. We used it <em>because of</em> its different distribution, e.g. higher positive sample proportion </p> <p>you're right. It is based on <code>patient_id</code> information. (Although dropping it doesn't hurt our score.)</p> <p>malignant vs benign information is a subset of diagnosis information</p> <p>By using diagnosis as target, you're giving the model more information. It can help the model learn representation better.</p> <p>Imagine you have a bunch of images of dog, cat, wolf, bird, fox …<br> Method 1: You label them as dog vs not dog<br> Method 2: You label them as dog, cat, wolf, bird, fox separately</p> <p>In method 2, the model could learn decision boundary of dog vs wolf better, because now it knows what's what.</p> <p>cv means cross-validation. People use "cv" to refer to cross validation score</p> <p>lb means leaderboard. People use "lb" to refer to leaderboard score</p> <p>It depends on your definition of survive. 😏 If we emerged as a survivor after a major event (whether it's shakeup or shakedown), I think we can say we survived.</p> <p>Anyways, thanks for your notebook showing how to use meta data.</p> <p>The mapping was based on the diagnosis description on last year competition's website: <a href="https://challenge2019.isic-archive.com/" target="_blank">https://challenge2019.isic-archive.com/</a></p> <p>Note that models using meta data tend to overfit more easily than models with images only, because augmentations do not apply to meta data</p> <p>Not all combinations. That would be too many 😄</p> <p>For example, 896 can only be used on the smaller B3</p> <p>Say your model 1's probability distribution has mean p=0.05; model 2's probability distribution has mean p=0.5. If you simply take average without ranking first, then model 2 would dominate model 1. </p> <p>By using rank, you can force them to make equal contributions.</p> <p>It's actually replace <code>a</code> and <code>b</code> with 1/2 in your example. I don't know what will happen if you submit probabilities larger than 1.</p> <p>For any 2-dimensional image, rotate90 or rotate180 can be achieved using flip and transpose operations only. </p> <p>For example, transpose+vertical flip equals to rotate90</p> <p>It's hard to do ablation on augmentations -- the cv score variance is too large to draw meaningful conclusions when comparing two runs that only diff by an augmentation parameter.</p> <p>When we tune the augmentations, we only check 1 fold's score without TTA, to have a general idea. However, even 5 fold cv with TTAx8 have noise (i.e. same code with different seeds lead to somewhat different scores).</p> <p>So the augmentation hyper parameters we used are not optimal, but should be good enough.</p> <p>Thanks. Yeah the model is pretty vanilla. We have posted our code here: <a href="https://www.kaggle.com/haqishen/1st-place-soluiton-code-small-ver#Define-Dataset" target="_blank">https://www.kaggle.com/haqishen/1st-place-soluiton-code-small-ver#Define-Dataset</a></p> <p>just a simple average of ranked probabilities</p> <p>There are different components in the pipeline where pytorch is easier to use or more flexible than TF. For example, in TF, it's hard to achieve augmentations similar to ours.</p> <p>We didn't trust LB so we didn't submit every single model. </p> <p>On cv, adding meta helped <code>cv_all</code> but hurt <code>cv_2020</code>. Overall, combining models with meta and models without meta seems like good diversity for ensemble.</p> <blockquote> <p>do you modify a bunch of parameters/augmentation method together?</p> </blockquote> <p>Usually make one change at a time</p> <blockquote> <p>Is there some systematic way to explore relatively optimal augmentation hyperparameters?</p> </blockquote> <p>Use smaller model and smaller image for faster iteration</p> <blockquote> <p>If we rank predictions firstly, I guess all pred_probs values are actually converted to percentile rank values. Therefore, the absolute difference between the original pred_probs has no influence anymore. which forces 2 models to contribute equally. Is this what you're saying?</p> </blockquote> <p>Yes precisely</p> <blockquote> <p>So this trick is designed for the AUC metric of his competition specifically?</p> </blockquote> <p>It applies to any metric where only the relative order of predictions (not absolute values) matter</p> <p>Personally I don't think there's much (if any) additional information beyond single images and meta data. It's just my hunch, not conclusion based on experiments.</p> <p>Thanks. No we didn't. We treat each data sample independently.</p> <p>Think of any given single model's LB score as a normal random variable with big standard deviation. Now, if you take the average of 5 such i.i.d. normal random variables, the standard deviation will be smaller, according to law of large number.</p> <p>Similarly, ensemble model's variation (i.e. "shake") is generally smaller than single model. The variation is averaged out.</p> <p>Congratulations to all winners, especially my teammates Qishen <a href="https://www.kaggle.com/haqishen" target="_blank">@haqishen</a> and Gary <a href="https://www.kaggle.com/garybios" target="_blank">@garybios</a> who are both computer vision competition veterans. I learned a lot from you. So happy to see you both on top of another LB after the deepfake drama.</p> <p>Big shoutout to my colleague Chris <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> who I feel like served as an unofficial host of this competition with all your datasets, notebooks and tutorials. The competition wouldn't be this popular with all your contribution. We used your resized jpg images and triple stratified leak-free folds. Thanks Chris.</p> <h2>How we survived the shake</h2> <p>The test set is very small, with very small proportion of positive samples. So public LB has huge variance. Even the 2020 train data is not big enough for validation purpose, due to its small positive samples. </p> <p>To have stable validation, we used 2018+2019+2020's data for both train and <strong>validation</strong>. We track two cv scores, <code>cv_all</code> and <code>cv_2020</code>. The former is much more stable than the latter.</p> <p>Second key to LB survival is ensemble. Our single model's LB-cv correlation is essential 0, but the bigger the ensemble, the more stable the LB. In the last few days, our ensemble's LB was steadily increasing as we added better models.</p> <p>Our final ensemble 1 optimizes <code>cv_all</code> and final ensemble 2 optimizes <code>cv_2020</code></p> <p>Ensemble 1: <code>cv_all=0.9845, cv_2020=0.9600, public=0.9442, private=0.9490</code> (1st place)<br> Ensemble 2: <code>cv_2020=0.9638, public=0.9494, private=0.9481</code> (3rd place)</p> <p>Our best single model has <code>cv_2020=0.9481</code></p> <p>All scores above are 5 fold, TTAx8.</p> <h2>TPU vs GPU, TF vs torch</h2> <p>TPU with TF seems to be dominating the public notebooks in this competition. It seems to be faster than torch/GPU on EfficientNets. However, our experiments showed that its high LB scores are due to better luck with the public LB. Our torch/GPU models have much better CV, thanks to the better PyTorch ecosystem and flexibility for faster experiments.</p> <h2>Models</h2> <p>Our ensembles consists of EfficientNet B3-B7, se_resnext101, resnest101. There are models with or without meta data. Input size ranges from 384 to 896. (All input are from Chris's resized jpgs. For example, for 896 input we read 1024 jpgs and resize to 896.) </p> <h2>Meta data</h2> <p>In some (not all) of our models, we used 14 meta data from <a href="https://www.kaggle.com/nroman/melanoma-pytorch-starter-efficientnet" target="_blank">this</a> and <a href="https://www.kaggle.com/awsaf49/xgboost-tabular-data-ml-cv-85-lb-787#Image-Size" target="_blank">this</a> public notebooks, as illustrated below.<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1120704%2Fae8a6c8597a1f1ab4649fc72627c9378%2Fmeta_NN.png?generation=1597734243315450&alt=media" alt=""></p> <h2>Targets</h2> <p>We find that using diagnosis as targets with cross entropy loss instead of binary target with BCE loss can boost score by ~0.01. </p> <p>2020 data's diagnosis sets and 2019 data's diagnosis sets are different. We manually map 2020's to 2019's. There are 9 labels.</p> <pre><code>2020 seborrheic keratosis -> BKL 2020 lichenoid keratosis -> BKL 2020 solar lentigo -> BKL 2020 lentigo NOS -> BKL 2020 cafe-au-lait macule -> unknown 2020 atypical melanocytic proliferation -> unknown 2020 nevus -> NV 2020 melanoma -> MEL </code></pre> <p>For prediction, we simply take the <code>MEL</code> class's softmax probability.</p> <h2>Augmentations</h2> <pre><code>transforms_train = A.Compose([ A.Transpose(p=0.5), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.RandomBrightness(limit=0.2, p=0.75), A.RandomContrast(limit=0.2, p=0.75), A.OneOf([ A.MotionBlur(blur_limit=5), A.MedianBlur(blur_limit=5), A.GaussianBlur(blur_limit=5), A.GaussNoise(var_limit=(5.0, 30.0)), ], p=0.7), A.OneOf([ A.OpticalDistortion(distort_limit=1.0), A.GridDistortion(num_steps=5, distort_limit=1.), A.ElasticTransform(alpha=3), ], p=0.7), A.CLAHE(clip_limit=4.0, p=0.7), A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=10, p=0.5), A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=15, border_mode=0, p=0.85), A.Resize(image_size, image_size), A.Cutout(max_h_size=int(image_size * 0.375), max_w_size=int(image_size * 0.375), num_holes=1, p=0.7), A.Normalize() ]) transforms_val = A.Compose([ A.Resize(image_size, image_size), A.Normalize() ]) </code></pre> <h2>Post processing</h2> <p>When ensembling different folds, or different models, we first rank all the probabilities of each model/fold, to ensure they are evenly distributed. In pandas, it can be done by <code>df['pred'] = df['pred'].rank(pct=True)</code></p> <h2>Code</h2> <p><a href="https://github.com/haqishen/SIIM-ISIC-Melanoma-Classification-1st-Place-Solution" target="_blank">https://github.com/haqishen/SIIM-ISIC-Melanoma-Classification-1st-Place-Solution</a></p> <p>We did use meta (i.e. tabular) data in some of our models, similar to <a href="https://www.kaggle.com/nroman/melanoma-pytorch-starter-efficientnet" target="_blank">this</a> public notebook. Let me add more information on that and update the original post. </p>
SIIM-ISIC Melanoma Classification	21st Public - 53rd Private - Trust Your CV	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>UPDATE: I posted another discussion <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175614" target="_blank">here</a> explaining How To CV and How To Ensemble</p> <p>Thank you Baron</p> <p>Don't feel bad. It takes skill to read the dozens of public notebooks and decide which ones can be trusted. For example, my best sub in Melanoma comp was also using my work plus some public notebooks that I trusted. </p> <p>In most comps, I use my second final submission as a mix of my work with public notebooks that I trust.</p> <p>In my popular public notebook <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">here</a>, just change <code>prepare_image()</code> function to the following. </p> <pre><code>IMG_SIZES = [512]FOLDS CROP = 384 def prepare_image(img, augment=True, dim=256): img = tf.image.decode_jpeg(img, channels=3) img = tf.cast(img, tf.float32) / 255.0 if augment: if dim!=CROP: img = tf.image.random_crop(img, [CROP, CROP, 3]) img = transform(img,DIM=CROP) img = tf.image.random_flip_left_right(img) img = tf.image.random_saturation(img, 0.7, 1.3) img = tf.image.random_contrast(img, 0.8, 1.2) img = tf.image.random_brightness(img, 0.1) elif dim!=CROP: img = tf.image.central_crop(img,CROP/dim) img = tf.reshape(img, [CROP,CROP, 3]) return img </code></pre> <p>And then when you build the model, use</p> <pre><code>model = build_model(dim=CROP, ef=EFF_NETS[fold]) </code></pre> <p>Great question. After training, all OOF predictions use <code>TTA = 21</code>. So the validation OOF predictions are the average of 21 random crops. (Also the test set predictions are the average of 21 random crops).</p> <p>During training, TF computes the validation loss and validation AUC using a single 384 center crop. (Assuming we're training with 512 and random cropping 384). This is the validation loss used for early stopping or model checkpoint.</p> <p>Thanks XY=ABCD. Congrats for your bronze medal</p> <p>Thanks Mark. Congrats on finishing 49th solo silver. That's fantastic.</p> <p>I see what you're trying to do. That's an interesting idea.</p> <p>Unfortunately, that won't work because the OOF are not an ensemble. In the OOF, each training image only has 1 prediction. Whereas in the test dataset, each image has 5 different predictions. So the test predictions are an ensemble, but the OOF predictions are just a "merging". As such you can't use "merging" weights to decide ensemble weights.</p> <p>I see what you're trying to do. That's an interesting idea.</p> <p>Unfortunately, that won't work because the OOF are not an ensemble. In the OOF, each training image only has 1 prediction. Whereas in the test dataset, each image has 5 different predictions. So the test predictions are an ensemble, but the OOF predictions are just a "merging". As such you can't use "merging" weights to decide ensemble weights.</p> <p>Those are strong models Sogna. Great CV. Congrats on solo silver finish!</p> <p>UPDATE: I posted a starter notebook <a href="https://www.kaggle.com/cdeotte/forward-selection-oof-ensemble-0-942-private" target="_blank">here</a> showing how to ensemble OOF files using forward selection. I use my 39 of my Melanoma models' OOF files. Forward selection chooses 8 of them and achieves CV 0.950, Public LB 0.958, Private LB 0.942.</p> <p>Thanks Janek. 28th postion! Your team did great. Congratulations.</p> <p><a href="https://www.kaggle.com/swadeshjana" target="_blank">@swadeshjana</a> <a href="https://www.kaggle.com/ritachetadas" target="_blank">@ritachetadas</a> <a href="https://www.kaggle.com/nitimohan" target="_blank">@nitimohan</a> Your team did fantastic. 62nd out of 3400 teams. Great job.</p> <p>My best single model is the top row of the table above. It was 512x512 then random crop 384x384, EfficientNetB5 with 2018 external data and all my extra malignant data. It got triple stratified CV 0.936 and LB 0.956</p> <p>All my models were pretty simple, just Adam optimizer, Ramp up then decay learn schedule, Binary cross entropy loss. And just global average pooling on EffNet backbones. Then for my different models, I just varied the image size, backbone size, external data, and upsample. (So I used same basic model for all).</p> <p>I think it I spent time to make my single model template stronger. Then all my models would be stronger and the ensemble would score higher. I'm curious to see what the top teams did.</p> <p>There was nothing special about my meta model. By itself, it had CV 0.760 and public LB 0.780, so I trusted that it wasn't overfitting train. It increased my CV 0.0005 which could have helped private LB a little but it turned out not to help private LB.</p> <p>Thanks Roman. Random cropping worked very well. It allowed to train at small resolution speed but gave the models all the information from high resolution images.</p> <p>I'm happy with my silver finish. To go higher, I think I needed to focus on a optimizing my single model design. If I started with stronger single models, my ensemble LB would have been much higher. </p> <p>Wow, i just read that your ensemble CV is 0.960. That's incredible Gary and team. Congrats on building a great model, I look forward to reading your teams' full writeup.</p> <p>Awesome. It is a great trick. We get all the information in the higher resolution images but we get to train at the speed of the smaller images. Congrats on solo gold Tim.</p> <p>Yes at train time. I introduced a new variable <code>CROP = ???</code> in addition to <code>IMAGE_SIZE = ???</code>. The varible <code>IMAGE_SIZE</code> becomes <code>dim</code> in the code below. (This is my popular notebook updated)</p> <pre><code>if augment: if dim!=CROP: img = tf.image.random_crop(img, [CROP, CROP, 3]) img = transform(img,DIM=CROP) img = tf.image.random_flip_left_right(img) #img = tf.image.random_hue(img, 0.01) img = tf.image.random_saturation(img, 0.7, 1.3) img = tf.image.random_contrast(img, 0.8, 1.2) img = tf.image.random_brightness(img, 0.1) elif dim!=CROP: img = tf.image.central_crop(img,CROP/dim) </code></pre> <p>I never trust public ensemble notebooks in competitions. I mixed some public notebook single models (that i read the code and trust) with my single models by blending public <code>submission.csv</code> files with my <code>submission.csv</code> files.</p> <p>When blending with public notebooks, you need to be general like weighting everything equally, or weight strong LB as 2 and weak LB as 1. You can't fine tune the weights like you can if you use OOF. Otherwise you will overfit.</p> <p>Thank you <a href="https://www.kaggle.com/ipythonx" target="_blank">@ipythonx</a> for your kind words. </p> <p>Thanks Kaz. Great job with your team's strong finish. I look forward to reading about your model. What was your CV score?</p> <p>This is a great job Manjesh. You did perfect. You built diverse models and maximized OOF CV. Then you trained meta model and ensembled it all together.</p> <p>When you use 5 KFold, each model makes predictions on every training image. If you look at the output files of my public notebook <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords/output" target="_blank">here</a>, you will see a file named <code>oof.csv</code>. Now imagine that you have two <code>oof</code> files named <code>oof1.csv</code> and <code>oof2.csv</code>. To compute the ensemble score between two models, you do this</p> <pre><code>df1 = pd.read_csv('oof1.csv') df2 = pd.read_csv('oof2.csv') auc = roc_auc_score(df1.target, 0.5 df1.pred + 0.5 * df2.pred) </code></pre> <p>Note that <code>df1.target</code> and <code>df2.target</code> are the same thing. If you wonder what <code>df1.target</code> is, it is the same as </p> <pre><code>train = pd.read_csv('train.csv') print( train.target.values ) </code></pre> <p>But they are in a different order as <code>df1.target</code> (which are ordered by how the TFRecords get read).</p> <p>Thanks Konstantin.</p> <p>Fantastic. Great solo silver. Congrats!</p> <p>Thanks Rob. Congrats to you and your team's great finish. </p> <p>Thanks Statking. I saw your writeup. You did fantastic! Congratulations on your excellent finish.</p> <p>If I use my private LB 0.942 model and do <code>0.5 * image + 0.5 * meta</code> it becomes private 0.943. That is powerful.</p> <p>If you load 512x512 and random crop to 256x256. That is not the same as loading 256x256. In the former, the images contain 4x more pixel information. Note that I am not resizing. My model is slowing viewing the entire 512x512 over time.</p> <p>So loading 512x512 and cropping to 256x256 is the same as training on 512x512. And training on 512x512 always did better than using the smaller image sizes.</p> <p>If you wish to train on 256x256, then you can load 256x256 and random crop to 128x128. Then your model will train very fast cause it processes 128x128 but it is training on 256x256</p> <h1>Melanoma Model Ensemble!</h1> <p>Thank you Kaggle, SIIM, and ISIC for an exciting competition. Thank you Kagglers for wonderful shared content and great discussions! </p> <p>Early on I decided to build a large ensemble instead of optimizing a single model. The AUC metric seemed very unstable with this unbalanced dataset and using ensembles, heavy TTA, and crop augmentation helped stabilize it.</p> <h1>My Final 3 Submissions</h1> <p>My main (first) submission was an ensemble that maximized CV where all models used the same <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/165526" target="_blank">triple stratified leak-free CV</a> with <code>seed = 42</code>. (How to CV explained <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175614" target="_blank">here</a>). Next I believed public notebooks could add diversity too, so my final 3 submissions were:</p> <ul> <li><code>Sub_1</code> - 9 models of mine ensemble - CV 0.9505 LB 0.9578 - Private 0.9418</li> <li><code>Sub_2</code> - 5 mine plus 10 public single models - CV ??? LB 0.9662 - Private 0.9425</li> <li><code>Sub_3 = 0.75 * Sub_1 + 0.25 * Sub_2</code> - CV ??? LB 0.9603 - Private 0.9429</li> </ul> <h1>Crop Augmentation</h1> <p>Crop Augmentation was key to prevent overfitting during training when using external data, upsampling, and large EfficientNet backbones. Crop augmentation also helped stabilize AUC particularly when used in TTA.</p> <p>Previously we saw that using different image sizes adds diversity (explained <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/160147" target="_blank">here</a>). What many people don't realize is that you can use TFRecord sized 512x512 but train on random 256x256 crops (different each epoch). Then training goes fast because your EfficientNet only processes size 256x256 but you are getting features from 512x512 resolution. This allows us to train quickly on large sizes such as 1024x1024 and 768x768 (using crops of 512 and 384 respectively).</p> <p>In the picture below, we read the top row from TFRecords, then random crop, then train with the bottom row.</p> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1723677%2Fb9fd40b45aa428e23a9a470322aa8c7b%2Fcrop.png?generation=1597700942674639&alt=media" alt=""></p> <h1>My Final Models</h1> <p>The following 8 models have ensemble CV 0.9500, Public LB 0.9577, and Private LB 0.9420 . Then ensembling meta data with geometric mean: <code>image_ensemble*0.9 tabular_model*0.1</code>, increases CV to 0.9505, Public LB to 0.9578, and Private LB to 0.9418.</p> <table> <thead> <tr> <th>CV</th> <th>LB</th> <th>read size</th> <th>crop size</th> <th>effNet</th> <th>ext data</th> <th>upsample</th> </tr> </thead> <tbody> <tr> <td>0.936</td> <td>0.956</td> <td>512</td> <td>384</td> <td>B5</td> <td>2018</td> <td>1,1,1,1</td> </tr> <tr> <td>0.935</td> <td>0.937</td> <td>768</td> <td>512</td> <td>B6</td> <td>2019 2018</td> <td>3,3,0,0</td> </tr> <tr> <td>0.935</td> <td>0.949</td> <td>768</td> <td>512</td> <td>B7</td> <td>2018</td> <td>1,1,1,1</td> </tr> <tr> <td>0.933</td> <td>0.950</td> <td>1024</td> <td>512</td> <td>B6</td> <td>2018</td> <td>2,2,2,2</td> </tr> <tr> <td>0.927</td> <td>0.942</td> <td>768</td> <td>384</td> <td>B4</td> <td>2018</td> <td>0,0,0,0</td> </tr> <tr> <td>0.920</td> <td>0.941</td> <td>512</td> <td>384</td> <td>B5</td> <td>2019 2018</td> <td>10,0,0,0</td> </tr> <tr> <td>0.916</td> <td>0.946</td> <td>384</td> <td>384</td> <td>B345</td> <td>no</td> <td>0,0,0,0</td> </tr> <tr> <td>0.910</td> <td>0.950</td> <td>384</td> <td>384</td> <td>B6</td> <td>2018</td> <td>0,0,0,0</td> </tr> </tbody> </table> <p>The above models use a variety of different augmentation, losses, optimizers, and learning rate schedules. External data explained <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/164910" target="_blank">here</a>. Upsample explained <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/169139" target="_blank">here</a>.</p> <h1>My Training</h1> <p>If you download my popular notebook <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">here</a> to your local machine or cloud provider, then you can run the code quickly using multiple GPUs by adding the following one line of code</p> <pre><code>DEVICE = "GPU" strategy = tf.distribute.MirroredStrategy() </code></pre> <p>Most of my models including my most accurate single model with CV 0.936 and LB 0.956 were trained using four Nvidia V100 GPUs. Thank you Nvidia for the use of GPUs!</p> <h1>Ensemble Pseudo Code</h1> <p>In the past 2 months, I trained 50+ diverse models. How do we ensemble 50+ models? Train all models using the same triple stratified folds <code>seed = 42</code> from my notebook <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">here</a>. Then to create an ensemble, start with the model that has largest CV and repeatedly try adding one model to increase CV. Whichever one additional model increases the CV the most (and at least 0.0003), keep that model and then iterate through all models again. Repeat this process until CV score stops increasing (by at least 0.0003).</p> <pre><code> # START ENSEMBLE USING MODEL WITH LARGEST CV Repeat until CV does not increase by 0.0003+ : # TRY ADDING EVERY MODEL ONE AT A TIME AND REMEMBER # HOW MUCH EACH INCREASES THE ENSEMBLE CV SCORE for k in range( len(models) ): for w in [0.01, 0.02, ..., 0.98, 0.99]: # TRY ADDING MODEL k WITH WEIGHT w TO ENSEMBLE trial = w model[k,] + (1-w) * ensemble auc_trial = roc_auc_score(true, trial) # ADD ONE NEW MODEL TO ENSEMBLE THAT INCREASED CV THE MOST # CHECK NEW CV SCORE. IF IT INCREASED REPEAT LOOP </code></pre> <h1>Ensemble Starter Notebook</h1> <p>I posted my solution code <a href="https://www.kaggle.com/cdeotte/forward-selection-oof-ensemble-0-942-private" target="_blank">here</a> showing how to ensemble OOF files using forward selection. The notebook uses 39 of my Melanoma models' OOF files. Forward selection chooses 8 of them and achieves CV 0.950, Public LB 0.958, Private LB 0.942.</p> <p>Thanks <a href="https://www.kaggle.com/ankitsajwan" target="_blank">@ankitsajwan</a> . Congratulations on achieving solo silver. Well done.</p>
SIIM-ISIC Melanoma Classification	222th Place Solution: Correlation CV vs Public LB 0.16, vs Private LB 0.73	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>First of all, thank organizers for holding this competition and Kagglers for posting truly useful datasets, notebooks, discussions!!!</p> <p>Many competitors have noticed that correlation of CV with Public LB is unstable. Some competitors have solved it by</p> <ul> <li><a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175412" target="_blank">Using external data for validation</a></li> <li><a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/175344" target="_blank">Ensemble</a></li> </ul> <p>By seeing these posts, I wondered how unstable correlation of my single models CV with Public LB and Private LB are. I investigated that by using late submissions.</p> <p>Note that, throughout this post, "CV" means "OOF CV", not "Averaged CV over the folds".</p> <p>I used <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> 's <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/165526" target="_blank">Triple Stratified Leak-Free KFold CV dataset</a> with 5 folds, and didn't include external data in validation phase. (Thank <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for providing very useful dataset and clear explanation. I could spend much time for training diverse models because of your datasets!)</p> <p>Trained models are </p> <ul> <li>Efficient Net without meta data</li> <li>Efficient Net with meta data</li> <li>ResNest without meta data</li> </ul> <p>As I wrote in title, my single models CV are more correlate with Private LB than Public LB!</p> <ul> <li>CV vs Public LB: 0.16</li> <li>CV vs Private LB: 0.73</li> <li>(Public LB vs Private LB: 0.53)</li> </ul> <p>Actual values of CV, Public LB, Private LB are below.</p> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1772718%2F91caae5b19967358979bb6e9fb2817eb%2F2020-08-20_00h07_39.png?generation=1597849679012485&alt=media" alt=""></p> <p>I hypothesize the reason of huge gap between Public LB and Private LB is very few amount of positive samples in Public test set. <a href="https://www.kaggle.com/cpmpml" target="_blank">@cpmpml</a> 's <a href="https://www.kaggle.com/cpmpml/number-of-public-melanoma-is-78-or-77" target="_blank">notebook</a> and <a href="https://www.kaggle.com/sirishks" target="_blank">@sirishks</a> 's <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/167215" target="_blank">analysis</a> show that the number of positive samples in Public and Private test set are 77 or 78 and 182.<br> (or maybe I was just lucky enough to got such relatively stable correlation of CV with Private LB. And also I'm not sure about my training settings is suitable for getting stable correlation.)</p> <h1>Details of my solution</h1> <h3>Training settings</h3> <p>Training settings of Efficient Net wo/w meta data are different for those of ResNest wo meta data (to obtain diverse models). The way to use meta data is identical to <a href="https://arxiv.org/abs/1910.03910" target="_blank">1st place solution of ISIC 2019</a>. Some settings are also based on this solution.</p> <h4>Common settings</h4> <ul> <li>Pytorch with GPU and TPU</li> <li><a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/165526" target="_blank">Triple Stratified Leak-Free KFold CV dataset</a> with 5 folds</li> <li>External data are <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/164910" target="_blank">whole 2017 and 2018, malignant of 2019</a>, <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/169139" target="_blank">additional 580 malignant samples</a> prepared by <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> (big thanks again!)</li> <li>RAdam optimizer</li> <li>BCE loss</li> <li>16 time TTA for validation and test phase. (4 different scale with horizontal flip, vertical flip, both of them. Actual TTA images look like below. This is also inspired by ISIC 2019 1st place solution)</li> </ul> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1772718%2Ff4a76e46576a1c13fa5132f48c4813fc%2F2020-08-19_23h50_09.png?generation=1597849603207907&alt=media" alt=""></p> <h4>Efficient Net</h4> <ul> <li>b0 ~ b6 with different image size (combinations of model size with image size are same with <a href="https://arxiv.org/abs/1905.11946" target="_blank">original paper</a>, like b0-224, b1-240, …, b6-528.)</li> <li>Pretrained weights on ImageNet</li> <li>Augmentations (actual snippet below)</li> </ul> <pre><code>p = .5 train_transforms = A.Compose([ A.RandomResizedCrop(img_size, img_size, p=p), A.ShiftScaleRotate(rotate_limit=(-90, 90), p=p) A.HorizontalFlip(p=p), A.VerticalFlip(p=p), A.HueSaturationValue(p=p), A.RandomBrightnessContrast(p=p), A.OneOf([A.IAAAffine(scale=1.0, translate_percent=(.5, .5), translate_px=None, rotate=0.0, shear=(50, 50), order=1, cval=0, mode='reflect', p=p), A.IAAAffine(scale=1.0, translate_percent=(.5, .5), translate_px=None, rotate=0.0, shear=(30, 30), order=1, cval=0, mode='reflect', p=p), A.IAAAffine(scale=1.0, translate_percent=(.3, .3), translate_px=None, rotate=0.0, shear=(0, 0), order=1, cval=0, mode='reflect', p=p)], p=p), A.Cutout(num_holes=1, max_h_size=32, max_w_size=32, fill_value=0, always_apply=False, p=p), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) val_transforms = A.Compose([ A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) </code></pre> <ul> <li>12 epochs for training wo meta data</li> <li>30 epochs for training w meta data (initial weighs are best AUC's one got by training wo meta data)</li> <li>No LR scheduler</li> </ul> <h4>ResNest</h4> <p>First of all, thank <a href="https://www.kaggle.com/arroqc" target="_blank">@arroqc</a> for posting <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/173272" target="_blank">topic telling ResNest is faster than Efficient Net implemented in Pytorch!</a>. I'm really suffered from same problem at that time and I guess training ResNest really helped to increase my CV in limited time!</p> <ul> <li>ResNest50, 101, 200 with different image size (combinations of model size with image size are 50-224, 101-256, 200-320, which are based on <a href="https://github.com/zhanghang1989/ResNeSt#pretrained-models" target="_blank">those of pretrained models</a>)</li> <li>Pretrained weights on ImageNet</li> <li>3 Dense head with ReLU, Dropout (probability=0.3). The number of neurons of each head is 1024, 512, 256. (This is based on <a href="https://www.kaggle.com/ajaykumar7778" target="_blank">@ajaykumar7778</a> 's <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/172882#961932" target="_blank">post</a>. Thanks to sharing your ideas! I guess it made my models diverse and increased CV of ensemble!)</li> <li>Image is resized from 1024x1024 resolution</li> <li>Augmentations (actual snippet below)</li> </ul> <pre><code>p = .5 train_transforms = A.Compose([ A.RandomResizedCrop(img_size, img_size, scale=(0.5, 1.0), p=1), A.ShiftScaleRotate(rotate_limit=(-90, 90), p=p), A.HorizontalFlip(p=p), A.VerticalFlip(p=p), A.HueSaturationValue(p=p), A.RandomBrightnessContrast(p=p), A.IAAAffine(scale=1.0, translate_percent=(.0, .0), translate_px=None, rotate=0.0, shear=(2.0, 2.0), order=1, cval=0, mode='reflect', p=p), A.Cutout(num_holes=1, max_h_size=32, max_w_size=32, fill_value=0, always_apply=False, p=p), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) val_transforms = A.Compose([ A.Resize(int(img_size1.25), int(img_size1.25), interpolation=cv2.INTER_AREA, always_apply=False, p=1), A.CenterCrop(img_size, img_size, always_apply=False, p=1.0), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2() ]) </code></pre> <ul> <li>CyclicLR scheduler (This is also based on <a href="https://www.kaggle.com/ajaykumar7778" target="_blank">@ajaykumar7778</a>'s <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/172882#961932" target="_blank">post</a>. Thanks again for sharing your ideas! It seemed like that this helped to stabilize training!)</li> </ul> <h2>Ensemble for Submission</h2> <p>My final submission is hugely relied on OOF CV. I ensembled relatively high OOF CV models by taking summation of probability of rank with optimal weighs find by Optuna. (The code for rank AUC is based on <a href="https://www.kaggle.com/steubk" target="_blank">@steubk</a> 's <a href="https://www.kaggle.com/steubk/simple-oof-ensembling-methods-for-classification" target="_blank">notebook</a>. Thanks for sharing! This ensemble really boosted my CV!)</p> <p>Only some portion of models are used to ensemble, which are </p> <ul> <li>b0 and b1 w meta</li> <li>b3, 5 and 6 wo/w meta</li> <li>b4 wo meta</li> <li>resnest 50, 101 and 200 wo meta</li> </ul> <p>(I selected these models by just seeing OOF CV, because remaining time is 1 hour at that time! I believe there were more wise way to select models!)</p> <p>Ensemble score are CV: 0.9534, Public LB: 0.9449, Private LB: 0.9391</p> <h2>Things Not Work Well</h2> <ul> <li>Oversampling malignant image to balance 1:1 (inspired by <a href="https://arxiv.org/abs/1710.05381" target="_blank">this paper</a>)</li> <li>Label smoothing with alpha 0.05 (inspired by <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> 's <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">notebook</a>)</li> <li>Increase epochs to 100 with StepLR scheduler with step size = 25 and gamma = 1/5 (inspired by 2019 ISIC 1st place solution)</li> </ul> <p>Thanks for reading my post and sorry for my poor english!</p> <p>As this is my first hardworking comp, I have learned huge amount of things! For me, unstable CV vs Public LB correlation is really good learning opportunity because I believe that don't overfit to known test data is important in real world problems.</p> <p>P.S. I don't have my own rich computational resources, so used cloud gpu/tpu at GCP, AWS, Azure. It costs around $1041 😅. In next comp, cost-effective approach is definitely needed! </p>
SIIM-ISIC Melanoma Classification	241st place (bronze) solution (+ GitHub) with batch sampling	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>You're welcome <a href="https://www.kaggle.com/bijeeshavs" target="_blank">@bijeeshavs</a> </p> <p>Thanks <a href="https://www.kaggle.com/romanweilguny" target="_blank">@romanweilguny</a> , I also was surprised by <code>sample_from_datasets</code>, I've been looking for a long time a simple and elegant way to do batch sampling in <code>TF</code>, but be aware that it uses a little more memory.</p> <p>Where you got the implementation for <code>SWA</code>? I have tried the version from <code>tensorflow_addons</code> but it crashed my Kaggle and Colab env.</p> <p>I have tried the ensembling from Chris using 27 of my best OOFs and got a lower CV, public and private LB from it, my ensembling code worked better, but maybe I did something wrong.</p> <p>I used meta-data on all my submission, but just blending values like <code>90%image ensemble +10% meta ensemble</code>, but got just a small improvement.</p> <p>By what I saw I had good models, maybe if I had ensembled them in a more efficient way I should be somewhere close to 50, still learning how to diversify the ensemble.</p> <p>Thanks <a href="https://www.kaggle.com/utshabkumarghosh" target="_blank">@utshabkumarghosh</a> </p> <p>Thanks <a href="https://www.kaggle.com/ivanvoid" target="_blank">@ivanvoid</a> !, this <code>model backlog</code> takes some time to update during the competitions, but it is a time saver when you need com compare and evaluated your models later.</p> <p>I think that the best notebook was the <code>136</code> It was my best single model on private LB with <code>0.9396</code> and public <code>0.9470</code> also had a nice CV <code>0.937</code>.</p> <p>Thanks <a href="https://www.kaggle.com/epocxy" target="_blank">@epocxy</a> !</p> <p>Thanks <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> I think batch sampling was the one single trick that helped me the most, after it, I got very consistently CV 9.30+, I guess it could work even better if you use two datasets one with only positive samples and another with only negative samples, I also got nice results sampling from datasets from different years, like {10%: 2019, 50%: 2020+2018, 40%: malignants}</p> <p>Thanks <a href="https://www.kaggle.com/ambarish" target="_blank">@ambarish</a> , Yeah everything was created manually, I wish there was an automated way 😄, but as I am updating it almost daily it becomes easy to maintain, after the competition ends it works as a cool portfolio of projects and experiments.</p> <p>Hey guys, I felt 93 positions after the shakedown, but still managed to get a bronze, was not a very good placing but still think would be nice to share my solution and experiments at my <a href="https://github.com/dimitreOliveira/melanoma-classification" target="_blank">Git</a> in case anyone is interested in taking a look.</p> <p>My best solution from the 3 chosen, was the one that according to my experiment had the best CV values, so trusting my CV helped me here. Basically it was a weighted average using exponential log like some people also did.</p> <h4>Models</h4> <ul> <li>1x EfficientNet B4 384x384</li> <li>3x EfficientNet B4 512x512</li> <li>1x EfficientNet B5 512x512</li> </ul> <p>They were training using one augmentation pipeline and predicted using a lighter one (with out Cutout and shear), all using the data provide by Chris<br> All models were very simple just a regular AVG pooling and dense head, label smoothing of 0.05, and Adam optimizer, one model example:</p> <pre><code>def model_fn(input_shape=(256, 256, 3)): input_image = L.Input(shape=input_shape, name='input_image') base_model = efn.EfficientNetB4(input_shape=input_shape, weights=config['BASE_MODEL_WEIGHTS'], include_top=False) x = base_model(input_image) x = L.GlobalAveragePooling2D()(x) output = L.Dense(1, activation='sigmoid', kernel_initializer='zeros', name='output')(x) model = Model(inputs=input_image, outputs=output) opt = optimizers.Adam(learning_rate=config['LEARNING_RATE']) loss = losses.BinaryCrossentropy(label_smoothing=0.05) model.compile(optimizer=opt, loss=loss, metrics=['AUC']) return model </code></pre> <h4>Training</h4> <p>One thing that worked very well for me was using upsampling, but in my case, I did in a way that I did not see people doing, I used <code>tf.data.experimental.sample_from_datasets</code> to sample from 2 different datasets, one was the regular data (2020 + 2018 + 2017) and the other was just malignant samples (all sets), then I used the weights <code>[0.6, 0.4]</code> this way <code>40%</code> of the data were only malignant for every batch, this made the models converge faster.<br> Used only TPUs, both from Kaggle and Colab<br> Also, I got better results using a cyclical cosine learning rate with warm restarts and warm-up, shown below.<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1182060%2Fa0849f9196f11493360c242a33cb1edc%2Fdownload.png?generation=1597710718834670&alt=media" alt=""></p> <p>Here is a fold training history for illustration.<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1182060%2Fa488650b5cde87105510c0ed5c317a90%2Fhistory_fold2.png?generation=1597710894876834&alt=media" alt=""></p> <p>Here is the link to <a href="https://github.com/dimitreOliveira/melanoma-classification" target="_blank">my Github</a>, there you will find all my models, <a href="https://github.com/dimitreOliveira/melanoma-classification/tree/master/Model%20backlog" target="_blank">its scores</a>, EDAs, scripts and a <a href="https://github.com/dimitreOliveira/melanoma-classification/tree/master/Documentation" target="_blank">page with all relevant content</a> that I gathered during the competition.</p> <p>About this competition, it was a great opportunity to experiment a little more with TPUs and TensorFlow, especially with the dataset API, I feel that a should join another computer vision competition to do some more practice. <br> I tried a lot to make BiT(Big transfer) work but had no success, I got good results with Cutout, was getting close to making MixUp work good here but had no time left.</p> <p>I tweaked a lot my augmentations pipeline and this was what roughly what gave me best results:</p> <pre><code>def data_augment(image): p_rotation = tf.random.uniform([], 0, 1.0, dtype=tf.float32) p_rotate = tf.random.uniform([], 0, 1.0, dtype=tf.float32) p_cutout = tf.random.uniform([], 0, 1.0, dtype=tf.float32) p_shear = tf.random.uniform([], 0, 1.0, dtype=tf.float32) p_crop = tf.random.uniform([], 0, 1.0, dtype=tf.float32) if p_shear > .2: if p_shear > .6: image = transform_shear(image, config['HEIGHT'], shear=20.) else: image = transform_shear(image, config['HEIGHT'], shear=-20.) if p_rotation > .2: if p_rotation > .6: image = transform_rotation(image, config['HEIGHT'], rotation=45.) else: image = transform_rotation(image, config['HEIGHT'], rotation=-45.) if p_crop > .2: image = data_augment_crop(image) if p_rotate > .2: image = data_augment_rotate(image) image = data_augment_spatial(image) image = tf.image.random_saturation(image, 0.7, 1.3) image = tf.image.random_contrast(image, 0.8, 1.2) image = tf.image.random_brightness(image, 0.1) if p_cutout > .5: image = data_augment_cutout(image) return image </code></pre> <p>I would like to thank the community for all the helpful discussion and work shared and give a special thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for his amazing contributions to us all during the competition, this was a great learning opportunity.</p> <p>Nice <a href="https://www.kaggle.com/datafan07" target="_blank">@datafan07</a> , let me know if there is anything to improve.<br> Congratulations on your placing and thanks for your contributions.</p>
SIIM-ISIC Melanoma Classification	24th Place Solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I used BCE</p> <p>20 for pretrain,10 for finetune</p> <p>A single card can run batch size 10, with 2 cards, it's 20.</p> <p>I didn’t make another stratified csv for 2019 data. Just used Chris’s. The diagnosis column is the label for 8 class classification.</p> <p><strong>Trust your CV</strong><br> I entered this competition after Panda and am surprised by the result.<br> The most important things here should be your CV. Always trust it. A single positive sample in public testset can have 0.0064 effect on public LB and the effect is very likely to accumulate during ensembling and selecting.<br> I used <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a>'s JPEG files and his triple stratifed CV. They help me quickly start trainning and build a strong CV. Thank to his great work.</p> <p><strong>Best Single Model</strong><br> I used pytorch and 2xRTX2080 to generate my result and used no meta data.<br> The best single model is efficientnet-b5 on 512x512 resolution. I firstly train model on 2019 data with 8 classes. Then I finetune it with 2020+2018/2017 data. This method improves 0.01 on CV,0.005 on private LB but no improvement on public LB.<br> Augmentations: ImageCompression, Flips, ShiftRotateScale, HueSaturationValue, RandomBrightnetnessContrast, CutOut.<br> This model achieves 0.944 on CV (before TTA) and 0.9447-0.9462 on private LB(different averaging method). Sadly I picked the lowest one. xD.</p> <p><strong>Ensemble</strong><br> I ensembled this model with some of my previous models. Most of these overfitted.<br> The ensembles scores 0.9452-0.9492 on private LB. Made the wrong choise again. xD.</p>
SIIM-ISIC Melanoma Classification	24th place solution and my way to get it	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Hello everyone, congrats to all winners and thanks Kaggle and SIIM for this competition </p> <p>This is my second medal awarded competiton (finally I'm an expert, yeah!!!), and my second medical image analisys competiton. My first one was <a href="https://www.kaggle.com/c/aptos2019-blindness-detection" target="_blank">APTOS Blindness Detection</a> last year and these are some similar problems I faced here:</p> <p><strong>Imbalanced classes</strong></p> <p>A common problem for many medical image analysis is imbalanced data distribution (few images of positive cases). There were 5 classes (or 5 degrees of disease, because the problem could be also interpreted as regression) and 2 classes strongly prevailed. In this competition it was binary classification case and the first one was much larger. The obvious way to fix classes balance was to use external data, and here is the second challenge:</p> <p><strong>Use of external data</strong> </p> <p>In both competitins we had to deal with quite a large amount of external data, you can use it to balance classes or just use all of this data. In APTOS many people pretrained their models on old external images and finetune in actual data (and so did I). Inept use of external data could decrease your score, old (external) and actual datasets were quite different. In SIIM old and actual data was much less different, so we were more free to use it.<br> I used 2018+2019 external data for all training pipeline, validating on 2020 data only. </p> <h2>My approcah</h2> <p>At the beginning I tried various light models (like EffNet b0-b3, ResNet18 with image size 256x256) using PyTorch and various augmentation techniques both for metadata and for images, experementing with focal loss and label smoothing. But maximum I achived was 0.933 on public LB. But in discussions participants told about experiments with sizes like 512x512 and quite large models like EffNetB6, these kind of experiments was hard for me because I used PyTorch and GPUs only</p> <p>All my way in deep learning I had used PyTorch, but topics related to tensorflow and TPU appeared in discussion and public notebooks more and more, I could not ignore it anymore. Finally I found that using TPU I can train heavier models on larger images! </p> <p><strong>Making ensemble</strong></p> <p><a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/154683" target="_blank">2019 1st place solution</a> is blending of various versions of EfficientNet and various augmentation techniques and image sizes, so I decided to implement something like that</p> <p>I used pipeline like <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">Tripple Stratified KFold</a>, using 2018+2019+2020 data for training and only 2020 data for validation </p> <table> <thead> <tr> <th>Model</th> <th>Image Size</th> <th>Initial Weights</th> <th>Public Score</th> <th>Private Score</th> </tr> </thead> <tbody> <tr> <td>EfficientNetB5</td> <td>512</td> <td>ImageNet</td> <td>0.9524</td> <td>0.9200</td> </tr> <tr> <td>EfficientNetB5</td> <td>768</td> <td>ImageNet</td> <td>0.9469</td> <td>0.9185</td> </tr> <tr> <td>EfficientNetB5</td> <td>1024</td> <td>ImageNet</td> <td>0.9479</td> <td>0.9285</td> </tr> <tr> <td>EfficientNetB6</td> <td>384</td> <td>ImageNet</td> <td>0.9497</td> <td>0.9277</td> </tr> <tr> <td>EfficientNetB6</td> <td>512</td> <td>ImageNet</td> <td>0.9488</td> <td>0.9258</td> </tr> <tr> <td>EfficientNetB6</td> <td>768</td> <td>ImageNet</td> <td>0.9502</td> <td>0.9277</td> </tr> <tr> <td>EfficientNetB6</td> <td>1024</td> <td>ImageNet</td> <td>0.9478</td> <td>0.9287</td> </tr> <tr> <td>EfficientNetB7</td> <td>512</td> <td>ImageNet</td> <td>0.9480</td> <td>0.9239</td> </tr> <tr> <td>EfficientNetB7</td> <td>768</td> <td>ImageNet</td> <td>0.9379</td> <td>0.9083</td> </tr> <tr> <td>EfficientNetB5</td> <td>512</td> <td>NoisyStudent</td> <td>0.9480</td> <td>0.9194</td> </tr> <tr> <td>EfficientNetB6</td> <td>512</td> <td>NoisyStudent</td> <td>0.9435</td> <td>0.9242</td> </tr> <tr> <td>EfficientNetB7</td> <td>512</td> <td>NoisyStudent</td> <td>0.9510</td> <td>0.9218</td> </tr> <tr> <td>EfficientNetB5</td> <td>768</td> <td>NoisyStudent</td> <td>0.9543</td> <td>0.9295</td> </tr> <tr> <td>EfficientNetB6</td> <td>768</td> <td>NoisyStudent</td> <td>0.9424</td> <td>0.9218</td> </tr> <tr> <td>ResNet152</td> <td>512</td> <td>ImageNet</td> <td>0.9184</td> <td>0.8901</td> </tr> <tr> <td>InceptionResNetV2</td> <td>768</td> <td>ImageNet</td> <td>0.9338</td> <td>0.9161</td> </tr> <tr> <td>Blending</td> <td>---</td> <td>---</td> <td>0.9602</td> <td>0.9406</td> </tr> </tbody> </table> <p>Being based on <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/160147" target="_blank">this idea</a>, I mixed various models with various training image sizes. </p> <p><strong>Public submissions</strong></p> <p>We can't ignore it since have a public submission in a silver medal zone!<br> I also made two submmissions with mixing this ensemble and subs from some public kernels, like these ones <br> <a href="https://www.kaggle.com/truonghoang/stacking-ensemble-on-my-submissions" target="_blank">This one</a>, because it consists of models like VGG and SeResNext, I think they are quite uncorrelated with my effnets</p> <p><a href="https://www.kaggle.com/datafan07/analysis-of-melanoma-metadata-and-effnet-ensemble" target="_blank">This one</a>, because it has good work on metadata analysis</p> <p>I did not use kernels kind of "public blending" or "public minimax ensemble" which were in fact combinations of others, trying to choose from public submissions these ones which correlate as little as possible with my ensemble and with each other. </p> <p>At the end days of competition I fell from ~80 position to ~240 and it was nervous, but after th shakeup I, like many others, was thrown quite high (about 200 positions)! <br> And I really not sure about reasons for it! On the one hand blending of all my models without any public submissions was about on 800 + position on Public LB but something like 140-150 on Private LB, on the other simple blending of public subs gained a silver zone.. I think this story teaches us not to trust Public LB and choose the most stable models for final sub. </p> <p>I think it was quite a lottery, many conducted successful experiments, but chose wrong final submissions. What about me - I think I was saved by quite an ensemble and careful use of public submissions</p> <p>Special thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for his great <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">kernel</a> and TFRecords datasets covering almost all possible approaches. They helped me alot throughout the competition!</p> <p><a href="https://www.kaggle.com/dimitreoliveira" target="_blank">@dimitreoliveira</a> thanks =) </p> <p>I used TF with kaggle TPU<br> Loss is BCE with label smoothing 0.05 </p> <p>No, the reason for using TF (TPU) became available a little bit later :) </p> <p><a href="https://www.kaggle.com/truonghoang" target="_blank">@truonghoang</a> thanks for submissions of VGG and SeResNext models :)</p> <p>Thanks! That was actually the main idea - build uncorrelated ensemble</p>
SIIM-ISIC Melanoma Classification	254th Place Solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks to the kaggle and the organizers for hosting such an interesting competition. And I like to thank my teammates, brother <a href="https://www.kaggle.com/udaykamal" target="_blank">@udaykamal</a>, and <a href="https://www.kaggle.com/tahsin" target="_blank">@tahsin</a> for the insightful discussion that we've made along with this journey. And last but not least, We're greatly thankful to the <strong>MVP</strong> of this competition, <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for all the contribution that he's shared from the very beginning of this competition. </p> <p>Our experiment is based on <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> 's strong <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">baseline starter</a> and we extended it by integrating various types of the modeling approach.</p> <h1>Brief Summary</h1> <ul> <li>All the Base-Models are <code>EfficientNets</code>, and here <strong>E-Net</strong> for short. Total of 20 models only.</li> </ul> <pre><code>- `E-Net B2` (2x) - `E-Net B3` (2x) - `E-Net B4` (3x) - `E-Net B5` (2x) - `E-Net B6` (5x) - `E-Net B7` (6x) </code></pre> <ul> <li>We have used various types of the top model including </li> </ul> <pre><code>- Global Average Pooling (GAP) - Global Max Pooling (GMP) - Attention Weighted Net (AWN) - Generalized Mean Pooling (GeM) - Global Average Attention Mechanism (GAAM, [ours]) </code></pre> <p>Ok, here below are the full details. (<strong>TL,DR</strong>)</p> <hr> <h1>E-Net 2</h1> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>Folds</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 2</td> <td>GAP</td> <td>202</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.904</td> <td>0.9345</td> </tr> <tr> <td>b-ENet 2</td> <td>GAP</td> <td>1234</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.907</td> <td>0.9346</td> </tr> </tbody> </table> <p>Next, based on the <strong>CV</strong> score, we took a simple average of them. </p> <pre><code>ENet 2 = (a-ENet 2 + b-ENet 2)/2 </code></pre> <p>The resultant prediction graph as follows: <br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2Ff107b28e41ce558fa67b26e0abe56730%2F2.png?generation=1597815112995545&alt=media" alt=""></p> <h1>E-Net 3</h1> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>Folds</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 3</td> <td>GAAM</td> <td>101</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.890</td> <td>0.9462</td> </tr> <tr> <td>b-ENet 3</td> <td>GAP</td> <td>2020</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.912</td> <td>0.9435</td> </tr> </tbody> </table> <p>Next, based on the <strong>CV</strong> score, we took a simple weighted average of them. </p> <pre><code>ENet 3 = (a-ENet 31 + b-ENet 32)/3 </code></pre> <p>The resultant prediction graph as follows:<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2F4e767d1caa113e72e38aafcce541f403%2F3.png?generation=1597815707202196&alt=media" alt=""></p> <h1>E-Net 4</h1> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>Folds</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 4</td> <td>GAP + AWN</td> <td>786</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.9120</td> <td>0.9334</td> </tr> <tr> <td>b-ENet 4</td> <td>GAP</td> <td>786</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.9250</td> <td>0.9454</td> </tr> <tr> <td>c-ENet 4</td> <td>M</td> <td>999</td> <td>'20+'18+'19+Upsampled</td> <td>768</td> <td>1</td> <td>0.9320</td> <td>0.9326</td> </tr> </tbody> </table> <p>Here, M = <strong>[GAP + GeM+AWN + GMP]</strong></p> <p>Next, based on the <strong>CV</strong> score, we took a simple weighted average of them. </p> <pre><code>ENet 4 = (a-ENet 41 + b-ENet 42 + c-ENet 42)/5 </code></pre> <p>The resultant prediction graph as follows:<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2Fb70062f56a279740e23d527f38f31831%2F4.png?generation=1597816112525326&alt=media" alt=""></p> <h1>E-Net 5</h1> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Dat</th> <th>Img</th> <th>Fold</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 5</td> <td>GAP + AWN</td> <td>101</td> <td>'20+'18</td> <td>384</td> <td>5</td> <td>0.908</td> <td>0.9442</td> </tr> <tr> <td>b-ENet 5</td> <td>M</td> <td>786</td> <td>'20+'18</td> <td>512</td> <td>3</td> <td>0.884</td> <td>0.9491</td> </tr> </tbody> </table> <p>Here, M = <strong>[GAP + GMP + AWN]</strong></p> <p>Next, based on the <strong>CV</strong> score, we took a simple weighted average of them. </p> <pre><code>ENet 5 = (a-ENet 52 + b-ENet 51)/3 </code></pre> <p>The resultant prediction graph as follows:<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2F5a468bba3f008360fa58b416f70019e3%2F5.png?generation=1597816460348906&alt=media" alt=""></p> <h1>E-Net 6</h1> <p>Basically <code>E-Net 6</code> was our first modeling approach. So, initially, we kept the validation set the same (seed <code>42</code>) and experimented in the following way.</p> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>Fold</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 6</td> <td>GAP</td> <td>42</td> <td>'20 + '18</td> <td>384</td> <td>5</td> <td>0.904</td> <td>0.9454</td> </tr> <tr> <td>b-ENet 6</td> <td>GAP + AWN</td> <td>42</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.912</td> <td>0.9422</td> </tr> <tr> <td>c-ENet 6</td> <td>AWN</td> <td>42</td> <td>'20+'18-</td> <td>512</td> <td>5</td> <td>0.918</td> <td>0.9431</td> </tr> <tr> <td>d-ENet 6</td> <td>GeM</td> <td>42</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.905</td> <td>0.9405</td> </tr> <tr> <td>e-ENet 6</td> <td>GAAM</td> <td>42</td> <td>'20+'18</td> <td>512</td> <td>5</td> <td>0.925</td> <td>0.9458</td> </tr> </tbody> </table> <p>Next, as the above 6 submissions came from the same validation split, we further tried to find the best weights that will maximize the <strong>OOF</strong> validation score max. </p> <table> <thead> <tr> <th>-</th> <th>SimpleAvg</th> <th>PowerAvg</th> <th>RankAvg</th> <th>BaysianOpt</th> <th>L-BFGS-B</th> </tr> </thead> <tbody> <tr> <td>CV</td> <td>0.9319</td> <td>0.9312</td> <td>0.9321</td> <td>0.9322</td> <td>0.9320</td> </tr> <tr> <td>LB</td> <td>0.9487</td> <td>0.9488</td> <td>0.9483</td> <td>0.9490</td> <td>0.9491</td> </tr> </tbody> </table> <p>As we found <code>BaysianOpt</code> gave the maximum CV, so later we chose it for the final blending. I've published a notebook regarding this, showed a comparison between <strong>Bayesian Optimization</strong> and <strong>L-BFGS-B</strong> methods, <a href="https://www.kaggle.com/ipythonx/optimizing-metrics-out-of-fold-weights-ensemble" target="_blank">Optimizing Metrics: Out-of-Fold Weights Ensemble</a></p> <p>The resultant prediction graph as follows:<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2Faf77c044bad954675dae053b8419ec80%2F6.png?generation=1597821688482478&alt=media" alt=""></p> <h1>E-Net 7</h1> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>Fold</th> <th>CV</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>a-ENet 7</td> <td>GAP</td> <td>101</td> <td>'20+'18</td> <td>256</td> <td>5</td> <td>0.910</td> <td>0.9307</td> </tr> <tr> <td>b-ENet 7</td> <td>GAP</td> <td>42</td> <td>'20+'18</td> <td>256</td> <td>5</td> <td>0.910</td> <td>0.9312</td> </tr> <tr> <td>c-ENet 7</td> <td>GAP</td> <td>42</td> <td>'20+'18</td> <td>384</td> <td>4</td> <td>0.923</td> <td>0.9389</td> </tr> <tr> <td>d-ENet 7</td> <td>M</td> <td>2020</td> <td>'20 + '18 + '19 + Upsampled</td> <td>768</td> <td>1</td> <td>0.928</td> <td>0.9479</td> </tr> <tr> <td>e-ENet 7</td> <td>M</td> <td>1221</td> <td>'20 + '18 + '19 + Upsampled</td> <td>512</td> <td>5</td> <td>0.922</td> <td>0.9442</td> </tr> </tbody> </table> <p>Here, M = <strong>[GAP+GeM+GMP+AWN]</strong></p> <p>Next, based on the <strong>CV</strong> score, we took a simple weighted average of them. </p> <pre><code>ENet 7 = (a-ENet 71 + b-ENet 71 + c-ENet 72 + d-ENet 72 + e-ENet 72)/8 </code></pre> <p>The resultant prediction graph as follows:<br> <img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1984321%2Fb428333f2381ff3dba527e031e401985%2F7.png?generation=1597817972968820&alt=media" alt=""></p> <h1>Whole Data Training, 2020 SIIM Comp.</h1> <p>Maybe it's not full ideal but we did four experiments, inspired by <a href="https://www.kaggle.com/agentauers" target="_blank">@agentauers</a> 's awesome <a href="https://www.kaggle.com/agentauers/incredible-tpus-finetune-effnetb0-b6-at-once" target="_blank">kernel</a>. We didn't take any validation set, this was done before 2/3 weeks of the competition end. </p> <table> <thead> <tr> <th>Model</th> <th>Top</th> <th>Seed</th> <th>Data</th> <th>Img</th> <th>LB</th> </tr> </thead> <tbody> <tr> <td>ENet 3+4+5</td> <td>GAP</td> <td>101</td> <td>'20</td> <td>256</td> <td>0.9384</td> </tr> <tr> <td>ENet 3+4+5</td> <td>GAP</td> <td>42</td> <td>'20</td> <td>384</td> <td>0.9470</td> </tr> <tr> <td>ENet 3+4+5</td> <td>GAP</td> <td>786</td> <td>'20</td> <td>512</td> <td>0.9438</td> </tr> <tr> <td>ENet 3+4+5</td> <td>GAP</td> <td>202</td> <td>'20</td> <td>768</td> <td>0.9385</td> </tr> </tbody> </table> <p>Next, we took a simple average of these four, which leads <code>LB</code>: <strong>94.8</strong>.</p> <h1>Final Blends</h1> <p>We couldn't give enough time for metal features. So, we've used a public meta submission form <a href="https://www.kaggle.com/datafan07/eda-modelling-of-the-external-data-inc-ensemble" target="_blank">here</a>. And gave <code>0.1</code> to the meta-features in the final blending.</p> <p>The final blending took all the submission of <code>EfficientNets B2 to 7</code> and Meta features and combined training on the whole data set of 2020. After the generate single submission from <code>E-Net B2 to 7</code> and metal features (<code>0.1</code>), further, we did rank ensemble with combined submission. It leads the Public LB: <strong>0.9554</strong>, and Private <strong>0.9383</strong>.</p> <hr> <h2>Generalized Mean Pooling (GeM)</h2> <pre><code>class GeneralizedMeanPooling2D(tf.keras.layers.Layer): def __init__(self, p=3, epsilon=1e-6, name='', kwargs): super(GeneralizedMeanPooling2D, self).__init__(name, kwargs) self.init_p = p self.epsilon = epsilon def build(self, input_shape): if isinstance(input_shape, list) or len(input_shape) != 4: raise ValueError('`GeM` pooling layer only allow 1 input with 4 dimensions(b, h, w, c)') self.build_shape = input_shape self.p = self.add_weight( name='p', shape=[1,], initializer=tf.keras.initializers.Constant(value=self.init_p), regularizer=None, trainable=True, dtype=tf.float32 ) self.built=True def call(self, inputs): input_shape = inputs.get_shape() if isinstance(inputs, list) or len(input_shape) != 4: raise ValueError('`GeM` pooling layer only allow 1 input with 4 dimensions(b, h, w, c)') return (tf.reduce_mean(tf.abs(inputsself.p), axis=[1,2], keepdims=False) + self.epsilon)(1.0/self.p) </code></pre> <h3>Attention Weighted Network (AWN)</h3> <p>From <a href="https://www.kaggle.com/c/human-protein-atlas-image-classification/discussion/77269#454482" target="_blank">here</a>. Thanks to <a href="https://www.kaggle.com/wowfattie" target="_blank">@wowfattie</a> </p> <pre><code>class AttentionWeightedAverage2D(Layer): def __init__(self, kwargs): self.init = initializers.get('uniform') super(AttentionWeightedAverage2D, self).__init__( kwargs) def build(self, input_shape): self.input_spec = [InputSpec(ndim=4)] assert len(input_shape) == 4 self.W = self.add_weight(shape=(input_shape[3], 1), name='{}_W'.format(self.name), initializer=self.init) self._trainable_weights = [self.W] super(AttentionWeightedAverage2D, self).build(input_shape) def call(self, x): logits = K.dot(x, self.W) x_shape = K.shape(x) logits = K.reshape(logits, (x_shape[0], x_shape[1], x_shape[2])) ai = K.exp(logits - K.max(logits, axis=[1,2], keepdims=True)) att_weights = ai / (K.sum(ai, axis=[1,2], keepdims=True) + K.epsilon()) weighted_input = x * K.expand_dims(att_weights) result = K.sum(weighted_input, axis=[1,2]) return result def get_output_shape_for(self, input_shape): return self.compute_output_shape(input_shape) def compute_output_shape(self, input_shape): output_len = input_shape[3] return (input_shape[0], output_len) </code></pre> <h3>Global Average Attention Mechanism</h3> <p>The main idea of this mechanism is from <a href="https://www.kaggle.com/kmader" target="_blank">K Scott Mader</a>, currently working in Apple as ML Eng. However, you can find the vanilla implementation of the mechanism from his work (kernel). Here is one <a href="https://www.kaggle.com/hiramcho/melanoma-efficientnetb6-with-attention-mechanism" target="_blank">public kernel</a> of it. And <a href="https://www.kaggle.com/datafan07" target="_blank">@datafan07</a> also used it to his pipeline, great.</p> <hr> <p>Lastly, we like to mention some work that we've published for this competition, hope it may come helpful for future readers.</p> <ul> <li><a href="https://www.kaggle.com/ipythonx/tf-keras-melanoma-classification-starter-tabnet" target="_blank">TF.Keras: Melanoma Classification Starter, TabNet</a><ul> <li><a href="https://www.kaggle.com/ipythonx/optimizing-metrics-out-of-fold-weights-ensemble" target="_blank">Optimizing Metrics: Out-of-Fold Weights Ensemble</a></li> <li><a href="https://www.kaggle.com/ipythonx/training-cv-melanoma-starter-ghostnet-tta" target="_blank">PyTorch: [Training CV] Melanoma Starter. GhostNet + TTA</a></li> <li><a href="https://www.kaggle.com/ipythonx/tresnet-hp-gpu-dedicated-net-grad-accumulation-tta" target="_blank">PyTorch: TResNet:HP-GPU Dedicated Net+Grad-Accumulation+TTA</a></li></ul></li> </ul> <p>Yes, you're right. -)</p>
SIIM-ISIC Melanoma Classification	27th overview - I Survived the massive shakedown and be in the top 1%	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>You are right<br> Kaggle tpu time limit is 3 - hours per training , 30 hours per week (but it is really fast!)<br> If I had to train 5 folds of high-resolution images, then I needed to train 0,1,2 fold and after that, I train 3,4 fold seperately and merge [0,1,2] and [3,4] fold outputs into one output</p> <p>since it was sort of tedious jobs, for most of training, I used my local environment</p> <p>I have detailed it further.</p> <p>Thank you so much</p> <p><a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> thank you so much. i have detailed it further</p> <p>Thank you so much!</p> <ol> <li>I have trained all 5 folds models</li> <li>I utilized Chris's notebook. It is really well made and logical with stratified Tfrecords. </li> <li>with TPU, I could train models faster.</li> </ol> <p>Thank you for your sincere congratulation! </p> <ol> <li><p>256, 384, 512, 768 Size didn't take time too much with the usage of kaggle tpu and colab<br> but 1024 size training was a somewhat time-consuming work<br> but we had 2~3 months.</p></li> <li><p>I tried meta info + CNN dual inputs training, it doesn't show a sign of improving Public LB<br> with meta info added to CNN, my cv could reach above 96 just on ISIC 2020 data<br> but it didn't work for <strong>Public LB</strong> so i abandoned it(it was my mistake)<br> by an adversarial analysis, we can infer that training datasets and test datasets are somewhat different.<br> I guessed using meta info can lead my model to overfitting to just training datasets</p></li> </ol> <p>Since I had been so much afraid of shakedown, I tried to make an <strong>extremely low variance ensemble and it turned out to be a not so bad approach.</strong></p> <p><strong>With efficient net B0 ~ B7 imagenet + B0 ~ B7 noisy-student</strong><br> <strong>Size 256 , 384, 512, 768, 1024, it amounts to total 95 MODEL!</strong></p> <p>I ensembled all!</p> <p>For making networks from B0-B7, 256~1024, I used Chris's stratified notebook and I left the network original that Chris had made<br> (Efficient net -> GAP -> dense(1, smoothing = 0.05))<br> All the same network (From B0-B7, SIZE 256 to 1024)<br> All 2019 ext data and coarse dropout was applied</p> <p>as I had noticed so many strong competitors reported that their CV was around 0.95,<br> I guessed that if I could make my cv converge to around 0.95, and if my cv score > 0.95 then I thought that I supposedly could be good at this competition</p> <p><strong>This is how I ensembled 95 deep learning models</strong></p> <p><strong>NET BASED ENSEMBLE(EFFICIENT NET 0 ~ EFFICIENT NET 7)</strong><br> MODEL 0 : EffcientNet B0 from 256 to 1024, noisy + imagenet CV 0.941 PB 0.9441 PV 0.9350<br> MODEL 1 : EffcientNet B1 from 256 to 1024, noisy + imagenet CV 0.943 PB 0.9491 PV 0.9355<br> MODEL 2 : EffcientNet B2 from 256 to 1024, noisy + imagenet CV 0.946 PB 0.9516 PV 0.9406<br> MODEL 3 : EffcientNet B3 from 256 to 1024, noisy + imagenet CV 0.950 PB 0.9515 PV 0.9411<br> MODEL 4 : EffcientNet B4 from 256 to 1024, noisy + imagenet CV 0.953 PB 0.9543 PV 0.9422<br> MODEL 5 : EffcientNet B5 from 256 to 1024, noisy + imagenet CV 0.953 PB 0.9540 PV 0.9451<br> MODEL 6 : EffcientNet B6 from 256 to 1024, noisy + imagenet CV 0.953 PB 0.9536 PV 0.9472<br> MODEL 7 : EffcientNet B7 from 256 to 1024, noisy + imagenet CV 0.951 PB 0.9549 PV 0.9434<br> <strong>-> It was CV 0.9551, PUBLIC LB : 9555 PRIVATE LB 0.9461</strong></p> <p><strong>SIZE BASED ENSEMBLE(256 to 1024)</strong><br> MODEL 8 : ALL 256 SIZE, EffcientNet 0 ~ 7 CV : 0.939<br> MODEL 9 : ALL 384 SIZE, EffcientNet 0 ~ 7 CV : 0.953<br> MODEL 10 : ALL 512 SIZE, EffcientNet 0 ~ 7 CV : 0.954<br> MODEL 11 : ALL 768 SIZE, EffcientNet 0 ~ 7 CV : 0.949<br> MODEL 12 : ALL 1024 SIZE, EffcientNet 0 ~ 7 CV : 0.938</p> <p>and I adopted Power ensemble (square 2) that's because AUC is summarized to draw a line between malignant ones and benign ones.<br> If my model is robust, then the resultant power ensemble can be not much different from original ones as AUC is intrinsically just orders</p> <p><strong>SIZE BASED ENSEMBLE (with square 2, prediction^2)</strong><br> MODEL 13 : ALL 256 SIZE, EffcientNet 0 ~ 7 CV : 0.938<br> MODEL 14 : ALL 384 SIZE, EffcientNet 0 ~ 7 CV : 0.947<br> MODEL 15 : ALL 512 SIZE, EffcientNet 0 ~ 7 CV : 0.952<br> MODEL 16 : ALL 768 SIZE, EffcientNet 0 ~ 7 CV : 0.952<br> MODEL 17 : ALL 1024 SIZE, EffcientNet 0 ~ 7 CV : 0.947</p> <p><strong>FINAL MODEL = NET BASED MODEL + SIZE BASED MODEL + Square 2 SIZE BASED MODEL</strong></p> <p>FINAL MODEL :<strong>TOTAL SIMPLE AVERAGE (MODEL 0 TO 17) CV -> 0.9538</strong><br> To find appropriate weights, I adopted a differential evolution strategy</p> <h1><img src="https://i.imgur.com/xRrTIGE.png" alt="https://i.imgur.com/xRrTIGE.png"></h1> <p>FINAL MODEL : OPTIMIZE WEIGHTS WITH SCIPY DIFFERENTIAL_EVOLUTION MODULE -> <strong>CV 0.9562</strong></p> <p>0.8 * FINAL_MODEL + 0.2 * Tabular Meta(FROM XGBOOST) -> <strong>current LB 0.9446</strong><br> (If I didn't add meta info to the final model, I could have nearly reached the gold medal)<br> but at Public LB, adding meta info helped improve PUBLIC LB SCORE as much as 0.002, so I guessed that tabular data regularizes overfitting to CV(Cv dropped when added meta), that's why I couldn't abandon it</p> <p>By implementing things above described, I found out that my cv is proportional to LB</p> <p><strong>When I ensembled all, the resultant CV was around 95.62 and public LB was 95.80 and Private LB is now 94.46</strong></p> <p>I am a Kaggle novice and I am satisfied with the current result!</p> <p><strong>Some of you might be curious about scipy.optimize.differential_evolution model</strong></p> <p>This is not a special thing.</p> <p><a href="https://machinelearningmastery.com/weighted-average-ensemble-for-deep-learning-neural-networks/?fbclid=IwAR3GYgj0Fu4Mp3RhTeyacb99H2QyP5uuWJizR7ei6DOOC-NbERKQIGyBB4o" target="_blank">https://machinelearningmastery.com/weighted-average-ensemble-for-deep-learning-neural-networks/?fbclid=IwAR3GYgj0Fu4Mp3RhTeyacb99H2QyP5uuWJizR7ei6DOOC-NbERKQIGyBB4o</a></p> <p>I found the method here</p> <p>Actually, To optimize AUC ensemble, I tested the Bayesian method, the Powell optimization method(CV 9614, Public LB:9493 it turned out to be not good), and a lot of things. but CV from evolution differential method was so much proportional to Public LB since I guess it produced the optimized sum of weights = 1 and it is scaled to well for probability while bayesian and powell was not scaled to probability</p> <p><strong>What worked:</strong><br> trained model solely with 2019 data<br> Coarse dropout<br> Label smoothing<br> malignant upsampling<br> noisy student</p> <p><strong>What didn't work:</strong><br> Focal loss<br> Dual input with META + CNN(but it dramatically boosted CV)<br> Custom head<br> Meta tabular info(but it improved Public LB)<br> KNN feature bridging from train to test, from test to train</p> <p>Thank you for your congratulation!</p> <p>Let me give you an answer about what you asked</p> <ol> <li>the evaluation metric is AUC. In this competition, you don't need to classify accurately 0 : benign, 1 : malignant. it's somewhat different from measuring accuracy</li> </ol> <p>you just need to calculate how much it is likely to be,,, benign one or malignant one<br> it is expressed by "a probability"<br> for example, an output of benign one: 0.00001, malignant : 0.9495……</p> <p>i had tested a lot of networks and found out that my CV auc values were clustered around 95.x</p> <p>it means my model performance is 95.x</p> <p>in this situation, generalizing output probability around 0.95x can be a good way for maintaining model stability. if you don't apply label smoothing, your model's output can be overconfident about malignant ones or benign ones. </p> <p>that's why i applied label smoothing</p> <p>2.For upsampling, watch this!<br> <a href="https://www.kaggle.com/cdeotte/tfrecord-experiments-upsample-and-coarse-dropout" target="_blank">https://www.kaggle.com/cdeotte/tfrecord-experiments-upsample-and-coarse-dropout</a></p>
SIIM-ISIC Melanoma Classification	27th place solution - 2nd with context prize (edited)	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>This is a summery of "Yuval and nosound" model (27th place)</p> <p>You can find more in:</p> <ul> <li><a href="https://github.com/yuval6957/SIIM-Transformer" target="_blank">our github repository</a> </li> <li><a href="https://github.com/yuval6957/SIIM-Transformer/blob/master/SIIM%20paper.pdf" target="_blank">Paper</a></li> <li><a href="https://github.com/yuval6957/SIIM-Transformer/blob/master/SIIM%20presentation.pdf" target="_blank">Presentation</a></li> <li><a href="https://www.youtube.com/watch?v=qa6zimKQcno&t=15s" target="_blank">video</a></li> </ul> <h2>1. Summary</h2> <p>Our solution is based on two step model + Ensemble:</p> <ol> <li>Base model for feature extraction per image</li> <li>Transformer model - combining all the output features from a patient and predict per image. </li> <li>The 2nd stage also included some post - processing and ensembling.</li> </ol> <h3>Base Model:</h3> <p>As base model we used a models from the <a href="https://arxiv.org/abs/1905.11946" target="_blank">EfficientNet</a> family[6]:</p> <ul> <li>EfficientNet b3 </li> <li>EfficientNet b4 </li> <li>EfficientNet b5 </li> <li>EfficientNet b6 </li> <li>EfficientNet b7 </li> </ul> <p>All models were pre-trained on imagenet using noisy student algorithm. The models and weights are from <a href="https://github.com/rwightman/gen-efficientnet-pytorch" target="_blank">gen-efficientnet-pytorch</a>[2].</p> <p>The input to these model is the image and meta-data such as age, sex, and anatomic Site. The meta-data is processed by a small fully connected network and it’s output is concatenated to the input of the classification layer of the original EfficientNet network. This vector is going through a linear layer with output size of 256 to create the “features”, and then after an activation layer to the final linear classification layer. </p> <p>This network has 8 outputs and tries to classify the diagnosis label (there are actually more than 8 possible diagnoses, but some don’t have enough examples). </p> <h3>Transformer Models:</h3> <p>The input to the Transformer models are a stack of features from all images belonging to the same patient + the metadata for these images.</p> <p>The transformer is a stack of 4 transformer encoder layers with self attention as described in <a href="https://arxiv.org/abs/1706.03762" target="_blank">Attention Is All You Need</a> [1]. Each transformer encoder layer uses 4 self attention heads. </p> <p>The output of the transformer is a NC, where N is the number of input feature vectors (the number of images) and C is the number of classes (8 in this case). Hence, the transformer predicts the class of each feature vector simultaneously, using the information from all other feature vectors.</p> <p>The metadata is added using a “transformer style”, i.e. each parameter is transformed to a vector (size 256) using an embedding matrix and then added to the feature vector. for continuous values (like age) the embedding matrix was replaced by a 2 layer fully connected network. </p> <h3>Ensembling the output of all networks:</h3> <p>The data was split to 3 folds, 3 times (using 3 different seeds for splitting), and the inference was done using 16 (or 12) TTAs. giving 144 predictions from each model. These were averaged and then the outputs of all the models were averaged. All averaging was done on the outputs before softmax and there form it is actually geometric averaging.</p> <h3>Training</h3> <p>The heavy lifting was the training and inference of the base models. This was done on a server with 2 GPUs – Tesla V100, Titan RTX that worked in parallel on different tasks. Training one fold of one model took 3H (B3) to 11H (B7, B6 large images) on the Tesla and 20% more on the Titan, this sums up to about one day for B3 and 3.5 days for B7. Inferencing all the training data for 12 TTA’s + test data for 16 TTA’s to get the features for the next level took another 4h - 14h. The transformer training took less than 1H for the full model (3 folds3seed). </p> <p>The total time it took to train all models and folds is about 2.5W for one Tesla (~1.5W using the 2 GPUs).</p> <h2>2. Models and features</h2> <h3>Base models</h3> <p>As base models we tried various types of models (pre-trained on Imagenet):</p> <ul> <li>Densenets – 121, 161, 169, 201</li> <li>EfficientNet B0, B3 , B4, B5, B6, B7 with and with noisy student pre-training and with normal pretraining </li> <li>ResNet 101</li> <li>Xception </li> </ul> <p>At the end we used EfficientNet as it was best when judging accuracy/time</p> <p>The noisy student version performed better than the normal one.</p> <p>We also tried different image sizes and ended up using a <code>400600</code> images in most cases, except one were we used <code>600900</code> with the B6 network.</p> <h4>Metadata</h4> <p>As was described above the metadata was processed by a small fully connected nn and its output was concatenated to the output of the EfficientNet network (after removing the original top layer).</p> <p>We also tried a network without metadata, and used the metadata as targets, i.e. this network predicted the diagnosis, but also the sex, age and anatomic site. The final predictions (including transformer) when using this approach weren't as good as the metadata as input approach. </p> <h4>Model’s output</h4> <p>Although the task at hand is to predict melanoma yes/no, it is better to let the network choose the diagnosis among a few possible options. This lets the network “understand” more about the image. The final prediction is the value of the Melanoma output after doing softmax on the output vector. </p> <h4>Features</h4> <p>The final layer in this model is a linear layer with 256 inputs and 8 outputs, we use the input to this layer as features. </p> <h4>Augmentation</h4> <p>The following augmentations where used while training and inference:</p> <p>Random resize + crop</p> <p>Random rotation</p> <p>Random flip</p> <p>Random color jitter (brightness, contrast, saturation, hue)</p> <p><a href="https://arxiv.org/abs/1708.04552" target="_blank">Cutout</a>[3] - erasing a small rectangle in the image</p> <p>Hair - Randomly adding “hair like” lines to the image</p> <p>Metadata augmentation - adding random noise to the metadata as was done in the <a href="https://www.sciencedirect.com/science/article/pii/S2215016120300832?via%3Dihub" target="_blank">1st place solution in ISIC 2019 challenge</a> [7].</p> <h4>TTA</h4> <p>For inference each image was augmented differently 16 times and the final prediction was the average. These augmentations were also used for extracting 16 different features vectors per test image.</p> <p>The same was done to extract 12 features vectors for the train images (12 and not 16 because of time limits).</p> <h3>Transformer Network</h3> <p>The input to the transformer network is the features from all the images from one patient.</p> <p>The inspiration for this kind of model came from a previous competition in which we participated in RSNA<a href="https://www.kaggle.com/c/rsna-intracranial-hemorrhage-detection" target="_blank"> Intracranial Hemorrhage Detection</a>. In that competition, all the top solutions (including ours) used a two stage network approach (although none of them were transformers).</p> <p>Using a transformer seems appropriate in this case because transformers are built to seek relationships between embedding (feature) vectors in it’s input.</p> <p>As this is not a full seq2seq task, we only used encoder layers. The transformer is a stack of 4 encoder layers with 4 attention heads in each layer. (we also tested higher numbers of layers and attention heads - no performance improvement).</p> <h4>metadata</h4> <p>The metadata was incorporated in the network by adding “metadata vectors” to the input vectors - each value was transformed to a vector size 256 and added. The discrete values’ transformation was done using a trainable embedding matrix and the continuous values using a small nn.</p> <h4>output</h4> <p>The output of this network is a matrix of size NC where N - the number of images, C - the number of classes. Which means it decides on all the images of the patient at once. </p> <h4>Limit the input size</h4> <p>A transformer can be trained on different number of feature vectors, by using padding. But when the range of numbers is very large, from a couple of hundred images for some patients to a handful for others, this may cause some implementation issues (like in calculating the loss). To simplify these issues, we limited N to 24 feature vectors, and for each patient we randomly divided the images to groups of size up to 24. </p> <p>This might degrade the prediction as the most “similar” images might accidentally fall into different groups, but as we use TTA, this issue is almost solved. </p> <h4>Augmentation</h4> <p>From the base model we extract a number of feature vectors (12 for train and 16 for test) using different augmentation for the images and metadata. In the training and inference steps of the transformer model we randomly choose one of these vectors.</p> <p>Another augmentation is the random grouping as stated above.</p> <h2>3. Training and Inferencing</h2> <p>The original 2020 competition data is highly unbalanced, there are only 2-3% of positive targets in the train and test data. Although we were able to train the base model using uneven sampling, the best way to get good training was to add the data from ISIC 2019 competition which has a much higher percentage of melanoma images. </p> <p>We split the training data to 3 folds keeping all the images from the same patient in the same fold, and making sure each fold has a similar number of patients with melanoma. The ISIC2019’s data was also split evenly between the folds. The same folds were kept for the base and the transformer models. </p> <p>To get more diversity we had 3 different splits using 3 seeds </p> <h3>Preprocessing</h3> <p>All images were resized to an aspect ratio of 1:1.5, which was the most popular aspect ratio of the images in the original dataset. We prepared 3 image datasets of sizes <code>300450</code>, <code>400600</code>, <code>600900</code>. Most of the models were trained using the <code>400600</code> dataset, as 300450 gave inferior results and the <code>600900</code> didn’t improve the results enough.</p> <p>For the metadata we had to set the same terminology for the 2020 and 2019 datasets.</p> <h3>Loss Function</h3> <p>The loss function we used was cross entropy. Although the task is to predict only melanoma we found it is better to predict the diagnosis which was split to 8 different classes one of which was melanoma. The final prediction was the value for the melanoma class, after a softmax function on all classes. We also tried a binary cross entropy on the melanoma class alone and a combination between the two, but using cross entropy gave the best results.</p> <p>The same loss was used for the base model and the transformer, but in the transformer we needed to regularize for the different number of predictions in each batch resulting from the different number of images for each patient. </p> <p>We also tried using focal loss which didn’t improve the results, but we left one of the transformer models which was trained with focal loss in the ensemble (A model with cross entropy loss gave the similar CV and LB).</p> <h4>Training the transformer model</h4> <p>The transformer model was trained in two steps. For the first step we used the data from both competitions (2019, 2020). For the 2019 competition we don’t have information about the patient, and each image got a different dummy patient_id, meaning the transformer didn’t learn much from these images. In the 2nd stage we fine-tuned the transformer using only the 2020 competition’s data.</p> <p>In both steps we used a sampler that over sampled the larger groups.</p> <h4>Inference</h4> <p>As stated above, the inference was done using TTA. For the base model we used 12-16 different augmentations and for the transformer model 32.</p> <h3>Ensembling</h3> <p>For our final submissions we used 2 ensembles:</p> <h5>Without Context Submission:</h5> <ol> <li>EfficientNet B3 noisy student image size 400600</li> <li>EfficientNet B4 noisy student image size 400600</li> <li>EfficientNet B5 noisy student image size 400600</li> <li>EfficientNet B6 noisy student image size <strong>600900</strong></li> <li>EfficientNet B7 noisy student image size 400600</li> </ol> <h5>With Context</h5> <p>All the “without context” model +</p> <ul> <li>Transformer on features from A.</li> <li>Transformer on features from B.</li> <li>Transformer on features from C using focal loss</li> <li>Transformer on features from D.</li> <li>Transformer on features from E.</li> </ul> <h2>4. Interesting findings</h2> <h3>CV and LB</h3> <p>Although the number of images in the competition was very large, the number of different patients wasn’t large enough to give a stable and reliable CV and LB. And the correlation between the two was low. At the end we trusted neither and we submitted the models we felt were the most robust.</p> <h3>What didn’t work</h3> <ol> <li>Using different sizes of images as suggested in <a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/160147" target="_blank">CNN Input Size Explained</a> didn’t show any improvement.</li> <li>Using Mixup[5] and MixCut[4] augmentation didn’t work</li> <li>Larger transformers didn’t improve the results. </li> </ol> <h2>5. Better “Real World” model</h2> <p>This model can be much simpler if we won’t ensemble and take only one base model, the EfficientNet B5 is probably the best compromise.</p> <p>In the real world scenario the images from previous years will probably be tagged already. In that case we can use a full transformer with encoder and decoder which will perform a seq2seq operation. </p>
SIIM-ISIC Melanoma Classification	302th Solution Writeup - Always trust your CV	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>For me, the biggest win in this competition is I finally know how to use TPU 👌👌</p> <p>This competition has been very tough for me because I thought I'm stuck at the bottom of the LB and everybody seems to be way ahead of me. But I stick to my gut and trust my CV and in the end it pays off.</p> <h3>Data preprocessing:</h3> <p>To prevent leaks, I use MD5 hash to remove all duplicates on both original and external data.</p> <h3>Data augmentation:</h3> <ul> <li>ShiftScaleRotate</li> <li>Cutout </li> <li>Flip </li> <li>BrightnessContrast.</li> </ul> <h3>Validation Strategy:</h3> <p>At first I combined all data and did Triple Stratified KFold but the CV scores was way too high compared to public LB. Then I experimented with Triple Stratified KFold on original training set and noticed that CV and LB gaps are much smaller (0.917 - 0.919). So I concluded the test data must have similar distribution as the original training data.<br> My final strategy: Triple Stratified KFold on original training set, include external data during training of each folds.</p> <h3>Model (Image size):</h3> <ul> <li>B4 (384)</li> <li>B5 (456)</li> <li>B6 (512)</li> </ul> <h3>Ensemble:</h3> <p>For each model, take average of 3 folds. Then combine all models predictions using power average with p = 2.</p> <p>Overall validation scores (Average of 3 models): 0.938 CV, 0.389 Public LB, 0.376 Private LB.<br> I'm super happy because my CV, public LB and private LB are in line 😁😁.<br> Training kernel (TPU): <a href="https://www.kaggle.com/quandapro/isic-training-tpu" target="_blank">https://www.kaggle.com/quandapro/isic-training-tpu</a>.</p>
SIIM-ISIC Melanoma Classification	3rd place solution overview	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thank you very much for all the comments! :)</p> <p>Exactly <a href="https://www.kaggle.com/kozodoi" target="_blank">@kozodoi</a>! Although I had to reduce the "optimal" number of epochs on some occasions to avoid exceeding the limit of Kaggle's TPU (since I was using more data and also hair augmentation, which was quite computationally expensive).</p> <p>Hi <a href="https://www.kaggle.com/pawankumarsahu" target="_blank">@pawankumarsahu</a> ,<br> I used k-fold cross-validation to estimate the hyperparameters of the model (hyperparameter tuning) and then used those optimized hyperparameters to fit a model to the whole dataset. This procedure is based on the idea that the more data you use the more likely it is to have a robust model that generalizes well.</p> <p>Thank you, <a href="https://www.kaggle.com/robikscube" target="_blank">@robikscube</a>! I did not use hair removal in my final solution. I tested it and it worked worse for me than hair augmentation, so I decided to go this other way. The number of epochs was mostly determined based on when the early stopping was occurring in my previous CV results (with some adjustments to avoid exceeding the limit of Kaggle's TPU). Regarding my ensembles, I tried several things, but my final solution is actually a simple average of the 10 models (8 own models + 2 public notebooks). Finally I added metadata to this ensemble with a weighted average. I know I have a lot to learn about ensemble techniques and that I was pretty lucky to get such a good result with such a simple approach.</p> <p>Code available here: <a href="https://github.com/Masdevallia/3rd-place-kaggle-siim-isic-melanoma-classification" target="_blank">https://github.com/Masdevallia/3rd-place-kaggle-siim-isic-melanoma-classification</a></p> <p>Hello everybody!</p> <p>Well… I am speechless. I am quite new at Kaggle and was not expecting such a good result, it has taken me completely by surprise.</p> <p>First of all, I need to deeply thank the entire Kaggle community. I've learned a lot throughout the entire competition thanks to all the knowledge and insights you have generously shared. Thank you also to the organizers and Kaggle for hosting the competition.</p> <p>I am away on vacation with a limited internet connection, but I will share my solution as soon as I can.</p> <p>As a quick summary, my main submission was an ensemble of 8 different models built with various combinations of image sizes (256, 384, 512, 768). Many thanks to <a href="https://www.kaggle.com/vbhargav875" target="_blank">@vbhargav875</a>, whose notebook "EfficientNet-B5_B6_B7 TF-Keras" was an incredible starting point. I used CV to implement some experiments, but my finals models where obtained with all available data (without validation). I used 2017-2018-2019 + 2020 TFrecords (huge thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a>), hair augmentation (thanks to <a href="https://www.kaggle.com/nroman" target="_blank">@nroman</a> and <a href="https://www.kaggle.com/graf10a" target="_blank">@graf10a</a>), heavy TTA, EfficientNet-B6 models and metadata (thanks to <a href="https://www.kaggle.com/titericz" target="_blank">@titericz</a>). This approach scored: 0.9481 private LB, 0.9596 public LB.</p> <p>However, I wanted to try to ensemble some public notebooks too, in order to add some diversity. I decided to go ahead with these two amazing notebooks, which introduced some juicy techniques that I didn't have time to test:</p> <ul> <li><a href="https://www.kaggle.com/rajnishe/rc-fork-siim-isic-melanoma-384x384" target="_blank">https://www.kaggle.com/rajnishe/rc-fork-siim-isic-melanoma-384x384</a> (thanks to <a href="https://www.kaggle.com/rajnishe" target="_blank">@rajnishe</a>).</li> <li><a href="https://www.kaggle.com/ajaykumar7778/efficientnet-cv" target="_blank">https://www.kaggle.com/ajaykumar7778/efficientnet-cv</a> (thanks to <a href="https://www.kaggle.com/ajaykumar7778" target="_blank">@ajaykumar7778</a>).</li> </ul> <p>This approach scored: 0.9484 private LB, 0.9620 public LB.</p> <p>Congratulations to all participants! I know that I still have a long way to go, but I am looking forward to continuing to grow alongside this incredible community.</p> <p>😂😂😂 Thank you!</p> <p>Yes, exactly! Thank you!</p>
SIIM-ISIC Melanoma Classification	40th Place Summary - In Chris and CV we trust	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Hi Kaggle fam,</p> <p>Apologies this was a little delayed – was quite surprised at the result and took some time to retrace my own steps, but thought I would share a few findings that might add to what’s been shared already. </p> <p>Firstly massive shoutout to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for his triple-stratified TFrecords which saved a heap of time, and also the interesting techniques he kindly shared which I’ve still yet to try out and fully understand – I like many other noivces look forward to learning more from you in future competitions!</p> <p>Like most teams, I realised early on that training different nets on images of different sizes generated varying results in terms CV across validation folds, so I thought ensembles that maximise local CV might be the way to go. My submissions were simple weighted averages of a bunch of EfficientNets of sizes (B4-B7), mostly initialised with noisy-student weights, trained on image sizes 384, 512 and 768 with TTA (15) across 5 validation folds. For augmentation, I believe the original author of the techniques I used is <a href="https://www.kaggle.com/agentauers" target="_blank">@agentauers</a>, so a huge thank you for sharing them. Previous competition data was also used for increasing the diversity of the ensemble.</p> <p>Something I found interesting was that with my setup, larger nets + larger images seemed to have generally performed a little better than smaller nets + smaller images (both CV & private LB). Even when ensembling, smaller nets did not help with CV much at all and hence were largely not part of my final submissions. I’m curious to hear if that was the case for anyone else (sorry if it’s been talked about already).</p> <p>As for metadata, I had a hunch it might be useful so had been including it in some of my submissions – following Chris’s advice of a roughly 90/10 (image/meta) split. Shoutout to <a href="https://www.kaggle.com/titericz" target="_blank">@titericz</a> for his notebook, which worked very well for ensembling. I’d be interested to hear more from others who used metadata and how everyone incorporated it into their submissions.</p> <p>Thank you to the organisers and Kaggle fam for this wonderful competition. Here’s hoping for many more to come.</p> <p>Subs:</p> <table> <thead> <tr> <th>Sub</th> <th>No. of Effnets</th> <th>External Data</th> <th>Metadata</th> <th>Public LB</th> <th>Private LB</th> </tr> </thead> <tbody> <tr> <td>1</td> <td>18</td> <td>Y</td> <td>N</td> <td>0.9521</td> <td>0.9408</td> </tr> <tr> <td>2</td> <td>18</td> <td>Y</td> <td>Y</td> <td>0.9535</td> <td>0.9434</td> </tr> <tr> <td>3</td> <td>45</td> <td>Y</td> <td>Y</td> <td>0.9447</td> <td>0.9344</td> </tr> <tr> <td>Unused smaller ensemble</td> <td>6</td> <td>Y</td> <td>Y</td> <td>0.9544</td> <td>0.9405</td> </tr> </tbody> </table> <p>Cheers Chris! Great to hear that wasn't a one-off and you also had something similar going on. </p> <p>Thanks again for your generosity in sharing - you're an absolute legend. Please keep it up! 🙏</p>
SIIM-ISIC Melanoma Classification	85th description - random label smoothing	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks! I hope it works out for you</p> <p>Cool! I will be interested to see how that works out. The method is a little bit fiddly because it takes the single label smoothing parameter and makes many more. The results depend on the type of distribution (gauss vs uniform) as well as their shape. I suspect that I have not fully leveraged this idea, and I would like to explore what it means for the decision boundary that the network learns, especially wrt adversarial examples.</p> <p>Also thank you very much for the datasets and kernels that you published! I learned a lot from them.</p> <p>My approach was to build an ensemble of EfficientNets, I settled on this because it won last year and it did not seem that there were any new approaches performing better. I ran a lot of experiments using <a href="https://www.kaggle.com/cdeottes" target="_blank">@cdeottes</a> notebook with image size 128 and EfficientNet-B6 to find hyperparameters that increased my CV, then I made the assumption that these parameters would also work for larger image sizes and different EfficientNets. </p> <p>I included the meta data into the classifier by concatenating it with the output of an MLP on the EfficientNet output. I also experimented with different amounts of label smoothing and class weights, finding that a class weight of 5 and label smoothing of 0.05 worked best. I also experimented with assigning random label smoothing to the data as described at the end of this discussion. My final ensemble also included models trained on meta data only and on image embeddings combined with meta data, the ensembling was done using and explicit grid search on the out of fold scores for all models.</p> <p>For ensembling my models the best method I found was to find groups of predictions that were highly correlated (typically different EfficientNets trained on the same image size were highly correlated) and take a non-linear average that increased the out of fold cross validation score for each group. I then performed a grid search for the best weights to ensemble these averaged predictions. I found this approach to be superior to performing an explicit grid search without first averaging.</p> <p>To give an explicit example of this ensembling. Take all of the models trained on image size NxN, take the geometric mean (and/or median) and check that this has a better cross validation score than the best single model. Repeat this process for all image sizes that have models trained on them, taking either the geometric mean or the best single model in each case. Blend the averaged predictions for all image sizes. This can be applied to any type of grouping where correlations between predictions are found.</p> <p>The rationale behind this is that highly correlated models can still be included in the final ensemble, instead of ignoring models that took a long time to train.</p> <p>The only part of my final submission that is significantly different from what I have seen posted elsewhere is that I trained some models where the amount of label smoothing for each example was drawn randomly from a distribution. So each time the model saw an example, the label was different. As far as I am aware this is the first time this method has been employed.</p> <p>I trained multiple models with this strategy, experimenting with different distributions (for sampling the label smoothing), and then I ensembled all of these experiments (geometric mean and median both increased CV). This ensemble had a weight of 0.25 in my final submission.</p> <p>This approach produced the lowest difference between CV, private LB and public LB for a single model that I have trained. The scores for a single model trained in this way, with labels drawn from a gaussian with mean 0.05 and std 0.025, are:</p> <p>CV (2020 data only) 0.927<br> private LB 0.9319<br> public LB 0.9389.</p> <p>Which can be compared with the original <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">notebook</a> scores of:</p> <p>CV (2020 data only) 0.904<br> private LB 0.9262<br> public LB 0.9454.</p> <p>To be completely clear on what this entails I used the following loss:</p> <pre><code>class sls_loss(tf.keras.losses.Loss): def call(self, y_true, y_pred): ls = tf.abs(tf.random.normal([1], 0, 0.025, tf.float32)) y_true = y_true * (1.0 - ls) + 0.5 * ls bce = tf.keras.losses.BinaryCrossentropy(label_smoothing=0, reduction=tf.keras.losses.Reduction.NONE) per_example_loss = bce(y_true,y_pred) return tf.nn.compute_average_loss(per_example_loss, global_batch_size=GLOBAL_BATCH_SIZE) </code></pre> <p>Note this is slightly different to what I described as it is per batch.</p>
SIIM-ISIC Melanoma Classification	From 66x online tutorials to winning the First Provisional Silver Medal	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Hi everyone. After completing 66x online tutorials and going through shake-ups in the initial competitions I am able to secure my first silver medal. Special thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for his amazing notebook. I blended models of images with all size :). Special thanks to amazing mentors <a href="https://www.kaggle.com/dmitrylarko" target="_blank">@dmitrylarko</a> and 4x grandmaster <a href="https://www.kaggle.com/abhishek" target="_blank">@abhishek</a>. Good Luck to everyone.</p>
SIIM-ISIC Melanoma Classification	Justification and 4th place Solution Overview	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Almost the same interpretation<br> <em>y</em> does not have to be a single model, but it is not recommended if the R2 score between <em>y</em> and <em>z</em> is high (R2> 0.7).<br> On the other hand, choosing <em>y</em> with a higher R2 may increase the public score, but at the risk of overfitting the public score.<br> If you find a model where R2 between <em>y</em> and <em>z</em> is between 0.5 and 0.7 and can contribute to the public score, your private score will be guaranteed too.</p> <p>You made me notice a lot. Thank you very much.</p> <p>Each parameter I used is:</p> <p>DataSet:2017-2018-2019 + 2020 TFrecords (thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a>)<br> Image_size:384384<br> Model:efficientnet-b6<br> Loss:binary_crossentropy<br> Optimizer:Adam<br> Seed:42<br> TTA:15<br> Model building:<br> With reference to <a href="https://www.kaggle.com/ajaykumar7778/efficientnet-cv" target="_blank">https://www.kaggle.com/ajaykumar7778/efficientnet-cv</a> (thanks to <a href="https://www.kaggle.com/ajaykumar7778" target="_blank">@ajaykumar7778</a>)<br> x = base(keras.layers.Input(shape=(384,384,3)))<br> x = keras.layers.GlobalAveragePooling2D()(x)<br> x = keras.layers.Dropout(0.3)(x)<br> x = keras.layers.Dense(1024)(x)<br> x = keras.layers.Dropout(0.2)(x)<br> x = keras.layers.Dense(512)(x)<br> x = keras.layers.Dropout(0.4)(x)<br> x = keras.layers.Dense(256)(x)<br> x = keras.layers.Dropout(0.3)(x)<br> x = keras.layers.Dense(128)(x) <br> x = keras.layers.Dense(1)(x)<br> x = keras.layers.Activation('sigmoid', dtype='float32')(x)</p> <p>By blending with <a href="https://www.kaggle.com/paklau9/minmax-highest-public-lb-9619" target="_blank">https://www.kaggle.com/paklau9/minmax-highest-public-lb-9619</a>, Scored 0.9596 public LB and 0.9476 private LB. (thanks to@Pak Lau9)<br> I believe that one of the reason is probably that the R2 score is less than 0.6 between the ensemble models, the correlation is not large, and the generalization performance is high.</p> <p>First of all, thanks to the Kaggle community and the organizers.<br> I learned a lot through the competition.</p> <p>Some people suspect me to be a bot, so I will provide 4th place solution.<br> Certainly, I can't hide my surprise at this result.<br> But I'm a little disappointed with the skepticism of the competition itself.<br> I hope the contest is held in our good faith.</p> <p>I could not submit it many times, of course, because the participation period was not long.<br> In addition, the model was selected based on the CV results.<br> CV was done with multiple resolutions, and 384384 was the best.<br> Also, When ensemble with the best scoring model,<br> I was able to efficiently raise the score by performing the ensemble at the rate that the difference from the result after the ensemble became the minimum.<br> By using this method, we were able to exclude the ones with very bad differences.<br> However, this method also carries the risk of overfitting public data.<br> I think there is also a risk in ignoring CV results and increasing the number of applications and raising the score.<br> In fact, the 4th private score I got wasn't the best model in public.</p> <p>And I think the main factors to win are:<br> I have found that some of the prediction results of the CV model predict a high positive rate, whereas many kernels predict a low positive rate.<br> I thought this was a false negative in many published models.</p> <p>I finally submitted the following 3 models.<br> (1) Best score<br> (2) Ensemble with best score and model considered in CV<br> (3) Due to risk of overfitting, ensemble with model other than the best score and model considered in CV </p> <p>As a result, Model (3) was the 4th place result. and, (1) was the worst.<br> From this result, the following can be said.<br> Like many kernel predictive models, the best-scoring model are also models with low sensitivity and is more likely to predict false negatives.<br> The highest scoring model fits public data too much.</p> <p>I think the following are valid:<br> Trust CV as many claims show<br> We also observe trends by comparing with the results of many models that have a low correlation with the results examined in CV.</p> <p>Of course, it is very lucky that the model (3) got the 4th place result.</p> <p>I am aware of my lack of skills. However, I've found the fun of kaggle.<br> I will continue to deepen my learning through other contests.</p> <p>Best Regards</p> <p>Thank you everyone for celebrating me.</p> <p>To Helen-san<br> Thank you for your comment.<br> I'm sorry to explain a very simple method.<br> To use this method, you first need to find one prediction that contributed to best score model by the ensemble.<br> That prediction is y.Then try to run the following code, where x is the prediction of the model you want to ensemble.<br> That's how the models that helped to best score model are improved and help to score further.</p> <p>`import pandas as pd<br> import numpy as np<br> from statistics import mean</p> <p>x=pd.read_csv("submission_x.csv")["target"]<br> y=pd.read_csv("submission_y.csv")["target"]<br> z=pd.read_csv("submission_best.csv")["target"]</p> <h1>x:Prediction you want to ensemble</h1> <h1>y:Prediction that contributed to the best prediction</h1> <h1>z:Best prediction</h1> <p>df=pd.read_csv("sample_submission.csv")</p> <p>best=len(x)<br> for a in np.arange(0, 1, 0.1):<br> b=1-a<br> c=(a<em>x+b</em>y)<br> d=abs(z-c)/z<br> res=mean(d)<br> if res <best:<br> best=res<br> beat_a=a<br> beat_b=b<br> best_c=c</p> <p>if best>0.5:<br> print("Do not recommend ensemble")<br> else:<br> best_pre=z<em>0.9+best_c</em>0.1<br> df["target"]=best_pre<br> df.to_csv("submission.csv", index=False)<br> print(best)<br> print(f'a: {beat_a}')<br> print(f'b: {beat_b}')`</p>
SIIM-ISIC Melanoma Classification	Missed Opportunity - 4th place - Solo Gold	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p><a href="https://www.kaggle.com/cpmpml" target="_blank">@cpmpml</a>, nope I would not have chosen using any reasonable intuition because it is my own conservative blend of blends which is usually risky.</p> <p>Thanks <a href="https://www.kaggle.com/mightyrains" target="_blank">@mightyrains</a>.</p> <p>I forgot to say that yesterday. </p> <p><a href="https://www.kaggle.com/robikscube" target="_blank">@robikscube</a> congrats to you and your team for another strong finish.</p> <p><a href="https://www.kaggle.com/authman" target="_blank">@authman</a> congrats to you and your team on the silver medal.</p> <p>Congrats on another strong finish and thanks for your kind words <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a>.</p> <p>Your contributions here and always is well apreciated. I joined the Flower competition to try out TPU and I learnt a lot from you there as well as here on that subject. Your triple stratified dataset made life easier for so many of us. So thanks so much.</p> <p><a href="https://www.kaggle.com/authman" target="_blank">@authman</a>, <br> <a href="https://www.kaggle.com/robikscube" target="_blank">@robikscube</a>, <br> Thanks so much for your kind words. <br> I am thankful for experiencing this competition because I learnt so much about the use of TPU and a few TF tricks.</p> <p>Congrats <a href="https://www.kaggle.com/serigne" target="_blank">@serigne</a> on a strong finish. </p> <p>My current position public LB= 0.9571, private LB=0.9424 is a lower scoring one on the public LB but I went with trusting my CV as well. The best in private LB submission I did not choose was one of my ensembles that does not have a CV score. With a systematic approach there is no way I would have chosen it. I am only disappointed because I have been waiting so long for the elusive solo gold.</p> <p><a href="https://www.kaggle.com/roydatascience" target="_blank">@roydatascience</a>, it is an ensemble without CV hence there is no way I would have chosen it. I went with trusting my CV and chose a simple averaged ensemble and the other 2 based on CV ensemble.</p> <p><a href="https://www.kaggle.com/mpsampat" target="_blank">@mpsampat</a>, thanks for your kind words. Congrats on your silver medal.</p> <p><a href="https://www.kaggle.com/serigne" target="_blank">@serigne</a>, thanks.</p> <p>I had similar result to yours in the Jigsaw Multilingual competition as well hence my feeling a little sad this time. J'espère bientôt pour l'or en solo.</p> <p><a href="https://www.kaggle.com/roydatascience" target="_blank">@roydatascience</a>, my 2nd best submission on the private LB which is my current LB position is a submissions mean of 27 models.</p> <p>Congratulations to the winners.</p> <p><strong>Scores:-</strong><br> <strong>public LB=0.9618</strong><br> <strong>private LB=0.9482</strong> </p> <p>I am Gutted.</p> <p><a href="https://www.kaggle.com/sheriytm/melanoma-clf-xgb-missed-opportunity-4th-place" target="_blank">https://www.kaggle.com/sheriytm/melanoma-clf-xgb-missed-opportunity-4th-place</a></p> <p><strong>UPDATE</strong></p> <p>In late submission, using the mean ensemble of 27 models which gave my private LB score in the above ensemble script scores :-<br> <strong>public LB=0.9618</strong><br> <strong>private LB=0.9487</strong> </p>
SIIM-ISIC Melanoma Classification	My 23rd Place Aprroach	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks Dimitre!</p> <p>Yeah they were very diverse than the rest but gave decent cv and lb's so I included them too. I built this model in last 3-4 days so couldn't test it out on larger scale. But just checked the mix of these 7, that cluster alone gave me 0.9404 in private. If I had more time and tpu power maybe could get something better from it…</p> <p>No didn't include meta on this final heatmap. The 7's are from my last approach I shared in this topic, first models were mainly from earlier approaches similar to my first public notebook.</p> <p>I clustered similar approaches in different groups, eliminated some, then took them to this final map.</p> <p>For example this is one of the earlier clusetrs, mainly from my public notebook results, you can see the metadata easily:</p> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F4616296%2F4f8fd7e5ef5670771e6eb1faf9b53caf%2FScreenshot_2020-08-20%20corr%20-%20Jupyter%20Notebook.png?generation=1597888150914491&alt=media" alt=""></p> <p>Thanks. I'll try to publish it when my TPU timer resets…</p> <p>Just an update;</p> <p>Since my TPU limit reset I shared light version of my approach here.</p> <p><a href="https://www.kaggle.com/datafan07/final-melanoma-model-18th-place-solution-light-v" target="_blank">https://www.kaggle.com/datafan07/final-melanoma-model-18th-place-solution-light-v</a></p> <p>You are welcome! <a href="https://www.kaggle.com/fiyeroleung" target="_blank">@fiyeroleung</a> </p> <p>Thank you Chris!, my job would be much more harder without your perfect baselines and data!</p> <p>Thank you again Ben, it was great adaptation. I really enjoyed while playing with the custom callback!</p> <p><strong>Update;</strong></p> <p>Since my TPU limit reset I shared light version of my approach here:</p> <p><a href="https://www.kaggle.com/datafan07/final-melanoma-model-18th-place-solution-light-v" target="_blank">https://www.kaggle.com/datafan07/final-melanoma-model-18th-place-solution-light-v</a></p> <p>First of all thank you Kaggle and rest of the people involved in this competition. It was my first serious competition ever and learned a lot on the way. I wanted to write what worked for me (at least what I think worked), I learnt a lot from this community so I wanted to share them back!</p> <p>My highest scored submission on public score was based only 2020 data only. They were doing good with efficientnet + meta blend but I noticed they weren't doing great in terms of non seen data. I thought this were due to some unseen test set which Chris and I pointed out in some public discussions.</p> <p>I was getting some unstable results for some cases in the test set, there were big differences between only 2020 trained predictions and only 2019 predictions. I had gut feeling that this might be caused by some medical differences about the stage of the melanoma, or different scanning device but that's not my expertise area at all so to get overcome that I decided to use external data, I thought adding more examples would make my model better at predicting these weird cases. Thanks to Chris I used the external tfrecords and malignant upsampling on my existing model.</p> <p>Well… That increased my CV a lot but wasn't the case with LB. I decided to add these external data one by one and at the end decided to keep out 2019 part out of my model and only used 2018. This helped me a little but there was a big problem: <strong>overfitting</strong>. Tried some augmentations and regularizing but wasn't enough imo. I was really interested in Coarse Dropout from Chris but it was kinda damaging my model speed at the dropout levels I want. Then found <a href="https://www.kaggle.com/benboren" target="_blank">@benboren</a> 's great sprinkle method and fine tuned it for my model:</p> <pre><code>def make_mask(num_holes,side_length,rows, cols, num_channels): """Builds the mask for all sprinkles.""" row_range = tf.tile(tf.range(rows)[..., tf.newaxis], [1, num_holes]) col_range = tf.tile(tf.range(cols)[..., tf.newaxis], [1, num_holes]) r_idx = tf.random.uniform([num_holes], minval=0, maxval=rows-1, dtype=tf.int32) c_idx = tf.random.uniform([num_holes], minval=0, maxval=cols-1, dtype=tf.int32) r1 = tf.clip_by_value(r_idx - side_length // 2, 0, rows) r2 = tf.clip_by_value(r_idx + side_length // 2, 0, rows) c1 = tf.clip_by_value(c_idx - side_length // 2, 0, cols) c2 = tf.clip_by_value(c_idx + side_length // 2, 0, cols) row_mask = (row_range > r1) & (row_range < r2) col_mask = (col_range > c1) & (col_range < c2) # Combine masks into one layer and duplicate over channels. mask = row_mask[:, tf.newaxis] & col_mask mask = tf.reduce_any(mask, axis=-1) mask = mask[..., tf.newaxis] mask = tf.tile(mask, [1, 1, num_channels]) return mask def sprinkles(image, cfg = CFG): num_holes = cfg['num_holes'] side_length = cfg['side_length'] mode = cfg['sprinkles_mode'] PROBABILITY = cfg['sprinkles_prob'] RandProb = tf.cast( tf.random.uniform([],0,1) < PROBABILITY, tf.int32) if (RandProb == 0)\|(num_holes == 0): return image img_shape = tf.shape(image) if mode is 'normal': rejected = tf.zeros_like(image) elif mode is 'salt_pepper': num_holes = num_holes // 2 rejected_high = tf.ones_like(image) rejected_low = tf.zeros_like(image) elif mode is 'gaussian': rejected = tf.random.normal(img_shape, dtype=tf.float32) else: raise ValueError(f'Unknown mode "{mode}" given.') rows = img_shape[0] cols = img_shape[1] num_channels = img_shape[-1] if mode is 'salt_pepper': mask1 = make_mask(num_holes,side_length,rows, cols, num_channels) mask2 = make_mask(num_holes,side_length,rows, cols, num_channels) filtered_image = tf.where(mask1, rejected_high, image) filtered_image = tf.where(mask2, rejected_low, filtered_image) else: mask = make_mask(num_holes,side_length,rows, cols, num_channels) filtered_image = tf.where(mask, rejected, image) return filtered_image </code></pre> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F4616296%2F9f27283c72e3b99022acdff72643cce0%2F__results___13_0.png?generation=1597716024628082&alt=media" alt=""></p> <p>After adding this to my regular augmentations, I have noticed it decreased overfitting but it also reduced my models learning speed. To fix that I wanted to add attention on my model, thought that might speed up the training speed and also helps with the cv so ended up adding Scott Madder's attention model to my efficientnet top, attention explanation directly from his notebook <a href="https://www.kaggle.com/kmader/attention-on-pretrained-vgg16-for-bone-age#Show-Attention" target="_blank">here</a>. So I played with it edited it here and there meanwhile added another input to my model including metadata from tfrecords and ended up with this:</p> <pre><code>def get_model(): with strategy.scope(): inp1 = tf.keras.layers.Input(shape = (cfg['net_size'],cfg['net_size'], 3), name = 'inp1') inp2 = tf.keras.layers.Input(shape = (9), name = 'inp2') efnetb3 = efn.EfficientNetB3(weights = 'noisy-student', include_top = False) pt_depth = efnetb3.get_output_shape_at(0)[-1] pt_features = efnetb3(inp1) bn_features = tf.keras.layers.BatchNormalization()(pt_features) attn_layer = tf.keras.layers.Conv2D(64, kernel_size = (1, 1), padding = "same", activation = "relu")(tf.keras.layers.Dropout(0.5)(bn_features)) attn_layer = tf.keras.layers.Conv2D(16, kernel_size = (1, 1), padding = "same", activation = "relu")(attn_layer) attn_layer = tf.keras.layers.Conv2D(8, kernel_size = (1,1), padding = 'same', activation = 'relu')(attn_layer) attn_layer = tf.keras.layers.Conv2D(1, kernel_size = (1, 1), padding = "valid", activation = "sigmoid")(attn_layer) up_c2_w = np.ones((1, 1, 1, pt_depth)) up_c2 = tf.keras.layers.Conv2D(pt_depth, kernel_size = (1, 1), padding = "same", activation = "linear", use_bias = False, weights = [up_c2_w] ) up_c2.trainable = False attn_layer = up_c2(attn_layer) mask_features = tf.keras.layers.multiply([attn_layer, bn_features]) gap_features = tf.keras.layers.GlobalAveragePooling2D()(mask_features) gap_mask = tf.keras.layers.GlobalAveragePooling2D()(attn_layer) # To account for missing values from the attention model gap = tf.keras.layers.Lambda(lambda x: x[0] / x[1], name = "RescaleGAP")([gap_features, gap_mask]) gap_dr = tf.keras.layers.Dropout(0.5)(gap) dr_steps = tf.keras.layers.Dropout(0.25)(tf.keras.layers.Dense(128, activation = "relu")(gap_dr)) x1 = tf.keras.layers.Dense(16)(inp2) x1 = tf.keras.layers.Activation('relu')(x1) x1 = tf.keras.layers.Dropout(0.2)(x1) x1 = tf.keras.layers.BatchNormalization()(x1) x1 = tf.keras.layers.Dense(8)(inp2) x1 = tf.keras.layers.Activation('relu')(x1) x1 = tf.keras.layers.Dropout(0.2)(x1) x1 = tf.keras.layers.BatchNormalization()(x1) concat = tf.keras.layers.concatenate([dr_steps, x1]) concat = tf.keras.layers.Dense(512, activation = 'relu')(concat) concat = tf.keras.layers.BatchNormalization()(concat) concat = tf.keras.layers.Dropout(0.15)(concat) output = tf.keras.layers.Dense(1, activation = 'sigmoid',dtype='float32')(concat) model = tf.keras.models.Model(inputs = [inp1, inp2], outputs = [output]) opt = tf.keras.optimizers.Adam(learning_rate = LR) model.compile( optimizer = opt, loss = [tfa.losses.SigmoidFocalCrossEntropy(gamma = 2.0, alpha = 0.90)], metrics = [tf.keras.metrics.BinaryAccuracy(), tf.keras.metrics.AUC()] ) return model </code></pre> <p>I got predictions for different image sizes and different efficientnets and different data ratios (external etc.).</p> <p>At the end looking for ensembling I choose pretty basic way of averaging different models. I got CV's and LB's for many models and ensembled them basically depending on correlations between them, the heatmap looked like this, sorry for the mess :)</p> <p><img src="https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F4616296%2F85de95f55a0d3fb77a21b5b81e30aae1%2FScreenshot_2020-08-18%20corr%20-%20Jupyter%20Notebook.png?generation=1597716422214100&alt=media" alt=""></p> <p>Simply I ensembled the high cv predictions with less correlations between them. And got the final results.</p> <p>This was my first proper competition and I wasn't expecting writing something like this so this might be not looking like your usual writeups. I learnt a lot in this competition and wanted to share some of them back! Maybe I'll release the notebook in more proper way later but that's it for now. Thank you all!</p> <p><a href="https://www.kaggle.com/epocxy" target="_blank">@epocxy</a> details are here in my notebook, you can also see the original work there</p> <p><a href="https://www.kaggle.com/datafan07/final-melanoma-model-16th-place-solution-light-v" target="_blank">https://www.kaggle.com/datafan07/final-melanoma-model-16th-place-solution-light-v</a></p>
SIIM-ISIC Melanoma Classification	Our best private solution (0.9498) [not selected]	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>As most participants, we have not chosen our best private solution. But we would like to share it with you. Maybe it will be helpful for someone!</p> <p><a href="https://www.kaggle.com/vladimirsydor/solution-private-score-0-9498-not-selected" target="_blank">https://www.kaggle.com/vladimirsydor/solution-private-score-0-9498-not-selected</a></p> <p>Thanks to Kaggle team and all participants and good Kaggling! </p>
SIIM-ISIC Melanoma Classification	[2nd place] Solution Overview	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I used all the training data for ISIC 2019 in addition to the data provided for this competition. </p> <p>I have a <code>Trainer</code> class that uses this for gradient accumulation:</p> <pre><code>self.optimizer.zero_grad() for i in range(int(self.gradient_accumulation)): output = self.model(accum_batch[i]) loss = self.criterion(output, accum_labels[i]) (loss / self.gradient_accumulation).backward() self.optimizer.step() </code></pre> <p>I had gotten a grant from HOSTKEY for 4x 1080 Ti, so to maximize usage of all my GPUs, I also ran additional experiments on those GPUs. </p> <p>I mainly used it to test different backbones. I used small image size 256x256 and just experimented with different backbones to see which one performed best. This doesn't guarantee that I will pick the best backbone for the final configuration, but it led me to conclude that EfficientNet was the best family of backbones, without much benefit going to B7/B8. </p> <p>Usually I don't have the luxury of having additional GPUs for extra experimentation. I didn't use the 1080s for the final models because I wanted to leverage maximum batch size. </p> <p>Thank you! I did not use label smoothing. </p> <p>Thank you! I was using metadata in the beginning, and during the last week I decided to train some models without metadata so I could be eligible for without context prizes. Turns out these were my best models in the end. </p> <p>I used embedding layers to map the metadata to 32-dimensional vectors, which I then concatenated to the image feature vector before inputting the concatenated vector into the final linear classification head. </p> <p>Thank you! Now that I've started residency, it's definitely tough to keep up with Kaggle. I got lucky with this competition…</p> <p>Thanks! I just used the melanoma probability as the predicted score for submission.</p> <p>For my EfficientNet-B6, each fold took about 2 hours. For B7, about 4 hours. </p> <p>Thank you, Chris! I really appreciate all your discussion posts and notebooks, in this competition and others. </p> <p>I updated my post to detail the pseudolabeling more. I used soft pseudolabels (predicted probabilities) and a modified cross entropy loss. </p> <p>Haha, provisional since I might get DQ'd! I don't think I broke any rules, but after the deepfake fiasco, you can never be sure…</p> <p>Code available here: <a href="https://github.com/i-pan/kaggle-melanoma" target="_blank">https://github.com/i-pan/kaggle-melanoma</a></p> <p>Wow. Did not expect this. But super excited to finally get my solo gold medal and complete the journey to Grandmaster. I'm grateful to benefit from the shakeup this time after suffering in PANDA. Thank you to all the organizers, and congratulations to all the other winners and participants. </p> <p>This year, I accomplished 2 milestones: 1) I graduated medical school and became a doctor; and 2) I became a Kaggle Competitions Grandmaster. I actually just started my intern year as a doctor working 70-80 hours/week so did not have too much time to dedicate to this competition. The key was having a pipeline that allowed me to quickly iterate on experiments so I could start them in the morning, go to work, then analyze the results when I came back. Long story short, to all those who are starting out, keep going. Put in the time and effort. Compete, read winners' solutions, and learn, over and over again. </p> <p>I have to thank my teammates in previous competitions <a href="https://www.kaggle.com/felipekitamura" target="_blank">@felipekitamura</a>, <a href="https://www.kaggle.com/alexandrecc" target="_blank">@alexandrecc</a>, and <a href="https://www.kaggle.com/jamesphoward" target="_blank">@jamesphoward</a>. And I also have to thank the Kaggle community as I have learned so much from participating.</p> <p>Also huge thanks to <a href="https://www.kaggle.com/cdeotte" target="_blank">@cdeotte</a> for all the insights he shared. I used his triple stratified dataset to split my data for CV. </p> <p><strong>Environment</strong><br> PyTorch 1.6 with automatic mixed precision<br> 4x NVIDIA GTX 1080 Ti 11GB provided by HOSTKEY (<a href="http://www.hostkey.com" target="_blank">www.hostkey.com</a>) as part of their Kaggle competitions grant<br> 4x Quadro RTX 6000 24GB </p> <p><strong>Batch Size</strong><br> In the beginning, I was training models on GTX 1080 Ti GPUs provided by HOSTKEY. I wasn’t able to get multi-GPU training to work, so I was just experimenting with batch sizes of 8-16 on a single 11GB 1080 Ti. My CV scores were not that high, usually a 5-fold average of around 0.92, with similar results on LB. The TPU kernels were doing so well (on public LB, at least), that I thought it was in part due to increased batch size. At that point, I switched over to my 4x Quadro RTX6000 24GB setup to leverage more GPU memory and multi-GPU training. I aimed for a batch size of 64 while maximizing image resolution for a particular backbone (and if that would not fit, I settled for BS 32 with gradient accumulation 2).</p> <p><strong>Backbones & Image Resolution</strong><br> I tried several backbones in the EfficientNet, SE-ResNeXt, and ResNeSt families. I also tried BiT-ResNet (recently released by Google). EfficientNet performed better on CV so I decided to stick with EfficientNets for the remainder of the competition. I used the 1080 Ti GPUs to experiment with different backbones, all other hyperparameters held constant. Some of you asked whether this necessarily transfers when I switch over to a larger GPU and increase the batch size/change the image resolution. I did briefly compare backbones on the larger GPU and the results seemed to be consistent (EfficientNet > all others). </p> <p>I experimented with backbones of different sizes from pruned EfficientNet-B3 to EfficientNet-B8, using the implementation from <a href="https://github.com/rwightman/pytorch-image-models" target="_blank">https://github.com/rwightman/pytorch-image-models</a>. For smaller backbones, I tried larger resolutions (up to 1024 x 1024) and for EfficientNet-B8 I went down to 384 x 384. The image size for each backbone was selected so that I could use batch size of 64 (16/GPU) during training. I found that smaller EfficientNets at higher resolutions were not as good. The best models for me were EfficientNet-B6 (initialized with noisy student weights) and EfficientNet-B7, at image resolutions of 512 x 512 and 640 x 640, respectively, so I only used these moving forward.</p> <p><strong>Base Model</strong><br> My base model was your standard convolutional neural network backbone with linear classification head. I used generalized mean pooling with trainable parameter p (not sure if this was any better than average or max, as I just stuck with GeM from the beginning). I also used multisample dropout following <a href="https://www.kaggle.com/qishenha" target="_blank">@qishenha</a>’s implementation in one of this winning NLP solutions. </p> <p><strong>From 2 Class to 3 Class</strong><br> I felt that more granular classes would result in better feature representations that could help improve performance. The majority of melanomas are dark (exception being rare amelanotic melanomas), so differentiating them from benign nevi is probably the most challenging task. The 2019 data all had auxiliary diagnoses, including nevi, whereas a large fraction of the 2020 data was unknown. </p> <p>I trained a model on 2019 data only using the diagnosis as the target. Then, I applied this model to the 2020 data. My main focus was on labeling the unknowns as nevus or not nevus, as I know they are not melanoma. To find the threshold at which I would label an image as nevus, I used the 5th percentile of the 2019 model’s predictions on the 2020 data which had a known label of nevus.</p> <p>Now, all of the 2019 and 2020 data has a label of other, benign nevus, or melanoma, and I trained my model on these 3 classes using vanilla cross-entropy loss. I did not try label smoothing.</p> <p><strong>Upsampling</strong><br> There was a lot of discussion over whether or not to upsample malignant images or not. I did upsample malignant images for 2020 data. Because I used 2019 data and the percentage of melanomas in that dataset was much higher, I wanted to make sure that the 2019 melanomas did not overwhelm the 2020 melanomas. To that end, I upsampled the 2020 melanomas 7 times so that there was about an equal number of melanomas from both datasets.</p> <p><strong>Training</strong><br> I used AdamW optimizer and cosine annealing with warm restarts scheduler, initial learning rate 3.0E-4. I did 3 snapshots, 2 epochs each for EfficientNet-B6 and 3 epochs each for EfficientNet-B7. I noticed that it did not take long for the models to start overfitting. I found that this gave better results than using one cycle, so I stuck with it. Out of the 3 snapshots, I just took the one that did the best on that validation fold. Every experiment I ran, I did 5-fold CV using Chris Deotte’s triple stratified data splits. Single validation folds were not stable for me, so in order to really understand my model performance and the effects of my adjustments I had to look at 5-fold CV average. I only validated on 2020 data. </p> <p>In the beginning, I was using metadata by using embeddings for age, sex, and location. Each embedding was mapped to a 32-D vector and concatenated to the final feature vector before input into the linear classification layer. I did not want to spend too much time tuning this because I was afraid I would overfit to the distribution of the training set. I just used mean/mode imputation for missing values. </p> <p>It wasn’t until the last several days of the competition that I decided to train models without metadata, so I could be eligible for the without context special prize. It turns out that these models were actually my highest scoring private LB solutions!</p> <p><strong>Augmentations</strong><br> I knew that augmentation would be important given the small percentage of melanomas in the 2020 data. I used the RandAugment strategy, implemented here: <a href="https://github.com/ildoonet/pytorch-randaugment" target="_blank">https://github.com/ildoonet/pytorch-randaugment</a>. I used N=3 augmentations with magnitude M/30 where M was sampled from a Poisson distribution with mean 12 for extra stochasticity. For those unfamiliar with RandAugment, M is essentially the “hardness” of the augmentation (angle for rotation, % zoom, gamma for contrast adjustment, etc.). For augmentations like flips, M is not relevant. I tried other augmentations such as mixup, cutmix, and grid mask, but those did not help.</p> <p>I also used square cropping during training and inference. During training, a square was randomly cropped from the image if it was rectangular (otherwise, the entire image was used), where the length of the square image was the size of the shortest side (i.e., 768x512 would be cropped to 512x512). During inference, I spaced out 10 square crops as TTA and took the average as the final prediction (again, unless the image was already square - then no TTA was applied). I found that this gave me better results than rectangular crops or using the whole image. </p> <p><strong>Pseudolabeling</strong><br> Pseudolabeling was key to my solution. Given the limited number of 2020 melanomas, I felt that pseudolabeling would help increase performance. 2019 melanomas were helpful but still different from 2020 melanomas. I took my 5-fold EfficientNet-B6 model, trained without metadata, and obtained soft pseudolabels (3 classes) for the test set. When combining the test data with the training data (2019+2020), I upsampled images with melanoma prediction > 0.5 7 times (same factor as I did for 2020 training data). I used <a href="https://www.kaggle.com/cpmpml" target="_blank">@cpmpml</a>'s implementation (<a href="https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/173733" target="_blank">https://www.kaggle.com/c/siim-isic-melanoma-classification/discussion/173733</a>) of cross entropy in PyTorch (without label smoothing) so I could use soft pseudolabels. </p> <p><strong>CV vs LB</strong><br> I knew early on that it would be easy to fit public LB, given the small number of melanomas that would be in the public test. At the same time, the CV for my different experiments was much tighter than the LB, so I was nervous to fully trust CV as there may have been differences between training and test data. With that in mind, I favored solutions that had reasonably high CV and LB. </p> <p>There is a fair amount of luck that goes into picking the right solution, but you should be able to justify to yourself why you are picking a certain solution over another (going by CV score, LB score, some combination of CV/LB, or some hypotheses about the private test set that would favor one solution over another). </p> <p>My 2nd place solution was an ensemble of 3 5-fold models:</p> <ul> <li>EfficientNet-B6, 512x512, BS64, no metadata (CV 0.9336 / public 0.9534)</li> <li>EfficientNet-B7, 640x640, BS32, gradient accumulation 2, no metadata (CV 0.9389 / public 0.9525)</li> <li>Model 1, trained on combined training and pseudolabeled test data (CV 0.9438 / public 0.9493)</li> </ul> <p>Note that the CV score does not account for the 5-fold blend effect. </p> <p>My highest scoring private LB solution was actually model 3 alone, which I did not select.</p> <p>I trained other models with metadata, but best private LB score was 0.945 (public LB 0.959), with similar CV. </p>
SIIM-ISIC Melanoma Classification	[Summary] Public 11 Private 23 and Congrats to a new Master	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: SIIM-ISIC Melanoma Classification <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Congratulations to our new master <a href="https://www.kaggle.com/meliao" target="_blank">@meliao</a> !🙌🙌🙌</p> <p>First of all, congratulations to everyone who insists on CV and finally got its deserved place ! 😁</p> <p>A lot of thanks to my teammates <a href="https://www.kaggle.com/jielu0728" target="_blank">@jielu0728</a> <a href="https://www.kaggle.com/meliao" target="_blank">@meliao</a> <a href="https://www.kaggle.com/dandingclam" target="_blank">@dandingclam</a> <a href="https://www.kaggle.com/captain0602" target="_blank">@captain0602</a> 😏Even though a little frustrated with the final result because we had hoped to win a gold. We were almost the least shaken among the top teams. </p> <p>Our 0.9451 solution ranked 6th among all our 300+ submissions, and our 2 highest submissions are 0.9462. But I don’t regret it personally, because these submissions looked so inconspicuous, they are neither the highest CV nor the highest LB. I would never think of choosing them even with 10 extra days.</p> <h3>[Final submissions]</h3> <p>Ensemble 1 (trust lb) : Our best public LB 0.9723 (private 9268)<br> Ensemble 2 (trust model number) : Simple Average Rank on 18 submissions between LB 0.9680 and 0.9700 (private 9397)<br> Ensemble 3 (trust cv) : Simple Average Rank of 12 best models gives CV 0.9517 (private 9451)</p> <h3>[Single models]</h3> <p>In the image section, we made improvements based on <a href="https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords" target="_blank">chris's notebook</a>.<br> We tried training with B0-7 on image sizes of 256, 384, 512, 600, 768. </p> <p>ResNet gives smaller gap but we didn’t use due to their low public scores.</p> <p>Our best single model CV : 0.942-943, best LB : 9578</p> <p>In the metadata section, we tried ridge, xgb, and lgb. But nothing was better than a weighted blend with <a href="https://www.kaggle.com/titericz/simple-baseline" target="_blank">Giba's baseline</a></p> <h3>[What worked]</h3> <p>BCE + Focal loss (FL) => details in the end<br> Using Effnet on their best resolutions. Ex. 384 with B4, 512 with B5<br> Using upsample and 2018ext data<br> Gridmask, we found gridmask is better than coarse dropout => details in the end<br> noisy-student, train 18 epochs, early stop, train 15 folds help for some models</p> <h3>[What didn't work]</h3> <p>Add hair augment<br> Save model using lowest loss<br> Change seed<br> Change class weights in FL<br> Extreme upsample, like 25X upsample on 2020 mal</p> <h3>[How we achieved public LB 9723]</h3> <p>9603 : unweighted gmean on 3 single models</p> <p>9643 : 9603 * 0.4+giba's baseline * 0.6</p> <p>9694 : 9643+<a href="https://www.kaggle.com/datafan07/eda-modelling-of-the-external-data-inc-ensemble" target="_blank">9577</a> then <a href="https://www.kaggle.com/khoongweihao/post-processing-technique-c-f-1st-place-jigsaw" target="_blank">post-processing</a></p> <p>9723 : minmax post-processing</p> <p>When I reached 9694, I knew I was overfitted. Because there are few such complicated winning solutions in Kaggle Competitions, but like most people, I cannot restrain myself from seeking a higher LB score. Facts once again prove that simple solutions are better 😑</p> <h3>[BCE+FL]</h3> <pre><code>def Focal_Loss(y_true, y_pred, alpha=0.25, gamma=2, weight=5): y_true = K.flatten(y_true) y_pred = K.flatten(y_pred) BCE = K.binary_crossentropy(y_true, y_pred) BCE_EXP = K.exp(-BCE) alpha = alphay_true+(1-alpha)(1-y_true) focal_loss = K.mean(alpha * K.pow((1-BCE_EXP), gamma) * BCE) return BCE+weightfocal_loss </code></pre> <h3>[Grid Mask]</h3> <pre><code>def add_mask(img, dim): num_grid = 3 gm = GridMask(mode=0, num_grid=num_grid) gm.init_masks(dim,dim) init_masks = tf.cast(gm.masks[0], dtype='float32') init_masks = tf.stack([init_masks]3, axis=2) rotated_masks = transform(init_masks, DIM=init_masks.shape[0]) mask_single = tf.image.random_crop(rotated_masks,[dim,dim,3]) img = img*mask_single return img </code></pre> <p>Thank you !</p>
Santa 2020 - The Candy Cane Contest	14th Place Solution (Looking for teammates)	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2020 - The Candy Cane Contest <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Interesting, thanks for checking. Your team's agent seems very well-rounded. I remember you getting a similar win rate against <a href="https://www.kaggle.com/c/santa-2020/discussion/217537#1190549" target="_blank">mehdi_pedram</a> and <a href="https://www.kaggle.com/c/santa-2020/discussion/218453#1196994" target="_blank">nagiss</a>. When I tested our team's best agent against mehdi_pedram, we had a 10% win rate 🤕</p> <p>We'd like to thank the Kaggle team for hosting the Santa 2020 competition during a tough year. In this competition, I had the pleasure of teaming up with <a href="https://www.kaggle.com/lihuajing" target="_blank">Alex</a>, <a href="https://www.kaggle.com/nischaydnk" target="_blank">Nischay Dhankhar</a>, <a href="https://www.kaggle.com/chaudharypriyanshu" target="_blank">Priyanshu Chaudhary</a>, and <a href="https://www.kaggle.com/soosten" target="_blank">Per von Soosten (PS)</a>. This is a summary of our team's solution which placed 14th on the leaderboard. Our <a href="https://github.com/soosten/candy-canes/blob/main/agent.py" target="_blank">best agent</a> is relatively simple, with only about 100 lines of code (<a href="https://github.com/soosten/candy-canes" target="_blank">github repo</a>).</p> <p>TL;DR: We relied on a Bayesian Bandit approach with a few heuristics.</p> <h3>Local Simulations</h3> <p>We used a pool of opponents to evaluate our agents. Running a large number of matches against these opponents gave us a rough idea of agent performance, but improvements in local win rate did not always translate well to the leaderboard. Our pool of opponents included some of our own agents and a few agents from public notebooks:</p> <ul> <li>opponent_agent.py and submission.py from <a href="https://www.kaggle.com/a763337092/pull-vegas-slot-machines-add-weaken-rate-continue5" target="_blank">pull_vegas_slot_machines add weaken rate continue5</a></li> <li>thompson.py from <a href="https://www.kaggle.com/xhlulu/santa-2020-thompson-sampling" target="_blank">Santa 2020: Thompson Sampling</a></li> <li>bayesian_ucb.py from <a href="https://www.kaggle.com/xhlulu/santa-2020-ucb-and-bayesian-ucb-starter" target="_blank">Santa 2020: UCB and Bayesian UCB Starter</a></li> <li>submission.py from <a href="https://www.kaggle.com/ilialar/simple-multi-armed-bandit" target="_blank">Simple multi-armed bandit</a></li> </ul> <p>Thank you to <a href="https://www.kaggle.com/a763337092" target="_blank">Lindada焱焱焱</a>, <a href="https://www.kaggle.com/xhlulu" target="_blank">xhlulu</a> and <a href="https://www.kaggle.com/ilialar" target="_blank">Ilia Larchenko</a> for making these notebooks public. </p> <h3>Bayesian approach</h3> <p>The basic logic of our final submission is to maintain a set of distributions reflecting what we know about the current reward probability of each arm. At the outset, these distributions are initialized to a uniform prior. Every time we get a result from our previous pull, we perform a Bayesian update on the corresponding distribution reflecting the result of our previous pull. This is a classical idea for dealing with multi-armed bandits.</p> <h3>Choosing the next arm</h3> <p>We decide on which new arm to pull based on a simplified variant of the Bayesian UCB algorithm. We get an optimistic estimate of the reward probability of each arm by adding the mean and the standard deviation of the corresponding distribution and then choose an arm with a maximal estimate. An important part of the game is to understand when the opponent has discovered an arm with a high reward probability before the opponent has exploited that arm enough to dramatically decrease the probability. We tried to incorporate this information by applying some temporary Bayesian updates to the distribution before computing the mean and standard deviation comprising the estimate. More concretely:</p> <ul> <li>If the opponent pulled an arm more than twice in the last 10 turns, we assumed all of those pulls resulted in a reward.</li> <li>If the opponent pulled an arm exactly once in the last 100 turn, we assumed that pull did not result in a reward.</li> </ul> <p>Our local simulations indicated that the optimal strategy never pulls on an arm with a reward probability less than 0.22. Therefore, we stopped applying temporary updates to arms for which the true estimate (without any temporary updates) was less than 0.25. This ensured that we did not follow the opponent to arms which we already knew were bad.</p> <h3>Decaying thresholds</h3> <p>In principle, the distributions should also reflect the decay in the reward probability after each arm is pulled. However, we noticed that our agents that did not use the opponent's actions to decay their estimates performed surprisingly well. One explanation for this is that not decaying encourages the agent to exploit good machines that the opponent has found, this is especially important early in the game. On the other hand, having correct estimates of the thresholds is important near the end of the game. We attempted to get the best of both worlds by averaging these two estimates (with/without opponent decay) with a weight that favors non-decayed estimates early in the game and decayed estimates later in the game.</p> <h3>Learning from opponent actions</h3> <p>Finally, some opponent actions are so indicative of the result their pulls that we conservatively applied some permanent Bayesian updates to the distribution based on them. We hardcoded the logic needed to learn from these opponent actions. This can work well against agents who are greedy with respect to their threshold estimates, but these hardcoded rules are easy to counter by being deceptive. Here are the rules that we used</p> <ul> <li>If the opponent repeats a first-time action, assume the first time is a success.</li> <li>If the opponent doesn't pull a lever for a long time after pulling it for the first time, it is probably because the first time was a failure.</li> </ul>
Santa 2020 - The Candy Cane Contest	409th Place Solution - Copy Opponent Move Unless Win	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2020 - The Candy Cane Contest <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thank you!</p> <p>I didn't really have time to properly explore this competition to the same depth I explored Rock Paper Scissors, so in this competition, I cheated!</p> <p>My highest scoring original agent was: </p> <p><strong>Rock Paper Candy - Copy Opponent Move Unless Win (744.8)</strong></p> <ul> <li><a href="https://www.kaggle.com/jamesmcguigan/rock-paper-candy-copy-opponent-move-unless-win" target="_blank">https://www.kaggle.com/jamesmcguigan/rock-paper-candy-copy-opponent-move-unless-win</a></li> </ul> <p>Does exactly what it says on the tin. Rather than implement my own logic for finding the best handle to pull, I implemented the Little Sister strategy. Little Sister doesn't know how to play the game, she simply runs after her Big Brother and plays whatever move he played last. Unless of course she wins, in which case she keeps pulling the same handle until she loses and then runs after Big Brother again.</p> <p>I tried a few variations to modify the logic of when to repeat and when to copy, but the original and simplest logic worked best. The result of this strategy was 1.3% below the exact midpoint of the leaderboard!</p> <p>This approach outperformed all my failed attempts to implement UCB and Multi-Armed-Bandit correctly.</p> <p>My other approach was to compile a big list of public notebooks, play them against each other, and repeatedly submit the best ones to the competition as my own work, which really feels like cheating now that I have done it!</p> <ul> <li><a href="https://www.kaggle.com/jamesmcguigan/santa-2020-agents-comparison" target="_blank">https://www.kaggle.com/jamesmcguigan/santa-2020-agents-comparison</a></li> </ul> <p>Shoutouts to:</p> <p><a href="https://www.kaggle.com/felipefonte99" target="_blank">@felipefonte99</a> </p> <ul> <li>Your ensemble model scored 859.7 - 793.0 over 14 submissions, earning me 335th place!</li> <li><a href="https://www.kaggle.com/felipefonte99/ensemble-pull-vegas-decision-tree-model" target="_blank">https://www.kaggle.com/felipefonte99/ensemble-pull-vegas-decision-tree-model</a></li> </ul> <p><a href="https://www.kaggle.com/iehnrtnc" target="_blank">@iehnrtnc</a></p> <ul> <li>Your agent3.py notebook scored 823.6 - 781.4 over 6 submissions.</li> <li><a href="https://www.kaggle.com/iehnrtnc/santa2020" target="_blank">https://www.kaggle.com/iehnrtnc/santa2020</a></li> </ul> <p><a href="https://www.kaggle.com/sirishks" target="_blank">@sirishks</a></p> <ul> <li>Your advice to "Keep pulling the same bandit as long as reward keeps coming!" helped inspire the Copy Opponent Move Unless Win strategy</li> <li>Your notebook scored 761.0 with a single submission yet still outperformed my own notebook idea<br> = <a href="https://www.kaggle.com/sirishks/pull-vegas-slot-machines" target="_blank">https://www.kaggle.com/sirishks/pull-vegas-slot-machines</a></li> </ul>
Santa 2020 - The Candy Cane Contest	67th place solution - and good result in my own competition and challenge	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2020 - The Candy Cane Contest <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks, i'll try! ;)</p> <p>Congrats to the top solutions and a great competition.<br> One learns new thing in every competition, a perfect way to follow the journey of AI world and also to contribute to important problems. Thanks Kaggle and fellow kagglers contributing with valuable insights, ideas, and notebooks.</p> <p>For my 67th place solution, yes not in the top but shows that even with a basic approach can reach to a good medal place, I used 80M steps from agents with score 900 and above to train a LGBM regressor with custom parameters used together with the public Greedy algorithm, I tried many different approaches, but this one seemed to do it best when updated it with latest games played final days. I also submitted 2-3 extra of the best model to reduce the risk of land in an outlier situation after deadline.</p> <p>I have also made a personal competition and challenge this time, to contribute in 5 different Kaggle competition in parallel, trying to get good results in every one of them, equal distribution of time. Just for fun and the learning. <br> 1st and 2nd out finished prev. week. where I got a bronze medal and silver, and now bronze in this and a silver in the 4th which finalized at the same time yesterday, much better than I expected but grateful, and glad to see that lots of reading and testing pay off.<br> I had my first Kaggle competition only 1,5 year ago, so I glad that I managed my own personal challenge quite well after all. <br> All together I think this can move me to a total top 50 Kaggle rank, and still as Kaggle Expert, must reach that gold some year 😊 but that is even harder of course and humble to that challenge but everything is possible.</p> <p>Happy Kaggleing!</p>
Santa 2020 - The Candy Cane Contest	9th place solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2020 - The Candy Cane Contest <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thank you for hosting this exciting competition ! I'm happy to become a Competition Grandmaster.</p> <h1>Code</h1> <p>Source code is available here.<br> <a href="https://github.com/toshi-k/kaggle-santa-2020" target="_blank">https://github.com/toshi-k/kaggle-santa-2020</a></p> <h1>Basic Strategy</h1> <p>In this competition, the reward was decided by comparing the threshold and random generated number. It was easy to calculate the probability of getting reward if we knew the thresholds. But the agents can't see the threshold during the game, we had to estimate it.</p> <p>Like other teams, I also downloaded the history by Kaggle API and created a dataset for supervised learning. We can see the true value of <code>threshold</code> at each round in the response of API. So, I used it as the target variable.</p> <p>In the middle of the competition, I found out that quantile regression is much better than conventional L2 regression. I think it can adjust the balance between <strong>Explore</strong> and <strong>Exploit</strong> by the percentile parameter.</p> <h1>Features</h1> <p>I made 32 features for training and prediction. I tried some other features, but they didn't work well. Adding unnecessary features sometimes caused time out error, I didn't employ them.</p> <table> <thead> <tr> <th>        #        </th> <th>Name</th> <th>Explanation</th> </tr> </thead> <tbody> <tr> <td>#1</td> <td>round</td> <td>number of round in the game (0-1999)</td> </tr> <tr> <td>#2</td> <td>last_opponent_chosen</td> <td>whether the opponent agent chose this machine in the last step or not</td> </tr> <tr> <td>#3</td> <td>second_last_opponent_chosen</td> <td>whether the opponent agent chose this machine in the second last step or not</td> </tr> <tr> <td>#4</td> <td>third_last_opponent_chosen</td> <td>whether the opponent agent chose this machine in the third last step or not</td> </tr> <tr> <td>#5</td> <td>opponent_repeat_twice</td> <td>whether the opponent agent continued to choose this machine in the last two rounds (#2 x #3)</td> </tr> <tr> <td>#6</td> <td>opponent_repeat_three_times</td> <td>whether the opponent agent continued to choose this machine in the last three rounds (#2 x #3 x #4)</td> </tr> <tr> <td>#7</td> <td>num_chosen</td> <td>how many times the opponent and my agent chose this machine</td> </tr> <tr> <td>#8</td> <td>num_chosen_mine</td> <td>how many times my agent chose this machine</td> </tr> <tr> <td>#9</td> <td>num_chosen_opponent</td> <td>how many time the opponent agent chose this machine (#7 - #8)</td> </tr> <tr> <td>#10</td> <td>num_get_reward</td> <td>how many time my agent got rewards from this machine</td> </tr> <tr> <td>#11</td> <td>num_non_reward</td> <td>how many time my agent didn't get rewarded from this machine</td> </tr> <tr> <td>#12</td> <td>rate_mine</td> <td>ratio of my choices against the total number of choices (#8 / #7)</td> </tr> <tr> <td>#13</td> <td>rate_opponent</td> <td>ratio of opponent choices against the total number of choices (#9 / #7)</td> </tr> <tr> <td>#14</td> <td>rate_get_reward</td> <td>ratio of my rewarded choices against the total number of choices (#10 / #7)</td> </tr> <tr> <td>#15</td> <td>empirical_win_rate</td> <td>posterior expectation of threshold value based on my choices and rewords</td> </tr> <tr> <td>#16</td> <td>quantile_10</td> <td>10% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#17</td> <td>quantile_20</td> <td>20% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#18</td> <td>quantile_30</td> <td>30% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#19</td> <td>quantile_40</td> <td>40% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#20</td> <td>quantile_50</td> <td>50% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#21</td> <td>quantile_60</td> <td>60% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#22</td> <td>quantile_70</td> <td>70% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#23</td> <td>quantile_80</td> <td>80% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#24</td> <td>quantile_90</td> <td>90% point of posterior distribution of threshold based on my choices and rewords</td> </tr> <tr> <td>#25</td> <td>repeat_head</td> <td>how many times my agent chose this machine before the opponent agent chose this agent for the first time</td> </tr> <tr> <td>#26</td> <td>repeat_tail</td> <td>how many times my agent chose this machine after the opponent agent chose this agent last time</td> </tr> <tr> <td>#27</td> <td>repeat_get_reward_head</td> <td>how many times my agent got reward from this machine before my agent didn't get rewarded or the opponent agent chose this agent for the first time</td> </tr> <tr> <td>#28</td> <td>repeat_get_reward_tail</td> <td>how many times my agent got reward from this machine after my agent didn't get rewarded or the opponent agent chose this agent last time</td> </tr> <tr> <td>#29</td> <td>repeat_non_reward_head</td> <td>how many times my agent didn't get rewarded from this machine before my agent got reward or the opponent agent chose this agent for the first time</td> </tr> <tr> <td>#30</td> <td>repeat_non_reward_tail</td> <td>how many times my agent didn't get rewarded from this machine after my agent got reward or the opponent agent chose this agent last time</td> </tr> <tr> <td>#31</td> <td>opponent_repeat_head</td> <td>how many times the opponent agent chose this machine before my agent chose this machine for the first time</td> </tr> <tr> <td>#32</td> <td>opponent_repeat_tail</td> <td>how many times the opponent agent chose this machine after my agent chose this machine last time</td> </tr> </tbody> </table> <p>The feature importance of my best agent is as below.</p> <p><img src="https://raw.githubusercontent.com/toshi-k/kaggle-santa-2020/master/src/02_lgbm/importance.png" alt="importance"></p> <p>It may be interesting the most important feature was the <em>round</em> in the game. I think the agent can change the strategy based on the round, and it was something essential the agent learned from the history.</p> <p>Some other features related to the opponent agent were also important (<em>num_chosen_opponent</em>, <em>rate_opponent</em>) . ML based agent can utilize the behavior of the opponent agent which can't be handled by conventional approaches.</p> <h1>Top Agents</h1> <p>I tried several packages and parameters. It seemed that LightGBM was the best for my settings.</p> <p>Although some of CatBoost agents achieved similar performance like LightGBM, CatBoost didn't reach the best score of LightGBM. Since all features were numeric variable, it could not utilize the unique feature for categorical variables.</p> <p>I also tried XGBoost with pairwise loss. It compared the thresholds of machines in the same round. Although I thought it was a natural training setting, the performance of the agents were worse than quantile regression.</p> <p>NumRound=4000 was almost the maximum number to prevent the time out error. I set NumRound=3000 or NumRound=3500 for some agents as safer settings. I basically tuned learning rate to control the fitness to the dataset.</p> <table> <thead> <tr> <th>Regressor</th> <th>Loss</th> <th>NumRound</th> <th>LearningRate</th> <th>LB Score</th> <th>SubmissionID</th> </tr> </thead> <tbody> <tr> <td>LightBGM</td> <td>Quantile (0.65)</td> <td>4000</td> <td>0.05</td> <td>1449.4</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19318812" target="_blank">19318812</a></td> </tr> <tr> <td>LightBGM</td> <td>Quantile (0.65)</td> <td>4000</td> <td>0.10</td> <td>1442.1</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19182047" target="_blank">19182047</a></td> </tr> <tr> <td>LightBGM</td> <td>Quantile (0.65)</td> <td>3000</td> <td>0.03</td> <td>1438.8</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19042049" target="_blank">19042049</a></td> </tr> <tr> <td>LightBGM</td> <td>Quantile (0.66)</td> <td>3500</td> <td>0.04</td> <td>1433.9</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19137024" target="_blank">19137024</a></td> </tr> <tr> <td>CatBoost</td> <td>Quantile (0.65)</td> <td>4000</td> <td>0.05</td> <td>1417.6</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19153745" target="_blank">19153745</a></td> </tr> <tr> <td>CatBoost</td> <td>Quantile (0.67)</td> <td>3000</td> <td>0.10</td> <td>1344.5</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19170829" target="_blank">19170829</a></td> </tr> <tr> <td>LightGBM</td> <td>MSE</td> <td>4000</td> <td>0.03</td> <td>1313.3</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19093039" target="_blank">19093039</a></td> </tr> <tr> <td>XGBoost</td> <td>Pairwised</td> <td>1500</td> <td>0.10</td> <td>1173.5</td> <td><a href="https://www.kaggle.com/c/santa-2020/submissions?dialog=episodes-submission-19269952" target="_blank">19269952</a></td> </tr> </tbody> </table> <h1>Tips</h1> <h2>Logarithm transformation for probabilistic calculation</h2> <p>The chain of multiplication turns into zero because of the precision of floating point. For the calculation of posterior distribution of threshold, logarithm transformation and renormalization solved this problem.</p> <h2>LRU Cache</h2> <p>Precise calculation of posterior distribution is time consuming and it can be the cause of time our error. I employed LRU (Least Recently Used) Cache and reused the feature values for the same patterns of the actions and rewards.</p> <h1>What I should have done (to beat more agents)</h1> <p>When I calculated the winning rate of the agent for features #15-24, I set the probability approximately like <code>p = threshold decay / 101</code>. But I missed one important point here. The random generated in each round was integer, I should have rounded this part like <code>p = round(threshold decay) / 101</code>.</p>
Santa 2021 - The Merry Movie Montage	2428 by the numbers - no VRP, no TSP, no MIP	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks and congrats to you also. I'll be reading through your MILP Journey series with great interest!</p> <p>Thanks to everyone for a fun competition, and congratulations to all who stuck with it. Extra congrats to those who got to 2428 a month before anyone else.</p> <p>Along the way to 2428 I discovered that one solution method was fairly simple - not to be confused with "easy". It was only after using LKH3 to get to 2440 and spending a <em>whole lot of time</em> thinking about wildcards that I saw the underlying structure. I suspect the top finishers and perhaps others got to a similar place and went straight there without the VRP model. </p> <p>The picture below from superpermutations.com shows the start of the palindromic, aka classic version, of the superperm for n=7. A great paper by <a href="https://www.kaggle.com/vincevatter" target="_blank">@vincevatter</a> described the structure of these first 42 permutations as a "trajectory". A trajectory has 6 cycles of 7 permutations each. Guess how many trajectories there are? 5! (meaning 120 which makes sense that for n=7 there are 7! permutations). And a nice property of the trajectories is that the last permutation always begins with 76. So I chose that sequence as my Mr & Mrs Santa.</p> <p>Once I saw this feature, I noticed my superperms from LKH followed the same pattern. You can take the last 76xxxxxx perm in the trajectory and move it to the front of the line, and then trace the classic route to the end. Except you don't need to worry about the last cycle. All of those permutations can be made by combinations of 76xxxxxx perms. Assuming you break the trajectories into 3 groups of 40, you then have to add in the complementary set of 80 mandatory 76ers to each group. So the game then becomes how to sequence the 76ers and the longer trajectory substrings to cover all of the orphaned permutations. </p> <p>The math works out quite nicely. Each reworked trajectory for this puzzle is 47 characters long (36 perms + 5 wasted characters + 6 characters at the start). There are 40 of these per route for a subtotal of 1880. Added in are the 560 characters from the rest of the required perms (80*7). And that's the 2440.</p> <p>Others can tell the wildcard story better than me. If you look at the end of the trajectory you see the two highlighted permutations that form a repeating sequence of 7 characters.</p> <p><img src="https://i.imgur.com/4rWiweM.png" alt="superperms"></p>
Santa 2021 - The Merry Movie Montage	2430 Solution - Using My 2500 Public Notebook	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks Kaggle for an exciting and fun 2021 Santa optimization challenge.</p> <h1>My LKH Public Notebook - LB 2500</h1> <p>In this competition, i ran my LKH public notebook <a href="https://www.kaggle.com/cdeotte/santa-2021-tsp-baseline-2500" target="_blank">here</a> over and over. Each time I started with my best solution, randomly swapped 1-cycles (groups of 7 permutations) between strings, removed repeated non-mandatory permutations among strings, and randomly added wildcards (to mandatory permutations). After thousands of runs, LKH finally found a 2431 solution! My procedure wasn't improving the score anymore, so i loaded 2431 into LKH MinMax CTSP <a href="https://www.kaggle.com/kostyaatarik/colored-traveling-salesman-problem" target="_blank">here</a>, added support for wildcards, and found 2430! </p> <h1>Step 1 - Begin with 5913 Standard Permutation</h1> <p>I begin with the standard permutations. When you break it into 3 equal sized substrings, you keep all the 1,2,3,4-cycles together. The splits occur at 5,6-cycles. (So only distances of 5 and 6 are broken apart). <strong>Then run LKH.</strong><br> <img src="https://raw.githubusercontent.com/cdeotte/Kaggle_Images/main/Jan-2022/santa1b.png" alt=""></p> <h1>Step 2 - Randomly Swap Cycles and Run LKH</h1> <p>Starting with my best solution (from previous LKH runs), I would find 1-cycles (groups of 7 permutations) that were followed by a distance of 4 or more. Among all these, I would swap nine to fifteen 1-cycles between adjacent strings. <strong>Then run LKH.</strong><br> <img src="https://raw.githubusercontent.com/cdeotte/Kaggle_Images/main/Jan-2022/santa2b.png" alt=""></p> <h1>Step 3 - Permutation Balancing</h1> <p>Early on, i observed that some non-mandatory permutations were contained in multiple strings. So i would take my best solution, remove non-mandatory permutations from strings that were present in other strings. <strong>Then run LKH.</strong></p> <h1>Step 4 - Randomly Add Wildcards and Run LKH</h1> <p>Starting with my best solution, I would find mandatory permutations that did <strong>not</strong> have their other 6 rotations (1-cycle) included in the string. Among these, I would pick two and add a wildcard replacing their first number 1. Then update the distance matrix. <strong>Then run LKH.</strong><br> <img src="https://raw.githubusercontent.com/cdeotte/Kaggle_Images/main/Jan-2022/santa3b.png" alt=""></p> <h1>Step 5 - LKH CTSP with Wildcards boost 2431 to 2430</h1> <p>My procedure worked well but it stopped improving the score around 2431. I obtained 2430 by loading my 2431 solution into <strong>LKH MinMax CTSP</strong> <a href="https://www.kaggle.com/kostyaatarik/colored-traveling-salesman-problem" target="_blank">here</a> and added Wildcard support and ran it overnight!</p> <p>😄Thanks. Congratulations on Silver medal. I was watching the last day and happy to see you didn't get bumped in Bronze. Good job!</p> <p>Great question <a href="https://www.kaggle.com/crained" target="_blank">@crained</a> . This competition was all new to me. I have never worked on TSP nor LKH before. When I approach a new problem, I start by looking at examples and playing with code.</p>
Santa 2021 - The Merry Movie Montage	3rd place solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>First of all, I would like to thank the organizer for another year of interesting problems, and all the other participants for making the competition very fun. I would like to thank my teammates <a href="https://www.kaggle.com/nagiss" target="_blank">@nagiss</a>, <a href="https://www.kaggle.com/kibuna" target="_blank">@kibuna</a> and <a href="https://www.kaggle.com/hiroakikitahara" target="_blank">@hiroakikitahara</a> for the great collaboration. </p> <p>In this post, rather than explaining the solution of 2428 directly, I would like to explain what we thought step by step. It may be a bit long, but I hope it will be helpful.</p> <h2>First step</h2> <p>Since dealing with 🌟 is complicated and we can only use at most two 🌟, we first worked on the solution without 🌟. If we fix which of the three strings each permutation appears in, we can solve the problem as an Asymmetric Travelling Salesperson Problem (ATSP). Since there are all 7! permutations and 2 * 5! additional mandatory permutations, if the permutations could be equally distributed among the three strings, the number of vertices per string would be approximately (7! + 5! * 2) / 3 = 1760. This 1760-vertex ATSP can be optimally solved in a realistic time using LKH and Concorde. Thus, we only need to think about how to assign the permutations to the three strings.</p> <p>This means that it was true for this problem, not that it is true in general. For example, the superpermutation for n = 6 is a ATSP with 720 vertices, but it is considered difficult to find the optimal solution by Concorde in a straightforward way (<a href="https://arxiv.org/abs/1408.5108" target="_blank">Houston 2014</a>)</p> <h2>Assignment based on 2-cycle (Score: 2480)</h2> <p>First, we considered assigning the 5040 permutations in such a way that they contain the same number of mandatory permutations. Considering how other permutations should look like, it seems that permutations that can be moved at cost 1 (e.g. <code>7123456</code> -> <code>1234567</code>) should be in the same string as much as possible. Also, we want a group consisting of permutations that can be moved at cost 1 (e.g. <code>2345671</code> -> <code>3456712</code> -> … -> <code>1234567</code>), and a group that can be moved from the group at cost 2 (e.g. <code>3456721</code> -> <code>4567213</code> -> … -> <code>1345672</code>. The cost from <code>1234567</code> to <code>3456721</code> is 2), to be in the same string. Repeating such a cost 2 group-to-group move n (= 7) times brings it back to the original group and forms a cycle. This cycle is called a <a href="http://www.gregegan.net/SCIENCE/Superpermutations/Superpermutations.html#:~:text=method%3A%20Supermutate.js-,2%2Dcycle%20graphs,-A%20third%20way" target="_blank">2-cycle</a> in the context of the superpemutation (See the link for a more precise definition). We tried to use this 2-cycle to do the assignment.</p> <p>There are 120 2-cycles, so 40 of them are assigned to each of the three strings. Each 2-cycle contains exactly one mandatory permutation, so at this point, every string will contain 40 mandatory permutations. By adding the 80 mandatory permutations that have not yet been added, we can satisfy the constraint in question.</p> <p>The pseudo-Python code looks like this. After several iterations of solving the problem as an ATSP using LKH or Concorde with random 2-cycle assignment, a score of 2480 was achieved. We tried various methods of 2-cycle assignment, but could not find a solution with a score lower than 2480 without 2-cycle splitting described in the the following section.</p> <pre><code>twocycle_nodes = [] for v in ["12" + "".join(s) for s in itertools.permutations("34567")]: nodes = [] for y in range(6): nodes.append(v) v = v[2:] + v[1] + v[0] for x in range(6): nodes.append(v) v = v[1:] + v[0] assert v == twocycle twocycle_nodes.append(nodes) assignment = np.arange(120) % 3 np.random.shuffle(assignment) groups = [[], [], []] for idx_groups, nodes in zip(assignment, twocycle_nodes): # TODO groups[idx_groups].extend(nodes) mandatory = nodes[0] assert mandatory.startswith("12") groups[(idx_groups + 1) % 3].append(mandatory) groups[(idx_groups + 2) % 3].append(mandatory) solution = (solve_as_tsp(groups[0]), solve_as_tsp(groups[1]), solve_as_tsp(groups[2])) </code></pre> <h2>Splitting 2-cycle (Score: 2440 w/o 🌟, 2430 w/ 🌟)</h2> <p>When we checked the solution for 2480, we found that many edges of length 7 are used to make the mandatory permutations appear that are not in the 40 2-cycles assigned to that string. For example, all permutations of the 2-cycle including <code>1234567</code> were assigned to only one string, so the two strings that were not assigned the 2-cycle were likely to use the edge with cost 7 to move <code>1234567</code>. To alleviate this problem, we thought of giving some of the permutations in the 2-cycle to the other strings. To alleviate this problem, we considered giving some of the permutations in the 2-cycle to the other strings. Specifically, we gave the permutations that can move to <code>12xxxxx</code> by using only the cost 1 edge to other strings. The splitting part of the pseudo code looks like this.</p> <pre><code>groups = [[], [], []] for idx_groups, nodes in zip(assignment, twocycle_nodes): mandatory = nodes[0] # e.g. "1234567" neighbors = nodes[-6:] # e.g. ['2345671', '3456712', '4567123', '5671234', '6712345', '7123456'] nodes = nodes[1:-6] groups[idx_groups].extend([mandatory] + nodes) groups[(idx_groups + 1) % 3].extend([mandatory] + neighbors[:3]) groups[(idx_groups + 2) % 3].extend([mandatory] + neighbors[3:]) </code></pre> <p>We tried several assignments in this way and got 2440 solution without 🌟. Furthermore, by adding the following two ideas, we reached 2430 with 🌟.</p> <ul> <li>For 2-cycle assignment, stop assigning randomly and create n = 7 2-cycles starting from n = 5 2-cycles and assign them in order.</li> <li>Assuming that one 🌟 only shrinks one edge, randomly choose two mandatory permutations and replace the first 1 with 8 (🌟)</li> </ul> <h2>Non-TSP Solution by eijirou-san (Score: 2440 w/o 🌟, 2435 w/ 🌟)</h2> <p>Here, I would like to share the solution by <a href="https://www.kaggle.com/eijirou-san" target="_blank">@eijirou-san</a>, who kept the first place on the Leaderboard in early stage of the competition. In this solution, the procedure of splitting 2-cycles is deeply considered, and the 2435 solution can be built without TSP solvers.</p> <p>Consider a block constructed by deleting the permutations after the last 2-edge of a 2-cycle and connecting it with a 3-edge to a group brought from another 2-cycle (See the figure below). The total cost of this block is 56, but since it ends in <code>12</code>, it can be considered 54 due to the two-letter overlap with the next group. Furthermore, since one block contains two mandatory permutations, we can construct a solution with a score of 54 x 40 + 7 x 40 = 2440 solutions by adding the remaining 40 mandatory permutations at a cost 7.</p> <p><img src="https://user-images.githubusercontent.com/8179588/149190973-a0ad6925-e501-45bf-8e18-4a0ce6d93e66.png" alt="image"></p> <p>We can construct the 2435 solution by inserting two 12xxxxx while utilizing two 🌟 (e.g. splitting 1672345 -> 7234561 into 1682345 -> 8234576 and 1278345 -> 7834561). However, we could not find a better solution than 2435 by this splitting method and 🌟.</p> <h2>The 2428 solution</h2> <p>We verified the lower bound in a similar way to the <a target="_blank">one using TSP posted in Discussion</a>, and confirmed that this 2440 solution is optimal without 🌟, so we moved on to consider the construction of a solution using 🌟.</p> <ul> <li>As the 2440 w/o 🌟 method, Divide the 2-cycle into four blocks: S (1 mandatory permutation required), A (35 permutations), B (4 permutations), and C (2 permutations).<br> <img src="https://user-images.githubusercontent.com/8179588/149297004-3e0e2971-637d-4c5e-93df-3e452d1bff33.png" alt="image"></li> <li>In this case, one string should contain all 120 types of S and 40 of each of A, B, and C to achieve an even distribution.</li> <li>Due to the position of the "1" and "2", the minimum cost of the transition between each block is as follows (all transitions are required to be the minimum cost to achieve 2428)<ul> <li>S -> S … 7 (Can move to a different 2-cycle)</li> <li>S -> A … 2 (Moves only within the same 2-cycle)</li> <li>S -> B … 1 (Moves only within the same 2-cycle)</li> <li>S -> C … 5 (Can move to a different 2-cycle)</li> <li>A -> S … 7 (Can move to a different 2-cycle)</li> <li>A -> A … 3 (Moves only within the same 2-cycle. Moving to the same block in the same 2-cycle does not make any sense.)</li> <li>A -> B … 2 (Moves only within the same 2-cycle)</li> <li>A -> C … 5 (Can move to a different 2-cycle)</li> <li>B -> S … 3 (Can move to a different 2-cycle)</li> <li>B -> A … 5 (More efficient to go through S)</li> <li>B -> B … 4 (More efficient to go through S)</li> <li>B -> C … 1 (Moves only within the same 2-cycle)</li> <li>C -> S … 1 (Moves only within the same 2-cycle)</li> <li>C -> A … (More efficient to go through S)</li> <li>C -> B … (More efficient to go through S)</li> <li>C -> C … (More efficient to go through S)</li></ul></li> <li>The transition cost in the block is 38 for A, 3 for B, and 1 for C, for a total of 42</li> <li>We tried to make a unit of permutations (containing three S's and one A, B, and C, which can transition to another unit with minimum cost) using these. For example, if we make a unit such that A -> S -> C -> S -> B -> S -> (next A), the cost is 42 + 7 + 5 + 1 + 1 + 3 + 2 = 61, and if we connect 40 units of these, we get 61 x 40 = 2440. The structure of our 2440/2430 solution looked like this.</li> <li>Analyzing the 2430 solutions using 🌟 in a way that replaces two Ss with 82xxxxx, we find that while the cost of one A -> S is reduced from 7 to 1, the result is an improvement of -5 per 🌟, since we can no longer enter A at cost 2 elsewhere.</li> <li>The key to improving this and getting to -6 per 🌟 was to use 🌟 as more than two letters. We use 🌟 at the end of the A Block to reduce the cost of A -> S from 7 to 1 as shown in the figure below. A single 🌟 is used as three characters: 7, 6, and 1.<br> <img src="https://user-images.githubusercontent.com/8179588/149606773-bd730ca0-8356-461a-bae2-aca888fe8b54.png" alt="image"></li> <li>In this usage, the last permutation of the A Block using 🌟 belongs to the 2-cycle of the transition destination S, so the last permutation of the original A Block has to be used somewhere. We note that if the A Block with 🌟 is from 1\|2xyz<strong>ab</strong> (in the notation in <a href="http://www.gregegan.net/SCIENCE/Superpermutations/Superpermutations.html#TCG" target="_blank">the Greg Egan's page</a>), then S is from 1\|2xyz<strong>ba</strong>, and the two-cycles are related by a swap of the last two letters. Therefore, if we use 🌟 in the same way for the A Block of 1\|2xyz<strong>ba</strong>, the last permutation will be swapped among the A Blocks using 🌟, and there will be no remaining permutations. We want A -> S to be a transition between different 2-cycles, so when we use 🌟 for this pairing, we make sure that each is assigned to a different string. In summary, the procedure is as follows.<ul> <li>Assign A Block of 1\|2xyzab and 1\|2xyzba to different strings</li> <li>Swap the last permutation of the A Blocks between the two strings</li> <li>Use 🌟 in the form 2xyza182xyzba and 2xyzb182xyzab respectively</li></ul></li> <li>Using this, we can achieve -6 improvement per single 🌟, and reach the 2428 solution.</li> </ul> <p>Honestly, we haven't prove the optimality of 2428. I tried to use Concorde for some relaxation problems, but I could not come up with the formulation of unconstrained use of 🌟.</p> <p><a href="https://www.kaggle.com/atamazian" target="_blank">@atamazian</a> Thanks!</p> <p><a href="https://www.kaggle.com/niekvanderzwaag" target="_blank">@niekvanderzwaag</a> Thanks!</p> <p><a href="https://www.kaggle.com/aayushpoddar" target="_blank">@aayushpoddar</a> Thanks!</p> <p><a href="https://www.kaggle.com/atmguille" target="_blank">@atmguille</a> Thanks! Sorry for the delay, but I've added it. It's a bit long, but I hope you'll read it.</p> <p><a href="https://www.kaggle.com/solverworld" target="_blank">@solverworld</a> I'm sorry I left out the important part. I've added it now!</p> <p><a href="https://www.kaggle.com/zyu2017" target="_blank">@zyu2017</a> Thank you for explaining 😄. I think our solution is almost the same as yours.</p> <p><a href="https://www.kaggle.com/robertking0" target="_blank">@robertking0</a> Thanks! I hope the solution to 2428 will be interesting for you too.</p> <p>I'm sorry for the delay 🙏, but I've also added the 2428 solution.</p>
Santa 2021 - The Merry Movie Montage	4th place solution by hand	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I have finished editing the code. <br> The final version is <a href="https://www.kaggle.com/cashfeg/4th-place-solution-code" target="_blank">here</a>. </p> <p>Thanks for the fun competition. The Santa Competition for new-year holidays is my pleasure and I am pleased that this tradition has continued. </p> <p>My solution is made by hand. I used a computer to simply enumerate. </p> <h2>2440 without wildcard</h2> <p>In this problem, we need to construct 3 strings such that </p> <ul> <li>Every permutation (5040 in total) of [1, 2, 3, 4, 5, 6, 7] is contained in at least 1 string. </li> <li>Every permutation in the form of 12xxxxx (120 in total) is contained in all strings. <br> (1: Mr. Santa, 2: Ms. Santa)</li> </ul> <p>Second condition seems to break the symmetry, but in reality it seems that, as a result of this too big break, there is a room to make a solution by symmetry. </p> <p>The key idea for me is that 120 permutations of 12xxxxx are not waste. <br> For example, <br> <code>1273456 1237456 1234756 1234576 1234567</code> <br> is not only 5 permutations but also it is a part of a 2-cycle <br> <code>7 2345612 7 3456123 7 4561234 7 5612345 7 6123456 7 1234561 (7 2345612)</code></p> <p>By looking for a good string (part of a 2-cycle) that does not overlap with these, I found strings like these:<br> <code>1 2345672 1 3456723 1 4567234 1 5672345 1 6723456 1 7234567 (1 2345672)</code><br> By removing the duplicates with 12xxxxx, we obtain <br> <code>345672 1 3456723 1 4567234 1 5672345 1 6723456 1 723456</code> (length 45) <br> If we fix 1 and 2, there are 5! = 120 sequences like this, so a simple assignment will create 3 strings consists of 40 such sequences and 120 12xxxxx. <br> The length is 45 * 40 + 7 * 120 = 2640, Clearly, we can combine 1234567 and 3456721…, and so on, so the length is now 2440. <br> More precisely, as 12xxxxx can be part of an important sequence, we need to be careful when combining them. But that's not a critical problem because all 3 strings contains all 12xxxxx. </p> <p>This solution by <a href="https://www.kaggle.com/jpmiller" target="_blank">@jpmiller</a> seems similar. <br> <a href="https://www.kaggle.com/c/santa-2021/discussion/300519" target="_blank">https://www.kaggle.com/c/santa-2021/discussion/300519</a></p> <h2>2440-> 2428 with wildcard</h2> <p>If we understand the structure of the 2440 solution, it's just a puzzle. <br> When the leaderboard is updated, it's time to start a new race. Think without sleeping. I did this twice(2430 -> 2429 -> 2428).</p> <h3>2430</h3> <p>We start from 2440 solution, which consists of 40 sequences of the following form: <br> <code>12 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 723456</code> (length 47) <br> and 80 12xxxxx. <br> We should produce 12xxxxx by almighty because it's inefficient, so where to put almighty(denote by 8) should be: <br> <code>12 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823456 7</code> (length 48) <br> We added 1 character and one 1234567 is newly included, so seemingly this reduces length by 6, <br> but no, because we have 1234567 twice. So we add one more character like this: <br> <code>127 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823456 7</code> (length 49) <br> thus we could reduce 5 characters by 1 almighty. </p> <h3>2429</h3> <p>Take 2 similar sequence of length 48 with duplicate, such as 1234567 and 1234576, <br> <code>12 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823456 7</code> (length 48) <br> <code>12 345762 1 3457623 1 4576234 1 5762345 1 7623457 1 823457 6</code> (length 48) <br> and swap the last two characters.<br> <code>12 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823457 6</code> (length 48) <br> <code>12 345762 1 3457623 1 4576234 1 5762345 1 7623457 1 823456 7</code> (length 48) </p> <p>If we joint these two sequences and insert one character, we obtain <br> <code>127 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823457 6</code> (length 49) <br> <code>2 1 3457623 1 4576234 1 5762345 1 7623457 1 823456 7</code> (length 41) <br> This reduces 11 characters by 2 almighty. </p> <h3>2428</h3> <p>We can put these two sequences in different strings. <br> <code>12 345672 1 3456723 1 4567234 1 5672345 1 6723456 1 823457 6</code> (length 48) <br> <code>12 345762 1 3457623 1 4576234 1 5762345 1 7623457 1 823456 7</code> (length 48) </p>
Santa 2021 - The Merry Movie Montage	A MILP Journey, part 2: 2440 solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Following up on <a href="https://www.kaggle.com/c/santa-2021/discussion/300507" target="_blank">https://www.kaggle.com/c/santa-2021/discussion/300507</a> I will now describe how a MILP model was used to find a 2440 solution.</p> <h1>A first model</h1> <p>The first evolution of the model was to explicitly represent the duplicated mandatory permutations. I also removed all the 7-edges and replaced them by 2 binary variables per node.</p> <p>The variables are:</p> <ul> <li>next(p1, p2) is an integer variable whose value is the number of times p1 is immediately followed by p2 in the strings of the solution to the problem.<ul> <li>start(p) if p is preceded by a 7-edge, whatever the 7 edge</li> <li>end(p) if p is followed by a 7 edge, whatever the 7 edge</li></ul></li> </ul> <p>In order to make the problem easier to solve I enforced that nodes in my new graph were visited exactly once. A s result I no longer can remove arcs as I did for the lower bound model, because a path that goes from p1 to p2 will not necessarily visit an extra node p3 if cost(p1, p3) + cost(p3, p1) = cost(p1, 2) when p3 is already visited by another path.</p> <p>Another restriction was to remove 4-arcs, 5-arcs, and 6-arcs as none of them appeared in the lower bound model solution. This restricts drastically the size of the model,</p> <p>The constraints are simple:</p> <ul> <li>flow conservation. The sum over p1 of next(p1, p)) + start(p) = sum over p2 of next(p0, p2) + end(p) for all p0</li> <li>subtour elimination. I reused the same as in the lower bound model. I later tried with the standard subtour elimination constraint, but to my surprise it took longer to solve that version of the MILP.</li> </ul> <p>The objective is the same as before. It is the sum of the costs time the next(p1, p2) variables where the cost of 7 edges to 7 minus epsilon (epsilon = 0.01).</p> <p>Solving this model yields again a solution close to 7320. I then wrote a little cycle extraction, that starts from a non zero next(p1, p2) variable, then looks for which variable next(p2, p3) is no zero, etc, until it comes back. The hope was ot get 3 cycles of equal length, but this did not happen: Many more cycles were found. My subtour elimination constraints were not strong enough.</p> <h1>a Better model</h1> <p>I then added a variant of Miller–Tucker–Zemlin (MTZ) constraints to eliminate all subtours. The difference is that I have implicit arcs via the start and end variables. Another difference is that we look for 3 paths, not one. For this I add one variable u(p) for every node p. It represents the rank of p in the path that contains p. The constraints are:</p> <p>u[i] - u[j] + N3 * nex(i,j) <= N3 - 1 for all i,j</p> <p>u[i] <= (N3 - 1) * (1 - start_perm[i]) for all i</p> <p>u[i] >= (1 - start_perm[i]) for all i</p> <p>where N3 is the number of permutations divided by 3.</p> <p>The first one is MTZ, the other 2 are saying that u[p] is zero if and only if start(p) is one.</p> <p>A last twist is to use the know upper bound of 7320 as a cutoff. It helps the solver during its branch and bound: any node of cost higher than the cutoff is pruned.</p> <p>This model was better, less short cycles. But it produced a lot of cycles of similar nature. Here is one:</p> <p>123456712345672134567231456723415672345167234561723456</p> <p>Issue is that the mandatory 1234567 is duplicated, which is not what we want. We want duplicates of the same mandatory permutations to appear in 3 different strings. for this I had to add a graph coloring piece to the model.</p> <p>Other cycles were of the form</p> <p>12345672134567231456723415672345167234561723456</p> <p>These are 2-cycles for a mandatory minus 6 permutations. The missing 6 permutations are the rotations of the mandatory.</p> <h1>Graph coloring</h1> <p>I added 3 binary variables per node, class(p, k) with k=1,2,3 to represent which of the final 3 strings p belongs to.</p> <p>The constraints state that a node can only have one class, and that the number of nodes having a given class is N3. They also state that if next(p1, p2) is one, then class(p1,k) == class(p2,k) for all k.</p> <p>Adding these constraints made the problem very hard to solve. No solution was found after a day of computation.</p> <p>I studied the previous model solution, and found few things:</p> <ul> <li>All nodes with a start were mandatory permutations. This was easy to enforce with an additional constraint.</li> <li>All nodes with an end were mandatory permutations or were of the form 1x2xxxxx. Same, easy to enforce via constraints</li> <li>At least one copy of each mandatory had both a start and an end. I decided to drop one duplicate for each mandatory. This reduced the size of the problem further.</li> <li>The truncated 2-cycles for all mandatory cover all permutations that are not a rotation of a mandatory. I decided to enforce this by setting to 1 all the arcs appearing in these truncated 2-cycles.</li> </ul> <p>The resulting model solves in about 5 minutes, with a number of cycles. When the cycles are grouped by class and concatenated we get 3 strings of length 2160. Each of these string contain 80 mandatory. By appending the 40 missing mandatory we get 3 strings of length 2440 who meet all the original problem constraints.</p> <p>Code is now available at It is at <a href="https://github.com/jfpuget/kaggle_santa_21" target="_blank">https://github.com/jfpuget/kaggle_santa_21</a></p>
Santa 2021 - The Merry Movie Montage	A journey to get to 2428	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I meant: if you have already decided what should be the neighborhood of the wild card like ABCDEF*PQRSTU and fix these values, then you can treat this length 13 part as just one node. <br> It is hopefully better explained in the notebook (which is now linked above).</p> <p>This was a fun competition. I am sure most of the teams observed similar behavior about the shortest solutions.<br> Just in case it is helpful, I have also posted the code <a href="https://www.kaggle.com/szabo7zoltan/santa-2021-getting-to-2428-in-four-steps" target="_blank">https://www.kaggle.com/szabo7zoltan/santa-2021-getting-to-2428-in-four-steps</a> that broke down my approach into four parts.</p> <p>A few of the steps that helped me along the way:</p> <p>1, Starting with the 5913 superpermutation to get to the 2440 (no wildcard solution) with LKH.</p> <p>2, Investigating the 2440 no wildcard solution to understand how it works.<br> This also helps in guessing where the wildcards would have maximal benefits.</p> <p>3, Freezing the neighborhood of the wildcard and use LKH again to get to 2428. (This last part probably can be done by more elementary methods (simple mathematics), but LKH also works)</p> <p>Thanks! It was a nice competition</p>
Santa 2021 - The Merry Movie Montage	Get to 2430 with the Power of Randomization!	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Thanks Kaggle for hosting such an enjoyable Christmas competition - despite not achieving the perfect score, <a href="https://www.kaggle.com/product-feedback/299988" target="_blank">being banned twice</a> (causing multiple heart attacks), and the tension between the participants that has exploded in the last week, I can overall say that it was a pleasure to sit there with pen and paper, use a state-of-the-art TSP solver, harness the power of randomization, and trying really hard to get to 2428 until the end.<br> In this competition I also won my first silver medal, becoming a competition expert: this gives me a lot of motivation to compete even more this year!</p> <p>My journey in this competition can basically be broken down into four phases:</p> <ol> <li><p>For the first week or two, I basically did nothing but run public notebooks for <a href="https://www.kaggle.com/cdeotte/santa-2021-tsp-baseline-2500" target="_blank">TSP conversion</a>, <a href="https://www.kaggle.com/yosshi999/wildcard-postprocessing-using-dynamic-programming" target="_blank">wildcard placement</a>, and <a href="https://www.kaggle.com/kostyaatarik/permutations-rebalancing" target="_blank">permutation rebalancing</a> (big thanks to the authors!). By making small changes and doing a lot of experiments, I was able to get a LB of around 2490. </p></li> <li><p>The next step was trying different starting superpermutations in Chris's notebook after reading <a href="https://www.gregegan.net/SCIENCE/Superpermutations/Superpermutations.html" target="_blank">Greg Egan's page</a> and understanding the reported strings were very different in nature. One morning, I found out that the permutation of length 5913 worked really well and following basically the same procedure of the previous point, I managed to get to LB 2481. And as soon as I did that, a <a href="https://www.kaggle.com/ks2019/santa-baseline-2481" target="_blank">crucial notebook</a> for the competition with the same score was released. </p></li> <li><p>This stage was really a race against time. As soon as the previously mentioned notebook was released, I immediately knew it was a bomb and would move LB a lot. Handcrafting a baseline with a solid mathematical structure was the key to breaking the 2480 barrier and going straightly below 2450, a jump that was very well visible at the beginning of the competition since really few people were in this range. Things rapidly escalated and in a few days, I was able to get a 2440 perfect non-wildcard solution. This was done by going back and forth between <a href="https://www.kaggle.com/kostyaatarik/minmax-ctsp" target="_blank">MinMax CTSP</a> and <a href="https://www.kaggle.com/kostyaatarik/permutations-rebalancing" target="_blank">permutation rebalancing</a>. Starting from the 2481 solution, I noticed that when CTSP was stuck in a local minimum, it was a good idea to run the permutation rebalancing kernel increasing randomization by setting INITIAL_TOUR_FRACTION parameter and also changing the way permutations were rebalanced (the function <a href="https://www.kaggle.com/kostyaatarik/permutations-rebalancing?scriptVersionId=80839642&cellId=8" target="_blank">rebalance_perms</a> assumes a certain order in popping permutations, it is not the only one), then go back to CTSP for another run of joint optimization. With standard wildcard positioning code, however, the 2440 solution improved only to LB 2438.</p></li> <li><p>The last phase was the most fun and creative: I took some days and pen and paper to analyze the solutions and think about a nice way to use wildcards. I really thought I made it after I wrote a <a href="https://www.kaggle.com/mviola/santa-2021-randomized-wildcard-postprocessing" target="_blank">Randomized Wildcard Postprocessing</a> script, but it came up a little short. The procedure is described in the notebook, so feel free to check it more in detail there, but the idea is just to take an optimal path and its associated distance matrix and for many times:</p></li> </ol> <ul> <li>Randomly select two edges representing the transition from permutations of the form 1a2bcde to mandatory ones 12bcdea and set their cost to a negative value such as -1.<br> <a href="https://postimg.cc/hQ1CGkF7" target="_blank"><img src="https://i.postimg.cc/4yrjWGBw/distance-matrix.jpg" alt="distance-matrix.jpg"></a></li> <li>Reoptimize with LKH and find a new optimal tour that is very likely to include these transitions and that can later be optimized with a wildcard for an improvement of 6 characters each.<br> <a href="https://postimg.cc/JDD0M8kP" target="_blank"><img src="https://i.postimg.cc/k4wbNXX3/path.jpg" alt="path.jpg"></a><br> While I had no guarantees that this randomized algorithm would in general work well, I noticed that many runs could improve the score a lot and I could transform my set of 2440 strings to a set of 2442 strings but where each allows a gain of 6 for each wildcard, for a final LB of 2430.<br> After making sure I couldn't do better by bute-forcing all possible choices, I spent the last three weeks brainstorming and trying to improve upon this idea with other wildcard bridges and joint optimization on the three strings with CTSP, but I was not able to perform well enough to get to 2428 or 2429.</li> </ul> <p>Thank you for spending time reading my solution summary, I can’t wait to now understand what I missed and other approaches: 2428 has been my new recurring thought hahaha…<br> Happy (late) new year to everyone and happy Kaggling!</p>
Santa 2021 - The Merry Movie Montage	LKH and Wildcards gets to 2430	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>I hope I <code>triple</code> quoted all the <code></code> so that things didn't come out in italics</p> <p>I haven't seen anyone describe using the TSP solver LKH with wildcards in the way we did, so I will give a short description of our approach.</p> <p>Thanks to Kaggle for running a great competition and for the other competitors who provided much understanding along the way. Thanks to my partner <a href="https://www.kaggle.com/vkonstantakos" target="_blank">@vkonstantakos</a> for providing the 2440 solution I couldn't get to. </p> <p>Spoiler alert: we didn't get to 2428</p> <p>Consider each string of the solution as a group of permutations (a list in python) in the standard way, and compute the cost of each permutation to another in the usual way using distance(a,b).</p> <pre><code>def distance(a,b): #number of characters to append to a to get a string containing b #Assume both a,b are length N for n in range(N+1): if a[n:] == b[:N-n]: return n </code></pre> <p>Running the LKH solver on this group using this distance function will produce the shortest string for this given group of permutations. Note that this assumes that you have already partitioned the permutations into the 3 strings properly.</p> <p>Now, suppose we want to add wildcards into our string. We did this as follows:</p> <ol> <li>Pick a wildcard pattern, such as <code>234567</code> of any length, although as we will see, the wildcard should be not more than 7 characters from the beginning or end of the string.</li> <li>Generate all the permutations that this string represents. For the example in 1, it would be a single string <code>1234567</code>. For a longer string, say, <code>s=1234567</code>, it would be 1723456 and 1234567. Note that there can be at most len(s)-7 permutations, but you might not have that many because not all length 7 strings are a permutation.</li> <li>Remove from your group all these permutations from step 2.</li> <li>Add to your group the wildcard pattern from step 1.</li> <li>Use a modified distance function wdistance (see way below), which calculates the distance from a permutation to another, considering the presence of wildcards. Example: <code>wdistance('1723456','234567') is 1</code>.</li> <li>Now you can run LKH with this modified group and distance function. The answer (assuming LKH returns the optimal answer) is the shortest path that can be obtained when the wildcard takes on a different value one node prior to the wildcard perm and (possibly) different value on the node immediately following the wildcard perm, but not beyond those. Put another way, if the solution obtained is:<br> <code>p1->p2->p3-p_with_wildcard->p4->p5</code><br> Then p3 and p4 can use any value for the wildcard, but p1 ,p2, and p3 must all use the same value, and p4 and p5 must use the same value. So you can see that this is not guaranteed to be the best possible use of the wildcard; but if you use enough digits around the wildcard you will eventually be guaranteed to get the best answer. For example, searching over all <code><6-digits><6-digits></code> strings will eventually get the best answer (for a single wildcard).</li> </ol> <p>This is our basic method of determining wildcards; as you can see it does not involve any real understanding of the underlying patterns others have described in detail. It takes about 3-4 minutes to run LKH on a group and get what is reasonably reliable optimal answer. We checked this by running for longer times (hours) over multiple runs and not seeing any improvement. You can also speed up the search by using an initial tour close to the original optimal (non-wildcard) string.</p> <p>Here are the steps we took using this method</p> <ol> <li>We realized that the mandatory perms (beginning with '12' for us) seemed to be the most costly, so we started putting wildcards in those. For example, <code>234567, 124567</code>. After a few attempts and a little thought, it became apparent that the wildcard only makes sense replacing the 1 or the 2.</li> <li>Since we knew that we should be saving 5 or (hopefully) 6 per wildcard, the wildcard perm should follow another perm with a cost of 1. We called this the target for that perm. There is only 1 target for a perm once we pick the wildcard position. For example, target('1234567',wc=0) is '1723456'. target('1234567',wc=1) is '2173456', where wc is the index of the wildcard placement.</li> <li>A few experiments showed that wc=0 fared much better than wc=1.</li> <li>Some staring at solutions revealed a pattern of 36 permutations that started with a cost of 7 and ended at a target at a high frequency. This is the famous 42-perm cycle with the mandatories and their rotations removed. The targets for wc=0 generally seemed to be at the end of a 36 perm section and just before a cost of 7 perm. This appeared to be a good place to put the <code>234567</code> perm following it's target, because the following cost of 7 would not be impacted. It looked like it would save 6 points. However, as <a href="https://www.kaggle.com/cpmpml" target="_blank">@cpmpml</a> pointed out in his solution, that perm was ALWAYS at the start of the section. When we used that wildcard in our LKH solution, the moving of the perm to the end broke the pattern, losing 1 point, so the most any wildcard could save (and we tried them all) was 5 points.</li> <li>After find a large number of wildcards that produced 2435 when used singly, we started combining them, while not every pair of 2435 solutions together produced 2430, enough did that we quickly found a pair for each string that produced 2430.</li> <li>After finding 2430, we tried lots and lots of things to improve our score. First we tried to get to 2434 with a single wildcard: longer and longer wildcard strings <code>abcdefghijk</code> etc. We began to realize that maybe 2435 is the best you can do with 1 wildcard, but that 2 could do 2428 somehow. And we ran out of time….</li> </ol> <pre><code>def match_wc(a,b): #do a and b match using as wildcard in a or b? assert len(x1)==len(x2) for a,b in zip(x1,x2): if a==b or a=='' or b=='': continue return False return True def wdistance(string,b): #count the number of characters needed to have string a followed by perm b #where string or b has possible wildcard * #This is like distance but with wildcards, and string can be longer than 7 #distance can be 0 if they match a=string[-7:] # take last 7 characters for n in range(N+1): if match_wc(a[n:],b[:N-n]): return len(b)-7+n </code></pre> <p>I think I just slept a little less…</p>
Santa 2021 - The Merry Movie Montage	My journey + Constrained TSP to get from 2440 to 2430	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>First thanks to all organizers and participants. I really enjoyed this optimization competition. Hoping to see these more often.</p> <p>My goal during this competition was to get a medal. Here's a quick journey and maybe some novel way to approach wildcard problem. I didn't want to put too much effort into the theory of superpermutations though and was hoping that my optimization experience would be enough.</p> <h1>Getting to 2440</h1> <p>Having some OR background but no commercial solver available, I formulated preliminary MILP model using GAMS + Gurobi/CPLEX and sent it to NEOS server but unfortunately ran into memory issues.</p> <p>Luckily <a href="https://www.kaggle.com/kostyaatarik" target="_blank">@kostyaatarik</a> posted a nice <a href="https://www.kaggle.com/kostyaatarik/minmax-ctsp" target="_blank">solution with CTSP</a>, which provided very useful since it had potential to eventually reach 2440. Alterating between CTSP and rebalancing got me down to around 2445. From there I just let the model run for several days to get down to 2440.</p> <p>Adding <a href="https://www.kaggle.com/yosshi999/wildcard-postprocessing-using-dynamic-programming" target="_blank">wildcard dynamic programming </a> by <a href="https://www.kaggle.com/yosshi999" target="_blank">@yosshi999</a> it got me down to 2438 and I was satisfied.</p> <p>Until few days ago when I saw that even bronze was in danger and I need to optimize further.</p> <h1>Using constrained traveling salesman to get lower score with wildcards</h1> <p>Solution rests on following ideas/assumptions:</p> <ul> <li>Optimize individual strings;</li> <li>Have wildcard options that can be used with the constraint of using only two wildcards;</li> <li>The distance from wildcard to its non-wildcard permutation would be 0 to force the solver to replace permutation with its wildcard;</li> <li>Wildcard would be used only in first position e.g. *234567 to simplify calculations;</li> <li>Only mandatory permutations would be used for wildcards as these seemed to be putting the most additional length to superpermutation;</li> </ul> <p>I decided that <a href="https://www.kaggle.com/chaudharypriyanshu/st-21-a-perm-rebalancing-wildcard-optimization" target="_blank">permutation rebalancing notebook</a> by <a href="https://www.kaggle.com/chaudharypriyanshu" target="_blank">@chaudharypriyanshu</a> would be a good place to start to alter it to incorporate wildcards with constraint of using only two. Looking at <a href="http://webhotel4.ruc.dk/~keld/research/LKH-3/" target="_blank">possible models of LKH-3</a>, I decided to go with ACVRP (Asymmetric capacitated vehicle routing problem) with using single vehicle, reducing it to ACTSP. Setting non-wildcard permutations to have weight of 0, wildcard to have weight of 1 and setting the vehicle to have capacity = 2, I ran the solution for several hours to obtain 2430 solution just couple of hours before deadline to secure medal spot. Probably lower solution can be obtained by broadening some of the assumptions mentioned above.</p> <p>The code is published in <a href="https://www.kaggle.com/taanieluleksin/wilcard-optimization-with-acvrp-up-to-2430" target="_blank">this notebook</a>.</p>
Santa 2021 - The Merry Movie Montage	My solution	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>First of all, I would like to thank the organizer for another year of interesting problems, and all the other participants for making the competition very fun! </p> <p>Since many participants have already shown their solutions and told in detail about the ideas and with very beautiful pictures, I will briefly talk about what I did. The first week I watched as top1 rapidly improves their solutions. Since I do not know how to use libraries for optimization, I thought about a constructive solution. When I saw a score of 2440 or less on the leaderboard, I figured that the distance between the subsequences should be almost zero. So I began to build greedily solution from a sequence and understood the idea of cycles, which was described many times on the forum. When I wrote the code to generate the solution for 2440, top1 had a result of 2429 (their solution <a href="https://www.kaggle.com/skril31/generating-a-2428-solution-in-100-lines-of-code)" target="_blank">https://www.kaggle.com/skril31/generating-a-2428-solution-in-100-lines-of-code)</a>. I figured that each star should give plus 6 to score and pretty quickly came up with an idea described in the solution <a href="https://www.kaggle.com/c/santa-2021/discussion/300509" target="_blank">https://www.kaggle.com/c/santa-2021/discussion/300509</a> . However, I had a terrible code that even I did not understand well and I had to manually rebuild the sequences all day to get 2428. All this day I was afraid that I would not be in time and someone would get 2428 faster than me, it was a little nervous for me)</p> <p>Thanks! <br> Clear eyes, full hearts…</p>
Santa 2021 - The Merry Movie Montage	Santa 5th Place Solution (2428) & Insights	Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge	<\|system\|>You can successfully explain and teach others topics and concepts from Kaggle competition solution write-ups. You are a highly talented data scientist who has shown exceptional performance in this data-science Kaggle competition: Santa 2021 - The Merry Movie Montage <\|user\|>Explain and teach me concepts from Kaggle competition solution write-ups that solved this challenge <\|assistant\|><p>Yes, I think that (understanding of structure) made the difference between those who got to 2428 quickly vs those who took some time going from 2430 to 2428. About notebook, I realized that when I saw many teams in 2440s range (mostly 2446) after 1-2 days of release of notebook. I went from 2481 to 2440 with significantly different approach. So, I didn't expect that while releasing notebook. Congratulations on the silver, btw.</p> <p>First of congratulations to everyone who achieved a decent score in this competition. I am happy to get a solo gold. I solved most of it on paper and then coded it. Here is my solution in detail:</p> <h2>Name Conventions:</h2> <p>There are 3 types of sequences:</p> <ol> <li>Mandatory (M) - sequences starting with '12' - (120)</li> <li>Mandatory Relatives (R) - sequences containing '12' but not starting with it - (1205)</li> <li>Non Mandatory Non Relatives (N) - All other sequences - (4320)</li> </ol> <h2>Solution:</h2> <h3>1. Proving lower bound = 2400 (without wildcard, Mathematically)</h3> <p>Due to additional constraint introduced in the problem, it was easy. The best length/sequence ratio we can have in a cyclic permutation with more than 8 sequences is 7/6 (6 one edges followed by a 2 edge - 2 cycles). There will be 1203 M in the solution. This enforces additional constraints to have - 120 * 5 * 3 R. So, our permutation must have these 120 * 5 * 2 additional duplicates. </p> <h5>Lets calculate lower bound</h5> <ul> <li>N - 4320 * 7/6 = 5040</li> <li>R - 3 * 120 * 5 = 1800</li> <li>M - 120 * 3 = 360</li> <li>Total length = 7200</li> <li>If we can split this cycle in 3 perms of equal length at 7-edges (if any), we get 2400. But we have relaxed some constraints for best case. May be adding those constraints can get us to 2440 mathematically. </li> </ul> <h3>2. Getting to 2440</h3> <ul> <li>This is similar to what other participants did. I had approximate count of N,R,M in mind and I didn't want to break N-N connections in 2 cycles for the start. This is may be where I get lucky, If I remove all R from a 2 cycle and keep only one M, I get a permutation of length 47 for each cycle (lets call it B, base permutations). Simple concatenating all these 120 cycles. I have permutation of length 120 * 47 = 5640 which contains all N sequences. </li> </ul> <h5>Sample base permutation (B) of 47 length: 12345672134567231456723415672345167234561723456</h5> <ul> <li>Now, for M & R -> we can combine pairs of M sequences with swapped chars at end positions '12345671234576'. We can easily make these connections, by appending corresponding sequence at the start of each 120 base perms which makes length of each base perms - 47+7 = 54. Total length = 120 * 54 = 6480.</li> </ul> <h5>Sample base permutation (B) of 54 length: 123457612345672134567231456723415672345167234561723456</h5> <ul> <li>Only sequence left to be added in each 2 cycle - #12#### (7123456). Now, lets add one M of length 7 with only constraint that it ends with a '7'. Base perm length = 54 + 7 =61. Total length 12061 = 7320 . </li> </ul> <h5>Sample base permutation (B) of 61 length: 1236547123457612345672134567231456723415672345167234561723456</h5> <ul> <li>Use 40 permutations of length 61 in each subpermutations to get 2440. I could prove it visually but after <a href="https://www.kaggle.com/cpmpml" target="_blank">@cpmpml</a> & other's confirmation, I was sure this is lower bound. </li> </ul> <h3>3. Getting to 2428</h3> <ul> <li>Once you know exactly how your solution is created, getting to 2428 is easy. For getting to 2428, we can modify our permutation and add corresponding sequence at the end instead of start of 47 length base permuation. Pairs (swapped at last position) of such wildcard permutations (length 48) will cover all sequences contained in base permutations of length 54. We miss R, but we have extra Ms to make up for it. Remember all we need to stack 2 M to save all Rs (12345671234576). We can stack 3M for these special 6 wildcard cases (124356712345671234765)</li> </ul> <h5>Sample wildcard permutation (B) of 48 length:12345672134567231456723415672345167234561234576</h5> <ul> <li>Our solution size -> get reduced from 54 to 48 (save of 6 length). 6 wildcards - 3 pairs - 2428 solution. </li> </ul> <h3>4. Why I think 2428 is optimal and we can save only 6 per wildcard in best solution</h3> <p>Assuming we can only use wildcard by breaking and making connections</p> <ul> <li>We can't save R. R is duplicated on average 3 times. If we use wildcard, to save R at one place, it will still show up at other place. I mean technically we can save R. But, when we save R, we actually remove a redundant edge. </li> <li>Touching base permutation of length 47 (except at the start or end) - Base permutation is saturated. There are only edges of length 1 or 2. (6 ones followed by 2)</li> <li>Case 1 - Break and make 2 ones - No benefit - Best you will have 2 ones with new wildcard in place</li> <li>Case 2 - Break and make 1 one and 1 two - Best you will have 2 ones with new wildcard in place. After 2 you will be followed by 6 ones in 2 cycle - Again you'll be able to save only 1 distance</li> <li>Case 3 - Break and make 3 twos - Best you will have 2 ones with new wildcard in place - Same logic - you'll be able to save only 1 distance</li> <li>At the start or end - here you're not followed by saturated connections - So, here we have best chance of getting benefits. We convert a 7 edge -> 1 edge with wildcard. 7 edges can only exists for M (because of redundant R). </li> <li>More than 6 save is only possible if there are multiple consecutive edges>=2 which is not possible here. If we observe base permutation, the distance between 7 edge and 2 edge is 7 which makes it impossible to use same wildcard to effectively reduce both edges.</li> <li>This may not be proper mathematical proof, but, I see it hold true as long as we don't have a 7 and a >=2 edge close to each other. I tried to bring them close, only to realise that I will be distorting my base permutation (Adding extra penalty) which may give me better wildcard benefits but increase my 2440 base sequence length.</li> </ul> <p>Code here: <a href="https://www.kaggle.com/ks2019/getting-2440-in-simpler-way?scriptVersionId=80946172" target="_blank">https://www.kaggle.com/ks2019/getting-2440-in-simpler-way?scriptVersionId=80946172</a></p> <p>P.S. If anyone has additional ideas for mathematically proving 2428 as lower bound, contact me. I will love to work on this together. </p>