Update app.py

b44acec verified about 1 year ago

5.86 kB

import gradio as gr
import random, json, os
import pandas as pd
import joblib
from huggingface_hub import hf_hub_download

REPO_ID = "DetectiveShadow/Entrepreneurial_predictor"

# --- Try loading trained regressor + feature columns from Hub; fall back to heuristic if not available ---
regressor = None
FEATURE_COLUMNS = None
try:
    reg_path  = hf_hub_download(REPO_ID, "regressor.pkl")
    feat_path = hf_hub_download(REPO_ID, "feature_columns.json")
    regressor = joblib.load(reg_path)
    with open(feat_path, "r") as f:
        FEATURE_COLUMNS = json.load(f)
except Exception as e:
    print("⚠️ Could not load regressor from Hub; will use heuristic. Error:", e)

def confidence_to_bonus(conf):
    return {"Low": 0, "Medium": 5, "High": 10}.get(conf, 5)

def heuristic_score(profile):
    # Matches earlier heuristic logic
    disposable = profile["income"] - profile["bills"] - profile["entertainment"]
    score = (
        (profile["savings"] + profile["assets"]) / 1000
        + disposable / 500
        + profile["sales_skills"] * 2
        + profile["idea_level"] * 3
        + profile["entrepreneurial_experience"] * 2
        + confidence_to_bonus(profile["confidence"])
        - profile["dependents"]
        + (40 - abs(35 - profile["age"])) / 5
    )
    return max(0, min(100, score))

def level_from_score(score):
    if score < 30: return "Low"
    if score < 60: return "Moderate"
    return "High"

def build_features_df(profile):
    # Build a one-row DataFrame in the same format as training
    base = pd.DataFrame([[
        profile["savings"], profile["income"], profile["bills"], profile["entertainment"],
        profile["assets"], profile["sales_skills"], profile["confidence"], profile["dependents"],
        profile["age"], profile["idea_level"], profile["entrepreneurial_experience"]
    ]], columns=[
        "savings","income","bills","entertainment","assets",
        "sales_skills","confidence","dependents","age",
        "idea_level","entrepreneurial_experience"
    ])
    df = pd.get_dummies(base, columns=["confidence"])
    if FEATURE_COLUMNS is not None:
        # ensure all training cols present
        for col in FEATURE_COLUMNS:
            if col not in df.columns:
                df[col] = 0
        df = df[FEATURE_COLUMNS]
    return df

def compute_score(profile):
    if regressor is not None and FEATURE_COLUMNS is not None:
        X = build_features_df(profile)
        try:
            pred = float(regressor.predict(X)[0])
            return max(0, min(100, pred))
        except Exception as e:
            print("⚠️ Regressor prediction failed, fallback to heuristic:", e)
    return heuristic_score(profile)

# --- Scenario generator ---
def random_profile():
    return {
        "savings": random.randint(0, 20000),
        "income": random.randint(1500, 10000),
        "bills": random.randint(500, 8000),
        "entertainment": random.randint(0, 1500),
        "assets": random.randint(0, 60000),
        "sales_skills": random.randint(1, 5),
        "confidence": random.choice(["Low", "Medium", "High"]),
        "dependents": random.randint(0, 6),
        "age": random.randint(18, 64),
        "idea_level": random.randint(1, 10),
        "entrepreneurial_experience": random.randint(0, 10),
    }

def profile_to_story(p):
    # A friendly, human-readable scenario
    parts = []
    parts.append(f"{p['age']}-year-old aspiring founder with {p['dependents']} dependents.")
    parts.append(f"Savings of ${p['savings']:,} and assets totaling ${p['assets']:,}.")
    parts.append(f"Monthly income ${p['income']:,}, bills ${p['bills']:,}, entertainment ${p['entertainment']:,}.")
    parts.append(f"Sales skills rated {p['sales_skills']}/5 and confidence **{p['confidence']}**.")
    parts.append(f"Business idea quality {p['idea_level']}/10 and entrepreneurial experience {p['entrepreneurial_experience']} year(s).")
    return " ".join(parts)

