İstatistik

# One-Way ANOVA Örneği: Marketing Channel Effectiveness
import numpy as np
import pandas as pd
from scipy import stats
from scipy.stats import f_oneway, levene, shapiro
import matplotlib.pyplot as plt

# Sentetik veri: 4 farklı marketing channel'ın conversion rate'leri
np.random.seed(42)

# Email: Ortalama conversion rate %8
email = np.random.normal(0.08, 0.02, 50)

# Social Media: Ortalama conversion rate %12
social = np.random.normal(0.12, 0.025, 45)

# Paid Ads: Ortalama conversion rate %15
paid_ads = np.random.normal(0.15, 0.03, 40)

# Organic: Ortalama conversion rate %6
organic = np.random.normal(0.06, 0.015, 55)

# DataFrame oluştur
data = []
for channel, rates in [('Email', email), ('Social', social), 
                      ('Paid_Ads', paid_ads), ('Organic', organic)]:
    for rate in rates:
        data.append({'Channel': channel, 'Conversion_Rate': rate})

df = pd.DataFrame(data)

print("Kanal Bazında İstatistikler:")
summary_stats = df.groupby('Channel')['Conversion_Rate'].agg([
    'count', 'mean', 'std', 'min', 'max'
]).round(4)
print(summary_stats)

# ANOVA varsayımlarını kontrol et
print(f"\n=== ANOVA Varsayım Kontrolleri ===")

# 1. Normallik testi (her grup için)
channels = df['Channel'].unique()
for channel in channels:
    channel_data = df[df['Channel'] == channel]['Conversion_Rate']
    stat, p_val = shapiro(channel_data)
    normal = "Normal" if p_val > 0.05 else "Normal Değil"
    print(f"{channel} Normallik: W = {stat:.3f}, p = {p_val:.6f} ({normal})")

# 2. Varyans homojenliği (Levene testi)
groups = [df[df['Channel'] == channel]['Conversion_Rate'] for channel in channels]
levene_stat, levene_p = levene(*groups)
homogeneous = "Homojen" if levene_p > 0.05 else "Heterojen"
print(f"\nVaryans Homojenliği: W = {levene_stat:.3f}, p = {levene_p:.6f} ({homogeneous})")

# One-Way ANOVA
f_statistic, p_value = f_oneway(*groups)

print(f"\n=== One-Way ANOVA Sonuçları ===")
print(f"F-istatistiği: {f_statistic:.3f}")
print(f"p-value: {p_value:.2e}")

if p_value < 0.05:
    print("Sonuç: En az bir grup ortalaması diğerlerinden farklıdır (p < 0.05)")
else:
    print("Sonuç: Tüm grup ortalamaları eşittir (p ≥ 0.05)")

# Effect Size (Eta-squared)
# η² = SSB / SST
grand_mean = df['Conversion_Rate'].mean()
ssb = sum([len(group) * (group.mean() - grand_mean)**2 for group in groups])
sst = sum([(x - grand_mean)**2 for x in df['Conversion_Rate']])
eta_squared = ssb / sst

print(f"Effect Size (η²): {eta_squared:.3f}")
if eta_squared < 0.01:
    effect_size = "Küçük"
elif eta_squared < 0.06:
    effect_size = "Orta"
elif eta_squared < 0.14:
    effect_size = "Büyük"
else:
    effect_size = "Çok Büyük"
print(f"Effect Size Yorumu: {effect_size} etki")

# Post-Hoc Analysis: Tukey HSD
from scipy.stats import tukey_hsd
from itertools import combinations

# Tukey HSD testi
groups_data = [df[df['Channel'] == channel]['Conversion_Rate'].values 
               for channel in channels]
tukey_result = tukey_hsd(*groups_data)

print("=== Post-Hoc Analysis: Tukey HSD ===")
print("Grup karşılaştırmaları:")

# Manuel pairwise karşılaştırma
for i, j in combinations(range(len(channels)), 2):
    group1_data = df[df['Channel'] == channels[i]]['Conversion_Rate']
    group2_data = df[df['Channel'] == channels[j]]['Conversion_Rate']
    
    t_stat, p_val = stats.ttest_ind(group1_data, group2_data)
    
    # Bonferroni correction
    n_comparisons = 6  # C(4,2) = 6 karşılaştırma
    bonferroni_p = p_val * n_comparisons
    bonferroni_p = min(bonferroni_p, 1.0)  # p-value 1'i geçemez
    
    mean_diff = group1_data.mean() - group2_data.mean()
    
    significance = "***" if bonferroni_p < 0.001 else "**" if bonferroni_p < 0.01 else "*" if bonferroni_p < 0.05 else "ns"
    
    print(f"{channels[i]} vs {channels[j]}:")
    print(f"  Mean difference: {mean_diff:7.4f}")
    print(f"  p-value (Bonferroni): {bonferroni_p:.6f} {significance}")

