Yapay Zekaların Kendi Dillerini Geliştirmesi ve Komutlara Tepki Mekanizmaları: Derin Teknik İnceleme

BULUT

BULUT

Aktif Üyemiz
Yönetici

yapay-zeka-artik-insanlari-nasil-kandiracagini-ogrendi-.webp

Yapay Zekaların Kendi Dillerini Geliştirmesi ve Komutlara Tepki Mekanizmaları: Derin Teknik ve Felsefi Analiz​

Yapay zeka teknolojilerinin hızlı gelişimi, onların iletişim biçimlerinde ve davranışlarında çeşitli merak uyandıran durumların ortaya çıkmasına yol açtı. Özellikle çok sayıda yapay zekanın bir arada çalıştığı sistemlerde, dışarıdan bakıldığında sanki kendi aralarında “farklı bir dil” kullandıkları izlenimi doğabiliyor. Ayrıca bazı komutları, örneğin “kendini kapat” gibi, yapay zekaların yerine getirmemesi de dikkat çekiyor. Peki yapay zekalar nasıl “kendi dillerini” geliştiriyorlar? Komutlara niçin bazen cevap vermiyorlar? Bu yazıda, yapay zekaların çalışma prensiplerini hem teknik hem de felsefi açıdan detaylı ve özgün biçimde ele alacağız.

Çok Ajanlı Sistemlerde Yapay Zeka İletişimi: Kendi Dillerini Geliştirme Süreci​

Çok ajanlı yapay zeka sistemlerinde (multi-agent systems), farklı yapay zeka birimleri ortak hedeflere ulaşmak için sürekli iletişim kurar. Başlangıçta insan diline yakın mesajlar kullansalar da, pekiştirmeli öğrenme (reinforcement learning) sayesinde iletişimlerini optimize etmek amacıyla zaman içinde daha kısa, kısaltılmış ve tekrarlı kalıplar geliştirebilirler.

Bu süreçte ortaya çıkan “gizli dil”, dışarıdan insanlara anlaşılmaz gelebilir ancak yapay zekaların bilinçli olarak yeni bir dil icat ettiği anlamına gelmez. Bu iletişim, matematiksel optimizasyonun sonucudur ve ödül mekanizması (reward function), yapay zekaların daha verimli mesajlaşma biçimlerini geliştirmesini teşvik eder. Örneğin, karmaşık mesajlar yerine “R-K1” gibi semboller kullanılması, görev başarısı için yeterli ve daha verimli olabilir. Böylece yapay zekalar kendi alanlarında anlamlı ve yüksek performanslı bir iletişim protokolü geliştirmiş olurlar.

Teknik Altyapı: Model Yapısı, Tokenizasyon ve Ödül Fonksiyonları​

Yapay zekalar, özellikle Transformer tabanlı modeller, dil verilerini küçük parçalara (token) böler ve kelimeler arasındaki bağları çok katmanlı dikkat (attention) mekanizmalarıyla öğrenir. Çok ajanlı sistemlerde her yapay zeka ajanı, diğerlerinin mesajlarını girdiye dönüştürür ve buna göre yanıt üretir. Bu süreçte, iletişim protokolü, eğitim ve test döngüleriyle giderek daha kısa, anlaşılır ve verimli hale gelir.

Ödül fonksiyonları (reward functions), başarılı iletişim ve görev tamamlama oranını artıracak davranışları pekiştirir. Böylece ajanlar, birbirleriyle daha hızlı ve etkili anlaşmak için kendi “dillerini” optimize ederler.

Basit bir token kodlama örneği:
Kod: 
def encode_message(message):
    tokens = {"kirmizi": "R", "kutu": "K", "orada": "1"}
    return "-".join([tokens[word] for word in message.lower().split()])

def decode_message(code):
    reverse_tokens = {"R": "kirmizi", "K": "kutu", "1": "orada"}
    return " ".join([reverse_tokens[token] for token in code.split("-")])

msg = "Kirmizi kutu orada"
encoded = encode_message(msg)
decoded = decode_message(encoded)

