Makine Öğrenmesi / İleri / Proje 5

Proje 5 · İleri · ~70 dk

Kompozit laminat için vekil model ve ters tasarım

Karbon/epoksi bir laminatın tabaka açılarından düzlem içi rijitliğini tahmin eden bir sinir ağı kuracağız. Doğru girdi gösterimini klasik laminasyon teorisinden türetecek, sonra hedef rijitliği veren açıları bu ağ üzerinden gradyanla arayıp her sonucu kesin hesapla doğrulayacağız.

Bu derste öğrenecekleriniz

  • Simetrik bir laminatın A matrisini ve düzlem içi mühendislik sabitlerini klasik laminasyon teorisiyle hesaplamak
  • A'nın laminasyon parametrelerinin doğrusal fonksiyonu olduğunu göstermek ve bunu özellik tasarımında kullanmak
  • Açı gibi periyodik girdilerin gösteriminin veri verimliliğine etkisini öğrenme eğrisiyle ölçmek
  • Türevlenebilir bir vekil üzerinden çok başlangıçlı gradyan inişiyle ters tasarım yapmak
  • Her tasarımı kesin modelle doğrulamak; çözümün tek olmadığını ve vekilin zayıf kaldığı bölgeleri yorumlamak
Seviye
İleri
Süre
~70 dk
Kütüphaneler
NumPy, PyTorch, Matplotlib

1. Problem: istenen rijitliği veren tabaka açıları

Karbon/epoksi bir panel tasarladığınızı düşünün. Tek yönlü bir tabaka lif doğrultusunda çok rijit, life dik doğrultuda ise yumuşaktır. Tasarımcının asıl serbestliği tabakaların açısıdır: aynı malzemeyle, yalnız açıları değiştirerek x yönündeki elastisite modülünü yaklaşık 10 GPa ile 181 GPa arasında ayarlayabilirsiniz.

İleri problem kolaydır. Açılar verilince klasik laminasyon teorisi (KLT) rijitliği birkaç matris işlemiyle hesaplar. Mühendisin sorusu ise terstir: “x yönünde 70 GPa, y yönünde 40 GPa istiyorum; hangi açıları seçmeliyim?” Bu ters problemin üç zorluğu var: ilişki doğrusal değildir, birden çok çözüm olabilir ve üretimde açılar çoğu zaman 0°, ±45° ve 90° ile sınırlıdır.

Projede beş adım izleyeceğiz:

  1. KLT ile rastgele açılı laminatların rijitliğini hesaplayıp veri üretmek ve kodu bilinen sonuçlarla sınamak.
  2. Fiziğin önerdiği girdi gösterimini, yani laminasyon parametrelerini türetmek.
  3. Açılardan rijitliği tahmin eden bir sinir ağı vekil modeli (surrogate) kurmak ve üç farklı girdi gösterimini aynı ağla karşılaştırmak.
  4. Hedef rijitliği veren açıları, vekilin gradyanını kullanarak aramak (ters tasarım).
  5. Bulunan her tasarımı kesin KLT ile doğrulamak ve üretim dostu açılarla yapılan kapsamlı aramayla karşılaştırmak.
Mühendislik notu

Kesin model bu kadar ucuzsa vekil neden?

Dürüst olalım: düzlem içi rijitlik için KLT birkaç mikrosaniyede kesin sonuç verir; bu problemde vekile gerçekten ihtiyaç yok. Problemi bilerek seçtik, çünkü doğru cevabı her an bilebiliyoruz. Asıl kazanç iş akışında: girdi gösterimini fizikten türetmek, türevlenebilir bir vekil üzerinden tasarım aramak ve her sonucu kesin modelle doğrulamak. Aynı akış, tek bir çözümü dakikalar süren problemlerde (sonlu elemanlarla burkulma yükü, ilerleyen hasar, doğrusal olmayan analiz) gerçekten gerekir. Vekilsiz yolu Alıştırma 4'te deneyeceksiniz.

Veri tamamen sentetiktir. Tabaka özellikleri olarak ders kitaplarında sık kullanılan T300/5208 karbon/epoksi değerlerini aldık (tablo). Bunlar öğretim amaçlı tipik değerlerdir, bir üreticinin tasarım değeri değildir. Laminat simetrik ve 8 tabakalıdır: $[\theta_1/\theta_2/\theta_3/\theta_4]_s$. Orta düzlemin altındaki dört tabaka üsttekilerin aynasıdır; bu yüzden tasarım değişkeni dört açıdır. Açılar $[-90^\circ, 90^\circ)$ aralığından düzgün dağılımla çekildi.

Tabaka özellikleri (T300/5208, ders kitabı değerleri) ve laminat
BüyüklükDeğerAnlam
$E_1$181 GPaLif doğrultusunda elastisite modülü
$E_2$10,3 GPaLife dik elastisite modülü
$G_{12}$7,17 GPaDüzlem içi kayma modülü
$\nu_{12}$0,28Ana Poisson oranı
$t$0,125 mmTabaka kalınlığı; 8 tabakada $h$ = 1 mm

2. Klasik laminasyon teorisi: açılardan rijitliğe

KLT'nin türetmesi ve varsayımları sitedeki klasik laminasyon teorisi notunda var. Burada yalnız kullanacağımız dört adımı özetliyoruz.

Tabaka rijitliği. Her tabaka kendi ana eksenlerinde (1: lif, 2: life dik) düzlem gerilme durumundadır. $\nu_{21} = \nu_{12}E_2/E_1$ olmak üzere indirgenmiş rijitlik matrisi $Q$'nun terimleri:

$$ \begin{aligned} Q_{11} &= \frac{E_1}{1-\nu_{12}\nu_{21}} \\[6pt] Q_{22} &= \frac{E_2}{1-\nu_{12}\nu_{21}} \\[6pt] Q_{12} &= \frac{\nu_{12}E_2}{1-\nu_{12}\nu_{21}} \\[6pt] Q_{66} &= G_{12} \end{aligned} $$

T300/5208 için $Q_{11}$ = 181,81, $Q_{22}$ = 10,35, $Q_{12}$ = 2,90 ve $Q_{66}$ = 7,17 GPa çıkıyor.

Dönüşüm. $\theta$ açısıyla yerleştirilen tabakanın laminat eksenlerindeki ($x$, $y$) rijitliği, $T$ gerilme dönüşüm matrisi olmak üzere:

$$ \bar Q(\theta) = T(\theta)^{-1}\, Q\, T(\theta)^{-\mathsf T} $$

$\bar Q$ genelde doludur: $\bar Q_{16}$ ve $\bar Q_{26}$ terimleri, normal gerilme ile kayma şekil değiştirmesi arasında bir kuplaj yaratır.

Laminat. Simetrik laminatta zar–eğilme kuplajı $B = 0$'dır. Düzlem içi yükler için yalnız zar rijitliği $A$ gerekir:

$$ A = \sum_{k=1}^{8} \bar Q(\theta_k)\, t_k $$

Mühendislik sabitleri. $a = A^{-1}$ olmak üzere laminatın düzlem içi eşdeğer sabitleri:

$$ \begin{aligned} E_x &= \frac{1}{h\,a_{11}} \\[6pt] E_y &= \frac{1}{h\,a_{22}} \\[6pt] G_{xy} &= \frac{1}{h\,a_{66}} \\[6pt] \nu_{xy} &= -\frac{a_{12}}{a_{11}} \end{aligned} $$
KLT'nin çekirdeği (koddan): A ve mühendislik sabitleri, çok sayıda laminat için birlikte
def A_matrisi(acilar):
    """[θ1/θ2/θ3/θ4]s: A = Σ Q̄_k t_k (8 tabaka). acilar: (n, 4) derece."""
    return 2 * T_KAT * Qbar_acik(np.radians(acilar)).sum(axis=-3)

def sabitler(acilar):
    a = np.linalg.inv(A_matrisi(np.atleast_2d(acilar)))
    return np.stack([1 / (H * a[:, 0, 0]), 1 / (H * a[:, 1, 1]), 1 / (H * a[:, 2, 2]),
                     -a[:, 0, 1] / a[:, 0, 0]], -1)          # Ex, Ey, Gxy, νxy
Örnek

KLT kodunu bilinen sonuçlarla sınamak

Veri üretmeden önce kodu üç sınamadan geçirdik (sayılar çıktıdan):

  • $\bar Q$'yu ders kitabındaki $T^{-1}QT^{-\mathsf T}$ çarpımıyla ve açık trigonometrik formüllerle ayrı ayrı hesapladık. En büyük fark 8,5×10⁻¹⁴ GPa, yani yuvarlama düzeyinde.
  • Bütün tabakaları 0° olan $[0]_8$ laminatı, tabakanın kendi sabitlerini vermeli: $E_x$ = 181,00, $E_y$ = 10,30, $G_{xy}$ = 7,17 GPa, $\nu_{xy}$ = 0,280. Veriyor.
  • $[0/{\pm}45/90]_s$ laminatı yarı-izotroptur: düzlem içi rijitliği yöne bağlı değildir. Bunun koşulu $A_{11} = A_{22}$, $A_{16} = A_{26} = 0$ ve $A_{66} = (A_{11} - A_{12})/2$'dir. $A_{16} = A_{26} = 0$, ±45° çifti dengeli olduğu için kendiliğinden sağlanır; diğer iki koşulda farklar 1,4×10⁻¹⁴ ve 0 GPa·mm çıktı. $E_x = E_y$ = 69,68 GPa değeri, bu laminat için bilinen $E = (U_1^2 - U_4^2)/U_1$ formülüyle (bir sonraki bölüm) birebir aynı.
Dikkat

Modelin kapsamı

Yalnız düzlem içi rijitliği ($A$) modelliyoruz. Eğilme rijitliği $D$ tabakaların sırasına bağlıdır ve burada hesaplanmıyor. Dayanım da modelde yok: bir tasarımın hangi yükte ilk tabaka hasarına uğrayacağını Tsai–Wu gibi ölçütler söyler (sitedeki hasar ölçütleri notu). Alıştırma 5'te bunu ekleyeceksiniz.

3. Laminasyon parametreleri: fiziğin önerdiği gösterim

$\bar Q(\theta)$'nın açık formülleri $\cos^4\theta$, $\sin^2\theta\cos^2\theta$ gibi terimler içerir. Trigonometrik özdeşliklerle bunlar çift açılara indirgenince açıdan bağımsız beş sabit ortaya çıkar. Bunlar Tsai ve Pagano'nun malzeme değişmezleridir:

$$ \begin{aligned} U_1 &= \tfrac18\,(3Q_{11} + 3Q_{22} + 2Q_{12} + 4Q_{66}) \\ U_2 &= \tfrac12\,(Q_{11} - Q_{22}) \\ U_3 &= \tfrac18\,(Q_{11} + Q_{22} - 2Q_{12} - 4Q_{66}) \\ U_4 &= \tfrac18\,(Q_{11} + Q_{22} + 6Q_{12} - 4Q_{66}) \\ U_5 &= \tfrac18\,(Q_{11} + Q_{22} - 2Q_{12} + 4Q_{66}) \end{aligned} $$

Bizim malzemede $U_1$ = 76,37, $U_2$ = 85,73, $U_3$ = 19,71, $U_4$ = 22,61 ve $U_5$ = 26,88 GPa. Değişmezlerle dönüşmüş rijitlik yalnız $\cos 2\theta$, $\sin 2\theta$, $\cos 4\theta$ ve $\sin 4\theta$ içerir:

$$ \begin{aligned} \bar Q_{11} &= U_1 + U_2\cos 2\theta + U_3\cos 4\theta \\ \bar Q_{22} &= U_1 - U_2\cos 2\theta + U_3\cos 4\theta \\ \bar Q_{12} &= U_4 - U_3\cos 4\theta \\ \bar Q_{66} &= U_5 - U_3\cos 4\theta \\ \bar Q_{16} &= \tfrac12 U_2\sin 2\theta + U_3\sin 4\theta \\ \bar Q_{26} &= \tfrac12 U_2\sin 2\theta - U_3\sin 4\theta \end{aligned} $$

