frist

Dockerfile

@@ -1,20 +1,36 @@
-FROM python:3.13.5-slim
+FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04
 
+# Set working directory
 WORKDIR /app
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
+    python3.10 \
+    python3-pip \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Create symlink for python
+RUN ln -s /usr/bin/python3.10 /usr/bin/python
 
-RUN pip3 install -r requirements.txt
+# Upgrade pip
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
 
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app
+COPY app.py .
+
+# Expose streamlit port
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV CUDA_VISIBLE_DEVICES=0
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

docker-compose.yml

@@ -0,0 +1,18 @@
+version: '3.8'
+
+services:
+  qwen3-app:
+    build: .
+    container_name: qwen3-vl-app
+    runtime: nvidia
+    environment:
+      - NVIDIA_VISIBLE_DEVICES=all
+      - NVIDIA_DRIVER_CAPABILITIES=compute,utility
+      - CUDA_VISIBLE_DEVICES=0
+    ports:
+      - "8501:8501"
+    volumes:
+      - ./models:/root/.cache/huggingface/hub:ro
+    shm_size: '16gb'
+    stdin_open: true
+    tty: true

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+torch==2.1.2 --index-url https://download.pytorch.org/whl/cu118
+torchvision==0.16.2 --index-url https://download.pytorch.org/whl/cu118
+transformers==4.45.0
+pillow==10.2.0
+streamlit==1.40.1
+accelerate==0.27.2
+peft==0.7.1
+unsloth==2024.12.16

src/streamlit_app.py

@@ -1,40 +1,120 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import torch
+from PIL import Image
+from transformers import AutoProcessor, AutoModelForVision2Seq
+import io
 
-"""
-# Welcome to Streamlit!
+st.set_page_config(page_title="Qwen3-VL-8B Inference", layout="wide")
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+@st.cache_resource
+def load_model(model_id):
+    """Load model and processor with float16 optimization"""
+    processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+    model = AutoModelForVision2Seq.from_pretrained(
+        model_id,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    return model, processor
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+def main():
+    st.title("🖼️ Qwen3-VL-8B Vision-Language Model")
+    st.markdown("Upload an image and ask questions about it or provide instructions!")
+    
+    # Model configuration
+    model_id = "reverseforward/qwenmeasurement"  # Replace with your model ID
+    
+    try:
+        model, processor = load_model(model_id)
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        st.info("Make sure your model ID is correct and you have internet access to HuggingFace Hub")
+        return
+    
+    # Create two columns for layout
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("📤 Upload Image")
+        uploaded_file = st.file_uploader("Choose an image", type=["jpg", "jpeg", "png", "webp"])
+        
+        if uploaded_file is not None:
+            image = Image.open(uploaded_file)
+            st.image(image, use_column_width=True, caption="Uploaded Image")
+        else:
+            image = None
+            st.info("Please upload an image to continue")
+    
+    with col2:
+        st.subheader("💬 Input Text")
+        text_input = st.text_area(
+            "Ask a question or provide instructions about the image:",
+            placeholder="e.g., What objects are in this image? Describe them in detail.",
+            height=150
+        )
+    
+    st.divider()
+    
+    # Generate response
+    if st.button("🚀 Generate Response", type="primary"):
+        if image is None:
+            st.warning("Please upload an image first!")
+        elif not text_input.strip():
+            st.warning("Please enter a text prompt!")
+        else:
+            with st.spinner("Processing... This may take a moment"):
+                try:
+                    # Prepare inputs
+                    messages = [
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "image", "image": image},
+                                {"type": "text", "text": text_input}
+                            ]
+                        }
+                    ]
+                    
+                    # Process with float16 for efficiency
+                    text = processor.apply_chat_template(
+                        messages,
+                        tokenize=False,
+                        add_generation_prompt=True
+                    )
+                    
+                    inputs = processor(
+                        text=text,
+                        images=[image],
+                        return_tensors="pt",
+                        padding=True
+                    )
+                    
+                    # Move to GPU and use float16
+                    inputs = {k: v.to(model.device).to(torch.float16) if v.dtype in [torch.float32, torch.float64] else v.to(model.device) for k, v in inputs.items()}
+                    
+                    # Generate
+                    with torch.no_grad():
+                        output_ids = model.generate(
+                            **inputs,
+                            max_new_tokens=1024,
+                            temperature=0.7,
+                            top_p=0.95
+                        )
+                    
+                    # Decode response
+                    response = processor.decode(
+                        output_ids[0][inputs["input_ids"].shape[1]:],
+                        skip_special_tokens=True
+                    )
+                    
+                    st.success("✅ Generation complete!")
+                    st.subheader("📝 Response")
+                    st.write(response)
+                    
+                except Exception as e:
+                    st.error(f"Error during generation: {e}")
+                    st.info("Check your model configuration and GPU memory")
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()