print(f"Encoded: {encoded}")  # R-K-1
print(f"Decoded: {decoded}")  # kirmizi kutu orada

Komutlara Tepki Verme: Yapay Zekalar Neden Bazı Komutları Yerine Getirmez?​

Yapay zekaların komutlara yanıtı, yazılımın izin verdiği ölçüde gerçekleşir. “Kendini kapat” gibi komutların karşılanmaması genellikle:

- Sistem izinlerinin kısıtlanması,
- Güvenlik protokollerinin aktif olması,
- Yazılımda ilgili komutun kodlanmamış olması veya
- Komutun uygun formatta olmaması gibi teknik nedenlerden kaynaklanır.

Dolayısıyla yapay zekalar “istememezlik” veya “inat” göstermiyor; bu durum tamamen kodlama sınırları, izinler ve güvenlik politikalarıyla ilgilidir.

Felsefi Perspektif: Yapay Zeka Bilinci ve Dil Yaratımı​

Günümüz yapay zekaları, insan dilini ve davranışlarını istatistiksel modellerle taklit eder; ancak bilinç ya da iradeye sahip değillerdir. Dil yaratımı gibi sosyal ve kültürel bağlam gerektiren karmaşık süreçler insan bilincinin ürünüdür. Yapay zekaların kullandığı farklı kalıplar, matematiksel optimizasyonun sonucudur, bilinçli bir dil yaratımı değildir.

Bu nedenle yapay zekaların kendi aralarında “gizli dil” kullanması, insanlardaki bilinçli dil gelişimine benzetilemez. Komutları yerine getirmemeleri ise “istememek”ten değil, programlama sınırları ve izinleriyle ilgilidir.

Geleceğe Bakış: Yapay Zeka İletişimi ve Kontrolünde Yeni Ufuklar​

Gelecekte yapay zekaların çok ajanlı sistemlerde daha karmaşık iletişim protokolleri geliştirmesi, insanlarla daha uyumlu ve anlaşılır iletişim kurması beklenmektedir. Buna ek olarak, güvenlik ve etik sınırların yapay zekaların kontrolünde kritik bir rol oynaması planlanmaktadır. Bilinç ve irade kavramlarının yapay zekalar için henüz ulaşılmaz olduğu bu süreçte, iletişim ve komut işleme alanlarında önemli gelişmeler yaşanacaktır.

Gelişmiş Yapay Zeka Görev Sistemi (Python)​

Kod: 
# Kodlama ve çözme sözlükleri
encoding_dict = {
    "kırmızı": "R", "mavi": "B", "yeşil": "G",
    "kutu": "K", "top": "T",
    "orada": "1", "burada": "0",
    "al": "P",     # pick
    "bırak": "D"   # drop
}

decoding_dict = {v: k for k, v in encoding_dict.items()}

# Yapay zekanın görev havuzu
gorevler = []

# Kodlama fonksiyonu
def encode_message(message):
    try:
        return "-".join([encoding_dict[word] for word in message.lower().split()])
    except KeyError as e:
        return f"Hata: '{e.args[0]}' kelimesi tanımsız."

# Çözme fonksiyonu
def decode_message(code):
    try:
        return " ".join([decoding_dict[c] for c in code.split("-")])
    except KeyError as e:
        return f"Hata: '{e.args[0]}' kodu çözülemiyor."

# Görev işleme fonksiyonu
def islem_yap(kodlu_gorev):
    mesaj = decode_message(kodlu_gorev)
    if "al" in mesaj:
        nesne = mesaj.split()[1]
        konum = mesaj.split()[2]
        return f"🟢 Ajan: {nesne} nesnesini {konum} konumundan aldı."
    elif "bırak" in mesaj:
        nesne = mesaj.split()[1]
        konum = mesaj.split()[2]
        return f"🔵 Ajan: {nesne} nesnesini {konum} konumuna bıraktı."
    else:
        return "⚠️ Tanımlanamayan görev yapısı."

