Cara Membuat Aplikasi Face Attendance Menggunakan Python, OpenCV, dan Face Recognition

Pengantar

Sistem absensi merupakan salah satu komponen penting dalam pengelolaan kehadiran karyawan, guru, maupun siswa. Seiring perkembangan teknologi, metode absensi konvensional mulai banyak digantikan oleh sistem otomatis yang lebih cepat, akurat, dan minim risiko kecurangan.

Salah satu teknologi yang banyak digunakan adalah Face Recognition, yaitu teknologi pengenalan wajah yang mampu mengidentifikasi seseorang melalui kamera secara otomatis. Dengan metode ini, proses absensi dapat dilakukan tanpa kontak fisik dan tanpa memerlukan kartu atau tanda tangan manual.

Pada tutorial ini, Anda akan mempelajari cara membangun aplikasi Face Attendance menggunakan Python Flask, Face Recognition, MariaDB, dan Bootstrap di Ubuntu 24.04. Sistem yang dibuat memiliki fitur registrasi dataset wajah, proses absensi otomatis, serta dashboard monitoring berbasis web.

Prasyarat

Sebelum memulai, pastikan VPS atau server telah memenuhi kebutuhan berikut:

Ubuntu 24.04
Python 3.12 atau lebih baru
MariaDB/MySQL
Domain dan SSL (opsional)
Akses root atau sudo

Membuat Database

Membuat Database MariaDB
Masuk ke MariaDB:
```
mysql -u root -p
```
Buat database:
```
CREATE DATABASE face_attendance;
```
Buat user aplikasi:
```
CREATE USER 'face_user'@'localhost'
IDENTIFIED BY 'FaceAttendance123!';
```
Berikan hak akses ke database:
```
GRANT ALL PRIVILEGES
ON face_attendance.*
TO 'face_user'@'localhost';

FLUSH PRIVILEGES;
```
Gunakan database yang telah dibuat:
```
USE face_attendance;
```
Keterangan:
Database ini digunakan untuk menyimpan data pengguna dan riwayat kehadiran yang terdeteksi oleh sistem.

Membuat Tabel Users
Buat tabel untuk menyimpan data pengguna:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    full_name VARCHAR(100) NOT NULL,
    folder_name VARCHAR(100) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Keterangan:
Tabel users digunakan untuk menyimpan identitas pengguna beserta folder dataset wajah yang dimiliki.

Membuat Tabel Attendance

Buat tabel untuk menyimpan data absensi:

CREATE TABLE attendance (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    attendance_date DATE NOT NULL,
    attendance_time TIME NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

    CONSTRAINT fk_attendance_user
    FOREIGN KEY (user_id)
    REFERENCES users(id)
    ON DELETE CASCADE,

    UNIQUE KEY uniq_daily_attendance (
        user_id,
        attendance_date
    )
);

Keterangan:
Tabel attendance digunakan untuk menyimpan riwayat kehadiran dan mencegah absensi ganda pada hari yang sama.

Instalasi Dependensi

Mempersiapkan Lingkungan Python
Perbarui repository dan paket sistem:
```
sudo apt update
sudo apt upgrade -y
```
Install dependensi yang dibutuhkan:
```
sudo apt install python3-pip python3-venv build-essential cmake \
libopenblas-dev liblapack-dev libjpeg-dev -y
```
Buat direktori project:
```
mkdir ~/face-attendance
cd ~/face-attendance
```
Buat virtual environment:
```
python3 -m venv venv
```
Aktifkan virtual environment:
```
source venv/bin/activate
```
Install library Python yang diperlukan:
```
pip install flask
pip install pymysql
pip install pillow
pip install numpy
pip install face-recognition
```
Verifikasi instalasi:
```
python -c "import face_recognition; print('OK')"
```
Contoh output:
```
OK
```
Keterangan:
Library Flask digunakan untuk membangun aplikasi web, sedangkan Face Recognition digunakan untuk mendeteksi dan mengenali wajah pengguna.

Struktur Direktori Proyek

Membuat Struktur Direktori Project
Buat struktur direktori project seperti berikut:
```
face-attendance
├── app.py
├── train.py
├── encodings.pkl
├── dataset
├── templates
│   ├── dashboard.html
│   ├── dataset.html
│   ├── attendance.html
│   └── report.html
├── static
└── venv
```
Buat direktori yang diperlukan:
```
mkdir dataset
mkdir templates
mkdir static
```
Keterangan:
File app.py digunakan sebagai aplikasi utama Flask, train.py digunakan untuk membuat encoding wajah, direktori dataset digunakan untuk menyimpan foto wajah, encodings.pkl digunakan untuk menyimpan hasil training wajah, sedangkan direktori templates berisi halaman dashboard aplikasi.

