使用语义模型和场景感知NLP的个性化搜索优化以改进搜索结果

Python 
1 # Traditional keyword-based search
2 destinations = [
3    {"name": "Sunset Resort", "description": "Budget-friendly beachfront accommodation"},
4    {"name": "Mountain Lodge", "description": "Affordable mountain getaway"},
5    {"name": "City Center Hotel", "description": "Cost-effective downtown location"}
6 ]
7
8 def basic_search(query):
9    return [d for d in destinations if query.lower() in d['description'].lower()]
10
11 # Search for "cheap hotels"
12 results = basic_search("cheap hotels")
13 print(f"Found results: {len(results)}")  # Output: Found results: 0
14
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

Python 
1 from dataclasses import dataclass
2 from typing import List, Optional
3 from datetime import datetime
4 import numpy as np
5 from transformers import AutoModel, AutoTokenizer
6
7 @dataclass
8 class Accommodation:
9    id: str
10    name: str
11    description: str
12    location: str
13    price_per_night: float
14    amenities: List[str]
15    reviews: List[str]
16    rating: float
17    embedding: Optional[np.ndarray] = None
18
19    def to_searchable_text(self) -> str:
20        """Combine all relevant fields into searchable text."""
21        amenities_text = ", ".join(self.amenities)
22        reviews_text = " ".join(self.reviews[:5])  # Use first 5 reviews
23        return f"{self.name} in {self.location}. {self.description}. " \
24               f"Features: {amenities_text}. Guest reviews: {reviews_text}"
25
26  class AccommodationProcessor:
27    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2"):
28        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
29        self.model = AutoModel.from_pretrained(model_name)
30        
31    def create_embedding(self, text: str) -> np.ndarray:
32        """Create an embedding for text using Hugging Face model."""
33        inputs = self.tokenizer(text, return_tensors="pt", 
34                                max_length=512, truncation=True, padding=True)
35        outputs = self.model(**inputs)
36        return outputs.last_hidden_state.mean(dim=1).detach().numpy()
37
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

Python 
1 import faiss
2 from dataclasses import dataclass
3 from typing import List, Tuple
4
5 @dataclass
6 class SearchResult:
7    accommodation: Accommodation
8    score: float
9    relevance_factors: dict
10
11  class TravelSearchEngine:
12    def __init__(self, embedding_dim: int = 384):
13        self.index = faiss.IndexFlatL2(embedding_dim)
14        self.accommodations: List[Accommodation] = []
15        self.processor = AccommodationProcessor()
16        
17    def add_accommodations(self, accommodations: List[Accommodation], 
18                           batch_size: int = 32):
19        """Add accommodations to the search index with batching."""
20        for i in range(0, len(accommodations), batch_size):
21            batch = accommodations[i:i + batch_size]
22            embeddings = []
23            for acc in batch:
24                text = acc.to_searchable_text()
25                acc.embedding = self.processor.create_embedding(text)
26                embeddings.append(acc.embedding)
27            
28            vectors = np.vstack(embeddings)
29            self.index.add(vectors)
30            self.accommodations.extend(batch)
31
32    def _expand_query(self, query: str) -> str:
33        """Expand query with semantic variations."""
34        expansions = {
35            'cheap': ['affordable', 'budget', 'inexpensive'],
36            'luxury': ['high-end', 'premium', 'upscale'],
37            'beach': ['seaside', 'oceanfront', 'coastal'],
38            'city': ['downtown', 'urban', 'metropolitan']
39        }
40        
41        expanded = query
42        for term, synonyms in expansions.items():
43            if term in query.lower():
44                expanded += f" {' '.join(synonyms)}"
45        return expanded
46
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.

Python 
1 class SmartRanker:
2    def __init__(self):
3        self.price_ranges = {
4            'budget': (0, 100),
5            'mid-range': (100, 250),
6            'luxury': (250, float('inf'))
7        }
8        
9    def rank_results(self, results: List[SearchResult], 
10                     context: dict) -> List[SearchResult]:
11        """Rank results based on multiple factors."""
12        for result in results:
13            score_adjustments = {
14                'price_match': self._calculate_price_match(
15                    result.accommodation, context.get('budget')),
16                'rating_boost': result.accommodation.rating * 0.1,
17                'location_relevance': self._calculate_location_relevance(
18                    result.accommodation, context.get('location')),
19                'seasonal_boost': self._calculate_seasonal_boost(
20                    result.accommodation, context.get('date'))
21            }
22            
23            # Combine scores
24            result.score *= sum(score_adjustments.values())
25            result.relevance_factors = score_adjustments
26            
27        return sorted(results, key=lambda x: x.score, reverse=True)
28    
29    def _calculate_price_match(self, 
30                             accommodation: Accommodation, 
31                             budget: float) -> float:
32        if not budget:
33            return 1.0
34        return 1.0 / (1.0 + abs(accommodation.price_per_night - budget))
35    
36    def _calculate_location_relevance(self, 
37                                    accommodation: Accommodation, 
38                                    target_location: str) -> float:
39        if not target_location:
40            return 1.0
41        # Implement location matching logic here
42        return 1.0
43    
44    def _calculate_seasonal_boost(self, 
45                                accommodation: Accommodation, 
46                                travel_date: datetime) -> float:
47        if not travel_date:
48            return 1.0
49        # Implement seasonal scoring logic here
50        return 1.0
51
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

