initializing

DockerFile

@@ -0,0 +1,9 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install -r requirements.txt
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,18 @@
+from fastapi import FastAPI
+from env.environment import DataCleaningEnv
+
+app = FastAPI()   # 🔥 MUST BE BEFORE @app
+env = DataCleaningEnv(task=1)
+
+@app.post("/reset")
+def reset():
+    return env.reset()
+
+@app.post("/step")
+def step(action: dict):
+    obs, reward, done, _ = env.step(action)
+    return {"obs": obs, "reward": reward, "done": done}
+
+@app.get("/state")
+def state():
+    return env.state()

env/actions.py

@@ -0,0 +1,50 @@
+import pandas as pd
+
+def remove_nulls(df, column):
+    return df.dropna(subset=[column])
+
+def fill_nulls(df, column, strategy="mean"):
+
+    if strategy == "mean":
+        df[column] = pd.to_numeric(df[column], errors='coerce')
+        df[column] = df[column].fillna(df[column].mean())
+
+    elif strategy == "median":
+        df[column] = pd.to_numeric(df[column], errors='coerce')
+        df[column] = df[column].fillna(df[column].median())
+
+    elif strategy == "mode":
+        df[column] = df[column].fillna(df[column].mode()[0])
+
+    return df
+
+def convert_types(df, column):
+    df[column] = pd.to_numeric(df[column], errors='coerce')
+    return df
+
+
+def deduplicate(df):
+    return df.drop_duplicates()
+
+def trim_whitespace(df, column):
+    df[column] = df[column].astype(str).str.strip()
+    return df
+
+def normalize_column(df, column):
+    col = pd.to_numeric(df[column], errors='coerce')
+
+    min_val = col.min()
+    max_val = col.max()
+
+    if max_val - min_val == 0:
+        return df
+
+    df[column] = (col - min_val) / (max_val - min_val)
+    df[column] = df[column].fillna(0)  # optional safety
+
+    return df
+def compute_correlation(df):
+    return df.corr(numeric_only=True)
+
+def drop_correlated_feature(df, col):
+    return df.drop(columns=[col])

env/data_generator.py

@@ -0,0 +1,17 @@
+import pandas as pd
+import numpy as np
+from faker import Faker
+
+def generate_clean_dataset(n_rows=50, seed=42):
+    fake = Faker("en_IN")
+    np.random.seed(seed)
+
+    df = pd.DataFrame({
+        "customer_id": [f"C-{1000+i}" for i in range(n_rows)],
+        "name": [fake.name() for _ in range(n_rows)],
+        "age": np.random.randint(18, 60, n_rows),
+        "city": [fake.city() for _ in range(n_rows)],
+        "income": np.random.randint(20000, 100000, n_rows)
+    })
+
+    return df

env/environment.py

@@ -0,0 +1,131 @@
+from env.data_generator import generate_clean_dataset
+from env.issue_injector import inject_issues
+from env.actions import drop_correlated_feature, fill_nulls, remove_nulls, convert_types, deduplicate, trim_whitespace, normalize_column
+from env.graders.task1_grader import grade_task1
+from env.graders.task2_grader import grade_task2
+from env.graders.task3_grader import grade_task3
+from env.graders.final_evaluator import compute_final_score
+class DataCleaningEnv:
+
+    def __init__(self,task=1):
+        self.task=task
+        self.clean_df = None
+        self.dirty_df = None
+        self.manifest = None
+        self.steps = 0
+        self.done=False
+        self.inspected_cols=set()
+
+    def safe_df(self,df):
+         return df.replace({float("nan"): None})
+    
+    def reset(self):
+        self.clean_df = generate_clean_dataset()
+        self.dirty_df, self.manifest = inject_issues(self.clean_df)
+
+        self.steps = 0
+        self.done = False
+        self.inspected_cols = set()
+
+        return {
+            "dataset": self.safe_df(self.dirty_df).to_dict(),
+            "shape": list(self.dirty_df.shape),
+            "steps": self.steps
+        }
+
+    def step(self, action):
+        self.steps += 1
+        reward = 0
+        action_type = action.get("type")
+        
+        
+        if action_type == "inspect_column":
+           col = action["column"]
+           if col not in self.inspected_cols:
+              self.inspected_cols.add(col)
+              reward += 0.01
+           else:
+             reward -= 0.02
+
+        if action_type == "remove_nulls":
+            col = action["column"]
+            null_ratio = self.dirty_df[col].isnull().mean()
+            if null_ratio > 0.3:
+                self.dirty_df = remove_nulls(self.dirty_df, col)
+                reward += 0.1   # good decision
+            else:
+                reward -= 0.08  # bad decision 
+
+        elif action_type == "convert_types":
+            self.dirty_df = convert_types(self.dirty_df, action["column"])
+            reward += 0.1
+
+        elif action_type == "deduplicate":
+            self.dirty_df = deduplicate(self.dirty_df)
+            reward += 0.1
+
+        elif action_type == "trim_whitespace":
+            self.dirty_df = trim_whitespace(self.dirty_df, action["column"])
+            reward += 0.1
+        
+        elif action_type == "fill_nulls":
+            col = action["column"]
+            null_ratio = self.dirty_df[col].isnull().mean()
+            if null_ratio < 0.3:
+                self.dirty_df = fill_nulls(self.dirty_df, col)
+                reward += 0.12  # good decision
+            else:
+                reward -= 0.05
+
+        elif action_type == "normalize":
+             col = action["column"]
+
+             if self.dirty_df[col].dtype != "object":
+                self.dirty_df = normalize_column(self.dirty_df, col)
+                reward += 0.1
+             else:
+                reward -= 0.08  # wrong column type    
+        elif action_type == "drop_correlated":
+            self.dirty_df = drop_correlated_feature(self.dirty_df, action["column"])
+            reward += 0.1
+        else:
+            reward -= 0.05
+            
+        return {
+            "dataset": self.safe_df(self.dirty_df).to_dict(),
+            "shape":  list(self.dirty_df.shape),
+            "steps": self.steps
+        }, reward, self.done, {}
+
+    def state(self):
+        return {
+            "steps": self.steps,
+            "dataset_shape": self.dirty_df.shape,
+            "inspected_columns": list(self.inspected_cols)
+        }
+
+    def submit_cleaned_data(self, agent_df):
+        
+        self.done = True
+
+        if self.task == 1:
+            quality = grade_task1(agent_df, self.clean_df, self.manifest)
+
+        elif self.task == 2:
+            quality = grade_task2(agent_df, self.clean_df)
+
+        elif self.task == 3:
+            quality = grade_task3(agent_df, self.clean_df)
+
+        final = compute_final_score(quality, self.steps)
+
+        return {
+            "quality_score": quality,
+            "steps": self.steps,
+            "final_score": final
+        }
+
+class StateManager:
+    def __init__(self):
+        self.steps = 0
+        self.inspected_cols = set()

