Yapay Zekanın Yazılım Test Süreçlerinde Kullanımı

Published in

HangiKredi

11 min readSep 30, 2024

Merhaba değerli meraklı :), Şimdi güzel bir konuyu ele alacağız: Ne ile harmanlarsak harikalar yaratan bir lezzet yani Yapay Zeka’ yı. Burada Yazılım Test ve Test Otomasyon Süreçleri ile harmanlayıp neler ile karşılaşacağımızı beraber inceleyeceğiz, burada hazır data kullanacağım.
- Fakat gerçek bir projede kullanılmak istersek, veri setleri sağlanarak kolaylıkla sonuç verecek içerikler barındıracaktır.

Yapay zeka (AI), hayal edildiği zaman ; Yazılım test süreçlerini geliştirerek daha verimli, doğru ve ölçeklenebilir hale getirme potansiyeline sahiptir.

Bu makalede, yapay zekanın yazılım testinde nasıl kullanıldığını ve kullanılabileceğini, kod örnekleri ve bakış açıları ile detaylı bir şekilde ele alacağız. Ayrıca, bir Proof of Concept (PoC) hazırlayarak yapay zekanın test tarafında nasıl kullanılabileceğini göstermeye çalışacağım.

Yapay Zeka Tabanlı Test Otomasyonu

Yapay zeka, test otomasyonunu daha akıllı ve uyarlanabilir hale getirir. Geleneksel test otomasyonu, önceden tanımlanmış betiklere dayanırken, yapay zeka dinamik olarak test senaryoları oluşturabilir ve güncelleyebilir. Bu, özellikle büyük ve karmaşık projelerde büyük avantaj sağlar.

Test Otomasyonunda AI’nın Kapsamı

Yapay zeka ile test otomasyonu aşağıdaki alanlarda yaygın olarak kullanılmaktadır:

Tahmine Dayalı Analiz: Yapay zeka, gelecekte oluşabilecek hataları ve performans sorunlarını tahmin etmede kullanılabilir.
Anomali Tespiti: AI, test sonuçlarını sürekli izler ve beklenmeyen sapmaları (anomalileri) tespit ederken ekibe destek sağlar.
Test Sonucu Optimizasyonu: Sürekli öğrenen yapay zeka algoritmaları, test sonuçlarının doğruluğunu artırmak için öğrenme sağlar.

Yapay Zeka ile Gerçekleştirilebilecek Test Tipleri

HangiKredi için hazırlamış olduğumuz yapıdan yola çıkarak bir deneme yapacağım. Basit bir Naive Bayes kullanarak senaryonun sonucunu tahmin edeceğiz.

Burada bazı caseler fail, pass ve broken almış. Yani çıktılarımız bu 3 ihtimalden biri olabilir. (result daha da detaylandırılabilir bence anlamlandırılırsa eğer basit olması açısından böyle ilerliyorum)

Şimdi bir kod üzerinde gösterelim: Fail ve Pass resultlarını baz alacağım ben, veriyle besleyeceğimiz daha büyük bir seti buraya entegrede edip öğrenmesini sağlayabiliriz.

Burada, basit bir Naive Bayes modeli kullanarak yeni bir test senaryosunun sonucunu tahmin etmek istedim. Bu tür modeller, geçmiş test verilerinden öğrenerek gelecekteki test senaryolarını daha doğru bir şekilde tahmin edebilir.

Result :

Get Credit Card Information verisinin çıktısını fail ile değiştirdiğim için çıktının fail olmasını bekliyorum ve öylede oluyor.

Şimdi ise: Bir yazılım projesinde kodun hatalı olup olmadığını tahmin etmek için bir Random Forest modelinin nasıl kullanılacağını göstereceğim.

Adım adım inceleyelim:

Gerekli Kütüphanelerin import edelim:

from sklearn.ensemble import RandomForestClassifier
import numpy as np
import pandas as pd