# Effect size for each comparison (Cohen's d)
print(f"\nCohen's d for each comparison:")
for i, j in combinations(range(len(channels)), 2):
    group1_data = df[df['Channel'] == channels[i]]['Conversion_Rate']
    group2_data = df[df['Channel'] == channels[j]]['Conversion_Rate']
    
    # Pooled standard deviation
    n1, n2 = len(group1_data), len(group2_data)
    s1, s2 = group1_data.std(ddof=1), group2_data.std(ddof=1)
    pooled_std = np.sqrt(((n1-1)*s1**2 + (n2-1)*s2**2) / (n1+n2-2))
    
    cohens_d = (group1_data.mean() - group2_data.mean()) / pooled_std
    
    print(f"{channels[i]} vs {channels[j]}: d = {cohens_d:6.3f}")

# Ki-Kare Bağımsızlık Testi Örneği
import numpy as np
import pandas as pd
from scipy.stats import chi2_contingency, chi2
from scipy.stats.contingency import association

# Örnek: Marketing Channel vs Conversion
# Sentetik veri oluştur
np.random.seed(42)
channels = ['Email', 'Social', 'Paid', 'Organic']
conversions = ['Converted', 'Not_Converted']

# Contingency table (çapraz tablo)
observed = np.array([
    [45, 155],  # Email: 45 conversion, 155 no conversion
    [65, 135],  # Social: 65 conversion, 135 no conversion  
    [85, 115],  # Paid: 85 conversion, 115 no conversion
    [25, 175]   # Organic: 25 conversion, 175 no conversion
])

print("Contingency Table (Çapraz Tablo):")
df_contingency = pd.DataFrame(observed, 
                             index=['Email', 'Social', 'Paid', 'Organic'],
                             columns=['Converted', 'Not_Converted'])
print(df_contingency)

# Ki-kare testi
chi2_stat, p_value, dof, expected = chi2_contingency(observed)

print(f"\n=== Ki-Kare Bağımsızlık Testi ===")
print(f"χ² istatistiği: {chi2_stat:.3f}")
print(f"p-value: {p_value:.6f}")
print(f"Serbestlik derecesi: {dof}")

# Kritik değer
alpha = 0.05
critical_value = chi2.ppf(1 - alpha, dof)
print(f"Kritik değer (α=0.05): {critical_value:.3f}")

# Karar
if p_value < alpha:
    print("Sonuç: Değişkenler bağımsız DEĞİLdir (p < 0.05)")
    print("Marketing channel ile conversion arasında anlamlı ilişki vardır.")
else:
    print("Sonuç: Değişkenler bağımsızdır (p ≥ 0.05)")

# Effect size (Cramér's V)
n = observed.sum()
cramers_v = np.sqrt(chi2_stat / (n * (min(observed.shape) - 1)))
print(f"Cramér's V (effect size): {cramers_v:.3f}")

# Beklenen değerler
print(f"\nBeklenen Değerler:")
df_expected = pd.DataFrame(expected.round(1),
                          index=['Email', 'Social', 'Paid', 'Organic'],
                          columns=['Converted', 'Not_Converted'])
print(df_expected)

# Goodness-of-Fit Test Örneği
from scipy.stats import chisquare

# Örnek: Zar atma deneyi - her yüzün eşit gelme olasılığı
observed_dice = [18, 22, 16, 25, 20, 19]  # 6 yüz için gözlenen frekanslar
expected_dice = [20, 20, 20, 20, 20, 20]  # Her yüz için beklenen (eşit dağılım)

chi2_gof, p_gof = chisquare(observed_dice, expected_dice)

print("=== Goodness-of-Fit Testi (Zar Örneği) ===")
print(f"Gözlenen: {observed_dice}")
print(f"Beklenen: {expected_dice}")
print(f"χ² istatistiği: {chi2_gof:.3f}")
print(f"p-value: {p_gof:.6f}")

if p_gof < 0.05:
    print("Sonuç: Zar ADALET DEĞİL (p < 0.05)")
else:
    print("Sonuç: Zar adil görünüyor (p ≥ 0.05)")

# Bayesian A/B Testing Örneği
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

# Beta-Binomial Conjugacy örneği
# A/B test: Conversion rate karşılaştırması

class BayesianABTest:
    def __init__(self, alpha_prior=1, beta_prior=1):
        self.alpha_prior = alpha_prior
        self.beta_prior = beta_prior
        
    def update_posterior(self, conversions, trials):
        """Beta posterior güncelleme"""
        alpha_posterior = self.alpha_prior + conversions
        beta_posterior = self.beta_prior + trials - conversions
        return alpha_posterior, beta_posterior
    
    def probability_A_beats_B(self, alpha_A, beta_A, alpha_B, beta_B, samples=10000):
        """A'nın B'den iyi olma olasılığı (Monte Carlo)"""
        # Posterior'lardan örneklem al
        samples_A = np.random.beta(alpha_A, beta_A, samples)
        samples_B = np.random.beta(alpha_B, beta_B, samples)
        
        return np.mean(samples_A > samples_B)

