Update app.py

app.py

@@ -29,25 +29,130 @@ class StartupValuationCalculator:
             "200%+": 1.5
         }
         
-        # 단위경제 점수 가중치
-        self.unit_economics_weights = {
-            "ltv_cac_ratio": 0.3,
-            "gross_margin": 0.3,
-            "retention": 0.2,
-            "payback": 0.2
+        # 버크스 방법 카테고리별 최대값 ($500K each)
+        self.berkus_max_values = {
+            "sound_idea": 500000,
+            "prototype": 500000,
+            "quality_team": 500000,
+            "strategic_relationships": 500000,
+            "product_rollout": 500000
         }
         
-        # IP 자산 가치 가중치
-        self.ip_asset_weights = {
-            "patents": 0.25,
-            "papers": 0.15,
-            "domains": 0.15,
-            "trademarks": 0.10,
-            "github": 0.10,
-            "awards": 0.10,
-            "team": 0.15
+        # 스코어카드 가중치
+        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 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, 
+            berkus_data["team_experience"] * 20 + 
+            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  # 0-100 -> 0-1
+        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)":
@@ -75,129 +180,82 @@ class StartupValuationCalculator:
             return 999
         return cac / (arpu * (gross_margin / 100))
     
-    def get_unit_economics_score(self, ltv_cac_ratio, gross_margin, retention_rate, payback_months):
-        """단위경제 점수 계산 (0-100)"""
-        scores = {
-            "ltv_cac_ratio": min(100, (ltv_cac_ratio / 3) * 100) if ltv_cac_ratio > 0 else 0,
-            "gross_margin": min(100, gross_margin * 1.25),
-            "retention": retention_rate,
-            "payback": max(0, 100 - (payback_months / 24) * 100) if payback_months < 999 else 0
-        }
-        
-        total_score = sum(scores[key] * self.unit_economics_weights[key] for key in scores)
-        return total_score
-    
-    def evaluate_domain(self, domains):
-        """도메인 가치 평가"""
-        if not domains:
-            return 0
+    def calculate_valuation(self, data, berkus_data, scorecard_data, use_revenue_multiple=True):
+        """종합 가치평가 계산"""
+        results = {}
         
-        domain_list = [d.strip() for d in domains.split(',') if d.strip()]
-        score = 0
+        # 1. 버크스 방법 평가
+        berkus_valuation, berkus_scores = self.calculate_berkus_score(berkus_data)
+        results["berkus_valuation"] = berkus_valuation
+        results["berkus_scores"] = berkus_scores
         
-        for domain in domain_list:
-            parsed = urlparse(domain if domain.startswith('http') else f'http://{domain}')
-            domain_name = parsed.netloc or parsed.path
+        # 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"])
             
-            # .com 도메인 가산점
-            if domain_name.endswith('.com'):
-                score += 30
-            elif domain_name.endswith(('.io', '.ai', '.tech')):
-                score += 20
+            # 멀티플 결정
+            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:
-                score += 10
+                base_multiple = multiples["low"]
             
-            # 짧은 도메인 가산점
-            name_length = len(domain_name.split('.')[0])
-            if name_length <= 5:
-                score += 20
-            elif name_length <= 8:
-                score += 10
-        
-        return min(100, score / len(domain_list))
-    
-    def evaluate_patents(self, patent_filed, patent_granted):
-        """특허 가치 평가"""
-        score = 0
-        score += patent_filed * 15  # 출원 특허당 15점
-        score += patent_granted * 30  # 등록 특허당 30점
-        return min(100, score)
-    
-    def evaluate_papers(self, papers):
-        """논문 가치 평가"""
-        if not papers:
-            return 0
-        
-        paper_count = len([p.strip() for p in papers.split('\n') if p.strip()])
-        score = paper_count * 20  # 논문당 20점
-        
-        # 주요 학회/저널 키워드 체크
-        prestigious_keywords = ['Nature', 'Science', 'IEEE', 'ACM', 'CVPR', 'NeurIPS', 'ICML']
-        for keyword in prestigious_keywords:
-            if keyword.lower() in papers.lower():
-                score += 10
-        
-        return min(100, score)
-    
-    def evaluate_github(self, github_url, github_stars):
-        """GitHub 저장소 평가"""
-        if not github_url:
-            return 0
-        
-        score = 0
-        if github_stars >= 1000:
-            score = 80
-        elif github_stars >= 500:
-            score = 60
-        elif github_stars >= 100:
-            score = 40
-        elif github_stars >= 50:
-            score = 20
+            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:
-            score = 10
-        
-        return score
-    
-    def evaluate_team(self, team_size, phd_count, serial_entrepreneurs, big_tech_experience):
-        """팀 역량 평가"""
-        score = 0
-        
-        # 팀 규모
-        if team_size >= 20:
-            score += 20
-        elif team_size >= 10:
-            score += 15
-        elif team_size >= 5:
-            score += 10
-        
-        # 박사 학위
-        score += min(30, phd_count * 10)
+            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"
         
-        # 연쇄창업가
-        score += min(30, serial_entrepreneurs * 15)
+        # 4. 스코어카드 조정
+        final_valuation, scorecard_adjustments, weighted_score = self.calculate_scorecard_valuation(
+            scorecard_data, base_valuation
+        )
         
-        # 빅테크 경험
-        score += min(20, big_tech_experience * 5)
+        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
         
-        return min(100, score)
-    
-    def calculate_ip_score(self, ip_data):
-        """지적재산 종합 점수 계산"""
-        scores = {
-            "patents": self.evaluate_patents(ip_data["patent_filed"], ip_data["patent_granted"]),
-            "papers": self.evaluate_papers(ip_data["papers"]),
-            "domains": self.evaluate_domain(ip_data["domains"]),
-            "trademarks": min(100, ip_data["trademarks"] * 20),
-            "github": self.evaluate_github(ip_data["github_url"], ip_data["github_stars"]),
-            "awards": min(100, ip_data["awards"] * 25),
-            "team": self.evaluate_team(
-                ip_data["team_size"], ip_data["phd_count"],
-                ip_data["serial_entrepreneurs"], ip_data["big_tech_experience"]
-            )
-        }
+        # 5. 런웨이 계산
+        results["runway"] = data["cash_balance"] / data["burn_rate"] if data["burn_rate"] > 0 else 999
         
-        total_score = sum(scores[key] * self.ip_asset_weights[key] for key in scores)
-        return total_score, scores
+        return results
     
     def get_growth_category(self, growth_rate):
         """성장률 카테고리 결정"""
@@ -212,128 +270,60 @@ class StartupValuationCalculator:
         else:
             return "200%+"
     
-    def calculate_valuation(self, data, ip_data):
-        """종합 가치평가 계산"""
-        # 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"])
-        
-        # 단위경제 점수
-        ue_score = self.get_unit_economics_score(
-            ltv_cac_ratio, data["gross_margin"], data["retention_rate"], payback
-        )
-        
-        # IP 자산 점수
-        ip_score, ip_breakdown = self.calculate_ip_score(ip_data)
-        
-        # 종합 점수 (단위경제 60%, IP 40%)
-        combined_score = ue_score * 0.6 + ip_score * 0.4
-        
-        # 기본 멀티플 선택
-        multiples = self.industry_multiples[data["industry"]]
-        if combined_score >= 80:
-            base_multiple = multiples["high"]
-        elif combined_score >= 50:
-            base_multiple = multiples["mid"]
-        else:
-            base_multiple = multiples["low"]
-        
-        # 성장률 조정
-        growth_adj = self.growth_adjustments[self.get_growth_category(data["growth_rate"])]
-        adjusted_multiple = base_multiple * growth_adj
-        
-        # 스테이지 조정
-        stage_adj = {
-            "MVP/베타": 0.7,
-            "초기 매출": 0.85,
-            "성장 단계": 1.0,
-            "수익성 확보": 1.2
-        }
-        
-        # IP 자산 프리미엄 (최대 20%)
-        ip_premium = 1 + (ip_score / 100 * 0.2)
-        
-        final_multiple = adjusted_multiple * stage_adj[data["stage"]] * ip_premium
-        
-        # 최종 가치평가
-        valuation = arr * final_multiple
-        
-        # 런웨이 계산
-        runway = data["cash_balance"] / data["burn_rate"] if data["burn_rate"] > 0 else 999
-        
-        return {
-            "valuation": valuation,
-            "arr": arr,
-            "multiple": final_multiple,
-            "ltv": ltv,
-            "cac": cac,
-            "ltv_cac_ratio": ltv_cac_ratio,
-            "payback": payback,
-            "ue_score": ue_score,
-            "ip_score": ip_score,
-            "ip_breakdown": ip_breakdown,
-            "combined_score": combined_score,
-            "runway": runway
-        }
-    
-    def create_comparison_chart(self, valuation, industry, arr):
-        """동종업계 비교 차트 생성"""
-        multiples = self.industry_multiples[industry]
-        
+    def create_valuation_comparison_chart(self, results, language="ko"):
+        """평가 방법별 비교 차트"""
         fig = go.Figure()
         
-        # 업계 범위
-        low_val = arr * multiples["low"]
-        mid_val = arr * multiples["mid"]
-        high_val = arr * multiples["high"]
+        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=["하위 25%", "중간값", "상위 25%", "현재 기업"],
-            y=[low_val, mid_val, high_val, valuation],
-            text=[f"${low_val/1000000:.1f}M", f"${mid_val/1000000:.1f}M", 
-                  f"${high_val/1000000:.1f}M", f"${valuation/1000000:.1f}M"],
+            x=methods,
+            y=values,
+            text=[f"${v/1000000:.2f}M" for v in values],
             textposition="outside",
-            marker_color=["lightgray", "gray", "darkgray", "blue"]
+            marker_color=["lightblue", "lightgreen", "darkblue"]
         ))
         
