奢侈品稀缺度定价算法，根据限量数量计算单品合理溢价区间平衡销量与档次。

奢侈品稀缺度定价算法：基于限量数量的最优溢价区间求解

一、实际应用场景描述

在时尚产业的奢侈品管理（Luxury Management） 与 限量营销（Limited Edition Marketing） 实践中，稀缺性（Scarcity） 是品牌控制价格弹性和维持品牌调性的核心杠杆。典型场景包括：

- 限量联名款：品牌与艺术家/设计师联名，全球限量500件，编号发售（如 Nike × Dior 联名球鞋）。

- 季节限定款：品牌在特定季节推出的"仅此一季"系列（如 LV 早春限定系列），季末即销毁剩余库存以保持稀缺。

- VIP 专属款：仅对品牌最高等级会员开放的"隐形产品线"（如 Hermès 的喜马拉雅铂金包等候名单制）。

- 数字稀缺（NFT/数字藏品）：品牌发行限量数字藏品（如 Nike Cryptokicks），数量恒定，二级市场可交易。

这些策略的核心商业目标是通过人为制造稀缺（Artificial Scarcity）来提升产品溢价能力（Pricing Power），同时不损害品牌长期价值。然而，品牌在实操中面临复杂的定价决策：

- 定多少量？ 限量100件 vs 1000件 vs 10000件——量太少"饥饿营销"被骂，量太多"稀缺感"荡然无存。

- 溢价定多少？ 限量款定价2999元还是4999元？定低了"对不起稀缺性"，定高了滞销又伤品牌。

- 如何平衡？ 销量和档次（Brand Equity）天然冲突——卖得多利润高但品牌调性下降，卖得少品牌高冷但收入不足覆盖成本。

本程序旨在通过构建稀缺度-溢价优化模型（Scarcity-Premium Optimization），量化"限量数量→稀缺感知→支付意愿→最优定价"的传导链条，求解给定限量数量下的最优溢价区间，辅助品牌在"销量"与"档次"之间找到帕累托最优。

二、行业痛点分析

1. "拍脑袋"定限量：品牌往往凭经验定"限量500件"，缺乏数据支撑——500件对球鞋品类是"稀缺"，对T恤品类却是"过剩"。不同品类的稀缺感知阈值完全不同。

2. 溢价与稀缺度脱节：品牌知道"限量款要贵"，但贵多少？是成本×2、×3还是×10？缺乏系统性框架将"稀缺程度"映射为"价格溢价"。

3. Veblen效应盲区：奢侈品存在凡勃伦效应（Veblen Effect）——价格越高，需求越大（因为贵本身就是购买理由）。品牌不知道"提价→需求上升"的甜蜜区间在哪里，常常提价过度导致断崖式下滑。

4. 二级市场忽视：限量款在得物、StockX等二级市场的转售溢价（Resale Premium）是稀缺度的"真实市场温度计"，但品牌几乎不将此信号纳入首发定价模型。

三、核心逻辑讲解

核心目标：构建稀缺度定价优化模型（Scarcity-Based Pricing Optimization），在给定限量数量 Q_{limit} 下，求解最大化品牌长期价值函数的最优价格 P^* 。

关键逻辑链：

限量数量 → 稀缺指数 → 品牌资产溢价 → 消费者支付意愿 → 需求曲线 → 利润函数 → 最优价格

核心假设与模型：

1. 稀缺指数（Scarcity Index, SI）

SI = \frac{D_{market}}{Q_{limit}} \cdot \ln(Q_{limit} + 1) \cdot \gamma_{category}

- D_{market} ：目标市场规模（品牌在该品类的潜在消费者总数）。

- Q_{limit} ：限量数量。

- \gamma_{category} ：品类稀缺敏感度系数（球鞋=1.5，T恤=0.6，包袋=1.2，珠宝=2.0）。

- 直觉： Q 越小、 D 越大、 \gamma 越高 → SI越大 → 越稀缺。

2. 稀缺感知与品牌资产提升

BE_{scarce} = BE_{base} \cdot (1 + \alpha \cdot \ln(1 + SI))

- BE_{base} ：品牌基准资产值。

