Apparel Design & Trend Forecasting

From Intuition to Signal

Fashion trend forecasting in traditional Indian apparel — whether Page Industries' innerwear lines, Raymond's suiting collections, or Arvind's denim brands — has operated on a combination of WGSN reports, trade show attendance, and merchant intuition. The problem is lag: a WGSN trend report published in October for the following spring season is already 6–8 months old by the time a collection reaches retail. Social commerce and fast-fashion platforms generate real-time demand signals that compress this lag to days. This chapter builds the signal extraction pipeline, the size optimisation model, and the automated pattern grading system.

Open data/social-trend-signals.json in the code panel. It contains 90 days of aggregated engagement signals from Meesho, Myntra, Instagram Reels, and Flipkart Fashion for three product categories — ethnic kurtas, formal shirts, and athleisure bottoms — including keyword frequency, SKU-level sell-through rate, colour attribute distributions, and geographic demand hotspots.

Trend Signal Architecture

Signal Sources and Their Properties

The compositing challenge: high-frequency signals (Instagram) are noisy but fast; low-frequency signals (POS) are clean but slow. A Kalman filter or exponential smoothing ensemble across tiers gives the best leading indicator.

Attribute Extraction from Image Data

When a kurta SKU on Myntra goes from 200 to 1,800 units sold in 72 hours, the important question is not "kurtas are trending" but "which attributes are driving this SKU?" — neckline style, embroidery type, colour family, sleeve length, fabric texture.

import anthropic

def extract_garment_attributes(image_url: str, client: anthropic.Anthropic) -> dict:
    """
    Extract fashion attributes from a product image using Claude's vision.
    Returns structured attribute dict for trend aggregation.
    """
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {"type": "url", "url": image_url}},
                {"type": "text", "text": """Extract fashion attributes from this apparel image.
Return JSON only with these keys:
- category: [kurta|shirt|trouser|saree|dress|other]
- colour_family: [red|blue|green|yellow|neutral|white|black|multi|printed]
- pattern: [solid|stripe|check|floral|geometric|abstract|none]
- neckline: [round|v-neck|mandarin|boat|keyhole|not_applicable]
- sleeve: [sleeveless|half|three-quarter|full]
- fabric_texture: [cotton|silk|polyester|denim|linen|blended|unknown]
- embellishment: [plain|embroidered|sequin|print|applique|none]
- fit: [slim|regular|relaxed|flared]
- occasion: [casual|festive|formal|athleisure]"""}
            ]
        }]
    )
    import json
    return json.loads(response.content[0].text)

Running this across 10,000–15,000 trending SKUs per week produces a daily attribute frequency distribution — the raw material for trend velocity analysis.

Demand Sensing with Festival and Seasonal Patterns

Indian apparel demand has sharper seasonal spikes than Western markets. The festival calendar creates predictable demand pulses that a generic time-series model misses:

A Prophet-based forecasting model (Facebook's open-source time series library) natively handles multiple seasonality and holiday regressors — the festival calendar slots in as a custom holiday list:

from prophet import Prophet
import pandas as pd

festivals = pd.DataFrame({
    "holiday": ["diwali"] * 3 + ["navratri"] * 3,
    "ds": pd.to_datetime(["2023-11-12", "2024-11-01", "2025-10-20",
                          "2023-10-15", "2024-10-03", "2025-09-22"]),
    "lower_window": [-28, -28, -28, -21, -21, -21],
    "upper_window": [3, 3, 3, 7, 7, 7],
})

model = Prophet(
    holidays=festivals,
    seasonality_mode="multiplicative",   # demand multiplies, not adds
    yearly_seasonality=True,
    weekly_seasonality=True,
    changepoint_prior_scale=0.3,         # flexible — fashion changes fast
)

Pattern Grading Automation

Pattern grading — scaling a base size pattern up and down across the size range — is a time-consuming manual task in traditional apparel production. A senior grader at a Raymond or Arvind manufacturing unit spends 3–5 hours grading a 12-piece woven shirt pattern across 5 sizes (S/M/L/XL/XXL). AI-assisted grading reduces this to 30–45 minutes of review time.

Open data/base-pattern-grades.json for a base size M shirt pattern (22 key points in 2D Cartesian space) with manual grade rules from a Bengaluru export house.

Grade Rule Learning

import numpy as np
from sklearn.linear_model import Ridge

def learn_grade_rules(pattern_points: dict[str, np.ndarray],
                      size_labels: list[str]) -> dict[str, np.ndarray]:
    """
    pattern_points: {size_label: (N, 2) array of N key points}
    size_labels: ordered list, e.g., ['XS', 'S', 'M', 'L', 'XL', 'XXL']
    Returns: {point_index: regression_coefficients} for linear interpolation/extrapolation
    """
    size_codes = {s: i - len(size_labels)//2 for i, s in enumerate(size_labels)}  # centre at M=0
    X = np.array([size_codes[s] for s in size_labels]).reshape(-1, 1)
    grade_models = {}
    base_points = pattern_points[size_labels[len(size_labels)//2]]  # base size
    for pt_idx in range(base_points.shape[0]):
        y_x = np.array([pattern_points[s][pt_idx, 0] for s in size_labels])
        y_y = np.array([pattern_points[s][pt_idx, 1] for s in size_labels])
        ridge_x = Ridge(alpha=0.1).fit(X, y_x)
        ridge_y = Ridge(alpha=0.1).fit(X, y_y)
        grade_models[pt_idx] = np.array([ridge_x.coef_[0], ridge_y.coef_[0]])
    return grade_models

The learned grade rules can be applied to new style base patterns that share the same construction category — reducing the grader's task to verifying seam allowances and checking critical fit points (armhole depth, seat, crotch length) rather than computing all 22 points from scratch.

Indian Body Measurement Optimisation

The fundamental problem: Indian garment sizing is calibrated to Western body proportion norms. The NIFT (National Institute of Fashion Technology) conducted India's first comprehensive body measurement survey (2007) covering 25,000 subjects across 6 cities. Page Industries used similar data to develop Jockey's India-specific fit blocks, which contributed to their quality reputation in the innerwear market.

Key anthropometric differences that affect grading:

Prompt: "I have body measurement data from 4,800 male respondents aged 18–45 from the NIFT 2007
survey and my own retail alteration records (3,200 tickets from Raymond EBO stores in
Delhi, Mumbai, and Hyderabad). I want to optimise my formal trouser size range — currently 28W
to 40W in 1-inch waist steps, one inseam length. Analysis shows 34% of alterations are waist
take-ins (suggesting oversized hip proportioning in my block) and 28% are hem shortening
(suggesting my one-inseam assumption is failing). Propose a revised size grid architecture
and explain the commercial trade-off between reducing SKU count and improving fit hit rate."

Virtual Try-On and Digital Fit Validation

Before physical samples are cut, 3D simulation (CLO3D, Browzwear VStitcher) allows fit validation on a parameterised avatar matched to the target body measurement profile. The integration with AI trend forecasting: the same attribute extraction model that scores trending silhouettes feeds the avatar parameter adjustments — if relaxed-fit wide-leg trousers are gaining velocity in the demand data, the avatar for fit testing adjusts accordingly.

The business case in the Indian context: Page Industries runs 450+ SKUs per season. Reducing physical sample iterations from 3–4 to 1–2 per style saves ₹800–1,200 per sample in material and production cost — across 450 SKUs, ₹2–4 crore per season in sample cost reduction.

Key Takeaways