Update app.py

app.py

@@ -6,6 +6,8 @@ import json
 from sentence_transformers import SentenceTransformer
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
+import re
+from collections import Counter
 
 def load_data():
     try:
@@ -49,32 +51,27 @@ model = SentenceTransformer('all-mpnet-base-v2')
 tfidf_vectorizer = TfidfVectorizer(stop_words='english')
 tfidf_matrix = tfidf_vectorizer.fit_transform(texts)
 
-# Synonym dictionary for query expansion
-synonyms = {
-    "slidable": ["detachable", "removable"],
-    "flexible": ["elastic", "deformable"],
-    "aerosol": ["vapor"],
-    "device": ["generator"]
-}
+def extract_key_features(text):
+    # Extract noun phrases as potential key features
+    noun_phrases = re.findall(r'\b(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b', text)
+    # Extract phrases following "comprising", "including", "consisting of" as potential key features
+    feature_phrases = re.findall(r'(?:comprising|including|consisting of)\s+(.*?)(?:;|\.)', text, re.IGNORECASE)
+    
+    all_features = noun_phrases + feature_phrases
+    # Remove duplicates and lowercase
+    return list(set(feature.lower() for feature in all_features))
 
-def expand_query(query):
-    words = query.split()
-    expanded_query = []
-    for word in words:
-        if word in synonyms:
-            expanded_query.append(f"({word} OR {' OR '.join(synonyms[word])})")
-        else:
-            expanded_query.append(word)
-    return " ".join(expanded_query)
+def compare_features(query_features, patent_features):
+    common_features = set(query_features) & set(patent_features)
+    similarity_score = len(common_features) / max(len(query_features), len(patent_features))
+    return common_features, similarity_score
 
 def hybrid_search(query, top_k=5):
     print(f"Original query: {query}")
     
-    # Expand the query using synonyms
-    expanded_query = expand_query(query)
-    print(f"Expanded query: {expanded_query}")
+    query_features = extract_key_features(query)
     
-    # Encode the original query using the transformer model
+    # Encode the query using the transformer model
     query_embedding = model.encode([query])[0]
     query_embedding = query_embedding / np.linalg.norm(query_embedding)
     
@@ -82,7 +79,7 @@ def hybrid_search(query, top_k=5):
     semantic_distances, semantic_indices = index.search(np.array([query_embedding]), top_k * 2)
     
     # Perform TF-IDF based search
-    query_tfidf = tfidf_vectorizer.transform([expanded_query])
+    query_tfidf = tfidf_vectorizer.transform([query])
     tfidf_similarities = cosine_similarity(query_tfidf, tfidf_matrix).flatten()
     tfidf_indices = tfidf_similarities.argsort()[-top_k * 2:][::-1]
     
@@ -90,28 +87,36 @@ def hybrid_search(query, top_k=5):
     combined_results = {}
     for i, idx in enumerate(semantic_indices[0]):
         patent_number = patent_numbers[idx].decode('utf-8')
-        combined_results[patent_number] = semantic_distances[0][i] * 1.5  # Increase weight for semantic similarity
+        text = metadata[patent_number]['text']
+        patent_features = extract_key_features(text)
+        common_features, feature_similarity = compare_features(query_features, patent_features)
+        combined_results[patent_number] = {
+            'score': semantic_distances[0][i] * 1.5 + feature_similarity,
+            'common_features': common_features,
+            'text': text
+        }
     
     for idx in tfidf_indices:
         patent_number = patent_numbers[idx].decode('utf-8')
-        if patent_number in combined_results:
-            combined_results[patent_number] += tfidf_similarities[idx]
-        else:
-            combined_results[patent_number] = tfidf_similarities[idx]
+        if patent_number not in combined_results:
+            text = metadata[patent_number]['text']
+            patent_features = extract_key_features(text)
+            common_features, feature_similarity = compare_features(query_features, patent_features)
+            combined_results[patent_number] = {
+                'score': tfidf_similarities[idx] + feature_similarity,
+                'common_features': common_features,
+                'text': text
+            }
     
     # Sort and get top results
-    top_results = sorted(combined_results.items(), key=lambda x: x[1], reverse=True)[:top_k]
+    top_results = sorted(combined_results.items(), key=lambda x: x[1]['score'], reverse=True)[:top_k]
     
     results = []
-    for patent_number, score in top_results:
-        if patent_number not in metadata:
-            print(f"Warning: Patent number {patent_number} not found in metadata")
-            continue
-        patent_data = metadata[patent_number]
+    for patent_number, data in top_results:
         result = f"Patent Number: {patent_number}\n"
-        text = patent_data.get('text', 'No text available')
-        result += f"Text: {text[:200]}...\n"
-        result += f"Combined Score: {score:.4f}\n\n"
+        result += f"Text: {data['text'][:200]}...\n"
+        result += f"Combined Score: {data['score']:.4f}\n"
+        result += f"Common Key Features: {', '.join(data['common_features'])}\n\n"
         results.append(result)
     
     return "\n".join(results)
@@ -119,10 +124,10 @@ def hybrid_search(query, top_k=5):
 # Create Gradio interface
 iface = gr.Interface(
     fn=hybrid_search,
-    inputs=gr.Textbox(lines=2, placeholder="Enter your search query here..."),
+    inputs=gr.Textbox(lines=2, placeholder="Enter your patent query here..."),
     outputs=gr.Textbox(lines=10, label="Search Results"),
     title="Patent Similarity Search",
-    description="Enter a query to find similar patents based on their content."
+    description="Enter a patent description to find similar patents based on key features."
 )
 
 if __name__ == "__main__":