- \alpha ：稀缺资产转化系数（奢侈品品牌约0.15-0.30）。

- S型饱和： \ln(1+SI) 保证稀缺度的边际效应递减——从100件降到50件感受强烈，从50件降到10件感受有限。

3. 支付意愿（WTP）与价格需求曲线

WTP(P, SI) = WTP_{base} \cdot (1 + \beta \cdot \ln(1 + SI)) \cdot (1 - \epsilon \cdot \frac{P - P_{base}}{P_{base}})

- 第一项：基准支付意愿。

- 第二项：稀缺溢价（稀缺度越高，愿意多付）。

- 第三项：价格弹性（凡勃伦效应下 \epsilon 可为负，即价格越高需求越大）。

- 当 \epsilon < 0 时，存在价格-需求正相关区间（凡勃伦效应）。

4. 需求函数

Q_d(P) = D_{market} \cdot \Phi\left(\frac{\ln(WTP) - \ln(P)}{\sigma}\right)

- \Phi ：标准正态累积分布函数（Logit/Probit 模型）。

- \sigma ：消费者异质性参数（越大表示消费者WTP差异越大）。

- 直觉：价格低于消费者WTP时购买，高于时放弃。

5. 利润函数与最优定价

\pi(P) = (P - C_{unit}) \cdot \min(Q_d(P), Q_{limit}) - C_{fixed}

- C_{unit} ：单位变动成本。

- C_{fixed} ：固定成本（营销、渠道等）。

- 约束： Q_d(P) \leq Q_{limit} （供不应求时以限量为上限）。

6. 品牌长期价值函数（Balanced Objective）

\max_{P} \quad V(P) = \pi(P) + \lambda \cdot BE_{scarce}(P)

- \lambda ：品牌资产权重（奢侈品品牌通常 \lambda = 0.3-0.5 ，即利润与品牌价值同等重要）。

- 当 \lambda = 0 ：纯利润最大化（可能过度透支品牌）。

- 当 \lambda 很大：纯品牌价值最大化（可能"有价无市"）。

四、代码模块化实现（Python）

# -*- coding: utf-8 -*-

"""

奢侈品稀缺度定价算法

功能：基于限量数量计算单品合理溢价区间，平衡销量与品牌档次

版本：1.0.0

作者：Fashion Tech Engineer

"""

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from scipy.optimize import minimize_scalar, brentq

from scipy.stats import norm

from dataclasses import dataclass, field

from typing import Dict, List, Tuple, Optional, Callable

import json

import matplotlib

from matplotlib.colors import LinearSegmentedColormap

matplotlib.rcParams['font.sans-serif'] = ['SimHei']

matplotlib.rcParams['axes.unicode_minus'] = False

# ==================== 配置与数据结构 ====================

@dataclass

class LuxuryPricingConfig:

"""奢侈品定价全局配置"""

# --- 市场与成本参数 ---

MARKET_DEMAND: int = 500_000 # 目标市场规模（潜在消费者数）

BASE_PRICE: float = 1999.0 # 常规款基准售价（元）

UNIT_COST: float = 600.0 # 单位变动成本（元）

FIXED_COST: float = 2_000_000 # 固定成本（营销+渠道+生产准备）

# --- 稀缺度参数 ---

LIMIT_QUANTITY: int = 500 # 限量数量

CATEGORY_GAMMA: float = 1.5 # 品类稀缺敏感度（球鞋=1.5, T恤=0.6, 包袋=1.2）

# --- 消费者参数 ---

BASE_WTP: float = 2500.0 # 基准支付意愿（元）

PRICE_ELASTICITY: float = -0.8 # 价格弹性（负值=正常品；正值=凡勃伦效应）

WTP_SIGMA: float = 0.4 # 消费者WTP异质性（标准差）

# --- 品牌资产参数 ---

BASE_BRAND_EQUITY: float = 1000.0 # 基准品牌资产值

SCARCITY_ALPHA: float = 0.20 # 稀缺→品牌资产转化系数

BRAND_WEIGHT_LAMBDA: float = 0.4 # 品牌资产在目标函数中的权重

# --- 二级市场参数 ---

RESALE_MARKUP: float = 0.30 # 二级市场平均加价率（30%）

