Split View: REITs 부동산 투자 분석 완전 가이드: DCF 모델·수익률 시뮬레이션·직접투자 비교

# REIT types and characteristics
reit_types = {
    "Equity REITs": {
        "description": "Own and operate income-producing real estate",
        "revenue_source": "Rental income + property appreciation",
        "risk_level": "Moderate",
        "examples": "Office, retail, logistics, data centers",
        "market_share": "~90%"
    },
    "Mortgage REITs (mREITs)": {
        "description": "Invest in real estate debt and MBS",
        "revenue_source": "Interest income (rate spread)",
        "risk_level": "High (interest rate sensitive)",
        "examples": "Residential mortgages, commercial mortgages",
        "market_share": "~7%"
    },
    "Hybrid REITs": {
        "description": "Combination of equity and mortgage strategies",
        "revenue_source": "Rental income + interest income",
        "risk_level": "Moderate to High",
        "examples": "Diversified portfolio operations",
        "market_share": "~3%"
    }
}

for reit_type, info in reit_types.items():
    print(f"\n{'='*50}")
    print(f"  {reit_type}")
    print(f"{'='*50}")
    for key, value in info.items():
        print(f"  {key}: {value}")

# Major K-REITs analysis (2025 example data)
k_reits = [
    {
        "name": "SK REIT",
        "ticker": "395400",
        "sector": "Office/Logistics",
        "assets": "SK Seorin Building, logistics centers",
        "dividend_yield": 5.8,
        "market_cap_billion_krw": 1200,
    },
    {
        "name": "ESR Kendall Square REIT",
        "ticker": "365550",
        "sector": "Logistics",
        "assets": "Major domestic logistics centers",
        "dividend_yield": 6.2,
        "market_cap_billion_krw": 800,
    },
    {
        "name": "Shinhan Alpha REIT",
        "ticker": "293940",
        "sector": "Office",
        "assets": "Pangyo Alpha Dom Tower, etc.",
        "dividend_yield": 5.5,
        "market_cap_billion_krw": 600,
    },
    {
        "name": "Lotte REIT",
        "ticker": "330590",
        "sector": "Retail/Hotel",
        "assets": "Lotte Mart, Lotte Hotel, etc.",
        "dividend_yield": 7.1,
        "market_cap_billion_krw": 500,
    },
    {
        "name": "JR Global REIT",
        "ticker": "348950",
        "sector": "Overseas Office",
        "assets": "Belgium office, overseas assets",
        "dividend_yield": 8.5,
        "market_cap_billion_krw": 400,
    },
]

print(f"{'Name':<25} {'Sector':<16} {'Div Yield':>10} {'Mkt Cap(B KRW)':>15}")
print("-" * 70)
for reit in k_reits:
    print(f"{reit['name']:<25} {reit['sector']:<16} "
          f"{reit['dividend_yield']:>9.1f}% {reit['market_cap_billion_krw']:>15,}")

Cap Rate = NOI / Property Value x 100

Example: Annual NOI of 500M KRW, Property Value of 10B KRW
Cap Rate = 500M / 10B x 100 = 5.0%

FFO = Net Income + Depreciation - Gains on Property Sales

AFFO = FFO - Maintenance CapEx - Straight-line Rent Adjustments