Python 
1 # Create sample data
2 def create_sample_accommodations():
3    return [
4        Accommodation(
5            id="1",
6            name="Beachfront Paradise",
7            description="Luxury beachfront resort with stunning ocean views",
8            location="Malibu, CA",
9            price_per_night=299.99,
10            amenities=["Pool", "Spa", "Restaurant", "Beach access"],
11            reviews=["Amazing beach views!", "Excellent service"],
12            rating=4.8
13        ),
14        Accommodation(
15            id="2",
16            name="Downtown Boutique",
17            description="Affordable boutique hotel in city center",
18            location="Portland, OR",
19            price_per_night=149.99,
20            amenities=["Free WiFi", "Restaurant", "Business Center"],
21            reviews=["Great location!", "Perfect for business travelers"],
22            rating=4.5
23        )
24    ]
25
26  # Initialize the search engine
27  engine = TravelSearchEngine()
28  ranker = SmartRanker()
29
30  # Add sample accommodations
31  accommodations = create_sample_accommodations()
32  engine.add_accommodations(accommodations)
33
34  # Example search function
35  def search_accommodations(query: str, context: dict = None):
36    """
37    Search accommodations with context awareness.
38    
39    Args:
40        query: Search query (e.g., "beach resort near LA").
41        context: Additional context (budget, dates, location preferences).
42    """
43    # Expand query
44    expanded_query = engine._expand_query(query)
45    
46    # Get initial results
47    results = engine.search(expanded_query, k=10)
48    
49    # Apply smart ranking
50    if context:
51        results = ranker.rank_results(results, context)
52    
53    # Display results
54    for result in results:
55        print(f"\n{result.accommodation.name}")
56        print(f"Location: {result.accommodation.location}")
57        print(f"Price: ${result.accommodation.price_per_night:.2f}/night")
58        print(f"Rating: {result.accommodation.rating}⭐")
59        print(f"Relevance Score: {result.score:.2f}")
60        print("Relevance Factors:", result.relevance_factors)
61
62 # Example usage
63 search_context = {
64    'budget': 200,
65    'location': 'California',
66    'date': datetime(2024, 7, 1)
67 }
68
69 search_accommodations("affordable beach resort", search_context)
70
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.

Python 
1 from functools import lru_cache
2
3 class CachedSearchEngine(TravelSearchEngine):
4    @lru_cache(maxsize=1000)
5    def get_query_embedding(self, query: str) -> np.ndarray:
6        """Cache query embeddings for frequent searches."""
7        return self.processor.create_embedding(query)
8
9    def optimize_index(self):
10        """Convert to a more efficient index type for large datasets."""
11        if len(self.accommodations) > 100000:
12            # Convert to IVF index for better scaling
13            nlist = int(np.sqrt(len(self.accommodations)))
14            quantizer = faiss.IndexFlatL2(self.embedding_dim)
15            new_index = faiss.IndexIVFFlat(quantizer, 
16                                         self.embedding_dim, 
17                                         nlist)
18            new_index.train(self.get_all_vectors())
19            new_index.add(self.get_all_vectors())
20            self.index = new_index
21
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

Python 
1 class SearchAnalytics:
2    def __init__(self):
3        self.searches = []
4        
5    def log_search(self, query: str, results: List[SearchResult], 
6                   selected_result: Optional[str]):
7        """Log search data for analysis."""
8        self.searches.append({
9            'timestamp': datetime.now(),
10            'query': query,
11         'num_results': len(results),
12            'top_result': results[0].accommodation.id if results else None,
13            'selected_result': selected_result,
14            'conversion': selected_result is not None
15        })
16    
17    def get_metrics(self) -> dict:
18        """Calculate key search metrics."""
19        total_searches = len(self.searches)
20        conversions = sum(1 for s in self.searches if s['conversion'])
21        
22        return {
23            'total_searches': total_searches,
24            'conversion_rate': conversions / total_searches if total_searches else 0,
25            'zero_results_rate': sum(1 for s in self.searches 
26                                   if s['num_results'] == 0) / total_searches
27        }
28
29
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.