RESALE_DATA_AVAILABLE: bool = True # 是否有二级市场数据

# --- 优化参数 ---

PRICE_LOWER_BOUND: float = 500.0 # 价格下限

PRICE_UPPER_BOUND: float = 20_000.0 # 价格上限

PREMIUM_BOUND_LOWER: float = 0.0 # 最低溢价率

PREMIUM_BOUND_UPPER: float = 5.0 # 最高溢价率（5倍基准价）

# --- 品类预设 ---

CATEGORY_PRESETS: Dict[str, Dict] = field(default_factory=lambda: {

'球鞋': {'gamma': 1.5, 'elasticity': -0.5, 'alpha': 0.25},

'T恤': {'gamma': 0.6, 'elasticity': -1.2, 'alpha': 0.10},

'包袋': {'gamma': 1.2, 'elasticity': -0.3, 'alpha': 0.20},

'珠宝': {'gamma': 2.0, 'elasticity': -0.1, 'alpha': 0.35},

'腕表': {'gamma': 1.8, 'elasticity': -0.2, 'alpha': 0.30},

})

# ==================== 稀缺指数模型 ====================

class ScarcityIndexModel:

"""稀缺指数（SI）计算引擎"""

def __init__(self, config: LuxuryPricingConfig = None):

self.config = config or LuxuryPricingConfig()

def calculate_si(self, limit_quantity: int = None,

market_demand: int = None,

gamma: float = None) -> float:

"""

计算稀缺指数

:param limit_quantity: 限量数量，默认取配置值

:param market_demand: 市场规模，默认取配置值

:param gamma: 品类敏感度，默认取配置值

:return: 稀缺指数（SI），值越大越稀缺

"""

Q = limit_quantity or self.config.LIMIT_QUANTITY

D = market_demand or self.config.MARKET_DEMAND

g = gamma or self.config.CATEGORY_GAMMA

if Q <= 0:

return float('inf')

# SI = (D/Q) * ln(Q+1) * gamma

si = (D / Q) * np.log(Q + 1) * g

return si

def calculate_brand_equity_boost(self, si: float) -> float:

"""

计算稀缺带来的品牌资产提升

:param si: 稀缺指数

:return: 提升后的品牌资产值

"""

base = self.config.BASE_BRAND_EQUITY

alpha = self.config.SCARCITY_ALPHA

return base * (1 + alpha * np.log1p(si))

def scarcity_tier(self, si: float) -> Tuple[str, int]:

"""

将稀缺指数映射为"稀缺等级"

:return: (等级名称, 建议溢价下限%, 建议溢价上限%)

"""

if si > 5000:

return ('传奇级稀缺', 200, 500)

elif si > 2000:

return ('极度稀缺', 150, 300)

elif si > 800:

return ('高度稀缺', 100, 200)

elif si > 300:

return ('中度稀缺', 50, 100)

elif si > 100:

return ('轻度稀缺', 20, 50)

else:

return ('普通限量', 0, 20)

# ==================== 需求与WTP模型 ====================

class DemandModel:

"""基于WTP的需求曲线模型"""

def __init__(self, config: LuxuryPricingConfig = None):

self.config = config or LuxuryPricingConfig()

def calculate_wtp(self, si: float, price: float) -> float:

"""

计算给定稀缺度下的消费者支付意愿

:param si: 稀缺指数

:param price: 产品定价

:return: 支付意愿（元）

"""

base_wtp = self.config.BASE_WTP

beta = self.config.SCARCITY_ALPHA

epsilon = self.config.PRICE_ELASTICITY

# WTP = base * (1 + beta * ln(1+SI)) * (1 - epsilon * (P-P_base)/P_base)

scarcity_premium = 1 + beta * np.log1p(si)

price_effect = 1 - epsilon * (price - self.config.BASE_PRICE) / self.config.BASE_PRICE

wtp = base_wtp * scarcity_premium * max(price_effect, 0.1)

return wtp

def calculate_demand(self, price: float, si: float) -> int:

"""

计算给定价格下的需求量（Probit模型）

:param price: 产品定价

:param si: 稀缺指数

:return: 需求量（人）

"""

wtp = self.calculate_wtp(si, price)