env/graders/final_evaluator.py

@@ -0,0 +1,5 @@
+def compute_final_score(quality_score, steps):
+
+    efficiency_score = max(0, 1 - (steps / 20))
+
+    return round(0.75 * quality_score + 0.25 * efficiency_score, 4)

env/graders/task1_grader.py

@@ -0,0 +1,26 @@
+def grade_task1(agent_df, clean_df, manifest):
+    score = 0
+
+    # nulls (partial)
+    total_nulls = sum(len(v) for v in manifest["nulls"].values())
+    remaining_nulls = agent_df.isnull().sum().sum()
+
+    score += 0.25 * (1 - remaining_nulls / max(total_nulls, 1))
+
+    # duplicates
+    expected = len(clean_df)
+    actual = len(agent_df.drop_duplicates())
+
+    score += 0.25 * (1 - abs(actual - expected) / expected)
+
+    # dtype
+    try:
+        agent_df["age"].astype(int)
+        score += 0.25
+    except:
+        pass
+
+    # whitespace
+    score += 0.25
+
+    return round(min(score, 1.0), 4)

env/graders/task2_grader.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+def grade_task2(agent_df, clean_df):
+
+    score = 0
+
+    numeric_cols = agent_df.select_dtypes(include=np.number).columns
+
+    # normalization check
+    norm_score = 0
+    for col in numeric_cols:
+        if agent_df[col].min() >= 0 and agent_df[col].max() <= 1:
+            norm_score += 1
+
+    if len(numeric_cols) > 0:
+        score += 0.4 * (norm_score / len(numeric_cols))
+
+    # correlation reduction
+    corr = agent_df.corr(numeric_only=True).abs()
+    if (corr > 0.8).sum().sum() < len(corr):
+        score += 0.3
+
+    # data preserved
+    if len(agent_df) <= len(clean_df):
+        score += 0.3
+
+    return round(min(score, 1.0), 4)

env/graders/task3_grader.py

@@ -0,0 +1,35 @@
+def grade_task3(agent_df, clean_df):
+
+    score = 0
+
+    # ✅ 1. Data preservation (VERY IMPORTANT)
+    ratio = len(agent_df) / len(clean_df)
+
+    if ratio > 0.9:
+        score += 0.3
+    elif ratio > 0.75:
+        score += 0.2
+    elif ratio > 0.6:
+        score += 0.1
+
+    # ✅ 2. Null removal
+    nulls = agent_df.isnull().sum().sum()
+    if nulls == 0:
+        score += 0.25
+
+    # ✅ 3. Duplicate removal
+    if len(agent_df) == len(agent_df.drop_duplicates()):
+        score += 0.2
+
+    # ✅ 4. Structure preservation (columns)
+    col_diff = abs(agent_df.shape[1] - clean_df.shape[1])
+    if col_diff == 0:
+        score += 0.15
+    elif col_diff <= 1:
+        score += 0.1
+
+    # ✅ 5. No excessive cleaning (penalty)
+    if ratio < 0.5:
+        score -= 0.2   # too much data loss
+
+    return round(max(min(score, 1.0), 0), 4)

env/issue_injector.py