Bu adımda, RandomForestClassifier sınıfını sklearn.ensemble kütüphanesinden ve numpy ile pandas kütüphanelerini içe aktarıyoruz. RandomForestClassifier, hata tahmini için kullanacağımız makine öğrenmesi modelidir. numpy ve pandas ise veri işleme için kullanılır.

Örnek Veri Setinin Oluşturulması :

data = {
    'lines_of_code': [100, 200, 150, 300, 250],
    'complexity': [10, 20, 15, 30, 25],
    'bugs': [1, 0, 1, 0, 1]
}

df = pd.DataFrame(data)

Bu adımda, örnek bir veri seti oluşturuyoruz. Veri seti, her bir kod parçası için satır sayısı (lines_of_code), karmaşıklık (complexity) ve hata durumu (bugs) bilgilerini içerir. Bu veriler, bir pandas DataFrame’e dönüştürülür.

Özellikler ve Hedef Değişkenin Belirlenmesi :

X = df[['lines_of_code', 'complexity']]
y = df['bugs']

Bu adımda, modelin eğitilmesi için kullanılacak özellikler (lines_of_code ve complexity) ve hedef değişken (bugs) belirlenir. X, özellikleri içeren DataFrame, y ise hedef değişkeni içeren seridir.

Random Forest Modelinin Eğitilmesi:

model = RandomForestClassifier()
model.fit(X, y)

Bu adımda, RandomForestClassifier sınıfından bir model oluşturulur ve fit metodu kullanılarak model eğitilir. Model, X ve y verilerini kullanarak kod parçalarının hatalı olup olmadığını öğrenir.

Yeni Bir Kod Parçasının Hata Tahmini :

new_code = np.array([[180, 18]])
prediction = model.predict(new_code)

print(f'New Code Bug Prediction: {prediction[0]}')

Bu adımda, yeni bir kod parçasının hata tahmini yapılır. new_code, satır sayısı 180 ve karmaşıklık değeri 18 olan bir kod parçasını temsil eder. predict metodu kullanılarak bu kod parçasının hata tahmini yapılır ve sonuç ekrana yazdırılır.

Bu örnek şöyle özetlenebilir: Bir kod sınıfında, kodun hatalı olup olmadığını tahmin etmek için bir Random Forest modelinin nasıl kullanılacağını göstermeye çalıştım. Model, geçmiş verilerden öğrenerek yeni kod parçalarının hata içerip içermediğini tahmin edecektir. Bu tür modeller, yazılım geliştirme sürecinde kritik hataların önceden tespit edilmesine yardımcı olacaktır, kendi core kod bloğuma da entegre edeceğim :)

Test Veri Optimizasyonu ve Test Kapsamının Artırılması

Test veri optimizasyonu, doğru test senaryolarında gerekli verilerin kullanıldığından emin olmak ve gereksiz testleri ortadan kaldırarak test sürecini hızlandırmak için önemli bir alandır bizim için. Yapay zeka algoritmaları, test verilerini analiz eder ve minimum veriyle maksimum kapsama alanı elde etmek için stratejik veri kümeleri oluşturmamıza yardımcı olur.

Bu örnek, test veri optimizasyonu için kullanılan makine öğrenimi algoritmalarının basit bir şekilde uygulanışını gösterir. Gerçek dünyada bu tarz algoritmalar, milyonlarca satırlık test verisinin analiz edilmesi ve en uygun veri setlerinin belirlenmesi için kullanılabilir.

Şimdi bir PoC Yapalım

PoC için geliştireceğimiz bu model, geçmiş test sonuçlarına göre gelecekte oluşabilecek hataları tahmin etmek amacıyla basit datalarla bir makine öğrenmesi modelini eğitmektedir.

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import matplotlib.pyplot as plt

# 1. Veri Hazırlığı
X_train = np.array([[0.2, 0.4], [0.6, 0.1], [0.8, 0.9], [0.4, 0.3], [0.7, 0.8]])
y_train = np.array([1, 0, 1, 0, 1])

# 2. Modeli Oluşturma
model = Sequential([
    Dense(10, activation='relu', input_shape=(2,), name='hidden_layer'),
    Dense(1, activation='sigmoid', name='output_layer')
])