# --- Gradio app logic ---
def new_scenario():
    p = random_profile()
    story = profile_to_story(p)
    true_score = round(compute_score(p), 2)
    true_level = level_from_score(true_score)
    # We keep true values hidden in state; return the story, reset guess, and stash state
    return story, 50, {"profile": p, "score": true_score, "level": true_level}

def check_guess(guess, state):
    if not state or "score" not in state:
        return {"error": "No scenario generated yet. Click '🎲 New Scenario' first."}
    true_score = state["score"]
    true_level = state["level"]
    delta = round(abs(true_score - float(guess)), 2)
    verdict = "✅ Great guess!" if delta <= 5 else ("🟡 Close!" if delta <= 10 else "❌ Not quite.")
    return {
        "Your Guess": float(guess),
        "Actual Score": true_score,
        "Readiness Level": true_level,
        "Off by": delta,
        "Verdict": verdict
    }

with gr.Blocks() as demo:
    gr.Markdown("# 🎯 Guess the Entrepreneurial Readiness")
    gr.Markdown(
        "I’ll generate a random founder profile. **You guess the readiness score (0–100)**, "
        "then we’ll reveal the actual score and level."
    )

    state = gr.State()  # holds {"profile": ..., "score": ..., "level": ...}

    with gr.Row():
        with gr.Column(scale=3):
            scenario_md = gr.Markdown("Click **New Scenario** to start.")
            with gr.Row():
                new_btn = gr.Button("🎲 New Scenario", variant="primary")
                guess = gr.Slider(0, 100, value=50, step=1, label="Your Guess (0–100)")
                reveal_btn = gr.Button("🔍 Check My Guess")
        with gr.Column(scale=2):
            result = gr.JSON(label="Result")

    # Wire events
    new_btn.click(fn=new_scenario, inputs=None, outputs=[scenario_md, guess, state])
    reveal_btn.click(fn=check_guess, inputs=[guess, state], outputs=result)

