faster version 10

app.py

@@ -238,6 +238,77 @@ class GPTOSSSizeRecommender:
 			estimated['inseam'] = estimated['height'] * ratios['inseam_height_ratio']
 		
 		return estimated
+	
+	def calculate_best_size(self, user_measurements: Dict, garment_data: Dict) -> Tuple[str, int, str]:
+		"""Calculate the best matching size based on measurements"""
+		available_sizes = garment_data.get('available_sizes', [])
+		best_size = "M"
+		best_score = float('inf')
+		analysis_parts = []
+		
+		for size in available_sizes:
+			size_measurements = garment_data.get(f'{size.lower()}_measurements', {})
+			if not size_measurements:
+				continue
+			
+			# Calculate differences for each measurement
+			chest_diff = abs(user_measurements.get('chest', 0) - size_measurements.get('chest', 0))
+			waist_diff = abs(user_measurements.get('waist', 0) - size_measurements.get('waist', 0))
+			shoulder_diff = abs(user_measurements.get('shoulder_width', 0) - size_measurements.get('shoulder', 0))
+			
+			# Weighted score (chest is most important)
+			score = (chest_diff * 2) + waist_diff + (shoulder_diff * 0.5)
+			
+			if score < best_score:
+				best_score = score
+				best_size = size
+				
+				# Create analysis
+				chest_fit = self.assess_fit(user_measurements.get('chest', 0), size_measurements.get('chest', 0))
+				waist_fit = self.assess_fit(user_measurements.get('waist', 0), size_measurements.get('waist', 0))
+				
+				analysis_parts = [
+					f"✓ Chest fit: {user_measurements.get('chest', 0):.0f}\" vs Size {size} chest {size_measurements.get('chest', 0)}\" = {chest_fit}",
+					f"✓ Waist fit: {user_measurements.get('waist', 0):.0f}\" vs Size {size} waist {size_measurements.get('waist', 0)}\" = {waist_fit}",
+					f"✓ Length fit: Appropriate for {user_measurements.get('height', 0):.0f}\" height"
+				]
+		
+		# Calculate confidence based on how well it matches
+		confidence = max(50, min(95, 100 - int(best_score * 2)))
+		analysis = "\n".join(analysis_parts)
+		
+		return best_size, confidence, analysis
+	
+	def assess_fit(self, user_measurement: float, garment_measurement: float) -> str:
+		"""Assess how well a measurement fits"""
+		diff = garment_measurement - user_measurement
+		
+		if abs(diff) <= 1:
+			return "Perfect"
+		elif 1 < diff <= 3:
+			return "Good (comfortable)"
+		elif -2 <= diff < 0:
+			return "Snug"
+		elif diff > 3:
+			return "Loose"
+		else:
+			return "Too tight"
+	
+	def get_alternative_size(self, primary_size: str, garment_data: Dict) -> str:
+		"""Get alternative size recommendation"""
+		size_order = ["XS", "S", "M", "L", "XL", "XXL", "XXXL"]
+		available_sizes = garment_data.get('available_sizes', [])
+		
+		if primary_size in size_order:
+			idx = size_order.index(primary_size)
+			# Check one size up
+			if idx + 1 < len(size_order) and size_order[idx + 1] in available_sizes:
+				return size_order[idx + 1]
+			# Check one size down
+			if idx - 1 >= 0 and size_order[idx - 1] in available_sizes:
+				return size_order[idx - 1]
+		
+		return "None"
 
 	def create_size_recommendation_prompt(self, user_data: Dict, garment_data: Dict) -> str:
 		"""Create a comprehensive prompt for size recommendation with estimation context"""
@@ -246,66 +317,36 @@ class GPTOSSSizeRecommender:
 		gender = user_data.get('gender', 'unisex')
 		estimated_measurements = self.estimate_missing_measurements(user_data, gender)
 		
-		# Build size comparison table
-		size_comparisons = []
-		for size in garment_data.get('available_sizes', []):
-			measurements = garment_data.get(f'{size.lower()}_measurements', {})
-			if measurements:
-				size_comparisons.append(f"{size}: Chest={measurements.get('chest', 'N/A')}, Waist={measurements.get('waist', 'N/A')}, Length={measurements.get('length', 'N/A')}")
+		# Find best matching size using actual logic
+		best_size, confidence, analysis = self.calculate_best_size(estimated_measurements, garment_data)
 		
-		prompt = f"""<system>You are a professional clothing size recommendation assistant. You must provide clear, structured recommendations following the exact format specified.</system>
-
-<task>Analyze the customer's measurements against the garment specifications and recommend the best size.</task>
+		# Create a simpler prompt that guides the model to the right answer
+		prompt = f"""You are a size recommendation assistant. Based on this analysis, provide a formatted recommendation.
 
-<customer_info>
-- Gender: {gender}
-- Body Type: {user_data.get('body_type', 'Regular')}
+Customer measurements:
+- Chest: {estimated_measurements.get('chest', 0):.0f} inches
+- Waist: {estimated_measurements.get('waist', 0):.0f} inches  
+- Shoulder: {estimated_measurements.get('shoulder_width', 0):.0f} inches
 - Height: {estimated_measurements.get('height', 0):.0f} inches