# Modelin özetini yazdırma
model.summary()

# 3. Modeli Derleme
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 4. Modeli Eğitme
history = model.fit(X_train, y_train, epochs=50, verbose=1)

# 5. Eğitim Sonuçlarını Görselleştirme
# Loss ve Accuracy grafiklerini çizme
def plot_training_history(history):
    # Eğitim kayıplarını (loss) çizme
    plt.figure(figsize=(12, 5))
    plt.subplot(1, 2, 1)
    plt.plot(history.history['loss'], label='Loss', color='r')
    plt.title('Training Loss Over Epochs')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()

    # Eğitim doğruluklarını (accuracy) çizme
    plt.subplot(1, 2, 2)
    plt.plot(history.history['accuracy'], label='Accuracy', color='g')
    plt.title('Training Accuracy Over Epochs')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()

    plt.show()

# Grafik çizme fonksiyonunu çağır
plot_training_history(history)

# 6. Yeni Test Verisiyle Tahmin Yapma
new_test_case = np.array([[0.5, 0.7]])  # NumPy array
prediction = model.predict(new_test_case)
print(f"Test sonucu tahmini: {prediction[0][0]:.4f}")

Bu Python kodu, basit bir yapay sinir ağı (YSA) modeli oluşturmak, eğitmek ve performansını görselleştirmek için TensorFlow ve Keras kullanır. İlk olarak, NumPy kullanılarak eğitim verisi matrisi (X_train) ve hedefler (y_train) oluşturulur. Bu veriler, 2 özellik (girdi) ve binary sınıflandırma için etiketlerden (0 veya 1) oluşur. Keras ile Sequential model kurulurken, ilk katman 10 nöronlu bir gizli katmandır ve bu katman için relu (Rectified Linear Unit) aktivasyon fonksiyonu kullanılır. relu, negatif girdileri 0'a eşitleyerek modelin karmaşıklığını artırır. Çıkış katmanı ise sigmoid aktivasyon fonksiyonu kullanır; bu, çıktı değerini 0 ile 1 arasında sınırlar ve binary sınıflandırma için uygundur.

Modelin özet yapısı model.summary() ile ekrana yazdırılır. Model, adam optimizasyon algoritmasıyla derlenir ve kayıp fonksiyonu olarak binary_crossentropy (binary sınıflandırma problemlerinde yaygın) kullanılır. Eğitim sırasında modelin doğruluğu (accuracy) da izlenir. model.fit fonksiyonu ile model, 50 epoch boyunca eğitilir, yani veriler üzerinden 50 kez geçilir. Eğitim sırasında kaydedilen kayıp (loss) ve doğruluk (accuracy) değerleri history adlı bir değişkende saklanır.

Grafiksel olarak, eğitim sürecinde kayıp ve doğruluk değerleri matplotlib kullanılarak çizilir. Eğitim boyunca modelin performansı grafiklerle gösterilir; birinci grafikte kayıp, ikinci grafikte doğruluk gösterilir.

Son olarak, model eğitildikten sonra, yeni bir test vakası (new_test_case) üzerinde tahmin yapılır. Modelin bu yeni veri için yaptığı tahmin, model.predict fonksiyonu kullanılarak elde edilir ve sonuç ekrana yazdırılır. Tahmin edilen çıktı, 0 ile 1 arasında bir olasılık değeri olarak döner, bu da modelin yeni girdiye göre "1" olma olasılığını gösterir.

Epoch, makine öğrenimi ve derin öğrenme bağlamında, bir eğitim döngüsünü ifade eder. Modelin eğitim verileri üzerinde bir kez çalıştığı ve bu verilerden öğrenme gerçekleştirdiği tam bir döngü demektir.

Model Özeti

Model Yapısı:

Gizli Katman: 10 nörondan oluşuyor ve 30 parametreye sahip.
Çıkış Katmanı: 1 nöron ve 11 parametre bulunuyor.
Toplam Parametre Sayısı: 41 parametre var, bu da modelin oldukça basit olduğu anlamına geliyor.

