|
|
| import os |
| import re |
| import json |
| import torch |
| from sentence_transformers import SentenceTransformer, util |
| from transformers import AutoTokenizer, AutoModelForSeq2SeqLM |
|
|
|
|
| |
| |
| |
| def load_training_data(data_folder): |
| data = [] |
| missing_code = 0 |
| missing_query = 0 |
|
|
| for file in os.listdir(data_folder): |
| if file.endswith(".json"): |
| path = os.path.join(data_folder, file) |
| with open(path, "r", encoding="utf-8") as f: |
| try: |
| entries = json.load(f) |
| for e in entries: |
| if not e.get("pandas_code"): |
| missing_code += 1 |
| continue |
| if not (e.get("english") or e.get("query")): |
| missing_query += 1 |
| continue |
| data.append(e) |
| except Exception as e: |
| print(f"⚠️ Skipped {file}: {e}") |
|
|
| print(f"📚 Loaded {len(data)} valid query–code pairs from {data_folder}") |
| print(f"⚠️ Skipped {missing_code} missing-code and {missing_query} missing-query entries.") |
| return data |
|
|
|
|
| |
| |
| |
| class EnhancedRetriever: |
| def __init__(self, data): |
| self.model = SentenceTransformer("all-MiniLM-L6-v2") |
|
|
| valid_data = [ |
| item for item in data |
| if (item.get("pandas_code") and (item.get("english") or item.get("query"))) |
| ] |
|
|
| if not valid_data: |
| raise ValueError("No valid query–code pairs found in dataset!") |
|
|
| self.queries = [ |
| item.get("english") or item.get("query") |
| for item in valid_data |
| ] |
| self.codes = [item["pandas_code"] for item in valid_data] |
|
|
| print(f"✅ Using {len(valid_data)} valid items for retrieval.") |
| print("🧠 Encoding queries for retrieval...") |
| self.query_embeddings = self.model.encode(self.queries, convert_to_tensor=True) |
|
|
| def retrieve_best_match(self, user_query, top_k=3): |
| user_emb = self.model.encode(user_query, convert_to_tensor=True) |
| similarity = util.pytorch_cos_sim(user_emb, self.query_embeddings)[0] |
| top_results = torch.topk(similarity, k=top_k) |
|
|
| results = [] |
| for i in range(top_k): |
| results.append({ |
| "query": self.queries[top_results.indices[i]], |
| "pandas_code": self.codes[top_results.indices[i]], |
| "similarity": float(top_results.values[i]) |
| }) |
|
|
| return results |
|
|
|
|
| |
| |
| |
| class Generator: |
| def __init__(self, model_dir="./text2code_model"): |
| if not os.path.exists(model_dir): |
| print("⚙️ No fine-tuned model found — using base CodeT5.") |
| model_dir = "Salesforce/codet5-small" |
|
|
| self.tokenizer = AutoTokenizer.from_pretrained(model_dir) |
| self.model = AutoModelForSeq2SeqLM.from_pretrained(model_dir) |
|
|
| def generate(self, query): |
| prompt = f"Generate Pandas code for: {query}" |
| inputs = self.tokenizer(prompt, return_tensors="pt") |
| outputs = self.model.generate(**inputs, max_length=128) |
| return self.tokenizer.decode(outputs[0], skip_special_tokens=True) |
|
|
|
|
| |
| |
| |
| def extract_column_names(text): |
| """Extract potential column names from text""" |
| words = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', text) |
| stopwords = { |
| 'show', 'display', 'find', 'get', 'the', 'and', 'or', 'where', |
| 'what', 'how', 'many', 'much', 'list', 'give', 'me', 'all', |
| 'with', 'for', 'bottom', 'top', 'average', 'mean', 'sum', |
| 'median', 'count', 'minimum', 'maximum', 'highest', 'lowest' |
| } |
| cols = [w for w in words if w.lower() not in stopwords and len(w) > 2] |
| return [normalize_name(c) for c in cols] |
|
|
| def extract_values(text): |
| """Extract quoted values and numbers from text""" |
| quoted = re.findall(r"'([^']*)'", text) |
| numbers = re.findall(r'\b\d+\b', text) |
| return quoted + numbers |
|
|
| |
| |
| |
| |
| |
| |
| |
|
|
| |
|
|
| |
| |
| |
| |
|
|
| |
| |
| |
| |
| |
|
|
| |
| |
|
|
| |
|
|
|
|
|
|
|
|
|
|
| def enhanced_adaptation(user_query, code, original_retrieved_query): |
| """Smarter code adaptation with normalized column matching""" |
| query_columns = extract_column_names(user_query) |
| original_columns = extract_column_names(original_retrieved_query) |
| query_values = extract_values(user_query) |
| original_values = extract_values(original_retrieved_query) |
|
|
| new_code = code |
|
|
| |
| for orig_col, new_col in zip(original_columns, query_columns): |
| if orig_col and new_col and normalize_name(orig_col) != normalize_name(new_col): |
| for pattern in [rf"'{orig_col}'", rf'"{orig_col}"', rf"\b{orig_col}\b"]: |
| new_code = re.sub(pattern, new_col, new_code, flags=re.IGNORECASE) |
|
|
| |
| if hasattr(bot, "col_map"): |
| for norm_col in query_columns: |
| if norm_col in bot.col_map: |
| correct_name = bot.col_map[norm_col] |
| new_code = re.sub(rf"\b{norm_col}\b", correct_name, new_code, flags=re.IGNORECASE) |
|
|
| |
| for orig_val, new_val in zip(original_values, query_values): |
| if orig_val and new_val and orig_val != new_val: |
| new_code = re.sub(rf"'{re.escape(orig_val)}'", f"'{new_val}'", new_code) |
| new_code = re.sub(rf'"{re.escape(orig_val)}"', f'"{new_val}"', new_code) |
| new_code = re.sub(rf"\b{re.escape(orig_val)}\b", new_val, new_code) |
|
|
| new_code = adapt_operations_based_on_query(user_query, new_code) |
| new_code = adapt_filters_based_on_query(user_query, new_code) |
|
|
| return new_code |
|
|
| def adapt_operations_based_on_query(query, code): |
| q = query.lower() |
| c = code |
|
|
| if any(word in q for word in ["average", "mean", "avg"]): |
| c = re.sub(r"\.(sum|min|max|count)\(\)", ".mean()", c) |
| elif any(word in q for word in ["total", "sum", "add", "together"]): |
| c = re.sub(r"\.(mean|min|max|count)\(\)", ".sum()", c) |
| elif any(word in q for word in ["minimum", "min", "lowest", "smallest"]): |
| c = re.sub(r"\.(mean|sum|max|count)\(\)", ".min()", c) |
| elif any(word in q for word in ["maximum", "max", "highest", "largest"]): |
| c = re.sub(r"\.(mean|sum|min|count)\(\)", ".max()", c) |
| elif any(word in q for word in ["count", "number", "how many"]): |
| c = re.sub(r"\.(mean|sum|min|max)\(\)", ".count()", c) |
|
|
| return c |
|
|
|
|
| def adapt_filters_based_on_query(query, code): |
| q = query.lower() |
| c = code |
|
|
| if "status" in q and "rejected" in q: |
| c = re.sub(r"df\[df\['\w+'\] == '[^']*'\]", "df[df['Status'] == 'rejected']", c) |
| elif "status" in q and "approved" in q: |
| c = re.sub(r"df\[df\['\w+'\] == '[^']*'\]", "df[df['Status'] == 'approved']", c) |
|
|
| if "top" in q and "head" not in c: |
| nums = re.findall(r'\d+', q) |
| if nums: |
| c = re.sub(r"\.tail\(\d+\)", f".head({nums[0]})", c) |
| if "head" not in c and "sort_values" in c: |
| c += f".head({nums[0]})" |
| elif "bottom" in q and "tail" not in c: |
| nums = re.findall(r'\d+', q) |
| if nums: |
| c = re.sub(r"\.head\(\d+\)", f".tail({nums[0]})", c) |
| if "tail" not in c and "sort_values" in c: |
| c += f".tail({nums[0]})" |
|
|
| return c |
|
|
|
|
| |
| |
| |
| def select_best_template(retrieved_results, user_query): |
| user_query_lower = user_query.lower() |
| user_ops = [] |
|
|
| if any(op in user_query_lower for op in ['average', 'mean', 'avg']): user_ops.append('mean') |
| if any(op in user_query_lower for op in ['sum', 'total']): user_ops.append('sum') |
| if any(op in user_query_lower for op in ['median']): user_ops.append('median') |
| if any(op in user_query_lower for op in ['count', 'number']): user_ops.append('count') |
| if any(op in user_query_lower for op in ['minimum', 'min', 'lowest']): user_ops.append('min') |
| if any(op in user_query_lower for op in ['maximum', 'max', 'highest']): user_ops.append('max') |
| if any(op in user_query_lower for op in ['group', 'grouped']): user_ops.append('groupby') |
| if any(op in user_query_lower for op in ['filter', 'where', 'condition']): user_ops.append('filter') |
|
|
| best_score = -1 |
| best_result = retrieved_results[0] |
|
|
| for result in retrieved_results: |
| score = result["similarity"] |
| code = result["pandas_code"].lower() |
|
|
| for op in user_ops: |
| if op in code: |
| score += 0.1 |
|
|
| if 'groupby' in user_ops and 'groupby' in code: |
| score += 0.15 |
| if 'filter' in user_ops and 'df[' in code and '==' in code: |
| score += 0.15 |
|
|
| if score > best_score: |
| best_score = score |
| best_result = result |
|
|
| return best_result |
|
|
|
|
| |
| |
| |
| def validate_code_against_query(code, user_query): |
| query_lower = user_query.lower() |
| code_lower = code.lower() |
| issues = [] |
|
|
| if any(w in query_lower for w in ['average', 'mean', 'avg']) and 'mean' not in code_lower: |
| issues.append("Query asks for average but code doesn't use mean()") |
| if any(w in query_lower for w in ['sum', 'total']) and 'sum' not in code_lower: |
| issues.append("Query asks for sum but code doesn't use sum()") |
| if 'median' in query_lower and 'median' not in code_lower: |
| issues.append("Query asks for median but code doesn't use median()") |
| if any(w in query_lower for w in ['group', 'grouped']) and 'groupby' not in code_lower: |
| issues.append("Query asks for grouping but code doesn't use groupby()") |
| if any(w in query_lower for w in ['filter', 'where']) and '==' not in code_lower: |
| issues.append("Query asks for filtering but code doesn't have filter condition") |
|
|
| return issues |
|
|
|
|
| def post_process_code(code, user_query): |
| code = re.sub(r'\.groupby\(\)\.groupby\(\)', '.groupby()', code) |
| if 'df[' not in code and "df." not in code and "groupby" in code: |
| code = f"df.{code}" if "=" not in code else f"df[{code}]" |
| code = re.sub(r'\.\.', '.', code) |
| return code |
|
|
| def normalize_name(name): |
| """Normalize column names for consistent comparison""" |
| if not isinstance(name, str): |
| return name |
| |
| return re.sub(r'[^a-z0-9]', '', name.lower()) |
|
|
| |
| |
| |
| class RobustHybridText2Code: |
| def __init__(self, data_folder="data", |
| model_dir=r"D:\final_claimbotics\claimbotics_model\kaggle\working\codegen_model\final_model"): |
| self.data = load_training_data(data_folder) |
| self.retriever = EnhancedRetriever(self.data) |
| self.generator = Generator(model_dir) |
| |
| all_cols = set() |
| for item in self.data: |
| code = item.get("pandas_code", "") |
| |
| cols = re.findall(r"df\[['\"]([^'\"]+)['\"]\]", code) |
| all_cols.update(cols) |
| self.col_map = {normalize_name(c): c for c in all_cols} |
|
|
| def get_code(self, user_query): |
| retrieved_results = self.retriever.retrieve_best_match(user_query, top_k=3) |
| best = select_best_template(retrieved_results, user_query) |
|
|
| print(f"🔍 [Best Match Similarity: {best['similarity']:.2f}]") |
| print(f"📝 Original Query: {best['query']}") |
|
|
| if best["similarity"] > 0.90: |
| print("🎯 High similarity (≥ 0.90) — using code directly from data.") |
| code = best["pandas_code"] |
| |
| elif best["similarity"] >= 0.75: |
| print("🔄 Using retrieved code with enhanced adaptation...") |
| code = enhanced_adaptation(user_query, best["pandas_code"], best["query"]) |
| else: |
| print("🤖 Low similarity — generating new code...") |
| code = self.generator.generate(user_query) |
|
|
| code = post_process_code(code, user_query) |
| issues = validate_code_against_query(code, user_query) |
| if issues: |
| print(f"⚠️ Validation issues: {issues}") |
|
|
| return code |
|
|
|
|
| |
| |
| |
| if __name__ == "__main__": |
| print("💬 Enhanced ClaimBotics Hybrid Text→Code System Ready!\n") |
| print("=" * 60) |
|
|
| bot = RobustHybridText2Code( |
| data_folder="data", |
| model_dir=r"D:\final_claimbotics\claimbotics_model\kaggle\working\codegen_model\final_model" |
| ) |
|
|
| while True: |
| user_input = input("\n🧑 You: ").strip() |
| if user_input.lower() in ["exit", "quit", "bye"]: |
| print("👋 Goodbye!") |
| break |
| if not user_input: |
| continue |
|
|
| try: |
| code = bot.get_code(user_input) |
| print(f"\n🤖 Suggested Pandas Code:\n{code}") |
| print("=" * 60) |
| except Exception as e: |
| print(f"❌ Error: {e}") |
| print("Please try again with a different query.") |
|
|
