T.C.
SELÇUK ÜNİVERSİTESİ
AKŞEHİR MÜHENDİSLİK VE MİMARLIK FAKÜLTESİ
MAKİNE MÜHENDİSLİĞİ BÖLÜMÜ
ANKASTRE KİRİŞ VE DİŞLİ SİSTEMİ
TASARIM PROBLEMLERİNİN
OPTİMİZASYONU
YILDIRIM USLU
ABDULLAH ELMUHAMMED
MUSTAFA KAAN YURDUSAY
EMRE GÜLER
DANIŞMAN
DR. ÖĞR. ÜYESİ ÜSAME ALİ USCA
OCAK 2025
KONYA
iv
TEZ BİLDİRİMİ
Bu tezdeki bütün bilgilerin etik davranış ve akademik kurallar çerçevesinde elde
edildiğini ve tez yazım kurallarına uygun olarak hazırlanan bu çalışmada bana ait
olmayan her türlü ifade ve bilginin kaynağına eksiksiz atıf yapıldığını bildiririm.
DECLARATION PAGE
I hereby declare that all information in this document has been obtained and
presented in accordance with academic rules and ethical conduct. I also declare that, as
required by these rules and conduct, I have fully cited and referenced all material and
results that are not original to this work.
İmza
Öğrencinin Adı SOYADI
Yıldırım USLU
Abdullah ELMUHAMMED
Mustafa Kaan YURDUSAY
Emre GÜLER
Tarih:
v
ÖNSÖZ
Öncelikle bizlere bu konuyu öneren ve bilgi edinmemize aracı olan Üsame Ali
USCA hocamıza teşekkür ediyoruz. Çalışmamızı yazdığımız süreç bizim için zaman
zaman zorlu geçti ancak sonucunda her birimiz, kendimize biraz daha bilgi katarak
geleceğe doğru emin adımlarla yürüyen makine mühendisleri olarak bu çalışmayı
bitirdik. Optimizasyon, gerçekten de derinlemesine araştırılması gereken bir konu ve bu
konuyu elimizden geldiğince araştırdık.
Öğrencinin Adı SOYADI
Yıldırım USLU
Abdullah ELMUHAMMED
Mustafa Kaan YURDUSAY
Emre GÜLER
KONYA-2025
vi
İçindekiler
ÖNSÖZ ................................................................................................................................ vi
1. GİRİŞ ................................................................................................................................ 1
2. MATERYAL VE YÖNTEM ......................................................................................... 6
KAYNAKLAR ................................................................................................................... 36
EKLER ............................................................................................................................... 39
vii
1
1. GİRİŞ
1.1 Optimizasyon Nedir?
Mühendislikte bir sistem veya sürecin en iyi duruma getirilmesi için kullanılan
kavrama optimizasyon denir. Optimizasyon, kaynakların verimli ve etkin bir şekilde
kullanılmasını sağlar. Endüstri, ekonomi, Lojistik, makine tasarımı ve Mühendislik gibi
alanlarda optimizasyon yöntemlerinden yararlanılır.
Optimizasyon, bir sürecin, Tasarımın veya sistemin en iyi hale getirilmesi için
matematiksel hesaplamalar kullanır. Genelde yüksek kar, en düşük maliyet, yüksek
verimlilik gibi iyileştirmelerin sağlanabilmesi için kullanılır. [1]
Optimizasyon mühendisliğin yanı sıra bazı işletmelerde envanter yönetimi ve
lojistik işleri içinde kullanılabilir. Mühendislikte kullanımı daha önce de bahsedildiği gibi
tasarım ve süreç iyileştirilmesi şeklindedir. [2]
1.2 Metasezgisel Optimizasyon
Son yıllarda yüksek boyutlu, karmaşık, çok modlu ve doğrusal olmayan
optimizasyon problemlerini çözmek amacıyla birçok Metasezgisel optimizasyon
algoritması önerilmiştir. Bu algoritmalar genelde sürü halinde avlanan canlıların
davranışları, bitkilerin davranış biçimleri, insanların sosyal davranışları, bilimsel yasalar
ve kurallardan ilham alır. [3] Problemin yapısına uygun olarak farklı algoritmalardan biri
seçilmelidir. Bundan dolayı her geçen gün farklı yöntemler ve algoritmalar
üretilmektedir.
Meta
sezgisel
optimizasyon
algoritmaları
11
farklı
kategoride
değerlendirilmektedir. [4] Bahsedilen 11 kategori şekil bir de gösterildiği şekilde fizik
tabanlı, kimya tabanlı, biyoloji tabanlı, sosyal tabanlı, müzik tabanlı, sürü tabanlı,
matematik tabanlı, bitki tabanlı, su tabanlı, spor tabanlı ve melez tabanlı optimizasyonları
içerir. Literatürde, bu kategorilerin içerisinde yer alan yüzlerce farklı Algoritma
bulunmaktadır. Yukarıda sayılan ve şekil 1'de gösterilen kategorilerden biri olan melez
2
kategorisinde, aynı veya farklı kategorideki yöntemlerin Üstün özellikleri kullanılarak
çözüm arayışı sağlanmaktadır.
Fizik tabanlı algoritmalar doğadaki çeşitli fiziksel olaylardan esinlenerek ortaya
çıkmıştır. Bu algoritmalara örnek olarak elektromanyetizma algoritması [5], Merkezi
kuvvet optimizasyon algoritması [6], yapay fizik optimizasyon algoritması [7], Galaksi
tabanlı algoritmalar [8], su döngüsü algoritması verilebilir [9]. Sosyal tabanlı algoritmalar
ise insan davranışlarından ve halkın sosyal durumu ile ilişkili bazı özelliklerden
esinlenerek ortaya çıkmıştır. Parlamento optimizasyon algoritması, Emperyalist
yarışmacı algoritması, sosyal duygusal optimizasyon algoritması, sosyal taklit
algoritması bu tür algoritmalara örnek olarak verilebilir. Parçacık sürü optimizasyonu,
karınca kolonisi algoritması, yapay arı kolonisi algoritması ise sürü zekası tabanlı
optimizasyon algoritmalarına örnek olarak söylenebilir. Bu tür algoritmalar genel olarak
sürü halinde yaşayan ve avlanan hayvan topluluklarının hareketlerinden esinlenir. Kimya
tabanlı algoritmalar doğadaki kimyasal olaylardan esinlenir. Örneğin yapay atom
algoritması, yapay kimyasal tepkime optimizasyon algoritması kimya tabanlı
algoritmalardan bazılarıdır. Doğadaki canlıların hareketlerinden esinlenerek ortaya çıkan
Algoritma olarak biyoloji tabanı algoritmalar denir Örneğin genetik Algoritma, bakteriyel
besin arama optimizasyon algoritması, diferansiyel gelişim algoritması bunların en
bilinenlerindendir. Temel optimizasyon algoritması, sinüs kosinüs algoritması Meta
sezgisel ve matematik programlama tekniklerinin birleştirilmesiyle oluşturulmuş
matematik tabanlı algoritmalara örnektir.
Farklı algoritmaların, farklı problemlerin çözümlerine farklı farklı yaklaşımları
olmasına karşın her bir algoritmanın arama uzayında iki aşaması vardır. Bu iki aşama,
keşif ve sömürü aşamalarıdır. Keşif aşaması, ilk aşamadır ve çözüm uzayında
olabildiğince geniş ve rastgele bir arama yaptığımız aşamayı ifade eder. Sömürü aşaması
ise ilk aşamada bulunan alanda daha keskin bir arama yapma yeteneğini ifade eder.
Algoritmanın keşif özelliği daha baskın olması demek, daha rastgele aramalar yapıp daha
farklı çözüm kümeleri elde edebilmesi demektir. Sömürü yeteneği daha baskın ise daha
keskin ve kaliteli çözüm kümeleri bulunabilir. Yeteneklerden birinin iyileştirilmesi
diğerinde ters orantıda bir düşüş yapabilmektedir. Bu iki aşama ve yetenekler bakımında
herhangi bir algoritmada dengeyi elde etmek oldukça zordur.
3
Tüm optimizasyon problemlerini verimli bir şekilde çözebilecek tek bir algoritma
yoktur ve “No Free Lunch (Bedava Öğle Yemeği Yok)” teorisi ile böyle bir algoritmanın
bulunamayacağı mantıksal olarak da kanıtlanmıştır. Bu yüzden sürekli ve düzenli olarak,
araştırmacılar yeni algoritmalar üretmektedir.
Metasezgisel Optimizasyon algoritmalarına örnek olarak: Cıvık Mantar
Optimizasyon Algoritması, Balina Optimizasyon Algoritması, Gri Kurt Optimizasyon
Algoritması, Harris Şahini Optimizasyon Algoritması ve Arşimet Optimizasyon
Algoritması verilebilir. Ancak çalışmamızda bunları kullanmayacağız.
1.3 Tek Amaçlı Optimizasyon Nedir?
Daha önce de bahsettiğimiz gibi, optimizasyon kavramı, bir sistem veya süreci
en uygun hale getirmek anlamına gelir. Birçok alanda bu kelime önüne bazı kelimeler
alarak farklı anlamlara da gelebilmektedir.
Tek amaçlı optimizasyon matematiksel olarak formüle edilmiş bir problemde
en uygun değeri bulmak için modelin hangi parametrelere sahip olacağının bulunması
denilebilir. Örneğin herhangi bir makine parçası tasarımı yapılıyor ve bu parça 3 farklı
maddeden yapılıyor. Bu 3 farklı maddenin de farklı fiyatları var. “Bu parçayı en
uygun fiyat ile üretmek için hangi maddeden ne kadar kullanmalıyız?” gibi bir
problem yalnızca maliyete odaklandığı için tek amaçlı bir optimizasyon problemidir.
Çok amaçlı optimizasyon problemleri ise adı üzerinde birden fazla amaca
çözüm üretilmesi beklenen problemlerdir. Yukarıdaki parça tasarımı problemine
devam edecek olursak, ilgili maddelerin farklı dayanıklılık oranları olsun ve biz hem
ucuz hem de dayanıklı bir parça yapmayı hedefleyelim. Malumdur ki daha dayanıklı
malzemenin fiyatı daha yüksek olacaktır o yüzden daha dayanıklı bir parça istedikçe
fiyat daha da fazla artacaktır.
Hem dayanıklı hem de ucuz bir tasarım hedeflediğimiz zaman, bir çok amaçlı
optimizasyon problemi ortaya koyarız. Ve bu problemlerin tek bir çözümü olamaz.
Bu tür problemlerde amaç, dengeyi sağlamaktır.
4
1.4 Çok Amaçlı Optimizasyon Nedir?
Çok amaçlı optimizasyon (ÇAO), performans kriterinde birden fazla amacın
sistematik ve eş zamanlı olarak optimize edilmesine denir. Çok amaçlı optimizasyon
problemlerinde, karar probleminin bir modeli oluşturulurken amaç fonksiyonunun
oluşturulması her zaman için pek kolay olmayabilir. Karar problemlerinde, bulunan
çözümlerin niteliğini değerlendirmek için birden fazla kriter dikkate alınmalıdır. Tüm bu
kriterleri tek bir amaç fonksiyonunda birleştirmek genellikle mümkün olmayabilir. Kimi
problemlerde bu kriterler çelişir ve bu tür problemleri optimize ederken farklı çözüm
alternatifleri kullanmamız gerekebilir.
ÇAO problemlerinde, doğası gereği birden fazla çözüm bulunması gerekliliği söz
konusudur. Tek amaçlı problemlerin çözümünde kullanılan algoritmaları kullanmak,
çözüm uzayının yeteri kadar iyi taranmaması anlamına geleceğinden işimize yaramaz. İyi
sonuçlar alamayız. Araştırmacı ve mühendisler, bu tür problemlerin çözümünde
kullanılması amacı ile çözüm uzayının tamamını arayacak yöntemler geliştirip bunları
algoritmalara adapte etmişlerdir. ÇAO problemlerinde tüm amaçlar tek bir amaçta
birleştirilmelidir. Sabit (SAAF) ve değişken ağırlıklı (DAAF) amaç fonksiyonları bu
yöntemlere örnek olarak sayılabilir.
Bu yöntemlerden SAAF birden fazla amacı tek bir amaç kapsamında birleştirir ve
ÇAO problemini, bir TAO haline getirebilir. (Michalewicz, Murata ve ishibuchi)
Amaçlara farklı ağırlık değerleri verilmesi ile farklı pareto dizileri elde edilir. Birden fazla
optimal pareto çözüm dizisinin bulunması için çözüm algoritmasının birden çok defa
çalıştırılması lazımdır. Denklem 1’de görüldüğü üzere, SAAF yöntemi tek amaç
fonksiyonu altında birleştirilir.
𝐹 (𝑥 ) = 𝑤1 𝑓1 (𝑥 ) + 𝑤2 𝑓2 (𝑥 ) + ⋯ + 𝑤𝑛 𝑓𝑛 (𝑥 ), ∑𝑛{𝑖=1} 𝑤𝑖 = 1 (1)
DAAF’nin oluşturulma amacı ise SAAF yönteminin eksikliklerini gidermektir.
Bu yöntemde kullanılan ağırlık değerleri rastgele seçilir. SAAF, arama uzayında tek
yönde arama yaptığı için pareto çözüm dizilerini bulmak için yeterli olmayabilir. ÇAO
problemlerinde, çözüm uzayının farklı yönlerde aranması gerekir. Bu amacı
5
gerçekleştirmek ve SAAF yönteminin eksiklerini kapatmak için DAAF yöntemi
oluşturulmuştur. Denklem 1’e ek olarak, DAAF yönteminde aşağıda verilen denklem 3
de sağlanmalıdır. Denklem 3’te [10] ağırlıklar sabit değildir ve bu sayede uzayda farklı
yönlerde çözümler aramamızı sağlar.
𝑤𝑖 =
𝑟𝑎𝑠𝑔𝑒𝑙𝑒𝑖
𝑟𝑎𝑠𝑔𝑒𝑙𝑒1+𝑟𝑎𝑠𝑔𝑒𝑙𝑒2+⋯+𝑟𝑎𝑠𝑔𝑒𝑙𝑒𝑛
,
𝑖 = 1,2, … , 𝑛 (3)
1.5 Kısıtlı ve Kısıtsız Optimizasyonlar
Matematiksel optimizasyonlar, kısıtlı ve kısıtsız olarak ikiye ayrılır. Kısıtsız
optimizasyonlar, herhangi bir amaç fonksiyonunda herhangi bir kısıtlama olmadan
maksimum ve minimum değerleri bulmayı hedefler. Örneğin bir fonksiyonun türevi
alınarak kritik noktalarını bulmak, minimum ve maksimum noktaları saptamak bu tür
optimizasyon problemlerinin çözümünde kullanılan ana yöntemlerdir. Bu tür bir
yaklaşım, fonksiyonların sürekli ve türevlenebilir olduğu durumlarda etkilidir. [11]
Kısıtlı optimizasyonlarda ise amaç, bir amaç fonksiyonunun belirli kısıtlar
çerçevesinde minimum ve maksimum değerlerini belirlemektir. [12] Eşitlikler veya
eşitsizlikler biçiminde karşımıza çıkabilir. Genelde kaynak sınırlamaları, bütçe kısıtları
ve fiziksel sınırlamalar gibi gerçek dünya şartlarını temsil ederler. Lagrange çarpanları
metodu gibi özel yöntem ve metotlar kullanılarak çözülebilirler. Kısıtlar amaç
fonksiyonuna dahil edilerek, problemi kısıtsız bir probleme dönüştürür ve böylece
çözümü daha basit bir şekilde elde edebiliriz. [13]
Kısıtlı optimizasyonda, kısıtlar çözüm uzayını daraltır ve çözümün bu sınırlar
içerisinde bir yerde bulunmasını gerektirirken kısıtsız optimizasyon problemlerinde daha
basit bir şekilde çözüme ulaşılır. [14] Zaten bu nedenden dolayı da kısıtlı problemleri
öncelikle kısıtsız hale getirmeye uğraşırız. Bu yüzden kısıtlı optimizasyon problemleri,
daha önce de bahsedildiği gibi karmaşık metotlar ile çözülür. Yine daha önce
bahsettiğimiz Lagrange çarpanları yöntemi, bunlardan biridir. [15]
Kısıtsız optimizasyon problemleri genel olarak teoriktir. Kısıtlı problemler ise
gerçek dünyada karşılaşacağımız durumları ifade eder. Çünkü gerçek hayatta birçok
6
kaynak sınırlıdır. Örnek olarak, bir parça tasarımı yaparken şirketin bütçesini ve üretim
kapasitesini göz önünde bulundurmamız gerekir ki bunlar birer kısıttır.
Sonuç olarak, kısıtlı ve kısıtsız optimizasyonlar matematiksel optimizasyonda iki
temel bölümdür. Kısıtlı optimizasyonlar daha çok teorik problemlerin çözümüne yönelik
olup, çözümünde daha basit teknikler kullanılırken, kısıtlı optimizasyonlar gerçek
problemlerdir ve çok daha karmaşık yöntemler ile gerçekleştirilirler. Mühendislik
alanında optimizasyon problemlerini çözmek için her iki optimizasyon türünün de iyice
anlaşılması elzemdir.
2. MATERYAL VE YÖNTEM
Bu bölümde, öncelikle çalışmamızın ana konusu ve amacı olan iki farklı
optimizasyon problemini inceleyeceğiz ve akabinde, bu problemlerde çözüme
ulaşmamıza yardımcı olan MVO (Multi-Verse Optimization) ve ABC (Artificial Bee
Colony Optimization) isimli optimizasyon yöntemlerinden bahsedeceğiz.
2.1 Ankastre Kiriş Tasarım Problemi
Problem, temelde bir ankastre kirişin ağırlığını azaltmayı amaçlar. Bunun için de
içi boş kare bloklar kullanılır. İlk ve boyutça en büyük olup, bir duvara sabitlenmiştir.
Onun haricinde dört blok daha vardır. Beşinci ve boyutça en küçük blok dikey bir yük ile
yüklenmiştir. [16] Ek 1’de görüldüğü üzere küplerin yüzey alanı beş farklı parametre ile
belirlenmiştir.
Şekil 2.1 Ankastre Kiriş.
7
Şekil 2.2 Ankastre kirişi oluşturan bloklar.
Bu problemi, MVO ve ABC yöntemlerini kullanarak optimize ettik.
Kullandığımız yöntemler kapsamında yaptığımız optimizasyon çalışmaları ile, Tablo
2.1’de MVO sonuçlarına olabildiğince yakın değerler elde ettik. Çalışmalarımız sırasında
Python proglamlama dilinden yararlandık.
Tablo 2.1 Ankastre kiriş tasarım problemi için farklı optimizasyon yöntemleri ile elde
edilmiş sonuçların karşılaştırılması
2.1.1 Ankastre Kiriş Tasarımı Optimizasyonu Sırasında Kullanılan Kodlar ve
Açıklamalar
Bu bölümde, ilk problemimiz olan ankastre kiriş tasarımı problemini iki farklı
yaklaşım ile optimize ederken kullandığımız Python kodlarını paylaşacak ve analiz
edeceğiz.
8
Ankastre Kiriş Tasarımı Problemine MVO Yaklaşımı
Bu problemin optimize edilme sürecinde kullandığımız python kodları aşağıdaki
gibidir.
import random
import numpy as np
# Amaç fonksiyonu
def objective_function(x):
return 0.6224 * np.sum(x)
# Kısıt fonksiyonu
def constraint_function(x):
x = [max(xi, 0.01) for xi in x]
return (61 / x[0]**3 + 27 / x[1]**3 + 19 / x[2]**3 + 7 / x[3]**3 + 1 / x[4]**3
- 1)
# Kısıt kontrolü (True: Sağlanıyor, False: Sağlanmıyor)
def is_constraint_satisfied(x):
return constraint_function(x) <= 0
# Rastgelelik için sabit tohum
random.seed(42)
np.random.seed(42)
# Parametreler
n_universes = 100
max_iter = 1000
lower_bound = [0.01] * 5
upper_bound = [100] * 5
penalty_factor = 1e5 # Ceza faktörü
# Evrenleri başlatma
9
def initialize_universes():
universes = []
for _ in range(n_universes):
universe = [random.uniform(lower_bound[i], upper_bound[i]) for i in
range(len(lower_bound))]
universes.append(universe)
return universes
# Fitness hesaplama
def calculate_fitness(universe):
obj_value = objective_function(universe)
constraint_violation = max(0, constraint_function(universe))
obj_value += penalty_factor * (constraint_violation ** 2) # Ceza faktörü
kademeli artıyor
return obj_value
# Yerel arama (local search) fonksiyonu
def local_search(universe):
for _ in range(10): # Yerel arama iterasyonları
perturbed = [max(lower_bound[j], min(upper_bound[j], universe[j] +
random.uniform(-0.1, 0.1))) for j in range(len(universe))]
if calculate_fitness(perturbed) < calculate_fitness(universe):
universe = perturbed
return universe
# Multiverse Optimization
def multiverse_optimization():
universes = initialize_universes()
best_universe = min(universes, key=calculate_fitness)
for iteration in range(max_iter):
adaptive_penalty = penalty_factor * (1 + iteration / max_iter) # Dinamik
ceza faktörü
10
# En iyi evrenleri seç
top_k = 10
top_universes = sorted(universes, key=calculate_fitness)[:top_k]
for i in range(n_universes):
if universes[i] != best_universe:
for j in range(len(lower_bound)):
black_hole = random.choice(top_universes)
scale = 1 - (iteration / max_iter) # Keşif ve sömürü dengesi
new_value = universes[i][j] + scale * random.uniform(-1, 1) *
(black_hole[j] - universes[i][j])
universes[i][j]
=
max(lower_bound[j],
min(upper_bound[j],
new_value))
# Kısıt ihlal edenleri düzelt
if not is_constraint_satisfied(universes[i]):
universes[i] = best_universe
# En iyi çözümü güncelle
if calculate_fitness(universes[i]) < calculate_fitness(best_universe):
best_universe = universes[i]
# Yerel arama ile iyileştirme
best_universe = local_search(best_universe)
# Rastgele evren yenileme
if iteration % 100 == 0:
for k in range(5): # Rastgele 5 evreni yeniden başlat
universes[random.randint(0,
n_universes
-
1)]
=
[random.uniform(lower_bound[i], upper_bound[i]) for i in range(len(lower_bound))]
# Durum çıktısı
print(f"Iteration {iteration + 1}: Best Universe = {best_universe}, "
f"Value = {calculate_fitness(best_universe):.4f}, "
11
f"Constraint Satisfied = {is_constraint_satisfied(best_universe)}")
# Tüm evrenlerin kısıt durumlarını yazdır
print("\n--- Tüm Evrenlerin Kısıt Durumları ---")
for idx, universe in enumerate(universes):
print(f"Universe
{idx
+
1}:
Constraint
Satisfied
=
{is_constraint_satisfied(universe)}")
return best_universe, calculate_fitness(best_universe)
# Optimizasyonu çalıştır
best_universe, best_value = multiverse_optimization()
print(f"\nEn iyi çözüm: {best_universe}, Değer: {best_value:.4f}, "
f"Kısıt Sağlandı mı: {is_constraint_satisfied(best_universe)}")
Yukarıda verilen kod, problemde ifade edildiği üzere, beş adet içi boş küp şeklinde
kutudan oluşan bir ankastre kirişin ağırlığını azaltmayı amaçlayan bir optimizasyon
problemini çözmek amacıyla MVO yani Multi-Verse Optimization metodunu kullanır.
Probleme konu olan tasarımda beş adet blok bulunur ve bu bloklardan ilki ve en büyük
boyutlu olanı duvara sabitlenmiş iken, beşinci ve boyutça en küçük blok düşey yönde bir
yük ile yüklenmiştir.
Problemde amaç fonksiyonu, kirişin toplam ağırlığını minimize etmektir ve bu
ağırlık blokların toplam yüzey alanı ile ilişkilidir. “objective_function” fonksiyonu
içerisinde tanımlanmıştır. Problemde söz konusu kısıt ise “constraint_function” ile ifade
edilir. Bu kısıt sayesinde blokların hacmi belirli bir sınırlandırmaya tabi tutulur.
Algoritmada kısıtın dışına çıkan çözümler cezalandırılır ve böylece daha uygun
çözümlere yoğunlaşılabilir.
12
Optimizasyon Sürecinde Kullanılan Fonksiyonlar ve Değişkenler
a) Objective_function(x)
Az önce verdiğimiz kodlarda objective_function(x) fonksiyonunda giriş, yani x
problemde söz konusu kirişi oluşturan her bir bloğun boyutlarını temsil eden bir listedir.
Fonksiyonun çıkışı, toplam yüzey alanını temsil eder ki bunu hesaplamak için 0.6224 gibi
bir ölçeklendirme katsayısı kullandık.
b) Constraint_function(x)
Constraint_function(x) ise adından da anlaşılacağı üzere kısıt fonksiyonudur.
Giriş, yani x, daha önce de bahsettiğimiz gibi kirişi oluşturan her bir bloğun boyutlarını
temsil eder. Fonksiyonun asıl amacı kısıt ihlali değerini hesaplamaktır. Değer ≤ 0 ise kısıt
sağlanmıştır, aksi takdirde çıkış değeri ceza fonksiyonu kapsamına girer.
c) Is_constraint_satisfied(x)
Bir boolean değeri elde edeceğimiz is_constraint_satisfied(x) fonksiyonu ise
kısıtların sağlanıp sağlanmadığını kontrol eder ve hangi çıkışların ceza fonksiyonunda
kullanılacağı ile alakalı bize yardımcı olur.
d) Initialize_universes()
Initialize_universes() fonksiyonu, adından da anlaşılacağı üzere bizim için
rastgele 100 evren oluşturur. Oluşturulan evrenlerin her birinden, beş bloğun her birinin
boyutlarını temsil eden bir liste elde ederiz. Belirlenen minimum ve maksimum sınırlar
kapsamında bu boyutlar arasında seçim yapılır.
13
e) Calculate_fitness(universe)
Calculate_fitness(universe) fonksiyonu initialize_universes() fonksiyonu yardımı
ile oluşturduğumuz evrenler yani çözümler arasından herhangi birini rastgele olarak seçip
sınar. Çıkış fonksiyonu ile evrenin uygunluk değerini kontrol eder ve kısıtların
sağlanmadığı durumda ceza faktörünü ekler.
f) Local_search(universe)
Local_search(universe) fonksiyonu ile her bir evren üzerinde yerel düzeyde arama
yapılarak daha iyi bir çözüm üretilmesi hedeflenir. Evrenler üzerinde tamamen rastgele
bir şekilde ufak değişiklikler deneyerek uygunluk değerini iyileştirmeye çalışır.
g) multiverse_optimization()
Son olarak, ana fonksiyonumuz olan multiverse_optimization() fonksiyonu ile
MVO algoritmasını uygularız. Bu fonksiyon:

Rastgele çözümler, yani evrenler oluşturur.

Evrenlerin konumunu her bir iterasyonda güncelleyerek en iyi çözüme ulaşmayı
hedefler

Keşif amacı ile belirli iterasyonlarda rastgele evrenleri yeniden başlatır.

En nihayetinde, bu algoritma en iyi çözümü elde etmemizi sağlar.
Optimizasyon sürecinde, öncelikle initialize_universes fonksiyonu bize yüz adet
evren yaratır. Daha sonra bu evrenlerin uygunluğunu sınarız. Her biri için fitness değeri
hesaplanır ve kısıt ihlali yapan evrenler ceza fonksiyonunda kullanılmak üzere
cezalandırılır. Her bir iterasyonda bu sınamadan geçen en iyi evrenler belirlenir. Daha
önce de bahsettiğimiz keşif ve sömürü kavramları arasında bir dengel belirlenir ve
evrenler en iyi çözüme doğru çekilir. Rastgele bir şekilde keşif yapmak amacı ile çeşitli
iterasyonlarda tüm evrenler yeniden başlatılır.
14
Sonuçların raporlanması amacı ile; en iyi çözüm, ağırlık ve kısıt durumu çıktı
olarak verilir.
Hazırladığımız algoritmanın çıktıları şunlardır:

En yüksek uygunluk değerine sahip evren yani en iyi çözüm

En iyi çözümün ağırlığı ve kısıt durumunu belirten uygunluk değeri

Çözümlerin kısıtları ihlal edip etmediğini belirterek bize kısıt sağlanma
durumu hakkında bilgi verir.
Algoritmanın başarılı sonuçlar veriyor olmasının bazı sebepleri ise şunlardır:

Kısıtları ihlal eden her bir evrene ceza faktörünü ekleyerek sadece en
uygun çözümlere odaklanan bir ceza mekanizmasına sahip olması.

Adaptive_penalty; yani dinamik ceza faktörü mekanizması, iterasyon
sayısına bağlı artarak optimizasyon sürecinin son aşamalarında daha kesin
çözümlere ulaşılmasını sağlar.

Algoritmamız yerel arama yaparak bazı çözümlerde rastgele ve ufak
değişiklikler yaparak en optimum çözüme ulaşması için yazılmıştır.

Bu algoritma, her bir iterasyonda rastgele evrenleri yeniden başlatır ve
böylece global minimum çözüme ulaşma olasılığımız artar.
Ankastre Kiriş Tasarım Problemine ABC Yaklaşımı
Bu problemi ABC yöntemi ile optimize ederken kullandığımız Python kodları şunlardır:
import numpy as np
# Hedef fonksiyon
def objective_function(x):
return 0.6224 * np.sum(x)
# Kısıt fonksiyon
15
def constraint_function(x):
return (61 / x[0]**3 + 27 / x[1]**3 + 19 / x[2]**3 + 7 / x[3]**3 + 1 / x[4]**3-1)
# Kısıtı kontrol eden fonksiyon
def is_feasible(x):
return constraint_function(x) <= 0
# Rastgele çözüm üret
def random_solution(bounds, max_trials=1000):
for _ in range(max_trials):
solution = [np.random.uniform(bound[0], bound[1]) for bound in bounds]
if is_feasible(solution):
return solution
raise ValueError("Geçerli çözüm bulunamadı.")
# Çözümü değerlendir
def evaluate(solution):
if is_feasible(solution):
return objective_function(solution)
else:
penalty = 1e6 * max(0, constraint_function(solution)) # Dinamik ceza
return objective_function(solution) + penalty
# Çözümü mutasyona uğrat
def mutate(solution, bounds):
for _ in range(100): # Maksimum deneme sayısı
mutant = solution.copy()
dim_to_mutate = np.random.randint(len(bounds))
mutant[dim_to_mutate]
np.random.uniform(bounds[dim_to_mutate][0], bounds[dim_to_mutate][1])
if is_feasible(mutant):
return mutant
return solution # Geçerli mutant bulunamazsa orijinal çözümü döndür
=
16
# ABC algoritması
def abc_optimization(bounds, n_agents, n_iter):
# Arıların sayısı
employed_bees = n_agents // 2
onlooker_bees = n_agents // 2
# Başlangıç popülasyonu
population = [random_solution(bounds) for _ in range(n_agents)]
fitness = [evaluate(individual) for individual in population]
# İterasyonlar
for _ in range(n_iter):
# Employed bees
for i in range(employed_bees):
candidate = mutate(population[i], bounds)
candidate_fitness = evaluate(candidate)
if candidate_fitness < fitness[i]:
population[i] = candidate
fitness[i] = candidate_fitness
# Normalize edilmiş olasılıkların hesaplanması
total_fitness = sum(abs(f) for f in fitness[:employed_bees] if f !=
float('inf'))
probabilities = [abs(f)/total_fitness if f != float('inf') else 0 for f in
fitness[:employed_bees]]
# Onlooker bees
for _ in range(onlooker_bees):
selected_bee = np.random.choice(employed_bees, p=probabilities)
candidate = mutate(population[selected_bee], bounds)
candidate_fitness = evaluate(candidate)
if candidate_fitness < fitness[selected_bee]:
population[selected_bee] = candidate
fitness[selected_bee] = candidate_fitness
17
# En iyi çözümü döndür
best_index = np.argmin(fitness)
return population[best_index], fitness[best_index]
# Parametreler
bounds = [(0.01, 100), (0.01, 100), (0.01, 100), (0.01, 100), (0.01, 100)] # x0, x1,
x2, x3 ve x4 için sınırlar
n_agents = 200 # Arıların sayısı
n_iter = 500 # İterasyon sayısı
# Optimizasyon
best_solution, best_fitness = abc_optimization(bounds, n_agents, n_iter)
# Sonuçların yazdırılması
print(f"En iyi çözüm: {best_solution}")
print(f"En iyi fitness: {best_fitness}")
print(f"Kısıtı ihlal ediyor mu? {not is_feasible(best_solution)}")
Yukarıda verilen kod, problemde ifade edildiği üzere, beş adet içi boş küp şeklinde
kutudan oluşan bir ankastre kirişin ağırlığını azaltmayı amaçlayan bir optimizasyon
problemini çözmek amacıyla ABC yani Artificial Bee Colony metodunu kullanır.
Probleme konu olan tasarımda beş adet blok bulunur ve bu bloklardan ilki ve en büyük
boyutlu olanı duvara sabitlenmiş iken, beşinci ve boyutça en küçük blok düşey yönde bir
yük ile yüklenmiştir.
18
Optimizasyon Sürecinde Kullanılan Fonksiyonlar ve Değişkenler
Kod içerisinde çeşitli fonksiyonlar ve değişkenler optimizasyon sürecinin temel
bileşenleri olarak yer almaktadır. Aşağıda, bunların görevleri detaylandırılmıştır:
a) objective_function(x)
fonksiyonu, hedef fonksiyonun hesaplanmasını sağlar ve minimize edilmek
istenen fonksiyonu temsil eder:
𝑓 (𝑥⃗ ) = 0.6224 (𝑥1 + 𝑥2 + 𝑥3 + 𝑥4 + 𝑥5 )
Burada optimizasyon sürecinde belirlenen tasarım değişkenleridir.
b) constraint_function(x)
Bu fonksiyon, çözümlerin sağlaması gereken bir kısıt fonksiyonunu temsil eder:
𝑔(𝑥⃗ ) =
61 27 19 7
1
3+ 3+ 3+ 3+ 3−1 ≤0
𝑥1 𝑥2 𝑥3 𝑥4 𝑥5
Eğer ise çözüm geçerli (uygun) kabul edilir.
c) is_feasible(x)
Bu fonksiyon, constraint_function(x) fonksiyonunu kullanarak bir çözümün
geçerli olup olmadığını kontrol eder.
d) random_solution(bounds, max_trials=1000)
Bu fonksiyon, belirlenen değişken sınırları içinde rastgele bir çözüm üretir.
Üretilen çözümün geçerli olması için is_feasible(x) fonksiyonuyla kontrol edilir. Eğer
19
max_trials kadar deneme yapılmasına rağmen geçerli bir çözüm bulunamazsa hata
döndürülür.
e) evaluate(solution)
Bu fonksiyon, verilen çözümün hedef fonksiyon değerini hesaplar. Eğer çözüm
kısıtları sağlamıyorsa, büyük bir ceza ekleyerek uygunsuz çözümlerin optimize
edilmesini engeller. Böylece kısıtı ihlal eden çözümler cezalandırılır.
f) mutate(solution, bounds)
Bu fonksiyon, mevcut çözümün bir bileşenini rastgele seçerek yeni bir değer atar.
Eğer mutasyona uğrayan yeni çözüm geçerliyse, bu yeni çözüm döndürülür. Aksi
takdirde, mevcut çözüm korunur.
Ankastre Kiriş Tasarım Probleminin Optimizasyon İşleminin Sonunda Elde
Ettiğimiz Değerler
Ankastre kiriş tasarım problemini çözerken kullandığımız her iki Optimizasyon
yöntemi (MVO ve ABC) de yaklaşık olarak aynı sonuçları verdi. Bu işlemler sonunda,
ABC algoritmasını da kullanarak şu sonuçları elde ettik:

𝑥1 = 5.77804566673954

𝑥2 = 4.758942039964147

𝑥3 = 4.609177892201982

𝑥4 = 3.5713961504923146

𝑥5 = 2.369833880197304

𝑂𝑝𝑡𝑖𝑚𝑢𝑚 𝑎ğ𝚤𝑟𝑙𝚤𝑘 = 13.124795039860107
MVO algoritması ise bize bu sonuçları verdi:

𝑥1 = 5.999014707797229

𝑥2 = 4.8904328012125
20

𝑥3 = 4.428594903825031

𝑥4 = 3.4728783945061603

𝑥5 = 2.1499723029051387

𝑂𝑝𝑡𝑖𝑚𝑢𝑚 𝑎ğ𝚤𝑟𝑙𝚤𝑘 = 13.0336
Yani görüldüğü gibi, yaklaşık olarak iki algoritmadan da aynı değerleri elde ettik.
2.2 Dişli Sistemi Tasarımı Optimizasyon Problemi
Şekil 2.3, 2.4 ve EK-2’de görüldüğü üzere bu problemin dört parametresi vardır.
Ve buradaki asıl amaç dişli oranını optimize etmektir. [17] Dişli oranı şu şekilde
hesaplanır: [18]
Dişli Oranı = Dış milin açısal hızı / İçteki milin açısal hızı
Şekil 2.3 Dişli Tren Sistemi
Şekil 2.4 Sistemi oluşturan dişliler
Bu problemi MVO ile çözdüğümüzde aşağıdaki tablodakine (Tablo 2.2) benzer bir sonuç
elde etmemizin yanı sıra, ABC yöntemi ile de yaklaşık olarak aynı sonucu elde ettik. [19]
Tablo 2.2 Dişli sistemi probleminin farklı optimizasyon yöntemleri ile optimize
edilmesinin ardından elde edilen sonuçlar
21
Tablo 2.2’de görüldüğü üzere, tüm yöntemler bize yaklaşık olarak aynı sonuçları
verdi. Ve biz de, problemi çözdüğümüz her iki optimizasyon yönteminde kullandığımız
kodlar sayesinde bunlara oldukça yakın sonuçlar elde ettik.
Dişli Treni Tasarım Problemi Optimizasyonuna MVO Yaklaşımı
Bu problemi öncelikle MVO algoritması ile çözdük. MVO yöntemini uygularken
kullandığımız kodlar şunlardır:
import random
import numpy as np
# Hedef fonksiyon: Minimize edilecek fonksiyon
def objective_function(x):
return ((1/6.931) - ((x[2] * x[1]) / (x[0] * x[3])))**2
# Rastgele sayı üretici için sabit bir seed
# random.seed(42)
# np.random.seed(42)
# MVO Parametreleri
n_universes = 100 # evren sayısı
max_iter = 1000 # maksimum iterasyon sayısı
lower_bound = [12, 12, 12, 12] # alt sınır
22
upper_bound = [60, 60, 60, 60] # üst sınır
# Evrenlerin başlangıç pozisyonlarını rastgele belirle
def initialize_universes():
return [[random.randint(lower_bound[i], upper_bound[i]) for i in range(4)]
for _ in range(n_universes)]
# Evrenlerin potansiyel enerji (uygunluk) hesaplaması
def calculate_fitness(universe):
return objective_function(universe)
# Evrenlerin büyük patlama ve kara delikler arasındaki dolaşımı
def multiverse_optimization():
universes = initialize_universes()
best_universe = min(universes, key=calculate_fitness)
for iteration in range(max_iter):
for i in range(n_universes):
if universes[i] != best_universe:
for j in range(4):
black_hole = random.choice(universes)
new_value
=
universes[i][j]
+
random.uniform(-1,
1)
*
(black_hole[j] - universes[i][j])
new_value
=
max(lower_bound[j],
min(upper_bound[j],
new_value))
universes[i][j] = int(new_value)
if calculate_fitness(universes[i]) < calculate_fitness(best_universe):
best_universe = universes[i]
if iteration % 100 == 0:
print(f"Iteration {iteration + 1}: Best Universe = {best_universe}, Value
= {calculate_fitness(best_universe)}")
23
return best_universe, calculate_fitness(best_universe)
# Optimizasyonu çalıştır
best_universe, best_value = multiverse_optimization()
print(f"En iyi çözüm: {best_universe}, Değer: {best_value}")
Kodun temel amacı, MVO yöntemini kullanarak dört değişkenli bir dişli
sisteminde en optimal dişli oranlarını bulmamıza yardımcı olmaktır.
Şimdi de bu kodların işleyişini ve önemli bazı noktaları açıklayalım.
Kullanılan Bazı Fonksiyon ve Parametrelerin Açıklaması
a) Objective_function
Minimize edilmesi gereken fonksiyon şudur:
1
𝑥2 ⋅ 𝑥1 2
(
−
)
6.931 𝑥0 ⋅ 𝑥3
Burada, x = [x 0 , x1 , x 2 , x 3 ] tasarım değişkenleridir. Bu fonksiyon ile problemdeki
uygunluk, yani fitness değerini belirleriz.
b) İnitialize_universes
Bu fonksiyon her evren için rastgele değerler üretir ve sonrasında bunları
belirlenen sınırlar dahilinde olacak şekilde dağıtır.
c) Calculate_fitness
Bu bir uygunluk fonksiyonudur ve her evren için bir uygunluk değeri hesaplar.
Uygunluk değeri ne kadar düşük olursa o kadar iyi bir çözüm bulundu demektir.
d) Multiverse_optimization
Bu bizim ana fonksiyonumuzdur ve bizi asıl optimum çözüme götürür. Tüm
evrenlerin arasında rastgele bir tanesinin içinden en iyi çözüm seçilir. Her iterasyonda her
24
bir evren, rastgele seçilen başka bir evrenin çekim etkisi ile güncellenir. Yeni değerler,
alt ve üst sınırlara uygun biçimde düzenlenir ve yeni çözüm daha iyi ise en iyi çözüm
olarak belirlenir. 100 iterasyonda bir, en iyi çözüm ekrana yazdırılır.
Kodumuz şu şekilde çalışır: Öncelikle başlangıç değerlerini belirler ve 100 farklı
evren oluşturulur (Aday Evrenler). En iyi evren bunların arasından seçilir.
1000 iterasyon boyunca, her evren sürekli olarak başka evrenlerin etkisi ile
güncellenir ve yeni değerler, sınırlar içerisinde kalacak şekilde ayarlanır. Yeni çözümün
eskisinden daha iyi olması durumunda, daha önce de bahsedildiği üzere en iyi evren
etiketini alır. Her 100 iterastonda bir o anki en iyi çözüm belirtilir ve son iterasyonda en
iyi çözüm değeri yazdırılır.
Dişli Treni Tasarım Problemi Optimizasyonuna ABC Yaklaşımı
Aynı problemi, ABC yöntemi ile de çözdük ve çözüme ulaşmakta kullandığımız
kod şudur:
import numpy as np
# Yeni fonksiyon: ((1/6.931) - ((x[2] * x[1]) / (x[0] * x[3])))**2
def custom_function(x):
return ((1/6.931) - ((x[2] * x[1]) / (x[0] * x[3])))**2
# Rastgele çözüm üret
def random_solution(bounds):
return [np.random.randint(bound[0], bound[1]) for bound in bounds]
# Çözümü değerlendir
def evaluate(solution):
return custom_function(solution)
# Çözümü mutasyona uğrat
25
def mutate(solution, bounds):
mutant = solution.copy()
dim_to_mutate = np.random.randint(len(bounds))
mutant[dim_to_mutate] = np.random.randint(bounds[dim_to_mutate][0],
bounds[dim_to_mutate][1])
return mutant
# ABC algoritması
def abc_optimization(bounds, n_agents, n_iter):
# Arıların sayısı
employed_bees = n_agents // 2
onlooker_bees = n_agents // 2
# Başlangıç popülasyonu
population = [random_solution(bounds) for _ in range(n_agents)]
fitness = [evaluate(individual) for individual in population]
# İterasyonlar
for _ in range(n_iter):
# Employed bees
for i in range(employed_bees):
candidate = mutate(population[i], bounds)
candidate_fitness = evaluate(candidate)
if candidate_fitness < fitness[i]:
population[i] = candidate
fitness[i] = candidate_fitness
# Normalize edilmiş olasılıkların hesaplanması
total_fitness = sum(abs(f) for f in fitness[:employed_bees])
probabilities = [abs(f)/total_fitness for f in fitness[:employed_bees]]
# Onlooker bees
for i in range(onlooker_bees):
selected_bee = np.random.choice(employed_bees, p=probabilities)
26
candidate = mutate(population[selected_bee], bounds)
candidate_fitness = evaluate(candidate)
if candidate_fitness < fitness[selected_bee]:
population[selected_bee] = candidate
fitness[selected_bee] = candidate_fitness
# En iyi çözümü döndür
best_index = np.argmin(fitness)
return population[best_index], fitness[best_index]
# Parametreler
bounds = [(12, 60), (12, 60), (12, 60), (12, 60)] # x0, x1, x2 ve x3 için sınırlar
n_agents = 2000
n_iter = 300
# Arıların sayısı
# İterasyon sayısı
# Optimizasyon
best_solution, best_fitness = abc_optimization(bounds, n_agents, n_iter)
print(f"En iyi çözüm: {best_solution}")
print(f"En iyi fitness: {best_fitness}")
Bu kodun amacı, ABC algoritmasını kullanarak dört değişkenli bir dişli sistemi
optimizasyon probleminde bize yardımcı olmak idi. Bu algoritma, daha önceki
bölümlerde de bahsettiğimiz biyolojik sistemlerden esinlenen türden bir algoritmadır ve
çözüm uzayını etkin bir şekilde tarayarak en iyi dişli oranını bulmak ana amaçtır. Bu
algoritma, bize tablo 2.2’de belirtilen MVO algoritması sonuçlarına yakın değerler
vermiştir.
Şimdi de bu kodların işleyişini ve önemli bazı noktaları açıklayalım.
Optimizasyon Sürecinde Kullanılan Bazı Temel Parametre ve Fonksiyonlar
a) Objective_function
Minimize edilmesi gereken fonksiyon şudur:
27
1
𝑥2 ⋅ 𝑥1 2
(
−
)
6.931 𝑥0 ⋅ 𝑥3
Burada, 𝑥 = 𝑥0 , 𝑥1 , 𝑥2 , 𝑥3 tasarım değişkenlerini belirtir. Bu fonksiyon, uygunluk
değerini belirler.
b) Random_solution
Bu fonksiyon, aday çözümleri, belirlenen sınırlar dahilinde, adından da
anlaşılacağı üzere rastgele değerler alarak oluşturur.
c) Evaluate
Evaluate fonksiyonu, belirlenen uygunluk fonksiyonunun yardımı ile her aday
çözümünü değerlendirir. Yani uygunluk değerini hesaplar.
d) Mutate
Mutate fonksiyonu, mevcut çözümde rastgele bir boyut belirler, örneğin 𝑥0 veya
𝑥1 gibi, ve bu boyutu rastgele bir değere atayarak mutasyona uğratır.
Optimizasyon süreci adım adım şu şekilde gerçekleşir: Önce bir başlangıç
popülasyonu oluşturulur. Bu çözümler, uygunluk fonksiyonu ışığında değerlendirilir ve
uygunluk değerleri belirlenir.
İkinci adım, işçi arılar fazıdır. Bu adımda her arı, mutate fonksiyonunu kullanarak
rastgele bir mutasyon işlemi uygular. Yeni çözümün eskisinden daha iyi olması halinde,
mevcut en iyi çözüm güncellenir.
Bir sonraki adımda, izleyici arılar, uygunluk değerlerini normalize ederek
olasılıklar hesaplar ve bu olasılıklar dahilinde en iyi çözüme odaklanırlar. Tıpkı işçi arılar
gibi onlar da rastgele şekilde mutasyon işlemi uygular ve en iyi çözümü güncellerler.
Son adımda en iyi çözüm belirlenir. Tüm iterasyonlar tamamlanınca en iyi yani
en düşük uygunluk değerine sahip çözüme dönülür.
28
Dişli Sistemi Tasarım Probleminin Optimizasyon İşleminin Sonunda Elde Ettiğimiz
Değerler
Her iki Optimizasyon yöntemi (MVO ve ABC) de yaklaşık olarak aynı sonuçları
verdi. Bu işlemler sonunda, ABC optimizasyon algoritmasını da kullanarak şu sonuçları
elde ettik:

𝑛𝑎 = 47

𝑛𝑏 = 13

𝑛𝑐 = 12

𝑛𝑑 = 23

𝑂𝑝𝑡𝑖𝑚𝑎𝑙 𝑑𝑖ş𝑙𝑖 𝑜𝑟𝑎𝑛𝚤 = 9.921579583985335𝑒 − 10
MVO algoritması ise bize şu sonuçları verdi:

𝑛𝑎 = 54

𝑛𝑏 = 12

𝑛𝑐 = 37

𝑛𝑑 = 57

𝑂𝑝𝑡𝑖𝑚𝑎𝑙 𝑑𝑖ş𝑙𝑖 𝑜𝑟𝑎𝑛𝚤 = 8.887614372714457𝑒 − 10
Görüldüğü üzere, her iki optimizasyon algoritmasından da aynı optimum dişli
oranını elde ettik. Bu da demek oluyor ki, tasarım sürecinde bu orana oldukça dikkat
etmeliyiz.
29
2.3 MVO (Multi-Verse Optimizer) Nedir?
MVO, doğadan esinlenen bir tür optimizasyon algoritmasıdır. Algoritma, şu üç
kozmolojik kavramdan esinlenir: Kara delikler, beyaz delikler ve solucan delikleri. Keşif,
sömürü ve yerel aramalar yapmak amacı ile bu üç kavramın matematiksel modelleri
geliştirilmiştir.
Doğa, çoğu nüfus tabanlı olan birçok stokastik optimizasyon yöntemi için büyük
bir ilham kaynağı olmuştur. Bu tür yöntemlerin isimlerinden de anlaşılacağı üzere,
optimizasyonu tamamen rastgele gerçekleştirirler. Optimizasyon sürecinin başlangıcında,
öncelikle bir dizi rastgele çözüm oluşturulur. Oluşturulan ilk çözümler, belirli bir
iterasyon sayısı boyunca birleştirilir, taşınır veya evrimleşirler. Bahsedilen durum,
neredeyse tüm nüfus tabanlı algoritmaların ana çerçevesidir diyebiliriz. Bu alandaki diğer
algoritmalardan farklı kılan şey, optimizasyon sırasında çözümleri birleştirme, taşıma
veya evrimleştirme mekanizmasıdır.
Örneğin, Genetik Algoritmalar (GAs) [20], doğadaki daha uygun bireylerin
hayatta kalma yeteneğini kullanarak en iyi çözümleri seçer ve ardından kromozomların
üremesine dayalı olarak bunları birleştirir. Parçacık Sürü Optimizasyonu (PSO) [21],
kuşların uçarkenki sosyal ve bireysel düşüncelerinden esinlenmiştir, bu nedenle aday
çözümleri, şu ana kadar elde edilen kendi kişisel en iyi konumlarına ve sürünün bulduğu
en iyi konuma göre bir arama alanında hareket etmeye zorlar. Gravitasyonel Arama
Algoritması (GSA) [22], arama alanındaki umut vaat eden bölgelere doğru arama
ajanlarını hareket ettirmek için Newton'un hareket yasalarını kullanır.
Farklı popülasyon tabanlı algoritmalar arasında yaygın olan kavramlardan biri de
keşif (exploration) ve sömürü (exploitation) süreçleridir. Keşif, algoritmanın arama
uzayında farklı umut verici bölgeleri küresel olarak keşfetmeye çalıştığı aşamadır. Bu
aşamada aday çözümlerde ani değişiklikler genellikle faydalıdır. Sömürü ise
algoritmanın, keşif aşamasında bulunan umut verici çözümler etrafında yerel olarak
yoğunlaşma ve yakınsama yeteneğidir. Küresel en iyi çözüme ulaşabilmek için keşif ve
sömürü arasında uygun bir denge sağlanmalıdır.
Son yıllarda, mevcut algoritmaların iyileştirilmesi veya yeni optimizasyon
algoritmalarının önerilmesi konusunda büyük bir ilgi artışı olmuştur. Bunun temel
30
sebeplerinden biri No Free Lunch (NFL) Teoremidir. Bu teorem, her türlü optimizasyon
problemini çözebilecek tek bir yöntem olmadığını mantıksal olarak kanıtlamıştır. Bu
nedenle, araştırmacılar mevcut algoritmaları geliştirme veya yeni rekabetçi algoritmalar
önerme konusunda çalışmalar yapmaktadır.
Büyük Patlama (Big Bang) Teorisi [23], evrenimizin büyük bir patlama ile
başladığını öne sürer. Bu teoriye göre, Büyük Patlama, var olan her şeyin başlangıcıdır
ve öncesinde hiçbir şey yoktur.
Çoklu Evren (Multi-Verse) Teorisi, fizikçiler arasında bilinen ve üzerinde
çalışılan görece yeni bir teoridir [24]. Bu teoriye göre, birden fazla Büyük Patlama olabilir
ve her biri yeni bir evrenin oluşumuna neden olur. "Çoklu evren" kavramı, yaşadığımız
evrenin ötesinde başka evrenlerin de var olabileceğini ifade eder [24]. Ayrıca, çoklu
evrenler birbirleriyle etkileşime girebilir ve çarpışabilir. Bu teori, her evrenin kendine
özgü fizik yasalarına sahip olabileceğini de öne sürmektedir.
Bu çalışmada, MVO algoritması, çoklu evren teorisindeki üç temel kavramdan
ilham alarak geliştirilmiştir:
MVO algoritması, çoklu evren teorisindeki üç temel kavramdan ilham almıştır:
1. Beyaz Delikler (White Holes): Evrenimizde gözlemlenmemiştir, ancak
fizikçiler Büyük Patlama’nın bir beyaz delik olabileceğini ve bir evrenin
oluşumundaki temel bileşenlerden biri olduğunu düşünmektedir [25].
Çoklu evren teorisinin döngüsel modeli [26], paralel evrenlerin çarpışması
sonucunda Büyük Patlamalar (ve dolayısıyla beyaz delikler) oluştuğunu
öne sürmektedir.
2. Kara Delikler (Black Holes): Evrenimizde sıkça gözlemlenmiştir ve
beyaz deliklerin tam tersi şekilde davranırlar. Aşırı yüksek kütle çekim
kuvvetleri sayesinde ışık dahil her şeyi kendilerine çekerler [27].
31
3. Solucan Delikleri (Wormholes): Evrenimizde sıkça gözlemlenmiştir ve
beyaz deliklerin tam tersi şekilde davranırlar. Aşırı yüksek kütle çekim
kuvvetleri sayesinde ışık dahil her şeyi kendilerine çekerler [27].
Her evrenin, uzayda genişlemesine neden olan bir enflasyon hızı (sonsuz
enflasyon) vardır [28]. Bir evrenin genişleme hızı, yıldızların, gezegenlerin, asteroitlerin,
kara deliklerin, beyaz deliklerin, solucan deliklerinin, fizik yasalarının ve yaşamın
uygunluğunun şekillenmesi açısından büyük önem taşır. Çoklu evren modellerinden biri
[29], çoklu evrenlerin beyaz delikler, kara delikler ve solucan delikleri aracılığıyla
etkileşime girerek dengeli bir duruma ulaştığını öne sürmektedir.
2.4 ABC Nedir?
Bilgisayar bilimi ve optimizasyon alanında; Yapay Arı Kolonisi (ABC)
algoritmaları, bal arılarının sürü davranışlarını model alarak oluşturulmuş bir tür
optimizasyon algoritmasıdır. 2005 yılında Erciyes Üniversitesi’nden Derviş Karaboğa bu
algoritmayı üretmiştir. [30] Bu çalışmayı yazarken incelediğimiz birçok yabancı
makalede, KARABOGA atıfını görerek gururlandık.
Yapay Arı Kolonisi (Artificial Bee Colony - ABC) algoritması, Dervis Karaboga
tarafından
geliştirilmiş,
doğadan
esinlenilerek
oluşturulmuş
bir
optimizasyon
algoritmasıdır. [31] ABC, bal arılarının doğal besin arama davranışından ilham alarak çok
değişkenli fonksiyonları optimize etmek için kullanılan bir sürü zeka algoritmasıdır.
ABC Algoritmasının Bileşenleri
ABC algoritması, yapay arı kolonisini üç temel bileşenle modellenen arı
gruplarından oluşur:

Çalışan Arılar (Employed Bees): Mevcut çözüm havuzunda bulunan çözümleri
iyileştirmek için çalışan arılardır. Her çalışan arı, belirli bir besin kaynağını
ziyaret eder ve oradan bilgi toplar.
32

Gözlemci Arılar (Onlooker Bees): Çalışan arılardan gelen bilgiyi analiz eder ve
daha iyi besin kaynaklarını seçerek arama yapar.

Keşifçi Arılar (Scout Bees): Yerel optimumlara sıkışmayı önlemek için rastgele
yeni çözümler oluşturur.
3. ABC Algoritmasının Çalışma Mantığı
ABC algoritması, aşağıdaki adımlarla çalışır:
1. Başlangıç Popülasyonunun Oluşturulması: Rastgele bir başlangıç popülasyonu
oluşturulur. Her birey bir besin kaynağını temsil eder.
2. Çalışan Arı Aşaması: Her çalışan arı, mevcut besin kaynağını geliştirmek için
yeni bir aday çözüm oluşturur.
3. Gözlemci Arı Aşaması: Gözlemci arılar, en iyi besin kaynaklarını seçerek
aramaya devam eder.
4. Keşifçi Arı Aşaması: Kötü performans gösteren besin kaynakları terk edilir ve
yeni kaynaklar rastgele oluşturulur.
5. Durdurma Kriteri: Algoritma belirlenen iterasyon sayısına ulaştığında veya en
iyi çözüm iyileşmediğinde durur.
ABC Algoritmasının Diğer Optimizasyon Algoritmaları ile Karşılaştırması
ABC algoritması, Genetik Algoritma (GA), Parçacık Sürüsü Optimizasyonu
(PSO) ve Parçacık Sürüsü Türetilmiş Evrimsel Algoritma (PS-EA) gibi diğer
optimizasyon algoritmalarıyla karşılaştırılmıştır. [32] Yapılan deneyler göstermiştir ki:

ABC algoritması hızlı bir kültüre uyum sağlayarak yeni çözümler üretebilir.
33

Yerel minimumlara sıkışma olasılığı daha azdır. [33]

PSO ve PS-EA gibi diğer sürü zeka algoritmalarına göre daha güçlü bir kaçınma
mekanizması sunar. [34]

GA'ya göre çok boyutlu problemlerde daha hızlı bir çözüm sağlar. [35]
ABC algoritması, optimizasyon problemlerini çözmek için etkili bir yaklaşım
sunar. Sürü zekasının avantajlarını kullanarak verimli ve esnek bir arama stratejisi
sunar. Gelecekte, ABC algoritmasının karmaşık sistemlerde, makine öğrenmesi
modellerinde ve büyük veri analitiğinde daha fazla kullanılması beklenmektedir. [36]
Bu çalışma, ABC algoritmasının teorik temellerini ve uygulamalarını ele
almaktadır. Gelecekte, farklı hibrid yaklaşımlar ile ABC algoritmasının daha da
geliştirilmesi mümkün olabilir.
34
3. SONUÇ
Bu çalışmada, ankastre kiriş ve dişli sistemi tasarım problemlerinin
optimizasyonu için farklı metasezgisel algoritmalar kullanılmış ve elde edilen sonuçlar
karşılaştırılmıştır. Çalışmada, Multi-Verse Optimization (MVO) ve Artificial Bee Colony
(ABC) algoritmaları kullanılarak optimizasyon süreçleri gerçekleştirilmiştir.
Öncelikle ankastre kiriş tasarım probleminde, MVO ve ABC algoritmaları
uygulanarak kirişin ağırlığını minimize eden parametrelerin belirlenmesi hedeflenmiştir.
Kodlama aşamasında Python programlama dili kullanılmış ve optimizasyon süreçlerinde
keşif ve sömürü aşamalarının dengeli bir şekilde yürütülmesine özen gösterilmiştir.
Yapılan optimizasyon çalışmaları sonucunda, her iki algoritma ile elde edilen sonuçların
benzer olduğu görülmüş, ancak MVO algoritmasının daha hızlı bir yakınsama sağladığı
ve optimal çözüme daha kararlı bir şekilde ulaştığı belirlenmiştir.
Dişli sistemi tasarım probleminde ise, sistemin dişli oranının optimize edilmesi
amaçlanmıştır. Bu problemde de MVO ve ABC algoritmaları karşılaştırılmış, sonuç
olarak her iki algoritmanın da optimal dişli oranlarına ulaşmak için başarılı olduğu
görülmüştür. Ancak, ABC algoritmasının daha geniş bir çözüm uzayını araştırarak daha
iyi bir keşif mekanizmasına sahip olduğu tespit edilmiştir.
Genel
olarak,
çalışmamızda
kullanılan
optimizasyon
yöntemleri
karşılaştırıldığında, her iki yöntemin avantaj ve dezavantajlarının olduğu görülmüştür:

MVO Algoritması: Daha hızlı bir yakınsama sağlarken, keşif yeteneği zamanla
azalmakta ve yerel minimumlara sıkışma riski taşımaktadır.