$A$'yı toplarken değişmezler toplamın dışına çıkar; açılar yalnız dört ortalama üzerinden girer. Bunlara laminasyon parametreleri denir:

$$ \begin{aligned} \xi_1 &= \frac1h \sum_k t_k \cos 2\theta_k \\[4pt] \xi_2 &= \frac1h \sum_k t_k \sin 2\theta_k \\[4pt] \xi_3 &= \frac1h \sum_k t_k \cos 4\theta_k \\[4pt] \xi_4 &= \frac1h \sum_k t_k \sin 4\theta_k \end{aligned} $$

Bizim laminatta tabakalar eşit kalınlıkta ve simetrik olduğundan $\xi$'ler, dört bağımsız açının kosinüs ve sinüslerinin aritmetik ortalamasıdır. (Kitaplar arasında numaralandırma değişir; bazıları $\xi_2$ ile $\cos 4\theta$ ortalamasını gösterir.) Zar rijitliği bu parametrelerin doğrusal fonksiyonudur:

$$ \begin{aligned} A_{11} &= h\,(U_1 + U_2\,\xi_1 + U_3\,\xi_3) \\ A_{22} &= h\,(U_1 - U_2\,\xi_1 + U_3\,\xi_3) \\ A_{12} &= h\,(U_4 - U_3\,\xi_3) \\ A_{66} &= h\,(U_5 - U_3\,\xi_3) \\ A_{16} &= h\,(\tfrac12 U_2\,\xi_2 + U_3\,\xi_4) \\ A_{26} &= h\,(\tfrac12 U_2\,\xi_2 - U_3\,\xi_4) \end{aligned} $$

Bu küçük formül, makine öğrenmesi açısından dört önemli sonuç taşır:

  • Doğrusallık. $A_{11}$'i $\xi$'lere doğrusal regresyonla uydurursanız $R^2 = 1$ çıkar ve katsayılar değişmezlerin kendisidir. Ham açılarla aynı regresyon neredeyse hiçbir şey öğrenemez. Sayıları 7. bölümde göreceğiz.
  • Sıra bağımsızlığı. Toplam sırayı unutur: $[21/{-21}/54/{-54}]_s$ ile $[54/21/{-54}/{-21}]_s$'nin $A$ matrisi aynıdır. Ham açı vektörü bu simetriyi bilmez; dört açının $4! = 24$ sıralamasının aynı sonucu verdiğini ağ örneklerden öğrenmek zorunda kalır.
  • Periyodiklik. $\theta$ ve $\theta + 180^\circ$ aynı tabakadır. $\cos 2\theta$ ve $\cos 4\theta$ bunu kendiliğinden sağlar.
  • Denge koşulu. Her $+\theta$ tabakasına (0° ve 90° dışında) aynı kalınlıkta bir $-\theta$ tabakasının eşlik ettiği laminatlara dengeli denir. Sinüsler tek fonksiyon olduğu için bunun sonucu $\xi_2 = \xi_4 = 0$'dır. Çekme ile kayma arasında kuplaj olmaması ($A_{16} = A_{26} = 0$) da ancak ve ancak $\xi_2 = \xi_4 = 0$ ise sağlanır. Bu koşulu öğrenmeye gerek yok; ters tasarımda doğrudan $\xi_2$ ve $\xi_4$ üzerinden bir ceza terimi olarak kullanacağız.

Dengeli bir laminatta $a_{66} = 1/A_{66}$ olduğundan kayma modülü de basitleşir: $G_{xy} = A_{66}/h = U_5 - U_3\,\xi_3$. Bu sonucu 8. bölümde kullanacağız. Buna karşılık $E_x$ gibi sabitler $\xi$'de doğrusal değildir, çünkü $A^{-1}$ üzerinden gelirler. Vekil ağın işi tam olarak bu kalan doğrusal olmayan kısmı, yani matris tersini öğrenmektir.

Türetme

Ulaşılabilir bölge: $\xi_3 \ge 2\xi_1^2 - 1$

Her tabaka için $\cos 4\theta = 2\cos^2 2\theta - 1$ özdeşliği geçerlidir. Ortalaması alınınca $\xi_3 = 2\langle\cos^2 2\theta\rangle - 1$ olur ($\langle\cdot\rangle$: tabakalar üzerinden ortalama). Karelerin ortalaması, ortalamanın karesinden küçük olamaz (Jensen eşitsizliği). Buradan:

$$ \xi_3 \ \ge\ 2\,\xi_1^2 - 1 $$

Eşitlik yalnız bütün tabakalarda $\cos 2\theta$ aynıysa, yani laminat $[\pm\theta]$ türündeyse sağlanır. Hiçbir dizilim bu parabolün altına inemez. Rastgele açılarla üretilen laminatlar bu sınıra ve genel olarak $|\xi|$'nin büyük olduğu bölgelere nadiren yaklaşır; bunun bedelini 8. bölümde göreceğiz.

4. Vekil model: aynı ağ, üç girdi gösterimi

Girdiden $[E_x, E_y, G_{xy}, \nu_{xy}]$'yi tahmin eden ağ bütün deneylerde aynı: iki gizli katman, katman başına 64 nöron ve tanh aktivasyonu (Ders 12). Değişen tek şey girdinin nasıl gösterildiğidir:

  1. Ham açılar (4 özellik): $\theta_k/90$.
  2. Tabaka başına cos/sin (16 özellik): her tabaka için $[\cos 2\theta_k, \sin 2\theta_k, \cos 4\theta_k, \sin 4\theta_k]$. Periyodikliği çözer, sıra simetrisini çözmez.
  3. Laminasyon parametreleri (4 özellik): $\xi_1, \dots, \xi_4$. Periyodiklik, sıra bağımsızlığı ve $A$'nın doğrusallığı gösterimin içindedir.

Ham açının sorununu bir örnekle görelim. $-89^\circ$ ve $89^\circ$ tabakaları arasında yalnız $2^\circ$ fark vardır, çünkü $-89^\circ + 180^\circ = 91^\circ$. Oysa ham gösterimde bu iki tabaka girdi aralığının iki ucundadır. Ağ, $\theta = -90^\circ$ ile $\theta = 90^\circ$'de aynı çıktıyı vermesi gerektiğini ancak örneklerden öğrenebilir. Üstelik $\cos 4\theta$ terimi bu aralıkta iki tam salınım yapar; bunu tanh fonksiyonlarının toplamıyla yakalamak çok örnek ister.

Bu, Ders 04'teki özellik mühendisliğinin ileri seviyedeki karşılığıdır. Su/bağlayıcı oranı bir beton dayanımı modelini nasıl kolaylaştırıyorsa, laminasyon parametreleri de bu problemi öyle kolaylaştırır. Fark şu: burada özelliği dönüşüm kurallarından kesin olarak türettik ve $A$ ile ilişkisi tam doğrusal.

Üç gösterim ve vekil ağ (koddan, kısaltılmış)
def gosterim(acilar, tur):
    t = np.radians(acilar)
    if tur == "ham":                       # θ/90 ∈ [−1, 1)
        return acilar / 90.0
    if tur == "trig":                      # tabaka başına cos/sin: 16 özellik
        return np.concatenate([np.cos(2 * t), np.sin(2 * t), np.cos(4 * t), np.sin(4 * t)], axis=-1)
    return lam_param(acilar)               # ξ1..ξ4

ag = nn.Sequential(nn.Linear(d, 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 4))

Eğitim ayrıntıları üç gösterim için de aynı. Girdiler ve çıktılar eğitim verisinin ortalama ve standart sapmasıyla standartlaştırıldı; kayıp, standartlaştırılmış çıktılar üzerinde MSE. Adam'ın öğrenme hızı $3\times10^{-3}$'ten kosinüs planlamasıyla $3\times10^{-5}$'e iniyor ve 256 örneklik mini yığınlarla 1000 adım atılıyor. Öğrenme eğrisi için eğitim kümesini 64'ten 2048'e kadar büyüttük; test kümesi 4000 rastgele laminattan oluşuyor.

Ölçüt olarak normalize RMSE kullanıyoruz: her çıktının test RMSE'si o çıktının test kümesindeki standart sapmasına bölünür ve dört çıktının ortalaması alınır. Bu ölçüt birimsizdir; 1 değeri “her zaman ortalamayı tahmin etmek” kadar kötü demektir. Ters tasarımda kullanacağımız son vekil ise $\xi$ girdili, 2048 örnekle ve 512'lik yığınlarla 5000 adım eğitildi.

5. Ters tasarım: açıları vekil üzerinden aramak

Eğitilmiş vekil türevlenebilir bir fonksiyondur: $\boldsymbol\theta \to \xi(\boldsymbol\theta) \to \text{ağ} \to [\hat E_x, \hat E_y, \hat G_{xy}, \hat\nu_{xy}]$. PyTorch'un otomatik türevi, çıktının açılara göre gradyanını verir. Bu kez ağırlıkları değil, girdiyi, yani açıları güncelliyoruz; ağın ağırlıkları sabit kalır. Hedef rijitlik problemi için en küçüklenecek fonksiyon:

$$ \begin{aligned} L(\boldsymbol\theta) = {} & \Big(\frac{\hat E_x}{70} - 1\Big)^2 + \Big(\frac{\hat E_y}{40} - 1\Big)^2 \\ & + \xi_2^2 + \xi_4^2 \end{aligned} $$

İlk iki terim göreli hatadır, bu yüzden birimden bağımsızdır. Son iki terim denge koşulunun cezasıdır ve vekilden değil, doğrudan $\xi(\boldsymbol\theta)$'dan hesaplanır. Bildiğimiz fiziği öğrenmeye bırakmıyoruz.

Kayıp yüzeyi çok tepeli ve periyodiktir; tek bir başlangıç noktası yerel bir minimumda takılabilir. Bu yüzden 64 rastgele başlangıcı tek bir yığın hâlinde aynı anda çözüyoruz. Kayıpların toplamının gradyanı, her başlangıç için kendi kaybının gradyanıdır, çünkü başlangıçlar birbirine bağlı değildir. Adam her açıyı ayrı ölçeklediği için adım boyu da başlangıçtan başlangıca bağımsızdır.

Çok başlangıçlı ters tasarım (koddan, kısaltılmış)
vekil.ag.requires_grad_(False)                  # ağırlıklar sabit: yalnız açılar güncellenir
aci = torch.tensor(np.random.default_rng(7).uniform(-90, 90, (64, 4)), dtype=torch.float32,
                   requires_grad=True)
opt = torch.optim.Adam([aci], lr=2.0)          # ilk adımlar ≈ 2°, kosinüs planlamasıyla 0,01°'ye iner
for _ in range(800):
    opt.zero_grad()
    xi = lam_param_t(aci)                       # türevlenebilir ξ(θ)
    kayip = amac(vekil(xi), xi)                 # 64 ayrı kayıp
    kayip.sum().backward()                      # her satır kendi gradyanını alır
    opt.step()

İkinci problem kısıtlıdır: $E_x \ge 50$ GPa koşuluyla kayma modülünü en büyük yapmak, yine dengeli bir laminatla. Kısıtı bir ceza terimiyle kayba ekliyoruz:

$$ \begin{aligned} L(\boldsymbol\theta) = {} & -\frac{\hat G_{xy}}{40} \\[4pt] & + 100\,\max\!\Big(0,\ 1 - \frac{\hat E_x}{50}\Big)^2 \\ & + \xi_2^2 + \xi_4^2 \end{aligned} $$