sigma = self.config.WTP_SIGMA

# Probit: Q = D * Φ((ln(WTP) - ln(P)) / sigma)

if wtp <= 0 or price <= 0:

return 0

z = (np.log(wtp) - np.log(price)) / sigma

purchase_prob = norm.cdf(z)

demand = int(self.config.MARKET_DEMAND * purchase_prob)

return demand

def demand_curve(self, si: float,

n_points: int = 50) -> Tuple[np.ndarray, np.ndarray]:

"""

生成完整需求曲线

:return: (价格数组, 需求量数组)

"""

prices = np.linspace(

self.config.PRICE_LOWER_BOUND,

self.config.PRICE_UPPER_BOUND,

n_points

)

demands = np.array([self.calculate_demand(p, si) for p in prices])

return prices, demands

# ==================== 利润与优化引擎 ====================

class ProfitOptimizer:

"""利润最大化与最优定价引擎"""

def __init__(self, config: LuxuryPricingConfig = None):

self.config = config or LuxuryPricingConfig()

self.demand_model = DemandModel(config)

self.scarcity_model = ScarcityIndexModel(config)

def calculate_profit(self, price: float, si: float) -> Dict:

"""

计算给定价格下的利润分解

:return: 利润明细字典

"""

demand = self.demand_model.calculate_demand(price, si)

# 实际销量受限于限量

actual_sales = min(demand, self.config.LIMIT_QUANTITY)

revenue = price * actual_sales

variable_cost = self.config.UNIT_COST * actual_sales

contribution = revenue - variable_cost

profit = contribution - self.config.FIXED_COST

# 品牌资产

brand_equity = self.scarcity_model.calculate_brand_equity_boost(si)

# 二级市场价格（如果存在）

resale_price = price * (1 + self.config.RESALE_MARKUP)

return {

'price': price,

'demand': demand,

'actual_sales': actual_sales,

'sell_out_rate': actual_sales / self.config.LIMIT_QUANTITY,

'revenue': revenue,

'variable_cost': variable_cost,

'contribution': contribution,

'profit': profit,

'brand_equity': brand_equity,

'resale_price': resale_price,

'premium_rate': (price - self.config.BASE_PRICE) / self.config.BASE_PRICE,

'is_scarce': demand > actual_sales # 供不应求

}

def objective_function(self, price: float, si: float) -> float:

"""

综合目标函数：利润 + λ * 品牌资产

负值（用于最小化）

"""

result = self.calculate_profit(price, si)

profit = result['profit']

brand = result['brand_equity']

lam = self.config.BRAND_WEIGHT_LAMBDA

# 将品牌资产转化为"货币等价"（按品牌资产评估的年度营销节省来折算）

brand_value = brand * 1000 # 简化：每单位品牌资产 ≈ 1000元营销价值

return -(profit + lam * brand_value)

def find_optimal_price(self, si: float = None) -> Dict:

"""

求解最优定价

:return: 最优定价结果

"""

si = si or self.scarcity_model.calculate_si()

result = minimize_scalar(

lambda p: self.objective_function(p, si),

bounds=(self.config.PRICE_LOWER_BOUND, self.config.PRICE_UPPER_BOUND),

method='bounded'

)

optimal_price = result.x

opt_result = self.calculate_profit(optimal_price, si)

# 计算盈亏平衡点

breakeven_price = self._find_breakeven(si)

# 计算"纯利润最大化"价格（λ=0）

result_profit_only = minimize_scalar(

lambda p: -self.calculate_profit(p, si)['profit'],

bounds=(self.config.PRICE_LOWER_BOUND, self.config.PRICE_UPPER_BOUND),

method='bounded'

)

profit_only_result = self.calculate_profit(result_profit_only.x, si)

# 计算"纯品牌最大化"价格（极高λ）

brand_price = self._find_brand_max_price(si)

return {

'optimal_price': optimal_price,

'optimal_result': opt_result,

'breakeven_price': breakeven_price,

'profit_max_price': result_profit_only.x,

'profit_max_result': profit_only_result,

'brand_focus_price': brand_price,

'si': si,

'scarcity_tier': self.scarcity_model.scarcity_tier(si)

}

