Popular Augmentation Library

Popular Augmentation library:

Augly

Augly (https://github.com/facebookresearch/AugLy) and Albumentations (https://github.com/albumentations-team/albumentations)

Augly example

Albumentations

Albumentations example:

Albumentations example

References

Mengukur Kualitas Ventilasi Ruangan Dengan Sensor Debu

Kualitas ventilasi ruangan adalah salah satu faktor penting untuk mengurangi penularan COVID-19. Transmisi virus SARS-CoV-2 dapat melalui droplet maupun aerosol. Droplet dimensinya agak besar, sehingga terbangnya tidak terlalu jauh. Aerosol dapat terbang cukup jauh, sehingga jarak 2 meter tidak cukup aman.

Untuk mengurangi penularan maka udara di suatu ruangan harus sering diganti baru atau dibersihkan dengan filter.

Ukuran kualitas ventilasi yang sering dipakai ada 2 yaitu debit aliran udara per detik dan ACH (Air Changes per Hour).

Debit aliran udara yang dipakai adalah 10 liter per orang per detik. [1]

Angka ACH yang dipakai minimal adalah 4, kalau bisa mencapai 6 [2].

Pada artikel ini dibahas pengukuran ACH dengan sensor debu.

Prinsip Pengukuran

Virus bersifat sebagai aerosol. Aerosol disimulasikan dengan menggunakan kabut yang dibangkitkan dengan alat fog generator. Kabut ini akan meningkatkan jumlah debu dalam ruangan.

Keberadaan kabut dideteksi oleh sensor debu.

Ventilasi diaktifkan untuk mengganti udara dengan udara segar yang bersih tidak mengandung debu. Jika udara sudah berhasil diganti, maka angka debu di sensor akan turun kembali ke keadaan normal.

Peralatan

Peralatan yang diperlukan adalah sebagai berikut

  • Pembangkit kabut / fog generator
  • Alat ukur debu. Misalnya menggunakan sensor GP2Y10 yang dihubungkan ke mikroproser Arduino Nano. Detail pembuatan dibahas di artikel tersendiri.

 

Laptop , mikroprosesor Arduino Nano dan sensor debu GP2Y10
Laptop , mikroprosesor Arduino Nano dan sensor debu GP2Y10

 

Pembangkit kabut (fog generator) 400 watt
Pembangkit kabut (fog generator)

 

Alternatif lain menggunakan perangkat handheld particle counter. Alat ini lebih bagus/presisi, namun juga lebih mahal. Pada pengukuran ini tidak diperlukan angka absolut jumlah debu, jadi pakai sensor murah juga sudah cukup.

Handheld particle counter
Handheld particle counter

Prosedur pengukuran

  • Nyalakan sensor debu
  • Pastikan angka debu yang terukur stabil selama sekurang-kurangnya 10 menit. Angka ini akan dijadikan referensi keadaan ‘bersih’
  • Nyalakan fog generator untuk membuat kabut. Isi ruangan dengan kabut sampai cukup banyak
  • Tunggu sampai kabut hilang.
  • Hentikan pengukuran setelah kabut sudah tidak terlihat, atau sudah cukup lama
  • Lakukan analisis untuk menghitung berapa lama waktu yang diperlukan agar kabut hilang

 

Pembangkit kabut sedang bekerja membangkitkan kabut berwarna putih
Pembangkit kabut sedang bekerja

Berikut ini percobaan pengkabutan di laboratorium

Analisis

Berikut ini contoh grafik jumlah debu terhadap waktu.

Kurva jumlah debu terhadap waktu masih banyak noise nya sehingga agak sulit melakukan analisis. Berikut ini sinyal yang sama namun dengan filter supaya sinyal frekuensi tinggi dihilangkan.

Dari kurva tersebut nampak bahwa debu mulai masuk di t=200, dan sudah hilang di sekitar t=1000. Jadi perlu waktu 800 detik untuk mengganti udara yang berkabut sampai bersih dengan udara baru.

Nilai ACH = 60 x 60 / 800 = 4,5

Jadi ruangan ini dalam 1 jam dapat melakukan pergantian udara sebanyak 4,5 kali.

Referensi

  1. Roadmap to improve and ensure good indoor ventilation in the context of COVID-19.
    Geneva: World Health Organization; 2021, Halaman 12
  2. Preventing the Spread of COVID-19 By Circulating Air in Schools and Other Buildings, Rhode Island Department of Health
  3. Wikipedia: Aerosol
  4. How Brisbane Independent School Prevented Outbreaks of Covid-19, despite Omicron wave

 

 

Melihat Daftar DNS Server di Ubuntu 20.04

Berikut ini perintah untuk mengetahui daftar DNS server yang dipakai oleh Ubuntu 20.04, dari command line:

systemd-resolve --status

Outputnya kurang lebih seperti ini:

Global
       LLMNR setting: no
MulticastDNS setting: no
  DNSOverTLS setting: no
      DNSSEC setting: no
    DNSSEC supported: no
          DNSSEC NTA: 10.in-addr.arpa
                      16.172.in-addr.arpa
                      168.192.in-addr.arpa
                      17.172.in-addr.arpa
                      18.172.in-addr.arpa
                      19.172.in-addr.arpa
                      20.172.in-addr.arpa
                      21.172.in-addr.arpa
                      22.172.in-addr.arpa
                      23.172.in-addr.arpa
                      24.172.in-addr.arpa
                      25.172.in-addr.arpa
                      26.172.in-addr.arpa
                      27.172.in-addr.arpa
                      28.172.in-addr.arpa
                      29.172.in-addr.arpa
                      30.172.in-addr.arpa
                      31.172.in-addr.arpa
                      corp
                      d.f.ip6.arpa
                      home
                      internal
                      intranet
                      lan
                      local
                      private
                      test

Link 2 (enp0s31f6)
      Current Scopes: DNS
DefaultRoute setting: yes
       LLMNR setting: yes
MulticastDNS setting: no
  DNSOverTLS setting: no
      DNSSEC setting: no
    DNSSEC supported: no
  Current DNS Server: 111.95.141.4
         DNS Servers: 202.73.99.2
                      118.136.64.5
                      111.95.141.4
          DNS Domain: domain.name

Sumber: https://askubuntu.com/questions/152593/command-line-to-list-dns-servers-used-by-my-system

Cara Upload File CSV ke Database MySQL Dengan Python

MySQL dilengkapi fitur load CSV, tapi  fitur ini susah untuk digunakan karena seringkali format data CSV tidak sesuai dengan yang diminta, ada tanda kutip, spasi, koma yang berantakan, dll. Untuk mengatasi hal ini, Python dapat membantu dengan cara memasukkan data dengan cara membaca file CSV baris per baris ke MySQL.

Penjelasan yang lebih jelas untuk menyambung Python ke MySQL dapat dilihat di sini

Ini adalah script untuk memasukkan data CSV ke MySQL dengan menggunakan teknik looping:

import mysql.connector
import csv

mydb = mysql.connector.connect(
  host="host",
  user="root",
  password="pass",
  database="data"
)

mycursor = mydb.cursor()
with open('daftar.csv', newline='') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    for val in reader : 
        sql = "INSERT INTO `data`.`info` (`nama`, `data`, `nilai`) VALUES (%s,%s,%s)"   
        mycursor.execute(sql,val)

mydb.commit()
mydb.close()

Data CSV yang bernama daftar.csv pada contoh memiliki format seperti ini (tanpa header):

nama1 data1 nilai1
nama2 data2 nilai2
nama3 data3 nilai3

Covid-19 Detection with Chest Radiograph: Resources

Papers

Research Papers:

  • CovidGAN: Data Augmentation Using Auxiliary Classifier GAN for Improved Covid-19 Detection – in this research, we present a method to generate synthetic chest X-ray (CXR) images by developing an Auxiliary Classifier Generative Adversarial Network (ACGAN) based model called CovidGAN. In addition, we demonstrate that the synthetic images produced from CovidGAN can be utilized to enhance the performance of CNN for COVID-19 detection. Classification using CNN alone yielded 85% accuracy. By adding synthetic images produced by CovidGAN, the accuracy increased to 95%. We hope this method will speed up COVID-19 detection and lead to more robust systems of radiology.

  • Iteratively Pruned Deep Learning Ensembles for COVID-19 Detection in Chest X-rays – The best performing models are iteratively pruned to reduce complexity and improve memory efficiency. The predictions of the best-performing pruned models are combined through different ensemble strategies to improve classification performance. Empirical evaluations demonstrate that the weighted average of the best-performing pruned models significantly improves performance resulting in an accuracy of 99.01% and area under the curve of 0.9972 in detecting COVID-19 findings on CXRs. The combined use of modality-specific knowledge transfer, iterative model pruning, and ensemble learning resulted in improved predictions. We expect that this model can be quickly adopted for COVID-19 screening using chest radiographs.

  • COVID-ResNet: A Deep Learning Framework for Screening of COVID19 from Radiographs – Using these techniques, we showed the state of the art results on the open-access COVID-19 dataset. This work presents a 3-step technique to fine-tune a pre-trained ResNet-50 architecture to improve model performance and reduce training time. We call it COVIDResNet. This is achieved through progressively re-sizing of input images to 128x128x3, 224x224x3, and 229x229x3 pixels and fine-tuning the network at each stage. This approach along with the automatic learning rate selection enabled us to achieve the state of the art accuracy of 96.23% (on all the classes) on the COVIDx dataset with only 41 epochs. This work presented a computationally efficient and highly accurate model for multi-class classification of three different infection types from along with Normal individuals. This model can help in the early screening of COVID19 cases and help reduce the burden on healthcare systems.

More Papers (from https://www.kaggle.com/c/siim-covid19-detection/discussion/240838)

Source: https://pymed.ai/blog/researches-about-covid-19-chest-x-ray-classification-and-segmentation-with-deep-learning/

X-rays COVID-19 Localization

  1. COVID-19 detection from scarce chest x-ray image data using few-shot deep learning approach
  2. Identification of Images of COVID-19 from Chest X-rays Using Deep Learning: Comparing COGNEX VisionPro Deep Learning 1.0™ Software with Open Source Convolutional Neural Networks
  3. COVID-19 Image Data Collection
  4. CovidCTNet: an open-source deep learning approach to diagnose covid-19 using small cohort of CT images

Common Pitfalls (https://www.kaggle.com/c/siim-covid19-detection/discussion/240639)

Common pitfalls and recommendations for using machine learning to detect and prognosticate for COVID-19 using chest radiographs and CT scans

The above is a link to a peer-reviwed paper recently published in the prestigious journal Nature Machine Intelligence. They examined 2,212 studies published in 2020, of which 415 were included after initial screening and, after quality screening, 62 studies were included in the systematic review.

Unfortunately they found that “…none of the models identified are of potential clinical use due to methodological flaws and/or underlying biases.“

Their main findings were:

  • Duplication and quality issues: Source issues, Frankenstein datasets, Implicit biases in the source data
  • Methodology issues: “…Diagnostic studies commonly compare their models’ performance to that of RT–PCR. However, as the ground-truth labels are often determined by RT–PCR, there is no way to measure whether a model outperforms RT–PCR from accuracy, sensitivity or specificity metrics alone. Ideally, models should aim to match clinicians using all available clinical and radiomic data…”

They then proceed to suggest a number of recommendations. The paper is well worth reading and is Open Access:

Top Solutions

This is an object detection and classification problem.

VinBigData Chest X-ray Abnormalities Detection

Components: Detection models (YOLO-V4 ), Specialized detector for aortic enlargement, Multi-label classifier-based post-processing. Image size 1280.

  • 4th place by @hiraiitsuki

    • model: yolov5x
    • image size: 640
    • TTA: 3 scale patterns and horizontal flip
    • ensemble: (4fold cv * 3 different preprocessed labels ) = 12 models

RSNA Pneumonia Detection Challenge

  • 1st place + code by @vaillant

    • classification-detection pipeline
    • detection: RetinaNet, Deformable R-FCN, Deformable Relation Networks.
    • classification: InceptionResNetV2 , Xception , DenseNet169.
    • Boxes were ensembled using: https://github.com/ahrnbom/ensemble-objdet

  • 2nd place by @dmytropoplavskiy

    • base model: custom RetinaNet (se-resnext101)
    • 512×512 resolution
    • augmentations: Mild rotations (up to 6 deg), shift, scale, shear and h_flip, for some images random level of blur and noise and gamma changes.
    • ensemble: NMS

  • 3rd place + code by @pmcheng

    • base models: RetinaNet (resnet-50 and resnet-101 ) + focal loss
    • 224 x 224 resolution as a abdominal radiologist he considered that high image resolution was not necessary for pneumonia bounding box prediction.
    • augmentations: rotation, translation, scaling, and horizontal flipping + random constants
    • NMS to eliminate any overlapping bounding boxes

SIIM-ACR Pneumothorax Segmentation

  • 1st place + code by @sneddy

    • base models: AlbuNet (resnet34) , Resnet50 , SCSEUnet (seresnext50)
    • Combo loss: combinations of BCE, dice and focal.
    • start with 512×512 and uptrain on size 1024×1024
    • small batch (2-4) size without accumulation
    • detailed tricks on his summary and github

  • 2nd place + code by @lanjunyelan

    • classification and segmentation pipeline.

    • Classification: classify whether an image in related with pneumothorax or not. Multi-task model based on UNET (seresnext 50, seresnext101, efficientnet-b3
      ) with a branch for classifying. BCE + focal loss. Basic augmentation: hflip, scale, rotate, bright, blur

    • Segmentation: 2 base models: unet and deeplabv3. Loss: dice loss. Augmentation: same as classification

  • 3rd place + code by @bestfitting

    • base model UNET (resnet34, se-resnext50)
    • cropped lungs, 576×576 cropped images (1024×1024 initially).
    • Attention: CBAM
    • Loss: Lovasz Los.
    • No classification model, No classification loss

RSNA STR Pulmonary Embolism Detection

Segmentation

  • Unveiling COVID-19 from Chest X-ray with deep learning: a hurdles race with small data Enzo Tartaglione, Carlo Alberto Barbano, Claudio Berzovini, Marco Calandri, Marco Grangetto
    https://arxiv.org/abs/2004.05405
  • A Critic Evaluation of Methods for COVID-19 Automatic Detection from X-Ray Images Gianluca Maguolo, Loris Nanni, https://arxiv.org/abs/2004.12823

Resources :

Research Papers

  1. A Deep Neural Network to Distinguish COVID-19 from other Chest Diseases using X-ray Images ( https://www.mdpi.com/1424-8220/21/2/455/htm)
  2. COVID-CT-MD: COVID-19 Computed Tomography (CT) Scan Dataset Applicable in Machine Learning and Deep Learning (https://paperswithcode.com/paper/covid-ct-md-covid-19-computed-tomography-ct)
  3. CovidGAN: Data Augmentation Using Auxiliary Classifier GAN for Improved Covid-19 Detection (https://ieeexplore.ieee.org/document/9093842)
  4. Synthesis of COVID-19 Chest X-rays using Unpaired Image-to-Image Translation 🙁https://paperswithcode.com/paper/synthesis-of-covid-19-chest-x-rays-using)

Cara Menyambung Python ke MySQL

Kita akan menggunakan package MySQL Connector untuk menyambung Python ke MySQL sehingga kita dapat menjalankan command SQL dalam MySQL melalui Python. Jika package mysql.connector belum diinstall maka install terlebih dahulu dengan menuliskan command ini pada command line:

pip install mysql-connector-python

Buat file Python baru, lalu import mysql.connector: 

import mysql.connector

Buat connection dengan database di MySQL: (ganti variabel sesuai dengan setting data yang ingin diakses)

mydb = mysql.connector.connect(
 host="localhost",
 user="root",
 password="password",
 database="data"
)

Buat sebuah cursor:

mycursor = mydb.cursor()

Jalankan command SQL, misalnya melihat data:

mycursor.execute("select * from data;") 
myresult = mycursor.fetchall()

Hasil data dari perintah command tadi diambil dengan mycursor.fetchall() dan disimpan di variabel myresult. Hasil dapat dilihat dengan print(myresult).

Selain melihat data, kita juga dapat memasukkan data, misalnya:

mycursor.execute("INSERT INTO `data`.`population` (`name`) VALUES (%s)",”John Doe”)
mydb.commit()

Selama mydb.commit() belum dijalankan, data pada SQL tidak akan berubah.

Ketika sudah selesai, jangan lupa untuk menutup connection:

mydb.close()

Serial Console di Ubuntu 20.04

Tidak semua kejadian crash menghasilkan catatan pesan di console Putty. Untuk itu ditambahkan serial console supaya output dari console dapat direkam di komputer lain. Petunjuk menambahkan serial console didapat di artikel “Ubuntu 18.04: GRUB2 and Linux with serial console“

Teknisnya dilakukan dengan mengedit file /etc/default/grub menjadi sebagai berikut:

# If you change this file, run ‘update-grub’ afterwards to update
# /boot/grub/grub.cfg.
# For full documentation of the options in this file, see:
# info -f grub -n ‘Simple configuration’

GRUB_DEFAULT=0
GRUB_TIMEOUT_STYLE=hidden
GRUB_TIMEOUT=0
GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
GRUB_CMDLINE_LINUX_DEFAULT=””
#GRUB_CMDLINE_LINUX=””

# Uncomment to enable BadRAM filtering, modify to suit your needs
# This works with Linux (no patch required) and with any kernel that obtains
# the memory map information from GRUB (GNU Mach, kernel of FreeBSD …)
#GRUB_BADRAM=”0x01234567,0xfefefefe,0x89abcdef,0xefefefef”

# Uncomment to disable graphical terminal (grub-pc only)
#GRUB_TERMINAL=console

# The resolution used on graphical terminal
# note that you can use only modes which your graphic card supports via VBE
# you can see them in real GRUB with the command `vbeinfo’
#GRUB_GFXMODE=640×480

# Uncomment if you don’t want GRUB to pass “root=UUID=xxx” parameter to Linux
#GRUB_DISABLE_LINUX_UUID=true

# Uncomment to disable generation of recovery mode menu entries
#GRUB_DISABLE_RECOVERY=”true”

# Uncomment to get a beep at grub start
#GRUB_INIT_TUNE=”480 440 1″
#
GRUB_CMDLINE_LINUX=”console=tty1 console=ttyS0,115200″
GRUB_TERMINAL=”console serial”
GRUB_SERIAL_COMMAND=”serial –speed=115200 –unit=0 –word=8 –parity=no –stop=1″

Kemudian dilakukan update konfigurai grub dengan aplikasi grub-mkconfig

grub-mkconfig -o /boot/grub/grub.cfg

Setelah itu dilakukan reboot
Output dari serial console diambil dari port COM1, kemudian disambungkan ke USB serial yang terhubung ke sebuah laptop. Di laptop dipakai software Putty sebagai terminal serial. Port COM1 sudah ada di motherboard, namun belum terhubung ke konektor DB9, jadi perlu disambungkan dulu dengan tambahan konektor port serial DB9.

Konektor port serial DB9 untuk COM1 dan COM2
Konektor port serial DB9
Kabel USB ke Serial DB9
Kabel USB ke Serial DB9