Ceza yöntemi kısıtı yaklaşık sağlar; ceza katsayısı büyüdükçe çözüm sınıra yaklaşır. Her iki problemde de bulunan tasarımı kesin KLT ile yeniden hesaplıyoruz: vekilin söylediğine değil, KLT'nin söylediğine bakıyoruz. Son olarak sonuçları üretim dostu açılarla, $\{0^\circ, \pm45^\circ, 90^\circ\}$ kümesindeki $4^4 = 256$ dizilimin hepsini KLT ile deneyen kapsamlı aramayla karşılaştırıyoruz.

6. Çalıştırılabilir kod

Betik altı bölümden oluşur: KLT ve doğrulamalar, laminasyon parametreleriyle doğrusal regresyon, üç gösterimle öğrenme eğrisi, iki ters tasarım problemi ve grafikler. Yalnız CPU yeter; PyTorch kurulumu için Ders 12'deki adımları izleyin. Betik sıradan bir dizüstü bilgisayarda birkaç dakikada biter.

p5_kompozit_laminat.py455 satır · Pythonİndir
"""Proje 5 — Kompozit laminat için vekil model ve ters tasarım.

Simetrik, 8 tabakalı [θ1/θ2/θ3/θ4]s karbon/epoksi laminatın düzlem içi mühendislik sabitlerini
(Ex, Ey, Gxy, νxy) klasik laminasyon teorisiyle (KLT) hesaplıyor, bu hesaptan üretilen veriyle
bir sinir ağı vekil modeli eğitiyor ve hedef rijitliği veren tabaka açılarını vekil üzerinden
gradyanla arıyoruz. Veri sentetiktir: rastgele açılı laminatların KLT çözümleri. Tabaka özellikleri
ders kitaplarında sık kullanılan T300/5208 değerleridir; bir üreticinin tasarım değeri değildir.

Çalıştır:  python p5_kompozit_laminat.py
Gerekenler: numpy, matplotlib, torch  (Python 3.12+, yalnız CPU yeter)
Süre:      sıradan bir dizüstü bilgisayarda 1–3 dakika
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
import itertools
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
import torch
from torch import nn

# --- Grafik stili (kurs genelinde aynı) ---
RENK = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"]
MUREKKEP, IKINCIL, SOLUK = "#0b0b0b", "#52514e", "#898781"
plt.rcParams.update({
    "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white",
    "axes.edgecolor": "#c3c2b7", "axes.labelcolor": IKINCIL, "axes.titlecolor": MUREKKEP,
    "axes.titlesize": 11, "axes.titleweight": "bold", "axes.labelsize": 10,
    "xtick.color": IKINCIL, "ytick.color": IKINCIL, "font.size": 10,
    "axes.grid": True, "grid.color": "#e1e0d9", "grid.linewidth": 0.6,
    "axes.spines.top": False, "axes.spines.right": False,
    "axes.prop_cycle": plt.cycler(color=RENK), "lines.linewidth": 2, "legend.frameon": False,
})
KLASOR = Path(__file__).resolve().parent

# %% 1. Tabaka rijitliği ve klasik laminasyon teorisi (KLT)
E1, E2, G12, NU12 = 181.0, 10.3, 7.17, 0.28   # GPa; T300/5208 (ders kitabı değerleri)
T_KAT, N_KAT = 0.125, 8                       # tabaka kalınlığı (mm), tabaka sayısı
H = N_KAT * T_KAT                             # laminat kalınlığı: 1 mm

nu21 = NU12 * E2 / E1
payda = 1 - NU12 * nu21
Q11, Q22, Q12, Q66 = E1 / payda, E2 / payda, NU12 * E2 / payda, G12   # indirgenmiş rijitlik
Q = np.array([[Q11, Q12, 0], [Q12, Q22, 0], [0, 0, Q66]])
# Tsai–Pagano değişmezleri: Q̄(θ), cos 2θ, cos 4θ, sin 2θ, sin 4θ'nın doğrusal birleşimidir
U1 = (3 * Q11 + 3 * Q22 + 2 * Q12 + 4 * Q66) / 8
U2 = (Q11 - Q22) / 2
U3 = (Q11 + Q22 - 2 * Q12 - 4 * Q66) / 8
U4 = (Q11 + Q22 + 6 * Q12 - 4 * Q66) / 8
U5 = (Q11 + Q22 - 2 * Q12 + 4 * Q66) / 8


def Qbar_T(teta):
    """Ders kitabı yolu: Q̄ = T⁻¹ Q T⁻ᵀ (T: gerilme dönüşüm matrisi, teta radyan)."""
    c, s = np.cos(teta), np.sin(teta)
    T = np.array([[c * c, s * s, 2 * s * c], [s * s, c * c, -2 * s * c], [-s * c, s * c, c * c - s * s]])
    Ti = np.linalg.inv(T)
    return Ti @ Q @ Ti.T


def Qbar_acik(teta):
    """Açık trigonometrik formüller; teta dizisi → (..., 3, 3)."""
    c, s = np.cos(teta), np.sin(teta)
    q11 = Q11 * c**4 + 2 * (Q12 + 2 * Q66) * s**2 * c**2 + Q22 * s**4
    q22 = Q11 * s**4 + 2 * (Q12 + 2 * Q66) * s**2 * c**2 + Q22 * c**4
    q12 = (Q11 + Q22 - 4 * Q66) * s**2 * c**2 + Q12 * (s**4 + c**4)
    q66 = (Q11 + Q22 - 2 * Q12 - 2 * Q66) * s**2 * c**2 + Q66 * (s**4 + c**4)
    q16 = (Q11 - Q12 - 2 * Q66) * s * c**3 + (Q12 - Q22 + 2 * Q66) * s**3 * c
    q26 = (Q11 - Q12 - 2 * Q66) * s**3 * c + (Q12 - Q22 + 2 * Q66) * s * c**3
    return np.stack([np.stack([q11, q12, q16], -1), np.stack([q12, q22, q26], -1),
                     np.stack([q16, q26, q66], -1)], -2)


def A_matrisi(acilar):
    """[θ1/θ2/θ3/θ4]s için A = Σ Q̄_k t_k (8 tabaka; simetrik olduğu için B = 0). acilar: (n, 4) derece."""
    return 2 * T_KAT * Qbar_acik(np.radians(acilar)).sum(axis=-3)


def lam_param(acilar):
    """Laminasyon parametreleri ξ1..ξ4 = (1/h) Σ t_k [cos 2θ, sin 2θ, cos 4θ, sin 4θ]."""
    t = np.radians(acilar)
    return np.stack([np.cos(2 * t).mean(-1), np.sin(2 * t).mean(-1),
                     np.cos(4 * t).mean(-1), np.sin(4 * t).mean(-1)], -1)


def A_xi(xi):
    """Aynı A, ξ'nin doğrusal fonksiyonu olarak (Tsai–Pagano)."""
    x1, x2, x3, x4 = np.moveaxis(xi, -1, 0)
    A11, A22 = H * (U1 + U2 * x1 + U3 * x3), H * (U1 - U2 * x1 + U3 * x3)
    A12, A66 = H * (U4 - U3 * x3), H * (U5 - U3 * x3)
    A16, A26 = H * (U2 / 2 * x2 + U3 * x4), H * (U2 / 2 * x2 - U3 * x4)
    return np.stack([np.stack([A11, A12, A16], -1), np.stack([A12, A22, A26], -1),
                     np.stack([A16, A26, A66], -1)], -2)


def sabitler(acilar):
    """Düzlem içi mühendislik sabitleri, a = A⁻¹ ile:
    Ex = 1/(h a11), Ey = 1/(h a22), Gxy = 1/(h a66), νxy = −a12/a11."""
    a = np.linalg.inv(A_matrisi(np.atleast_2d(acilar)))
    return np.stack([1 / (H * a[:, 0, 0]), 1 / (H * a[:, 1, 1]), 1 / (H * a[:, 2, 2]),
                     -a[:, 0, 1] / a[:, 0, 0]], -1)


def dizilim(acilar, basamak=0):
    return "[" + "/".join(f"{a:.{basamak}f}" for a in acilar) + "]s"


print("=== 1. Tabaka ve laminat (KLT) ===")
print(f"T300/5208: Q11 = {Q11:.2f}, Q22 = {Q22:.2f}, Q12 = {Q12:.2f}, Q66 = {Q66:.2f} GPa")
print(f"Değişmezler: U1 = {U1:.2f}, U2 = {U2:.2f}, U3 = {U3:.2f}, U4 = {U4:.2f}, U5 = {U5:.2f} GPa")
tetalar = np.radians(np.arange(-90, 91, 7.5))
fark = max(np.abs(Qbar_T(t) - Qbar_acik(t)).max() for t in tetalar)
print(f"Q̄: T⁻¹QT⁻ᵀ ile açık formül arasındaki en büyük fark = {fark:.1e} GPa")
for ad, dz in [("[0]8", [0, 0, 0, 0]), ("[0/±45/90]s", [0, 45, -45, 90])]:
    Ex, Ey, Gxy, nu = sabitler(np.array(dz, float))[0]
    print(f"{ad:12s}: Ex = {Ex:6.2f}, Ey = {Ey:6.2f}, Gxy = {Gxy:5.2f} GPa, νxy = {nu:.3f}")
A_qi = A_matrisi(np.array([[0.0, 45, -45, 90]]))[0]
E_qi = (U1**2 - U4**2) / U1          # yarı-izotrop laminatın bilinen modülü
print(f"Yarı-izotrop kontrol: A11 − A22 = {A_qi[0, 0] - A_qi[1, 1]:.1e}, "
      f"A66 − (A11 − A12)/2 = {A_qi[2, 2] - (A_qi[0, 0] - A_qi[0, 1]) / 2:.1e} GPa·mm, "
      f"(U1² − U4²)/U1 = {E_qi:.2f} GPa")
assert fark < 1e-9
assert np.allclose(sabitler(np.zeros(4))[0], [E1, E2, G12, NU12])
assert np.isclose(sabitler(np.array([0.0, 45, -45, 90]))[0, 0], E_qi)

# %% 2. Laminasyon parametreleri: A, ξ'de doğrusal; açılarda değil
rng = np.random.default_rng(42)
aci_havuz = rng.uniform(-90, 90, (2048, 4))      # eğitim havuzu: düzgün dağılımlı rastgele açılar
aci_test = rng.uniform(-90, 90, (4000, 4))       # test laminatları
Y_havuz, Y_test = sabitler(aci_havuz), sabitler(aci_test)
A_havuz, A_test = A_matrisi(aci_havuz), A_matrisi(aci_test)
assert np.abs(A_xi(lam_param(aci_test)) - A_test).max() < 1e-9   # iki yol aynı A'yı veriyor


def dogrusal_r2(Xe, ye, Xt, yt):
    """En küçük kareler (sabit terimli); test R² ve katsayılar."""
    w, *_ = np.linalg.lstsq(np.column_stack([np.ones(len(Xe)), Xe]), ye, rcond=None)
    tahmin = np.column_stack([np.ones(len(Xt)), Xt]) @ w
    return 1 - np.sum((yt - tahmin)**2) / np.sum((yt - yt.mean())**2), w, tahmin


print("\n=== 2. Laminasyon parametreleri: A, ξ'nin doğrusal fonksiyonu ===")
bilesen = {"A11": (0, 0), "A12": (0, 1), "A66": (2, 2), "A16": (0, 2)}
satir_ham, satir_xi = [], []
for ad, (i, j) in bilesen.items():
    r2_ham, _, _ = dogrusal_r2(aci_havuz, A_havuz[:, i, j], aci_test, A_test[:, i, j])
    r2_xi, w, _ = dogrusal_r2(lam_param(aci_havuz), A_havuz[:, i, j], lam_param(aci_test), A_test[:, i, j])
    satir_ham.append(f"{ad} {r2_ham:.3f}")
    satir_xi.append(f"{ad} {r2_xi:.6f}")
    if ad == "A11":
        w_A11 = w / H