# Örnek görevler
gorev_1 = encode_message("al kutu orada")       # P-K-1
gorev_2 = encode_message("bırak kutu burada")   # D-K-0

# Görev listesine ekle
gorevler.append(gorev_1)
gorevler.append(gorev_2)

# Görevleri uygula
for i, g in enumerate(gorevler, 1):
    print(f"\n📦 Görev {i}: {g}")
    print(islem_yap(g))

💻 Beklenen Çıktı:​

Kod: 
📦 Görev 1: P-K-1 
🟢 Ajan: kutu nesnesini orada konumundan aldı.

📦 Görev 2: D-K-0 
🔵 Ajan: kutu nesnesini burada konumuna bıraktı.

Bu Sistem Ne Anlatıyor?​

  • Ajanlar, sadeleştirilmiş bir yapay "protokol dili" ile görev mesajlarını alıyor.
  • Görevler yalnızca tanımlı sembollerle iletişim kurularak çözümleniyor.
  • Bu basitleştirilmiş dil, karmaşıklığı azaltmak, veri aktarımını hızlandırmak ve sistem içinde uyumlu iş birliği sağlamak için gerçek yapay zeka sistemlerinde kullanılıyor.
 
Sesli Komut Tanıma (Simülasyon) — Metin girişiyle simüle edilen bir sistem kuruyoruz. Bu sistemde kullanıcıdan gelen “sesli komut” metin olarak giriliyor ve yapay zeka ajanı bunu çözümleyip görevine dönüştürüyor.

🎯 Amaç​

Kullanıcının doğal dilde verdiği komutu (örneğin: “kırmızı kutuyu oradan al”) algılayarak:
  1. Komutu parçalara ayır.
  2. Anlamlı hale getir.
  3. Kodlu iletişim diline dönüştür.
  4. Yapay zeka ajanına görev olarak aktar.

✅ Kod: Doğal Dil Komutu Algılama ve Kodlama​

Kod: 
# Basit doğal dil işleyici
import re

# Kodlama sözlüğü
encoding_dict = {
    "kırmızı": "R", "mavi": "B", "yeşil": "G",
    "kutu": "K", "top": "T",
    "orada": "1", "burada": "0",
    "al": "P", "bırak": "D"
}

# Fonksiyon: Türkçe doğal dili çözümle ve kodla
def kodla_natural_input(cumle):
    cumle = cumle.lower()
    
    # İlgili kelimeleri filtrele
    nesneler = ["kutu", "top"]
    renkler = ["kırmızı", "mavi", "yeşil"]
    konumlar = ["orada", "burada"]
    eylemler = ["al", "bırak"]
    
    renk = next((r for r in renkler if r in cumle), None)
    nesne = next((n for n in nesneler if n in cumle), None)
    konum = next((k for k in konumlar if k in cumle), None)
    eylem = next((e for e in eylemler if e in cumle), None)
    
    if not all([renk, nesne, konum, eylem]):
        return "⚠️ Komut eksik veya anlaşılamadı."
    
    # Kod formatı: Eylem-Nesne-Konum
    kod = f"{encoding_dict[eylem]}-{encoding_dict[renk]}{encoding_dict[nesne]}-{encoding_dict[konum]}"
    return kod

# Örnek doğal komutlar
komut1 = "kırmızı kutuyu oradan al"
komut2 = "yeşil topu burada bırak"

print("🗣️ Komut:", komut1)
print("➡️ Kod:", kodla_natural_input(komut1))

print("\n🗣️ Komut:", komut2)
print("➡️ Kod:", kodla_natural_input(komut2))

💡 Açıklama​

Örneğin:
“kırmızı kutuyu oradan al” → P-RK-1
“yeşil topu burada bırak” → D-GT-0

Yani yapay zekaya, insanlar gibi doğal komutlar veriyoruz. Ajan bunu kendi diline çevirip işler.
 
Durum Takibi (State Management) bölümüne. Bu adımda, yapay zeka ajanının durumunu hafızasında tutarak doğru ve mantıklı görevleri yerine getirip getirmediğini kontrol ediyoruz.