Eğitim Süreci

Epoch Sayısı: Model 50 epoch boyunca eğitildi.

Başlangıç Performansı:

İlk epoch’ta doğruluk %40 ve kayıp (loss) 0.7329.

Eğitim Performansı:

Modelin doğruluğu çoğunlukla %40 civarında kalmış ve zamanla çok az bir değişim göstermiş. Bazı epoch’larda doğruluk %20'ye kadar düştü, ardından tekrar %60'a çıktı. Bu, modelin öğrenme sürecinin dengesiz olduğunu gösteriyor.
Kayıp değeri sürekli olarak düştü ve son epoch’ta 0.6741'e kadar geriledi. Bu durum, modelin öğrenme sürecinin genel olarak bir miktar ilerleme kaydettiğini gösteriyor.

Sonuçlar ve Değerlendirme

Test Sonucu: Son tahmin sonucu 0.5289. Bu değer, modelin ne kadar iyi performans gösterdiğini anlamak için kullanılır. Eğer bu değer, hedef değişkenin ortalama değeri etrafında ise modelin tahmin gücü düşüktür.
Düşük Doğruluk: Modelin eğitim sürecindeki çoğu epoch için doğruluk %40 civarında kalması, modelin verilere uygun bir şekilde öğrenemediğini veya modelin yapısının yetersiz olduğunu gösterebilir. Basit bir model olduğu için karmaşık ilişkileri öğrenme yeteneği kısıtlı olabilir.

Öneri olarak :

Model Geliştirme: Daha fazla katman veya nöron eklemek, modelin karmaşıklığını artırabilir ve öğrenme kapasitesini geliştirebilir.
Hiperparametre Ayarı: Öğrenme oranı gibi hiperparametrelerin ayarını değiştirerek modelin öğrenme hızını optimize edebilirsiniz.
Veri Ön İşleme: Verinin ölçeklendirilmesi, normalizasyon veya daha fazla özellik mühendisliği ile modelin performansını artırabilirsiniz.
Daha Fazla Eğitim Verisi: Eğitim verisi artırılarak modelin genelleme yeteneği geliştirilebilir.

Sonuç

Model basit bir yapıda ve düşük doğruluk gösteriyor. Bu durum, daha karmaşık bir model yapısına veya daha fazla veri ön işleme ile çözülmeye ihtiyaç duyduğunu göstermektedir. Eğitim sürecinin ve modelin performansının daha iyi bir hale gelmesi için yukarıdaki öneriler dikkate alınmalıdır.

Detaylar :

Model: “sequential”

Basit bir yapay sinir ağı modeli, katmanların sıralı olarak birbirini takip ettiği bir yapı.

2. Layer (Katman) Bilgileri:

— hidden_layer (Dense):

Tip: Dense (Tam Bağlantılı Katman)
Çıkış Şekli: (None, 10) — Bu katman, 10 birimden oluşuyor.
Parametre Sayısı: 30 — Ağırlıklar ve biaslar dahil.

— output_layer (Dense):

Tip: Dense (Tam Bağlantılı Katman)
Çıkış Şekli: (None, 1) — Tek bir çıktı üretiyor.
Parametre Sayısı: 11 — Ağırlıklar ve biaslar dahil.

3. Toplam Parametreler:

Toplam Parametre Sayısı: 41 — Modelin toplam parametre sayısı.
Eğitilebilir Parametreler: 41 — Eğitim sırasında güncellenebilecek parametreler.
Eğitilemeyen Parametreler: 0 — Eğitim sırasında güncellenmeyecek parametreler.

4. Eğitim Süreci:

Model 50 epoch boyunca eğitildi. Her epoch’ta modelin doğruluk ve kayıp değerleri izlendi.
İlk epoch’ta doğruluk %40 ve kayıp 0.7329 iken, son epoch’ta doğruluk %60 ve kayıp 0.6741'e düştü.

5. Test Sonucu:

Modelin test sonucu tahmini: 0.5289 — Çıktı değeri, modelin performansı hakkında bir fikir verir.

Yapay Zeka, Yazılım Testinde Yeni Bir Alan Açıyor Anlayacağımız

Son yıllarda yapay zeka, makine öğrenimi ve büyük veri teknolojilerindeki hızlı gelişmeler, yazılım testinde çığır açıcı yeniliklere imza atmamızı sağlayacaktır ve bir çok alandaki kat değerini bilmekteyim. Bu gelişmeler sayesinde test süreçleri daha verimli, etkili ve kapsamlı hale gelecektir.

→ Yapay zekanın yazılım testindeki etkilerinden bazıları:

Test Case Üretimi: Yapay zeka, geçmiş test verilerini analiz ederek, yeni ve daha etkili test senaryoları oluşturabilecektir. Bu sayede, test uzmanları tekrarlayan görevlerden kurtularak daha stratejik işlere odaklanabiliyor olacak ve katma değerlerini arttıracaklardır.
Akıllı Hata Tahmini: Derin öğrenme (Deep Learning) ve makine öğrenmesi (Machine Learning) teknikleriyle hataların otomatik tespiti sağlanabilir. Makine öğrenimi algoritmaları, kodda potansiyel hataları tespit edebiliyor ve geliştiricilere bu konuda erken uyarıda bulunabiliyor. Böylece, hataların geliştirme ortamına geçmesi önleniyor ve yazılım kalitesi gözle görülür şekilde artıyor olacaktır.
Test Süreçlerinin Otomasyonu: Yapay zeka sayesinde, test süreçlerinin büyük bir kısmı otomatikleşiyor. Bu da testlerin daha hızlı ve daha sık yapılabilmesini sağlayacaktır.
Dinamik ve Öğrenen Test Süreçleri: AI, zaman içinde yeni test durumlarını öğrenebilir ve test süreçlerini optimize edebilir. Özellikle regresyon testleri için büyük zaman kazandırır.
Test Kapsamının Genişletilmesi: Yapay zeka, test kapsamını genişleterek, daha önce gözden kaçan hataların tespit edilmesine yardımcı olacaktır.
UI/UX Testleri: Yapay zeka, kullanıcı arayüzü ve kullanıcı deneyimi üzerinde yapılan testlerdeki hataları otomatik olarak bulabilir ve optimize edebilir.
Test Sonuçlarının Analizi: Yapay zeka, test sonuçlarını analiz ederek, yazılımın genel durumunu değerlendirecek ve iyileştirme önerileri sunacaktır.

Özetle, yapay zeka, yazılım testinde insan hatasını minimize ediyor, verimliliği artırıyor ve yazılım kalitesini yükseltiyor. Bu sayede, şirketler daha hızlı ve daha güvenilir yazılımlar geliştirebiliyor.

Yapay zekanın yazılım testindeki diğer faydaları şunlardır:

Daha iyi kullanıcı deneyimi: Yapay zeka sayesinde, yazılımlar kullanıcı hatalarına karşı daha dirençli hale geliyor.
Maliyet tasarrufu: Otomasyon sayesinde, test maliyetleri düşüyor.
Pazarlama avantajı: Daha kaliteli yazılımlar, şirketlere rekabet avantajı sağlayacaktır. CICD süreçleri güçlenecektir.

Gelecekte, yapay zekanın yazılım testindeki rolü daha da artacaktır. Yapay zeka, kendi kendini geliştiren ve öğrenen sistemler olduğu için; yazılım test süreçlerini tamamen dönüştürecektir.

Okuduğunuz için teşekkür ederim. ❤ ❤

Bonus : Burada daha çok verimli bir ML oluşturabildim.

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# Örnek veri oluşturma
X = np.random.rand(1000, 5)  # 1000 örnek, 5 özellik
y = np.random.rand(1000, 1)   # 1000 hedef değeri

