İnsanlık tarihi boyunca bitkiler, hastalıkların tedavisinde ve sağlığın korunmasında temel biyolojik kaynaklardan biri olmuştur. Tıbbi bitkilerin kullanımı, M.Ö. 2000’lerden günümüze uzanan süreçte, ampirik gözlemlere dayalı geleneksel uygulamalardan modern bilimsel yaklaşımlara doğru değişmiştir. İnsanın bitkileri tedavi amacıyla kullanımı, yazılı tarihten çok daha önceye dayanmaktadır. Kuzey Irak’taki Şanidar Mağarası’nda bulunan yaklaşık 60.000 yıl öncesine ait mezarlarda civanperçemi, kanarya otu ve ebegümeci gibi tıbbi bitkilerin varlığı, fitoterapinin insanlık tarihi kadar eski olduğunu göstermektedir. Tarihsel süreçte, basit bitkisel uygulamalarla başlayan tedavi anlayışı, zamanla dini ritüeller, iksirler, farmasötik preparatlar ve antibiyotiklerin geliştirilmesiyle çeşitlenmiş; günümüzde ise doğal kaynaklara yönelik ilginin yeniden artmasıyla birlikte, fitoterapi modern bilimsel yöntemlerle yeniden yapılandırılmaya başlanmıştır. 21. yüzyılda yapay zeka, veri analizi ve mikrodenetleyici tabanlı gömülü sistemlerdeki gelişmeler, fitoterapinin bilimsel temellerinin güçlendirilmesi ve klinik uygulamalarının optimize edilmesi açısından önemli olanaklar sunmaktadır.
Modern Dönemde Fitoterapi
Dünya Sağlık Örgütü (WHO) verilerine göre, gelişmekte olan ülkelerdeki nüfusun %80'i temel sağlık ihtiyaçları için bitkisel kökenli geleneksel ilaçlara bağımlıdır. Gelişmiş ülkelerde ise tamamlayıcı tıp kapsamında bitkisel ürün kullanımında hızlı bir artış gözlenmektedir. Küresel bitkisel tıbbi ürün pazarının 2027 yılında 230.73 milyar dolara ulaşması beklenmektedir. Ancak, bitkisel ilaçların yaygın kullanımı beraberinde önemli sorunları da getirmektedir:
- Standardizasyon eksikliği
- Yan etki ve etkileşim profillerinin yetersiz dokümantasyonu
- Kalite kontrol problemleri
- Bilimsel kanıt düzeyinin düşüklüğü
- Tekrarlanabilir sonuçların alınamaması
Bu sorunların çözümünde, modern teknolojilerin entegrasyonu kritik önem taşımaktadır.
ETNOBOTANİK: BİTKİSEL İLAÇLARIN TEMELİ
Etnobotanik Tanımı ve Kapsamı
Etnobotanik terimi, 1895 yılında biyoloji profesörü John W. Harshberger tarafından "yerli halkın bitki kullanımı" olarak tanımlanmıştır. Günümüzde etnobotanik, "bir yörede yaşayan halkın, yakın çevresinde bulunan bitkilerden çeşitli gereksinimlerini karşılamak üzere yararlanma bilgisi ve bitkilerin etkileri" şeklinde tanımlanmaktadır.
Etnobotanik çalışmaların temel amaçları:
- Geleneksel bilginin dokümantasyonu
- Bilimsel değerlendirme için veri tabanı oluşturma
- Kültürel mirasın korunması
- Yeni ilaç adaylarının keşfi
- Sürdürülebilir kullanım stratejilerinin geliştirilmesi
Etnobotanik Araştırma Metodolojisi
Etnobotanik araştırmalar, multidisipliner bir yaklaşım gerektirir ve şu aşamaları içerir:
Saha Çalışmaları
- Mevsimsel çalışmalar: Farklı vejetasyon dönemlerinde gerçekleştirilmelidir
- Bilgi toplama teknikleri:
- Yapılandırılmış görüşmeler
- Kısmi yapılandırılmış görüşmeler
- Yapılandırılmamış görüşmeler
- Katılımcı gözlem
- Serbest listeleme
Botanik Dokümantasyon
- Şahit örneklerin toplanması
- Herbaryum örneklerinin hazırlanması
- Bilimsel teşhis ve taksonomik sınıflandırma
- Binominal isimlendirme sistemi
Kritik İlke: Bilimsel olarak teşhis edilemeyen bitkilere ait etnobotanik bilgiler eksik kabul edilir. Herbaryum örneği olmayan çalışmalar bilimsel değerlendirmeye uygun değildir.
Veri Yönetimi ve Analizi
Geleneksel yöntemler:
- Elle tutulmuş kayıtlar
- Fotoğraf dokümantasyonu
- Ses kayıtları
Modern yaklaşım:
Toplanan etnobotanik verilerin dijital ortama aktarılması ve veri analizi teknikleriyle işlenmesi, araştırmaların etkinliğini önemli ölçüde artırmaktadır.
Veri Analizi Uygulamaları:
Python
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
Etnobotanik veri seti örneği
data = pd.DataFrame({
'bitki_adi': ['Salvia officinalis', 'Melissa officinalis', 'Thymus vulgaris'],
'kullanim_sikliği': [45, 38, 52],
'etkinlik_skoru': [4.2, 3.8, 4.5],
'yan_etki_raporu': [2, 1, 3]
})
Kümeleme analizi ile benzer kullanım profillerinin belirlenmesi
kmeans = KMeans(n_clusters=2, random_state=42)
data['cluster'] = kmeans.fit_predict(data[['kullanim_sikliği', 'etkinlik_skoru']])
Görselleştirme
plt.scatter(data['kullanim_sikliği'], data['etkinlik_skoru'],
c=data['cluster'], cmap='viridis')
plt.xlabel('Kullanım Sıklığı')
plt.ylabel('Etkinlik Skoru')
plt.title('Etnobotanik Veri Kümeleme Analizi')
plt.show()
Bu yaklaşım, büyük veri setlerinde örüntü tanıma, trend analizi ve istatistiksel değerlendirme yapılmasına olanak tanır.
Türkiye'nin Etnobotanik Zenginliği
Türkiye, üç fitocoğrafik bölgenin (İran-Turan, Akdeniz, Avrupa-Sibirya) kesişiminde yer alması nedeniyle olağanüstü bir bitki çeşitliliğine sahiptir:
İstatistiksel Veriler:
- Toplam bitki taksonu: ~12.500
- Endemik takson: ~4.000 (%33)
- Tıbbi amaçla kullanılan tür: >1.000
- Ticareti yapılan tür: ~400
Karşılaştırmalı Analiz:
| Ülke | Bitki Türü Sayısı | Endemik Tür Sayısı |
|------|-------------------|-------------------|
| Türkiye | 12.500 | 4.000 |
| İtalya | 5.600 | - |
| Yunanistan | 5.000 | 800 |
| İspanya | 5.000 | - |
| Fransa | 4.500 | - |
| Almanya | 2.500 | - |
| İsviçre | - | 1 |
Bu zenginlik, etnobotanik araştırmalar ve yeni ilaç keşfi için muazzam bir potansiyel sunmaktadır.
BİTKİSEL DROGLAR: TANIMLANMA VE KARAKTERİZASYON
Morfolojik ve Anatomik İnceleme
Bitkisel drogların doğru tanımlanması, etkin ve güvenli kullanımın temel koşuludur.
Makroskopik İnceleme (Organoleptik Özellikler)
Beş duyu organımızla yapılan ilk değerlendirme:
- Görünüş: Renk, büyüklük, şekil
- Doku: Kırılma yüzeyi, yüzey özellikleri
- Koku: Karakteristik aromalar
- Tat: Acılık, burukluluk (dikkatle!)
Örnek Değerlendirme:
Salvia officinalis (Tıbbi Adaçayı)
- Renk: Yeşil-gri
- Yüzey: İnce tüylü
- Koku: Aromatik, kamfor benzeri
- Tat: Hafif acı, buruk
Mikroskopik İnceleme
Kesin tanımlama ve saflık kontrolü için mikroskobik özellikler kritiktir:
İncelenen Yapılar:
- Epiderma: Hücre şekli, kutikula, stomalar
- Tüyler: Örtü ve salgı tüyleri
- Kristaller: Kalsiyum oksalat formları (druz, rafit, sfenoit)
- Nişasta: Hilum şekli, halka yapısı
- Sekonder metabolitler: Uçucu yağ salgı organları
Örnek: Adaçayı Tür Ayırımı
Salvia officinalis ve Salvia triloba mikroskobik olarak örtü tüylerinin taban hücre sayısı ile ayırt edilebilir:
- S. officinalis: 2 taban hücreli
- S. triloba: 3-4 taban hücreli
Dijital Morfoloji ve Görüntü İşleme
Modern yaklaşımlar, görüntü işleme ve AI teknikleriyle mikroskobik analizi otomatize edebilmektedir:
python
import cv2
import numpy as np
from tensorflow import keras
Mikroskop görüntüsü yükleme
image = cv2.imread('adacayi_tuy.jpg')
Ön işleme
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5,5), 0)
Kenar tespiti
edges = cv2.Canny(blur, 50, 150)
Kontur bulma
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
Taban hücre sayma
taban_hucresi_sayisi = len(contours)
AI tabanlı sınıflandırma modeli
model = keras.models.load_model('salvia_classifier.h5')
prediction = model.predict(np.expand_dims(image, axis=0))
if prediction > 0.5:
tur = "Salvia officinalis"
else:
tur = "Salvia triloba"
print(f"Tespit edilen tür: {tur}")
print(f"Taban hücresi sayısı: {taban_hucresi_sayisi}")
Bu yaklaşım, analiz süresini kısaltır, insan hatasını minimize eder ve büyük ölçekli tarama çalışmalarını mümkün kılar.
Drog Hazırlama ve Standartizasyon
Toplama
Optimal Toplama Zamanları:
- Yapraklar: Çiçeklenme başlangıcı
- Çiçekler: Tam açılmadan önce
- Toprak altı kısımları: Toprak üstü kısımlar kuruduktan sonra
- Kabuklar: Yaprak döküm sonrası
- Meyve/tohumlar: Olgunlaşma sonrası
Faktörler:
- Mevsim
- Günün saati (uçucu yağlarda kritik)
- Hava koşulları
- Bitkinin gelişim evresi
Kurutma
Yöntemler:
- Güneşte kurutma
- Avantaj: Ekonomik
- Dezavantaj: Renk kaybı, uçucu yağ kaybı
- Uygun: Kök ve rizomlar - Gölgede kurutma
- Avantaj: Kalite korunumu
- Dezavantaj: Uzun süre
- Uygun: Yaprak ve çiçekler - Kontrollü sıcaklıkta kurutma
- Avantaj: Hızlı, enzimatik bozunmayı minimize eder
- Dezavantaj: Enerji maliyeti
- Kritik sıcaklık aralığı: 35-50°C'de minimum süre
Hedef nem içeriği: %10-12
Sensör Tabanlı Kurutma İzleme Sistemi:
cpp
// Arduino tabanlı nem ve sıcaklık izleme
#include
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(9600);
dht.begin();
}
void loop() {
float nem = dht.readHumidity();
float sicaklik = dht.readTemperature();
// Kritik koşul kontrolü
if (sicaklik > 35 && sicaklik < 50) {
Serial.println("Optimal kurutma sıcaklığı");
} else if (sicaklik > 50) {
Serial.println("UYARI: Sıcaklık çok yüksek! Enzimatik aktivite artabilir.");
}
if (nem < 12) {
Serial.println("Hedef nem seviyesine ulaşıldı. Kurutma tamamlandı.");
}
// Veri logu
Serial.print("Sıcaklık: "); Serial.print(sicaklik);
Serial.print("°C, Nem: "); Serial.print(nem); Serial.println("%");
delay(60000); // 1 dakika
}
Bu sistem, gerçek zamanlı izleme, uyarı sistemi ve veri kaydı sağlayarak kurutma sürecini optimize eder.
Saklama
Kritik Faktörler:
- Işık: Fotodegradasyonu önlemek için karanlık ortam
- Sıcaklık: Serin (tercihen 15-25°C)
- Nem: Düşük (<%12)
- Hava: Oksidasyonu minimize etmek için hava geçirmez ambalaj
Örnek: Stabilite Verisi
Taxus baccata yapraklarında taksolün degradasyonu:
- Oda sıcaklığı (1 yıl): %30-40 kayıp
- Oda sıcaklığı (>1 yıl): %70-80 kayıp
- -18°C (uzun dönem): Belirgin kayıp
IoT Tabanlı Depo İzleme Sistemi:
python
Raspberry Pi + Sensörler
import time
import board
import adafruit_dht
import sqlite3
from datetime import datetime
Sensör başlatma
dht_device = adafruit_dht.DHT22(board.D4)
Veritabanı bağlantısı
conn = sqlite3.connect('drog_depo.db')
cursor = conn.cursor()
Tablo oluşturma
cursor.execute('''CREATE TABLE IF NOT EXISTS olcumler
(tarih TEXT, sicaklik REAL, nem REAL, uyari TEXT)''')
def veri_oku_ve_kaydet():
try:
sicaklik = dht_device.temperature
nem = dht_device.humidity
uyari = ""
if sicaklik > 25:
uyari += "Yüksek sıcaklık! "
if nem > 12:
uyari += "Yüksek nem! "
Veritabanına kayıt
cursor.execute("INSERT INTO olcumler VALUES (?, ?, ?, ?)",
(datetime.now().isoformat(), sicaklik, nem, uyari))
conn.commit()
print(f"Sıcaklık: {sicaklik}°C, Nem: {nem}%, Uyarı: {uyari}")
except RuntimeError as error:
print(f"Okuma hatası: {error.args[0]}")
Ana döngü
while True:
veri_oku_ve_kaydet()
time.sleep(300) # 5 dakika
Bu sistem, depolama koşullarının sürekli izlenmesini, anormal durumların tespitini ve uzun dönem veri analizini mümkün kılar.
4. FİTOKİMYA: BİTKİSEL İLAÇLARIN KİMYASAL TEMELİ
4.1. Sekonder Metabolitler: Sınıflandırma ve Biyosentez
Bitkiler, birincil metabolitlerin (şekerler, amino asitler, yağlar) yanı sıra, karmaşık biyosentetik yolaklardan oluşan sekonder metabolitler sentezlerler. Sekonder metabolitler, bitkilerin ekolojik adaptasyonunda, savunmasında ve insan sağlığında kritik roller oynar.
4.1.1. Terpenoitler (İzoprenoitler)
Temel Yapı: İzopentenil pirofosfat (IPP) ve dimetilallil pirofosfat (DMAPP) üniteleri
Sınıflandırma:
- Hemiterpenler (C5)
- Monoterpenler (C10) - Uçucu yağlar
- Seskiterpenler (C15) - Seskiterpen laktonlar
- Diterpenler (C20) - Giberellinler, taksol
- Sesterterpenler (C25)
- Triterpenler (C30) - Saponinler, steroller
- Tetraterpenler (C40) - Karotenler
- Politerpenler (>C40) - Kauçuk
Farmakolojik Önemi:
- Monoterpenler:
- α-Tujon (Artemisia absinthum): Halüsinojen, GABA reseptör modülatörü
- Mentol (Mentha sp.): Analjezik, antiprüritik - Seskiterpen Laktonlar:
- Artemisinin (Artemisia annua): Antimalaryal (WHO Temel İlaç Listesi)
- Parthenolid (Tanacetum parthenium): Antienflamatuvar, migren profilaksisi - Diterpenler:
- Taksol (Taxus brevifolia): Antineoplastik (over, meme kanseri)
- Forskolin (Coleus forskohlii): Adenilat siklaz aktivatörü - Triterpenler:
- Glikozitli triterpenler (saponinler): Hipoglisemik, hipokolesterolemik
- Ginseng saponinleri: Adaptojenik, nöroprotektif - Tetraterpenler (Karotenler):
- β-Karoten: A vitamini prekürsörü
- Likopen: Antioksidan, prostat kanseri koruması
Biyosentez Yolakları:
İki major yolak: - Mevalonat Yolağı (sitozolik) → Seskiterpenler, triterpenler, steroller
- Non-mevalonat (MEP/DOXP) Yolağı (plastidial) → Monoterpenler, diterpenler, karotenler
python
Terpenoit biyosentez simülasyonu (basitleştirilmiş)
class TerpenoidBiosynthesis:
def __init__(self):
self.IPP = 1
self.DMAPP = 1
def prenyl_transferase(self, n_units):
"""n adet C5 ünitesinin birleşimi"""
carbon_count = 5 * n_units
if n_units == 2:
product = "Monoterpen (C10)"
elif n_units == 3:
product = "Seskiterpen (C15)"
elif n_units == 4:
product = "Diterpen (C20)"
elif n_units == 6:
product = "Triterpen (C30)"
elif n_units == 8:
product = "Tetraterpen (C40)"
else:
product = f"Terpenoit (C{carbon_count})"
return product
def monoterpene_synthase(self, substrate="Geranyl-PP"):
"""Monoterpen sentaz aktivitesi"""
products = ["Linalool", "Limonene", "Pinene", "Myrcene"]
import random
return random.choice(products)
Kullanım
biosynthesis = TerpenoidBiosynthesis()
print(biosynthesis.prenyl_transferase(2)) # Monoterpen (C10)
print(biosynthesis.monoterpene_synthase()) # Rastgele monoterpen
4.1.2. Alkaloitler
Tanım: Azot içeren, genellikle bazik, farmakolojik olarak aktif bitkisel bileşikler
Biyosentetik Köken: Amino asitler (triptofan, tirozin, fenilalanin, lisin, ornitin)
Sınıflandırma (Heterosiklik halka sistemine göre):
- Pirolidin (nikotin, hygrin)
- Pirolizidin (senesifonin) - Hepatotoksik
- Piridin (nikotin, anatabine)
- Kinolin (kinin, kindin)
- İzokinolin (morfin, kodein, papaverin, berberin)
- İndol (reserpin, vinkristin, vinblastin, psilocibin)
- İmidazol (pilokarpin)
- Pürin (kafein, teobromin, teofilin)
- Tropon (atropin, skopolamin, kokain)
- Steroidal (solanin, konessine)
Farmakolojik Kategoriler:
- Analjezikler:
- Morfin (Papaver somniferum): μ-opioid reseptör agonisti
- Kodein: Antitussive - Antimalaryal:
- Kinin (Cinchona sp.): Shizontozid - Antikanser:
- Vinkristin, Vinblastin (Catharanthus roseus): Mikrotübül inhibitörleri
- Kamptotesin (Camptotheca acuminata): Topoizomeraz I inhibitörü - Antimuskarinikler:
- Atropin (Atropa belladonna): Midriyatik, antispazmodik
- Skopolamin: Antiemetik (hareket hastalığı) - Kolinerjikler:
- Pilokarpin (Pilocarpus jaborandi): Glokom tedavisi - Kardiyak:
- Reserpin (Rauwolfia serpentina): Antihipertansif - Santral Sinir Sistemi Stimülanları:
- Kafein (Coffea arabica): Adenozin reseptör antagonisti
- Efedrin (Ephedra sinica): Sempatomiminetik
Toksisite Örnekleri:
- Pirolizidin alkaloitler (Senecio, Heliotropium): Hepatotoksik, venooklüziv hastalık
- Akonitum alkaloitleri (Aconitum sp.): Kardiyotoksik
- Konine (Conium maculatum): Nörotoksik (Sokrates'in zehri)
AI Destekli Alkaloit Aktivite Tahmini:
python
from rdkit import Chem
from rdkit.Chem import Descriptors, AllChem
from sklearn.ensemble import RandomForestClassifier
import numpy as np
Alkaloit veri seti (SMILES formatında)
alkaloids = {
'morphine': 'CN1CC[C@]23[C@@H]4[C@H]1CC5=C2C(=C(C=C5)O)O[C@H]3[C@H](C=C4)O',
'codeine': 'COc1ccc2c(c1O)[C@@H]3N(CC[C@]24[C@@H]3CC=C4)C',
'caffeine': 'CN1C=NC2=C1C(=O)N(C(=O)N2C)C'
}
Aktivite etiketleri (1: analjezik, 0: stimülan)
activities = {'morphine': 1, 'codeine': 1, 'caffeine': 0}
def calculate_features(smiles):
"""Moleküler tanımlayıcılar hesaplama"""
mol = Chem.MolFromSmiles(smiles)
features = [
Descriptors.MolWt(mol),
Descriptors.MolLogP(mol),
Descriptors.NumHDonors(mol),
Descriptors.NumHAcceptors(mol),
Descriptors.TPSA(mol)
]
return features
Özellik matrisi oluşturma
X = np.array([calculate_features(smiles) for smiles in alkaloids.values()])
y = np.array([activities[name] for name in alkaloids.keys()])
Model eğitimi
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)
Yeni alkaloit tahmini
new_alkaloid_smiles = 'CC(C)C[C@H]1NC(=O)[C@H](CC2=CC=CC=C2)NC(=O)[C@@H]3CCCN3C(=O)[C@H](CC(=O)N)NC1=O'
new_features = np.array([calculate_features(new_alkaloid_smiles)])
prediction = clf.predict(new_features)
print(f"Tahmin edilen aktivite: {'Analjezik' if prediction[0] == 1 else 'Stimülan'}")
Bu tip modeller, yeni alkaloit yapılarının aktivite profillerini ön değerlendirme aşamasında tahmin ederek ilaç geliştirme sürecini hızlandırabilir.
4.1.3. Fenolik Bileşikler
Tanım: Aromatik halka(lar) üzerinde bir veya daha fazla hidroksil grubu taşıyan bileşikler
Biyosentetik Köken:
- Şikimik asit yolağı
- Fenilpropanoit yolağı
- Asetat-malonat (poliketit) yolağı
Major Sınıflar:
A. Flavonoitler (C6-C3-C6)
Temel Yapı: İki benzen halkası (A ve B) + heterosiklik oksijen içeren C halkası
Alt Sınıflar:
- Flavonlar (örn. apigenin, luteolin)
- C3 pozisyonunda oksijenasyon yok
- Antiinflamatuvar, antioksidan - Flavonoller (örn. kersetin, kemferol, mirisetin)
- C3-OH grubu
- En yaygın flavonoit sınıfı
- Kardiyovasküler koruma - Flavan-3-oller (örn. kateşin, epikateşin)
- Monomerler → Proantosiyanidinler (kondanse tanenler)
- Yeşil çay, kakao, kırmızı şarap - İzoflavonlar (örn. genistein, daidzein)
- B halkası C3'te (3-fenilkromon)
- Fitoöstrojenler
- Soya fasulyesi - Flavanonlar (örn. hesperetin, naringenin)
- C2-C3 doymuş
- Turunçgil meyveleri - Antosiyaninler (örn. sianidin, delfinidin)
- Flavylium iyonu
- Kırmızı-mavi pigmentler
Farmakolojik Aktiviteler:
- Antioksidan: Radikal süpürücü aktivite (OH grupları)
- Antiinflamatuvar: COX/LOX inhibisyonu
- Antitrombotik: Trombosit agregasyon inhibisyonu
- Kardiyoprotektif: Endotel fonksiyonu iyileştirme
- Antikanserojenik: Karsinojen detoksifikasyonu, apoptoz indüksiyonu
- Nöroprotektif: BDNF artışı, Alzheimer koruması
Örnek: Kersetin (Quercetin)
Soğan, elma, çay, kırmızı şarapta zengin:
- Güçlü antioksidan (askorbik asitten 5x güçlü)
- Antihistaminik (mast hücre stabilizasyonu)
- Antiinflamatuvar (NF-κB inhibisyonu)
- Antiviral (COVID-19 araştırmaları)
Kersetin-COVID-19 İlişkisi - Moleküler Docking Simülasyonu:
python
from Bio.PDB import PDBParser
from scipy.spatial import distance
import numpy as np
Basitleştirilmiş docking skoru hesaplama
class SimpleDocking:
def __init__(self, protein_pdb, ligand_coords):
self.protein = protein_pdb
self.ligand = ligand_coords
def calculate_binding_energy(self):
"""Basitleştirilmiş bağlanma enerjisi"""
Gerçek docking çok daha komplekstir
Bu örnek kavramsal amaçlıdır
Van der Waals etkileşimi (mesafe bazlı)
distances = []
for atom in self.protein:
dist = distance.euclidean(atom, self.ligand)
distances.append(dist)
avg_distance = np.mean(distances)
Basitleştirilmiş enerji skoru
binding_energy = -1 / avg_distance * 10 # Negatif = kararlı
return binding_energy
def predict_activity(self, threshold=-5.0):
"""Aktivite tahmini"""
energy = self.calculate_binding_energy()
if energy < threshold:
return "Güçlü bağlanma - Potansiyel aktif"
else:
return "Zayıf bağlanma - Düşük aktivite"
Örnek kullanım
protein_atoms = np.random.rand(100, 3) # SARS-CoV-2 Mpro
quercetin_position = np.array([0.5, 0.5, 0.5])
docking = SimpleDocking(protein_atoms, quercetin_position)
print(f"Bağlanma enerjisi: {docking.calculate_binding_energy():.2f} kcal/mol")
print(docking.predict_activity())
B. Non-Flavonoit Fenolikler
- Fenolik Asitler:
- Hidroksibenzoatlar (C6-C1): Gallik asit, protokateşuik asit
- Hidroksisinamatlar (C6-C3): Kafeik asit, ferulik asit, p-kumarik asit
Kafeik Asit Feniletil Ester (CAPE):
- Arı tutkalı (propolis) bileşeni
- Güçlü antiinflamatuvar (NF-κB↓)
- Antineoplastik - Stilbenler (C6-C2-C6):
- Resveratrol (Vitis vinifera, Polygonum cuspidatum)
- SIRT1 aktivatörü → uzun ömür
- Kardiyoprotektif
- Antidiyabetik
- Nöroprotektif - Lignanlar:
- Fitoöstrojenler
- Sekoizolarisirezinol (keten tohumu) → enterolakton/enterodiol
- Meme kanseri koruması - Kumarinler:
- Kumarin: Tatlı tere (Melilotus)
- Warfarin: Antikoagülan (vitamin K antagonisti)
- Psoralenler: Fotosensitize edici (PUVA tedavisi) - Tanenler:
a) Hidrolize Edilebilen Tanenler:
- Gallotanenler (gallik asit esterleri)
- Elajitanenler (elajik asit türevleri)
b) Kondanse Tanenler (Proantosiyanidinler):
- Flavan-3-ol polimerleri
- Astrenjan (buruk) tat
- Protein bağlama (enzim inhibisyonu)
Tanenler - İlaç Etkileşimi:
Yüksek tanen içeren gıdalar (çay, kırmızı şarap, nar) bazı ilaçların biyoyararlanımını azaltabilir:
- Demir emilimi ↓
- Tiamin bağlanması
- Bazı antibiyotiklerin emilimi ↓
Gerçek Zamanlı Tanen-İlaç Etkileşim İzleme:
cpp
// Arduino + Spektrofotometre sensörü ile tanen-protein kompleksi izleme
#include
// AS7262 6-Kanal Spektral Sensör (Visible)
#define SENSOR_ADDR 0x49
float baseline_absorbance[6];
float current_absorbance[6];
void setup() {
Serial.begin(9600);
Wire.begin();
// Başlangıç ölçümü (sadece ilaç)
measure_baseline();
}
void loop() {
// Tanen eklendikten sonra ölçüm
measure_current();
// Kompleks oluşum analizi
float complex_formation = calculate_complexation();
if (complex_formation > 0.3) {
Serial.println("UYARI: Yüksek tanen-ilaç kompleksi!");
Serial.println("İlaç biyoyararlanımı azalabilir.");
}
delay(60000); // 1 dakika
}
void measure_baseline() {
// 6 dalga boyunda (450, 500, 550, 570, 600, 650 nm) absorbans ölçümü
for (int i = 0; i < 6; i++) {
baseline_absorbance[i] = read_channel(i);
}
}
void measure_current() {
for (int i = 0; i < 6; i++) {
current_absorbance[i] = read_channel(i);
}
}
float calculate_complexation() {
float total_change = 0;
for (int i = 0; i < 6; i++) {
total_change += abs(current_absorbance[i] - baseline_absorbance[i]);
}
return total_change / 6.0;
}
float read_channel(int channel) {
// Sensör okuma fonksiyonu (basitleştirilmiş)
Wire.beginTransmission(SENSOR_ADDR);
Wire.write(channel);
Wire.endTransmission();
Wire.requestFrom(SENSOR_ADDR, 2);
int reading = Wire.read() << 8 | Wire.read();
return reading / 1000.0;
}
4.1.4. Kükürt Bileşikleri
İki Major Sistem:
A. Glukosinolat-Miyrozinaz Sistemi (Brassicaceae)
Glukosinolatlar:
- β-thioglikozit-N-hidroksisülfatlar
- >200 farklı yapı
Hidroliz Ürünleri:
- İzotiyosiyanatlar (ITC): Keskin tat
- Tiyosiyanatlar
- Nitril
- Epitiyonitriller
Örnek:
Brokoli: Glukorafanin → (Miyrozinaz) → Sülforafan (ITC)
Sülforafanın Etkileri: - Faz II Detoksifikasyon Enzim İndüksiyonu:
- Glutatyon S-transferaz ↑
- NAD(P)H:kinon oksidoredüktaz (NQO1) ↑
- Nrf2 transkripsiyon faktörü aktivasyonu - Antikanserojenik Mekanizmalar:
- Karsinojen detoksifikasyonu
- Histon deasetilaz (HDAC) inhibisyonu
- Apoptoz indüksiyonu
- Hücre döngüsü durması - Antiinflamatuvar:
- NF-κB inhibisyonu - Antimikrobiyal:
- Helicobacter pylori inhibisyonu
B. Alliin-Alliinaz Sistemi (Alliaceae)
Alliaceae (Allium) Bitkileri:
- Sarımsak (A. sativum)
- Soğan (A. cepa)
- Pırasa (A. porrum)
Biyokimya:
Alliin (S-allil-L-sistein sülfoksit) → (Alliinaz) → Allisiin (dialil tiyosülfinat)
Allisiin → Çeşitli organosülfür bileşikleri:
- Dialil sülfit (DAS)
- Dialil disülfit (DADS)
- Dialil trisülfit (DATS)
- Ajoene
Farmakolojik Aktiviteler: - Kardiyovasküler:
- Platelet agregasyon inhibisyonu
- LDL oksidasyonu ↓
- Kolesterol sentezi ↓ (HMG-CoA redüktaz inhibisyonu)
- Kan basıncı ↓ (NO sentezi ↑) - Antikanser:
- Faz II enzim indüksiyonu
- Apoptoz indüksiyonu
- Angiogenez inhibisyonu - Antimikrobiyal:
- Geniş spektrum (bakteri, mantar, parazit)
- Allisiin: minimum inhibitör konsantrasyon (MIC) ~ 10 µg/mL (S. aureus) - Antidiyabetik:
- İnsülin sekresyonu ↑
- İnsülin duyarlılığı ↑
Sarımsak - Statik Farmakodünamik Etkileşim:
Sarımsak ekstraktı CYP3A4'ü indükleyebilir → bazı ilaçların plazma konsantrasyonu ↓:
- Saquinavir (HIV proteaz inhibitörü): %50 azalma
- Warfarin: INR azalması (kanama riski)
IoT Tabanlı Sarımsak Tüketimi - İlaç Etkileşim Uyarı Sistemi:
python
Raspberry Pi + Hasta İlaç Profili
import datetime
import sqlite3
class DrugInteractionMonitor:
def __init__(self):
self.conn = sqlite3.connect('patient_drugs.db')
self.cursor = self.conn.cursor()
Risk ilaçları veritabanı
self.cursor.execute('''CREATE TABLE IF NOT EXISTS risk_drugs
(ilac TEXT, etkilesim_riski TEXT,
mekanizma TEXT, oneri TEXT)''')
Örnek veri
risk_drugs = [
('Warfarin', 'Yüksek', 'CYP2C9 indüksiyonu', 'INR yakın takip'),
('Saquinavir', 'Yüksek', 'CYP3A4 indüksiyonu', 'Dozaj ayarı gerekebilir'),
('Atorvastatin', 'Orta', 'CYP3A4 indüksiyonu', 'Lipid profili izle')
]
self.cursor.executemany('INSERT OR IGNORE INTO risk_drugs VALUES (?,?,?,?)',
risk_drugs)
self.conn.commit()
def check_garlic_interaction(self, patient_drugs):
"""Sarımsak-ilaç etkileşim kontrolü"""
print("=== Sarımsak-İlaç Etkileşim Analizi ===")
print(f"Tarih: {datetime.datetime.now()}\n")
interactions_found = False
for drug in patient_drugs:
self.cursor.execute(
"SELECT * FROM risk_drugs WHERE ilac=?", (drug,)
)
result = self.cursor.fetchone()
if result:
interactions_found = True
print(f"⚠️ UYARI: {result[0]}")
print(f" Risk Seviyesi: {result[1]}")
print(f" Mekanizma: {result[2]}")
print(f" Öneri: {result[3]}\n")
if not interactions_found:
print("✓ Bilinen etkileşim tespit edilmedi.")
return interactions_found
def log_garlic_consumption(self, amount_mg):
"""Sarımsak tüketimi kaydı"""
self.cursor.execute('''CREATE TABLE IF NOT EXISTS garlic_log
(tarih TEXT, miktar_mg INTEGER)''')
self.cursor.execute("INSERT INTO garlic_log VALUES (?, ?)",
(datetime.datetime.now().isoformat(), amount_mg))
self.conn.commit()
print(f"Sarımsak tüketimi kaydedildi: {amount_mg} mg\n")
Kullanım
monitor = DrugInteractionMonitor()
Hasta ilaç profili
hasta_ilaclari = ['Warfarin', 'Metformin', 'Lisinopril']
Sarımsak tüketimi öncesi kontrol
monitor.check_garlic_interaction(hasta_ilaclari)
Tüketim kaydı
monitor.log_garlic_consumption(600) # 600 mg sarımsak ekstresi
5. BİTKİSEL İLAÇ GELİŞTİRME: PREKLİNİK VE KLİNİK ARAŞTIRMALAR
5.1. İlaç Geliştirme Süreci: Genel Bakış
Bir bitkisel ürünün "ilaç" statüsüne kavuşması, sistematik ve bilimsel bir sürecin tamamlanmasını gerektirir.
İlaç Geliştirme Aşamaları:
Hastalık Analizi
↓
Hedef Belirleme
↓
İlaç Keşfi (Hit/Lead Finding)
↓
Lead Optimizasyonu
↓
Preklinik Araştırmalar (2-4 yıl)
├─ In vitro testler
├─ In vivo (hayvan) testleri
├─ Farmakokinetik
├─ Toksikoloji
└─ Formülasyon geliştirme
↓
IND/CTA Başvurusu
↓
Klinik Araştırmalar (6-7 yıl)
├─ Faz I (20-100 sağlıklı gönüllü)
├─ Faz II (100-300 hasta)
└─ Faz III (1000-5000 hasta)
↓
NDA/MAA Başvurusu
↓
Onay ve Piyasaya Sürüm
↓
Faz IV (Pazarlama Sonrası Gözetim)
Toplam Süre: 10-15 yıl
Toplam Maliyet: ~1-2.6 milyar USD
Başarı Oranı: ~10% (preklinik → onay)
5.2. Preklinik Araştırmalar
5.2.1. In Vitro Çalışmalar
Amaç: Hücre düzeyinde etkinlik ve toksisite değerlendirmesi
Yöntemler:
- Hücre Canlılık Testleri:
- MTT assay
- Nötral kırmızı uptake
- LDH salınımı - Apoptoz/Nekroz Analizi:
- Annexin V / PI boyama
- TUNEL assay
- Caspase aktivitesi - Mekanizma Çalışmaları:
- Western blot (protein ekspresyonu)
- RT-PCR (gen ekspresyonu)
- Flow sitometri (hücre döngüsü) - Antioksidan Aktivite:
- DPPH radikal süpürme
- ABTS assay
- ORAC (Oksijen Radikal Absorbans Kapasitesi)
Örnek: Hypericum perforatum (Sarı kantaron) Ekstresinin Antidepresan Aktivite Tahmini
python
import numpy as np
import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
In vitro veri seti (örnek)
data = pd.DataFrame({
'konsantrasyon_ug_ml': [1, 5, 10, 25, 50, 100],
'serotonin_uptake_inhibisyon_%': [5, 22, 45, 68, 82, 89],
'norepinefrin_uptake_inhibisyon_%': [3, 18, 38, 61, 77, 85],
'dopamin_uptake_inhibisyon_%': [2, 15, 32, 55, 72, 81],
'GABA_uptake_inhibisyon_%': [1, 12, 28, 48, 65, 75],
'citotoksisite_%': [0, 2, 5, 8, 15, 28],
'antidepresan_aktivite': [0, 0, 1, 1, 1, 0] # 0=yok, 1=var
})
Özellikler ve hedef
X = data[['konsantrasyon_ug_ml', 'serotonin_uptake_inhibisyon_%',
'norepinefrin_uptake_inhibisyon_%', 'citotoksisite_%']]
y = data['antidepresan_aktivite']
Model eğitimi
clf = GradientBoostingClassifier(n_estimators=100, random_state=42)
clf.fit(X, y)
Çapraz doğrulama skoru
cv_scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')
print(f"Çapraz Doğrulama Doğruluğu: {cv_scores.mean():.2f} (+/- {cv_scores.std():.2f})")
Özellik önem dereceleri
feature_importance = pd.DataFrame({
'ozellik': X.columns,
'onem': clf.feature_importances_
}).sort_values('onem', ascending=False)
print("\nÖzellik Önem Dereceleri:")
print(feature_importance)
Görselleştirme
plt.figure(figsize=(10, 6))
plt.barh(feature_importance['ozellik'], feature_importance['onem'])
plt.xlabel('Önem Skoru')
plt.title('Antidepresan Aktivite Tahmini - Özellik Önemi')
plt.tight_layout()
plt.show()
Yeni konsantrasyon için tahmin
yeni_veri = np.array([[30, 60, 55, 7]]) # 30 µg/mL
tahmin = clf.predict(yeni_veri)
tahmin_olasilik = clf.predict_proba(yeni_veri)
print(f"\n30 µg/mL için tahmin:")
print(f"Aktivite: {'Var' if tahmin[0] == 1 else 'Yok'}")
print(f"Olasılık: {tahmin_olasilik[0][1]:.2%}")
Çıktı Yorumu:
Model, serotonin geri alım inhibisyonunun en önemli prediktör olduğunu gösterebilir, bu da Hypericum'un antidepresan mekanizmasını destekler.
5.2.2. In Vivo (Hayvan) Çalışmaları
Amaç: Organizmal düzeyde etkinlik, farmakokinetik ve toksikoloji değerlendirmesi
3R Prensipleri:
- Replace: Alternatif yöntemler (in vitro, in silico)
- Reduce: Minimum sayıda hayvan
- Refine: Acı/stres minimizasyonu
Farmakokinetik Çalışmalar:
ADME Profili:
- Absorption (Emilim): Biyoyararlanım
- Distribution (Dağılım): Doku dağılımı, kan-beyin bariyeri geçişi
- Metabolism (Metabolizma): Faz I/II enzimler, metabolit profili
- Excretion (Atılım): Yarılanma ömrü, klerens
Örnek: Farmakokinetik Parametrelerin Hesaplanması
python
import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
Plazma konsantrasyonu - zaman verisi (sıçan, oral 100 mg/kg)
zaman_saat = np.array([0, 0.5, 1, 2, 4, 6, 8, 12, 24])
konsantrasyon_ug_ml = np.array([0, 2.5, 4.8, 6.2, 5.1, 3.8, 2.6, 1.2, 0.3])
Tek kompartmanlı model: C(t) = (F*Doz*ka)/(Vd*(ka-ke)) * (e^(-ke*t) - e^(-ka*t))
Basitleştirilmiş eliminasyon fazı: C(t) = C0 * e^(-ke*t)
def elimination_phase(t, C0, ke):
return C0 * np.exp(-ke * t)
Sadece eliminasyon fazı için fit (t > Tmax)
t_elim = zaman_saat[3:]
C_elim = konsantrasyon_ug_ml[3:]
params, _ = curve_fit(elimination_phase, t_elim, C_elim)
C0_fit, ke_fit = params
Farmakokinetik parametreler
t_half = np.log(2) / ke_fit
AUC = np.trapz(konsantrasyon_ug_ml, zaman_saat) # Trapezoid kuralı
Cmax = np.max(konsantrasyon_ug_ml)
Tmax = zaman_saat[np.argmax(konsantrasyon_ug_ml)]
print("=== Farmakokinetik Parametreler ===")
print(f"Cmax: {Cmax:.2f} µg/mL")
print(f"Tmax: {Tmax:.2f} saat")
print(f"t1/2: {t_half:.2f} saat")
print(f"AUC0-24: {AUC:.2f} µg·h/mL")
print(f"ke: {ke_fit:.4f} h⁻¹")
Plazma konsantrasyon-zaman eğrisi
plt.figure(figsize=(10, 6))
plt.plot(zaman_saat, konsantrasyon_ug_ml, 'o-', label='Gözlenen')
t_fit = np.linspace(Tmax, 24, 100)
plt.plot(t_fit, elimination_phase(t_fit, C0_fit, ke_fit), '--', label='Model fit')
plt.xlabel('Zaman (saat)')
plt.ylabel('Plazma Konsantrasyonu (µg/mL)')
plt.title('Farmakokinetik Profil')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
Toksikoloji Çalışmaları:
- Akut Toksisite:
- Tek doz
- LD50 belirleme (artık daha az kullanılıyor)
- OECD 423 (Fixed Dose Procedure) - Subakut/Subkronik Toksisite:
- 14-90 gün tekrarlı doz
- Hedef organ toksisitesi
- Hematoloji, biyokimya, histopatoloji - Kronik Toksisite:
- 6-12 ay
- Kanserojenite çalışmaları - Özel Toksisite:
- Genotoksisite: Ames testi, mikronükleus testi
- Reproduktif Toksisite: Teratojenite (Segment II), fertilite
- İmmünotoksisite
AI Destekli Toksisite Tahmini (QSAR):
python
from rdkit import Chem
from rdkit.Chem import Descriptors
from sklearn.svm import SVR
import numpy as np
Bilinen bileşikler ve LD50 değerleri (mg/kg, sıçan, oral)
training_data = {
'Kafein': ('CN1C=NC2=C1C(=O)N(C(=O)N2C)C', 192),
'Nikotin': ('CN1CCC[C@H]1c2cccnc2', 50),
'Morfin': ('CN1CC[C@]23[C@@H]4[C@H]1CC5=C2C(=C(C=C5)O)O[C@H]3[C@H](C=C4)O', 335)
}
def calculate_descriptors(smiles):
"""Moleküler tanımlayıcılar"""
mol = Chem.MolFromSmiles(smiles)
return [
Descriptors.MolWt(mol),
Descriptors.MolLogP(mol),
Descriptors.NumHDonors(mol),
Descriptors.NumHAcceptors(mol),
Descriptors.TPSA(mol),
Descriptors.NumRotatableBonds(mol)
]
Eğitim seti hazırlama
X_train = []
y_train = []
for name, (smiles, ld50) in training_data.items():
X_train.append(calculate_descriptors(smiles))
y_train.append(np.log10(ld50)) # Log dönüşümü
X_train = np.array(X_train)
y_train = np.array(y_train)
Model eğitimi
model = SVR(kernel='rbf', C=100, gamma=0.1)
model.fit(X_train, y_train)
Yeni bileşik için tahmin (örnek: Hiperforin)
hyperforin_smiles = 'CC(C)C1CC(=C(C(=O)C1(C)CC=C(C)C)O)C=C(C)C'
hyperforin_desc = np.array([calculate_descriptors(hyperforin_smiles)])
log_ld50_pred = model.predict(hyperforin_desc)
ld50_pred = 10 ** log_ld50_pred[0]
print(f"Tahmin edilen LD50 (Hiperforin): {ld50_pred:.0f} mg/kg")
Toksisite sınıflandırması (GHS)
if ld50_pred > 2000:
tox_class = "Düşük toksisite (Kategori 5)"
elif ld50_pred > 300:
tox_class = "Orta toksisite (Kategori 4)"
elif ld50_pred > 50:
tox_class = "Yüksek toksisite (Kategori 3)"
else:
tox_class = "Çok yüksek toksisite (Kategori 1-2)"
print(f"Toksisite Sınıfı: {tox_class}")
Bu tip in silico (bilgisayar destekli) yöntemler, pahalı ve etik açıdan sorunlu hayvan deneylerinin sayısını azaltmaya yardımcı olur.
5.3. Klinik Araştırmalar
5.3.1. Faz I: Güvenlik ve Farmakokinetik
Amaç:
- İnsan vücudunda güvenlik profili
- Farmakokinetik parametreler
- Maksimum tolere edilebilir doz (MTD)
- Doz-yanıt ilişkisi
Katılımcılar: 20-100 sağlıklı gönüllü (onkolojide genellikle hastalar)
Dizayn:
- Tek artan doz (SAD)
- Çoklu artan doz (MAD)
- Gıda etkisi çalışmaları
Örnek: Faz I Doz Artış Protokolü
python
import numpy as np
import matplotlib.pyplot as plt
class PhaseITrial:
def __init__(self, starting_dose=10):
self.starting_dose = starting_dose
self.dose_levels = []
self.dlt_rates = [] # Dose Limiting Toxicity
def modified_fibonacci(self, n_levels=6):
"""Modifiye Fibonacci doz artışı"""
doses = [self.starting_dose]
for i in range(1, n_levels):
if i == 1:
multiplier = 2.0 # %100 artış
elif i == 2:
multiplier = 1.67 # %67 artış
elif i == 3:
multiplier = 1.5 # %50 artış
else:
multiplier = 1.33 # %33 artış
doses.append(doses[-1] * multiplier)
return doses
def simulate_toxicity(self, dose, mtd=100):
"""Toksisite olasılığı simülasyonu (sigmoid model)"""
Logistik fonksiyon
probability = 1 / (1 + np.exp(-0.05 * (dose - mtd)))
return probability
def run_trial(self, n_levels=6, mtd_true=100):
"""Faz I çalışması simülasyonu"""
self.dose_levels = self.modified_fibonacci(n_levels)
print("=== Faz I Doz Artış Çalışması ===\n")
for i, dose in enumerate(self.dose_levels):
tox_prob = self.simulate_toxicity(dose, mtd_true)
3+3 dizayn simülasyonu
cohort_size = 3
dlt_count = np.random.binomial(cohort_size, tox_prob)
print(f"Doz Seviyesi {i+1}: {dose:.1f} mg")
print(f" Toksisite Olasılığı: {tox_prob:.2%}")
print(f" Gözlenen DLT: {dlt_count}/{cohort_size}")
self.dlt_rates.append(dlt_count / cohort_size)
Durdurma kuralı
if dlt_count >= 2:
print(f" ⚠️ DLT eşiği aşıldı. MTD: {self.dose_levels[i-1]:.1f} mg")
break
elif dlt_count == 1:
print(f" → 3 hasta daha ekleniyor...")
cohort_size = 6
dlt_count = np.random.binomial(cohort_size, tox_prob)
if dlt_count >= 2:
print(f" ⚠️ MTD: {self.dose_levels[i-1]:.1f} mg")
break
print()
def plot_dose_response(self):
"""Doz-yanıt eğrisi"""
plt.figure(figsize=(10, 6))
plt.plot(self.dose_levels[:len(self.dlt_rates)],
self.dlt_rates, 'o-', markersize=10)
plt.axhline(y=0.33, color='r', linestyle='--',
label='Hedef DLT Oranı (%33)')
plt.xlabel('Doz (mg)')
plt.ylabel('DLT Oranı')
plt.title('Faz I Doz-Toksisite İlişkisi')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
Simülasyon
trial = PhaseITrial(starting_dose=10)
trial.run_trial(n_levels=8, mtd_true=100)
trial.plot_dose_response()
5.3.2. Faz II: Etkinlik ve Doz Bulma
Amaç:
- Terapötik etkinliğin gösterilmesi
- Optimal doz aralığının belirlenmesi
- Yan etki profilinin genişletilmesi
Katılımcılar: 100-300 hedef hasta popülasyonu
Dizayn:
- Faz IIA: Tek kol, doz bulma
- Faz IIB: Randomize, çok kollu, plasebo kontrollü
Birincil Sonlanım Noktaları:
- Biyolojik belirteçler
- Semptom skorları
- Objektif yanıt oranı (onkoloji)
Örnek: Faz II Randomize Kontrollü Çalışma - Veri Analizi
python
import pandas as pd
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
import seaborn as sns
Hipotetik veri: Hypericum ekstraktı depresyon çalışması
Hamilton Depresyon Derecelendirme Ölçeği (HAM-D) skoru
np.random.seed(42)
data = pd.DataFrame({
'hasta_id': range(1, 201),
'grup': ['Plasebo']*50 + ['Hypericum_300mg']*50 +
['Hypericum_600mg']*50 + ['Hypericum_900mg']*50,
'baseline_HAMD': np.random.normal(22, 3, 200), # Orta-şiddetli depresyon
})
6 hafta sonrası değişim
data['endpoint_HAMD'] = data.apply(lambda row:
row['baseline_HAMD'] - np.random.normal(
{'Plasebo': 3, 'Hypericum_300mg': 6,
'Hypericum_600mg': 9, 'Hypericum_900mg': 10}[row['grup']], 2
), axis=1
)
data['change_HAMD'] = data['baseline_HAMD'] - data['endpoint_HAMD']
data['response'] = (data['change_HAMD'] >= 0.5 * data['baseline_HAMD']).astype(int) # ≥%50 azalma
İstatistiksel Analiz
print("=== Faz II Etkinlik Analizi ===\n")
Tanımlayıcı istatistikler
print("Ortalama HAM-D Değişimi:")
print(data.groupby('grup')['change_HAMD'].describe()[['mean', 'std']])
print()
ANOVA (gruplar arası fark)
groups = [data[data['grup'] == g]['change_HAMD'].values
for g in data['grup'].unique()]
f_stat, p_value = stats.f_oneway(*groups)
print(f"ANOVA: F={f_stat:.2f}, p={p_value:.4f}")
if p_value < 0.05:
print("Sonuç: Gruplar arası anlamlı fark var.\n")
else:
print("Sonuç: Gruplar arası anlamlı fark yok.\n")
Post-hoc: Her doz vs plasebo
for dose in ['Hypericum_300mg', 'Hypericum_600mg', 'Hypericum_900mg']:
plasebo_group = data[data['grup'] == 'Plasebo']['change_HAMD']
dose_group = data[data['grup'] == dose]['change_HAMD']
t_stat, p_val = stats.ttest_ind(plasebo_group, dose_group)
cohen_d = (dose_group.mean() - plasebo_group.mean()) / np.sqrt(
(dose_group.std()**2 + plasebo_group.std()**2) / 2
)
print(f"{dose} vs Plasebo:")
print(f" t={t_stat:.2f}, p={p_val:.4f}, Cohen's d={cohen_d:.2f}")
Yanıt Oranları
print("\nYanıt Oranları (≥%50 HAM-D azalma):")
response_rates = data.groupby('grup')['response'].mean() * 100
print(response_rates)
Görselleştirme
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
Box plot
sns.boxplot(data=data, x='grup', y='change_HAMD', ax=axes[0])
axes[0].set_xlabel('Grup')
axes[0].set_ylabel('HAM-D Skoru Değişimi')
axes[0].set_title('Doz-Yanıt İlişkisi')
axes[0].axhline(y=0, color='r', linestyle='--', alpha=0.5)
Yanıt oranları
response_rates.plot(kind='bar', ax=axes[1], color=['gray', 'lightblue', 'blue', 'darkblue'])
axes[1].set_xlabel('Grup')
axes[1].set_ylabel('Yanıt Oranı (%)')
axes[1].set_title('Tedavi Yanıt Oranları')
axes[1].set_xticklabels(axes[1].get_xticklabels(), rotation=45)
plt.tight_layout()
plt.show()
Optimal doz önerisi
optimal_dose = response_rates.idxmax()
print(f"\n Önerilen Faz III Dozu: {optimal_dose}")
NNT (Number Needed to Treat) Hesaplaması:
python
Yanıt oranı farkı
plasebo_response = response_rates['Plasebo'] / 100
optimal_response = response_rates[optimal_dose] / 100
ARR = optimal_response - plasebo_response # Absolute Risk Reduction
NNT = 1 / ARR
print(f"\nAbsolut Risk Azalması: {ARR:.2%}")
print(f"NNT: {NNT:.1f}")
print(f"Yorum: {NNT:.0f} hasta tedavi edildiğinde 1 ek yanıt elde edilir.")
5.3.3. Faz III: Geniş Ölçekli Etkinlik Onayı
Amaç:
- Standart tedavi ile karşılaştırmalı etkinlik
- Güvenlik profilinin netleştirilmesi
- Risk-fayda dengesinin değerlendirilmesi
Katılımcılar: 1000-5000 hasta
Dizayn:
- Çok merkezli
- Randomize
- Çift kör (double-blind)
- Plasebo/aktif kontrollü
- Paralel grup veya çaprazlama
Birincil Sonlanım: Klinik olarak anlamlı sonuç (örn. mortalite, majör kardiyovasküler olay, hastalıksız sağkalım)
Gerçek Zamanlı Klinik Çalışma İzleme Sistemi:
python
Raspberry Pi + Bulut Entegrasyonu
import requests
import json
from datetime import datetime
class ClinicalTrialMonitor:
def __init__(self, trial_id, api_endpoint):
self.trial_id = trial_id
self.api_endpoint = api_endpoint
self.enrolled_patients = 0
self.adverse_events = []
def enroll_patient(self, patient_id, arm):
"""Hasta kaydı"""
data = {
'trial_id': self.trial_id,
'patient_id': patient_id,
'arm': arm,
'enrollment_date': datetime.now().isoformat()
}
response = requests.post(f"{self.api_endpoint}/enroll", json=data)
if response.status_code == 200:
self.enrolled_patients += 1
print(f"✓ Hasta {patient_id} kaydedildi ({arm})")
print(f" Toplam kayıtlı: {self.enrolled_patients}")
else:
print(f"✗ Kayıt hatası: {response.text}")
def report_adverse_event(self, patient_id, event_type, severity):
"""Yan etki bildirimi"""
ae_data = {
'trial_id': self.trial_id,
'patient_id': patient_id,
'event_type': event_type,
'severity': severity, # 1-5 (CTCAE)
'date': datetime.now().isoformat()
}
self.adverse_events.append(ae_data)
Ciddi yan etki kontrolü
if severity >= 3:
print(f"⚠️ CİDDİ YAN ETKİ (Hasta {patient_id})")
print(f" Tip: {event_type}, Şiddet: {severity}")
Otomatik bildirim (email, SMS)
self.notify_investigators(ae_data)
Veri merkezi
requests.post(f"{self.api_endpoint}/adverse_event", json=ae_data)
def check_futility(self, interim_data):
"""Ara analiz: Yararsızlık kontrolü"""
Conditional power hesabı (basitleştirilmiş)
observed_effect = interim_data['treatment_mean'] - interim_data['control_mean']
target_effect = interim_data['target_effect']
conditional_power = observed_effect / target_effect
print("\n=== Ara Analiz ===")
print(f"Gözlenen etki: {observed_effect:.2f}")
print(f"Hedef etki: {target_effect:.2f}")
print(f"Koşullu güç: {conditional_power:.2%}")
if conditional_power < 0.2:
print("⚠️ UYARI: Düşük başarı olasılığı. Çalışma durdurulabilir.")
return 'STOP_FUTILITY'
elif conditional_power > 0.9:
print("✓ Yüksek başarı olasılığı. Erken durdurma değerlendirilebilir.")
return 'CONSIDER_EARLY_STOP'
else:
return 'CONTINUE'
def notify_investigators(self, ae_data):
"""Araştırıcılara bildirim"""
Email/SMS API entegrasyonu
notification = f"""
Ciddi Yan Etki Bildirimi
Çalışma: {self.trial_id}
Hasta: {ae_data['patient_id']}
Olay: {ae_data['event_type']}
Şiddet: Grade {ae_data['severity']}
Tarih: {ae_data['date']}
"""
print(notification)
requests.post("sms_api_endpoint", data=notification)
def generate_dsmb_report(self):
"""Veri Güvenlik İzleme Kurulu raporu"""
report = {
'trial_id': self.trial_id,
'enrolled': self.enrolled_patients,
'total_ae': len(self.adverse_events),
'serious_ae': len([ae for ae in self.adverse_events if ae['severity'] >= 3]),
'generated_date': datetime.now().isoformat()
}
print("\n=== DSMB Raporu ===")
print(json.dumps(report, indent=2))
return report
Kullanım örneği
monitor = ClinicalTrialMonitor(
trial_id='HYPER-PHASE3-2026',
api_endpoint='https://trial-api.example.com'
)
Hasta kaydı
monitor.enroll_patient('P001', 'Hypericum_900mg')
monitor.enroll_patient('P002', 'Placebo')
Yan etki raporu
monitor.report_adverse_event('P001', 'Gastrointestinal discomfort', severity=2)
monitor.report_adverse_event('P002', 'Hepatotoxicity', severity=4)
Ara analiz
interim_data = {
'treatment_mean': 8.5,
'control_mean': 3.2,
'target_effect': 6.0
}
decision = monitor.check_futility(interim_data)
DSMB raporu
monitor.generate_dsmb_report()
5.3.4. Faz IV: Pazarlama Sonrası Gözetim (Farmakovijilans)
Amaç:
- Nadir yan etkilerin tespiti
- Uzun dönem güvenlik
- Gerçek dünya etkinliği
- İlaç-ilaç etkileşimleri
- Risk yönetimi
Yöntemler:
- Spontan raporlama sistemleri
- Gözlemsel kohort çalışmaları
- Vaka-kontrol çalışmaları
- Elektronik sağlık kaydı (EHR) veri madenciliği
AI Destekli Farmakovijilans: Yan Etki Sinyali Tespiti
python
import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
class PharmacovigilanceAI:
def __init__(self):
self.reports = pd.DataFrame()
self.model = IsolationForest(contamination=0.05, random_state=42)
def add_reports(self, new_reports):
"""Yeni yan etki raporları ekleme"""
self.reports = pd.concat([self.reports, new_reports], ignore_index=True)
def calculate_prr(self, drug, event):
"""Proportional Reporting Ratio"""
2x2 kontenjans tablosu
a = len(self.reports[(self.reports['drug'] == drug) &
(self.reports['event'] == event)])
b = len(self.reports[(self.reports['drug'] == drug) &
(self.reports['event'] != event)])
c = len(self.reports[(self.reports['drug'] != drug) &
(self.reports['event'] == event)])
d = len(self.reports[(self.reports['drug'] != drug) &
(self.reports['event'] != event)])
if b == 0 or c == 0:
return None, None
prr = (a / b) / (c / d)
Chi-kare testi
from scipy.stats import chi2_contingency
chi2, p_value, _, _ = chi2_contingency([[a, b], [c, d]])
return prr, p_value
def detect_signals(self, threshold_prr=2.0, threshold_p=0.05):
"""Sinyal tespiti"""
signals = []
unique_drugs = self.reports['drug'].unique()
unique_events = self.reports['event'].unique()
print("=== Farmakovijilans Sinyal Analizi ===\n")
for drug in unique_drugs:
for event in unique_events:
prr, p_value = self.calculate_prr(drug, event)
if prr and prr >= threshold_prr and p_value < threshold_p:
signals.append({
'drug': drug,
'event': event,
'PRR': prr,
'p_value': p_value
})
print(f" SİNYAL: {drug} - {event}")
print(f" PRR: {prr:.2f} (CI: güven aralığı hesaplanmalı)")
print(f" p-değeri: {p_value:.4f}\n")
return pd.DataFrame(signals)
def anomaly_detection(self):
"""Anomali tespiti (AI)"""
Özellik mühendisliği
features = pd.get_dummies(self.reports[['drug', 'event', 'age_group', 'gender']])
Model eğitimi
self.model.fit(features)
Anomali skoru
anomaly_scores = self.model.decision_function(features)
self.reports['anomaly_score'] = anomaly_scores
Anomaliler
anomalies = self.reports[self.model.predict(features) == -1]
print(f"\n {len(anomalies)} anomali tespit edildi.")
print("\nEn anormal 5 rapor:")
print(anomalies.nsmallest(5, 'anomaly_score')[
['report_id', 'drug', 'event', 'severity', 'anomaly_score']
])
return anomalies
def generate_periodic_report(self):
"""Periyodik güvenlik raporu"""
report = f"""
=== Periyodik Güvenlik Raporu ===
Rapor Tarihi: {pd.Timestamp.now()}
Toplam Rapor: {len(self.reports)}
Ciddi Yan Etki: {len(self.reports[self.reports['severity'] >= 3])}
Ölüm: {len(self.reports[self.reports['outcome'] == 'death'])}
İlaç Dağılımı:
{self.reports['drug'].value_counts()}
En Sık Yan Etki:
{self.reports['event'].value_counts().head(10)}
print(report)
Simüle edilmiş raporlar
np.random.seed(42)
reports = pd.DataFrame({
'report_id': range(1, 1001),
'drug': np.random.choice(['Hypericum', 'Placebo', 'Fluoxetine'], 1000, p=[0.4, 0.3, 0.3]),
'event': np.random.choice([
'Headache', 'Nausea', 'Dizziness', 'Photosensitivity',
'Hepatotoxicity', 'Serotonin_syndrome'
], 1000, p=[0.3, 0.25, 0.2, 0.15, 0.07, 0.03]),
'severity': np.random.randint(1, 6, 1000),
'age_group': np.random.choice(['18-30', '31-50', '51-70', '>70'], 1000),
'gender': np.random.choice(['M', 'F'], 1000),
'outcome': np.random.choice(['recovered', 'ongoing', 'death'], 1000, p=[0.85, 0.14, 0.01])
})
Hypericum-fotosensitivite ilişkisini güçlendirme (bilinen yan etki)
hypericum_reports = reports[reports['drug'] == 'Hypericum']
photosens_indices = hypericum_reports.sample(n=50).index
reports.loc[photosens_indices, 'event'] = 'Photosensitivity'
Analiz
pv = PharmacovigilanceAI()
pv.add_reports(reports)
Sinyal tespiti
signals = pv.detect_signals()
Anomali tespiti
anomalies = pv.anomaly_detection()
Periyodik rapor
pv.generate_periodic_report()
Çıktı Yorumu:
Sistem, Hypericum-fotosensitivite ilişkisini anlamlı bir sinyal olarak tespit edecek, bu da ürün bilgi formunun (KT) güncellenmesini gerektirebilir.
6. KALİTE KONTROLÜ VE STANDARDİZASYON
6.1. Bitkisel İlaçlarda Kalite Kavramı
Bitkisel ilaçların kalitesi, üç temel unsura dayanır:
- Kalite (Quality): Kimlik, saflık, içerik
- Etkinlik (Efficacy): Klinik fayda
- Güvenlik (Safety): Risk-fayda dengesi
6.2. Standardizasyon
Tanım: Bitkisel ürünlerde belirli bileşen(ler)in belirli aralıklarda garanti edilmesi
Yöntemler: - Aktif Bileşen Standardizasyonu:
- Örnek: Hypericum ekstraktı %0.3 hiperisin, %3-5 hiperforin - Marker Bileşen Standardizasyonu:
- Aktif bileşen bilinmiyorsa
- Örnek: Ginkgo biloba, %24 ginkgo flavon glikozitleri - Fingerprint (Parmak İzi) Yöntemi:
- HPLC/GC kromatogramı
- Çoklu bileşen paterni
Analitik Yöntemler:
- HPLC (High Performance Liquid Chromatography)
- GC-MS (Gas Chromatography-Mass Spectrometry)
- UV-Vis Spektrofotometri
- TLC (Thin Layer Chromatography)
- NMR (Nuclear Magnetic Resonance)
- FT-IR (Fourier Transform Infrared Spectroscopy)
HPLC Analizi - Python Simülasyonu:
python
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import find_peaks
class HPLCSimulator:
def __init__(self):
self.retention_times = []
self.peak_areas = []
def generate_chromatogram(self, compounds, noise_level=0.05):
"""HPLC kromatogramı simülasyonu"""
time = np.linspace(0, 30, 3000) # 30 dakika, 0.01 dak çözünürlük
signal = np.zeros_like(time)
for compound in compounds:
rt = compound['retention_time'] # Alıkonma zamanı
area = compound['area']
width = compound['width']
Gaussian pik
peak = area * np.exp(-0.5 * ((time - rt) / width) ** 2)
signal += peak
self.retention_times.append(rt)
self.peak_areas.append(area)
Gürültü ekleme
noise = np.random.normal(0, noise_level * signal.max(), len(time))
signal += noise
return time, signal
def integrate_peaks(self, time, signal, prominence=0.1):
"""Pik entegrasyonu"""
peaks, properties = find_peaks(signal, prominence=prominence, width=5)
print("=== Pik Entegrasyon Sonuçları ===\n")
total_area = 0
results = []
for i, peak_idx in enumerate(peaks):
rt = time[peak_idx]
height = signal[peak_idx]
Basitleştirilmiş alan hesabı (trapezoid)
start = max(0, peak_idx - 50)
end = min(len(signal), peak_idx + 50)
area = np.trapz(signal[start:end], time[start:end])
total_area += area
results.append({'RT': rt, 'Area': area, 'Height': height})
print(f"Pik {i+1}:")
print(f" Alıkonma Zamanı: {rt:.2f} dk")
print(f" Alan: {area:.2f}")
print(f" Yükseklik: {height:.2f}\n")
Yüzde içerikler
print("Göreceli Alan Yüzdeleri:")
for i, result in enumerate(results):
percentage = (result['Area'] / total_area) * 100
print(f" Pik {i+1}: {percentage:.2f}%")
return results
def plot_chromatogram(self, time, signal, title="HPLC Kromatogramı"):
"""Kromatogram görselleştirme"""
plt.figure(figsize=(12, 6))
plt.plot(time, signal, 'b-', linewidth=1)
plt.xlabel('Alıkonma Zamanı (dakika)')
plt.ylabel('Absorbans (mAU)')
plt.title(title)
plt.grid(True, alpha=0.3)
plt.show()
Hypericum ekstraktı örneği
compounds = [
{'name': 'Rutin', 'retention_time': 8.5, 'area': 1200, 'width': 0.3},
{'name': 'Hyperoside', 'retention_time': 10.2, 'area': 1500, 'width': 0.35},
{'name': 'Isoquercitrin', 'retention_time': 12.8, 'area': 1100, 'width': 0.3},
{'name': 'Quercitrin', 'retention_time': 14.5, 'area': 900, 'width': 0.32},
{'name': 'Quercetin', 'retention_time': 18.3, 'area': 800, 'width': 0.35},
{'name': 'Hypericin', 'retention_time': 22.1, 'area': 450, 'width': 0.4}, # Hedef: %0.3
{'name': 'Hyperforin', 'retention_time': 25.7, 'area': 5500, 'width': 0.5} # Hedef: %3-5
]
Simülasyon
hplc = HPLCSimulator()
time, signal = hplc.generate_chromatogram(compounds, noise_level=0.03)
hplc.plot_chromatogram(time, signal, "Hypericum perforatum Ekstraktı - HPLC Analizi")
Pik entegrasyonu
results = hplc.integrate_peaks(time, signal, prominence=50)
Standardizasyon kontrolü
total_area = sum([r['Area'] for r in results])
hypericin_area = results[5]['Area'] # 6. pik
hyperforin_area = results[6]['Area'] # 7. pik
hypericin_percent = (hypericin_area / total_area) * 100
hyperforin_percent = (hyperforin_area / total_area) * 100
print("\n=== Standardizasyon Kontrolü ===")
print(f"Hiperisin İçeriği: {hypericin_percent:.2f}% (Hedef: 0.3%)")
print(f"Hiperforin İçeriği: {hyperforin_percent:.2f}% (Hedef: 3-5%)")
if hypericin_percent >= 0.25 and hypericin_percent <= 0.35:
print("✓ Hiperisin: SPESİFİKASYONDA")
else:
print("✗ Hiperisin: SPESİFİKASYON DIŞI")
if hyperforin_percent >= 3.0 and hyperforin_percent <= 5.0:
print("✓ Hiperforin: SPESİFİKASYONDA")
else:
print("✗ Hiperforin: SPESİFİKASYON DIŞI")
6.3. Kontaminasyon ve Safsızlık Kontrolü
Kritik Kontroller:
- Ağır Metaller:
- Pb, Cd, Hg, As
- ICP-MS (Inductively Coupled Plasma Mass Spectrometry)
- WHO/Farmakope limitleri - Pestisitler:
- Organoklorlu, organofosforlu, piretroit
- GC-MS/MS
- AB limitleri (MRL - Maximum Residue Limits) - Mikrobiyolojik Kontaminasyon:
- Total aerobik sayım
- Maya/küf
- Enterobakteri
- Patojenler (E. coli, Salmonella) - Aflatoksinler:
- B1, B2, G1, G2
- HPLC-FLD (Fluorescence Detection)
- Limit: <4 ppb (EU) - Radyoaktivite:
- Cs-137, I-131
- Gamma spektrometri
IoT Tabanlı Kalite Kontrol İzleme Sistemi:
cpp
// Arduino Mega + Çoklu Sensör Entegrasyonu
#include
#include
// Sensör pinleri
#define HEAVY_METAL_SENSOR A0 // Elektrokimyasal sensör
#define MOISTURE_SENSOR A1
#define TEMP_SENSOR A2
#define pH_SENSOR A3
// Spektrofotometre (I2C)
#define SPECTRO_ADDR 0x39
// SD Kart
#include
File logFile;
struct QualityData {
float temperature;
float moisture;
float pH;
float heavy_metal_ppm;
float aflatoxin_ppb;
unsigned long timestamp;
};
QualityData currentData;
void setup() {
Serial.begin(9600);
Wire.begin();
// SD kart başlatma
if (!SD.begin(10)) {
Serial.println("SD kart hatası!");
}
// Sensör kalibrasyonu
calibrateSensors();
Serial.println("Kalite Kontrol Sistemi Hazır");
}
void loop() {
// Veri toplama
currentData.timestamp = millis();
currentData.temperature = readTemperature();
currentData.moisture = readMoisture();
currentData.pH = readPH();
currentData.heavy_metal_ppm = readHeavyMetal();
currentData.aflatoxin_ppb = readAflatoxin();
// Değerlendirme
bool passed = evaluateQuality(currentData);
// Veri kayıt
logData(currentData, passed);
// Ekran çıktısı
displayData(currentData, passed);
// Uyarı sistemi
if (!passed) {
triggerAlarm();
}
delay(60000); // 1 dakika
}
float readHeavyMetal() {
// Elektrokimyasal sensör okuma
int rawValue = analogRead(HEAVY_METAL_SENSOR);
// Kalibrasyon eğrisi: y = mx + b
float ppm = rawValue * 0.05 - 10.0; // Örnek kalibrasyon
return max(0.0, ppm);
}
float readAflatoxin() {
// ELISA benzeri optik okuma (spektrofotometre)
Wire.beginTransmission(SPECTRO_ADDR);
Wire.write(0x14); // 450 nm dalga boyu
Wire.endTransmission();
Wire.requestFrom(SPECTRO_ADDR, 2);
int absorbance = (Wire.read() << 8) | Wire.read();
// Kalibrasyon eğrisi ile ppb hesaplama
float ppb = 20.0 * exp(-0.001 * absorbance); // Ters orantılı
return ppb;
}
float readTemperature() {
int rawValue = analogRead(TEMP_SENSOR);
return (rawValue * 5.0 / 1024.0 - 0.5) * 100.0; // LM35
}
float readMoisture() {
int rawValue = analogRead(MOISTURE_SENSOR);
return rawValue / 1024.0 * 100.0; // Yüzde
}
float readPH() {
int rawValue = analogRead(pH_SENSOR);
return rawValue / 1024.0 * 14.0; // pH 0-14
}
bool evaluateQuality(QualityData data) {
bool passed = true;
// Ağır metal kontrolü (örnek: Pb <10 ppm)
if (data.heavy_metal_ppm > 10.0) {
Serial.println("✗ Ağır metal limiti aşıldı!");
passed = false;
}
// Aflatoksin kontrolü (<4 ppb EU limiti)
if (data.aflatoxin_ppb > 4.0) {
Serial.println("✗ Aflatoksin limiti aşıldı!");
passed = false;
}
// Nem kontrolü (%10-12)
if (data.moisture > 12.0) {
Serial.println("✗ Nem çok yüksek!");
passed = false;
}
// Sıcaklık kontrolü (15-25°C)
if (data.temperature < 15.0 || data.temperature > 25.0) {
Serial.println("⚠ Sıcaklık uygun değil!");
passed = false;
}
return passed;
}
void logData(QualityData data, bool passed) {
logFile = SD.open("quality_log.csv", FILE_WRITE);
if (logFile) {
logFile.print(data.timestamp);
logFile.print(",");
logFile.print(data.temperature);
logFile.print(",");
logFile.print(data.moisture);
logFile.print(",");
logFile.print(data.pH);
logFile.print(",");
logFile.print(data.heavy_metal_ppm);
logFile.print(",");
logFile.print(data.aflatoxin_ppb);
logFile.print(",");
logFile.println(passed ? "PASS" : "FAIL");
logFile.close();
}
}
void displayData(QualityData data, bool passed) {
Serial.println("\n=== Kalite Kontrol Raporu ===");
Serial.print("Zaman: "); Serial.print(data.timestamp / 1000); Serial.println(" sn");
Serial.print("Sıcaklık: "); Serial.print(data.temperature); Serial.println(" °C");
Serial.print("Nem: "); Serial.print(data.moisture); Serial.println(" %");
Serial.print("pH: "); Serial.println(data.pH);
Serial.print("Ağır Metal: "); Serial.print(data.heavy_metal_ppm); Serial.println(" ppm");
Serial.print("Aflatoksin: "); Serial.print(data.aflatoxin_ppb); Serial.println(" ppb");
Serial.print("Sonuç: "); Serial.println(passed ? "✓ UYGUN" : "✗ UYGUN DEĞİL");
Serial.println("===========================\n");
}
void triggerAlarm() {
// Buzzer/LED uyarısı
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
// Email/SMS bildirimi (WiFi/GSM modülü ile)
// sendAlert("Kalite kontrol başarısız!");
}
void calibrateSensors() {
Serial.println("Sensör kalibrasyonu başlatılıyor...");
// Kalibrasyon prosedürü
delay(5000);
Serial.println("Kalibrasyon tamamlandı.");
} - YAPAY ZEKA VE MAKİNE ÖĞRENMESİNİN FİTOTERAPİDE UYGULAMALARI
7.1. AI Destekli İlaç Keşfi
Geleneksel vs AI Yaklaşımı:
| Yöntem | Süre | Maliyet | Başarı Oranı |
|--------|------|---------|--------------|
| Geleneksel (High-throughput screening) | 3-5 yıl | $500M+ | %10-15 |
| AI Destekli (Virtual screening) | 6-12 ay | $50M+ | %25-30 |
Derin Öğrenme ile Moleküler Aktivite Tahmini:
python
import tensorflow as tf
from tensorflow import keras
from rdkit import Chem
from rdkit.Chem import AllChem
import numpy as np
class MolecularActivityPredictor:
def __init__(self, input_dim=2048):
self.input_dim = input_dim
self.model = self._build_model()
def _build_model(self):
"""Derin sinir ağı modeli"""
model = keras.Sequential([
keras.layers.Dense(1024, activation='relu', input_shape=(self.input_dim,)),
keras.layers.Dropout(0.3),
keras.layers.Dense(512, activation='relu'),
keras.layers.Dropout(0.3),
keras.layers.Dense(256, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(1, activation='sigmoid') # Binary classification
])
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy', 'AUC']
)
return model
def smiles_to_fingerprint(self, smiles):
"""SMILES → Morgan fingerprint"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return None
Morgan fingerprint (radius=2, 2048 bit)
fp = AllChem.GetMorganFingerprintAsBitVect(mol, 2, nBits=self.input_dim)
return np.array(fp)
def train(self, smiles_list, activity_labels, epochs=50, batch_size=32):
"""Model eğitimi"""
Fingerprint dönüşümü
X = np.array([self.smiles_to_fingerprint(s) for s in smiles_list])
y = np.array(activity_labels)
Eğitim
history = self.model.fit(
X, y,
epochs=epochs,
batch_size=batch_size,
validation_split=0.2,
verbose=1
)
return history
def predict(self, smiles):
"""Aktivite tahmini"""
fp = self.smiles_to_fingerprint(smiles)
if fp is None:
return None
fp = fp.reshape(1, -1)
prediction = self.model.predict(fp, verbose=0)
return prediction[0][0]
def virtual_screening(self, compound_library):
"""Sanal tarama"""
results = []
print("=== Sanal Tarama Başlatıldı ===\n")
for compound in compound_library:
smiles = compound['smiles']
name = compound['name']
activity_score = self.predict(smiles)
if activity_score is not None:
results.append({
'name': name,
'smiles': smiles,
'activity_score': activity_score
})
Skorlara göre sıralama
results = sorted(results, key=lambda x: x['activity_score'], reverse=True)
print(f"Toplam tarama: {len(results)} bileşik\n")
print("En yüksek skorlu 10 bileşik:")
for i, result in enumerate(results[:10], 1):
print(f"{i}. {result['name']}: {result['activity_score']:.4f}")
return results
Örnek kullanım: Antidepresan aktivite tahmini
Eğitim verisi (bilinen antidepresanlar ve inaktif moleküller)
training_data = {
'smiles': [
Aktif (1)
'CN(C)CCC=C1c2ccccc2CCc2ccccc12', # Amitriptyline
'CNCCC(c1ccc(OC)cc1)c1cccs1', # Duloxetine
'CN1C[C@H]2CC[C@@H]1C[C@@H]([C@@H]2OC(=O)C(CO)c1ccccc1)C(=O)OC', # Cocaine (örnek)
İnaktif (0)
'CC(C)Cc1ccc(cc1)C(C)C(=O)O', # Ibuprofen
'CC(=O)Oc1ccccc1C(=O)O', # Aspirin
],
'activity': [1, 1, 1, 0, 0]
}
Model oluşturma ve eğitim
predictor = MolecularActivityPredictor()
history = predictor.train(
training_data['smiles'],
training_data['activity'],
epochs=100
)
Hypericum bileşiklerini tarama
hypericum_compounds = [
{'name': 'Hypericin', 'smiles': 'Cc1cc2c(c(c1O)C)C(=O)c1c(O)c3c(c(O)c1C2=O)C(=O)c1c(O)cc(C)c(O)c1C3=O'},
{'name': 'Hyperforin', 'smiles': 'CC(C)C[C@H]1C(=O)C2=C([C@@]1(C)CC=C(C)C)C(=O)[C@@]1(C)CC[C@H](C(C)(C)CC=C(C)C)C(=O)[C@]1(O)C2'},
{'name': 'Quercetin', 'smiles': 'O=c1c(O)c(-c2ccc(O)c(O)c2)oc2cc(O)cc(O)c12'},
{'name': 'Rutin', 'smiles': 'CC1OC(OCC2OC(Oc3c(-c4ccc(O)c(O)c4)oc4cc(O)cc(O)c4c3=O)C(O)C(O)C2O)C(O)C(O)C1O'}
]
results = predictor.virtual_screening(hypericum_compounds)
En yüksek skorlu bileşik
best_hit = results[0]
print(f"\n En Promising Bileşik: {best_hit['name']}")
print(f" Aktivite Skoru: {best_hit['activity_score']:.4f}")
print(f" Önerilen Aksiyon: In vitro validasyon çalışmaları")
7.2. Kişiselleştirilmiş Fitoterapi
Hedef: Hasta profiline göre optimal bitkisel ilaç seçimi ve dozajı
Girdiler:
- Genetik profil (farmakogenomik)
- Demografik veriler
- Hastalık öyküsü
- Mevcut ilaçlar
- Laboratuvar sonuçları
- Yaşam tarzı faktörleri
python
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
import joblib
class PersonalizedPhytotherapyAI:
def __init__(self):
self.model = None
self.scaler = StandardScaler()
self.feature_names = []
def prepare_patient_data(self, patient_info):
"""Hasta verilerini işleme"""
features = {
'age': patient_info['age'],
'weight': patient_info['weight_kg'],
'gender_male': 1 if patient_info['gender'] == 'M' else 0,
Genetik markörler (örnek)
'CYP2D6_poor_metabolizer': patient_info.get('CYP2D6_PM', 0),
'CYP3A4_inducer': patient_info.get('CYP3A4_inducer', 0),
Klinik parametreler
'depression_severity_HAMD': patient_info['HAMD_score'],
'liver_function_ALT': patient_info['ALT'],
'renal_function_eGFR': patient_info['eGFR'],
Komorbidite
'diabetes': patient_info.get('diabetes', 0),
'hypertension': patient_info.get('hypertension', 0),
Komedikasyon
'taking_warfarin': patient_info.get('warfarin', 0),
'taking_SSRI': patient_info.get('SSRI', 0),
Yaşam tarzı
'sun_exposure_hours': patient_info.get('sun_exposure', 2),
'smoking': patient_info.get('smoking', 0)
}
return pd.DataFrame([features])
def train_model(self, historical_data):
"""Geçmiş veri ile model eğitimi"""
X = historical_data.drop(['patient_id', 'treatment', 'response'], axis=1)
y = historical_data['response'] # 1: yanıt verdi, 0: yanıt vermedi
self.feature_names = X.columns.tolist()
Normalizasyon
X_scaled = self.scaler.fit_transform(X)
Model eğitimi
self.model = RandomForestClassifier(
n_estimators=200,
max_depth=10,
min_samples_split=10,
random_state=42
)
self.model.fit(X_scaled, y)
print("Model eğitimi tamamlandı.")
print(f"Özellik sayısı: {len(self.feature_names)}")
def recommend_treatment(self, patient_info):
"""Tedavi önerisi"""
Hasta verisini hazırlama
X_patient = self.prepare_patient_data(patient_info)
X_patient_scaled = self.scaler.transform(X_patient)
Farklı tedavi seçenekleri
treatments = [
{'name': 'Hypericum 300mg', 'dose_mg': 300},
{'name': 'Hypericum 600mg', 'dose_mg': 600},
{'name': 'Hypericum 900mg', 'dose_mg': 900},
{'name': 'Plasebo', 'dose_mg': 0}
]
recommendations = []
for treatment in treatments:
Her tedavi için yanıt olasılığı tahmini
response_prob = self.model.predict_proba(X_patient_scaled)[0][1]
Risk değerlendirmesi
risk_score = self._calculate_risk(patient_info, treatment)
Fayda-risk oranı
benefit_risk_ratio = response_prob / (risk_score + 0.01) # +0.01 sıfıra bölmeyi önler
recommendations.append({
'treatment': treatment['name'],
'response_probability': response_prob,
'risk_score': risk_score,
'benefit_risk_ratio': benefit_risk_ratio
})
En iyi öneriye göre sıralama
recommendations = sorted(
recommendations,
key=lambda x: x['benefit_risk_ratio'],
reverse=True
)
return recommendations
def _calculate_risk(self, patient_info, treatment):
"""Risk skoru hesaplama"""
risk = 0.1 # Bazal risk
Fotosensitivite riski (Hypericum)
if 'Hypericum' in treatment['name']:
sun_exposure = patient_info.get('sun_exposure', 2)
risk += sun_exposure * 0.05
İlaç etkileşim riski
if patient_info.get('warfarin', 0) == 1 and 'Hypericum' in treatment['name']:
risk += 0.3 # Ciddi etkileşim
if patient_info.get('SSRI', 0) == 1 and 'Hypericum' in treatment['name']:
risk += 0.4 # Serotonin sendromu riski
Karaciğer fonksiyon bozukluğu
if patient_info['ALT'] > 40:
risk += 0.2
Yüksek doz riski
if treatment['dose_mg'] > 600:
risk += 0.1
return min(risk, 1.0) # Maksimum 1.0
def generate_report(self, patient_info, recommendations):
"""Hasta raporu oluşturma"""
report = f""" ╔══════════════════════════════════════════════════════════════╗
║ KİŞİSELLEŞTİRİLMİŞ FİTOTERAPİ RAPORU ║
╚══════════════════════════════════════════════════════════════╝
HASTA BİLGİLERİ:
─────────────────────────────────────────────────────────────
Yaş: {patient_info['age']} yıl
Cinsiyet: {patient_info['gender']}
Kilo: {patient_info['weight_kg']} kg
HAM-D Skoru: {patient_info['HAMD_score']} (Orta-ağır depresyon)
GENETİK PROFİL:
─────────────────────────────────────────────────────────────
CYP2D6: {'Zayıf metabolize edici' if patient_info.get('CYP2D6_PM') else 'Normal'}
CYP3A4: {'İndüklenmiş' if patient_info.get('CYP3A4_inducer') else 'Normal'}
KOMORBID İTE VE KOMEDİKASYON:
─────────────────────────────────────────────────────────────
Diyabet: {'Var' if patient_info.get('diabetes') else 'Yok'}
Hipertansiyon: {'Var' if patient_info.get('hypertension') else 'Yok'}
Warfarin kullanımı: {'Var' if patient_info.get('warfarin') else 'Yok'}
SSRI kullanımı: {'Var' if patient_info.get('SSRI') else 'Yok'}
TEDAVİ ÖNERİLERİ (Fayda-Risk Oranına Göre):
═════════════════════════════════════════════════════════════
for i, rec in enumerate(recommendations, 1):
report += f"""
{i}. {rec['treatment']}
• Yanıt Olasılığı: {rec['response_probability']:.1%}
• Risk Skoru: {rec['risk_score']:.2f}
• Fayda/Risk Oranı: {rec['benefit_risk_ratio']:.2f}
En iyi öneri
best = recommendations[0]
report += f"""
═════════════════════════════════════════════════════════════
ÖNERİLEN TEDAVİ: {best['treatment']}
═════════════════════════════════════════════════════════════
ÖZEL UYARILAR:
─────────────────────────────────────────────────────────────
Özel uyarılar
if patient_info.get('warfarin'):
report += "\n ⚠️ Warfarin etkileşimi: INR sık takip edilmeli"
if patient_info.get('SSRI'):
report += "\n ⚠️ Serotonin sendromu riski: Semptomları izle"
if patient_info.get('sun_exposure', 0) > 3:
report += "\n ⚠️ Fotosensitivite riski: Güneş koruyucu kullan"
report += """
═════════════════════════════════════════════════════════════
Not: Bu rapor bir örnektir.
Nihai karar hekime aittir.
════════════════════════════════════════════════════════════
return report
Örnek kullanım
personalized_ai = PersonalizedPhytotherapyAI()
Geçmiş veri ile eğitim (simüle edilmiş)
np.random.seed(42)
historical_data = pd.DataFrame({
'patient_id': range(1, 501),
'age': np.random.randint(18, 70, 500),
'weight': np.random.normal(70, 15, 500),
'gender_male': np.random.binint(0, 2, 500),
'CYP2D6_poor_metabolizer': np.random.binomial(1, 0.07, 500),
'CYP3A4_inducer': np.random.binomial(1, 0.15, 500),
'depression_severity_HAMD': np.random.randint(17, 30, 500),
'liver_function_ALT': np.random.normal(25, 10, 500),
'renal_function_eGFR': np.random.normal(90, 20, 500),
'diabetes': np.random.binomial(1, 0.10, 500),
'hypertension': np.random.binomial(1, 0.25, 500),
'taking_warfarin': np.random.binomial(1, 0.05, 500),
'taking_SSRI': np.random.binomial(1, 0.15, 500),
'sun_exposure_hours': np.random.randint(0, 6, 500),
'smoking': np.random.binomial(1, 0.20, 500),
'treatment': np.random.choice(['Hypericum_600mg', 'Hypericum_900mg', 'Placebo'], 500),
'response': np.random.binomial(1, 0.6, 500)
})
personalized_ai.train_model(historical_data)
Yeni hasta
new_patient = {
'age': 45,
'weight_kg': 75,
'gender': 'F',
'CYP2D6_PM': 0,
'CYP3A4_inducer': 0,
'HAMD_score': 24,
'ALT': 28,
'eGFR': 95,
'diabetes': 0,
'hypertension': 1,
'warfarin': 1, # Kritik etkileşim!
'SSRI': 0,
'sun_exposure': 4,
'smoking': 0
}
Tedavi önerileri
recommendations = personalized_ai.recommend_treatment(new_patient)
Rapor oluşturma
report = personalized_ai.generate_report(new_patient, recommendations)
print(report)
Çıktı Yorumu:
Sistem, warfarin kullanan hasta için Hypericum yerine alternatif tedavi önerebilir veya düşük doz + yakın INR takibi ile risk yönetimi stratejisi sunabilir.
7.3. AI ile Klinik Karar Destek Sistemi
Gerçek Zamanlı Hasta İzleme ve Müdahale Önerisi:
python
import numpy as np
from datetime import datetime, timedelta
import pandas as pd
from sklearn.ensemble import GradientBoostingRegressor
class ClinicalDecisionSupport:
def __init__(self):
self.symptom_model = GradientBoostingRegressor()
self.alert_thresholds = {
'HAMD_increase': 5,
'liver_enzyme_increase': 2.0, # katlar
'adverse_event_severity': 3
}
def monitor_patient(self, patient_id, longitudinal_data):
"""Longitudinal veri analizi"""
df = pd.DataFrame(longitudinal_data)
df['date'] = pd.to_datetime(df['date'])
df = df.sort_values('date')
print(f"=== Hasta {patient_id} İzlem Raporu ===\n")
Trend analizi
hamd_trend = self._analyze_trend(df['HAMD_score'].values)
alt_trend = self._analyze_trend(df['ALT'].values)
alerts = []
HAM-D skor değişimi
if len(df) >= 2:
baseline_hamd = df.iloc[0]['HAMD_score']
current_hamd = df.iloc[-1]['HAMD_score']
hamd_change = baseline_hamd - current_hamd
if hamd_change < -self.alert_thresholds['HAMD_increase']:
alerts.append({
'type': 'DETERIORATION',
'message': f'HAM-D skoru {abs(hamd_change):.0f} puan arttı!',
'action': 'Acil psikiyatrik değerlendirme'
})
Karaciğer enzim yüksekliği
baseline_alt = df.iloc[0]['ALT']
current_alt = df.iloc[-1]['ALT']
alt_ratio = current_alt / baseline_alt
if alt_ratio > self.alert_thresholds['liver_enzyme_increase']:
alerts.append({
'type': 'HEPATOTOXICITY',
'message': f'ALT {alt_ratio:.1f}x arttı (Baseline: {baseline_alt:.0f}, Current: {current_alt:.0f})',
'action': 'Tedaviyi durdur, hepatoloji konsültasyonu'
})
Yan etki kontrolü
recent_ae = df[df['adverse_event_severity'] >= self.alert_thresholds['adverse_event_severity']]
if len(recent_ae) > 0:
for _, ae in recent_ae.iterrows():
alerts.append({
'type': 'ADVERSE_EVENT',
'message': f"Ciddi yan etki: {ae['adverse_event_type']} (Grade {ae['adverse_event_severity']})",
'action': 'Yan etki yönetimi protokolü uygula'
})
Görselleştirme
self._plot_monitoring(df, patient_id)
Öneriler
recommendations = self._generate_recommendations(df, hamd_trend, alt_trend, alerts)
return {
'alerts': alerts,
'recommendations': recommendations,
'hamd_trend': hamd_trend,
'alt_trend': alt_trend
}
def _analyze_trend(self, values):
"""Basit trend analizi"""
if len(values) < 2:
return 'INSUFFICIENT_DATA'
Lineer regresyon slope
x = np.arange(len(values))
slope = np.polyfit(x, values, 1)[0]
if abs(slope) < 0.5:
return 'STABLE'
elif slope > 0.5:
return 'INCREASING'
else:
return 'DECREASING'
def _plot_monitoring(self, df, patient_id):
"""Monitoring grafiği"""
import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 1, figsize=(12, 8))
HAM-D skoru
axes[0].plot(df['date'], df['HAMD_score'], 'o-', linewidth=2, markersize=8)
axes[0].axhline(y=7, color='g', linestyle='--', label='Remisyon (<7)')
axes[0].set_ylabel('HAM-D Skoru')
axes[0].set_title(f'Hasta {patient_id} - Depresyon Semptomu İzlemi')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
ALT düzeyi
axes[1].plot(df['date'], df['ALT'], 's-', color='orange', linewidth=2, markersize=8)
axes[1].axhline(y=40, color='r', linestyle='--', label='Üst Normal Limit')
axes[1].set_ylabel('ALT (U/L)')
axes[1].set_xlabel('Tarih')
axes[1].set_title('Karaciğer Fonksiyon İzlemi')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
def _generate_recommendations(self, df, hamd_trend, alt_trend, alerts):
"""Aksiyon önerileri"""
recommendations = []
HAM-D trend bazlı
if hamd_trend == 'DECREASING':
recommendations.append("✓ Tedavi yanıtı olumlu, mevcut dozda devam")
elif hamd_trend == 'STABLE' and df.iloc[-1]['HAMD_score'] > 7:
recommendations.append("⚠ Yanıt yetersiz, doz artışı düşünülebilir")
elif hamd_trend == 'INCREASING':
recommendations.append(" Kötüleşme var, alternatif tedavi değerlendir")
ALT trend bazlı
if alt_trend == 'INCREASING':
recommendations.append("⚠ ALT yükselmesi, karaciğer fonksiyonlarını sık takip et")
Alert bazlı
if len(alerts) > 0:
recommendations.append(f" {len(alerts)} adet aktif uyarı - Acil değerlendirme")
return recommendations
Kullanım örneği
cds = ClinicalDecisionSupport()
Longitudinal veri (8 haftalık takip)
patient_data = [
{'date': '2026-01-01', 'HAMD_score': 24, 'ALT': 28, 'adverse_event_type': None, 'adverse_event_severity': 0},
{'date': '2026-01-15', 'HAMD_score': 20, 'ALT': 32, 'adverse_event_type': 'Nausea', 'adverse_event_severity': 1},
{'date': '2026-02-01', 'HAMD_score': 16, 'ALT': 38, 'adverse_event_type': None, 'adverse_event_severity': 0},
{'date': '2026-02-15', 'HAMD_score': 13, 'ALT': 45, 'adverse_event_type': None, 'adverse_event_severity': 0},
{'date': '2026-03-01', 'HAMD_score': 10, 'ALT': 62, 'adverse_event_type': 'Photosensitivity', 'adverse_event_severity': 2},
{'date': '2026-03-15', 'HAMD_score': 8, 'ALT': 85, 'adverse_event_type': None, 'adverse_event_severity': 0},
]
results = cds.monitor_patient('P12345', patient_data)
Sonuçları yazdırma
print("\n UYARILAR:")
for alert in results['alerts']:
print(f" [{alert['type']}] {alert['message']}")
print(f" → Aksiyon: {alert['action']}\n")
print(" ÖNERİLER:")
for rec in results['recommendations']:
print(f" {rec}")
print(f"\n TRENDLER:")
print(f" HAM-D: {results['hamd_trend']}")
print(f" ALT: {results['alt_trend']}")
8. ENTEGRE SİSTEM MİMARİSİ: TARLADAN HASTAYA
8.1. IoT Tabanlı Tam Döngü İzleme Sistemi
Sistem Bileşenleri:
┌─────────────────────────────────────────────────────────────┐
│ BULUT PLATFORMU │
│ ┌───────────────┐ ┌──────────────┐ ┌─────────────┐ │
│ │ Veri Merkezi │ │ AI/ML Motor │ │ Dashboard │ │
│ └───────┬───────┘ └──────┬───────┘ └──────┬──────┘ │
└──────────┼──────────────────┼──────────────────┼────────────┘
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌─────────────┐ ┌──────────────┐
│ EDGE │ │ API │ │ Web/Mobile │
│ GATEWAY │ │ Services │ │ Client │
└──────┬───────┘ └─────────────┘ └──────────────┘
│
┌──────┴────────────────────────────────────┐
│ SENSOR NETWORK │
├───────────────┬───────────────┬────────────┤
│ │ │ │
┌───▼────┐ ┌────▼─────┐ ┌────▼─────┐ ┌──▼──────┐
│ TARLA │ │ DEPO │ │ ÜRETİM │ │ KLİNİK │
│ │ │ │ │ │ │ │
│ • Toprak│ │ • Sıcaklık│ │ • Kalite │ │ • Hasta │
│ • İklim │ │ • Nem │ │ • HPLC │ │ Vitalı │
│ • Sulama│ │ • Aflatox│ │ • Batch │ │ • Lab │
└────────┘ └──────────┘ └──────────┘ └─────────┘
8.2. Uçtan Uca Uygulama Örneği: Hypericum Üretim-Tedavi Zinciri
Senaryo: Hypericum perforatum ekstraktı üretimi ve depresyon tedavisinde kullanımı
python
Python - Merkezi Kontrol ve Analiz Sistemi
import asyncio
import json
from datetime import datetime
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
class HypericumProductionChain:
def __init__(self):
self.field_data = []
self.storage_data = []
self.production_batches = []
self.clinical_data = []
async def monitor_field(self, field_id):
"""Tarla sensör verilerini izleme"""
Arduino/ESP32'den gelen veri simülasyonu
field_reading = {
'timestamp': datetime.now().isoformat(),
'field_id': field_id,
'soil_moisture': np.random.uniform(30, 60), # %
'temperature': np.random.uniform(18, 28), # °C
'rainfall': np.random.uniform(0, 10), # mm
'hypericin_content_predicted': None
}
AI modeli ile hiperisin içeriği tahmini
field_reading['hypericin_content_predicted'] = self._predict_hypericin(
field_reading['soil_moisture'],
field_reading['temperature'],
field_reading['rainfall']
)
self.field_data.append(field_reading)
Optimal hasat zamanı önerisi
if field_reading['hypericin_content_predicted'] > 0.28:
print(f"🌱 Alan {field_id}: Optimal hasat zamanı! (Tahmin: {field_reading['hypericin_content_predicted']:.2%} hiperisin)")
return 'READY_TO_HARVEST'
return 'GROWING'
def _predict_hypericin(self, moisture, temp, rain):
"""Hiperisin içeriği tahmini (basitleştirilmiş model)"""
Gerçekte ML modeli kullanılır
optimal_moisture = 45
optimal_temp = 23
moisture_factor = 1 - abs(moisture - optimal_moisture) / 50
temp_factor = 1 - abs(temp - optimal_temp) / 20
base_content = 0.003 # %0.3
predicted = base_content * (moisture_factor + temp_factor) / 2
return max(0.001, min(0.005, predicted))
async def monitor_storage(self, batch_id):
"""Depo koşulları izleme"""
storage_reading = {
'timestamp': datetime.now().isoformat(),
'batch_id': batch_id,
'temperature': np.random.uniform(18, 22),
'humidity': np.random.uniform(8, 14),
'aflatoxin_ppb': np.random.uniform(0, 5)
}
self.storage_data.append(storage_reading)
Kalite kontrol
alerts = []
if storage_reading['humidity'] > 12:
alerts.append('Yüksek nem! Küflenme riski.')
if storage_reading['aflatoxin_ppb'] > 4:
alerts.append('Aflatoksin limiti aşıldı! Parti reddedilmeli.')
if len(alerts) > 0:
print(f"⚠️ Depo Uyarısı (Parti {batch_id}):")
for alert in alerts:
print(f" - {alert}")
return 'QUALITY_ISSUE'
return 'OK'
async def monitor_production(self, batch_id):
"""Üretim HPLC analizi simülasyonu"""
Gerçekte HPLC cihazından veri alınır
hplc_results = {
'timestamp': datetime.now().isoformat(),
'batch_id': batch_id,
'hypericin_percent': np.random.uniform(0.25, 0.35),
'hyperforin_percent': np.random.uniform(3.0, 5.5),
'total_flavonoids_percent': np.random.uniform(5, 8)
}
self.production_batches.append(hplc_results)
Standardizasyon kontrolü
spec_pass = (
0.25 <= hplc_results['hypericin_percent'] <= 0.35 and
3.0 <= hplc_results['hyperforin_percent'] <= 5.5
)
if spec_pass:
print(f"✓ Parti {batch_id}: SPESİFİKASYONDA")
print(f" Hiperisin: {hplc_results['hypericin_percent']:.2%}")
print(f" Hiperforin: {hplc_results['hyperforin_percent']:.2%}")
return 'RELEASE'
else:
print(f"✗ Parti {batch_id}: SPESİFİKASYON DIŞI")
return 'REJECT'
async def monitor_clinical_outcome(self, patient_id, batch_id):
"""Klinik sonuç izleme"""
outcome = {
'timestamp': datetime.now().isoformat(),
'patient_id': patient_id,
'batch_id': batch_id,
'baseline_HAMD': np.random.randint(20, 28),
'week_8_HAMD': None,
'response': None,
'adverse_events': []
}
8 hafta sonrası simülasyon
await asyncio.sleep(0.1) # Gerçekte 8 hafta
outcome['week_8_HAMD'] = max(0, outcome['baseline_HAMD'] - np.random.randint(8, 15))
outcome['response'] = (outcome['baseline_HAMD'] - outcome['week_8_HAMD']) >= (0.5 * outcome['baseline_HAMD'])
Yan etkiler (ürün kalitesi ile ilişkili)
batch = next((b for b in self.production_batches if b['batch_id'] == batch_id), None)
if batch and batch['hypericin_percent'] > 0.32:
Yüksek hiperisin → fotosensitivite riski
if np.random.random() < 0.15:
outcome['adverse_events'].append('Photosensitivity_Grade2')
self.clinical_data.append(outcome)
print(f"\n👤 Hasta {patient_id} (Parti {batch_id}):")
print(f" Baseline HAM-D: {outcome['baseline_HAMD']}")
print(f" 8. Hafta HAM-D: {outcome['week_8_HAMD']}")
print(f" Yanıt: {'✓ Evet' if outcome['response'] else '✗ Hayır'}")
if len(outcome['adverse_events']) > 0:
print(f" Yan Etkiler: {', '.join(outcome['adverse_events'])}")
return outcome
def generate_traceability_report(self, patient_id):
"""İzlenebilirlik raporu (Farm to Patient)"""
patient_outcome = next((c for c in self.clinical_data if c['patient_id'] == patient_id), None)
if not patient_outcome:
print("Hasta bulunamadı.")
return
batch_id = patient_outcome['batch_id']
batch_production = next((b for b in self.production_batches if b['batch_id'] == batch_id), None)
İlgili depo ve tarla verilerini bul (basitleştirilmiş)
batch_storage = [s for s in self.storage_data if s['batch_id'] == batch_id]
report = f"""
╔═══════════════════════════════════════════════════════════════╗
║ İZLENEBİLİRLİK RAPORU (FARM TO PATIENT) ║
╚═══════════════════════════════════════════════════════════════╝
HASTA BİLGİSİ:
─────────────────────────────────────────────────────────────────
Hasta ID: {patient_id}
Parti No: {batch_id}
Tedavi Sonucu: {'Yanıt verdi ✓' if patient_outcome['response'] else 'Yanıt vermedi ✗'}
Baseline → 8.Hafta: {patient_outcome['baseline_HAMD']} → {patient_outcome['week_8_HAMD']}
ÜRETİM BİLGİSİ:
─────────────────────────────────────────────────────────────────
if batch_production:
report += f"""
Analiz Tarihi: {batch_production['timestamp']}
Hiperisin: {batch_production['hypericin_percent']:.3%}
Hiperforin: {batch_production['hyperforin_percent']:.2%}
Toplam Flavonoit: {batch_production['total_flavonoids_percent']:.2%}
if len(batch_storage) > 0:
avg_temp = np.mean([s['temperature'] for s in batch_storage])
avg_humidity = np.mean([s['humidity'] for s in batch_storage])
max_aflatoxin = max([s['aflatoxin_ppb'] for s in batch_storage])
report += f"""
DEPOLAMA KOŞULLARI:
─────────────────────────────────────────────────────────────────
Ortalama Sıcaklık: {avg_temp:.1f}°C
Ortalama Nem: {avg_humidity:.1f}%
Maksimum Aflatoksin: {max_aflatoxin:.2f} ppb
report += """
═══════════════════════════════════════════════════════════════
Bu rapor, bitkisel ilacın tarladan hastaya tüm üretim zincirini
izlenebilir hale getirir ve kalite güvencesi sağlar.
═══════════════════════════════════════════════════════════════
print(report)
Ana sistem simülasyonu
async def main():
system = HypericumProductionChain()
print("=== HYPERICUM ÜRETİM ZİNCİRİ SİMÜLASYONU ===\n")
1. Tarla İzleme
print("1. TARLA İZLEME")
print("─" * 50)
field_status = await system.monitor_field('FIELD_001')
print()
2. Depo İzleme
print("2. DEPO İZLEME")
print("─" * 50)
storage_status = await system.monitor_storage('BATCH_2026_001')
print()
3. Üretim Kontrolü
print("3. ÜRETİM KALİTE KONTROLÜ")
print("─" * 50)
production_status = await system.monitor_production('BATCH_2026_001')
print()
4. Klinik İzleme
print("4. KLİNİK SONUÇ İZLEME")
print("─" * 50)
await system.monitor_clinical_outcome('P12345', 'BATCH_2026_001')
print()
5. İzlenebilirlik Raporu
print("\n5. İZLENEBİLİRLİK RAPORU")
print("=" * 65)
system.generate_traceability_report('P12345')
Çalıştırma
asyncio.run(main())
8.3. Mobil Hasta Uygulaması - React Native (Kavramsal)
javascript
// HypericumPatientApp.js - Mobil uygulama ana ekran
import React, { useState, useEffect } from 'react';
import { View, Text, Button, Alert } from 'react-native';
import axios from 'axios';
const HypericumPatientApp = () => {
const [patientData, setPatientData] = useState(null);
const [symptoms, setSymptoms] = useState([]);
const [medication, setMedication] = useState(null);
useEffect(() => {
loadPatientData();
}, []);
const loadPatientData = async () => {
try {
const response = await axios.get('https://api.phytotherapy.com/patient/me');
setPatientData(response.data);
setMedication(response.data.current_medication);
} catch (error) {
Alert.alert('Hata', 'Veri yüklenemedi');
}
};
const logSymptom = async (symptomType, severity) => {
const symptomData = {
date: new Date().toISOString(),
type: symptomType,
severity: severity, // 1-10
medication_batch: medication.batch_id
};
try {
await axios.post('https://api.phytotherapy.com/symptoms', symptomData);
// AI analizi tetikle
const aiResponse = await axios.post(
'https://api.phytotherapy.com/ai/analyze',
{ patient_id: patientData.id, symptom: symptomData }
);
if (aiResponse.data.alert) {
Alert.alert('Uyarı', aiResponse.data.message);
}
} catch (error) {
Alert.alert('Hata', 'Semptom kaydedilemedi');
}
};
const checkDrugInteraction = async (newMedication) => {
try {
const response = await axios.post(
'https://api.phytotherapy.com/interactions/check',
{
current: medication.name,
new: newMedication
}
);
if (response.data.interaction_risk === 'HIGH') {
Alert.alert(
'Ciddi Etkileşim!',
response.data.message + '\n\nDoktorunuza danışın.',
[{ text: 'Tamam', style: 'cancel' }]
);
}
} catch (error) {
console.error(error);
}
};
return (
Hypericum Tedavi Takibi
{patientData && (
Hasta: {patientData.name}
İlaç: {medication.name} ({medication.batch_id})
Doz: {medication.dose_mg} mg/gün
)}
title="Semptom Kaydet"
onPress={() => logSymptom('depression', 5)}
/>
title="İlaç Etkileşimi Kontrol"
onPress={() => checkDrugInteraction('Warfarin')}
/>
);
};
export default HypericumPatientApp;
9. SONUÇ VE GELECEĞİN FİTOTERAPİSİ
9.1. Mevcut Durum Değerlendirmesi
Bitkisel ilaçlar, insanlık tarihinin en eski tedavi yöntemlerinden modern bilimsel ürünlere doğru değişim geçirmiştir. Ancak halen karşılaşılan zorluklar:
Teknik Zorluklar:
Standardizasyon kompleksliği
Farmakokinetik/farmakodinamik verilerin yetersizliği
Çoklu bileşen sinerjisi anlaşılması
Bitki-bitki, bitki-ilaç etkileşimleri
Regulatuar Zorluklar:
Ülkeler arası farklı yasal düzenlemeler
Klinik kanıt gereksinimleri
Gıda destekleri vs bitkisel ilaç ayrımı
Pazar Zorlukları:
Tağşişat ve kontaminasyon
Kalitesiz ürünlerin yaygınlığı
Bilimsel olmayan iddialar
9.2. Yapay Zeka ve Teknolojinin Katkısı
Modern teknolojilerin entegrasyonu, bu zorlukların üstesinden gelmeyi mümkün kılmaktadır:
AI/ML Uygulamaları:
İlaç Keşfi: Virtual screening ile hızlı lead bulma
Kişiselleştirme: Hasta profiline göre optimal tedavi seçimi
Farmakovijilans: Erken yan etki sinyali tespiti
Kalite Kontrol: Otomatik spektral analiz ve parmak izi tanıma
IoT ve Sensör Ağları:
Tarım: Optimal yetiştirme koşulları izleme
Üretim: Gerçek zamanlı kalite kontrol
Klinik: Hasta izleme ve adherans takibi
İzlenebilirlik: Farm-to-patient traceability
Gömülü Sistemler:
Edge Computing: Sensör verilerinin yerel işlenmesi
TinyML: Mikrodenetleyicide AI modeli çalıştırma
Enerji Verimliliği: Uzun süreli izleme sistemleri