+        title = "평가 방법별 기업가치 비교" if language == "ko" else "Valuation by Method"
         fig.update_layout(
-            title=f"{industry} 업계 가치평가 비교",
-            yaxis_title="기업가치 (USD)",
+            title=title,
+            yaxis_title="Valuation (USD)",
             showlegend=False,
             height=400
         )
         
         return fig
     
-    def create_ip_breakdown_chart(self, ip_breakdown):
-        """IP 자산 분석 차트"""
-        categories = list(ip_breakdown.keys())
-        values = list(ip_breakdown.values())
-        
-        fig = go.Figure(data=[
-            go.Radar(
-                r=values,
-                theta=categories,
-                fill='toself',
-                name='IP 자산 점수'
-            )
-        ])
+    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=title
         )
         
         return fig
@@ -342,26 +332,26 @@ def create_ui():
     calculator = StartupValuationCalculator()
     
     def process_valuation(
+        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,
-        # IP 관련 입력
-        domains, patent_filed, patent_granted, papers, trademarks,
-        github_url, github_stars, awards, partnerships,
-        team_size, phd_count, serial_entrepreneurs, big_tech_experience,
-        media_coverage, app_downloads, social_followers
+        # 버크스 방법 입력
+        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
     ):
-        # 입력값 검증
-        if monthly_revenue <= 0:
-            return "월 매출을 입력해주세요.", None, None, None
-        
         # 데이터 준비
         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,
