import gradio as gr import pandas as pd import numpy as np from datetime import datetime import plotly.graph_objects as go import re from urllib.parse import urlparse import requests import json import os class StartupValuationCalculator: def __init__(self): # 업종별 벤치마크 멀티플 (EV/ARR) self.industry_multiples = { "SaaS - B2B": {"low": 3, "mid": 6, "high": 10}, "SaaS - B2C": {"low": 2, "mid": 4, "high": 7}, "마켓플레이스": {"low": 2, "mid": 5, "high": 8}, "이커머스": {"low": 1, "mid": 2.5, "high": 4}, "핀테크": {"low": 3, "mid": 5, "high": 8}, "헬스케어": {"low": 4, "mid": 7, "high": 12}, "AI/딥테크": {"low": 5, "mid": 8, "high": 15}, "기타": {"low": 2, "mid": 4, "high": 6} } # 성장률 조정 계수 self.growth_adjustments = { "0-20%": 0.7, "20-50%": 0.9, "50-100%": 1.1, "100-200%": 1.3, "200%+": 1.5 } # 버크스 방법 카테고리별 최대값 ($500K each) self.berkus_max_values = { "sound_idea": 500000, "prototype": 500000, "quality_team": 500000, "strategic_relationships": 500000, "product_rollout": 500000 } # 스코어카드 가중치 self.scorecard_weights = { "team": 0.30, "market_size": 0.25, "product": 0.15, "competition": 0.10, "marketing": 0.10, "need_for_funding": 0.05, "other": 0.05 } # 언어별 텍스트 self.translations = { "ko": { "title": "🦄 스타트업 가치평가 자동화 시스템 v3.0", "subtitle": "버크스 방법과 스코어카드 방법을 포함한 종합 평가", "valuation_result": "가치평가 결과", "company_value": "기업가치", "arr": "연간 반복 매출", "multiple": "적용 멀티플", "unit_economics": "단위경제", "berkus_score": "버크스 평가", "scorecard_score": "스코어카드 평가", "financial_health": "재무 건전성", "insights": "평가 인사이트" }, "en": { "title": "🦄 Startup Valuation System v3.0", "subtitle": "Comprehensive valuation with Berkus and Scorecard methods", "valuation_result": "Valuation Result", "company_value": "Company Value", "arr": "Annual Recurring Revenue", "multiple": "Applied Multiple", "unit_economics": "Unit Economics", "berkus_score": "Berkus Score", "scorecard_score": "Scorecard Score", "financial_health": "Financial Health", "insights": "Valuation Insights" } } def call_llm_api(self, prompt, api_key): """LLM API를 호출하여 고급 분석 수행""" if not api_key: return None url = "https://api.fireworks.ai/inference/v1/chat/completions" payload = { "model": "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507", "max_tokens": 4096, "top_p": 1, "top_k": 40, "presence_penalty": 0, "frequency_penalty": 0, "temperature": 0.6, "messages": [ { "role": "system", "content": "You are an expert startup valuation analyst and strategic advisor with deep knowledge of venture capital, financial analysis, and business strategy." }, { "role": "user", "content": prompt } ] } headers = { "Accept": "application/json", "Content-Type": "application/json", "Authorization": f"Bearer {api_key}" } try: response = requests.post(url, headers=headers, data=json.dumps(payload)) if response.status_code == 200: return response.json()['choices'][0]['message']['content'] else: return None except: return None def generate_strategic_report(self, data, results, language, api_key): """LLM을 사용하여 전략적 보고서 생성""" if language == "ko": prompt = f""" 다음 스타트업의 가치평가 결과를 분석하고 전략적 조언을 포함한 상세 보고서를 작성해주세요: 회사 정보: - 회사명: {data['company_name']} - 설립년도: {data['founded_year']} - 산업: {data['industry']} - 사업 단계: {data['stage']} 평가 결과: - 최종 기업가치: ${results['final_valuation']/1000000:.2f}M - 버크스 평가: ${results['berkus_valuation']/1000000:.2f}M - ARR: ${results['arr']/1000000:.2f}M - 성장률: {data['growth_rate']}% - LTV/CAC: {results['ltv_cac_ratio']:.1f} - 런웨이: {results['runway']:.1f}개월 - 스코어카드 점수들: {results['scorecard_adjustments']} 다음을 포함하여 작성해주세요: 1. 가치평가 결과의 타당성 분석 2. 동종업계 대비 포지셔닝 3. 주요 강점과 개선 필요 영역 4. 향후 6-12개월 전략적 우선순위 5. 자금조달 전략 및 적정 조달 규모 6. 주요 리스크와 완화 방안 7. 핵심 KPI와 마일스톤 제안 """ else: prompt = f""" Please analyze the following startup valuation results and provide a comprehensive strategic report: Company Information: - Company Name: {data['company_name']} - Founded: {data['founded_year']} - Industry: {data['industry']} - Stage: {data['stage']} Valuation Results: - Final Valuation: ${results['final_valuation']/1000000:.2f}M - Berkus Valuation: ${results['berkus_valuation']/1000000:.2f}M - ARR: ${results['arr']/1000000:.2f}M - Growth Rate: {data['growth_rate']}% - LTV/CAC: {results['ltv_cac_ratio']:.1f} - Runway: {results['runway']:.1f} months - Scorecard Scores: {results['scorecard_adjustments']} Please include: 1. Valuation validity analysis 2. Industry positioning 3. Key strengths and improvement areas 4. Strategic priorities for next 6-12 months 5. Fundraising strategy and optimal round size 6. Key risks and mitigation strategies 7. Core KPIs and milestone recommendations """ llm_response = self.call_llm_api(prompt, api_key) return llm_response def calculate_berkus_score(self, berkus_data): """버크스 방법으로 평가 (최대 $2.5M)""" scores = {} total = 0 # 1. 건전한 아이디어 (Sound Idea) idea_score = min(100, berkus_data["idea_validation"] + berkus_data["market_research"] * 10) scores["sound_idea"] = self.berkus_max_values["sound_idea"] * (idea_score / 100) # 2. 프로토타입 (Prototype) prototype_score = 0 if berkus_data["prototype_stage"] == "없음": prototype_score = 0 elif berkus_data["prototype_stage"] == "컨셉/목업": prototype_score = 30 elif berkus_data["prototype_stage"] == "작동 프로토타입": prototype_score = 60 elif berkus_data["prototype_stage"] == "베타 버전": prototype_score = 80 elif berkus_data["prototype_stage"] == "출시 버전": prototype_score = 100 scores["prototype"] = self.berkus_max_values["prototype"] * (prototype_score / 100) # 3. 우수한 팀 (Quality Team) team_score = min(100, min(berkus_data["team_experience"], 10) * 10 + # 최대 10년까지만 가산 berkus_data["domain_expertise"] * 15 + berkus_data["startup_experience"] * 15 ) scores["quality_team"] = self.berkus_max_values["quality_team"] * (team_score / 100) # 4. 전략적 관계 (Strategic Relationships) relationship_score = min(100, berkus_data["partnerships"] * 15 + berkus_data["advisors"] * 10 + berkus_data["pilot_customers"] * 25 ) scores["strategic_relationships"] = self.berkus_max_values["strategic_relationships"] * (relationship_score / 100) # 5. 제품 출시/판매 (Product Rollout) if berkus_data["sales_started"]: rollout_score = min(100, 50 + berkus_data["customer_validation"] * 10) else: rollout_score = berkus_data["launch_readiness"] scores["product_rollout"] = self.berkus_max_values["product_rollout"] * (rollout_score / 100) total = sum(scores.values()) return total, scores def calculate_scorecard_valuation(self, scorecard_data, base_valuation): """스코어카드 방법으로 조정된 가치평가""" adjustments = {} # 각 요소별 조정 비율 계산 (0.5 ~ 1.5) adjustments["team"] = scorecard_data["team_strength"] / 100 adjustments["market_size"] = scorecard_data["market_opportunity"] / 100 adjustments["product"] = scorecard_data["product_stage"] / 100 adjustments["competition"] = scorecard_data["competitive_advantage"] / 100 adjustments["marketing"] = scorecard_data["marketing_channels"] / 100 adjustments["need_for_funding"] = scorecard_data["funding_efficiency"] / 100 adjustments["other"] = scorecard_data["other_factors"] / 100 # 가중 평균 계산 weighted_score = 0 for factor, weight in self.scorecard_weights.items(): # 각 점수를 0.5 ~ 1.5 범위로 변환 (50점이 1.0) adjusted_score = 0.5 + (adjustments[factor]) weighted_score += adjusted_score * weight # 기본 가치평가에 조정 비율 적용 adjusted_valuation = base_valuation * weighted_score return adjusted_valuation, adjustments, weighted_score def calculate_arr(self, monthly_revenue, revenue_type): """월 매출을 연간 반복 매출(ARR)로 변환""" if revenue_type == "구독형 (SaaS)": return monthly_revenue * 12 elif revenue_type == "거래수수료형": return monthly_revenue * 12 * 0.8 else: return monthly_revenue * 12 * 0.6 def calculate_ltv(self, arpu, gross_margin, monthly_churn): """LTV 계산""" if monthly_churn == 0: monthly_churn = 0.01 return arpu * (gross_margin / 100) / monthly_churn def calculate_cac(self, monthly_marketing, monthly_sales, new_customers): """CAC 계산""" if new_customers == 0: return 0 return (monthly_marketing + monthly_sales) / new_customers def calculate_payback(self, cac, arpu, gross_margin): """Payback Period 계산 (개월)""" if arpu * (gross_margin / 100) == 0: return 999 return cac / (arpu * (gross_margin / 100)) def calculate_valuation(self, data, berkus_data, scorecard_data, use_revenue_multiple=True): """종합 가치평가 계산""" results = {} # 1. 버크스 방법 평가 berkus_valuation, berkus_scores = self.calculate_berkus_score(berkus_data) results["berkus_valuation"] = berkus_valuation results["berkus_scores"] = berkus_scores # 2. 매출 기반 평가 (매출이 있는 경우) if data["monthly_revenue"] > 0 and use_revenue_multiple: # ARR 계산 arr = self.calculate_arr(data["monthly_revenue"], data["revenue_type"]) # 단위경제 계산 ltv = self.calculate_ltv(data["arpu"], data["gross_margin"], data["monthly_churn"]) cac = self.calculate_cac(data["monthly_marketing"], data["monthly_sales"], data["new_customers"]) ltv_cac_ratio = ltv / cac if cac > 0 else 0 payback = self.calculate_payback(cac, data["arpu"], data["gross_margin"]) # 멀티플 결정 multiples = self.industry_multiples[data["industry"]] growth_category = self.get_growth_category(data["growth_rate"]) growth_adj = self.growth_adjustments[growth_category] # 기본 멀티플 선택 if ltv_cac_ratio >= 3: base_multiple = multiples["high"] elif ltv_cac_ratio >= 1.5: base_multiple = multiples["mid"] else: base_multiple = multiples["low"] adjusted_multiple = base_multiple * growth_adj # 매출 기반 가치평가 revenue_valuation = arr * adjusted_multiple results["arr"] = arr results["ltv"] = ltv results["cac"] = cac results["ltv_cac_ratio"] = ltv_cac_ratio results["payback"] = payback results["multiple"] = adjusted_multiple else: revenue_valuation = 0 results["arr"] = 0 results["ltv"] = 0 results["cac"] = 0 results["ltv_cac_ratio"] = 0 results["payback"] = 0 results["multiple"] = 0 # 3. 기본 가치평가 결정 (버크스 vs 매출 기반) if revenue_valuation > berkus_valuation * 1.5: base_valuation = revenue_valuation valuation_method = "revenue_multiple" else: base_valuation = max(berkus_valuation, revenue_valuation) valuation_method = "berkus" # 4. 스코어카드 조정 final_valuation, scorecard_adjustments, weighted_score = self.calculate_scorecard_valuation( scorecard_data, base_valuation ) results["base_valuation"] = base_valuation results["final_valuation"] = final_valuation results["valuation_method"] = valuation_method results["scorecard_adjustments"] = scorecard_adjustments results["scorecard_multiplier"] = weighted_score # 5. 런웨이 계산 results["runway"] = data["cash_balance"] / data["burn_rate"] if data["burn_rate"] > 0 else 999 return results def get_growth_category(self, growth_rate): """성장률 카테고리 결정""" if growth_rate < 20: return "0-20%" elif growth_rate < 50: return "20-50%" elif growth_rate < 100: return "50-100%" elif growth_rate < 200: return "100-200%" else: return "200%+" def create_valuation_comparison_chart(self, results, language="ko"): """평가 방법별 비교 차트""" fig = go.Figure() methods = ["Berkus", "Revenue Multiple", "Scorecard Adjusted"] values = [ results["berkus_valuation"], results["base_valuation"] if results["valuation_method"] == "revenue_multiple" else 0, results["final_valuation"] ] fig.add_trace(go.Bar( x=methods, y=values, text=[f"${v/1000000:.2f}M" for v in values], textposition="outside", marker_color=["lightblue", "lightgreen", "darkblue"] )) title = "평가 방법별 기업가치 비교" if language == "ko" else "Valuation by Method" fig.update_layout( title=title, yaxis_title="Valuation (USD)", showlegend=False, height=400 ) return fig def create_scorecard_radar_chart(self, adjustments, language="ko"): """스코어카드 요소별 점수 레이더 차트""" categories = list(adjustments.keys()) if language == "ko": categories_display = ["팀", "시장규모", "제품", "경쟁력", "마케팅", "자금효율", "기타"] else: categories_display = ["Team", "Market", "Product", "Competition", "Marketing", "Funding", "Other"] values = [adjustments[cat] * 100 for cat in categories] fig = go.Figure(data=go.Scatterpolar( r=values, theta=categories_display, fill='toself' )) title = "스코어카드 평가 요소" if language == "ko" else "Scorecard Factors" fig.update_layout( polar=dict( radialaxis=dict( visible=True, range=[0, 100] )), showlegend=False, title=title ) return fig def create_ui(): calculator = StartupValuationCalculator() def process_valuation( api_key, language, # 기본 정보 company_name, founded_year, industry, stage, revenue_type, # 매출 정보 monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn, retention_rate, new_customers, monthly_marketing, monthly_sales, # 재무 정보 cash_balance, burn_rate, # 버크스 방법 입력 idea_validation, market_research, prototype_stage, team_experience, domain_expertise, startup_experience, partnerships, advisors, pilot_customers, sales_started, customer_validation, launch_readiness, # 스코어카드 입력 team_strength, market_opportunity, product_stage, competitive_advantage, marketing_channels, funding_efficiency, other_factors ): # 데이터 준비 data = { "company_name": company_name, "founded_year": founded_year, "industry": industry, "stage": stage, "revenue_type": revenue_type, "monthly_revenue": monthly_revenue * 1000, "growth_rate": growth_rate, "arpu": arpu, "gross_margin": gross_margin, "monthly_churn": monthly_churn / 100, "retention_rate": retention_rate, "new_customers": new_customers, "monthly_marketing": monthly_marketing * 1000, "monthly_sales": monthly_sales * 1000, "cash_balance": cash_balance * 1000, "burn_rate": burn_rate * 1000 } berkus_data = { "idea_validation": idea_validation, "market_research": market_research, "prototype_stage": prototype_stage, "team_experience": team_experience, "domain_expertise": domain_expertise, "startup_experience": startup_experience, "partnerships": partnerships, "advisors": advisors, "pilot_customers": pilot_customers, "sales_started": sales_started, "customer_validation": customer_validation, "launch_readiness": launch_readiness } scorecard_data = { "team_strength": team_strength, "market_opportunity": market_opportunity, "product_stage": product_stage, "competitive_advantage": competitive_advantage, "marketing_channels": marketing_channels, "funding_efficiency": funding_efficiency, "other_factors": other_factors } # 가치평가 계산 use_revenue = monthly_revenue > 0 results = calculator.calculate_valuation(data, berkus_data, scorecard_data, use_revenue) # 언어별 텍스트 t = calculator.translations[language] # 결과 포맷팅 if language == "ko": valuation_text = f""" # 🚀 {company_name} {t['valuation_result']} ## 📊 종합 평가 - **{t['company_value']}**: ${results['final_valuation']/1000000:.2f}M - **평가 방법**: {'매출 멀티플' if results['valuation_method'] == 'revenue_multiple' else '버크스 방법'} + 스코어카드 조정 - **스코어카드 조정 배수**: {results['scorecard_multiplier']:.2f}x ## 🎯 {t['berkus_score']} (최대 $2.5M) - **총 평가액**: ${results['berkus_valuation']/1000000:.2f}M - 건전한 아이디어: ${results['berkus_scores']['sound_idea']/1000:.0f}K - 프로토타입: ${results['berkus_scores']['prototype']/1000:.0f}K - 우수한 팀: ${results['berkus_scores']['quality_team']/1000:.0f}K - 전략적 관계: ${results['berkus_scores']['strategic_relationships']/1000:.0f}K - 제품 출시: ${results['berkus_scores']['product_rollout']/1000:.0f}K """ else: valuation_text = f""" # 🚀 {company_name} {t['valuation_result']} ## 📊 Summary - **{t['company_value']}**: ${results['final_valuation']/1000000:.2f}M - **Method**: {'Revenue Multiple' if results['valuation_method'] == 'revenue_multiple' else 'Berkus Method'} + Scorecard - **Scorecard Multiplier**: {results['scorecard_multiplier']:.2f}x ## 🎯 {t['berkus_score']} (Max $2.5M) - **Total**: ${results['berkus_valuation']/1000000:.2f}M - Sound Idea: ${results['berkus_scores']['sound_idea']/1000:.0f}K - Prototype: ${results['berkus_scores']['prototype']/1000:.0f}K - Quality Team: ${results['berkus_scores']['quality_team']/1000:.0f}K - Strategic Relationships: ${results['berkus_scores']['strategic_relationships']/1000:.0f}K - Product Rollout: ${results['berkus_scores']['product_rollout']/1000:.0f}K """ # 매출 기반 평가 추가 (매출이 있는 경우) if use_revenue and results['arr'] > 0: if language == "ko": valuation_text += f""" ## 💰 매출 기반 평가 - **ARR**: ${results['arr']/1000000:.2f}M - **적용 멀티플**: {results['multiple']:.1f}x - **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x - **Payback**: {results['payback']:.1f}개월 """ else: valuation_text += f""" ## 💰 Revenue-based Valuation - **ARR**: ${results['arr']/1000000:.2f}M - **Multiple**: {results['multiple']:.1f}x - **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x - **Payback**: {results['payback']:.1f} months """ # 재무 건전성 if language == "ko": valuation_text += f""" ## 🏃 {t['financial_health']} - **현금 런웨이**: {results['runway']:.1f}개월 - **월간 번레이트**: ${burn_rate}K """ else: valuation_text += f""" ## 🏃 {t['financial_health']} - **Cash Runway**: {results['runway']:.1f} months - **Monthly Burn Rate**: ${burn_rate}K """ # LLM 기반 전략적 분석 추가 strategic_report = None if api_key and api_key.strip(): strategic_report = calculator.generate_strategic_report(data, results, language, api_key) if strategic_report: if language == "ko": valuation_text += f""" ## 🤖 AI 전략적 분석 {strategic_report} """ else: valuation_text += f""" ## 🤖 AI Strategic Analysis {strategic_report} """ # 차트 생성 comparison_chart = calculator.create_valuation_comparison_chart(results, language) scorecard_chart = calculator.create_scorecard_radar_chart(results['scorecard_adjustments'], language) # 상세 테이블 if language == "ko": methods_df = pd.DataFrame({ "평가 방법": ["버크스 방법", "매출 멀티플", "스코어카드 조정", "최종 평가"], "평가액": [ f"${results['berkus_valuation']/1000000:.2f}M", f"${results['base_valuation']/1000000:.2f}M" if results['valuation_method'] == 'revenue_multiple' else "N/A", f"{results['scorecard_multiplier']:.2f}x", f"${results['final_valuation']/1000000:.2f}M" ] }) else: methods_df = pd.DataFrame({ "Method": ["Berkus Method", "Revenue Multiple", "Scorecard Adjustment", "Final Valuation"], "Value": [ f"${results['berkus_valuation']/1000000:.2f}M", f"${results['base_valuation']/1000000:.2f}M" if results['valuation_method'] == 'revenue_multiple' else "N/A", f"{results['scorecard_multiplier']:.2f}x", f"${results['final_valuation']/1000000:.2f}M" ] }) return valuation_text, comparison_chart, scorecard_chart, methods_df # Gradio UI with gr.Blocks(title="Startup Valuation Calculator", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🦄 스타트업 가치평가 자동화 시스템 v3.5 ### AI 기반 전략적 분석을 포함한 종합 평가 시스템 """) # API 키와 언어 선택 with gr.Row(): api_key = gr.Textbox( label="Fireworks API Key (선택사항 - AI 분석용)", placeholder="AI 전략적 분석을 원하시면 API 키를 입력하세요", type="password" ) language = gr.Radio( choices=[("한국어", "ko"), ("English", "en")], value="ko", label="Language / 언어", type="value" ) with gr.Tab("기본 정보 / Basic Info"): with gr.Row(): company_name = gr.Textbox(label="회사명 / Company Name", value="우리 스타트업") founded_year = gr.Slider(2000, 2025, value=2022, step=1, label="설립연도 / Founded Year") with gr.Row(): industry = gr.Dropdown( choices=list(calculator.industry_multiples.keys()), value="SaaS - B2B", label="산업 분류 / Industry" ) stage = gr.Radio( choices=["MVP/베타", "초기 매출", "성장 단계", "수익성 확보"], value="초기 매출", label="사업 단계 / Stage" ) revenue_type = gr.Radio( choices=["구독형 (SaaS)", "거래수수료형", "일회성 판매"], value="구독형 (SaaS)", label="수익 모델 / Revenue Model" ) with gr.Tab("버크스 평가 / Berkus Method"): gr.Markdown("### 💡 아이디어 검증 / Idea Validation") with gr.Row(): idea_validation = gr.Slider(0, 100, value=70, step=10, label="아이디어 검증 수준 / Idea Validation Level (%)") market_research = gr.Slider(0, 10, value=5, step=1, label="시장 조사 깊이 / Market Research Depth (1-10)") gr.Markdown("### 🔧 프로토타입 / Prototype") prototype_stage = gr.Radio( choices=["없음", "컨셉/목업", "작동 프로토타입", "베타 버전", "출시 버전"], value="베타 버전", label="프로토타입 단계 / Prototype Stage" ) gr.Markdown("### 👥 팀 역량 / Team Quality") with gr.Row(): team_experience = gr.Slider(0, 30, value=5, step=1, label="팀 평균 경력(년) / Average Experience (years)") domain_expertise = gr.Slider(0, 5, value=3, step=1, label="도메인 전문성 / Domain Expertise (1-5)") startup_experience = gr.Slider(0, 5, value=2, step=1, label="스타트업 경험 / Startup Experience (1-5)") gr.Markdown("### 🤝 전략적 관계 / Strategic Relationships") with gr.Row(): partnerships = gr.Number(label="전략적 파트너십 수 / Strategic Partnerships", value=2) advisors = gr.Number(label="고문/멘토 수 / Advisors/Mentors", value=3) pilot_customers = gr.Number(label="파일럿 고객 수 / Pilot Customers", value=5) gr.Markdown("### 🚀 제품 출시 / Product Rollout") with gr.Row(): sales_started = gr.Checkbox(label="매출 발생 시작 / Sales Started", value=True) customer_validation = gr.Slider(0, 10, value=5, step=1, label="고객 검증 수준 / Customer Validation (1-10)") launch_readiness = gr.Slider(0, 100, value=80, step=10, label="출시 준비도 / Launch Readiness (%)") with gr.Tab("스코어카드 평가 / Scorecard"): gr.Markdown("### 각 요소를 동일 스테이지 평균 대비 평가 (50 = 평균)") gr.Markdown("### Rate each factor compared to same-stage average (50 = average)") team_strength = gr.Slider(0, 100, value=60, step=5, label="팀 역량 / Team Strength") market_opportunity = gr.Slider(0, 100, value=70, step=5, label="시장 기회 / Market Opportunity") product_stage = gr.Slider(0, 100, value=65, step=5, label="제품 완성도 / Product Maturity") competitive_advantage = gr.Slider(0, 100, value=55, step=5, label="경쟁 우위 / Competitive Advantage") marketing_channels = gr.Slider(0, 100, value=50, step=5, label="마케팅/판매 / Marketing & Sales") funding_efficiency = gr.Slider(0, 100, value=60, step=5, label="자금 효율성 / Funding Efficiency") other_factors = gr.Slider(0, 100, value=50, step=5, label="기타 요소 / Other Factors") with gr.Tab("매출 정보 / Revenue (Optional)"): gr.Markdown("### 💰 매출이 있는 경우만 입력 / Only if you have revenue") with gr.Row(): monthly_revenue = gr.Number(label="월 매출 / Monthly Revenue ($K)", value=0) growth_rate = gr.Slider(0, 300, value=0, step=10, label="연간 성장률 / Annual Growth Rate (%)") with gr.Row(): arpu = gr.Number(label="ARPU ($)", value=0) gross_margin = gr.Slider(0, 100, value=0, step=5, label="매출총이익률 / Gross Margin (%)") with gr.Row(): retention_rate = gr.Slider(0, 100, value=0, step=5, label="고객 유지율 / Retention Rate (%)") monthly_churn = gr.Slider(0, 20, value=0, step=0.5, label="월 이탈률 / Monthly Churn (%)") with gr.Row(): new_customers = gr.Number(label="월 신규 고객 / New Customers/Month", value=0) monthly_marketing = gr.Number(label="월 마케팅 비용 / Marketing Cost ($K)", value=0) monthly_sales = gr.Number(label="월 영업 비용 / Sales Cost ($K)", value=0) with gr.Tab("재무 현황 / Financials"): gr.Markdown("### 💸 현금 상황 / Cash Position ($K)") with gr.Row(): cash_balance = gr.Number(label="현금 잔고 / Cash Balance ($K)", value=1000) burn_rate = gr.Number(label="월 번레이트 / Monthly Burn Rate ($K)", value=80) # 평가 실행 버튼 evaluate_btn = gr.Button("🔍 가치평가 실행 / Run Valuation", variant="primary", size="lg") # 결과 출력 with gr.Row(): with gr.Column(scale=2): valuation_output = gr.Markdown(label="평가 결과 / Results") with gr.Column(scale=1): methods_table = gr.DataFrame(label="평가 방법 비교 / Method Comparison") with gr.Row(): comparison_chart = gr.Plot(label="평가 방법 비교 / Valuation Comparison") scorecard_chart = gr.Plot(label="스코어카드 분석 / Scorecard Analysis") # 이벤트 연결 evaluate_btn.click( process_valuation, inputs=[ api_key, language, company_name, founded_year, industry, stage, revenue_type, monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn, retention_rate, new_customers, monthly_marketing, monthly_sales, cash_balance, burn_rate, idea_validation, market_research, prototype_stage, team_experience, domain_expertise, startup_experience, partnerships, advisors, pilot_customers, sales_started, customer_validation, launch_readiness, team_strength, market_opportunity, product_stage, competitive_advantage, marketing_channels, funding_efficiency, other_factors ], outputs=[valuation_output, comparison_chart, scorecard_chart, methods_table] ) # 예시 데이터 gr.Markdown("### 📝 예시 데이터 / Example Data") with gr.Row(): gr.Button("초기 스타트업 / Early Startup").click( lambda: [ "", "ko", "테크 스타트업", 2023, "AI/딥테크", "MVP/베타", "구독형 (SaaS)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 500, 50, 80, 7, "베타 버전", 3, 4, 1, 1, 2, 3, False, 0, 70, 70, 65, 55, 60, 45, 50, 50 ], outputs=[ api_key, language, company_name, founded_year, industry, stage, revenue_type, monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn, retention_rate, new_customers, monthly_marketing, monthly_sales, cash_balance, burn_rate, idea_validation, market_research, prototype_stage, team_experience, domain_expertise, startup_experience, partnerships, advisors, pilot_customers, sales_started, customer_validation, launch_readiness, team_strength, market_opportunity, product_stage, competitive_advantage, marketing_channels, funding_efficiency, other_factors ] ) gr.Button("성장 단계 / Growth Stage").click( lambda: [ "", "en", "SaaS Corp", 2021, "SaaS - B2B", "성장 단계", "구독형 (SaaS)", 100, 150, 200, 75, 2, 90, 40, 30, 20, 2000, 120, 90, 9, "출시 버전", 8, 5, 3, 5, 5, 20, True, 8, 95, 85, 80, 75, 70, 65, 75, 60 ], outputs=[ api_key, language, company_name, founded_year, industry, stage, revenue_type, monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn, retention_rate, new_customers, monthly_marketing, monthly_sales, cash_balance, burn_rate, idea_validation, market_research, prototype_stage, team_experience, domain_expertise, startup_experience, partnerships, advisors, pilot_customers, sales_started, customer_validation, launch_readiness, team_strength, market_opportunity, product_stage, competitive_advantage, marketing_channels, funding_efficiency, other_factors ] ) return demo # 실행 if __name__ == "__main__": demo = create_ui() demo.launch(share=True)