# REIT key metrics calculation
class REITMetrics:
    def __init__(self, name, noi, property_value, net_income,
                 depreciation, gain_on_sale, capex, shares, price):
        self.name = name
        self.noi = noi
        self.property_value = property_value
        self.net_income = net_income
        self.depreciation = depreciation
        self.gain_on_sale = gain_on_sale
        self.capex = capex
        self.shares = shares
        self.price = price

    def cap_rate(self):
        return self.noi / self.property_value * 100

    def ffo(self):
        return self.net_income + self.depreciation - self.gain_on_sale

    def affo(self):
        return self.ffo() - self.capex

    def ffo_per_share(self):
        return self.ffo() / self.shares

    def p_ffo(self):
        return self.price / self.ffo_per_share()

    def nav_per_share(self, total_debt):
        nav = self.property_value - total_debt
        return nav / self.shares

    def premium_discount(self, total_debt):
        nav = self.nav_per_share(total_debt)
        return (self.price - nav) / nav * 100

    def report(self, total_debt):
        print(f"\n{'='*45}")
        print(f"  {self.name} - Investment Metrics")
        print(f"{'='*45}")
        print(f"  Cap Rate:          {self.cap_rate():.2f}%")
        print(f"  FFO:               {self.ffo():,.0f} M KRW")
        print(f"  AFFO:              {self.affo():,.0f} M KRW")
        print(f"  FFO/Share:         {self.ffo_per_share():,.0f} KRW")
        print(f"  P/FFO:             {self.p_ffo():.2f}x")
        print(f"  NAV/Share:         {self.nav_per_share(total_debt):,.0f} KRW")
        premium = self.premium_discount(total_debt)
        label = "Premium" if premium > 0 else "Discount"
        print(f"  NAV {label}:    {abs(premium):.1f}%")


# Example REIT analysis
example_reit = REITMetrics(
    name="Sample Office REIT",
    noi=5000,               # NOI 5B KRW (in millions)
    property_value=100000,  # Property value 100B KRW
    net_income=2000,        # Net income 2B KRW
    depreciation=3500,      # Depreciation 3.5B KRW
    gain_on_sale=500,       # Gain on sale 500M KRW
    capex=800,              # Maintenance CapEx 800M KRW
    shares=10000000,        # 10M shares outstanding
    price=5500              # Current price 5,500 KRW
)

example_reit.report(total_debt=40000)  # Total debt 40B KRW

import numpy as np

class REITsDCFModel:
    """REIT DCF Valuation Model"""

    def __init__(self, current_affo, growth_rates, discount_rate,
                 terminal_growth_rate, shares_outstanding):
        """
        Parameters:
        - current_affo: Current annual AFFO (in millions)
        - growth_rates: List of annual AFFO growth rates
        - discount_rate: Discount rate (WACC)
        - terminal_growth_rate: Perpetual growth rate
        - shares_outstanding: Total shares outstanding
        """
        self.current_affo = current_affo
        self.growth_rates = growth_rates
        self.discount_rate = discount_rate
        self.terminal_growth_rate = terminal_growth_rate
        self.shares = shares_outstanding

    def project_cash_flows(self):
        """Project future AFFO cash flows"""
        cash_flows = []
        affo = self.current_affo
        for rate in self.growth_rates:
            affo = affo * (1 + rate)
            cash_flows.append(affo)
        return cash_flows

    def calculate_terminal_value(self, final_affo):
        """Calculate Terminal Value using Gordon Growth Model"""
        tv = final_affo * (1 + self.terminal_growth_rate) / \
             (self.discount_rate - self.terminal_growth_rate)
        return tv

    def calculate_present_values(self, cash_flows, terminal_value):
        """Calculate present values"""
        pv_cash_flows = []
        for i, cf in enumerate(cash_flows):
            pv = cf / (1 + self.discount_rate) ** (i + 1)
            pv_cash_flows.append(pv)

        n = len(cash_flows)
        pv_terminal = terminal_value / (1 + self.discount_rate) ** n
        return pv_cash_flows, pv_terminal

    def intrinsic_value_per_share(self):
        """Calculate intrinsic value per share"""
        cash_flows = self.project_cash_flows()
        terminal_value = self.calculate_terminal_value(cash_flows[-1])
        pv_cfs, pv_tv = self.calculate_present_values(cash_flows, terminal_value)

        total_value = sum(pv_cfs) + pv_tv
        value_per_share = total_value / self.shares
        return value_per_share, pv_cfs, pv_tv, cash_flows, terminal_value

    def sensitivity_analysis(self, discount_rates, terminal_rates):
        """Sensitivity analysis: discount rate x terminal growth rate matrix"""
        results = []
        for dr in discount_rates:
            row = []
            for tg in terminal_rates:
                self.discount_rate = dr
                self.terminal_growth_rate = tg
                val, _, _, _, _ = self.intrinsic_value_per_share()
                row.append(val)
            results.append(row)
        return np.array(results)