@@ -376,285 +366,330 @@ def create_ui():
             "burn_rate": burn_rate * 1000
         }
         
-        ip_data = {
-            "domains": domains,
-            "patent_filed": patent_filed,
-            "patent_granted": patent_granted,
-            "papers": papers,
-            "trademarks": trademarks,
-            "github_url": github_url,
-            "github_stars": github_stars,
-            "awards": awards,
+        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,
-            "team_size": team_size,
-            "phd_count": phd_count,
-            "serial_entrepreneurs": serial_entrepreneurs,
-            "big_tech_experience": big_tech_experience,
-            "media_coverage": media_coverage,
-            "app_downloads": app_downloads,
-            "social_followers": social_followers
+            "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
         }
         
         # 가치평가 계산
-        results = calculator.calculate_valuation(data, ip_data)
+        use_revenue = monthly_revenue > 0
+        results = calculator.calculate_valuation(data, berkus_data, scorecard_data, use_revenue)
+        
+        # 언어별 텍스트
+        t = calculator.translations[language]
         
         # 결과 포맷팅
-        valuation_text = f"""
-# 🚀 {company_name} 가치평가 결과
-
-## 📊 주요 지표
-- **기업가치**: ${results['valuation']/1000000:.1f}M (₩{results['valuation']/1000000*1300:.0f}억)
-- **ARR**: ${results['arr']/1000000:.1f}M
-- **적용 멀티플**: {results['multiple']:.1f}x
+        if language == "ko":
+            valuation_text = f"""
+# 🚀 {company_name} {t['valuation_result']}
 
