Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+dataset.zip
+dataset/
+*.png

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -1,12 +1,6 @@
 ---
-title: Git Config -global Credential.helper Store
-emoji: 🏢
-colorFrom: yellow
-colorTo: indigo
+title: git_config_-global_credential.helper_store
+app_file: client.py
 sdk: gradio
 sdk_version: 5.13.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

client.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+
+
+class AnimeCNN(nn.Module):
+    def __init__(self, num_classes=4):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 32, 3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(0.25),
+            
+            nn.Conv2d(32, 64, 3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(0.25)
+        )
+        
+        self.classifier = nn.Sequential(
+            nn.Linear(64*16*16, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
+model = AnimeCNN()
+model.load_state_dict(torch.load('model.pth', map_location=device, weights_only=True))
+model.eval()
+
+classes = ["usada_pekora", "aisaka_taiga", "megumin", "minato_aqua"]
+
+transform = transforms.Compose([
+    transforms.Resize((64, 64)),
+    transforms.ToTensor(),
+    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+])
+
+def predict(image):
+    image = transform(image).unsqueeze(0)
+    
+    with torch.no_grad():
+        outputs = model(image)
+        probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
+    
+    confidences = {classes[i]: float(probabilities[i]) for i in range(4)}
+    return confidences
+
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="入力画像"),
+    outputs=gr.Label(num_top_classes=4, label="予測結果"),
+    title="アニメキャラクター分類器",
+    description="うさだぺこら・逢坂大河・めぐみん・湊あくあの画像を分類します。画像をアップロードしてください。",
+    examples=[
+        ["examples/usada_pekora.jpg"],
+        ["examples/aisaka_taiga.jpg"],
+        ["examples/megumin.jpg"],
+        ["examples/minato_aqua.jpg"]
+    ],
+)
+
+interface.launch(server_name="0.0.0.0", server_port=7860, share=True)

model.pth

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

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "cnn-anime-classification"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gradio>=5.13.0",
+    "matplotlib>=3.10.0",
+    "numpy>=2.2.2",
+    "pillow>=11.1.0",
+    "scikit-learn>=1.6.1",
+]

requirements.txt

@@ -0,0 +1,69 @@
+
+aiofiles==23.2.1
+annotated-types==0.7.0
+anyio==4.8.0
+certifi==2024.12.14
+charset-normalizer==3.4.1
+click==8.1.8
+contourpy==1.3.1
+cycler==0.12.1
+fastapi==0.115.7
+ffmpy==0.5.0
+filelock==3.17.0
+fonttools==4.55.4
+fsspec==2024.12.0
+gradio==5.13.0
+gradio-client==1.6.0
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.27.1
+idna==3.10
+jinja2==3.1.5
+joblib==1.4.2
+kiwisolver==1.4.8
+markdown-it-py==3.0.0
+markupsafe==2.1.5
+matplotlib==3.10.0
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.2.1
+numpy==2.2.2
+orjson==3.10.15
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+pydantic==2.10.5
+pydantic-core==2.27.2
+pydub==0.25.1
+pygments==2.19.1
+pyparsing==3.2.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2024.2
+pyyaml==6.0.2
+requests==2.32.3
+rich==13.9.4
+ruff==0.9.2
+safehttpx==0.1.6
+scikit-learn==1.6.1
+scipy==1.15.1
+semantic-version==2.10.0
+setuptools==70.0.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.45.2
+sympy==1.13.1
+threadpoolctl==3.5.0
+tomlkit==0.13.2
+torch==2.5.1
+torchvision==0.20.1
+tqdm==4.67.1
+typer==0.15.1
+typing-extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+uvicorn==0.34.0
+websockets==14.2
+

train.py