# Run DCF model
model = REITsDCFModel(
    current_affo=4200,           # Current AFFO 4.2B KRW
    growth_rates=[0.05, 0.05, 0.04, 0.04, 0.03,
                  0.03, 0.03, 0.02, 0.02, 0.02],  # 10-year growth rates
    discount_rate=0.08,          # 8% discount rate
    terminal_growth_rate=0.02,   # 2% perpetual growth
    shares_outstanding=10000000  # 10M shares
)

value, pv_cfs, pv_tv, cfs, tv = model.intrinsic_value_per_share()

print("="*55)
print("  REIT DCF Valuation Results")
print("="*55)
print(f"\n  [Projected AFFO]")
for i, cf in enumerate(cfs):
    print(f"    Year {i+1}: {cf:>10,.0f} M KRW")

print(f"\n  Terminal Value:         {tv:>15,.0f} M KRW")
print(f"\n  [Present Values]")
print(f"    PV of Projected CFs:  {sum(pv_cfs):>12,.0f} M KRW")
print(f"    PV of Terminal Value: {pv_tv:>12,.0f} M KRW")
print(f"    Total Enterprise Val: {sum(pv_cfs)+pv_tv:>12,.0f} M KRW")
print(f"\n  Intrinsic Value/Share: {value:,.0f} KRW")

# Sensitivity analysis
print(f"\n{'='*55}")
print("  Sensitivity Analysis (Value per Share)")
print("="*55)
d_rates = [0.07, 0.08, 0.09, 0.10]
t_rates = [0.01, 0.015, 0.02, 0.025]

matrix = model.sensitivity_analysis(d_rates, t_rates)
header = "WACC \\ Terminal g"
print(f"\n  {header:<18}", end="")
for tg in t_rates:
    print(f"  {tg*100:>5.1f}%", end="")
print()
print("  " + "-" * 45)
for i, dr in enumerate(d_rates):
    print(f"  {dr*100:>5.1f}%           ", end="")
    for j in range(len(t_rates)):
        print(f"  {matrix[i][j]:>6,.0f}", end="")
    print()

import numpy as np

def monte_carlo_reit_simulation(
    initial_investment,
    annual_dividend_yield,
    expected_price_return,
    volatility,
    years,
    n_simulations=10000,
    dividend_reinvest=True
):
    """
    Monte Carlo simulation for REIT investment

    Parameters:
    - initial_investment: Initial investment amount
    - annual_dividend_yield: Annual dividend yield
    - expected_price_return: Expected annual price return
    - volatility: Annual volatility (std dev)
    - years: Investment horizon (years)
    - n_simulations: Number of simulations
    - dividend_reinvest: Whether to reinvest dividends
    """
    np.random.seed(42)
    results = np.zeros((n_simulations, years + 1))
    results[:, 0] = initial_investment

    for sim in range(n_simulations):
        portfolio_value = initial_investment
        for year in range(1, years + 1):
            # Price return (log-normal distribution)
            price_return = np.random.normal(
                expected_price_return, volatility
            )
            # Dividend income
            dividend = portfolio_value * annual_dividend_yield

            if dividend_reinvest:
                portfolio_value = portfolio_value * (1 + price_return) + dividend
            else:
                portfolio_value = portfolio_value * (1 + price_return)

            portfolio_value = max(portfolio_value, 0)
            results[sim, year] = portfolio_value

    return results


# Run simulation
initial = 100_000  # USD 100,000
results = monte_carlo_reit_simulation(
    initial_investment=initial,
    annual_dividend_yield=0.055,     # 5.5% dividend yield
    expected_price_return=0.03,      # 3% expected price growth
    volatility=0.15,                 # 15% volatility
    years=20,                        # 20 years
    n_simulations=10000
)