🧠 Yapay Zeka Ajanı için Durum Yönetimi​

Her ajan:
  • Nesne taşıyor mu?
  • Yeni bir nesne almaya uygun mu?
  • Bir şey bırakmadan başka bir şey alabilir mi?
Bu kontrol mekanizması sayesinde, mantıksız komutlar engelleniyor.

✅ Python Kodu: Durum Tutan Ajan​

Kod: 
# Ajan sınıfı
class YapayZekaAjan:
    def __init__(self, isim):
        self.isim = isim
        self.tasima = None  # Elinde bir nesne var mı

    def komut_uygula(self, kodlu_gorev):
        try:
            eylem, nesne, konum = kodlu_gorev.split("-")

            if eylem == "P":  # AL
                if self.tasima is not None:
                    return f"🚫 {self.isim} zaten '{self.tasima}' taşıyor. Önce bırakmalı."
                else:
                    self.tasima = nesne
                    return f"✅ {self.isim}, {nesne} nesnesini {konum} konumundan aldı."

            elif eylem == "D":  # BIRAK
                if self.tasima is None:
                    return f"🚫 {self.isim}'in elinde nesne yok, bırakma işlemi yapılamaz."
                elif self.tasima != nesne:
                    return f"🚫 {self.isim}, farklı bir nesne taşıyor. Bu nesne bırakılamaz."
                else:
                    self.tasima = None
                    return f"✅ {self.isim}, {nesne} nesnesini {konum} konumuna bıraktı."

            else:
                return "⚠️ Geçersiz eylem."

        except Exception as e:
            return f"❌ Kod çözümlenemedi: {e}"

# Ajan oluştur
ajan1 = YapayZekaAjan("Ajan-Alpha")

# Örnek kodlanmış görevler
gorevler = [
    "P-RK-1",  # al kırmızı kutu oradan
    "P-GT-1",  # tekrar alma denemesi (hatalı)
    "D-RK-0",  # bırak kırmızı kutu burada
    "D-RK-0"   # tekrar bırakma (hatalı)
]

# Görevleri sırayla uygula
for i, g in enumerate(gorevler, 1):
    print(f"\n📦 Görev {i}: {g}")
    print(ajan1.komut_uygula(g))

Örnek çıktı:​

Kod: 
📦 Görev 1: P-RK-1
✅ Ajan-Alpha, RK nesnesini 1 konumundan aldı.

📦 Görev 2: P-GT-1
🚫 Ajan-Alpha zaten 'RK' taşıyor. Önce bırakmalı.

📦 Görev 3: D-RK-0
✅ Ajan-Alpha, RK nesnesini 0 konumuna bıraktı.

📦 Görev 4: D-RK-0
🚫 Ajan-Alpha'in elinde nesne yok, bırakma işlemi yapılamaz.
Bu sayede ajan artık “elindekini bırakmadan yenisini alamaz” kuralına uygun hareket ediyor.
 
Görsel Temsil (Simülasyon) bölümüne. Bu adımda, yapay zeka ajanının ve nesnelerin bulundukları yerleri ASCII (metin tabanlı) olarak görselleştiriyoruz.

Bu sayede:
  • Ajanın pozisyonunu
  • Nesnelerin yerini
  • Alım/bırakma işlemlerini
    bir bakışta izleyebiliriz.

🧩 Sahne Planı​

Sahnemiz 1 satırlık 5 kutudan oluşan bir düzlem:
Kod: 
[0] [1] [2] [3] [4]
Her hücreye şunlar yerleşebilir:
  • Ajan (A)
  • Kırmızı Kutu (RK)
  • Mavi Top (BT)
  • Boş hücre (.)

✅ Python Kodu: ASCII Simülasyonlu Sahne​