@@ -0,0 +1,186 @@
+import os
+import numpy as np
+from PIL import Image
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader, Dataset, SubsetRandomSampler
+from sklearn.model_selection import train_test_split
+
+def load_dataset(folder_path, max_images_per_class=60, allowed_classes=None):
+    dataset = {}
+    
+    class_names = [
+        name for name in os.listdir(folder_path)
+        if os.path.isdir(os.path.join(folder_path, name)) and 
+        (allowed_classes is None or name in allowed_classes)
+    ]
+    
+    if allowed_classes:
+        class_names = [cls for cls in allowed_classes if cls in class_names]
+    
+    for class_name in class_names:
+        class_path = os.path.join(folder_path, class_name)
+        images = []
+        
+        for file_name in os.listdir(class_path):
+            if len(images) >= max_images_per_class:
+                break
+            if file_name.lower().endswith(('.png', '.jpg', '.jpeg')):
+                img_path = os.path.join(class_path, file_name)
+                img = Image.open(img_path).convert('RGB')
+                images.append(np.array(img))
+        
+        dataset[class_name] = images
+    
+    return dataset
+
+class AnimeDataset(Dataset):
+    def __init__(self, images, transform=None, classes=None):
+        self.images = []
+        self.labels = []
+        self.transform = transform
+        self.classes = classes or list(images.keys())
+        
+        for label, class_name in enumerate(self.classes):
+            class_images = images.get(class_name, [])
+            self.images.extend(class_images)
+            self.labels.extend([label] * len(class_images))
+
+    def __len__(self):
+        return len(self.images)
+    
+    def __getitem__(self, idx):
+        image = Image.fromarray(self.images[idx])
+        label = self.labels[idx]
+        
+        if self.transform:
+            image = self.transform(image)
+            
+        return image, label
+
+class AnimeCNN(nn.Module):
+    def __init__(self, num_classes=4):
+        super().__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 32, 3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(0.25),
+            
+            nn.Conv2d(32, 64, 3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),
+            nn.Dropout(0.25)
+        )
+        
+        self.classifier = nn.Sequential(
+            nn.Linear(64*16*16, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+def main():
+    SEED = 42
+    CLASSES = ["usada_pekora", "aisaka_taiga", "megumin", "minato_aqua"]
+    IMG_SIZE = 64
+    BATCH_SIZE = 16 
+    NUM_EPOCHS = 15  
+    
+    torch.manual_seed(SEED)
+    np.random.seed(SEED)
+    
+    dataset = load_dataset("dataset", allowed_classes=CLASSES)
+    
+    transform = transforms.Compose([
+        transforms.Resize((IMG_SIZE, IMG_SIZE)),
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+    ])
+    
+    anime_dataset = AnimeDataset(dataset, transform=transform, classes=CLASSES)
+    
+    indices = list(range(len(anime_dataset)))
+    train_indices, val_indices = train_test_split(
+        indices, 
+        test_size=0.2,
+        random_state=SEED,
+        stratify=anime_dataset.labels
+    )
+    
+    train_loader = DataLoader(
+        anime_dataset,
+        batch_size=BATCH_SIZE,
+        sampler=SubsetRandomSampler(train_indices),
+        pin_memory=True
+    )
+    
+    val_loader = DataLoader(
+        anime_dataset,
+        batch_size=40,  
+        sampler=SubsetRandomSampler(val_indices),
+        pin_memory=True
+    )
+    
+    model = AnimeCNN(num_classes=len(CLASSES))
+    
+    optimizer = optim.Adam(
+        model.parameters(), 
+        lr=0.001,
+        weight_decay=1e-4
+    )
+    
+    criterion = nn.CrossEntropyLoss()
+    
+    for epoch in range(NUM_EPOCHS):
+        model.train()
+        train_loss = 0.0
+        
+        for inputs, labels in train_loader:
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            train_loss += loss.item()
+        
+        model.eval()
+        val_loss = 0.0
+        correct = 0
+        total = 0
+        
+        with torch.no_grad():
+            for inputs, labels in val_loader:
+                outputs = model(inputs)
+                loss = criterion(outputs, labels)
+                val_loss += loss.item()
+                
+                _, predicted = torch.max(outputs, 1)
+                total += labels.size(0)
+                correct += (predicted == labels).sum().item()
+        
+        train_loss /= len(train_loader)
+        val_loss /= len(val_loader)
+        val_acc = 100 * correct / total
+        
+        print(f"Epoch {epoch+1:02d} | "
+              f"Train Loss: {train_loss:.4f} | "
+              f"Val Loss: {val_loss:.4f} | "
+              f"Accuracy: {val_acc:.2f}%")
+
+    print("Model saved as model.pth")
+    torch.save(model.state_dict(), "model.pth")
+
+if __name__ == "__main__":
+    main()