Showing ideas that are with tags
  • 2

    U-net with simple Resnet Blocks In Segmentation [0.81]

    2 months ago
    walt
    Model Description U-net with simple Resnet Blocks
    The Score IoU 0.81
    Loss Function binary_crossentropy loss and then Lovász-hinge loss
    Image Size 101
    Data Augmentation Up down flip,90 deg rotation
    Learning Rate0.01
    OptimizerAdam
    Used Tricks ● Cancel last dropout (seems better)
    ● modify convolution_block, to be more consistant with the standard resent model
    ● Use faster IOU metric score code
    ● Use binary_crossentropy loss and then Lovász-hinge loss (very slow!)
    ● Start with saved model
    Machine RAM 14GB,Tesla K80
    Runing Time 215 minutes
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    InceptionResNetV2 In Classification [0.387]

    2 months ago
    Tahlia
    Model Description InceptionResNetV2
    The Scoref1 0.387
    Loss Functioncategorical_crossentropy
    Image Size 3 channels with 299 size
    Data Augmentation iaa.Affine(rotate=0), iaa.Affine(rotate=90), iaa.Affine(rotate=180), iaa.Affine(rotate=270), iaa.Fliplr(0.5), iaa.Flipud(0.5),
    Learning Rate0.0001
    Optimizer Adam
    Used Tricks
    MachineRAM 14GB ,GPU Tesla K80
    Runing Time 315 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    U-net with ResNext34 In Segmentation [0.894]

    1 month ago
    jimes
    Model Description U-net with ResNext34
    The ScoreIoU 0.894
    Loss Function BCE+Dice after that lovasz loss
    Image Size Input 101 -> pad to 128
    Data Augmentation ● HorizontalFlip(p=0.5)
    ● RandomBrightness(p=0.2,limit=0.2)
    ● RandomContrast(p=0.1,limit=0.2)
    ● ShiftScaleRotate(shiftlimit=0.1625, scalelimit=0.6, rotate_limit=0, p=0.7)
    Learning Rate0.01 Reduce LR To 0.001
    Optimizer SGD
    Used Tricks ● Used Encoder ResNet34 + scSE (conv7x7 -> conv3x3 and remove first max pooling)
    ● Center Block Feature Pyramid Attention (remove 7x7)
    ● Decoder conv3x3, transposed convolution, scSE + hyper columns
    ● Pretrain on pseudolabels for 150 epochs
    ● Finetune on train data. 5 folds, 4 snapshots with cosine annealing LR, 50 epochs each
    Machine GeForce GTX 1080ti
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNext34 In Segmentation [0.877]

    1 month ago
    jimes
    Model Description ● Encoder is ResNet34 pretrained on ImageNet
    ● The Centerblock FPA model for attention
    ● Decoder conv3x3 + GAU
    The ScoreIoU 0.877
    Loss Function BCE+Dice after that lovasz loss
    Image Size 101 -> resize to 202 -> pad to 256
    Data Augmentation ● dohorizontalflip2
    ● dorandomshiftscalecrop_pad2 0.2
    ● dohorizontalshear2 (-0.07, +0.07)
    ● doshiftscale_rotate2 rotate 15
    ● doelastictransform2 (0, 0.15)
    ● dobrightnessshift (-0.1, +0.1)
    ● dobrightnessmultiply (-0.08, +0.08)
    ● do_gamma (-0.08, +0.08)
    Learning Rate0.01
    Optimizer SGD
    Used Tricks ● LR on cosine annealing
    ● 5-fold Average Ensemble ResNet34 got 0.881 private LB
    Machine
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with SENet154 In Segmentation [0.890]

    1 month ago
    jimes
    Model Description ● single UNet model with a Squeeze-and-Excitation network encoder
    ● no ensembling, no pseudo labeling
    ● object context in the decoders and in the base
    The ScoreIoU 0.890
    Loss Function BCE+Dice after that use symmetric lovasz loss
    Image Size 101 -> resize to 128
    Data Augmentation ● CropAndRescale(max_scale=0.2)
    ● HorizontalShear(max_scale=0.07)
    ● Rotation(max_angle=15)
    ● ElasticDeformation(max_distort=0.15)
    ● BrightnessShift(max_value=0.1)
    ● BrightnessScaling(max_value=0.08)
    ● GammaChange(max_value=0.08)
    ● Cutout(1, 30)
    ● HorizontalFlip()
    Learning Rate0.01
    Optimizer AdamW with the Noam scheduler
    Used Tricks ● modifying Lovasz to symmetric (lovasz_hinge(outputs, targets) + lovasz_hinge(-outputs, 1 - targets)) / 2
    ● use SWA after the training on the best loss, pixel accuracy, metric and the last models
    ● use 10 folds using reflective padding and another 10 folds with resizing
    Machine
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with SE ResNeXt-50 In Segmentation [0.891]

    1 month ago
    jimes
    Model Description ● SE ResNeXt-50, pretrained on ImageNet
    ● Decoder features
    ● Spatial and Channel Squeeze Excitation gating
    ● Hypercolumns
    ● Deep supervision (zero/nonzero mask)
    The ScoreIoU 0.891
    Loss Function BCE+Dice after that use lovasz loss
    Image Size 101 -> pad to 128
    Data Augmentation ● Random fixed-size crop
    ● Random horizontal flip
    ● Random gamma-correction
    ● Random cutout
    ● Random invert
    Learning Rate0.05
    Optimizer SGD( momentum 0.9, weight decay 0.0001)
    Used Tricks ● use 5-fold random split
    ● Classification used loss BCE
    ● Segmentation used losses - BCE + Lavasz Hinge
    ● 0.5
    ● LR schedule - cosine annealing from maximum LR, cycle length - 50 epochs, 10 cycles per experiment
    ● Best snapshots according to metric were saved independently for each cycle, final solution uses 2 best cycles per fold
    Machine
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with SE ResNeXt-50 In Segmentation [0.888]

    1 month ago
    jimes
    Model Description ● SE ResNeXt-50, pretrained on ImageNet
    ● Decoder features
    ● Dilated convolutions with dilation from 1 to 5
    ● Hypercolumns
    ● ASPOCModule before last Convolution layer
    ● Deep supervision (zero/nonzero mask, nonzero mask segmentation)
    ● Dropout
    The ScoreIoU 0.888
    Loss Function BCE+Dice after that use lovasz loss
    Image Size 101 -> Replication up to 128
    Data Augmentation ● Random Rotation up to 10 degree
    ● Random Crop and Scale
    ● Random Horizontal flip
    Learning Rate0.01
    Optimizer SGD(momentum = 0.9, weight decay = 0.0001)
    Used Tricks
    Machine
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with SE SeNet154 In Segmentation [0.890]

    1 month ago
    jimes
    Model Description ● U-Net like decoder with ScSe, CBAM and Hypercolumn
    ● used backbones SeNet154
    The ScoreIoU 0.890
    Loss Function Lovasz Hinge0.9 + BCE0.1
    Image Size 101 ->resize to 224
    Data Augmentation random gamma,brightness,shift, scale, rotate,horizontal flip,contrast
    Learning Rate0.0001
    Optimizer adam
    Used Tricks ● because of random shift in brightness all images were pre-processed next way np.clip(img - np.median(img) +127, 0, 255)
    Machine1080ti GPU
    Runing Time 6 days
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with Pyramid Scene Parsing Network PSPNet In Segmentation [0.891]

    1 month ago
    jimes
    Model Description ● Pyramid pooling module,residual blocks and auxiliary training
    ● Spatial and channel squeeze excitation module
    ● Guided upsampling module
    The ScoreIoU 0.891
    Loss Function Cross-entropy + Lovász-softmax loss
    Image Size 101 ->reflect padding to 129
    Data Augmentation ● Random horizontally flip
    ● Random translate with reflect padding
    ● Random crop and resize
    Learning Rate0.001
    Optimizer adam
    Used Tricks ● use 10-fold CV (random split)
    ● use TTA with horizontal flip
    ● use Cosine annealing with restarts LR
    Machine1080ti GPU
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNet34 In Segmentation [0.888]

    1 month ago
    jimes
    Model Description ● Use ResNet model as an encoder for UNet
    ● Add intermediate layers like BAM,Squeeze Excitation blocks in a ResNet34 model which can be easily replicated for other network architectures
    ● Show how to add Deep supervision to the network, and calculate loss and combine loss at different scale.
    The ScoreIoU 0.888
    Loss Function BCE+Dice after that lovasz loss
    Image Size Input 101 -> resize to 224
    Data Augmentation RandomRotate(4, tfm_y=TfmType.CLASS), RandomFlip(tfm_y=TfmType.CLASS), RandomLighting(0.1, 0, tfm_y=TfmType.CLASS), RandomBlur([3,5,7]), RandomZoom(0.1,tfm_y=TfmType.CLASS)
    Learning Rate0.0001
    Optimizer SGD(momentum of 0.9 )
    Used Tricks ● used BAM Bottleneck attention module for my best model which performed slightly better than scSE
    ● Used hyper columns
    ● Resize worked better than padding.
    ● Used Cyclic learning rate
    ● use 10 flods
    Machine GeForce GTX 1080ti
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNet34 In Segmentation [0.889]

    1 month ago
    jimes
    Model Description Resnet34 (removed first maxpool) + scSE + Hypercolumn (all activations in decoder - ELU)
    The ScoreIoU 0.889
    Loss Function Lovasz Hinge 0.9 + BCE 0.1
    Image Size 101 -> resize to 224
    Data Augmentation RandomCrop, HorizontalFlip, RandomContrast, RandomBrightness, RandomShift, HorizontalShare, RandomRotation, Expand, Resize(224)
    Learning Rate0.01
    Optimizer SGD(momentum 0.9)
    Used Tricks ● LR schedule on cosine annealing from 0.01 to 0.0005
    ● 5-fold CV (stratified by depth)
    ● use TTA with horizontal flip and threshold=0.45
    Machine2x 1080ti GPU
    Runing Time 5 days
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with SE-ResNeXt-50 In Segmentation [0.888]

    1 month ago
    jimes
    Model Description ● modified the first layer using it with stride = 1 by returning back max pooling
    ● ScSE (Spatial-Channel Squeeze and Excitation) both in Encoder and Decoder
    ● Hypercolumn
    ● Without any dropouts
    The ScoreIoU 0.888
    Loss Function 0.1 BSE + 0.9 Lovasz
    Image Size 101 -> resize to 128
    Data Augmentation Brightness , blurs, hflip, scale, rotate, contrast,However
    Learning Rate0.0001
    Optimizer adam
    Used Tricks ● the 1st input channel is the source image, the 2nd input channel is relative depth (currentdepth - mindepth / maxdepth - mindepth) and the third is CoordConv
    ● Cyclic learning rate (mode='triangular2', baselr=1e-4, maxlr=3e-4, step_size=1500)
    ● Use snapshot assembling(averaging last 10 best models with exponentially decreasing weights)
    ● Removing smalls masks and small independent masks (black and white) by using cv2.connectedComponentsWithStats
    Machine 1080ti GPU
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with Densenet and DPN In Segmentation [0.887]

    1 month ago
    jimes
    Model Description ● for encoder
    ● use densenet without dilation
    ● use densenet with dilation
    ● use normal DPN (Dual Path Networks)
    ● for decoder
    ● Unet style structure with hypercolumn
    ● linknet style structure without hypercolumn
    ● ModifiedSCSEBlock
    The ScoreIoU 0.887
    Loss Function Lovasz Loss
    Image Size 101 -> resize to 128
    Data Augmentation Brightness , blurs, hflip, scale, rotate, contrast,However
    Learning Rate0.0001
    Optimizer adam
    Used Tricks ● use 10 flods and 5 cycle learning for each fold
    ● deep supervision
    ● use TTA with horizontal flip
    Machine 1080ti GPU
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    UNet with pretrained resnet34/50 In Segmentation [0.887]

    1 month ago
    jimes
    Model Description ● first model resnet34 as encoder
    ● second model resnet50 as encoder
    ● replace upsample with deconv, remove first pooling layer of model1
    The ScoreIoU 0.887
    Loss Function Lovasz Loss
    Image Size 101 -> pad to 128
    Data Augmentation rotate 10 degree,h flip, p=0.5,translate x -0.1, 0.1,brightness 0.9 - 1.1
    Learning Rate0.0001
    Optimizer SGD
    Used Tricks ● Use Spatial and channel squeeze and excitation module (scse)
    ● Use Hypercolumn
    ● Add depths channel
    ● Remove first pooling layer of pretrained resnet34
    ● Use pseudo labeling
    ● 10 folds cross validation random split
    ● use TTA with horizontal flip
    ● ensemble resnet34/50 models
    Machine 1080ti GPU
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    UNet with Wider ResNet 38 In Segmentation [0.881]

    1 month ago
    jimes
    Model Description WiderResnet38 + Unet pretratined on ImageNet
    The ScoreIoU 0.881
    Loss Function 500 epochs with BCE loss then 500 epochs Lovasz Loss
    Image Size 101 -> pad to 128
    Data Augmentation shift scale rotate, brightness,contrast,gamma, elastic transform , grid distortion
    Learning Rate0.0001
    Optimizer adam
    Used Tricks ● Train 50x5 SGD with CosineLR, starting from previous best snapshot
    ● use TTA with horizontal flip
    ● Average masks from 4 folds
    Machine 1080ti GPU
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNext34 In Segmentation [0.88]

    1 month ago
    jimes
    Model Description U-net with ResNext34
    The ScoreIoU 0.88
    Loss Function BCE+Dice after that lovasz loss
    Image Size Input 101 -> resize to 202 -> pad to 256
    Data Augmentation ● HorizontalFlip(p=0.5)
    ● RandomBrightness(p=0.2,limit=0.2)
    ● RandomContrast(p=0.1,limit=0.2)
    ● ShiftScaleRotate(shiftlimit=0.1625, scalelimit=0.6, rotate_limit=0, p=0.7)
    Learning Rate0.01 Reduce LR To 0.001
    Optimizer SGD
    Used Tricks ● Used Encoder ResNet34 + scSE (conv7x7 -> conv3x3 and remove first max pooling)
    ● Center Block Feature Pyramid Attention (remove 7x7)
    ● Decoder conv3x3, transposed convolution, scSE + hyper columns
    ● Use 5 Flods
    Machine GeForce GTX 1080ti
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNext50 In Segmentation [0.875]

    2 months ago
    jimes
    Model Description U-net with ResNext50
    The ScoreIoU 0.875
    Loss Function BCE+Dice after that lovasz loss after that lovasz loss with cosine annealing
    Image Size Input 101 --> resize to 192 --> pad to 224
    Data Augmentation ● HorizontalFlip(p=0.5)
    ● RandomBrightness(p=0.2,limit=0.2)
    ● RandomContrast(p=0.1,limit=0.2)
    ● ShiftScaleRotate(shiftlimit=0.1625, scalelimit=0.6, rotate_limit=0, p=0.7)
    Learning Rate0.0001 Reduce LR To 0.00005
    Optimizer RMSprop
    Used Tricks ● Encoder --> ResNeXt50 pretrained on ImageNet
    ● Decoder--> conv3x3 + BN, Upsampling, scSE
    ● Use 5 flods
    Machine GeForce GTX 1080
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    VGG16 IN Classification [0.10]

    2 months ago
    Tahlia
    Model Description VGG16
    The Scoref1 0.10
    Loss Function binary_crossentropy
    Image Size 224
    Data Augmentation horizontal flips,Small gaussian blur with random sigma between 0 and 0.5, Strengthen or weaken the contrast in each image. Add gaussian noise,Make some images brighter and some darker,Scale/zoom them, translate/move them, rotate them and shear them.
    Learning Rate0.01
    Optimizer Adam
    Used Tricks
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 485 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    InceptionResNetV2 In Classification[0.269]

    2 months ago
    Tahlia
    Model Description InceptionResNetV2
    The Scoref1 0.269
    Loss Functionbinary_crossentropy
    Image Size 3 channels of 299 size
    Data Augmentation iaa.Affine(rotate=0),iaa.Affine(rotate=90),iaa.Affine(rotate=180), iaa.Affine(rotate=270),iaa.Fliplr(0.5), iaa.Flipud(0.5),
    Learning Rate0.001
    Optimizer Adam
    Used Tricks
    Machine RAM 14GB,Tesla K80
    Runing Time 450 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    Darknet in Classification [0.302]

    2 months ago
    Tahlia
    Model Description Darknet
    The Scoref1 0.302
    Loss Function nn.BCELoss
    Image Size 4 channels of 128 size
    Data Augmentation
    Learning Rate0.02
    OptimizerAdam
    Used Tricks
    Machine RAM 14GB,Tesla K80
    Runing Time 260 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    Two Xception Branches In Classification [0.28]

    2 months ago
    Tahlia
    Model Description Two Xception Branches
    The Scoref1 0.28
    Loss Functionbinary_crossentropy
    Image Size 3 channels of 299 size
    Data Augmentation ● vertical_flip=True,
    ● horizontal_flip=True,
    ● rotation_range=180,
    ● fill_mode='reflect'
    Learning Rate
    Optimizer Adam
    Used Tricks ● Use Yellow, blue and red channel - we create RGB image (yellow channel will be in fact green color now),
    ● Use another Source green channel -will be grayscale image but with 3 equal channel (condition for using Imagenet weights)
    MachineRAM 14GB,Tesla K80
    Runing Time 300 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    U-net with simple Resnet In Segmentation [0.830]

    2 months ago
    walt
    Model Description U-net with simple Resnet
    The ScoreIoU 0.830
    Loss Function binary_crossentropy for 50 epochs after that use lovasz_loss for 50 epochs
    Image Size 101
    Data Augmentationnp.fliplr(x)
    Learning Rate0.01
    OptimizerAdam
    Used Tricks ● Cancel last dropout (seems better)
    ● modify convolution_block, to be more consistant with the standard resent model.
    ● Use faster IOU metric score code.
    ● Use binary_crossentropy loss and then Lovász-hinge loss (very slow!)
    MachineRAM 14GB,Tesla K80
    Runing Time 260 minutes
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    Unet With simple ResNet blocks In Segmentation [0.84]

    2 months ago
    walt
    Model Description Unet With simple ResNet blocks
    The ScoreIoU 0.845
    Loss Function binary_crossentropy for 100 epochs after that use lovasz_loss for 120 epochs
    Image Size 101
    Data Augmentationnp.fliplr(x)
    Learning Rate0.005
    Optimizer adam
    Used Tricks
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 350 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    Unet With ResNet34 In Segmentation [0.840]

    2 months ago
    walt
    Model Description Unet With ResNet34
    The ScoreIoU 0.840
    Loss Function binary_crossentropy for 75 epochs after that use lovasz_loss for 75 epochs
    Image Size 101
    Data Augmentationnp.fliplr(x)
    Learning Rate0.01
    Optimizer adam
    Used Tricks
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 367 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    Unet with Resnet34 In Segmentation [0.810]

    2 months ago
    walt
    Model Description Unet with Resnet34
    The ScoreIoU 0.810
    Loss Function nn.BCEWithLogitsLoss
    Image Size 128
    Data Augmentation ● np.fliplr(x)
    ● RandomRotate2(4, tfm_y=TfmType.CLASS),
    ● RandomFlip(tfm_y=TfmType.CLASS),
    ● RandomStretch(0.2,tfm_y=TfmType.CLASS),
    ● RandomLighting(0.05, 0.05, tfm_y=TfmType.CLASS)
    Learning Rate0.01
    Optimizer adam
    Used Tricks
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 240 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with simple Resnet In Segmentation [0.835]

    2 months ago
    walt
    Model Description U-net with simple Resnet
    The Score IoU 0.835
    Loss Functionbinary_crossentropy for 100 epochs after that lovasz_loss for 200 epochs
    Image Size 101
    Data Augmentation np.fliplr(x)
    Learning Rate0.01
    Optimizer adam
    Used Tricks1-Using ELU in lovasz loss
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 330 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    Dataset TGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    UNET with VGG -16 In Segmentation [0.44]

    2 months ago
    Tahlia
    Model Description UNET with VGG -16
    The Score 0.44
    Loss Functionnn.BCEWithLogitsLoss()
    Image Size 128
    Data Augmentation RandomRotate(4, tfm_y=TfmType.CLASS), RandomFlip(tfm_y=TfmType.CLASS), RandomLighting(0.05, 0.05, tfm_y=TfmType.CLASS)]
    Learning Rate0.01
    Optimizeradam
    Used Tricks
    Machine RAM 14GB,Tesla K80
    Runing Time 150 minutes
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    Dataset TGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    UXception In Segmentation [0.87]

    2 months ago
    Tahlia
    Model Description Xception model with ResNet decoder
    The ScoreIoU 0.87
    Loss Functionbce_dice_loss
    Image Size 128
    Data Augmentation np.fliplr
    Learning Rate0.01
    Optimizer SGD(0.01, momentum=0.9, nesterov=True)
    Used Tricks ● Use of Pseudo-Labelling
    ● Using normalized Gradient optimizer
    ● Use Stochastic Weight Averaging (SWA)
    MachineRAM 14GB,Tesla K80
    Runing Time 280 minutes (both training and prediction)
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    NASNET MOBILE In Classification [0.317]

    2 months ago
    Tahlia
    Model Description NASNET MOBILE
    The Scoref1 0.317
    Loss Functionbinary_crossentropy
    Image Size 3 channels with 224 size
    Data Augmentation iaa.Affine(rotate=0),iaa.Affine(rotate=90),iaa.Affine(rotate=180), iaa.Affine(rotate=270),iaa.Fliplr(0.5), iaa.Flipud(0.5),
    Learning Rate0.002
    OptimizerAdam
    Used Tricks
    MachineRAM 14GB,Tesla K80
    Runing Time 412 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    InceptionV3 In Classification [0.379]

    2 months ago
    Tahlia
    Model Description InceptionV3
    The Score f1 0.379
    Loss Functionbinary_crossentropy
    Image Size 3channels with 299 size
    Data Augmentation iaa.Affine(rotate=0),iaa.Affine(rotate=90),iaa.Affine(rotate=180), iaa.Affine(rotate=270),iaa.Fliplr(0.5),iaa.Flipud(0.5),
    Learning Rate0.0001
    Optimizer Adam
    Used Tricks
    Machine RAM 14GB ,GPU Tesla K80
    Runing Time 260 minutes
    Goal Predicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    GapNet-PL In Classification [LB 0.375]

    2 months ago
    Tahlia
    Model Description GapNet-PL
    The Scoref1 0.375
    Loss Functionbinary_crossentropy
    Image Size 4channels with 512 size
    Data Augmentation horizontal flips,random crops, gaussian blur with random sigma between 0 and 0.5, strengthen or weaken the contrast in each image,add gaussian noise,Make some images brighter and some darker,Scale/zoom/translate/move and rotate each image
    Learning Rate0.001
    Optimizer Adam
    Used Tricks
    MachineRAM 14GB ,GPU Tesla K80
    Runing Time 380 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    ResNet34 In Classification [0.456]

    2 months ago
    Tahlia
    Model Description ResNet34
    The Scoref1 0.456
    Loss FunctionFocal Loss
    Image Size 256
    data augmentation ● RandomRotate(30, tfm_y=TfmType.NO),
    ● RandomDihedral(tfm_y=TfmType.NO)
    Learning Rate0.02
    OptimizerAdam
    Used Tricks ● Finding the optimal learning rate (0.02)
    ● train only the head of the model while keeping the rest frozen
    ● Use Differential learning rate -LR of the head=0.02 and LR of middle layers =LR/3 =0.02/3 and the base of model trained with LR/10
    ● Using test time augmentation TTA with 4-flod
    MachineRAM 14GB ,GPU Tesla K80
    Runing Time 400 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    InceptionResNetV2 In Classification [0.416]

    2 months ago
    Tahlia
    Model Description InceptionResNetV2
    The Scoref1 0.416
    Loss Function F1 Loss
    Image Size 256
    Data Augmentation
    Learning Rate0.001
    Optimizeradam
    Used Tricks
    Machine RAM 14GB,Tesla K80
    Runing Time 500 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    ResNet50 In Classificaion [0.443]

    2 months ago
    Tahlia
    Model Description ResNet50
    The Scoref1 0.443
    Loss Functionbinary_crossentropy
    Image Size 256
    data augmentationsplit 512x512 image to four 256x256 images
    Learning Rate0.001
    OptimizerAdam
    Used Tricksreduce learning rate with LearningRateReducer in each batch
    MachineRAM 14GB ,GPU Tesla K80
    Runing Time 466 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    Darknet_small In Classification[0.427]

    2 months ago
    Tahlia
    Model Description Darknet_small
    Scoref1 0.427
    Loss FunctionFocal Loss
    Image Size 4 channels of 256
    Data AugmentationNo transforms are used
    Learning Rate0.01
    OptimizerAdam
    Used Tricks
    MachineRAM 14GB ,GPU Tesla K80
    Runing Time 530 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    DatasetHuman Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    InceptionV3 In Classification [0.390]

    2 months ago
    Tahlia
    Model Description InceptionV3
    The Scoref1 0.390
    Loss Function binary_crossentropy
    Image Size 3 channels of 299 size
    Data Augmentation iaa.Affine(rotate=0), iaa.Affine(rotate=90), iaa.Affine(rotate=180), iaa.Affine(rotate=270), iaa.Fliplr(0.5), iaa.Flipud(0.5)
    Learning Rate0.001
    OptimizerAdam
    Used Tricks ● Slices each 512x512 image into four 299x299 images
    ● Slice each image for prediction and combine the results to get list of classes
    Machine RAM 14GB,Tesla K80
    Runing Time 35 minutes
    GoalPredicting protein organelle localization for each sample,there are 28 different localization labels
    Dataset Human Protein Atlas Image Classification(Size 16GB,28 labels,31072 samples)
  • 1

    U-Net with DICE Loss Segmentation [0.79]

    2 months ago
    Tahlia
    Model Description U-Net with DICE Loss
    The Score 0.79
    Loss Functionbce_dice_loss
    Image Size 128
    Data Augmentation np.fliplr(x)
    Learning Rate
    Optimizeradam
    Used Tricks ● Add Batch Normalization layer after each conv
    ● Add shuffle=True in model.fit() method for a better BN effect
    ● You can use crf method to improve the result
    ● Changed uncov to uconv, but removed the dropout in the last layer
    ● Added DICE loss functions
    Machine RAM 14GB,Tesla K80
    Runing Time
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with simple Resnet Blocks Segmentation [0.80]

    2 months ago
    Tahlia
    Model Description U-net with simple Resnet Blocks
    The Score0.80
    Loss Function binary_crossentropy
    Image Size 128
    Data Augmentation np.fliplr(x)
    Learning Rate
    Optimizer adam
    Used Tricks ● Use UpSample2d+Conv2d instead of ConvTrans2D
    ● Add Batch Normalization layer after each conv
    ● use crf method to improve the result
    ● Added dropout to the model which seems to improve performance
    MachineRAM 14GB,Tesla K80
    Runing Time 200 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with simple Resnet Blocks In Segmentation [0.79]

    2 months ago
    Tahlia
    Model Description U-net with simple Resnet Blocks
    The ScoreIoU 0.79
    Loss Functionbinary_crossentropy
    Image Size 101
    Data Augmentation np.fliplr(x)
    Learning Rate
    Optimizeradam
    Used Tricks ● Last layer dropout reduced by half
    ● replace conv2D with 2 basic resnet blocks in each level of U-net
    ● Use faster rle_encode ( 10 times fater than RLenc )
    ● set random_state= 1234
    Machine RAM 14GB,Tesla K80
    Runing Time 90 minutes
    GoalBuild an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    Dataset TGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    UNET with Resnet18 In Segmentation [0.40]

    2 months ago
    Tahlia
    Model Description UNET with Resnet18
    The Score 0.40
    Loss Functionnn.BCEWithLogitsLoss()
    Image Size 128
    Data Augmentation RandomFlip(tfm_y=TfmType.CLASS)
    Learning Rate0.001
    Optimizeradam
    Used Tricks
    Machine RAM 14GB,Tesla K80
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    Dataset TGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
  • 1

    U-net with ResNext34 In Segmentation [0.891]

    1 month ago
    jimes
    Model Description U-net with ResNext34
    The ScoreIoU 0.891
    Loss Function BCE+Dice after that lovasz loss
    Image Size Input 101 ->resize to 128
    Data Augmentation ● HorizontalFlip(p=0.5)
    ● RandomBrightness(p=0.2,limit=0.2)
    ● RandomContrast(p=0.1,limit=0.2)
    ● ShiftScaleRotate(shiftlimit=0.1625, scalelimit=0.6, rotate_limit=0, p=0.7)
    Learning Rate0.01 Reduce LR To 0.001
    Optimizer SGD
    Used Tricks ● Encoder ResNet34 + scSE (remove first max pooling)
    ● Center Block conv3x3, Global Convolutional Network
    ● Decoder Global Attention Upsample (implemented like senet -> like scSE, conv3x3 -> GCN) + deep supervision
    ● Pretrain on pseudolabels for 150 epochs
    ● Finetune on train data. 5 folds, 4 snapshots with cosine annealing LR, 50 epochs each
    Machine GeForce GTX 1080ti
    Runing Time
    Goal Build an deep learning Model that automatically and accurately identifies if a subsurface target is salt or not
    DatasetTGS Seismic dataset (size 200 MB,labels 2 ,4000 images), The images are 101 x 101 pixels and each pixel is classified as either salt or sediment
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
Push your Model Summary