final_values = results[:, -1]
print("="*55)
print("  REIT Monte Carlo Simulation (20 Years)")
print("="*55)
print(f"  Initial Investment:  ${initial:>12,}")
print(f"  Simulations:         {10000:>12,}")
print(f"\n  [Final Portfolio Value Distribution]")
print(f"  Mean:                ${np.mean(final_values):>12,.0f}")
print(f"  Median:              ${np.median(final_values):>12,.0f}")
print(f"  5th Percentile:      ${np.percentile(final_values, 5):>12,.0f}")
print(f"  95th Percentile:     ${np.percentile(final_values, 95):>12,.0f}")
print(f"  Minimum:             ${np.min(final_values):>12,.0f}")
print(f"  Maximum:             ${np.max(final_values):>12,.0f}")

total_return = (np.median(final_values) / initial - 1) * 100
annualized = ((np.median(final_values) / initial) ** (1/20) - 1) * 100
print(f"\n  Median Total Return:      {total_return:>8.1f}%")
print(f"  Median Annualized Return: {annualized:>8.1f}%")

| Criteria          | REITs              | Direct Real Estate    | RE Funds           |
|-------------------|--------------------|-----------------------|--------------------|
| Minimum Capital   | A few hundred USD  | Hundreds of thousands | Several thousand   |
| Liquidity         | High (like stocks) | Very low              | Low                |
| Diversification   | Easy               | Difficult             | Moderate           |
| Management Burden | None               | High (self-managed)   | None               |
| Leverage          | Limited            | Mortgage available    | Limited            |
| Tax Benefits      | Dividend tax       | Capital gains exempt  | Dividend tax       |
| Income Control    | None               | Full control          | None               |
| Transparency      | High (disclosure)  | Moderate              | Moderate           |
| Inflation Hedge   | Moderate           | Strong                | Moderate           |
| Transaction Costs | Brokerage fees     | Acquisition tax, fees | Redemption fees    |

def compare_investment_scenarios(
    investment_amount,
    years,
    # REITs parameters
    reit_dividend_yield=0.055,
    reit_price_growth=0.03,
    reit_tax_rate=0.154,        # 15.4% dividend tax
    # Direct investment parameters
    direct_rental_yield=0.035,
    direct_price_growth=0.04,
    direct_loan_ratio=0.60,
    direct_loan_rate=0.045,
    direct_expense_ratio=0.01,  # Maintenance, repairs
    direct_acquisition_tax=0.046  # 4.6% acquisition tax
):
    """Compare REITs vs direct real estate investment returns"""

    # === REITs Investment ===
    reit_value = investment_amount
    reit_total_dividend = 0

    for y in range(years):
        dividend = reit_value * reit_dividend_yield
        after_tax_dividend = dividend * (1 - reit_tax_rate)
        reit_total_dividend += after_tax_dividend
        reit_value *= (1 + reit_price_growth)

    reit_total_return = (reit_value - investment_amount) + reit_total_dividend

    # === Direct Real Estate Investment ===
    property_value = investment_amount / (1 - direct_loan_ratio)
    loan_amount = property_value * direct_loan_ratio
    equity = investment_amount
    acq_tax = property_value * direct_acquisition_tax
    equity_after_tax = equity - acq_tax

    direct_total_rental = 0
    current_property_value = property_value

    for y in range(years):
        rental_income = current_property_value * direct_rental_yield
        loan_interest = loan_amount * direct_loan_rate
        expenses = current_property_value * direct_expense_ratio
        net_rental = rental_income - loan_interest - expenses
        direct_total_rental += net_rental
        current_property_value *= (1 + direct_price_growth)

    property_gain = current_property_value - property_value
    direct_total_return = property_gain + direct_total_rental - acq_tax

    # Results
    print("="*60)
    print(f"  Investment Comparison (Capital: ${investment_amount:,}, {years}yr)")
    print("="*60)

    print(f"\n  [REITs Investment]")
    print(f"    Invested:           ${investment_amount:>15,}")
    print(f"    Final Asset Value:  ${reit_value:>15,.0f}")
    print(f"    Cumul. Div (post):  ${reit_total_dividend:>15,.0f}")
    print(f"    Total Return:       ${reit_total_return:>15,.0f}")
    reit_roi = reit_total_return / investment_amount * 100
    print(f"    ROI:                {reit_roi:>14.1f}%")

    print(f"\n  [Direct RE (LTV {direct_loan_ratio*100:.0f}%)]")
    print(f"    Equity:             ${investment_amount:>15,}")
    print(f"    Property Price:     ${property_value:>15,.0f}")
    print(f"    Loan Amount:        ${loan_amount:>15,.0f}")
    print(f"    Acquisition Tax:    ${acq_tax:>15,.0f}")
    print(f"    Sale Value:         ${current_property_value:>15,.0f}")
    print(f"    Cumul. Net Rental:  ${direct_total_rental:>15,.0f}")
    print(f"    Total Return:       ${direct_total_return:>15,.0f}")
    direct_roi = direct_total_return / investment_amount * 100
    print(f"    ROI (on equity):    {direct_roi:>14.1f}%")