ABC Algoritması: Çözüm uzayını daha geniş tarayabilmekte ve daha iyi bir keşif
mekanizması sunmaktadır. Ancak, iterasyon sayısı arttıkça yakınsama süresi
uzayabilmektedir.
Sonuç olarak, optimizasyon problemlerinde tek bir yöntem yerine, farklı
algoritmaların hibrit olarak birleştirilmesiyle daha verimli çözümler elde edilebileceği
düşünülmektedir. Gelecekteki çalışmalar için, MVO ve ABC algoritmalarının
avantajlarını birleştiren hibrit yaklaşımların geliştirilmesi önerilmektedir.
35
Bunun yanı sıra, farklı optimizasyon problemlerine yönelik olarak diğer
metasezgisel algoritmaların da araştırılması, mühendislik problemlerinin çözümünde
önemli katkılar sağlayacaktır.
36
KAYNAKLAR
1. Mei, L.-B., & Wang, Q. (2021). Structural optimization in civil engineering: A
literature
review.
Buildings,
11(2),
66.
(https://doi.org/10.3390/buildings11020066)
2. Beauregard, Y., Thomson, V., & Bhuiyan, N. (2008). Lean engineering logistics:
Load leveling of design jobs with ca pacity considerations.
(https://doi.org/10.5589/Q08-006)
3. B. Bunday, Basic Optimization Methods, London: Edward Arnold Ltd, 1984.
4. E. V. Altay, B. Alatas, “Bird swarm algorithms with chaotic mapping”, Artificial
Intelligence Review, vol. 53 no. 2, pp. 1373-1414, 2020.
5. E. Varol, B. Alataş, “Sürü zekâsında yeni bir yaklaşım: Kuş sürüsü algoritması”,
Dicle Üniversitesi Mühendislik Fakültesi Mühendislik Dergisi, vol. 8, no. 1, pp.
133-146, 2017.
6. S. İ. Birbil, S. C. Fang, “An electromagnetism-like mechanism for global
optimization”, Journal of global optimization, vol. 25, no. 3, pp. 263-282, 2003.
7. B. Xing, W. J. Gao, “Central force optimization algorithm”, In Innovative
Computational Intelligence: A Rough Guide to 134 Clever Algorithms, Springer
International Publishing, pp. 333-337, 2014.
8. L. Xie, Y. Tan, J. Zeng, Z. Cui, “Artificial physics optimisation: a brief survey”,
International Journal of Bio-Inspired Computation, vol. 2, no. 5, pp. 291-302,
2010.
9. M. Kripka, R. M. L. Kripka, “Big crunch optimization method”, In International
conference on engineering optimization. Brazil, 2008, pp. 1-5.
10. Biroğul, S. (2005). Genetik Algoritma Yaklaşımıyla Atölye Çizelgeleme, Yüksek
Lisans Tezi. Ankara: Gazi Üniversitesi, Fen Bilimleri Enstitüsü.
11. Michalewicz, Z. (1994). Genetic Algorithms + Data Structures = Evolution
Programs. Berlin: Springer-Verlag.
12. https://aof.sorular.net/ozet/matematiksel-iktisat-ceI-unite-7-kisitsizoptimizasyon
Erişim tarihi: Ocak 2025
13. Murata, T., & Ishibuchi, H. (1995). MOGA: Multiobjective Genetic Algorithms.
2nd IEEE International Conference on Evolutionary Computation, (s. 289-294).
Perth, Australia.
37
14. https://aof.sorular.net/sorularcevaplar/matematiksel-iktisat-8-kisitlioptimizasyon
Erişim tarihi: Ocak 2025
15. Schaffer, J. (1984). Some Experiments in Machine Learning Using Vector
Evaluated Genetic Algorithms, PhD Thesis. Nashville, ABD: Vanderbilt
University.
16. Carlos A, Coello C (2000) Constraint-handling using an evolu tionary
multiobjective optimization technique. Civil Eng Syst 17:319–346
17. Sandgren E (1990) Nonlinear integer and discrete programming in mechanical
design optimization. J Mech Des 112(2):223–229. doi:10.1115/1.2912596
18. Gandomi AH (2014) Interior search algorithm (ISA): a novel approach for global
optimization. ISA Trans 53(4):1168–1183. doi:10.1016/j.isatra.2014.03.018
19. Sadollah A, Bahreininejad A, Eskandar H, Hamdi M (2013) Mine blast algorithm:
a new population based algorithm for solving constrained engineering
optimization problems. Appl Soft Com put 13:2592–2612
20. John H (1992) Holland, adaptation in natural and artificial sys tems. MIT Press,
Cambridge
21. Kennedy J, Eberhart R (1995) Particle swarm optimization. In: Proceedings of
IEEE international conference on neural net works, pp 1942–1948
22. Rashedi E, Nezamabadi-Pour H, Saryazdi S (2009) GSA: a gravitational search
algorithm. Inf Sci 179:2232–2248
23. Khoury J, Ovrut BA, Seiberg N, Steinhardt PJ, Turok N (2002) From big crunch
to big bang. Phys Rev D 65:086007
24. Tegmark M (2004) Parallel universes. In: Barrow JD, Davies PCW, Harper CL Jr
(eds) Science and ultimate reality: Quantum theory, cosmology, and complexity.
Cambridge University Press, pp 459–491
25. Eardley DM (1974) Death of white holes in the early Universe. Phys Rev Lett
33:442
26. Steinhardt PJ, Turok N (2002) A cyclic model of the universe. Science 296:1436–
1439
38
27. Davies PC (1978) Thermodynamics of black holes. Rep Prog Phys 41:1313
28. Morris MS, Thorne KS (1988) Wormholes in spacetime and their use for
interstellar travel: a tool for teaching general relativity. Am J Phys 56:395–412
29. Guth AH (2007) Eternal inflation and its implications. J Phys A Math Theor
40:6811
30. Karaboga, Dervis & Basturk, Bahriye. (2007). A powerful and efficient algorithm
for numerical function optimization: Artificial bee colony (ABC) algorithm.
Journal of Global Optimization. 39. 459-471. 10.1007/s10898-007-9149-x.
31. Holland, J.H.: Adaptation in Natural and Artificial Systems. University of
Michigan Press, Ann Arbor, MI (1975)
32. Srinivasan, D., Seow, T.H.: Evolutionary Computation, CEC ’03, 8–12 Dec.
2003, 4(2003), Canberra, Australia, pp. 2292–2297.
33. . Hadley, G.: Nonlinear and Dynamics Programming. Addison Wesley, Reading,
MA (1964)
34. Kennedy, J., Eberhart, R.C.: Particle swarm optimization. In: Proceedings of the
1995 IEEE International Conference on Neural Networks, vol. 4, pp. 1942–1948.
IEEE Service Center, Piscat away (1995)
35. Holland, J.H.: Adaptation in Natural and Artificial Systems. University of
Michigan Press, Ann Arbor, MI (1975)
36. Yang, X.S.: Engineering optimizations via nature-inspired virtual bee algorithms.
Lecture Notes in Computer Science, pp. 317–323. Springer, GmbH (2005)
39
EKLER
EK-1 Ankastre Kiriş Tasarımı Probleminin optimizasyonu sürecinde dikkat edilecek
değer ve fonksiyonlar.
Ankastre Kiriş Tasarımı
Parametreler:
𝑥⃗ = [𝑥1 , 𝑥2 , 𝑥3 , 𝑥4 , 𝑥5 ]
Minimize etmek için amaç fonksiyonu:
𝑓(𝑥⃗ ) = 0.6224(𝑥1 + 𝑥2 + 𝑥3 + 𝑥4 + 𝑥5 )
Kısıt fonksiyonu:
𝑔(𝑥⃗ ) =
61 27 19 7
1
3+ 3+ 3+ 3+ 3−1 ≤0
𝑥1 𝑥2 𝑥3 𝑥4 𝑥5
Değişken aralığı:
0.01 ≤ 𝑥1 , 𝑥2 , 𝑥3 , 𝑥4 , 𝑥5 ≤ 100
Optimizasyon sonucu elde edilen değerler:
𝑥1
MVO
ABC
𝑥2
𝑥3
𝑥4
𝑥5
5.999014708 4.890432801 4.428594904 3.472878395 2.149972303
5.778045667 4.75894204 4.609177892 3.57139615 2.36983388
Optimum Ağırlık
13.0336

40
EK-2 Dişli Sistemi Tasarımı Problemini optimizasyonu sırasında dikkat edilecek değer
ve fonksiyonlar.
Dişli Sistemi Tasarımı
Parametreler:
x⃗⃗ = [x1 , x 2 , x 3 , x 4 ] = [nA , nB , nC , nD ]
Minimize etmek için amaç fonksiyonu:
f(x⃗⃗) = (
1
x3x2 2
−
)
6.931 x1 x 4
Değişken aralığı:
12 ≤ x1 , x 2 , x 3 , x 4 ≤ 60
Optimizasyon sonucu elde edilen değerler:
MVO
ABC
𝑛𝑎
54
47
𝑛𝑏
12
13
𝑛𝑐
37
12
𝑛𝑑
57
23
Optimal Dişli Oranı
8.89E-10
9.92E-10