r2_A11_ham, _, A11_ham_tahmin = dogrusal_r2(aci_havuz, A_havuz[:, 0, 0], aci_test, A_test[:, 0, 0])
r2_A11_xi, _, A11_xi_tahmin = dogrusal_r2(lam_param(aci_havuz), A_havuz[:, 0, 0],
                                          lam_param(aci_test), A_test[:, 0, 0])
print("Doğrusal regresyon test R² — ham açılarla: " + ", ".join(satir_ham))
print("Doğrusal regresyon test R² — ξ ile      : " + ", ".join(satir_xi))
print("A11/h katsayıları [sabit, ξ1, ξ2, ξ3, ξ4] = [" + ", ".join(f"{v:.2f}" for v in w_A11)
      + f"]  (U1, U2, U3 = {U1:.2f}, {U2:.2f}, {U3:.2f})")
r2_Ex_xi, _, _ = dogrusal_r2(lam_param(aci_havuz), Y_havuz[:, 0], lam_param(aci_test), Y_test[:, 0])
print(f"Ex için doğrusal regresyon (ξ ile) test R² = {r2_Ex_xi:.3f}  (Ex, A⁻¹ üzerinden doğrusal değil)")
assert np.allclose(w_A11, [U1, U2, 0, U3, 0], atol=1e-8)


# %% 3. Vekil model: aynı ağ, üç girdi gösterimi
def gosterim(acilar, tur):
    t = np.radians(acilar)
    if tur == "ham":                       # açılar doğrudan (θ/90 ∈ [−1, 1))
        return acilar / 90.0
    if tur == "trig":                      # tabaka başına [cos 2θk, sin 2θk, cos 4θk, sin 4θk]: 16 özellik
        return np.concatenate([np.cos(2 * t), np.sin(2 * t), np.cos(4 * t), np.sin(4 * t)], axis=-1)
    return lam_param(acilar)               # "xi": 4 laminasyon parametresi


