| import os | |
| import re | |
| import json | |
| import torch | |
| from sentence_transformers import SentenceTransformer, util | |
| from transformers import AutoTokenizer, AutoModelForSeq2SeqLM | |
| # ========================================== | |
| # STEP 1: Load Training Data Safely | |
| # ========================================== | |
| 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 | |
| # ========================================== | |
| # STEP 2: Enhanced Retriever | |
| # ========================================== | |
| 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 | |
| # ========================================== | |
| # STEP 3: Generator (CodeT5 / fine-tuned model) | |
| # ========================================== | |
| 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) | |
| # ========================================== | |
| # STEP 4: Adaptation Utilities | |
| # ========================================== | |
| 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 | |
| ##commented for only the testing it is working but not only normalize | |
| # def enhanced_adaptation(user_query, code, original_retrieved_query): | |
| # """More intelligent code adaptation""" | |
| # 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 orig_col.lower() != new_col.lower(): | |
| # 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) | |
| # 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 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 | |
| # 🆕 Replace columns based on normalized mapping | |
| 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) | |
| # 🆕 Optional: map normalized query columns to known dataset columns | |
| 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) | |
| # Keep value and operation adaptation | |
| 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 | |
| # ========================================== | |
| # STEP 5: Template Selection | |
| # ========================================== | |
| 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 | |
| # ========================================== | |
| # STEP 6: Validation & Post-Processing | |
| # ========================================== | |
| 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 | |
| # Lowercase, remove special chars and spaces | |
| return re.sub(r'[^a-z0-9]', '', name.lower()) | |
| # ========================================== | |
| # STEP 7: Main Hybrid System | |
| # ========================================== | |
| 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", "") | |
| # Extract column names from code strings | |
| 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 | |
| # ========================================== | |
| # STEP 8: Run Interactive Chat | |
| # ========================================== | |
| 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.") | |