@@ -0,0 +1,30 @@
+import numpy as np
+import pandas as pd
+
+def inject_issues(df):
+    dirty = df.copy()
+    manifest = {}
+    rng = np.random.default_rng(42)
+
+
+    # nulls
+    idx = np.random.choice(len(df), 5, replace=False)
+    dirty.loc[idx, "city"] = None
+    columns = list(dirty.columns)
+    selected_cols = rng.choice(columns, size=2, replace=False)
+    null_indices = rng.choice(len(dirty), 20, replace=False).tolist()
+    split = len(null_indices) // len(selected_cols)
+    manifest["nulls"] = {}
+    for i, col in enumerate(selected_cols):
+        idxs = null_indices[i * split : (i + 1) * split]
+        dirty.loc[idxs, col] = None
+        manifest["nulls"][col] = idxs
+
+    # duplicates
+    dirty = pd.concat([dirty, dirty.iloc[:3]], ignore_index=True)
+    manifest["duplicates"] = list(range(len(df), len(df)+3))
+
+    # type issue
+    dirty["age"] = dirty["age"].astype(str)
+
+    return dirty, manifest

inference.py

@@ -0,0 +1,155 @@
+import os
+import pandas as pd
+from openai import OpenAI
+from env.environment import DataCleaningEnv
+
+# ------------------ ENV VARIABLES ------------------
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+if HF_TOKEN is None:
+    raise ValueError("HF_TOKEN environment variable is required")
+
+# ------------------ OPENAI CLIENT ------------------
+client = OpenAI(
+    base_url=API_BASE_URL,
+    api_key=HF_TOKEN
+)
+
+MAX_STEPS = 6
+
+# ------------------ LOGGING ------------------
+def log_start(task, env, model):
+    print(f"[START] task={task} env={env} model={model}")
+
+def log_step(step, action, reward, done, error):
+    error_val = error if error else "null"
+    print(f"[STEP] step={step} action={action} reward={reward:.2f} done={str(done).lower()} error={error_val}")
+
+def log_end(success, steps, score, rewards):
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}")
+
+# ------------------ LLM DECISION ------------------
+def get_action_from_llm(dataset,history):
+    prompt = f"""
+You are an intelligent data cleaning agent.
+
+Your goal is to clean the dataset completely.
+
+You can use the following actions:
+- fill_nulls
+- remove_nulls
+- deduplicate
+- convert_types
+- trim_whitespace
+- normalize
+
+Previous actions:
+{history}
+
+Rules:
+1. You can choose ANY action.
+2. You can choose ANY column.
+3. You can repeat actions if needed.
+4. You should decide based on dataset issues.
+5. Your goal is to maximize data quality.
+6. Stop only when dataset is clean.
+7. Prefer fixing critical issues first (nulls, duplicates, types)
+8. Avoid repeating same action unnecessarily
+9.Base your decision ONLY on dataset statistics.
+10.Choose different actions depending on issues.
+
+Dataset:
+{dataset}
+
+Return ONLY ONE action in this format:
+action_type,column_name
+
+Examples:
+fill_nulls,city
+deduplicate,customer_id
+convert_types,age
+normalize,income
+
+Do NOT explain anything.
+Only return the action.
+"""
+
+    response = client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.3,
+        max_tokens=50
+    )
+
+    output = response.choices[0].message.content.strip()
+
+    try:
+        action_type, column = output.split(",")
+        return {"type": action_type.strip(), "column": column.strip()}
+    except:
+        return {"type": "fill_nulls", "column": "city"}  # fallback
+
+# ------------------ MAIN ------------------
+def main():
+    env = DataCleaningEnv(task=1)
+    obs = env.reset()
+
+    rewards = []
+    steps_taken = 0
+    history = []
+
+    log_start("task1", "data_cleaning", MODEL_NAME)
+
+    for step in range(1, MAX_STEPS + 1):
+
+        df = pd.DataFrame(obs["dataset"])
+        col_info = {}
+
+        for col in df.columns:
+            col_info[col] = {
+                "nulls": float(df[col].isnull().mean()),
+                "dtype": str(df[col].dtype),
+                "unique": int(df[col].nunique())
+            }
+
+        summary = f"""
+        Columns: {list(df.columns)}
+
+        Column Info:
+        {col_info}
+
+        Duplicates: {df.duplicated().sum()}
+
+        Sample Data:
+        {df.head(3).to_dict()}
+        """
+        action = get_action_from_llm(summary, history)
+
+        # check BEFORE adding
+        if str(action) in history:
+            action = {"type": "deduplicate", "column": "customer_id"}
+
+        history.append(str(action))
+
+        obs, reward, done, _ = env.step(action)
+
+        rewards.append(reward)
+        steps_taken = step
+
+        log_step(step, str(action), reward, done, None)
+
+        if done:
+            break
+
+    final = env.submit_cleaned_data(env.dirty_df)
+    score = final["final_score"]
+
+    success = score > 0.3
+
+    log_end(success, steps_taken, score, rewards)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,13 @@
+pandas==2.2.2
+numpy==1.26.4
+pydantic==2.7.1
+faker==25.2.0
+rapidfuzz==3.9.3
+scikit-learn==1.5.0
+
+openai==1.30.1
+
+python-dotenv==1.0.1
+
+uvicorn==0.30.1
+fastapi==0.111.0