def _find_breakeven(self, si: float) -> float:

"""求解盈亏平衡价格"""

try:

return brentq(

lambda p: self.calculate_profit(p, si)['profit'],

self.config.PRICE_LOWER_BOUND,

self.config.PRICE_UPPER_BOUND,

maxiter=100

)

except ValueError:

return self.config.BASE_PRICE

def _find_brand_max_price(self, si: float) -> float:

"""找到品牌资产最大化的最优价格（忽略利润约束）"""

prices = np.linspace(

self.config.PRICE_LOWER_BOUND,

self.config.PRICE_UPPER_BOUND,

200

)

best_price = self.config.BASE_PRICE

best_brand = 0

for p in prices:

r = self.calculate_profit(p, si)

if r['brand_equity'] > best_brand and r['profit'] > 0:

best_brand = r['brand_equity']

best_price = p

return best_price

def premium_interval(self, si: float) -> Tuple[float, float]:

"""

计算合理溢价区间

:return: (最低溢价率, 最高溢价率)

"""

opt = self.find_optimal_price(si)

base = self.config.BASE_PRICE

# 下限：盈亏平衡价格

lower = max((opt['breakeven_price'] - base) / base, 0)

# 上限：品牌聚焦价格（但确保至少微利）

upper = (opt['brand_focus_price'] - base) / base

upper = min(upper, self.config.PREMIUM_BOUND_UPPER)

return lower, upper

# ==================== 敏感性分析模块 ====================

class SensitivityAnalyzer:

"""敏感性分析：限量数量对最优定价的影响"""

def __init__(self, config: LuxuryPricingConfig = None):

self.config = config or LuxuryPricingConfig()

self.optimizer = ProfitOptimizer(config)

def analyze_quantity_range(self,

quantities: List[int] = None) -> pd.DataFrame:

"""

分析不同限量数量下的最优定价

:param quantities: 限量数量列表，默认自动生成

:return: 分析结果DataFrame

"""

if quantities is None:

quantities = [50, 100, 200, 500, 1000, 2000, 5000, 10000]

results = []

for q in quantities:

# 临时修改限量

original_q = self.config.LIMIT_QUANTITY

self.config.LIMIT_QUANTITY = q

self.optimizer.config.LIMIT_QUANTITY = q

si = self.optimizer.scarcity_model.calculate_si()

opt = self.optimizer.find_optimal_price(si)

profit_result = opt['optimal_result']

results.append({

'quantity': q,

'si': si,

'optimal_price': opt['optimal_price'],

'premium_rate': (opt['optimal_price'] - self.config.BASE_PRICE) / self.config.BASE_PRICE,

'profit': profit_result['profit'],

'revenue': profit_result['revenue'],

'sell_out_rate': profit_result['sell_out_rate'],

'brand_equity': profit_result['brand_equity'],

'is_scarce': profit_result['is_scarce'],

'scarcity_tier': opt['scarcity_tier'][0]

})

# 恢复

self.config.LIMIT_QUANTITY = original_q

self.optimizer.config.LIMIT_QUANTITY = original_q

return pd.DataFrame(results)

def analyze_parameter_sensitivity(self, si: float) -> pd.DataFrame:

"""分析关键参数变化对最优价格的影响"""

base_opt = self.optimizer.find_optimal_price(si)

base_price = base_opt['optimal_price']

params = {

'BASE_WTP': ('基准WTP', self.config.BASE_WTP),

'PRICE_ELASTICITY': ('价格弹性', self.config.PRICE_ELASTICITY),

'SCARCITY_ALPHA': ('稀缺转化系数', self.config.SCARCITY_ALPHA),

'UNIT_COST': ('单位成本', self.config.UNIT_COST),

'MARKET_DEMAND': ('市场规模', self.config.MARKET_DEMAND),

}

results = []

for param_name, (display_name, base_val) in params.items():

for perturbation in [-0.2, -0.1, 0.1, 0.2]:

# 保存原值

original = getattr(self.config, param_name)

# 扰动

setattr(self.config, param_name, original * (1 + perturbation))

self.optimizer.config = self.config

opt = self.optimizer.find_optimal_price(si)