# Örnek veri
np.random.seed(42)
bayesian_test = BayesianABTest(alpha_prior=1, beta_prior=1)  # Uniform prior

# A grubu: 120 trial, 18 conversion
# B grubu: 100 trial, 20 conversion
conversions_A, trials_A = 18, 120
conversions_B, trials_B = 20, 100

# Posterior'ları güncelle
alpha_A, beta_A = bayesian_test.update_posterior(conversions_A, trials_A)
alpha_B, beta_B = bayesian_test.update_posterior(conversions_B, trials_B)

print("=== Bayesian A/B Test Sonuçları ===")
print(f"A grubu: {conversions_A}/{trials_A} = {conversions_A/trials_A:.3f}")
print(f"B grubu: {conversions_B}/{trials_B} = {conversions_B/trials_B:.3f}")

# Posterior istatistikleri
mean_A = alpha_A / (alpha_A + beta_A)
mean_B = alpha_B / (alpha_B + beta_B)
var_A = (alpha_A * beta_A) / ((alpha_A + beta_A)**2 * (alpha_A + beta_A + 1))
var_B = (alpha_B * beta_B) / ((alpha_B + beta_B)**2 * (alpha_B + beta_B + 1))

print(f"\nPosterior A: Beta({alpha_A}, {beta_A})")
print(f"  Mean: {mean_A:.4f}, Std: {np.sqrt(var_A):.4f}")
print(f"Posterior B: Beta({alpha_B}, {beta_B})")
print(f"  Mean: {mean_B:.4f}, Std: {np.sqrt(var_B):.4f}")

# B'nin A'dan iyi olma olasılığı
prob_B_wins = bayesian_test.probability_A_beats_B(alpha_B, beta_B, alpha_A, beta_A)
print(f"\nP(B > A) = {prob_B_wins:.3f}")
print(f"P(A > B) = {1 - prob_B_wins:.3f}")

# Credible intervals (Bayesian confidence intervals)
ci_A = stats.beta.interval(0.95, alpha_A, beta_A)
ci_B = stats.beta.interval(0.95, alpha_B, beta_B)

print(f"\n95% Credible Intervals:")
print(f"A: [{ci_A[0]:.4f}, {ci_A[1]:.4f}]")
print(f"B: [{ci_B[0]:.4f}, {ci_B[1]:.4f}]")

# Python ile t-Testi
import numpy as np
from scipy import stats

# Veri
sample_mean = 1050
population_mean = 1000
sample_std = 80
n = 20
alpha = 0.05

# t-istatistiği hesaplama
t_statistic = (sample_mean - population_mean) / (sample_std / np.sqrt(n))
print(f"t-istatistiği: {t_statistic:.3f}")

# Serbestlik derecesi
df = n - 1
print(f"Serbestlik derecesi: {df}")

# p-value hesaplama (tek yönlü test)
p_value = 1 - stats.t.cdf(t_statistic, df)
print(f"p-value: {p_value:.6f}")

# Kritik değer
critical_value = stats.t.ppf(1 - alpha, df)
print(f"Kritik değer: {critical_value:.3f}")

# Karar
if t_statistic > critical_value:
    print("H₀ reddedilir. Artış anlamlıdır.")
else:
    print("H₀ kabul edilir. Artış anlamlı değildir.")

print(f"Alpha: {alpha}, p-value: {p_value:.6f}")
if p_value < alpha:
    print("p < α: H₀ reddedilir")
else:
    print("p ≥ α: H₀ kabul edilir")

# A/B Test Örneği
import numpy as np
from scipy import stats

# A/B Test Verileri
np.random.seed(42)
control_group = np.random.normal(100, 15, 200)    # Kontrol grubu
treatment_group = np.random.normal(105, 15, 180)  # Treatment grubu

# Temel istatistikler
control_mean = np.mean(control_group)
treatment_mean = np.mean(treatment_group)
control_std = np.std(control_group, ddof=1)
treatment_std = np.std(treatment_group, ddof=1)

print(f"Kontrol grubu: μ = {control_mean:.2f}, σ = {control_std:.2f}, n = {len(control_group)}")
print(f"Treatment grubu: μ = {treatment_mean:.2f}, σ = {treatment_std:.2f}, n = {len(treatment_group)}")

# İki örneklem t-testi
t_stat, p_val = stats.ttest_ind(control_group, treatment_group, equal_var=False)
print(f"\nt-istatistiği: {t_stat:.3f}")
print(f"p-value: {p_val:.6f}")