-## 💰 단위경제
-- **LTV**: ${results['ltv']:.0f}
-- **CAC**: ${results['cac']:.0f}
-- **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x
-- **Payback Period**: {results['payback']:.1f}개월
-- **단위경제 점수**: {results['ue_score']:.0f}/100
-
-## 🎯 지적재산 및 무형자산
-- **IP 자산 점수**: {results['ip_score']:.0f}/100
-- **종합 점수**: {results['combined_score']:.0f}/100
+## 📊 종합 평가
+- **{t['company_value']}**: ${results['final_valuation']/1000000:.2f}M
+- **평가 방법**: {'매출 멀티플' if results['valuation_method'] == 'revenue_multiple' else '버크스 방법'} + 스코어카드 조정
+- **스코어카드 조정 배수**: {results['scorecard_multiplier']:.2f}x
 
-### IP 자산 세부 평가:
-- 특허: {results['ip_breakdown']['patents']:.0f}/100
-- 논문: {results['ip_breakdown']['papers']:.0f}/100
-- 도메인: {results['ip_breakdown']['domains']:.0f}/100
-- 상표권: {results['ip_breakdown']['trademarks']:.0f}/100
-- 오픈소스: {results['ip_breakdown']['github']:.0f}/100
-- 수상실적: {results['ip_breakdown']['awards']:.0f}/100
-- 팀 역량: {results['ip_breakdown']['team']:.0f}/100
+## 🎯 {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']}
 
-## 🏃 재무 건전성
-- **현금 런웨이**: {results['runway']:.1f}개월
-- **월간 번레이트**: ${burn_rate}K
+## 📊 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 results['ltv_cac_ratio'] < 1:
-            valuation_text += "- ⚠️ LTV/CAC 비율이 1 미만입니다. 마케팅 효율성 개선이 필요합니다.\n"
-        elif results['ltv_cac_ratio'] > 3:
-            valuation_text += "- ✅ 우수한 LTV/CAC 비율을 보이고 있습니다.\n"
-        
-        if results['runway'] < 12:
-            valuation_text += "- ⚠️ 런웨이가 12개월 미만입니다. 추가 자금조달을 고려하세요.\n"
-        
-        if gross_margin < 60:
-            valuation_text += "- 📈 매출총이익률 개선 여지가 있습니다. (업계 평균: 70-80%)\n"
-        
-        if results['ip_score'] > 70:
-            valuation_text += "- 🏆 강력한 IP 포트폴리오를 보유하고 있어 가치평가에 프리미엄이 적용되었습니다.\n"
         
-        # 비교 차트 생성
-        comparison_chart = calculator.create_comparison_chart(
-            results['valuation'], industry, results['arr']
-        )
+        # 매출 기반 평가 추가 (매출이 있는 경우)
+        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
+"""
         
-        # IP 분석 차트
-        ip_chart = calculator.create_ip_breakdown_chart(results['ip_breakdown'])
+        # 재무 건전성
+        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
+"""
         