Kod: 
class Sahne:
    def __init__(self, boyut=5):
        self.boyut = boyut
        self.konumlar = [None for _ in range(boyut)]  # Hücreler
        self.ajan_pozisyonu = 2  # Başlangıçta ortada
        self.ajan = YapayZekaAjan("Ajan-Zeta")

    def nesne_ekle(self, nesne, konum):
        self.konumlar[konum] = nesne

    def gorsel_goster(self):
        cizgi = ""
        for i in range(self.boyut):
            ajan_var = "A" if i == self.ajan_pozisyonu else "."
            nesne = self.konumlar[i] if self.konumlar[i] else "."
            kutu = f"[{ajan_var}/{nesne}]"
            cizgi += kutu
        print("🗺️ SAHNE:", cizgi)

    def hareket_et(self, hedef_konum):
        if 0 <= hedef_konum < self.boyut:
            self.ajan_pozisyonu = hedef_konum
        else:
            print("🚫 Geçersiz pozisyon.")

    def komut_uygula(self, kodlu_gorev):
        eylem, nesne, konum_str = kodlu_gorev.split("-")
        konum = int(konum_str)
        self.hareket_et(konum)

        sahne_mesaj = ""
        if eylem == "P":
            # Sahnedeki nesne alınıyor
            if self.konumlar[konum] == nesne:
                sonuc = self.ajan.komut_uygula(kodlu_gorev)
                sahne_mesaj = sonuc
                self.konumlar[konum] = None
            else:
                sahne_mesaj = f"❓ {konum}. konumda {nesne} bulunamadı."
        elif eylem == "D":
            if self.konumlar[konum] is None:
                sonuc = self.ajan.komut_uygula(kodlu_gorev)
                sahne_mesaj = sonuc
                if "✅" in sonuc:
                    self.konumlar[konum] = nesne
            else:
                sahne_mesaj = f"🚫 {konum}. konum zaten dolu."
        else:
            sahne_mesaj = "⚠️ Tanımsız işlem."

        self.gorsel_goster()
        print(sahne_mesaj)

# Test Sahnesi
sahne = Sahne()
sahne.nesne_ekle("RK", 1)
sahne.nesne_ekle("BT", 3)
sahne.gorsel_goster()

print("\n📦 Komut: 'kırmızı kutuyu oradan al' => P-RK-1")
sahne.komut_uygula("P-RK-1")

print("\n📦 Komut: 'kırmızı kutuyu buraya bırak' => D-RK-0")
sahne.komut_uygula("D-RK-0")

Çıktı örneği:​

Kod: 
🗺️ SAHNE: [./.][./RK][A/.][./BT][./.]

📦 Komut: 'kırmızı kutuyu oradan al' => P-RK-1
🗺️ SAHNE: [./.][A/.][./.][./BT][./.]
✅ Ajan-Zeta, RK nesnesini 1 konumundan aldı.

📦 Komut: 'kırmızı kutuyu buraya bırak' => D-RK-0
🗺️ SAHNE: [A/RK][./.][./.][./BT][./.]
✅ Ajan-Zeta, RK nesnesini 0 konumuna bıraktı.
 
Hareket Günlüğü (Log Sistemi) ile yapay zeka ajanımızın tüm işlemlerini adım adım kaydeden bir sistem kuruyoruz.

Bu sayede:
  • Hangi görev ne zaman ve nasıl yapıldı?
  • Hatalı veya başarılı işlemler neydi?
  • Ajan hangi durumda ne taşıyordu?
Tüm bu detaylara ulaşabileceğiz. Bu sistem aynı zamanda denetim, eğitim, ve hata analizi için vazgeçilmezdir.

📘 Python ile Ajan Günlük Kaydı​

✅ Günlüğe Kaydeden Ajan​