class Vekil:
    """Standartlaştırma + 2 gizli katmanlı (64 nöron, tanh) MLP; çıktı [Ex, Ey, Gxy, νxy]."""

    def __init__(self, X, Y):
        self.xm, self.xs = X.mean(0), X.std(0)
        self.ym, self.ys = Y.mean(0), Y.std(0)
        torch.manual_seed(42)
        self.ag = nn.Sequential(nn.Linear(X.shape[1], 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(),
                                nn.Linear(64, 4))
        self.t = {k: torch.tensor(v, dtype=torch.float32)
                  for k, v in dict(xm=self.xm, xs=self.xs, ym=self.ym, ys=self.ys).items()}

    def egit(self, X, Y, adim, ogrenme_hizi=3e-3, yigin=256):
        Xt = torch.tensor((X - self.xm) / self.xs, dtype=torch.float32)
        Yt = torch.tensor((Y - self.ym) / self.ys, dtype=torch.float32)
        opt = torch.optim.Adam(self.ag.parameters(), lr=ogrenme_hizi)
        plan = torch.optim.lr_scheduler.CosineAnnealingLR(opt, adim, eta_min=ogrenme_hizi / 100)
        uretec = torch.Generator().manual_seed(42)
        for _ in range(adim):
            idx = torch.randint(0, len(Xt), (min(yigin, len(Xt)),), generator=uretec)
            opt.zero_grad()
            kayip = ((self.ag(Xt[idx]) - Yt[idx])**2).mean()   # standartlaştırılmış MSE
            kayip.backward()
            opt.step()
            plan.step()
        return self

    def __call__(self, X_t):              # torch girdisi → fiziksel birimde çıktı (türevlenebilir)
        return self.ag((X_t - self.t["xm"]) / self.t["xs"]) * self.t["ys"] + self.t["ym"]

    def tahmin(self, X):
        with torch.no_grad():
            return self(torch.tensor(X, dtype=torch.float32)).numpy().astype(float)


def nrmse(P, Y):
    """Normalize RMSE: her çıktı için RMSE / test standart sapması, dört çıktının ortalaması."""
    return float(np.mean(np.sqrt(np.mean((P - Y)**2, 0)) / Y.std(0)))


print("\n=== 3. Vekil model: öğrenme eğrisi (test: 4000 laminat, normalize RMSE) ===")
BOYUTLAR = [64, 128, 256, 512, 1024, 2048]
TURLER = {"ham": "ham açı", "trig": "cos/sin (16)", "xi": "ξ (4)"}
egri = {tur: [] for tur in TURLER}
parite, egitim_hatasi = {}, {}
for N in BOYUTLAR:
    for tur in TURLER:
        X = gosterim(aci_havuz[:N], tur)
        model = Vekil(X, Y_havuz[:N]).egit(X, Y_havuz[:N], adim=1000)
        P = model.tahmin(gosterim(aci_test, tur))
        egri[tur].append(nrmse(P, Y_test))
        if N == 256:
            parite[tur] = P[:, 0]
        if N == BOYUTLAR[-1]:                       # az uyum mu, aşırı uyum mu? eğitim hatasına bak
            egitim_hatasi[tur] = nrmse(model.tahmin(X), Y_havuz[:N])
print("    N   " + "  ".join(f"{ad:>12s}" for ad in TURLER.values()))
for k, N in enumerate(BOYUTLAR):
    print(f"{N:5d}   " + "  ".join(f"{egri[tur][k]:12.3f}" for tur in TURLER))
print("eğitim  " + "  ".join(f"{egitim_hatasi[tur]:12.3f}" for tur in TURLER)
      + "   (N = 2048, eğitim verisinde)")

# Ters tasarımda kullanılacak vekil: ξ girdili, 2048 örnek, daha uzun eğitim
X_xi = lam_param(aci_havuz)
vekil = Vekil(X_xi, Y_havuz).egit(X_xi, Y_havuz, adim=5000, yigin=512)
P = vekil.tahmin(lam_param(aci_test))
goreli = np.abs(P[:, :3] / Y_test[:, :3] - 1).mean(0) * 100
nu_rmse = np.sqrt(np.mean((P[:, 3] - Y_test[:, 3])**2))
print(f"Son vekil (ξ, N = 2048, 5000 adım): göreli hata Ex {goreli[0]:.2f} %, Ey {goreli[1]:.2f} %, "
      f"Gxy {goreli[2]:.2f} %; νxy RMSE {nu_rmse:.4f}")
assert all(np.isfinite(v).all() for v in egri.values())
assert egri["xi"][-1] < egri["trig"][-1] < egri["ham"][-1]


# %% 4. Ters tasarım: açıları vekil üzerinden gradyanla aramak
def lam_param_t(aci):
    """lam_param'ın PyTorch karşılığı (açıya göre türevlenebilir)."""
    t = torch.deg2rad(aci)
    return torch.stack([torch.cos(2 * t).mean(-1), torch.sin(2 * t).mean(-1),
                        torch.cos(4 * t).mean(-1), torch.sin(4 * t).mean(-1)], -1)


def ters_tasarim(vekil, amac, n_baslangic=64, adim=800, tohum=7):
    """Çok başlangıçlı gradyan inişi: her satır ayrı bir laminat; kayıplar toplanınca gradyanlar ayrışır."""
    vekil.ag.requires_grad_(False)                             # ağırlıklar sabit: yalnız açılar güncellenir
    aci = torch.tensor(np.random.default_rng(tohum).uniform(-90, 90, (n_baslangic, 4)),
                       dtype=torch.float32, requires_grad=True)
    opt = torch.optim.Adam([aci], lr=2.0)                      # adım ≈ 2°, sonra küçülür
    plan = torch.optim.lr_scheduler.CosineAnnealingLR(opt, adim, eta_min=0.01)
    for _ in range(adim):
        opt.zero_grad()
        xi = lam_param_t(aci)
        kayip = amac(vekil(xi), xi)
        kayip.sum().backward()
        opt.step()
        plan.step()
    with torch.no_grad():
        xi = lam_param_t(aci)
        kayip = amac(vekil(xi), xi).numpy()
    vekil.ag.requires_grad_(True)
    aci = aci.detach().numpy().astype(float)
    return (aci + 90) % 180 - 90, kayip                      # açıyı [−90°, 90°) aralığına sar


def dengesizlik(xi):
    """Dengeli laminat (A16 = A26 = 0) ⇔ ξ2 = ξ4 = 0: fizikten bilinen kısıt, öğrenilmiyor."""
    return xi[:, 1]**2 + xi[:, 3]**2


HEDEF = np.array([70.0, 40.0])     # Ex, Ey (GPa)


def amac_hedef(P, xi):
    return (P[:, 0] / HEDEF[0] - 1)**2 + (P[:, 1] / HEDEF[1] - 1)**2 + dengesizlik(xi)


print("\n=== 4. Ters tasarım 1: Ex = 70, Ey = 40 GPa, dengeli laminat ===")
aci1, kayip1 = ters_tasarim(vekil, amac_hedef)
yakinsadi = kayip1 < 1e-4
kume = {tuple(np.sort(np.round(a).astype(int))) for a in aci1[yakinsadi]}      # sırasız açı kümesi
sirali = {tuple(np.round(a).astype(int)) for a in aci1[yakinsadi]}             # dizilim sırası önemli
klt1 = sabitler(aci1[yakinsadi])
hata1 = np.abs(klt1[:, :2] / HEDEF - 1).max(1) * 100
A1 = A_matrisi(aci1[yakinsadi])
kalan = (f"; kalanlar {kayip1[~yakinsadi].min():.1e}–{kayip1[~yakinsadi].max():.1e}"
         if (~yakinsadi).any() else "")
kume_yazi = " | ".join("{" + ", ".join(map(str, k)) + "}" for k in sorted(kume))
print(f"{yakinsadi.sum()}/64 yakınsadı (kayıp < 1e-4{kalan}); açı kümesi: {len(kume)} → "
      f"{kume_yazi}; dizilim: {len(sirali)}")
i = int(np.argmin(kayip1))
p1, k1 = vekil.tahmin(lam_param(aci1[i:i + 1]))[0], sabitler(aci1[i])[0]
d1 = np.linalg.norm(X_xi - lam_param(aci1[i]), axis=1).min()       # ξ uzayında en yakın eğitim örneği
print(f"Örnek çözüm {dizilim(aci1[i], 1)}: vekil Ex = {p1[0]:.2f}, Ey = {p1[1]:.2f} GPa; "
      f"en yakın eğitim örneği {d1:.3f} (ξ)")
print(f"   KLT doğrulaması: Ex = {k1[0]:.2f}, Ey = {k1[1]:.2f}, Gxy = {k1[2]:.2f} GPa, νxy = {k1[3]:.3f}")
k1y = sabitler(np.round(aci1[i]))[0]                               # üretimde açı tam dereceye yuvarlanır
print(f"   Açılar tam dereceye yuvarlanınca {dizilim(np.round(aci1[i]))}: "
      f"KLT Ex = {k1y[0]:.2f}, Ey = {k1y[1]:.2f} GPa")
print(f"Tüm çözümler (KLT): hata ≤ {hata1.max():.2f} %; "
      f"Gxy {klt1[:, 2].min():.2f}–{klt1[:, 2].max():.2f} GPa; "
      f"νxy {klt1[:, 3].min():.3f}–{klt1[:, 3].max():.3f}; |A16| ≤ {np.abs(A1[:, 0, 2]).max():.3f} GPa·mm")

# Kapsamlı arama: üretim dostu açılar {0, ±45, 90}, 4^4 = 256 dizilim, kesin KLT
ayrik = np.array(list(itertools.product([0, 45, -45, 90], repeat=4)), float)
klt_ayrik = sabitler(ayrik)
dengeli = np.abs(lam_param(ayrik)[:, [1, 3]]).max(1) < 1e-12
hata_ayrik = np.abs(klt_ayrik[:, :2] / HEDEF - 1).max(1) * 100
n_A = len(np.unique(np.round(A_matrisi(ayrik).reshape(len(ayrik), -1), 6), axis=0))   # sıra önemsiz
n_farkli = len(np.unique(np.round(klt_ayrik, 6), axis=0))      # +45 ↔ −45: yalnız A16, A26 işaret değiştirir
print(f"Ayrık arama: 256 dizilim → {n_A} farklı A, {n_farkli} farklı (Ex, Ey, Gxy, νxy); "
      f"{dengeli.sum()} dengeli dizilim")
for ad, maske in [("dengeli", dengeli), ("dengesiz serbest", np.ones_like(dengeli))]:
    j = np.where(maske)[0][np.argmin(hata_ayrik[maske])]
    print(f"   en iyi ({ad}): {dizilim(ayrik[j])} → Ex = {klt_ayrik[j, 0]:.2f}, "
          f"Ey = {klt_ayrik[j, 1]:.2f} GPa, hata {hata_ayrik[j]:.1f} %")
assert hata1.max() < 3

# %% 5. Ters tasarım 2: Ex ≥ 50 GPa koşuluyla en büyük Gxy
EX_MIN = 50.0


def amac_kayma(P, xi):
    return -P[:, 2] / 40 + 100 * torch.relu(1 - P[:, 0] / EX_MIN)**2 + dengesizlik(xi)


def en_iyi(aci, kayip):
    i = int(np.argmin(kayip))
    return aci[i], vekil.tahmin(lam_param(aci[i:i + 1]))[0], sabitler(aci[i])[0]


print("\n=== 5. Ters tasarım 2: en büyük Gxy, Ex ≥ 50 GPa, dengeli ===")
aci2, kayip2 = ters_tasarim(vekil, amac_kayma)
a2, p2, k2 = en_iyi(aci2, kayip2)
print(f"Vekil optimumu {dizilim(a2)}: vekil Ex {p2[0]:.2f}, Gxy {p2[2]:.2f} | "
      f"KLT Ex {k2[0]:.2f}, Gxy {k2[2]:.2f} GPa")
d2 = np.linalg.norm(X_xi - lam_param(a2), axis=1).min()
print(f"Eğitim verisi burada seyrek: ξ3 ≤ −0.7 olan {np.sum(X_xi[:, 2] <= -0.7)}/{len(X_xi)} laminat; "
      f"en yakın eğitim örneği {d2:.3f} (ξ)")

# İyileştirme turu: bulunan tasarımların çevresinde KLT ile yeni örnek üret, vekili yeniden eğit
yeni = np.concatenate([aci2] + [aci2 + rng.normal(0, 3, aci2.shape) for _ in range(3)])
X_ek = np.concatenate([X_xi, lam_param(yeni)])
Y_ek = np.concatenate([Y_havuz, sabitler(yeni)])
vekil.egit(X_ek, Y_ek, adim=1500, ogrenme_hizi=1e-3, yigin=512)   # mevcut ağırlıklardan devam
aci3, kayip3 = ters_tasarim(vekil, amac_kayma)
a3, p3, k3 = en_iyi(aci3, kayip3)
print(f"+{len(yeni)} KLT örneğiyle yeniden eğitim → {dizilim(a3)}: vekil Ex {p3[0]:.2f}, Gxy {p3[2]:.2f} | "
      f"KLT Ex {k3[0]:.2f}, Gxy {k3[2]:.2f} GPa")
xi_3, A_3 = lam_param(a3), A_matrisi(a3[None])[0]
print(f"   ξ1 = {xi_3[0]:.3f}, ξ3 = {xi_3[2]:.3f}, A12/A22 = {A_3[0, 1] / A_3[1, 1]:.3f}; "
      f"parabol 2ξ1² − 1 = {2 * xi_3[0]**2 - 1:.3f} → optimum iç noktada")
# Karşılaştırma: ulaşılabilir bölgenin sınırındaki [±θ]2s laminatı (ξ3 = 2ξ1² − 1); Ex, θ ile azalır
alt, ust = 20.0, 45.0
for _ in range(50):                                            # ikiye bölme: Ex(θ) = 50 GPa
    orta = (alt + ust) / 2
    if sabitler(np.array([orta, -orta, orta, -orta]))[0, 0] > EX_MIN:
        alt = orta
    else:
        ust = orta
k_sinir = sabitler(np.array([alt, -alt, alt, -alt]))[0]
print(f"Sınırdaki [±{alt:.1f}]2s laminatı (ξ3 = 2ξ1² − 1): Ex = {k_sinir[0]:.2f}, Gxy = {k_sinir[2]:.2f} GPa")
print(f"KLT ile kısıt payı Ex − 50: önce {k2[0] - EX_MIN:+.3f}, sonra {k3[0] - EX_MIN:+.3f} GPa")
uygun = dengeli & (klt_ayrik[:, 0] >= EX_MIN)
j = np.where(uygun)[0][np.argmax(klt_ayrik[uygun, 2])]
print(f"Ayrık {{0, ±45, 90}} en iyi (dengeli): {dizilim(ayrik[j])} → Ex = {klt_ayrik[j, 0]:.2f}, "
      f"Gxy = {klt_ayrik[j, 2]:.2f} GPa (= U5, çünkü ξ3 = {lam_param(ayrik[j])[2]:.0f})")
assert np.isfinite([p2, k2, p3, k3]).all()

# %% 6. Grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
t_deg = np.linspace(-180, 180, 721)
Qb = Qbar_acik(np.radians(t_deg))
ax[0].axvspan(-90, 90, color="#f1f0ea", zorder=0)
for k, (ad, (i, j)) in enumerate([("$\\bar Q_{11}$", (0, 0)), ("$\\bar Q_{22}$", (1, 1)),
                                  ("$\\bar Q_{66}$", (2, 2)), ("$\\bar Q_{16}$", (0, 2))]):
    ax[0].plot(t_deg, Qb[:, i, j], color=RENK[k], label=ad)
ax[0].set(xlabel="Tabaka açısı θ (°)", ylabel="Rijitlik (GPa)", title="Q̄(θ): 180° periyotlu",
          xticks=np.arange(-180, 181, 45), ylim=(-65, 250))
ax[0].text(0, 196, "örnekleme aralığı [−90°, 90°)", ha="center", fontsize=8.5, color=IKINCIL)
ax[0].legend(loc="upper center", ncols=4, fontsize=9.5, handlelength=1.5, columnspacing=1.2)
g = slice(0, 1500)                                   # grafikte ilk 1500 test laminatı yeter
ax[1].scatter(A_test[g, 0, 0], A11_ham_tahmin[g], s=6, color=RENK[1], alpha=.35, linewidths=0,
              label=f"Ham açılarla: R² = {r2_A11_ham:.3f}")
ax[1].scatter(A_test[g, 0, 0], A11_xi_tahmin[g], s=6, color=RENK[0], alpha=.5, linewidths=0,
              label=f"ξ ile: R² = {r2_A11_xi:.6f}")
lim = [A_test[:, 0, 0].min(), A_test[:, 0, 0].max()]
ax[1].plot(lim, lim, color=MUREKKEP, ls="--", lw=1.2, label="Kesin (KLT)")
ax[1].set(xlabel="KLT ile A11 (GPa·mm)", ylabel="Doğrusal regresyon tahmini (GPa·mm)",
          title="A11 için doğrusal model: gösterim farkı")
ax[1].legend(loc="upper left", markerscale=2.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for k, (tur, ad) in enumerate([("ham", "Ham açılar (4)"), ("trig", "Tabaka başına cos/sin (16)"),
                               ("xi", "Laminasyon parametreleri ξ (4)")]):
    ax[0].loglog(BOYUTLAR, egri[tur], "-o", ms=5, color=RENK[[1, 2, 0][k]], label=ad)
ax[0].set(xlabel="Eğitim örneği sayısı N", ylabel="Test normalize RMSE (4 çıktı ort.)",
          title="Öğrenme eğrisi: aynı ağ, farklı gösterim")
ax[0].set_xticks(BOYUTLAR, [str(n) for n in BOYUTLAR])
ax[0].legend(loc="upper right")
ax[1].scatter(Y_test[g, 0], parite["ham"][g], s=5, color=RENK[1], alpha=.35, linewidths=0,
              label="Ham açılar, N = 256")
ax[1].scatter(Y_test[g, 0], parite["xi"][g], s=5, color=RENK[0], alpha=.5, linewidths=0, label="ξ, N = 256")
ax[1].plot([10, 181], [10, 181], color=MUREKKEP, ls="--", lw=1.2, label="Kesin (KLT)")
ax[1].set(xlabel="KLT ile Ex (GPa)", ylabel="Vekil tahmini Ex (GPa)", title="Ex: test laminatları, N = 256")
ax[1].legend(loc="upper left", markerscale=2.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 5.0), layout="constrained")
ax[0].scatter(Y_test[:2000, 0], Y_test[:2000, 1], s=4, color=SOLUK, alpha=.3, linewidths=0,
              label="Rastgele laminatlar (KLT)")
ax[0].scatter(klt_ayrik[~dengeli, 0], klt_ayrik[~dengeli, 1], s=36, marker="s", facecolors="white",
              edgecolors=RENK[1], label="{0, ±45, 90}, dengesiz")
ax[0].scatter(klt_ayrik[dengeli, 0], klt_ayrik[dengeli, 1], s=36, marker="s", color=RENK[1],
              label="{0, ±45, 90}, dengeli")
ax[0].axvline(HEDEF[0], color=MUREKKEP, ls="--", lw=1)
ax[0].axhline(HEDEF[1], color=MUREKKEP, ls="--", lw=1, label="Hedef: Ex = 70, Ey = 40 GPa")
ax[0].scatter(klt1[:, 0], klt1[:, 1], s=40, color=RENK[0], edgecolors="white", linewidths=1, zorder=5,
              label="Vekil + gradyan (KLT ile)")
ax[0].set(xlabel="Ex (GPa)", ylabel="Ey (GPa)", title="Hedef rijitlik: sürekli ve ayrık açılar")
ax[0].legend(loc="upper center", bbox_to_anchor=(0.5, -0.16), ncols=2, fontsize=8.5)
alfa, beta = rng.uniform(0, 90, (2, 1500))
den_ornek = sabitler(np.column_stack([alfa, -alfa, beta, -beta]))
yakin = ax[1].inset_axes([0.64, 0.56, 0.34, 0.40])               # optimum çevresine yakından bakış
for a in (ax[1], yakin):
    a.scatter(den_ornek[:, 0], den_ornek[:, 2], s=4, color=SOLUK, alpha=.3, linewidths=0,
              label="Dengeli [±α/±β]s (KLT)")
    a.axvline(EX_MIN, color=MUREKKEP, ls=":", lw=1.2, label="Kısıt: Ex = 50 GPa")
    a.scatter(klt_ayrik[dengeli, 0], klt_ayrik[dengeli, 2], s=36, marker="s", color=RENK[1],
              label="{0, ±45, 90}, dengeli")
    a.plot(k2[0], k2[2], marker="^", ms=9, color=RENK[2], ls="none", label="İlk vekil optimumu (KLT)")
    a.plot(k3[0], k3[2], marker="o", ms=8, color=RENK[0], ls="none", label="İyileştirme sonrası (KLT)")
yakin.set(xlim=(46, 54), ylim=(39.5, 42.5))
yakin.tick_params(labelsize=8)
ax[1].set(xlabel="Ex (GPa)", ylabel="Gxy (GPa)", title="Ex ≥ 50 GPa iken en büyük Gxy")
ax[1].legend(loc="upper center", bbox_to_anchor=(0.5, -0.16), ncols=2, fontsize=8.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: p5_kompozit_laminat_1.png, _2.png, _3.png")

Terminal çıktısıpython p5_kompozit_laminat.py
=== 1. Tabaka ve laminat (KLT) ===
T300/5208: Q11 = 181.81, Q22 = 10.35, Q12 = 2.90, Q66 = 7.17 GPa
Değişmezler: U1 = 76.37, U2 = 85.73, U3 = 19.71, U4 = 22.61, U5 = 26.88 GPa
Q̄: T⁻¹QT⁻ᵀ ile açık formül arasındaki en büyük fark = 8.5e-14 GPa
[0]8        : Ex = 181.00, Ey =  10.30, Gxy =  7.17 GPa, νxy = 0.280
[0/±45/90]s : Ex =  69.68, Ey =  69.68, Gxy = 26.88 GPa, νxy = 0.296
Yarı-izotrop kontrol: A11 − A22 = 1.4e-14, A66 − (A11 − A12)/2 = 0.0e+00 GPa·mm, (U1² − U4²)/U1 = 69.68 GPa

=== 2. Laminasyon parametreleri: A, ξ'nin doğrusal fonksiyonu ===
Doğrusal regresyon test R² — ham açılarla: A11 0.000, A12 -0.004, A66 -0.004, A16 0.283
Doğrusal regresyon test R² — ξ ile      : A11 1.000000, A12 1.000000, A66 1.000000, A16 1.000000
A11/h katsayıları [sabit, ξ1, ξ2, ξ3, ξ4] = [76.37, 85.73, 0.00, 19.71, -0.00]  (U1, U2, U3 = 76.37, 85.73, 19.71)
Ex için doğrusal regresyon (ξ ile) test R² = 0.874  (Ex, A⁻¹ üzerinden doğrusal değil)

=== 3. Vekil model: öğrenme eğrisi (test: 4000 laminat, normalize RMSE) ===
    N        ham açı  cos/sin (16)         ξ (4)
   64          0.892         0.570         0.213
  128          0.650         0.432         0.129
  256          0.555         0.265         0.102
  512          0.436         0.174         0.082
 1024          0.393         0.120         0.077
 2048          0.397         0.101         0.068
eğitim         0.379         0.084         0.063   (N = 2048, eğitim verisinde)
Son vekil (ξ, N = 2048, 5000 adım): göreli hata Ex 0.76 %, Ey 0.89 %, Gxy 0.67 %; νxy RMSE 0.0060

=== 4. Ters tasarım 1: Ex = 70, Ey = 40 GPa, dengeli laminat ===
54/64 yakınsadı (kayıp < 1e-4; kalanlar 1.2e-04–2.5e-01); açı kümesi: 1 → {-54, -21, 21, 54}; dizilim: 24
Örnek çözüm [21.3/-21.3/53.6/-53.6]s: vekil Ex = 70.00, Ey = 40.00 GPa; en yakın eğitim örneği 0.056 (ξ)
   KLT doğrulaması: Ex = 70.00, Ey = 39.90, Gxy = 34.24 GPa, νxy = 0.598
   Açılar tam dereceye yuvarlanınca [21/-21/54/-54]s: KLT Ex = 70.85, Ey = 40.90 GPa
Tüm çözümler (KLT): hata ≤ 0.25 %; Gxy 34.24–34.24 GPa; νxy 0.598–0.598; |A16| ≤ 0.001 GPa·mm
Ayrık arama: 256 dizilim → 35 farklı A, 22 farklı (Ex, Ey, Gxy, νxy); 70 dengeli dizilim
   en iyi (dengeli): [0/45/0/-45]s → Ex = 103.98, Ey = 29.22 GPa, hata 48.5 %
   en iyi (dengesiz serbest): [45/45/0/-45]s → Ex = 64.31, Ey = 31.81 GPa, hata 20.5 %

=== 5. Ters tasarım 2: en büyük Gxy, Ex ≥ 50 GPa, dengeli ===
Vekil optimumu [43/29/-31/-42]s: vekil Ex 49.92, Gxy 41.05 | KLT Ex 49.20, Gxy 41.45 GPa
Eğitim verisi burada seyrek: ξ3 ≤ −0.7 olan 57/2048 laminat; en yakın eğitim örneği 0.169 (ξ)
+256 KLT örneğiyle yeniden eğitim → [-42/-30/29/43]s: vekil Ex 49.92, Gxy 41.23 | KLT Ex 49.97, Gxy 41.27 GPa
   ξ1 = 0.297, ξ3 = -0.730, A12/A22 = 1.013; parabol 2ξ1² − 1 = -0.823 → optimum iç noktada
Sınırdaki [±33.8]2s laminatı (ξ3 = 2ξ1² − 1): Ex = 50.00, Gxy = 40.86 GPa
KLT ile kısıt payı Ex − 50: önce -0.795, sonra -0.030 GPa
Ayrık {0, ±45, 90} en iyi (dengeli): [0/0/45/-45]s → Ex = 103.98, Gxy = 26.88 GPa (= U5, çünkü ξ3 = 0)

Grafikler kaydedildi: p5_kompozit_laminat_1.png, _2.png, _3.png

PyTorch eğitimlerinde son basamaklar işlemciye, iş parçacığı sayısına ve kitaplık sürümüne göre biraz farklı çıkabilir; eğilimler ve sonuçlar aynı kalır.

7. Sonuçlar: gösterim her şeyi değiştiriyor

Solda dönüşmüş tabaka rijitliği bileşenlerinin −180 ile 180 derece arasındaki eğrileri, her biri 180 derece periyotla tekrar ediyor; sağda A11 için doğrusal regresyon tahminleri: ham açılarla tahminler ortalamada yatay bir bant, laminasyon parametreleriyle tahminler tam olarak köşegen üzerinde
Sol: $\bar Q_{11}$, $\bar Q_{22}$, $\bar Q_{66}$ ve $\bar Q_{16}$ açıyla 180° periyotlu değişiyor; gri bant veri ürettiğimiz $[-90^\circ, 90^\circ)$ aralığı. Sağ: $A_{11}$'e uydurulan doğrusal regresyon. Ham açılarla $R^2$ = 0,000, $\xi$ ile $R^2$ = 1,000000.

Sağdaki grafik bu projenin özeti gibi. Ham açılarla kurulan doğrusal model $A_{11}$'i hiç açıklayamıyor: tahminler ortalama çevresinde yatay bir bant. Nedeni basit: $A_{11}$, $\cos 2\theta$ ve $\cos 4\theta$ ile değişir. İkisi de $\theta = 0$ çevresinde simetrik (çift) fonksiyondur ve simetrik bir aralıkta açıyla doğrusal korelasyonları sıfırdır. Aynı nedenle $A_{12}$ ve $A_{66}$ için de $R^2$ sıfır çıkıyor (−0,004). $A_{16}$ ise $\sin 2\theta$ ve $\sin 4\theta$ içerdiği, yani tek fonksiyon olduğu için ham açılarla kısmen açıklanabiliyor ($R^2$ = 0,283).

$\xi$ ile kurulan model dört bileşenin hepsinde $R^2$ = 1,000000 veriyor. Öğrenilen katsayılar da rastgele sayılar değil: $A_{11}/h$ için [sabit, $\xi_1$, $\xi_2$, $\xi_3$, $\xi_4$] katsayıları [76,37; 85,73; 0,00; 19,71; −0,00] çıkıyor. Bunlar $[U_1, U_2, 0, U_3, 0]$'ın ta kendisi. Doğru gösterimle doğrusal regresyon fiziği yeniden keşfediyor. Mühendislik sabitleri ise $\xi$'de doğrusal değil: $E_x$'e aynı doğrusal modeli uydurmak test $R^2$ = 0,874 veriyor.

Solda logaritmik eksenlerde üç öğrenme eğrisi: ham açılar en üstte ve 1024 örnekten sonra yatay, tabaka başına cos/sin ortada, laminasyon parametreleri en altta; sağda 256 örnekle eğitilmiş iki vekilin Ex tahminleri: ham açılarla geniş saçılma, laminasyon parametreleriyle köşegene yakın dar bir bant
Sol: aynı ağ ve aynı eğitim bütçesiyle üç gösterimin öğrenme eğrisi (test kümesi 4000 laminat). Sağ: 256 eğitim örneğiyle $E_x$ tahminleri; kesikli çizgi kesin KLT.
Öğrenme eğrisi: test normalize RMSE (dört çıktının ortalaması)
Eğitim örneği NHam açılar (4)Tabaka başına cos/sin (16)$\xi$ (4)
640,8920,5700,213
1280,6500,4320,129
2560,5550,2650,102
5120,4360,1740,082
10240,3930,1200,077
20480,3970,1010,068

Üç gözlem öne çıkıyor:

  • Veri verimliliği. $\xi$ gösterimi 64 örnekle (0,213), ham açıların 2048 örnekle ulaştığı hatanın (0,397) yaklaşık yarısına iniyor. Tabaka başına cos/sin'in 2048 örnekle ulaştığı düzeye (0,101) $\xi$ 256 örnekle, yani sekiz kat az veriyle neredeyse ulaşıyor (0,102).
  • Ham açıların tavanı. Ham açılarla eğri 1024 örnekten sonra düzleşiyor (0,393 → 0,397). 2048 örnekte eğitim hatası 0,379, test hatası 0,397: model eğitim verisini bile uyduramıyor, yani az uyum (underfitting) var. Bunun ana nedeni 1000 adımlık eğitim bütçesi. Ayrı bir denemede aynı ağı aynı 2048 örnekle daha uzun eğittik: test/eğitim hatası 5000 adımda 0,231/0,189, 20.000 adımda 0,159/0,095 oldu. Ham açılarla da öğrenilebiliyor, ama çok daha uzun eğitimle; $\xi$ gösterimi ise 128 örnek ve 1000 adımla bile (0,129) 20.000 adımlık ham açı modelinden daha iyi. Az uyumun çaresi ya çok daha uzun eğitim ya da daha iyi bir gösterimdir.
  • Eğitim bütçesi. 2048 örnekte üç gösterimde de eğitim ve test hataları birbirine yakın (cos/sin için 0,084 ve 0,101, $\xi$ için 0,063 ve 0,068). Yani 1000 adımlık bütçe de sınırlayıcı. Ters tasarım vekilini daha uzun eğittik: ortalama göreli hata $E_x$ için %0,76, $E_y$ için %0,89, $G_{xy}$ için %0,67 ve $\nu_{xy}$'nin RMSE'si 0,0060.

Sağdaki grafik aynı farkı tek bir çıktı için gösteriyor. 256 örnekle eğitilen ham açı modelinin $E_x$ tahminleri kesin değerin çevresinde onlarca GPa saçılıyor; $\xi$ modelininki dar bir bant.

8. Sonuçlar: ters tasarım ve doğrulama

Hedef rijitlik: $E_x$ = 70 GPa, $E_y$ = 40 GPa

64 başlangıçtan 54'ü vekil kaybını $10^{-4}$'ün altına indirdi. Kalanların kaybı 1,2×10⁻⁴ ile 0,25 arasında kaldı: bir kısmı adım bütçesi bitmeden hedefe çok yaklaşmıştı, bir kısmı ise yerel bir minimumda takıldı (Alıştırma 4'te bu minimumun ne olduğunu göreceksiniz). Çok başlangıçlı aramanın nedeni budur.

Yakınsayan 54 çözümün hepsi aynı açı kümesine çıktı: tam dereceye yuvarlanınca $\{\pm21^\circ, \pm54^\circ\}$. Örnek çözüm [21,3/−21,3/53,6/−53,6]s için vekil $E_x$ = 70,00 ve $E_y$ = 40,00 GPa diyor. Kesin KLT ise $E_x$ = 70,00, $E_y$ = 39,90 GPa, $G_{xy}$ = 34,24 GPa ve $\nu_{xy}$ = 0,598 veriyor. Bütün çözümlerde en büyük göreli hata %0,25 ve en büyük $|A_{16}|$ = 0,001 GPa·mm; laminatlar gerçekten dengeli.

Bu kadar iyi uyumun bir nedeni var: çözüm, eğitim verisinin yoğun olduğu bir bölgede. $\xi$ uzayında en yakın eğitim örneği yalnız 0,056 uzakta. Bunu ikinci problemle karşılaştıracağız.

Dikkat

Açı toleransı

Açıları tam dereceye yuvarlayıp $[21/{-21}/54/{-54}]_s$ laminatını KLT ile yeniden hesaplayınca $E_x$ = 70,85 ve $E_y$ = 40,90 GPa çıkıyor. Yarım dereceden küçük yuvarlamalar (21,3° → 21°, 53,6° → 54°), $E_y$'yi yaklaşık %2,5 değiştiriyor; bu, %0,25'lik vekil hatasının on katı. Üretimdeki açı toleransları bu mertebededir; bir tasarımın açı hatalarına duyarlılığını ayrıca kontrol edin.

Çözüm neden tek değil? Üç ayrı düzeyde çokluk var:

  • Sıra. Aynı dört açının 24 farklı sıralaması bulundu ve hepsinin $A$ matrisi aynı. Bu sıralamalar eğilme rijitliği $D$'de, burkulmada ve tabaka ayrılmasına (delaminasyon) direnç gibi özelliklerde farklıdır. Sırayı bu ölçütlere göre seçmek gerekir; bizim modelimiz bu konuda bir şey söylemez.
  • Özellikler. Dengeli bir laminatın $A$'sı yalnız $\xi_1$ ve $\xi_3$'e bağlıdır. İki hedef ($E_x$, $E_y$) iki bilinmeyeni belirler; bu yüzden bütün çözümlerde $G_{xy}$ ve $\nu_{xy}$ de aynı çıktı ($G_{xy}$ = 34,24 GPa, $\nu_{xy}$ = 0,598). Denge koşulunu kaldırırsanız tablo tamamen değişir (Alıştırma 3).
  • Açılar. Aynı $(\xi_1, \xi_3)$'ü veren farklı açı kümeleri olabilir. Bu problemde optimizasyon yalnız birini buldu, ama bu genel bir garanti değildir.

Üretim dostu açılar. $\{0^\circ, \pm45^\circ, 90^\circ\}$ ile 256 dizilimin hepsini KLT ile hesapladık. Sıra $A$'yı değiştirmediği için 256 dizilimden yalnız 35 farklı $A$ matrisi çıkıyor. +45° ile −45° tabakalarının yer değiştirmesi ise yalnız $A_{16}$ ve $A_{26}$'nın işaretini çevirir; $E_x$, $E_y$, $G_{xy}$ ve $\nu_{xy}$ değişmez. Bu yüzden geriye 22 farklı özellik takımı kalıyor. 70 dizilim dengeli. Dengeli en iyi seçenek $[0/45/0/{-45}]_s$: $E_x$ = 103,98, $E_y$ = 29,22 GPa, hata %48,5. Denge koşulu kaldırılınca en iyi seçenek $[45/45/0/{-45}]_s$ ($E_x$ = 64,31, $E_y$ = 31,81 GPa, hata %20,5), ama bu laminatta çekme–kayma kuplajı var. 8 tabakayla standart açılar bu hedefe yaklaşamıyor; tabaka sayısını artırmanın etkisini Alıştırma 2'de göreceksiniz.

Solda Ex–Ey düzleminde rastgele laminatların gri bulutu, 0, ±45 ve 90 derecelik ayrık dizilimler turuncu kareler, hedef kesikli çizgilerin kesişimi ve vekil ile bulunan çözüm bu kesişimde mavi nokta; sağda dengeli laminatlar için Gxy–Ex düzlemi, Ex = 50 GPa kısıt çizgisi, ilk vekil optimumu çizginin solunda yeşil üçgen, iyileştirme sonrası çözüm çizginin üzerinde mavi nokta, kısıtı sağlayan ayrık dengeli dizilimler en fazla 26,88 GPa
Sol: hedef rijitlik problemi. Vekil ve gradyanla bulunan çözümler (mavi, KLT ile hesaplanmış) hedefin üzerinde; ayrık açılı dizilimlerin hiçbiri hedefe yakın değil. Sağ: $E_x \ge 50$ GPa iken en büyük $G_{xy}$. Gri bulut dengeli $[\pm\alpha/{\pm}\beta]_s$ laminatları; köşedeki küçük grafik optimum çevresine yakından bakıyor.
Ters tasarım sonuçları (tüm özellikler kesin KLT ile hesaplandı)
Problem ve yöntemDizilim$E_x$ (GPa)$E_y$ (GPa)$G_{xy}$ (GPa)Not
Hedef 70/40 — vekil + gradyan[21,3/−21,3/53,6/−53,6]s70,0039,9034,24Dengeli, hata %0,25
Hedef 70/40 — ayrık, dengeli[0/45/0/−45]s103,9829,22—Hata %48,5
Hedef 70/40 — ayrık, dengesiz[45/45/0/−45]s64,3131,81—Hata %20,5; kuplajlı
En büyük $G_{xy}$ — ilk vekil optimumu[43/29/−31/−42]s49,20—41,45Kısıt ihlali %1,6
En büyük $G_{xy}$ — iyileştirme sonrası[−42/−30/29/43]s49,97—41,27Kısıt sınırında
En büyük $G_{xy}$ — ayrık, dengeli[0/0/45/−45]s103,98—26,88$\xi_3 = 0$

Kısıtlı problem: vekilin zayıf olduğu yer

İkinci problemde vekilin bulduğu ilk optimum $[43/29/{-31}/{-42}]_s$. Vekil bu tasarım için $E_x$ = 49,92 GPa diyor. Sınırdan 0,08 GPa'lık bu fark ceza yönteminin kendi payıdır: ceza katsayısı sonlu olduğu için çözüm sınırın hemen dışında dengelenir. KLT ise $E_x$ = 49,20 GPa veriyor: kısıt %1,6 ihlal edilmiş. Vekilin bu noktadaki hatası 0,72 GPa, yani %1,5; bu, ortalama hatasının (%0,76) yaklaşık 1,9 katı. Neden burada?

Optimizasyon, kayma modülünü büyütmek için $\xi_3$'ü olabildiğince küçültmeye çalışır (dengeli laminatta $G_{xy} = U_5 - U_3\,\xi_3$). Bu, tasarımı $\xi_3$ dağılımının kuyruğuna götürür. $\xi_3$, dört bağımsız $\cos 4\theta$'nın ortalamasıdır; her birinin standart sapması $1/\sqrt2$ olduğundan rastgele laminatlarda $\xi_3$'ün standart sapması yaklaşık 0,35'tir ve −0,73 ortalamadan iki standart sapmadan fazla uzaktadır. Nitekim 2048 eğitim laminatından yalnız 57'sinde $\xi_3 \le -0{,}7$ ve ilk optimuma en yakın eğitim örneği $\xi$ uzayında 0,169 uzakta (hedef rijitlik çözümünde bu uzaklık 0,056'ydı). Optimizasyon algoritması, vekilin iyimser hata yaptığı noktaları özellikle bulur; bu yüzden en iyi görünen tasarım, vekilin en az güvenilir olduğu yerde çıkma eğilimindedir.

Çare, veriyi tasarımın gittiği yerde toplamaktır. Bulunan 64 tasarımı ve her birinin açılarına standart sapması 3° olan gürültü eklenmiş üç kopyasını KLT ile hesapladık (256 yeni örnek), eğitim kümesine ekledik ve vekili kaldığı yerden eğitmeye devam ettik. Yeniden aranan optimum $[{-42}/{-30}/29/43]_s$ için KLT $E_x$ = 49,97 ve $G_{xy}$ = 41,27 GPa veriyor. Kısıt payı −0,795 GPa'dan −0,030 GPa'ya, yani %0,06'ya indi. Bu artık vekil hatasının çok altında; gerçek bir tasarımda ise kısıta küçük bir pay koymak (ör. $E_x \ge 50{,}5$ GPa) doğru olur. Bu yaklaşım, Ders 15'teki aktif öğrenmenin tasarım problemindeki karşılığıdır.

Optimum nerede? $E_x$ kısıtı $\xi_3$'ün ne kadar küçülebileceğini sınırlar. Sabit $\xi_3$'te $E_x$'in $\xi_1$'e göre türevi $U_2\,[1 - (A_{12}/A_{22})^2]$'dir; bu yüzden en iyi tasarımda $E_x$'i en büyük yapan $\xi_1$ seçilir, yani $A_{12} \approx A_{22}$ olur. İyileştirme sonrası optimumda $\xi_1$ = 0,297, $\xi_3$ = −0,730 ve $A_{12}/A_{22}$ = 1,013. Parabol bu $\xi_1$'de −0,823 değerini alır; yani optimum ulaşılabilir bölgenin sınırında değil, içindedir. Sınırdaki $[\pm33{,}8]_{2s}$ laminatı da $E_x$ = 50,00 GPa'yı sağlar, ama yalnız $G_{xy}$ = 40,86 GPa verir: iki farklı açı çiftini (yaklaşık ±30° ve ±42°) karıştırmak daha iyidir.

Ayrık açılarla en iyi dengeli sonuç $G_{xy}$ = 26,88 GPa. Bu sayının nereden geldiğini laminasyon parametreleri hemen söyler: dört bağımsız tabakada dengeli bir standart dizilim, ya hiç ±45 içermez ($\xi_3 = 1$), ya bir ±45 çifti içerir ($\xi_3 = 0$) ya da yalnız ±45'lerden oluşur ($\xi_3 = -1$). Sonuncusu $[\pm45]_{2s}$'dir ve $E_x$ = 25 GPa ile kısıtı sağlamaz. Geriye $\xi_3 = 0$ kalır ve $G_{xy} = U_5$ = 26,88 GPa olur. Sürekli açılar yaklaşık %54 daha yüksek kayma rijitliği veriyor (41,27'ye karşı 26,88 GPa). Bu farkın bedeli, ±30° ve ±42° gibi standart dışı açılar için malzeme verisi ve üretim deneyimi gerekmesidir.

9. Sık yapılan hatalar

  • Açıları ham sayı olarak vermek. Periyodik bir girdiyi doğrusal bir sayı gibi kodlamak, ağı periyodikliği örneklerden öğrenmeye zorlar. Rüzgâr yönü, faz açısı, yılın günü gibi bütün periyodik girdilerde cos/sin kullanın.
  • Vekilin optimumuna doğrulamadan güvenmek. Optimizasyon algoritması vekilin hatalarını bulmakta çok başarılıdır. Son tasarımı mutlaka kesin modelle (ya da deneyle) doğrulayın.
  • Bilinen fiziği öğrenmeye bırakmak. Denge, simetri, sıra bağımsızlığı gibi kesin bilinen koşulları gösterime veya kayba doğrudan koyun. Ağ bunları ancak yaklaşık öğrenir ve veri harcar.
  • Eğitim verisinin tasarım uzayını kapsadığını varsaymak. Düzgün dağılımlı açılar, $\xi$ uzayında düzgün dağılmaz. En iyi tasarımlar çoğu zaman $\xi$ uzayının uç bölgelerindedir ve orada veri azdır.
  • Tek başlangıçla optimize etmek. Periyodik ve çok tepeli bir kayıpta tek başlangıç yerel minimumda kalabilir. Çok başlangıç, yığın hâlinde neredeyse bedavadır.
  • Düzlem içi rijitliği tasarımın tamamı sanmak. Eğilme rijitliği, burkulma, dayanım ve üretim kuralları (sektörde yaygın olan “her yönde en az %10 tabaka” gibi kurallar) ayrıca sağlanmalıdır.

10. Alıştırmalar

Alıştırma 1KolayÇapraz katlı ve açılı laminat

sabitler fonksiyonuyla $[0/90]_{2s}$ ve $[\pm45]_{2s}$ laminatlarının dört mühendislik sabitini hesaplayın. $[0/90]_{2s}$'nin kayma modülü neden tabakanınkiyle aynı? Cevabı laminasyon parametreleriyle açıklayın.

Çözümü göster

$[0/90]_{2s}$ için $E_x = E_y$ = 95,99 GPa, $G_{xy}$ = 7,17 GPa ve $\nu_{xy}$ = 0,030. $[\pm45]_{2s}$ için $E_x = E_y$ = 25,05 GPa, $G_{xy}$ = 46,59 GPa ve $\nu_{xy}$ = 0,747.

İki laminat da dengelidir, dolayısıyla $G_{xy} = U_5 - U_3\,\xi_3$. 0° ve 90° tabakalarda $\cos 4\theta = 1$ olduğundan çapraz katlı laminatta $\xi_3 = 1$ ve $G_{xy} = U_5 - U_3 = Q_{66} = G_{12}$ olur. Yani 0° ve 90° tabakalardaki lifler kayma rijitliğine katkı vermez; laminat, matrisin belirlediği $G_{12}$'de kalır. ±45° tabakalarda ise $\cos 4\theta = -1$, $\xi_3 = -1$ ve $G_{xy} = U_5 + U_3$ = 46,59 GPa. Kayma rijitliği isteniyorsa ±45° tabaka gerekir; buna karşılık $E_x$ yaklaşık 3,8 kat düşer (95,99'dan 25,05 GPa'ya).

Alıştırma 2OrtaDaha çok tabaka, daha ince ızgara

Kapsamlı aramayı 16 tabakalı $[\theta_1/\dots/\theta_8]_s$ ve 24 tabakalı $[\theta_1/\dots/\theta_{12}]_s$ laminatlar için tekrarlayın; açılar yine $\{0^\circ, \pm45^\circ, 90^\circ\}$ olsun. Hedefe (70, 40 GPa) en yakın dengeli dizilim ne kadar yaklaşıyor? İpucu: düzlem içi özellikler yalnız her açıdan kaç tabaka olduğuna bağlıdır, bu yüzden 16 tabakada $4^8 = 65.536$ dizilim yerine 165, 24 tabakada $4^{12} \approx 1{,}7\times10^7$ dizilim yerine 455 sayım bileşimini denemek yeter.

Çözümü göster

16 tabakada (yarı yığında 8 tabaka) en iyi dengeli bileşim iki 0° ile üç +45° ve üç −45° tabakadır: $E_x$ = 64,57, $E_y$ = 33,10 GPa, hata %17,3. Denge koşulu kaldırılınca en iyisi üç 0°, bir 90° ve dört −45° ile %14,2'dir. 24 tabakada en iyi dengeli bileşim üç 0°, bir 90°, dört +45° ve dört −45° tabaka: $E_x$ = 68,75, $E_y$ = 45,38 GPa, hata %13,5.

Nedenini laminasyon parametreleri açıklıyor. Dengeli standart dizilimler $(\xi_1, \xi_3)$ düzleminde köşeleri $(1, 1)$, $(-1, 1)$ ve $(0, -1)$ olan bir üçgenin ızgara noktalarıdır: $\xi_1$ = (0° sayısı − 90° sayısı)/n ve $\xi_3$ = 1 − 2·(±45 sayısı)/n. Hedefi tam olarak karşılayan ($E_x$ = 70, $E_y$ = 40 GPa) dengeli noktanın parametreleri $(\xi_1, \xi_3) \approx (0{,}220;\ -0{,}372)$ bu üçgenin içinde. Yani tabaka sayısı arttıkça standart açılarla hedefe istendiği kadar yaklaşılabilir; ama 8, 16 ve 24 tabakada ızgara hâlâ kaba.

Alıştırma 3OrtaDenge koşulu olmadan

amac_hedef fonksiyonundan dengesizlik(xi) terimini çıkarıp ters tasarımı tekrarlayın. Kaç farklı açı kümesi buluyorsunuz? Çözümlerin $G_{xy}$, $\nu_{xy}$ ve $|A_{16}|$ değerleri nasıl dağılıyor?

Çözümü göster

64 başlangıcın hepsi yakınsıyor ve 64 ayrı açı kümesi çıkıyor. KLT ile en büyük hata %1,68. Ama çözümler artık özellik düzeyinde de birbirinden çok farklı: $G_{xy}$ 9,74 ile 33,56 GPa arasında, $\nu_{xy}$ −0,210 ile 0,599 arasında değişiyor ve $|A_{16}|$ 28,48 GPa·mm'ye kadar çıkıyor. Hiçbiri dengeli değil.

Ders: iki hedef, dört serbest açıyı belirlemeye yetmez. Denge koşulu iki denklem daha ekleyerek problemi neredeyse tek çözümlü hâle getirdi. Ters problemde neyi sabitlemediyseniz, optimizasyon onu keyfî bir değerde bırakır; üstelik bu değerler (burada kuplaj) çoğu zaman istenmeyen davranışlardır.

Alıştırma 4ZorVekilsiz ters tasarım

KLT'yi PyTorch ile yazın: Qbar_acik'taki formülleri torch işlemleriyle kurun, $A$'yı toplayın ve torch.linalg.inv ile tersini alın. Ardından ters tasarımı vekil yerine bu kesin ve türevlenebilir modelle çalıştırın (aynı başlangıçlar, 800 adım). Sonucu vekilinkiyle karşılaştırın. Takılan başlangıçlar hangi tasarımlarda kalıyor?

Çözümü göster
def sabitler_t(aci):                     # aci: (n, 4) derece, torch.float64
    Qb = qbar_t(torch.deg2rad(aci))       # Qbar_acik'ın torch karşılığı → (n, 4, 3, 3)
    a = torch.linalg.inv(2 * T_KAT * Qb.sum(-3))
    return torch.stack([1 / (H * a[:, 0, 0]), 1 / (H * a[:, 1, 1]),
                        1 / (H * a[:, 2, 2]), -a[:, 0, 1] / a[:, 0, 0]], -1)

64 başlangıçtan 54'ü yakınsıyor ve hepsi $\{\pm21{,}3^\circ, \pm53{,}6^\circ\}$ kümesini buluyor. Kesin modelle $E_x$ = 70,000 ve $E_y$ = 40,000 GPa (hata %0,0000), $G_{xy}$ = 34,22 GPa ve $\nu_{xy}$ = 0,596. Vekil aynı kümeyi %0,25 hatayla bulmuştu.

Yakınsamayan on başlangıçtan biri eşiğin hemen üstünde ($L$ = 2,6×10⁻⁴); dokuzu ise aynı noktada, $L \approx 0{,}2545$'te kalıyor; örneğin $[79/7/7/49]_s$. Bütün açılar aynı işaretli olduğu için laminat dengesiz ($\xi_2 = 0{,}466$) ve kaybın çoğu denge cezasından geliyor. Dengeye ulaşmak için bazı açıların işaret değiştirmesi gerekir. Bu sırada kayıp önce artacağından gradyan inişi bu çukurdan çıkamaz.

Sonuç: kesin model bu kadar ucuz ve türevlenebilirken vekile gerek yok. Vekil, kesin model pahalıysa, türevlenebilir değilse ya da bir kara kutu yazılımın içindeyse anlam kazanır. Bu durumda bile son doğrulama kesin modelle yapılır.

Alıştırma 5ZorAynı rijitlik, farklı dayanım

Tek eksenli çekme ($N_x$, $N_y = N_{xy} = 0$) altında $[0/{\pm}45/90]_s$ ve $[21/{-21}/54/{-54}]_s$ laminatlarının ilk tabaka hasarı yükünü Tsai–Wu ölçütüyle hesaplayın. T300/5208 için ders kitaplarında verilen tipik dayanımları kullanın: $X_t = X_c$ = 1500 MPa, $Y_t$ = 40 MPa, $Y_c$ = 246 MPa, $S$ = 68 MPa; etkileşim terimi için $F_{12} = -\tfrac12\sqrt{F_{11}F_{22}}$ alın. Adımlar: orta düzlem şekil değiştirmesi $\varepsilon^0 = A^{-1}N$, her tabakada ana eksenlere dönüşüm, $\sigma_{12} = Q\,\varepsilon_{12}$ ve dayanım oranı $R$.

Çözümü göster

Birimlere dikkat: $A$ GPa·mm cinsinden olduğu için 1000 ile çarpılınca N/mm olur. $N_x$ = 1 N/mm için her tabakada gerilmeleri bulup Tsai–Wu polinomundan $aR^2 + bR - 1 = 0$ denklemini çözün; en küçük $R$ ilk tabaka hasarı yükünü N/mm cinsinden verir.

  • $[0/{\pm}45/90]_s$ ($E_x$ = 69,68 GPa): $N_x$ = 276,1 N/mm'de 90° tabakası hasar görür. O anda bu tabakada life dik gerilme $\sigma_2$ = 37,6 MPa, yani $Y_t$ = 40 MPa'ya çok yakın: klasik matris çatlağı.
  • $[21/{-21}/54/{-54}]_s$ ($E_x$ = 70,85 GPa): $N_x$ = 321,2 N/mm'de ±54° tabakaları hasar görür. Burada kayma gerilmesi $|\tau_{12}|$ = 48,9 MPa ile $\sigma_2$ = 20,8 MPa birlikte etkilidir.

Laminat kalınlığı 1 mm olduğundan ortalama gerilme $N_x/h$ aynı sayıdır (MPa). İki laminatın $E_x$'i hemen hemen aynı, ama ilk tabaka hasarı yükleri %16 farklı. Rijitlik hedefi dayanımı belirlemez. Gerçek bir tasarımda hasar kısıtı ters tasarım problemine eklenmeli, vekil de bu çıktıyı öğrenmelidir.

Özet

Özet
  • Simetrik bir laminatın zar rijitliği $A$, laminasyon parametreleri $\xi_1, \dots, \xi_4$'ün doğrusal fonksiyonudur. Doğru gösterimle doğrusal regresyon bile Tsai–Pagano değişmezlerini yeniden bulur.
  • Aynı ağ ve aynı eğitim bütçesiyle $\xi$ gösterimi, ham açılardan 32 kat az veriyle daha düşük hata veriyor. Periyodiklik ve sıra simetrisi gösterime gömülünce ağ yalnız gerçekten doğrusal olmayan kısmı öğreniyor.
  • Türevlenebilir bir vekil, otomatik türevle girdiye göre optimize edilebilir. Çok başlangıç, yerel minimumlara ve çözümün tek olmamasına karşı zorunludur.
  • Optimizasyon vekilin hatalarını arar. Her tasarımı kesin modelle doğrulayın; hata büyükse tasarımın gittiği bölgeden yeni veri toplayıp vekili yeniden eğitin.
  • Sürekli açılar standart açılardan belirgin biçimde iyi tasarımlar verebilir; ama sıra, eğilme, dayanım ve üretim koşulları ayrıca değerlendirilmelidir.

Kursun son dersinde bütün bu “doğrula, sınırlarını bil, belgele” alışkanlıklarını genel bir çerçeveye oturtacağız: Ders 17 — güvenilir makine öğrenmesi.

Kaynaklar

  • R. M. Jones — Mechanics of Composite Materials, 2. baskı, Bölüm 2 (tabaka rijitliği ve değişmezler) ve Bölüm 4 (laminasyon teorisi).
  • S. W. Tsai, H. T. Hahn — Introduction to Composite Materials (T300/5208 değerleri, değişmezler ve laminasyon parametreleri).
  • I. M. Daniel, O. Ishai — Engineering Mechanics of Composite Materials, 2. baskı (laminat analizi ve hasar ölçütleri).
  • PyTorch — Automatic differentiation (torch.autograd) belgeleri.