-        # 상세 분석 테이블
-        metrics_df = pd.DataFrame({
-            "지표": ["월 매출", "연 성장률", "매출총이익률", "월 이탈률", "고객 유지율", "IP 자산 점수"],
-            "현재 값": [f"${monthly_revenue}K", f"{growth_rate}%", f"{gross_margin}%", 
-                      f"{monthly_churn}%", f"{retention_rate}%", f"{results['ip_score']:.0f}/100"],
-            "업계 평균": ["N/A", "50-100%", "70-80%", "2-5%", "80-90%", "50/100"]
-        })
+        # 차트 생성
+        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, ip_chart, metrics_df
+        return valuation_text, comparison_chart, scorecard_chart, methods_df
     
     # Gradio UI
-    with gr.Blocks(title="스타트업 가치평가 계산기", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🦄 스타트업 가치평가 자동화 시스템 v2.0
+    with gr.Blocks(title="Startup Valuation Calculator", theme=gr.themes.Soft()) as demo:
+        # 언어 선택
+        language = gr.Radio(
+            choices=[("한국어", "ko"), ("English", "en")],
+            value="ko",
+            label="Language / 언어",
+            type="value"
+        )
         
-        간단한 정보 입력만으로 귀사의 예상 기업가치를 산출하고 동종업계와 비교해드립니다.
-        이제 지적재산과 무형자산까지 종합적으로 평가합니다.
+        gr.Markdown("""
+        # 🦄 스타트업 가치평가 자동화 시스템 v3.0
+        ### 버크스 방법과 스코어카드 방법을 포함한 종합 평가
         """)
         
-        with gr.Tab("기본 정보"):
+        with gr.Tab("기본 정보 / Basic Info"):
             with gr.Row():
-                company_name = gr.Textbox(label="회사명", value="우리 스타트업")
-                founded_year = gr.Slider(2015, 2024, value=2022, step=1, label="설립연도")
+                company_name = gr.Textbox(label="회사명 / Company Name", value="우리 스타트업")
+                founded_year = gr.Slider(2015, 2024, value=2022, step=1, label="설립연도 / Founded Year")
             
             with gr.Row():
                 industry = gr.Dropdown(
                     choices=list(calculator.industry_multiples.keys()),
                     value="SaaS - B2B",
-                    label="산업 분류"
+                    label="산업 분류 / Industry"
                 )
                 stage = gr.Radio(
                     choices=["MVP/베타", "초기 매출", "성장 단계", "수익성 확보"],
                     value="초기 매출",
-                    label="사업 단계"
+                    label="사업 단계 / Stage"
                 )
             
             revenue_type = gr.Radio(
                 choices=["구독형 (SaaS)", "거래수수료형", "일회성 판매"],
                 value="구독형 (SaaS)",
-                label="수익 모델"
+                label="수익 모델 / Revenue Model"
             )
         
-        with gr.Tab("매출 및 성장"):
-            gr.Markdown("### 💰 매출 정보 (단위: 천 달러)")
+        with gr.Tab("버크스 평가 / Berkus Method"):
+            gr.Markdown("### 💡 아이디어 검증 / Idea Validation")
             with gr.Row():
-                monthly_revenue = gr.Number(label="월 매출 ($K)", value=50)
-                growth_rate = gr.Slider(0, 300, value=100, step=10, 
-                                       label="연간 성장률 (%)")
+                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)")
             
-            with gr.Row():
-                arpu = gr.Number(label="고객당 평균 매출 (ARPU) ($)", value=100)
-                gross_margin = gr.Slider(0, 100, value=70, step=5,
-                                        label="매출총이익률 (%)")
-        
-        with gr.Tab("고객 및 마케팅"):
-            gr.Markdown("### 👥 고객 지표")
-            with gr.Row():
-                retention_rate = gr.Slider(0, 100, value=85, step=5,
-                                          label="월간 고객 유지율 (%)")
-                monthly_churn = gr.Slider(0, 20, value=3, step=0.5,
-                                         label="월 이탈률 (%)")
+            gr.Markdown("### 🔧 프로토타입 / Prototype")
+            prototype_stage = gr.Radio(
+                choices=["없음", "컨셉/목업", "작동 프로토타입", "베타 버전", "출시 버전"],
+                value="베타 버전",
+                label="프로토타입 단계 / Prototype Stage"
+            )
             