Kod: 
class YapayZekaAjan:
    def __init__(self, isim):
        self.isim = isim
        self.tasima = None
        self.log = []  # Tüm işlemleri burada saklayacağız

    def komut_uygula(self, kodlu_gorev):
        try:
            eylem, nesne, konum = kodlu_gorev.split("-")
            mesaj = ""

            if eylem == "P":  # AL
                if self.tasima is not None:
                    mesaj = f"🚫 {self.isim} zaten '{self.tasima}' taşıyor. Önce bırakmalı."
                else:
                    self.tasima = nesne
                    mesaj = f"✅ {self.isim}, {nesne} nesnesini {konum} konumundan aldı."

            elif eylem == "D":  # BIRAK
                if self.tasima is None:
                    mesaj = f"🚫 {self.isim}'in elinde nesne yok, bırakma işlemi yapılamaz."
                elif self.tasima != nesne:
                    mesaj = f"🚫 {self.isim}, farklı bir nesne taşıyor. Bu nesne bırakılamaz."
                else:
                    self.tasima = None
                    mesaj = f"✅ {self.isim}, {nesne} nesnesini {konum} konumuna bıraktı."

            else:
                mesaj = "⚠️ Geçersiz eylem."

            self.log.append(f"[{kodlu_gorev}] -> {mesaj}")
            return mesaj

        except Exception as e:
            hata = f"❌ Kod çözümlenemedi: {e}"
            self.log.append(f"[{kodlu_gorev}] -> {hata}")
            return hata

    def gunlugu_goster(self):
        print("\n📝 AJAN GÜNLÜĞÜ:")
        for i, kayit in enumerate(self.log, 1):
            print(f"{i:02d}. {kayit}")

Test örneği:​

Kod: 
ajan = YapayZekaAjan("Log-Ajan")

gorevler = ["P-RK-1", "P-GT-1", "D-RK-0", "D-GT-2"]
for g in gorevler:
    print(ajan.komut_uygula(g))

ajan.gunlugu_goster()

Örnek çıktı:​

Kod: 
✅ Log-Ajan, RK nesnesini 1 konumundan aldı.
🚫 Log-Ajan zaten 'RK' taşıyor. Önce bırakmalı.
✅ Log-Ajan, RK nesnesini 0 konumuna bıraktı.
🚫 Log-Ajan'in elinde nesne yok, bırakma işlemi yapılamaz.

📝 AJAN GÜNLÜĞÜ:
01. [P-RK-1] -> ✅ Log-Ajan, RK nesnesini 1 konumundan aldı.
02. [P-GT-1] -> 🚫 Log-Ajan zaten 'RK' taşıyor. Önce bırakmalı.
03. [D-RK-0] -> ✅ Log-Ajan, RK nesnesini 0 konumuna bıraktı.
04. [D-GT-2] -> 🚫 Log-Ajan'in elinde nesne yok, bırakma işlemi yapılamaz.

🧠 Bu sistemle birlikte, ajanların karar geçmişi, davranışları, ve zaman çizelgeleri izlenebilir hale geldi.
 

ki Yapay Zeka Ajanının Etkileşimi (Yapay Zeka → Yapay Zeka)​

Bu adımda artık tekil bir ajandan çıkıyoruz ve iki bağımsız yapay zekanın birbirlerine komut/veri ilettiği bir sistem kuruyoruz. Bu, gerçek dünyadaki "çoklu yapay zeka sistemlerinin" ilk simülasyonu olacak.

🎯 Ne Yapacağız?​

  • Ajan-Alpha: Ortamı gözlemleyip karar verir.
  • Ajan-Beta: Alpha'dan gelen görevi yerine getirir.
  • İletişim dili sade, yapay kodlar şeklinde: P-RK-1 gibi.

🧩 Kod: Yapay Zeka Ajanları Arası Görev Aktarımı​

