What is the RentTheRunway Dataset?

The RentTheRunway dataset originates from RentTheRunway.com, a popular online service specializing in designer apparel and accessory rentals. The publicly available versions are typically curated snapshots released by researchers (like the notable work from Rishabh Misra et al. at UCSD). These datasets contain anonymized user interactions and detailed feedback specifically related to clothing rentals.

Its primary value stems from the context-rich, detailed feedback users provide after renting and wearing an item, often for a specific event or occasion. This post-rental insight is key to its uniqueness.

Key Features & Data Structure of the RTR Dataset

Unlike continuously updated commercial data, the public RTR dataset is usually a static release. Its defining features center around detailed user attributes and nuanced feedback:

• Domain: Fashion Rental (Designer Clothing)
• Data Source: Authentic user feedback submitted post-rental.
• Core Interaction Data:
  
  • user_id: Anonymized user identifier.
  • item_id: Identifier for the rented clothing item.
  • rating: User's overall satisfaction score (e.g., 1-10 or 1-5 scale).
  • timestamp: Date/time of review submission.
  • review_text/review_summary: Qualitative user feedback.
• Unique Contextual & Fit Data (Critical for Modeling!):
  
  • User Attributes: Self-reported data like weight ('130lbs'), height ('5' 6"'), age, body type ('hourglass', 'pear'), bust size ('34b').
  • Fit Feedback: Explicit categorical rating (fit, small, large). This is a cornerstone for fit prediction models.
  • Rental Context: The specific occasion (rented_for): 'wedding', 'party', 'work', 'formal affair'. Essential for context-aware recommendations.
• Item Metadata: Basic item information, typically category ('dress', 'top', 'skirt').

Important Consideration: The richness of self-reported user attributes is powerful for modeling but requires careful handling. It's personal, potentially noisy (inconsistent reporting), and necessitates robust anonymization in public releases.

Why is the RentTheRunway Dataset Crucial for Fashion AI Research?

The RTR dataset holds significant importance within the recommendation systems and fashion tech communities:

1. Benchmark for Clothing Fit Prediction: It's the leading public dataset for researching and benchmarking models that predict clothing fit – a major hurdle in online fashion. The combination of body attributes and explicit fit feedback enables this.
2. Enabling Context-Aware Recommendations: The rented_for field allows researchers to study how occasions influence choice and satisfaction, paving the way for sophisticated context-aware recommendation engines.
3. Rich User Attribute Modeling: It offers a rare chance to model the interplay between granular user attributes (body measurements, type) and item characteristics for highly personalized suggestions.
4. Real-World Text Analysis: User reviews provide fertile ground for Natural Language Processing (NLP) analysis focusing on fit, style, occasion suitability, and nuanced sentiment, going beyond simple ratings.

Strengths of the RentTheRunway Dataset

• Detailed User Attributes: Unmatched granularity on user body measurements/types in a public dataset.
• Explicit Fit Feedback: Direct 'fit', 'small', 'large' signal vital for fit modeling.
• Event Context: rented_for field adds a crucial layer for contextual recommendations.
• Authentic User Reviews: Rich qualitative text data for deeper insights.
• Unique Domain Focus: Addresses specific challenges of fashion rental recommendations.

Weaknesses & Considerations When Using the RTR Dataset

• Rental vs. Purchase Behavior: Motivations might differ between renting and buying.
• Data Noise & Inconsistency: Self-reported attributes can be inaccurate; review quality varies.
• Potential Demographic Bias: RTR users might not represent the general population.
• Privacy Sensitivity: Detailed attributes demand ethical handling and anonymization.
• Static Nature: Represents a specific point in time; doesn't reflect current trends or inventory.
• Data Sparsity: Common in recommendation datasets; users interact with few items.
• Limited Item Metadata: Public versions may lack deep item specifics (style tags, material).

Common Use Cases & Applications

The RentTheRunway dataset is frequently used for:

• Developing and evaluating clothing fit prediction algorithms.
• Building context-aware recommendation systems leveraging rental occasions.
• Modeling how user body attributes influence item preference and fit.
• Attribute-based recommendation: Suggesting items for users with similar body profiles.
• NLP tasks: Sentiment analysis, aspect extraction (fit, style, occasion) from reviews.
• Researching fairness and bias related to body image and attribute reporting.

How to Access the RentTheRunway Dataset

The dataset is typically linked to academic research. Good starting points include:

1. Key Research Paper: "Decomposing Fit Semantics for Product Size Recommendation" by Rishabh Misra, Mengting Wan, Julian McAuley (WSDM 2018). Authors often provide data links on project pages or personal websites.
2. Academic/Data Repositories: Check platforms like Kaggle, Zenodo, or university data repositories where versions might be hosted.

Disclaimer: Always verify the data source and adhere to the terms of use specified by the providers. Ensure compliance with privacy regulations.

Connecting the RentTheRunway Dataset to Shaped

The RentTheRunway dataset, with its rich user attributes and contextual feedback, is an excellent candidate for demonstrating Shaped's ability to handle complex feature interactions for nuanced recommendations. Here’s how you might structure the connection:

1. Dataset Preparation (Conceptual): Obtain the RTR dataset file(s), typically containing reviews/rentals, user attributes, and item details combined or in separate files. The primary task is to prepare:

• Events Data: Contains the core interaction (user_id, item_id, rating, timestamp) plus crucial context: fit, rented_for, review_text, review_summary. Map rating -> label, timestamp -> created_at (convert to epoch).
• User Features Data: Contains user_id and the user attributes (weight, height, age, body_type, bust_size). Requires cleaning/standardization (e.g., converting height strings to inches, weight strings to numbers).
• Item Features Data: Contains item_id and item metadata (category).

Save these prepared datasets into separate files (e.g., .csv or .jsonl).

# Conceptual Preparation Outline (Not runnable code)

# 1. Load main RTR data file.

# 2. Create Events DataFrame: user_id, item_id, label (from rating), created_at (from timestamp),
#    fit, rented_for, review_text, review_summary -> save as shaped_rtr_events.jsonl

# 3. Create User Features DataFrame: user_id, weight_num, height_inches, age, body_type, bust_size -> save as shaped_rtr_users.jsonl

# 4. Create Item Features DataFrame: item_id, category -> save as shaped_rtr_items.jsonl

print("RTR data conceptually prepared into events, users, and items files.")

2. Create Shaped Datasets using URI: Upload the prepared files.

# Upload interaction events
shaped create-dataset-from-uri --name rtr_events \
                               --path path/to/rtr/shaped_rtr_events.jsonl \
                               --type jsonl

# Upload user features
shaped create-dataset-from-uri --name rtr_users \
                               --path path/to/rtr/shaped_rtr_users.jsonl \
                               --type jsonl

# Upload item features
shaped create-dataset-from-uri --name rtr_items \
                               --path path/to/rtr/shaped_rtr_items.jsonl \
                               --type jsonl

3. Create Shaped Model: Define the model schema in a YAML file. This configuration explicitly tells Shaped to use the rich event, user, and item features.

# File: rtr_model_schema.yaml
model:
  name: renttherunway_fit_recs
  # Model learns preferences based on rating (label) & context

connectors:
  - type: Dataset
    id: rtr_events # Interactions dataset
    name: events # Alias for fetch query
  - type: Dataset
    id: rtr_users # User attributes dataset
    name: users # Alias for fetch query
  - type: Dataset
    id: rtr_items # Item metadata dataset
    name: items # Alias for fetch query

fetch:
  # Define the interaction events with their rich context
  events: |
    SELECT
      user_id,
      item_id,
      label, # The user's overall rating
      created_at, # Timestamp of the review/rental
      # --- Contextual Event Features ---
      fit, # Categorical: 'fit', 'small', 'large'
      rented_for, # Categorical: 'wedding', 'party', etc.
      review_text, # Text feature
      review_summary # Text feature
    FROM events

  # Define user features including body attributes
  users: |
    SELECT
      user_id,
      # --- User Attributes ---
      weight_num, # Numerical feature (cleaned)
      height_inches, # Numerical feature (cleaned)
      age, # Numerical feature
      body_type, # Categorical feature
      bust_size # Categorical feature (or numerical if cleaned)
    FROM users

  # Define item features
  items: |
    SELECT
      item_id,
      category # Categorical item feature
    FROM items

Create the model using the CLI:

# Create the Rent the Runway model using Shaped CLI
shaped create-model --file rtr_model_schema.yaml

With this configuration, Shaped automatically incorporates the detailed user attributes (height, weight, body_type, etc.), item category, and crucial event context (fit, rented_for, review_text) into its deep learning models. This allows it to learn complex relationships between user profiles, item characteristics, the rental context, and fit feedback to provide highly personalized and contextually relevant fashion recommendations, directly addressing the core challenges highlighted by the RTR dataset.

Conclusion: The Value of the RTR Dataset in Fashion Recommendation

The RentTheRunway dataset is a standout resource in the recommender systems landscape. Its unique focus on fashion rental, combined with rich user attributes and explicit fit feedback, makes it invaluable. It pushes research beyond traditional preference prediction, providing a critical benchmark for the complex task of predicting clothing fit and enabling context-aware recommendations based on occasion. While careful handling of its sensitive attributes is essential, the RTR dataset offers unparalleled insights into the dynamics of user characteristics, item properties, and context within the fashion domain. It remains a vital tool for anyone working on the next generation of fashion recommendation technology.

‍Request a demo of Shaped today to see it in action with your specific use case. Or, start exploring immediately with our free trial sandbox.