-            gr.Markdown("### 📢 마케팅 효율성")
+            gr.Markdown("### 👥 팀 역량 / Team Quality")
             with gr.Row():
-                new_customers = gr.Number(label="월 신규 고객 수", value=50)
-                monthly_marketing = gr.Number(label="월 마케팅 비용 ($K)", value=20)
-                monthly_sales = gr.Number(label="월 영업 비용 ($K)", value=15)
-        
-        with gr.Tab("지적재산 및 기술"):
-            gr.Markdown("### 📚 특허 및 논문")
-            with gr.Row():
-                patent_filed = gr.Number(label="출원 특허 수", value=2)
-                patent_granted = gr.Number(label="등록 특허 수", value=1)
-                trademarks = gr.Number(label="상표권 수", value=1)
-            
-            papers = gr.Textbox(
-                label="발표 논문 (한 줄에 하나씩, URL 포함 가능)",
-                lines=3,
-                placeholder="예: https://arxiv.org/abs/2301.12345 - AI Model Optimization\nICML 2023 - Novel Approach to Machine Learning"
-            )
+                team_experience = gr.Slider(0, 5, value=3, 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("### 🌐 디지털 자산")
-            domains = gr.Textbox(
-                label="보유 도메인 (쉼표로 구분)",
-                placeholder="예: mycompany.com, mycompany.ai, myproduct.io"
-            )
+            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():
-                github_url = gr.Textbox(
-                    label="GitHub 저장소 URL",
-                    placeholder="https://github.com/yourcompany/yourrepo"
-                )
-                github_stars = gr.Number(label="GitHub 스타 수", value=100)
+                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("### 🏆 인증 및 수상")
+            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():
-                awards = gr.Number(label="주요 수상 실적 수", value=1)
-                partnerships = gr.Number(label="전략적 파트너십 수", value=2)
-        
-        with gr.Tab("팀 및 브랜드"):
-            gr.Markdown("### 👥 팀 구성")
+                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():
-                team_size = gr.Number(label="전체 팀 규모", value=10)
-                phd_count = gr.Number(label="박사 학위 보유자 수", value=1)
+                arpu = gr.Number(label="ARPU ($)", value=0)
+                gross_margin = gr.Slider(0, 100, value=0, step=5,
+                                        label="매출총이익률 / Gross Margin (%)")
             
             with gr.Row():
-                serial_entrepreneurs = gr.Number(label="연쇄창업가 수", value=1)
-                big_tech_experience = gr.Number(label="빅테크 출신 인원", value=2)
+                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 (%)")
             
-            gr.Markdown("### 📱 브랜드 및 사용자 기반")
             with gr.Row():
-                media_coverage = gr.Number(label="주요 언론 보도 수", value=5)
-                app_downloads = gr.Number(label="앱 다운로드 수 (만)", value=10)
-                social_followers = gr.Number(label="소셜미디어 팔로워 (천)", value=50)
+                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("재무 현황"):
-            gr.Markdown("### 💸 현금 상황 (단위: 천 달러)")
+        with gr.Tab("재무 현황 / Financials"):
+            gr.Markdown("### 💸 현금 상황 / Cash Position ($K)")
             with gr.Row():
-                cash_balance = gr.Number(label="현금 잔고 ($K)", value=1000)
-                burn_rate = gr.Number(label="월 번레이트 ($K)", value=80)
+                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("🔍 가치평가 실행", variant="primary", size="lg")
+        evaluate_btn = gr.Button("🔍 가치평가 실행 / Run Valuation", variant="primary", size="lg")
         
         # 결과 출력
         with gr.Row():
             with gr.Column(scale=2):
-                valuation_output = gr.Markdown(label="평가 결과")
+                valuation_output = gr.Markdown(label="평가 결과 / Results")
             with gr.Column(scale=1):
-                metrics_table = gr.DataFrame(label="주요 지표 비교")
+                methods_table = gr.DataFrame(label="평가 방법 비교 / Method Comparison")
         
         with gr.Row():
-            comparison_chart = gr.Plot(label="동종업계 비교")
-            ip_chart = gr.Plot(label="IP 자산 분석")
+            comparison_chart = gr.Plot(label="평가 방법 비교 / Valuation Comparison")
+            scorecard_chart = gr.Plot(label="스코어카드 분석 / Scorecard Analysis")
         
         # 이벤트 연결
         evaluate_btn.click(
             process_valuation,
             inputs=[
+                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,
-                domains, patent_filed, patent_granted, papers, trademarks,
-                github_url, github_stars, awards, partnerships,
-                team_size, phd_count, serial_entrepreneurs, big_tech_experience,
-                media_coverage, app_downloads, social_followers
+                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, ip_chart, metrics_table]
+            outputs=[valuation_output, comparison_chart, scorecard_chart, methods_table]
         )
         
-        # 예시 데이터 버튼들
-        gr.Markdown("### 📝 예시 데이터로 테스트하기")
+        # 예시 데이터
+        gr.Markdown("### 📝 예시 데이터 / Example Data")
         with gr.Row():
-            gr.Button("AI 스타트업 예시").click(
+            gr.Button("초기 스타트업 / Early Startup").click(
                 lambda: [
-                    "AI Tech Corp", 2021, "AI/딥테크", "성장 단계", "구독형 (SaaS)",
-                    100, 150, 200, 75, 2,
-                    90, 40, 30, 20,
-                    2000, 120,
-                    "aitech.com, aitech.ai", 5, 2, 
-                    "NeurIPS 2023 - Novel AI Architecture\nhttps://arxiv.org/abs/2023.12345", 3,
-                    "https://github.com/aitech/core", 500, 3, 5,
-                    15, 3, 2, 4,
-                    10, 50, 100
+                    "ko", "테크 스타트업", 2023, "AI/딥테크", "MVP/베타", "구독형 (SaaS)",
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 500, 50,
+                    80, 7, "베타 버전", 2, 4, 1, 1, 2, 3, False, 0, 70,
+                    70, 65, 55, 60, 45, 50, 50
                 ],
                 outputs=[
-                    company_name, founded_year, industry, stage, revenue_type,
+                    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,
-                    domains, patent_filed, patent_granted, papers, trademarks,
-                    github_url, github_stars, awards, partnerships,
-                    team_size, phd_count, serial_entrepreneurs, big_tech_experience,
-                    media_coverage, app_downloads, social_followers
+                    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("바이오테크 예시").click(
+            gr.Button("성장 단계 / Growth Stage").click(
                 lambda: [
-                    "BioHealth Inc", 2020, "헬스케어", "초기 매출", "구독형 (SaaS)",
-                    80, 200, 500, 85, 1,
-                    95, 20, 40, 30,
-                    3000, 150,
-                    "biohealth.com, biohealth.health", 8, 4,
-                    "Nature Medicine 2023 - Breakthrough in Drug Discovery\nScience 2023 - Novel Biomarker", 5,
-                    "https://github.com/biohealth/research", 200, 5, 3,
-                    25, 8, 1, 3,
-                    15, 5, 30
+                    "en", "SaaS Corp", 2021, "SaaS - B2B", "성장 단계", "구독형 (SaaS)",
+                    100, 150, 200, 75, 2, 90, 40, 30, 20, 2000, 120,
+                    90, 9, "출시 버전", 5, 5, 3, 5, 5, 20, True, 8, 95,
+                    85, 80, 75, 70, 65, 75, 60
                 ],
                 outputs=[
-                    company_name, founded_year, industry, stage, revenue_type,
+                    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,
-                    domains, patent_filed, patent_granted, papers, trademarks,
-                    github_url, github_stars, awards, partnerships,
-                    team_size, phd_count, serial_entrepreneurs, big_tech_experience,
-                    media_coverage, app_downloads, social_followers
+                    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
                 ]
             )