Practical AI and eCommerce insights — recommendation engines, LLMs, EU AI Act compliance, and retail AI strategy for Irish businesses.
Computer Vision | Retail AI | Ireland
Meta Description: Computer vision in retail explained by Michael English (IMPT.io CTO). How AI try-on technology, visual search, and size prediction reduce eCommerce returns for Irish retailers.
Target Keywords: computer vision retail Ireland, AI try-on technology Ireland, reduce eCommerce returns AI, visual search retail Ireland, AI size prediction Ireland, Michael English computer vision retail
Irish eCommerce retailers face a significant profitability challenge: return rates. Online clothing returns in Ireland average 25-35%, with some retailers reporting rates as high as 50% for fashion categories. Each return costs €8-€15 to process (shipping, handling, inspection, restocking) plus significant carbon emissions.
At €10 average return cost and 30% return rate on €100M clothing eCommerce revenue: €3M annually spent processing returns. Reduce the return rate by 30% and you save €900,000 — a compelling AI investment case.
Computer vision is the primary AI technology for addressing the root cause of fashion returns: fit uncertainty and colour/appearance discrepancy between product photography and real-world appearance.
Returns data from major UK and EU fashion retailers consistently shows:
| Return Reason | Frequency |
|---|---|
| "Doesn't fit" / wrong size | 38% |
| "Looks different than expected" / colour/appearance mismatch | 23% |
| "Changed my mind" | 19% |
| "Poor quality" / defects | 12% |
| Duplicate order | 5% |
| Other | 3% |
Computer vision directly addresses the top two reasons (61% of returns):
Fit prediction models learn the relationship between body measurements and product fit outcomes using historical purchase and return data:
Training data: Order records linking customer body measurements (or proxy measurements from self-reported size/height/weight) to whether items were returned for size reasons, and which size was ultimately kept.
Model architecture: A trained classifier or regression model that predicts, for a given customer profile and product, the probability of each size fitting correctly.
Output: "Based on your measurements, we recommend size M in this style" — or more sophisticated probabilistic outputs ("Size M will fit 72% of customers with your measurements; Size L fits 23%").
True Fit:
Sizebay:
Body Measurement via Smartphone:
Fit Analytics / Snap's Fit Finder: Uses smartphone camera to take body measurements (requires user permission, privacy-sensitive)
MTailor: Mobile app that uses video-based body scanning for made-to-measure; relevant for higher-end Irish retailers
For retailers with sufficient historical data (>100,000 size-related return events), custom models can outperform commercial solutions:
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
def train_size_recommendation_model(returns_data: pd.DataFrame) -> dict:
"""
Train a model predicting correct size from customer and product features.
Input data should include:
- customer_height, customer_weight, customer_age
- customer_chest, customer_waist, customer_hips (if available)
- product_id, product_category, product_brand
- size_purchased, was_returned_for_size (target variable)
- size_kept (for customers who exchanged)
"""
# Feature engineering
returns_data['bmi'] = returns_data['customer_weight'] / (
(returns_data['customer_height'] / 100) ** 2
)
# Create multi-class target: correct_size_offset from purchased
# -1 = should have gone smaller, 0 = correct, 1 = should have gone larger
features = [
'customer_height', 'customer_weight', 'bmi', 'customer_age',
'product_category_encoded', 'product_brand_encoded',
'size_purchased_encoded'
]
# Encode categoricals
le_cat = LabelEncoder()
le_brand = LabelEncoder()
le_size = LabelEncoder()
returns_data['product_category_encoded'] = le_cat.fit_transform(
returns_data['product_category']
)
returns_data['product_brand_encoded'] = le_brand.fit_transform(
returns_data['product_brand']
)
returns_data['size_purchased_encoded'] = le_size.fit_transform(
returns_data['size_purchased']
)
X = returns_data[features].dropna()
y = returns_data.loc[X.index, 'correct_size_offset']
# Train gradient boosting classifier
model = GradientBoostingClassifier(n_estimators=200, max_depth=5, random_state=42)
# Cross-validation
cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"CV Accuracy: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")
model.fit(X, y)
return {
'model': model,
'encoders': {'category': le_cat, 'brand': le_brand, 'size': le_size},
'cv_accuracy': cv_scores.mean()
}
Virtual try-on has evolved from novelty to genuine return-reducer for specific product categories.
How it works:
Commercial solutions:
Impact data: L'Oréal reports that customers using virtual try-on are 41% more likely to purchase and return products at 6.4x lower rate than non-try-on purchasers.
Irish relevance: Brown Thomas, Arnotts, and specialist beauty retailers (Carraig Donn, McCabes Pharmacy) could deploy cosmetics try-on with relatively modest integration effort.
Virtual glasses try-on is widely deployed because:
Technology: Face mesh tracking → 3D glasses model overlay → Lighting-adjusted rendering
Clothing try-on is technically much harder:
Current state:
Practical deployment for Irish fashion retailers (2025 state-of-art):
The most accessible approach is using a model image library with diverse body types, powered by AI garment placement:
Customer selects: Height: 5'7" | Build: Athletic | Skin tone: Medium
System shows: Product on model matching customer's profile from library
AI adjusts: Lighting, draping to show realistic fit
This is less technically sophisticated than live AR but achievable with current commercial tools and significantly better than standard model photography alone.
Visual search allows customers to upload an image (from Instagram, a street photo, a competitor product) and find similar items in your catalogue.
import torch
import torchvision.models as models
import torchvision.transforms as transforms
from PIL import Image
import numpy as np
class VisualSearchEngine:
def __init__(self):
# Load pre-trained EfficientNet (strong baseline for product images)
self.model = models.efficientnet_b4(pretrained=True)
# Remove final classification layer to get feature embeddings
self.model = torch.nn.Sequential(*list(self.model.children())[:-1])
self.model.eval()
self.transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def get_embedding(self, image_path: str) -> np.ndarray:
"""Get visual feature embedding for an image."""
image = Image.open(image_path).convert('RGB')
tensor = self.transform(image).unsqueeze(0)
with torch.no_grad():
embedding = self.model(tensor)
return embedding.squeeze().numpy()
def build_catalogue_index(self, product_images: dict) -> dict:
"""Build embedding index for entire product catalogue."""
embeddings = {}
for product_id, image_path in product_images.items():
try:
embeddings[product_id] = self.get_embedding(image_path)
except Exception as e:
print(f"Error embedding {product_id}: {e}")
return embeddings
def find_similar(
self,
query_image_path: str,
catalogue_embeddings: dict,
top_k: int = 10
) -> list:
"""Find visually similar products to a query image."""
query_embedding = self.get_embedding(query_image_path)
# Compute cosine similarities
similarities = []
for product_id, embedding in catalogue_embeddings.items():
similarity = np.dot(query_embedding, embedding) / (
np.linalg.norm(query_embedding) * np.linalg.norm(embedding)
)
similarities.append((product_id, float(similarity)))
# Sort by similarity, return top-K
similarities.sort(key=lambda x: x[1], reverse=True)
return similarities[:top_k]
Fine-tuning for fashion: The base EfficientNet model above is a good starting point. Fine-tuning on the DeepFashion2 dataset (800K clothing images with category labels) dramatically improves fashion-specific visual search quality.
Commercial alternatives:
For Irish retailers with private label manufacturing, or fresh/perishable goods operations, computer vision defect detection reduces quality failures that would otherwise result in returns.
import cv2
import numpy as np
from ultralytics import YOLO
def detect_textile_defects(image_path: str, model_path: str) -> dict:
"""
Detect defects in textile images using a fine-tuned YOLO model.
The YOLO model should be fine-tuned on labelled textile defect images:
- hole
- stain
- colour_variation
- thread_pull
- weave_irregularity
"""
model = YOLO(model_path) # Load fine-tuned model
results = model(image_path, conf=0.4) # Confidence threshold 0.4
defects = []
for result in results:
for box in result.boxes:
defects.append({
'class': result.names[int(box.cls)],
'confidence': float(box.conf),
'location': box.xyxy[0].tolist() # [x1, y1, x2, y2]
})
return {
'has_defects': len(defects) > 0,
'defects': defects,
'defect_count': len(defects),
'recommendation': 'reject' if len(defects) > 0 else 'pass'
}
| Application | Investment | Return | Payback Period |
|---|---|---|---|
| Fit recommendation (True Fit) | €20K-€60K/year | €200-600K (at 20% return reduction on €10M fashion GMV) | 1-4 months |
| Visual search | €30K setup + €15K/year | €50-150K (from improved discovery) | 3-12 months |
| Cosmetics try-on | €10K integration + €5K/year | €30-80K (conversion lift) | 2-6 months |
| Defect detection | €50K development | €100-300K (reduced defect returns, lower QC labour) | 3-6 months |
Computer vision is transitioning from luxury retail AI to mainstream eCommerce infrastructure. For Irish retailers suffering 25-35% return rates, the business case for fit prediction alone is compelling — returns that cost €8-15 each to process, reduced by 20-30%, often generate €200K-€1M annual savings for medium-sized fashion retailers.
The entry point is commercial fit prediction tools (True Fit, Sizebay) requiring minimal engineering effort. From there, visual search and virtual try-on extensions provide additional conversion and retention benefits.
The retailers investing in computer vision now will have the operational data and model training advantage that compounds over time — each additional return-reason data point makes the models more accurate, creating a virtuous cycle of improvement.
Michael English is Co-Founder & CTO of IMPT.io. He writes on AI infrastructure for Irish and EU businesses. Based in Clonmel, Co. Tipperary, Ireland.
Keywords: computer vision retail Ireland, AI try-on reduce returns Ireland, visual search retail Ireland, fit prediction eCommerce Ireland, reduce fashion returns AI, AI quality control retail, Michael English computer vision retail Ireland