bukets
Makine öğrenmesi (ML) modellerinizin ya da yapay zeka (YZ) kodlarınızın “otomatik” olarak çalışmasını sağlamanın pek çok yolu var. Burada temel olarak şu iki senaryoya odaklanabiliriz:
- Düzenli aralıklarla (periyodik) çalıştırma
- Gerçek zamanlı/olaya dayalı tetikleme
Aşağıda her iki yöntemi de nasıl hayata geçirebileceğinize dair hem kavramsal açıklamalar hem de somut örnekler bulacaksınız. Projeniz şu anda localhost’ta çalışıyorsa, ilk etapta lokalde bir “zamanlayıcı” kurmak yeterli olacaktır. Daha sonra isterseniz bunu bir sunucuya (örneğin bir VPS’e veya okulun/işyerinin açık bir sunucusuna) taşıyabilir, sürekli çalışır hale getirebilirsiniz.
1. Düzenli aralıklarla (periyodik) çalıştırma
“Her gün saat 15:00’te model eğitilsin/çıkarım yapılsın” gibi bir ihtiyacınız varsa, en yaygın yöntemler:
- Linux/Unix ortamında cron (crontab) kullanmak
- Windows ortamında Görev Zamanlayıcı (Task Scheduler) kullanmak
- Python içinde APScheduler, schedule, Celery Beat gibi kütüphanelerle içsel zamanlayıcı kurmak
1.1. Linux/Unix üzerinde cron ile periyodik çalıştırma
Eğer projenizi bir Linux dağıtımında (ya da WSL) çalıştırıyorsanız, cron en basit ve hafif çözüm olacaktır. Örnek akış:
Diyelim ki ana uygulamanız run_ml.py adında bir Python dosyası ve çalışma klasörünüz ~/projeler/ml_projesi/.
run_ml.py içinde hem veri hazırlama hem eğitim hem de gerekiyorsa çıktıların kaydedilmesi var. Örneğin:
# run_ml.py
import datetime
def main():
# 1) Veriyi yükle / güncelle
# 2) Modeli eğit (ya da güncel verilerle tahmin yap)
# 3) Çıktıları dosyaya/log dosyasına kaydet
print(f"[{datetime.datetime.now()}] Model çalıştı.")
# Örnek: model.save("model_{:%Y%m%d%H%M}.h5".format(datetime.datetime.now()))
if __name__ == "__main__":
main()
Bash terminalini açıp projenin çalıştığı klasöre gidin:
cd ~/projeler/ml_projesi
run_ml.py dosyasının çalıştırma yetkisi var mı, kontrol edin. Gerekirse:
chmod +x run_ml.py
Sistemde Python yorumlayıcısının tam yolunu öğrenin. Örneğin:
which python3
# çıktı örneği: /usr/bin/python3
crontab -e komutuyla kendi crontab dosyanızı açın. İlk kez açıyorsanız bir editör seçmeniz istenir (nano, vim vb.).
Aşağıdaki satırı ekleyin (örneğin her gün saat 03:00’te çalıştırmak için):
0 3 * * * /usr/bin/python3 /home/kullanici_adiniz/projeler/ml_projesi/run_ml.py >> /home/kullanici_adiniz/projeler/ml_projesi/logs/ml_run.log 2>&1
0 3 * * * → her gün sabah 03:00’te
/usr/bin/python3 → which python3 çıktınıza göre değişebilir
>> .../ml_run.log 2>&1 → hem standart çıktıyı hem de hata çıkışlarını ml_run.log dosyasına yönlendirir
Dosyayı kaydedip kapatın. Böylece cron servisi her gün 03:00’te otomatik olarak run_ml.py’yi çalıştıracak.
Çıktı ve hata kayıtlarını aynı klasör altındaki logs/ml_run.log dosyasından veya sizinkine uygun başka bir log dosyasından takip edebilirsiniz.
Notlar:
- Eğer projenizin bir sanal ortam (virtualenv/venv) içinde çalışması gerekiyorsa, crontab satırında önce sanal ortama (
source ~/projeler/ml_projesi/venv/bin/activate) aktifleştirme, sonra python3 run_ml.py komutunu çalıştırma şeklinde betik de hazırlayabilirsiniz.
- Host’unuzun saati doğru ayarlı değilse,
date komutuyla sistem saatini ve saat dilimini (timezone) kontrol edin. Sizin saat diliminiz Europe/Istanbul olduğuna göre /etc/timezone ya da timedatectl komutlarından “Europe/Istanbul” ayarlı olduğuna emin olun.
1.2. Windows üzerinde Görev Zamanlayıcı (Task Scheduler) kullanmak
Eğer Windows ortamında çalışıyorsanız:
Görev Oluşturma: Başlat menüsünden “Görev Zamanlayıcı” (Task Scheduler) uygulamasını açın.
Sağ tarafta “Görev Oluştur…” (Create Task…) seçeneğine tıklayın.
Genel Sekmesi (General)
Tetikleyiciler Sekmesi (Triggers)
“Yeni…” (New…) butonuna tıklayın.
Göreve hangi sıklıkla başlayacağıyla ilgili ayarları yapın (örneğin: “Her gün”, saat 03:00).
“Tamam” ile çıkın.
Eylemler Sekmesi (Actions)
“Yeni…” (New…) seçin.
“Program/script:” bölümüne Python yorumlayıcınızın yolunu yazın. Örneğin:
C:\Users\KullaniciAdiniz\AppData\Local\Programs\Python\Python39\python.exe
“Add arguments (optional):” kısmına projenizin script yolunu ve gerekirse sanal ortam aktif etme komutunu ekleyin. Örneğin:
"C:\Users\KullaniciAdiniz\projeler\ml_projesi\run_ml.py"
“Start in (optional):” kısmına betiğin bulunduğu klasör yolunu girin, örneğin:
C:\Users\KullaniciAdiniz\projeler\ml_projesi
“Tamam” ile çıkın.
Koşullar (Conditions) / Ayarlar (Settings) sekmelerinde
“Tamam” ile görevi kaydedin. Böylece her gün belirlediğiniz saatte Windows, python run_ml.py komutunu otomatik çalıştıracaktır.
Notlar:
Eğer sanal ortam (venv) kullanıyorsanız, doğrudan python.exe’yi değil, venv içindeki python.exe’yi göstermeniz yeterli olur. Örneğin:
C:\Users\KullaniciAdiniz\projeler\ml_projesi\venv\Scripts\python.exe
Ardından “Add arguments” kısmına run_ml.py yolunu verin.
Log almak isterseniz, run_ml.py’yi çalıştıran küçük bir .bat dosyası oluşturup (“run_ml.bat” gibi) içinde şöyle yazabilirsiniz:
@echo off
cd C:\Users\KullaniciAdiniz\projeler\ml_projesi
venv\Scripts\activate
python run_ml.py > loglar\ml_run_%DATE:~10,4%%DATE:~4,2%%DATE:~7,2%.txt 2>&1
Sonra Task Scheduler’da “Program/script” olarak bu .bat dosyasını gösterirsiniz. Böylece her çalıştırmada loglar klasörünün altına bir tarih damgalı log dosyası oluşturulur.
1.3. Python içinde APScheduler / schedule / Celery Beat gibi kütüphanelerle zamanlayıcı kurmak
Eğer kodunuzun içinden “periyodik” olarak tetikleme yapmak isterseniz, üçüncü parti Python kütüphaneleri de mevcut. En yaygın iki seçenek:
- APScheduler (https://apscheduler.readthedocs.io)
- schedule (https://pypi.org/project/schedule/)
- Celery + Celery Beat (daha ağır bir kuşaktır, dağıtık iş kuyruğu ve planlı görevler için)
Örnek: APScheduler ile her saat başı çalıştırma
Önce sanal ortam içindeyseniz, yükleyin:
pip install APScheduler
run_ml.py dosyanızın içine aşağıdakine benzer bir kod ekleyin (ya da ayrı bir scheduler dosyası oluşturun):
# scheduler.py
from apscheduler.schedulers.blocking import BlockingScheduler
import datetime
import os
import sys
# Eğer venv içindeyseniz, sürekli aynı venv'i kullanmak adına:
# sys.path.append("/path/to/your/venv/lib/python3.x/site-packages")
def ml_task():
# Burada ML/inference/eğitim işinizi çağırın:
print(f"[{datetime.datetime.now()}] ML görevi başladı.")
# Örneğin:
os.system(f"{sys.executable} /home/kullanici/projeler/ml_projesi/train_and_predict.py")
if __name__ == "__main__":
scheduler = BlockingScheduler(timezone="Europe/Istanbul")
# Her gün her saat başı çalıştıralım:
scheduler.add_job(ml_task, 'cron', minute=0)
print("APScheduler başlatıldı, her saat başı ml_task() tetiklenecek.")
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
print("Scheduler durduruldu.")
Terminalden:
python scheduler.py
Bu kod çalıştığı sürece her saat başı ml_task() fonksiyonunu çağıracak. Bu yaklaşımın avantajları:
Tüm zamanlama mantığı kodunuzun içinde, dış bir araca (cron/Task Scheduler) bağımlılık daha az.
Yayımladığınız uygulamayı başka ortama taşırken “aynı kodla” çalışmaya devam edebilir.
Uyarı:
- APScheduler’ı “production” ortamına alacaksanız, genellikle bir process manager (systemd, supervisor) veya Docker +
restart: always gibi yapılandırmalarla arka planda (“daemon” / “service”) çalışacak şekilde konfigüre etmek gerekir. Yoksa terminali kapattığınızda scheduler bitebilir.
2. Gerçek zamanlı / olaya dayalı tetikleme
Eğer YZ kodunuzun belirli bir “olaya” tepki vermesini istiyorsanız (örneğin bir API çağrısı alındığında, veritabanına yeni satır eklendiğinde veya bir dosya yüklenince), periyodik çalıştırma yerine “listener/consumer” mantığı kullanmalısınız. Örnek senaryolar:
- REST API’ye gelen her istekta model çıkarımı yapın
- Veritabanı tetikleyicisi (DB trigger) ile haberdar olurken Python consumer çalıştırın
- Dosya sistemine yeni bir CSV yüklendiğinde otomatik işleme
- MQ (RabbitMQ, Kafka, Redis Streams vb.) kuyruğuna yeni veri geldiğinde işleyici çalıştırın
2.1. Basit bir REST API ile tetikleme
Diyelim ki Flask kullanarak bir API yazdınız, localhost:5000/predict endpoint’i her çağrıldığında ML modeliniz çalışsın ve sonuç dönsün. Örnek:
# app.py
from flask import Flask, request, jsonify
import tensorflow as tf
import datetime
app = Flask(__name__)
# Örn: model = tf.keras.models.load_model("model.h5")
@app.route("/predict", methods=["POST"])
def predict():
veri = request.json["veri"] # JSON içinde "veri" alanı olsun
# 1) Modelle çıkarım yap
# çıktı = model.predict(veri)
çıktı = {"sonuc": "bu bir örnek çıktı"} # örneğin
print(f"[{datetime.datetime.now()}] /predict tetiklendi, çıktı: {çıktı}")
return jsonify(çıktı)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)
Bu durumda:
- Sizin “otomatik” kavramınız, bir client’ın (örneğin başka bir kodun)
POST http://localhost:5000/predict yapmasıyla gerçekleşir.
- Model, her istek geldiğinde “otomatik” olarak devreye girer.
Eğer sunucunuz (Flask uygulaması) arka planda sürekli çalışıyorsa, herhangi bir yerden curl veya başka bir Python script ile:
curl -X POST http://localhost:5000/predict -H "Content-Type: application/json" -d '{"veri":[[5.1,3.5,1.4,0.2]]}'
şeklinde istek atıldığında, modeliniz “otomatik” olarak devreye girer.
Not: Gerçek üretim ortamında Flask’ı doğrudan app.run() ile kullanmak yerine gunicorn veya uWSGI + NGinx gibi bir yapı kullanmak önerilir. Böylece uygulama, istek sayısına göre ölçeklenebilir ve stabil çalışır.
2.2. Dosya tabanlı tetikleme (watchdog ile)
Diyelim her gün okulunuzdaki bir klasöre yeni veriler gelecek ve “yeni veri gelince model eğitilsin” istiyorsunuz. Python’un watchdog kütüphanesini kullanabilirsiniz:
Yükleme:
pip install watchdog
Basit bir takipçi (watcher) betiği:
# file_watcher.py
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import datetime
import os
class MyHandler(FileSystemEventHandler):
def on_created(self, event):
if not event.is_directory and event.src_path.endswith(".csv"):
print(f"[{datetime.datetime.now()}] Yeni CSV geldi: {event.src_path}")
# Burada model eğitimi/çıkarsama/işleme kodunuzu çağırın:
os.system("python run_ml.py")
if __name__ == "__main__":
path = "/home/kullanici/projeler/veri_klasoru"
event_handler = MyHandler()
observer = Observer()
observer.schedule(event_handler, path=path, recursive=False)
observer.start()
print(f"Dosya izleme başladı → {path}")
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
Terminalden:
python file_watcher.py
Bu betik, veri_klasoru altına yeni bir .csv dosyası geldiğinde otomatik olarak run_ml.py’yi çalıştıracaktır.
Not: Benzer şekilde RabbitMQ, Kafka gibi mesaj kuyruğu altyapılarını da kullanabilirsiniz, ama okul projesi için genellikle cron/Task Scheduler veya APScheduler/schedule yeterli olacaktır.
3. Nasıl karar verirsiniz?
Periyodik (zaman bazlı) çalıştırma
- Her gün, her saat, her hafta veya ayda bir vs.
- Örneğin; gün sonu raporu, haftalık model yeniden eğitimi, vs.
- Araçlar:
- Linux:
cron / Windows: Task Scheduler
- Python içi: APScheduler, schedule
Olay bazlı (olduğu anda) çalıştırma
Sürekli arka plan servisi (daemon/service) olarak kalması
Eğer uygulamanın 7/24 açık kalması isteniyorsa, Linux’ta bir systemd servisi yazar veya Docker’da restart: always ile container’ı ayağa kaldırırsınız.
Windows’ta ise “Hizmet (Service)” olarak çalışacak şekilde geliştirilebilir.
4. Adım Adım Öneri (Örnek senaryo: Haftada 1 kez eğitim ve tahmin)
Diyelim ki modelinizi haftada bir Pazar günü saat 02:00’de yeniden eğitmek, ardından güncel verilerle tahmin yapmak istiyorsunuz. İş akışı:
Python script yazın (weekly_job.py):
# weekly_job.py
import datetime
def main():
print(f"[{datetime.datetime.now()}] Haftalık ML görevi başladı.")
# 1) Son verileri çek (DB, CSV vb.)
# 2) Modeli yeniden eğit: train_model()
# 3) Eğitilmiş modeli kaydet: save_model()
# 4) Yeni çıktı/tahmin sonuçlarını CSV veya veritabanına yaz
print(f"[{datetime.datetime.now()}] Haftalık ML görevi tamamlandı.")
if __name__ == "__main__":
main()
Linux cron örneği:
crontab -e
Aşağıyı ekleyin (Pazar 02:00):
0 2 * * 0 /usr/bin/python3 /home/kullanici/projeler/ml_projesi/weekly_job.py >> /home/kullanici/projeler/ml_projesi/logs/weekly_ml.log 2>&1
Windows Task Scheduler örneği:
Görev İsmi: “Haftalık ML Eğitimi”
Tetikleyici: “Haftalık” → Pazar günleri, saat 02:00
Eylem: Program/Script: C:\Python39\python.exe
(İsteğe bağlı) “Eylem > Detaylar” üzerinden “Çıktıları bir dosyaya yönlendir” tarzı bir yapı kuramayacağınız için, .py içinden veya bir .bat dosyası içinden log yazma mantığı eklemelisiniz.
Sonuç:
5. Pratik İpuçları
Sanal ortam (venv/conda): Kodunuzun hangi Python paketlerini kullandığı önemli. Cron/Task Scheduler satırlarında mutlaka o sanal ortamı aktive eden bir betik (.sh/.bat) kullanın veya doğrudan “venv içindeki python.exe” yolunu yazın.
Log tutmak: Hangi adımda ne hata verdi/çıktı ne oldu, hepsini bir log dosyasına yönlendirin. Böylece “neden çalışmadı” sorusuna terminal kapalı olsa bile cevap bulursunuz.
E-posta bildirimleri (opsiyonel): Cron üzerinden “MAILTO” ayarı yaparak, hata mesajı veya çıktı e-postanıza gelebilir. Windows’da ise PowerShell ile e-posta gönderen bir adım ekleyebilirsiniz.
Sistem saat dilimi (timezone): Türkiye için “Europe/Istanbul” ayarlı olduğuna emin olun; aksi halde cron/Task Scheduler farklı zamanlarda tetikleyebilir.
Docker çözümü:
Projenizi bir Docker imajına dönüştürüp (örneğin Dockerfile), sonra docker run -d --restart always … komutuyla arka planda sürekli çalışan bir container’a sahip olabilirsiniz.
İçindeki ENTRYPOINT veya CMD’de APScheduler gibi bir zamanlayıcı başlatabilirsiniz. Bu sayede hem lokalde hem başka bir sunucuda taşınabilir bir çözüm elde edilir.
Dev ortam vs. Prod ortam: Lokalde deneyimleriniz, sunucuya (okulun sunucusu, AWS EC2, GCP VM, DigitalOcean VPS vs.) taşıdığınızda “7/24 çalışan” bir yapı haline gelebilir. Üzerine ek olarak:
Sonuç ve Özet
Soru: “Makine öğrenmesi kodlarımın otomatik olarak çalışmasını istiyorum, mümkün mü?”
Cevap: Evet, mutlaka mümkün. Seçenekler:
- Zaman bazlı tetikleyici (cron / Task Scheduler / APScheduler) – belli aralıklarla kodu çalıştırır.
- Olay bazlı tetikleyici (dosya izler, REST API istekleriyle tetikler) – belli bir “olay” gerçekleşince kodu çalıştırır.
- Sürekli arka plan servisi – içindeki bir döngü veya zamanlayıcı aracılığıyla hep çalışmaya devam eder; bu sayede dışarıdan API/olayla tetikleyebilirsiniz.
Öncelikle kodunuzu tek bir Python script’inde paketleyin (örneğin run_ml.py). Ardından ya cron/Task Scheduler gibi işletim sistemi araçlarını kullanarak “her gün/saat/hafta belli bir zaman” dediğinizde otomatik koşulmasını ayarlayın, ya da kod içinde APScheduler gibi bir kütüphane kullanarak “örneğin her sabah 06:00’te çalışsın” mantığını kurun. İsterseniz yukarıda gösterilen örnekleri doğrudan kendi yol, dosya adı ve Python yorumlayıcınıza uyacak şekilde kopyalayıp yapıştırarak deneyebilirsiniz. Bunların hepsi “localhost” üzerinde de çalışır; daha sonra ihtiyaca göre bir sunucuya taşıyabilirsiniz.
Bu adımları uygulayarak projeniz, siz bilgisayarı açıp script’i manuel çalıştırmadan “otomatik” olarak belirlediğiniz zamanlarda devreye girmiş olacaktır. Kolay gelsin!
