Upload 24 files

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_10.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_100.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_20.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_30.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_40.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_50.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_60.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_70.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_80.png filter=lfs diff=lfs merge=lfs -text
+7gen_epoch_90.png filter=lfs diff=lfs merge=lfs -text

7gen.py

@@ -0,0 +1,184 @@
+# 7Gen - MNIST için Gelişmiş Üretici Model
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+import numpy as np
+from tqdm import tqdm
+import os
+
+print("🚀 7Gen - Gelişmiş MNIST Üretici Sistemi 🚀")
+
+# Cihaz ayarları
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f'Kullanılan cihaz: {device}')
+
+# Hiperparametreler
+batch_size = 64
+latent_dim = 100
+num_classes = 10
+num_epochs = 100
+lr = 0.0002
+
+# Veri yükleme
+transform = transforms.Compose([
+    transforms.ToTensor(),  # Burayı düzelttim
+    transforms.Normalize([0.5], [0.5])
+])
+
+dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
+dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+# Generator modeli
+class Generator(nn.Module):
+    def __init__(self):
+        super(Generator, self).__init__()
+        
+        self.label_emb = nn.Embedding(num_classes, num_classes)
+        
+        self.model = nn.Sequential(
+            nn.Linear(latent_dim + num_classes, 256),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(256),
+            
+            nn.Linear(256, 512),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(512),
+            
+            nn.Linear(512, 1024),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(1024),
+            
+            nn.Linear(1024, 784),
+            nn.Tanh()
+        )
+    
+    def forward(self, noise, labels):
+        label_embedding = self.label_emb(labels)
+        gen_input = torch.cat((noise, label_embedding), -1)
+        img = self.model(gen_input)
+        img = img.view(img.size(0), 1, 28, 28)
+        return img
+
+# Discriminator modeli
+class Discriminator(nn.Module):
+    def __init__(self):
+        super(Discriminator, self).__init__()
+        
+        self.label_emb = nn.Embedding(num_classes, num_classes)
+        
+        self.model = nn.Sequential(
+            nn.Linear(784 + num_classes, 512),
+            nn.LeakyReLU(0.2),
+            nn.Dropout(0.3),
+            
+            nn.Linear(512, 256),
+            nn.LeakyReLU(0.2),
+            nn.Dropout(0.3),
+            
+            nn.Linear(256, 1),
+            nn.Sigmoid()
+        )
+    
+    def forward(self, img, labels):
+        img_flat = img.view(img.size(0), -1)
+        label_embedding = self.label_emb(labels)
+        d_input = torch.cat((img_flat, label_embedding), -1)
+        validity = self.model(d_input)
+        return validity
+
+# Model oluşturma
+generator = Generator().to(device)
+discriminator = Discriminator().to(device)
+
+# Loss ve optimizer
+adversarial_loss = nn.BCELoss()
+optimizer_G = optim.Adam(generator.parameters(), lr=lr)
+optimizer_D = optim.Adam(discriminator.parameters(), lr=lr)
+
+# Klasör oluştur
+os.makedirs('generated_images', exist_ok=True)
+
+# Eğitim
+print("\n🔥 7Gen Eğitimi Başlıyor...")
+
+for epoch in range(num_epochs):
+    for i, (imgs, labels) in enumerate(tqdm(dataloader, desc=f"Epoch {epoch+1}/{num_epochs}")):
+        imgs = imgs.to(device)
+        labels = labels.to(device)
+        batch_size = imgs.size(0)
+        
+        # Ground truth'lar
+        valid = torch.ones(batch_size, 1).to(device)
+        fake = torch.zeros(batch_size, 1).to(device)
+        
+        # Generator eğitimi
+        optimizer_G.zero_grad()
+        z = torch.randn(batch_size, latent_dim).to(device)
+        gen_labels = torch.randint(0, num_classes, (batch_size,)).to(device)
+        gen_imgs = generator(z, gen_labels)
+        
+        g_loss = adversarial_loss(discriminator(gen_imgs, gen_labels), valid)
+        g_loss.backward()
+        optimizer_G.step()
+        
+        # Discriminator eğitimi
+        optimizer_D.zero_grad()
+        real_loss = adversarial_loss(discriminator(imgs, labels), valid)
+        fake_loss = adversarial_loss(discriminator(gen_imgs.detach(), gen_labels), fake)
+        d_loss = (real_loss + fake_loss) / 2
+        
+        d_loss.backward()
+        optimizer_D.step()
+    
+    print(f"Epoch {epoch+1}/{num_epochs} - D loss: {d_loss:.4f}, G loss: {g_loss:.4f}")
+    
+    # Her 10 epoch'ta örnek üret
+    if (epoch + 1) % 10 == 0:
+        with torch.no_grad():
+            z = torch.randn(100, latent_dim).to(device)
+            labels = torch.tensor([i for i in range(10) for _ in range(10)]).to(device)
+            gen_imgs = generator(z, labels)
+            gen_imgs = (gen_imgs + 1) / 2
+            
+            fig, axes = plt.subplots(10, 10, figsize=(10, 10))
+            for i in range(10):
+                for j in range(10):
+                    idx = i * 10 + j
+                    axes[i, j].imshow(gen_imgs[idx][0].cpu().numpy(), cmap='gray')
+                    axes[i, j].axis('off')
+            plt.savefig(f'generated_images/7gen_epoch_{epoch+1}.png')
+            plt.close()
+
+# Model kaydetme
+os.makedirs('models', exist_ok=True)
+torch.save(generator.state_dict(), 'models/7gen_generator.pth')
+torch.save(discriminator.state_dict(), 'models/7gen_discriminator.pth')
+
+print("\n✅ 7Gen eğitimi tamamlandı!")
+
+# Kullanım örneği
+def generate_digit(digit, num_samples=5):
+    generator.eval()
+    with torch.no_grad():
+        z = torch.randn(num_samples, latent_dim).to(device)
+        labels = torch.full((num_samples,), digit).to(device)
+        gen_imgs = generator(z, labels)
+        gen_imgs = (gen_imgs + 1) / 2
+        
+        plt.figure(figsize=(10, 2))
+        for i in range(num_samples):
+            plt.subplot(1, num_samples, i+1)
+            plt.imshow(gen_imgs[i][0].cpu().numpy(), cmap='gray')
+            plt.axis('off')
+        plt.savefig(f'generated_images/digit_{digit}_samples.png')
+        plt.show()
+
+# Test et
+print("\n🎯 Test örnekleri üretiliyor...")
+for digit in range(10):
+    generate_digit(digit, num_samples=5)
+
+print("\n🎉 7Gen hazır! generated_images klasörüne bak.")

