Upload 5 files

app.py

@@ -0,0 +1,93 @@
+import streamlit as st
+import torch
+import numpy as np
+from PIL import Image
+import torchvision.transforms as T
+from model import load_generator
+
+st.set_page_config(
+    page_title="Summer ↔ Winter CycleGAN",
+    page_icon="🏔️",
+    layout="centered",
+)
+
+st.title("🏔️ Summer ↔ Winter Translation")
+st.markdown(
+    "Upload a landscape photo and convert it between **summer** and **winter** "
+    "using a CycleGAN trained on Yosemite & Alpine datasets."
+)
+
+@st.cache_resource
+def get_generators():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    gen_a2b = load_generator("gen_a2b_fp16.pth", device)  # лето → зима
+    gen_b2a = load_generator("gen_b2a_fp16.pth", device)  # зима → лето
+    return gen_a2b, gen_b2a, device
+
+with st.spinner("Loading model weights..."):
+    gen_a2b, gen_b2a, device = get_generators()
+
+st.success(f"Model loaded on **{device}**", icon="✅")
+
+MEAN = (0.5, 0.5, 0.5)
+STD  = (0.5, 0.5, 0.5)
+
+to_tensor = T.Compose([
+    T.Resize((256, 256)),
+    T.ToTensor(),
+    T.Normalize(MEAN, STD),
+])
+
+def to_pil(tensor):
+    img = tensor.squeeze(0).cpu().float()
+    for i, (m, s) in enumerate(zip(MEAN, STD)):
+        img[i] = img[i] * s + m
+    img = torch.clamp(img, 0, 1)
+    return T.ToPILImage()(img)
+
+direction = st.radio(
+    "Translation direction",
+    ["☀️ Summer → ❄️ Winter", "❄️ Winter → ☀️ Summer"],
+    horizontal=True,
+)
+
+uploaded = st.file_uploader(
+    "Upload your landscape photo (JPG / PNG)",
+    type=["jpg", "jpeg", "png"],
+)
+
+if uploaded is not None:
+    input_img = Image.open(uploaded).convert("RGB")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.subheader("Input")
+        st.image(input_img, use_container_width=True)
+
+    with st.spinner("Translating..."):
+        tensor = to_tensor(input_img).unsqueeze(0).to(device)
+        generator = gen_a2b if "Summer" in direction.split("→")[0] else gen_b2a
+        with torch.no_grad():
+            output_tensor = generator(tensor)
+        output_img = to_pil(output_tensor)
+
+    with col2:
+        st.subheader("Output")
+        st.image(output_img, use_container_width=True)
+
+    from io import BytesIO
+    buf = BytesIO()
+    output_img.save(buf, format="PNG")
+    st.download_button(
+        label="⬇️ Download result",
+        data=buf.getvalue(),
+        file_name="translated.png",
+        mime="image/png",
+    )
+
+st.markdown("---")
+st.markdown(
+    "**Model:** CycleGAN Generator (ResNet-6 blocks, 64 channels) · "
+    "**Training data:** Yosemite summer2winter · "
+    "**Test data:** Alpine landscapes (Unsplash) · "
+)

gen_a2b_fp16.pth

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

gen_b2a_fp16.pth

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

model.py

@@ -0,0 +1,69 @@
+import torch
+import torch.nn as nn
+ 
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(channels, channels, 3),
+            nn.InstanceNorm2d(channels),
+            nn.ReLU(inplace=True),
+            nn.ReflectionPad2d(1),
+            nn.Conv2d(channels, channels, 3),
+            nn.InstanceNorm2d(channels),
+        )
+ 
+    def forward(self, x):
+        return x + self.block(x)
+ 
+class ResNetGenerator(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3, n_filters=64, n_res_blocks=6):
+        super().__init__()
+        model = [
+            nn.ReflectionPad2d(3),
+            nn.Conv2d(in_channels, n_filters, 7),
+            nn.InstanceNorm2d(n_filters),
+            nn.ReLU(inplace=True),
+ 
+            nn.Conv2d(n_filters, n_filters * 2, 3, stride=2, padding=1),
+            nn.InstanceNorm2d(n_filters * 2),
+            nn.ReLU(inplace=True),
+ 
+            nn.Conv2d(n_filters * 2, n_filters * 4, 3, stride=2, padding=1),
+            nn.InstanceNorm2d(n_filters * 4),
+            nn.ReLU(inplace=True),
+        ]
+ 
+        for _ in range(n_res_blocks):
+            model.append(ResidualBlock(n_filters * 4))
+ 
+        model += [
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),
+            nn.Conv2d(n_filters * 4, n_filters * 2, 3, padding=1),
+            nn.InstanceNorm2d(n_filters * 2),
+            nn.ReLU(inplace=True),
+ 
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False),
+            nn.Conv2d(n_filters * 2, n_filters, 3, padding=1),
+            nn.InstanceNorm2d(n_filters),
+            nn.ReLU(inplace=True),
+ 
+            nn.ReflectionPad2d(3),
+            nn.Conv2d(n_filters, out_channels, 7),
+            nn.Tanh()
+        ]
+ 
+        self.model = nn.Sequential(*model)
+ 
+    def forward(self, x):
+        return self.model(x)
+ 
+@torch.no_grad()
+def load_generator(path, device="cpu"):
+    gen = ResNetGenerator()
+    state_dict = torch.load(path, map_location="cpu", weights_only=True)
+    state_dict = {k: v.float() for k, v in state_dict.items()}
+    gen.load_state_dict(state_dict)
+    gen.to(device).eval()
+    return gen

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+streamlit>=1.32.0
+torch>=2.0.0
+torchvision>=0.15.0
+Pillow>=9.0.0
+numpy>=1.24.0