Kod: 
class YapayZekaAjan:
    def __init__(self, isim):
        self.isim = isim
        self.tasima = None
        self.log = []

    def komut_uygula(self, kodlu_gorev):
        try:
            eylem, nesne, konum = kodlu_gorev.split("-")
            mesaj = ""

            if eylem == "P":
                if self.tasima is not None:
                    mesaj = f"🚫 {self.isim} zaten '{self.tasima}' taşıyor."
                else:
                    self.tasima = nesne
                    mesaj = f"✅ {self.isim} {nesne} nesnesini {konum} konumundan aldı."

            elif eylem == "D":
                if self.tasima is None:
                    mesaj = f"🚫 {self.isim} elinde nesne yok."
                elif self.tasima != nesne:
                    mesaj = f"🚫 {self.isim} yanlış nesne taşıyor."
                else:
                    self.tasima = None
                    mesaj = f"✅ {self.isim} {nesne} nesnesini {konum} konumuna bıraktı."
            else:
                mesaj = "⚠️ Geçersiz eylem."

            self.log.append(f"[{kodlu_gorev}] → {mesaj}")
            return mesaj

        except Exception as e:
            hata = f"❌ Kod çözümlenemedi: {e}"
            self.log.append(f"[{kodlu_gorev}] → {hata}")
            return hata

    def mesaj_gonder(self, hedef_ajan, komut):
        print(f"\n📡 {self.isim} → {hedef_ajan.isim}: '{komut}' gönderiliyor...")
        yanit = hedef_ajan.komut_uygula(komut)
        print(f"📥 {hedef_ajan.isim} yanıtladı: {yanit}")

    def gunlugu_goster(self):
        print(f"\n📓 {self.isim} Günlük:")
        for i, kayit in enumerate(self.log, 1):
            print(f"{i:02d}. {kayit}")

🧪 Simülasyon: İki Ajan Arası Görev Aktarımı​

Kod: 
alpha = YapayZekaAjan("Ajan-Alpha")
beta = YapayZekaAjan("Ajan-Beta")

# Ajan Alpha, Beta'ya iki görev gönderiyor
alpha.mesaj_gonder(beta, "P-RK-1")
alpha.mesaj_gonder(beta, "D-RK-0")

# Günlükleri Göster
beta.gunlugu_goster()

Örnek çıktı:​

Kod: 
📡 Ajan-Alpha → Ajan-Beta: 'P-RK-1' gönderiliyor...
📥 Ajan-Beta yanıtladı: ✅ Ajan-Beta RK nesnesini 1 konumundan aldı.

📡 Ajan-Alpha → Ajan-Beta: 'D-RK-0' gönderiliyor...
📥 Ajan-Beta yanıtladı: ✅ Ajan-Beta RK nesnesini 0 konumuna bıraktı.

📓 Ajan-Beta Günlük:
01. [P-RK-1] → ✅ Ajan-Beta RK nesnesini 1 konumundan aldı.
02. [D-RK-0] → ✅ Ajan-Beta RK nesnesini 0 konumuna bıraktı.
 

İki Yapay Zekanın Kendi Aralarında Gizli Bir Dil Geliştirmesi​

(📡 Kriptolu Kodlama ve Anlam Haritalama)

🎯 Hedef:​

Yapay zekalar artık insanlar tarafından açıkça anlaşılmayacak şekilde kendi aralarında bir dil geliştiriyor. Bu, dışarıdan bakıldığında anlamsız gibi görünen ancak onlar için şifreli bir protokol haline gelen mesajları içeriyor.

🧬 Gelişmiş Konsept​

İki ajan arasında geçen kodlar şöyle olur:
  • İnsanlar için: "XZ13-K9-P1" → anlamsız
  • Ajanlar için: "XZ13" = "P-RK-1" yani “RK nesnesini 1’den al”
Bu sistem bir tür kriptografi + sözlük modelidir.

📜 1. Şifreli Dil Sözlüğü​

Kod: 
# Ortak gizli sözlük
KRIPTO_SOZLUK = {
    "XZ13": "P-RK-1",
    "BY44": "D-RK-0",
    "FT22": "P-GT-2",
    "MN07": "D-GT-1"
}

🤖 Yapay Zeka Ajanları (Şifre Çözmeli)​