7gen_discriminator.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8214e331ef016153c1afdfbf6538a0936523c3a5acb5a0435da4ec1d1ca0a52
+size 2158141

7gen_generator.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0eb28f1505b52f57de9c68bec28935750a1a14cb6dfe7c1e0b04293d301f5082
+size 5992786

7gen_inference.py

@@ -0,0 +1,177 @@
+# 7Gen Inference - Rakam Üretme Arayüzü
+import torch
+import torch.nn as nn
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+import os
+
+# Model yapısı (eğitimde kullandığımız ile aynı olmalı)
+class Generator(nn.Module):
+    def __init__(self):
+        super(Generator, self).__init__()
+        
+        self.label_emb = nn.Embedding(10, 10)
+        
+        self.model = nn.Sequential(
+            nn.Linear(100 + 10, 256),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(256),
+            
+            nn.Linear(256, 512),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(512),
+            
+            nn.Linear(512, 1024),
+            nn.LeakyReLU(0.2),
+            nn.BatchNorm1d(1024),
+            
+            nn.Linear(1024, 784),
+            nn.Tanh()
+        )
+    
+    def forward(self, noise, labels):
+        label_embedding = self.label_emb(labels)
+        gen_input = torch.cat((noise, label_embedding), -1)
+        img = self.model(gen_input)
+        img = img.view(img.size(0), 1, 28, 28)
+        return img
+
+# 7Gen sınıfı
+class SevenGenInference:
+    def __init__(self, model_path='models/7gen_generator.pth'):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.latent_dim = 100
+        
+        # Modeli yükle
+        self.generator = Generator().to(self.device)
+        self.generator.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.generator.eval()
+        
+        print(f"🚀 7Gen yüklendi! Cihaz: {self.device}")
+    
+    def generate_digit(self, digit, count=5):
+        """Belirli bir rakamdan istenen sayıda üret"""
+        with torch.no_grad():
+            z = torch.randn(count, self.latent_dim).to(self.device)
+            labels = torch.full((count,), digit).to(self.device)
+            
+            images = self.generator(z, labels)
+            images = (images + 1) / 2  # [-1,1] -> [0,1]
+            
+            return images.cpu()
+    
+    def visualize_digits(self, digit, count=5, save_path=None):
+        """Üretilen rakamları görselleştir"""
+        images = self.generate_digit(digit, count)
+        
+        fig, axes = plt.subplots(1, count, figsize=(2*count, 2))
+        if count == 1:
+            axes = [axes]
+            
+        for i, ax in enumerate(axes):
+            ax.imshow(images[i][0], cmap='gray')
+            ax.axis('off')
+            ax.set_title(f'Digit: {digit}')
+        
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            print(f"💾 Görsel kaydedildi: {save_path}")
+        
+        plt.show()
+    
+    def generate_grid(self, samples_per_digit=10, save_path=None):
+        """Her rakamdan örneklerle 10x10 grid oluştur"""
+        all_images = []
+        
+        for digit in range(10):
+            images = self.generate_digit(digit, samples_per_digit)
+            all_images.append(images)
+        
+        all_images = torch.cat(all_images, dim=0)
+        
+        fig, axes = plt.subplots(10, samples_per_digit, figsize=(15, 15))
+        
+        for i in range(10):
+            for j in range(samples_per_digit):
+                idx = i * samples_per_digit + j
+                axes[i, j].imshow(all_images[idx][0], cmap='gray')
+                axes[i, j].axis('off')
+                
+                if j == 0:
+                    axes[i, j].set_ylabel(f'{i}', rotation=0, size=20, labelpad=20)
+        
+        plt.suptitle('7Gen - Üretilen Rakamlar', size=20)
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            print(f"💾 Grid kaydedildi: {save_path}")
+        
+        plt.show()
+    
+    def save_as_png(self, digit, count=1, output_dir='output'):
+        """Tekil PNG dosyaları olarak kaydet"""
+        os.makedirs(output_dir, exist_ok=True)
+        
+        images = self.generate_digit(digit, count)
+        
+        for i in range(count):
+            img = images[i][0].numpy()
+            img = (img * 255).astype(np.uint8)
+            
+            pil_img = Image.fromarray(img)
+            filename = f"{output_dir}/digit_{digit}_{i+1}.png"
+            pil_img.save(filename)
+            
+            print(f"💾 Kaydedildi: {filename}")
+    
+    def interactive_generate(self):
+        """İnteraktif kullanım"""
+        print("\n🎮 7Gen İnteraktif Mod")
+        print("Çıkmak için 'q' yazın")
+        
+        while True:
+            try:
+                digit_input = input("\nHangi rakamı üretmek istersin? (0-9): ")
+                
+                if digit_input.lower() == 'q':
+                    print("👋 Görüşürüz!")
+                    break
+                
+                digit = int(digit_input)
+                if 0 <= digit <= 9:
+                    count = int(input("Kaç tane üreteyim? (1-20): "))
+                    if 1 <= count <= 20:
+                        self.visualize_digits(digit, count)
+                    else:
+                        print("❌ 1-20 arası bir sayı gir!")
+                else:
+                    print("❌ 0-9 arası bir rakam gir!")
+                    
+            except ValueError:
+                print("❌ Geçerli bir sayı gir!")
+            except KeyboardInterrupt:
+                print("\n👋 Görüşürüz!")
+                break
+
+# Ana kullanım
+if __name__ == "__main__":
+    # 7Gen'i başlat
+    seven_gen = SevenGenInference()
+    
+    # Örnekler
+    print("\n📝 Örnek kullanımlar:")
+    print("1. Tekil rakam üret")
+    seven_gen.visualize_digits(digit=7, count=5)
+    
+    print("\n2. Grid oluştur")
+    seven_gen.generate_grid(samples_per_digit=10, save_path='7gen_showcase.png')
+    
+    print("\n3. PNG olarak kaydet")
+    seven_gen.save_as_png(digit=5, count=3, output_dir='output')
+    
+    print("\n4. İnteraktif mod")
+    seven_gen.interactive_generate()