Download Source Code

Mengunduh Source Code Aplikasi
Untuk mempermudah implementasi, source code lengkap tersedia pada repository GitHub berikut:
```
https://github.com/pwhtuto21/face-attendance
```
Clone repository ke server:
```
git clone https://github.com/pwhtuto21/face-attendance.git
cd face-attendance
```
Keterangan:
Repository ini berisi source code aplikasi Face Attendance, template HTML, script training wajah, dan konfigurasi database yang dibutuhkan.

Menginstal Dependensi Aplikasi
Buat dan aktifkan virtual environment:
```
python3 -m venv venv
source venv/bin/activate
```
Install seluruh library yang dibutuhkan:
```
pip install -r requirements.txt
```
Keterangan:
File requirements.txt berisi seluruh library Python yang diperlukan oleh aplikasi Face Attendance.

Melakukan Training Dataset

Melakukan Training Dataset Wajah
Jalankan proses training wajah:
```
python train.py
```
Contoh output:
```
Memproses: robert
OK -> 1.jpg
OK -> 2.jpg

Selesai. Total encoding: 10
```
Keterangan:
Jika proses berhasil, file encodings.pkl akan dibuat secara otomatis dan digunakan oleh aplikasi untuk mengenali wajah saat proses absensi.

Menjalankan Aplikasi

Menjalankan Aplikasi
Jalankan aplikasi Flask:
```
python app.py
```
Jika berhasil, akan muncul output seperti berikut:
```
* Running on http://0.0.0.0:5000
```
Buka browser dan akses:
```
http://IP-SERVER:5000
```
Keterangan:
Jika halaman dashboard berhasil ditampilkan, berarti aplikasi Face Attendance telah berjalan dengan baik dan siap digunakan.

Menjalankan Sebagai Service dan Mengakses Dashboard

Membuat Service Systemd
Agar aplikasi berjalan otomatis setelah server reboot, buat file service berikut:

nano /etc/systemd/system/face-attendance.service

Masukkan konfigurasi service sesuai project yang digunakan.

[Unit]
Description=Face Attendance Flask Application
After=network.target

[Service]
User=root
WorkingDirectory=/root/face-attendance
ExecStart=/root/face-attendance/venv/bin/python /root/face-attendance/app.py
Restart=always

[Install]
WantedBy=multi-user.target

Reload konfigurasi systemd:

systemctl daemon-reload

Aktifkan service saat booting:

systemctl enable face-attendance

Jalankan service:

systemctl start face-attendance

Verifikasi status service:

systemctl status face-attendance

Contoh output:

● face-attendance.service - Face Attendance Flask Application
     Loaded: loaded
     Active: active (running)

Keterangan:
Dengan menggunakan systemd, aplikasi Face Attendance akan berjalan di background dan otomatis aktif kembali setelah server direstart.

Mengakses Dashboard Aplikasi
Setelah aplikasi berhasil dijalankan, buka browser dan akses:
```
http://IP-SERVER:5000
```
Apabila menggunakan reverse proxy dan SSL, aplikasi dapat diakses melalui domain:
```
https://absen.domainanda.com
```
Dashboard aplikasi menyediakan tiga menu utama:

Dataset
• Menambahkan pengguna baru.
• Mengambil foto wajah sebagai dataset.
• Menyimpan data wajah untuk proses training.

Attendance
• Melakukan deteksi wajah secara real-time.
• Mengenali identitas pengguna.
• Mencatat absensi secara otomatis ke database.

Report
• Menampilkan riwayat kehadiran.
• Melihat data absensi berdasarkan tanggal.
• Melakukan monitoring kehadiran pengguna.

Keterangan:
Dashboard menjadi pusat pengelolaan seluruh fitur Face Attendance mulai dari pendaftaran pengguna hingga pemantauan laporan kehadiran.

Kesimpulan

Face Recognition merupakan salah satu teknologi Computer Vision yang dapat dimanfaatkan untuk membangun sistem absensi modern yang lebih cepat, praktis, dan akurat. Dengan memanfaatkan Python Flask, Face Recognition, dan MariaDB, proses registrasi pengguna, pengenalan wajah, pencatatan kehadiran, hingga penyajian laporan dapat dilakukan secara otomatis melalui dashboard berbasis web.

Melalui panduan ini, Anda telah mempelajari cara membangun aplikasi Face Attendance di Ubuntu 24.04 mulai dari persiapan lingkungan Python, konfigurasi database, proses training dataset wajah, hingga menjalankan aplikasi sebagai service systemd. Untuk mempermudah implementasi, source code lengkap proyek Face Attendance dapat diunduh melalui repository GitHub dan langsung digunakan sesuai kebutuhan pengembangan.