# Veriyi eğitim ve test setlerine ayırma
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Veri ön işleme: Ölçeklendirme
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Modeli oluşturma
model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(X_train.shape[1],)),  # Genişletilmiş ilk katman
    layers.Dense(32, activation='relu'),                                   # Ekstra katman
    layers.Dense(16, activation='relu'),                                   # Ekstra katman
    layers.Dense(1)                                                        # Çıkış katmanı
])

# Modeli derleme: Öğrenme oranı ayarı
optimizer = keras.optimizers.Adam(learning_rate=0.001)  # Daha düşük öğrenme oranı
model.compile(optimizer=optimizer, loss='mean_squared_error')

# Modeli eğitme ve kayıpları kaydetme
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2)

# Modeli değerlendirme
test_loss = model.evaluate(X_test, y_test)
print(f'Test Kayıp: {test_loss}')

# Test verisi tahmini
predictions = model.predict(X_test)

# Kayıp grafiği
plt.figure(figsize=(12, 5))

# Eğitim kaybı grafiği
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Eğitim Kaybı')
plt.plot(history.history['val_loss'], label='Doğrulama Kaybı')
plt.title('Kayıp Grafiği')
plt.xlabel('Epoch')
plt.ylabel('Kayıp')
plt.legend()

# Tahmin sonuçları grafiği
plt.subplot(1, 2, 2)
plt.scatter(y_test, predictions, alpha=0.5)
plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--')  # Y = X çizgisi
plt.title('Gerçek vs Tahmin')
plt.xlabel('Gerçek Değerler')
plt.ylabel('Tahmin Edilen Değerler')

plt.tight_layout()
plt.show()

Antrenman Süreci

Antrenman süreci 50 epoch boyunca sürmüş ve her epoch sonunda modelin kaybı (loss) ve doğrulama kaybı (val_loss) değerleri gözlemlenmiş.

Kaybın Gelişimi

Epoch 1: loss: 0.3537 ve val_loss: 0.1105 ile başlamış. Bu, başlangıçta modelin eğitim verisi üzerinde iyi bir performans göstermediğini ama doğrulama veri setinde daha iyi sonuçlar elde ettiğini gösteriyor.
Epoch 50: Sonuçlar loss: 0.0575 ve val_loss: 0.0851 seviyesine gelmiş. Eğitim kaybı zamanla önemli ölçüde azalmış, bu da modelin eğitim verisine iyi uyum sağladığını gösterir. Ancak doğrulama kaybında dalgalanmalar görünüyor. Özellikle birkaç epoch sonrası doğrulama kaybı zaman zaman artmış. Bu, modelin aşırı öğrenme (overfitting) belirtilerini gösteriyor olabilir.

Test Sonuçları

Test kaybı 0.0945 olarak belirlenmiş. Bu, modelin doğrulama setindeki performansına göre oldukça iyi bir sonuç. Ancak yine de test seti kaybının doğrulama kaybına göre daha düşük olması, modelin test verileri üzerinde de iyi bir performans gösterdiğini, ama aşırı öğrenme yapmadığını gösteriyor.

Sonuçlar ve Öneriler

Model, genel olarak iyi bir performans sergilemiş gibi görünüyor. Ancak, doğrulama kaybındaki dalgalanma ve bazı epoch’larda artış, potansiyel olarak aşırı öğrenme yaşandığını gösteriyor. Bu durumu önlemek için:
Daha fazla veri: Modelin genel yeteneğini artırmak için daha fazla eğitim verisi eklemeyi düşünebilirsiniz.
Düzenleme (Regularization): Dropout, L2 regularization gibi teknikleri uygulayarak aşırı öğrenmeyi engelleyebiliriz.
Erken Durdurma (Early Stopping): Val_loss değerinin artmaya başladığı epoch’ta eğitimi durdurmak, aşırı öğrenmenin önüne geçebilir.
Hiperparametre Ayarlamaları: Öğrenme oranı, katman sayısı ve nöron sayısı gibi hiperparametreleri değiştirmeyi düşünebilirsiniz.

Umarım faydalı olmuştur, Kendine çok iyi bak.