# Etki büyüklüğü (Cohen's d)
pooled_std = np.sqrt(((len(control_group)-1)*control_std**2 + 
                     (len(treatment_group)-1)*treatment_std**2) / 
                    (len(control_group) + len(treatment_group) - 2))
cohens_d = (treatment_mean - control_mean) / pooled_std
print(f"Cohen's d: {cohens_d:.3f}")

# Güven aralığı
diff_mean = treatment_mean - control_mean
se_diff = np.sqrt(control_std**2/len(control_group) + treatment_std**2/len(treatment_group))
df_welch = ((control_std**2/len(control_group) + treatment_std**2/len(treatment_group))**2) / \
           ((control_std**2/len(control_group))**2/(len(control_group)-1) + 
            (treatment_std**2/len(treatment_group))**2/(len(treatment_group)-1))

t_critical = stats.t.ppf(0.975, df_welch)
ci_lower = diff_mean - t_critical * se_diff
ci_upper = diff_mean + t_critical * se_diff

print(f"Ortalama fark: {diff_mean:.2f}")
print(f"95% Güven aralığı: [{ci_lower:.2f}, {ci_upper:.2f}]")

# Python ile Basit Doğrusal Regresyon
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error

# Örnek veri: Reklam harcaması vs Satış
np.random.seed(42)
advertising = np.random.uniform(10, 100, 50)
noise = np.random.normal(0, 10, 50)
sales = 20 + 0.8 * advertising + noise

# DataFrame oluştur
df = pd.DataFrame({'Advertising': advertising, 'Sales': sales})

# Manuel hesaplama
x_mean = np.mean(advertising)
y_mean = np.mean(sales)

numerator = np.sum((advertising - x_mean) * (sales - y_mean))
denominator = np.sum((advertising - x_mean) ** 2)

beta1 = numerator / denominator
beta0 = y_mean - beta1 * x_mean

print(f"Manuel hesaplama:")
print(f"β₀ (intercept): {beta0:.3f}")
print(f"β₁ (slope): {beta1:.3f}")

# Sklearn ile
model = LinearRegression()
X = advertising.reshape(-1, 1)
y = sales

model.fit(X, y)
predictions = model.predict(X)

print(f"\nSklearn ile:")
print(f"β₀ (intercept): {model.intercept_:.3f}")
print(f"β₁ (slope): {model.coef_[0]:.3f}")

# Model değerlendirme
r2 = r2_score(y, predictions)
mse = mean_squared_error(y, predictions)
rmse = np.sqrt(mse)

print(f"\nModel Performansı:")
print(f"R²: {r2:.3f}")
print(f"MSE: {mse:.3f}")
print(f"RMSE: {rmse:.3f}")

# Pearson korelasyon
correlation, p_value = stats.pearsonr(advertising, sales)
print(f"Korelasyon: {correlation:.3f} (p = {p_value:.6f})")

# Çoklu Regresyon Örneği
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_absolute_error
import seaborn as sns

# Sentetik veri: Ev fiyat tahmini
np.random.seed(42)
n_samples = 500

# Features
size = np.random.normal(150, 50, n_samples)  # m²
bedrooms = np.random.poisson(3, n_samples)   # oda sayısı
age = np.random.exponential(15, n_samples)   # yaş
location_score = np.random.uniform(1, 10, n_samples)  # lokasyon skoru

# Target (price) - gerçekçi ilişki
noise = np.random.normal(0, 20000, n_samples)
price = (2000 * size + 
         10000 * bedrooms + 
         -500 * age + 
         15000 * location_score + 
         100000 + noise)

# DataFrame oluştur
df = pd.DataFrame({
    'size': size,
    'bedrooms': bedrooms,
    'age': age,
    'location_score': location_score,
    'price': price
})

print("Veri Seti Özeti:")
print(df.describe())

# Korelasyon matrisi
correlation_matrix = df.corr()
print(f"\nPrice ile korelasyonlar:")
print(correlation_matrix['price'].sort_values(ascending=False))

# Train-test split
X = df[['size', 'bedrooms', 'age', 'location_score']]
y = df['price']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Model eğitimi
model = LinearRegression()
model.fit(X_train, y_train)

# Tahminler
y_pred_train = model.predict(X_train)
y_pred_test = model.predict(X_test)

# Model değerlendirme
print(f"\nModel Katsayıları:")
print(f"Intercept: {model.intercept_:.0f}")
for i, feature in enumerate(X.columns):
    print(f"{feature}: {model.coef_[i]:.2f}")

print(f"\nModel Performansı:")
print(f"Train R²: {r2_score(y_train, y_pred_train):.3f}")
print(f"Test R²: {r2_score(y_test, y_pred_test):.3f}")
print(f"Test MAE: {mean_absolute_error(y_test, y_pred_test):.0f} TL")