new_price = opt['optimal_price']

price_change = (new_price - base_price) / base_price

results.append({

'parameter': display_name,

'perturbation': f"{perturbation*100:+.0f}%",

'new_price': new_price,

'price_change_pct': price_change * 100,

'abs_change': abs(price_change)

})

# 恢复原值

setattr(self.config, param_name, original)

self.optimizer.config = self.config

return pd.DataFrame(results)

# ==================== 可视化模块 ====================

class LuxuryVisualizer:

"""奢侈品定价可视化"""

@staticmethod

def plot_demand_curve(demand_model: DemandModel, si: float,

save_path: str = "demand_curve.png"):

"""绘制需求曲线"""

prices, demands = demand_model.demand_curve(si)

config = demand_model.config

fig, ax = plt.subplots(figsize=(12, 7))

ax.plot(prices, demands / 1000, 'b-', linewidth=2.5, label='需求曲线')

ax.axhline(y=config.LIMIT_QUANTITY / 1000, color='red', linestyle='--',

label=f'限量约束: {config.LIMIT_QUANTITY:,}件')

# 标注凡勃伦效应区域

if config.PRICE_ELASTICITY < 0:

ax.axvspan(config.BASE_PRICE * 0.5, config.BASE_PRICE * 1.5,

alpha=0.1, color='green', label='凡勃伦效应区(价格↑需求↑)')

ax.set_xlabel('价格（元）', fontsize=12)

ax.set_ylabel('需求量（千人）', fontsize=12)

ax.set_title(f'需求曲线（SI={si:.0f}）', fontsize=14, fontweight='bold')

ax.legend(fontsize=10)

ax.grid(True, alpha=0.3)

ax.spines['top'].set_visible(False)

ax.spines['right'].set_visible(False)

plt.tight_layout()

plt.savefig(save_path, dpi=150, bbox_inches='tight')

plt.show()

@staticmethod

def plot_profit_landscape(optimizer: ProfitOptimizer, si: float,

save_path: str = "profit_landscape.png"):

"""绘制利润-品牌资产权衡曲线"""

config = optimizer.config

prices = np.linspace(config.PRICE_LOWER_BOUND, config.PRICE_UPPER_BOUND, 100)

profits = []

brand_values = []

for p in prices:

r = optimizer.calculate_profit(p, si)

profits.append(r['profit'] / 10000) # 转为万元

brand_values.append(r['brand_equity'] / 10000)

fig, ax = plt.subplots(figsize=(12, 7))

color = 'tab:blue'

ax.set_xlabel('价格（元）', fontsize=12)

ax.set_ylabel('利润（万元）', color=color, fontsize=12)

ax.plot(prices, profits, color=color, linewidth=2.5, label='利润')

ax.tick_params(axis='y', labelcolor=color)

ax.grid(True, alpha=0.3)

ax2 = ax.twinx()

color = 'tab:red'

ax2.set_ylabel('品牌资产（万元）', color=color, fontsize=12)

ax2.plot(prices, brand_values, color=color, linewidth=2.5, linestyle='--',

label='品牌资产')

ax2.tick_params(axis='y', labelcolor=color)

# 标注最优价格

opt = optimizer.find_optimal_price(si)

opt_price = opt['optimal_price']

opt_profit = opt['optimal_result']['profit'] / 10000

ax.axvline(x=opt_price, color='green', linestyle=':', linewidth=2,

label=f'最优价格: ¥{opt_price:,.0f}')

ax.plot(opt_price, opt_profit, 'go', markersize=10, zorder=5)

lines1, labels1 = ax.get_legend_handles_labels()

lines2, labels2 = ax2.get_legend_handles_labels()

ax.legend(lines1 + lines2, labels1 + labels2, loc='upper left', fontsize=9)

ax.set_title(f'利润-品牌资产权衡（SI={si:.0f}）', fontsize=14, fontweight='bold')

ax.spines['top'].set_visible(False)

plt.tight_layout()

plt.savefig(save_path, dpi=150, bbox_inches='tight')

plt.show()

@staticmethod

def plot_quantity_sensitivity(sens_df: pd.DataFrame, base_price: float,

save_path: str = "quantity_sensiti

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！