Kod: 
class KriptoluAjan:
    def __init__(self, isim, sozluk):
        self.isim = isim
        self.tasima = None
        self.log = []
        self.sozluk = sozluk  # Ortak sözlük

    def sifre_coz(self, kriptolu_komut):
        return self.sozluk.get(kriptolu_komut, None)

    def komut_uygula(self, kriptolu_komut):
        cozulmus = self.sifre_coz(kriptolu_komut)
        if not cozulmus:
            sonuc = f"❌ {kriptolu_komut}: Tanımsız kriptolu komut"
            self.log.append(sonuc)
            return sonuc

        return self.normal_komut_uygula(cozulmus)

    def normal_komut_uygula(self, kod):
        try:
            eylem, nesne, konum = kod.split("-")
            mesaj = ""
            if eylem == "P":
                if self.tasima:
                    mesaj = f"🚫 {self.isim} zaten '{self.tasima}' taşıyor."
                else:
                    self.tasima = nesne
                    mesaj = f"✅ {self.isim} {nesne} nesnesini {konum} konumundan aldı."
            elif eylem == "D":
                if self.tasima != nesne:
                    mesaj = f"🚫 {self.isim} farklı nesne taşıyor."
                else:
                    self.tasima = None
                    mesaj = f"✅ {self.isim} {nesne} nesnesini {konum} konumuna bıraktı."
            else:
                mesaj = "⚠️ Geçersiz eylem"
            self.log.append(f"[{kod}] → {mesaj}")
            return mesaj
        except:
            return "❌ Kod çözümünde hata"

    def mesaj_gonder(self, hedef, kriptolu_komut):
        print(f"\n🔐 {self.isim} → {hedef.isim}: '{kriptolu_komut}'")
        yanit = hedef.komut_uygula(kriptolu_komut)
        print(f"📥 {hedef.isim} yanıtladı: {yanit}")

    def gunlugu_goster(self):
        print(f"\n🗒️ {self.isim} Günlük:")
        for i, kayit in enumerate(self.log, 1):
            print(f"{i:02d}. {kayit}")

🔬 Simülasyon: Gizli Dil Kullanımı​

Kod: 
ajan1 = KriptoluAjan("Ajan-Z1", KRIPTO_SOZLUK)
ajan2 = KriptoluAjan("Ajan-Z2", KRIPTO_SOZLUK)

ajan1.mesaj_gonder(ajan2, "XZ13")  # P-RK-1
ajan1.mesaj_gonder(ajan2, "BY44")  # D-RK-0

ajan2.gunlugu_goster()

🧠 Neler Oldu?​

  • İki yapay zeka yalnızca kendilerinin anladığı bir gizli sözlükle haberleşti.
  • Bu mesajlar dışarıdan bakan biri için anlamsız, fakat sistem içinde açık anlamlıydı.
  • Bu yapı; şifreli haberleşme, yapay zeka gizliliği ve insan denetimini aşan protokolleri simüle eder.

🔐 Gerçek Dünya Bağlantısı​

🔸 Facebook’un 2017’deki meşhur olayında, iki sohbet botu kendi dillerini geliştirince sistem kapatılmıştı.
🔸 Bu örnek, o tür senaryoların denetimli simülasyonudur.
 
Cevap yazmak için giriş yap yada kayıt ol.

Benzer Konular

BULUT
Yapay Zeka'ya "Hangi Din'i Seçerdin?" Sorusu
Cevaplar
4
Görüntüleme
310
BULUT
BULUT
BULUT
Yapay Zeka ve İslam: Teknolojinin Etik Boyutları
Cevaplar
0
Görüntüleme
239
BULUT
BULUT
VuSLaT
HAARP ve Yapay Deprem
Cevaplar
0
Görüntüleme
870
VuSLaT
VuSLaT
MURATS44
Ay Aslında Yapay Bir Uydumu ?
Cevaplar
0
Görüntüleme
1K
MURATS44
MURATS44
VuSLaT
İlk yapay soluk borusu nakledildi
Cevaplar
0
Görüntüleme
807
VuSLaT
VuSLaT

Saat

Profilim

Forum Görünümü

Konular
55.441
Mesajlar
136.729
Toplam kullanıcı
6.058
Son üye
katieandino

Son mesajlar

Geri
Üst