# Run comparison
compare_investment_scenarios(
    investment_amount=200_000,  # USD 200,000
    years=10
)

import numpy as np

def calculate_portfolio_metrics(weights, returns, cov_matrix):
    """Calculate portfolio expected return and volatility"""
    port_return = np.dot(weights, returns)
    port_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    sharpe = (port_return - 0.04) / port_volatility  # Risk-free rate 4%
    return port_return, port_volatility, sharpe


# Asset class definitions (annual expected return, std dev)
asset_classes = {
    "US Equities":      {"return": 0.09, "std": 0.18},
    "Intl Equities":    {"return": 0.08, "std": 0.20},
    "US Bonds":         {"return": 0.04, "std": 0.05},
    "Intl Bonds":       {"return": 0.045, "std": 0.08},
    "REITs":            {"return": 0.07, "std": 0.15},
}

# Correlation matrix (REITs have lower correlation with stocks/bonds)
correlation_matrix = np.array([
    [1.00, 0.75, 0.10, 0.15, 0.45],  # US Equities
    [0.75, 1.00, 0.05, 0.20, 0.55],  # Intl Equities
    [0.10, 0.05, 1.00, 0.60, 0.15],  # US Bonds
    [0.15, 0.20, 0.60, 1.00, 0.20],  # Intl Bonds
    [0.45, 0.55, 0.15, 0.20, 1.00],  # REITs
])

returns = np.array([v["return"] for v in asset_classes.values()])
stds = np.array([v["std"] for v in asset_classes.values()])
cov_matrix = np.outer(stds, stds) * correlation_matrix

# Portfolio scenario comparison
scenarios = {
    "No REITs (60/40)":     np.array([0.35, 0.25, 0.25, 0.15, 0.00]),
    "10% REITs Allocation": np.array([0.30, 0.20, 0.25, 0.15, 0.10]),
    "15% REITs Allocation": np.array([0.25, 0.20, 0.25, 0.15, 0.15]),
    "20% REITs Allocation": np.array([0.25, 0.15, 0.20, 0.20, 0.20]),
}

print("="*65)
print("  Portfolio Scenario Comparison")
print("="*65)
print(f"\n  {'Scenario':<25} {'Exp Return':>10} {'Volatility':>10} {'Sharpe':>8}")
print("  " + "-" * 55)

for name, weights in scenarios.items():
    ret, vol, sharpe = calculate_portfolio_metrics(weights, returns, cov_matrix)
    print(f"  {name:<25} {ret*100:>9.2f}% {vol*100:>9.2f}% {sharpe:>8.3f}")

print(f"\n  Adding REITs improves risk-adjusted returns via diversification")

| Tax Category    | REITs                | Direct Real Estate      | RE Funds            |
|-----------------|----------------------|-------------------------|---------------------|
| Acquisition Tax | None                 | 4.6% (residential)      | None                |
| Holding Tax     | None (paid by REIT)  | Property tax + Comp tax | None                |
| Dividend/Rental | 15.4% (9.9% special) | Income tax up to 45%    | 15.4%               |
| Capital Gains   | Exempt (listed)      | CGT 6-45%               | Dividend tax 15.4%  |