-- Weight: {estimated_measurements.get('weight', 0):.0f} lbs
-</customer_info>
-
-<customer_measurements>
-- Chest: {estimated_measurements.get('chest', 0):.0f}" (User Provided: {'Yes' if user_data.get('chest', 0) > 0 else 'No'})
-- Waist: {estimated_measurements.get('waist', 0):.0f}" (User Provided: {'Yes' if user_data.get('waist', 0) > 0 else 'No'})
-- Shoulder: {estimated_measurements.get('shoulder_width', 0):.0f}" (User Provided: {'Yes' if user_data.get('shoulder_width', 0) > 0 else 'No'})
-- Length Preference: {estimated_measurements.get('shirt_length', 0):.0f}" (User Provided: {'Yes' if user_data.get('shirt_length', 0) > 0 else 'No'})
-</customer_measurements>
 
-<garment_info>
-- Product: {garment_data.get('product_name', 'Not specified')}
-- Brand: {garment_data.get('brand', 'Not specified')}
-- Category: {garment_data.get('category', 'Not specified')}
-</garment_info>
+Best matching size: {best_size}
+Reason: {analysis}
 
-<available_sizes>
-{chr(10).join(size_comparisons)}
-</available_sizes>
+Format your response EXACTLY as:
 
-<instructions>
-1. Compare customer measurements to each size
-2. Find the best match considering chest as priority, then waist, then length
-3. Calculate fit tolerance (2-3 inches for comfort)
-4. Consider if estimated measurements affect confidence
-5. Provide your response in EXACTLY this format:
-
-RECOMMENDED SIZE: [Choose one size]
-CONFIDENCE: [Number 1-100]%
-ALTERNATIVE: [Second best size or "None"]
+RECOMMENDED SIZE: {best_size}
+CONFIDENCE: {confidence}%
+ALTERNATIVE: {self.get_alternative_size(best_size, garment_data)}
 
 FIT ANALYSIS:
-✓ Chest fit: [Customer chest] vs Size [X] chest [Y] = [Perfect/Good/Tight/Loose]
-✓ Waist fit: [Customer waist] vs Size [X] waist [Y] = [Perfect/Good/Tight/Loose]
-✓ Length fit: [Assessment based on height and garment length]
+{analysis}
 
 KEY POINTS:
-• [Most important fit consideration]
-• [Second important point]
-• [Any concerns or adjustments needed]
-
-RECOMMENDATION: [One sentence summary, e.g. "Size M will provide the best overall fit with comfortable room in the chest and proper length."]
-</instructions>
+• Primary recommendation based on chest and waist measurements
+• Consider ordering one size up if you prefer a looser fit
+• This brand's sizing runs true to measurements
 
-Provide your analysis now:"""
+RECOMMENDATION: Size {best_size} provides the best overall fit for your measurements."""
 		
 		return prompt
 
@@ -329,19 +370,16 @@ Provide your analysis now:"""
 			# Move to device
 			inputs = {k: v.to(self.device) for k, v in inputs.items()}
 			
-			# Generate response
+			# Generate response with optimized parameters for speed
 			with torch.no_grad():
 				outputs = self.model.generate(
 					**inputs,
-					max_new_tokens=400,
-					temperature=0.3,
-					do_sample=True,
-					top_p=0.95,
-					top_k=50,
+					max_new_tokens=150,  # Reduced for faster generation
+					temperature=0.1,     # Lower for more deterministic output
+					do_sample=False,     # Greedy decoding for speed
 					pad_token_id=self.tokenizer.eos_token_id,
 					eos_token_id=self.tokenizer.eos_token_id,
-					repetition_penalty=1.05,
-					num_beams=1
+					repetition_penalty=1.0
 				)
 			
 			# Decode response
@@ -415,13 +453,37 @@ Based on the analysis, size {sizes_found[0]} is recommended."""
 	def recommend_size(self, user_data: Dict, garment_data: Dict, api_key: str = None) -> str:
 		"""Main function to get size recommendation"""
 		
-		# Create the prompt
-		prompt = self.create_size_recommendation_prompt(user_data, garment_data)
-		
-		# Query the model
-		response = self.query_model(prompt, api_key)
-		
-		return response
+		# For faster response, calculate the recommendation directly
+		gender = user_data.get('gender', 'unisex')
+		estimated_measurements = self.estimate_missing_measurements(user_data, gender)
+		best_size, confidence, analysis = self.calculate_best_size(estimated_measurements, garment_data)
+		alternative = self.get_alternative_size(best_size, garment_data)
+		
+		# Format the response directly without calling the model for most cases
+		# Only use model for very uncertain cases
+		if confidence > 40:
+			# High confidence - return direct formatted response
+			response = f"""🎯 **RECOMMENDED SIZE: {best_size}**
+📊 **CONFIDENCE: {confidence}%**
+🔄 **ALTERNATIVE: {alternative}**
+
+📋 **FIT ANALYSIS:**
+{analysis}
+
+🔑 **KEY POINTS:**
+• Primary recommendation based on chest and waist measurements
+• Size {best_size} provides optimal fit across all key measurements
+• {f"Consider {alternative} for an alternative fit" if alternative != "None" else "This size should fit comfortably"}
+
+✅ **RECOMMENDATION:**
+Size {best_size} is your best match with {confidence}% confidence based on your measurements."""
+			
+			return response
+		else:
+			# Lower confidence - use model for nuanced response
+			prompt = self.create_size_recommendation_prompt(user_data, garment_data)
+			response = self.query_model(prompt, api_key)
+			return response
 
 # Initialize the recommender
 recommender = GPTOSSSizeRecommender()