demo.launch()

	import gradio as gr
	import random, json, os
	import pandas as pd
	import joblib
	from huggingface_hub import hf_hub_download

	REPO_ID = "DetectiveShadow/Entrepreneurial_predictor"

	# --- Try loading trained regressor + feature columns from Hub; fall back to heuristic if not available ---
	regressor = None
	FEATURE_COLUMNS = None
	try:
	reg_path = hf_hub_download(REPO_ID, "regressor.pkl")
	feat_path = hf_hub_download(REPO_ID, "feature_columns.json")
	regressor = joblib.load(reg_path)
	with open(feat_path, "r") as f:
	FEATURE_COLUMNS = json.load(f)
	except Exception as e:
	print("⚠️ Could not load regressor from Hub; will use heuristic. Error:", e)

	def confidence_to_bonus(conf):
	return {"Low": 0, "Medium": 5, "High": 10}.get(conf, 5)

	def heuristic_score(profile):
	# Matches earlier heuristic logic
	disposable = profile["income"] - profile["bills"] - profile["entertainment"]
	score = (
	(profile["savings"] + profile["assets"]) / 1000
	+ disposable / 500
	+ profile["sales_skills"] * 2
	+ profile["idea_level"] * 3
	+ profile["entrepreneurial_experience"] * 2
	+ confidence_to_bonus(profile["confidence"])
	- profile["dependents"]
	+ (40 - abs(35 - profile["age"])) / 5
	)
	return max(0, min(100, score))

	def level_from_score(score):
	if score < 30: return "Low"
	if score < 60: return "Moderate"
	return "High"

	def build_features_df(profile):
	# Build a one-row DataFrame in the same format as training
	base = pd.DataFrame([[
	profile["savings"], profile["income"], profile["bills"], profile["entertainment"],
	profile["assets"], profile["sales_skills"], profile["confidence"], profile["dependents"],
	profile["age"], profile["idea_level"], profile["entrepreneurial_experience"]
	]], columns=[
	"savings","income","bills","entertainment","assets",
	"sales_skills","confidence","dependents","age",
	"idea_level","entrepreneurial_experience"
	])
	df = pd.get_dummies(base, columns=["confidence"])
	if FEATURE_COLUMNS is not None:
	# ensure all training cols present
	for col in FEATURE_COLUMNS:
	if col not in df.columns:
	df[col] = 0
	df = df[FEATURE_COLUMNS]
	return df

	def compute_score(profile):
	if regressor is not None and FEATURE_COLUMNS is not None:
	X = build_features_df(profile)
	try:
	pred = float(regressor.predict(X)[0])
	return max(0, min(100, pred))
	except Exception as e:
	print("⚠️ Regressor prediction failed, fallback to heuristic:", e)
	return heuristic_score(profile)

	# --- Scenario generator ---
	def random_profile():
	return {
	"savings": random.randint(0, 20000),
	"income": random.randint(1500, 10000),
	"bills": random.randint(500, 8000),
	"entertainment": random.randint(0, 1500),
	"assets": random.randint(0, 60000),
	"sales_skills": random.randint(1, 5),
	"confidence": random.choice(["Low", "Medium", "High"]),
	"dependents": random.randint(0, 6),
	"age": random.randint(18, 64),
	"idea_level": random.randint(1, 10),
	"entrepreneurial_experience": random.randint(0, 10),
	}

	def profile_to_story(p):
	# A friendly, human-readable scenario
	parts = []
	parts.append(f"{p['age']}-year-old aspiring founder with {p['dependents']} dependents.")
	parts.append(f"Savings of ${p['savings']:,} and assets totaling ${p['assets']:,}.")
	parts.append(f"Monthly income ${p['income']:,}, bills ${p['bills']:,}, entertainment ${p['entertainment']:,}.")
	parts.append(f"Sales skills rated {p['sales_skills']}/5 and confidence {p['confidence']}.")
	parts.append(f"Business idea quality {p['idea_level']}/10 and entrepreneurial experience {p['entrepreneurial_experience']} year(s).")
	return " ".join(parts)

	# --- Gradio app logic ---
	def new_scenario():
	p = random_profile()
	story = profile_to_story(p)
	true_score = round(compute_score(p), 2)
	true_level = level_from_score(true_score)
	# We keep true values hidden in state; return the story, reset guess, and stash state
	return story, 50, {"profile": p, "score": true_score, "level": true_level}

	def check_guess(guess, state):
	if not state or "score" not in state:
	return {"error": "No scenario generated yet. Click '🎲 New Scenario' first."}
	true_score = state["score"]
	true_level = state["level"]
	delta = round(abs(true_score - float(guess)), 2)
	verdict = "✅ Great guess!" if delta <= 5 else ("🟡 Close!" if delta <= 10 else "❌ Not quite.")
	return {
	"Your Guess": float(guess),
	"Actual Score": true_score,
	"Readiness Level": true_level,
	"Off by": delta,
	"Verdict": verdict
	}

	with gr.Blocks() as demo:
	gr.Markdown("# 🎯 Guess the Entrepreneurial Readiness")
	gr.Markdown(
	"I’ll generate a random founder profile. You guess the readiness score (0–100), "
	"then we’ll reveal the actual score and level."
	)

	state = gr.State() # holds {"profile": ..., "score": ..., "level": ...}

	with gr.Row():
	with gr.Column(scale=3):
	scenario_md = gr.Markdown("Click New Scenario to start.")
	with gr.Row():
	new_btn = gr.Button("🎲 New Scenario", variant="primary")
	guess = gr.Slider(0, 100, value=50, step=1, label="Your Guess (0–100)")
	reveal_btn = gr.Button("🔍 Check My Guess")
	with gr.Column(scale=2):
	result = gr.JSON(label="Result")

	# Wire events
	new_btn.click(fn=new_scenario, inputs=None, outputs=[scenario_md, guess, state])
	reveal_btn.click(fn=check_guess, inputs=[guess, state], outputs=result)

	demo.launch()