コピペで学ぶ統計学

Colaboratoryにコードをコピペして、わからない点があれば生成AIに質問してください。

---

### 基本的な統計解析と回帰分析をPythonで実行する方法



```python
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# サンプルデータ (Sample Data)
data_x = np.array([1, 2, 3, 4, 5])
data_y = np.array([2, 4, 5, 4, 5])

# 平均 (Mean)
mean_x = np.mean(data_x)
mean_y = np.mean(data_y)

# 最大値・最小値 (Max and Min)
max_x = np.max(data_x)
min_x = np.min(data_x)

# 最頻値 (Mode)
mode_x = stats.mode(data_x)
mode_y = stats.mode(data_y)

# 中央値 (Median)
median_x = np.median(data_x)
median_y = np.median(data_y)

# 四分位数 (Quartiles)
quartiles_x = np.percentile(data_x, [25, 50, 75])

# 分散・標準偏差 (Variance and Standard Deviation)
variance_x = np.var(data_x)
std_dev_x = np.std(data_x)

# 共分散 (Covariance)
covariance = np.cov(data_x, data_y)[0, 1]

# 相関係数 (Correlation Coefficient)
correlation = np.corrcoef(data_x, data_y)[0, 1]

# 線形回帰と決定係数 (Linear Regression and R-squared)
X = data_x.reshape(-1, 1)  # データを適切な形状に変換
model = LinearRegression().fit(X, data_y)  # 線形回帰モデルをフィット
y_pred = model.predict(X)  # 予測値
r_squared = r2_score(data_y, y_pred)  # 決定係数

# 回帰平方和・総平方和 (Sums of Squares)
regression_sum_of_squares = np.sum((y_pred - np.mean(data_y)) ** 2)
total_sum_of_squares = np.sum((data_y - np.mean(data_y)) ** 2)

# プロット (Plot)
plt.scatter(data_x, data_y, color='blue', label='Data')  # データの散布図
plt.plot(data_x, y_pred, color='red', label='Linear Fit')  # 回帰直線
plt.title('Linear Regression and Data')  # グラフのタイトル
plt.xlabel('X-axis')  # X軸ラベル
plt.ylabel('Y-axis')  # Y軸ラベル
plt.legend()  # 凡例
plt.show()  # グラフを表示

# 結果表示 (Results)
print(f"Mean of X: {mean_x}, Mean of Y: {mean_y}")  # 平均
print(f"Max of X: {max_x}, Min of X: {min_x}")  # 最大値・最小値
print(f"Mode of X: {mode_x.mode[0]}, Mode of Y: {mode_y.mode[0]}")  # 最頻値
print(f"Median of X: {median_x}, Median of Y: {median_y}")  # 中央値
print(f"Quartiles of X: {quartiles_x}")  # 四分位数
print(f"Variance of X: {variance_x}, Std Dev of X: {std_dev_x}")  # 分散、標準偏差
print(f"Covariance: {covariance}")  # 共分散
print(f"Correlation Coefficient: {correlation}")  # 相関係数
print(f"R-squared: {r_squared}")  # 決定係数
print(f"Regression Sum of Squares: {regression_sum_of_squares}")  # 回帰平方和
print(f"Total Sum of Squares: {total_sum_of_squares}")  # 総平方和
```
### 統計量を計算した後に正規分布とデータのヒストグラムをプロットするコード


```python
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# Generate Sample Data
data = np.random.normal(loc=10, scale=2, size=100)  # Data from a normal distribution with mean 10 and std dev 2

# Mean
mean = np.mean(data)

# Population Variance
population_variance = np.var(data)

# Sample Variance (Unbiased)
sample_variance = np.var(data, ddof=1)

# Standard Error
standard_error = np.std(data, ddof=1) / np.sqrt(len(data))

# Probability Density Function (PDF) of Normal Distribution
x = np.linspace(min(data), max(data), 100)
pdf = norm.pdf(x, mean, np.std(data))

# Plot the Distribution
plt.figure(figsize=(8, 6))
plt.hist(data, bins=20, density=True, alpha=0.6, color='g', label='Data Histogram')  # Histogram of the data
plt.plot(x, pdf, color='red', label='Normal Distribution PDF')  # PDF of normal distribution
plt.title('Normal Distribution and Sample Data', fontsize=16)  # Title in English
plt.xlabel('Data values', fontsize=14)  # X-axis label in English
plt.ylabel('Density', fontsize=14)  # Y-axis label in English
plt.legend(fontsize=12)  # Legend in English
plt.grid(True)  # Show grid
plt.show()  # Show plot

# Display results
print(f"Mean: {mean}")
print(f"Population Variance: {population_variance}")
print(f"Sample Variance (Unbiased): {sample_variance}")
print(f"Standard Error: {standard_error}")
```

### Pythonコードで1サンプルt検定の実装


```python
import numpy as np
from scipy import stats

# サンプルデータ (Sample Data)
data = np.array([9.5, 10.5, 10.3, 10.1, 9.8, 10.6, 9.7, 10.0, 10.4, 9.9])

# 母平均 (Population Mean)
population_mean = 10

# サンプル平均 (Sample Mean)
sample_mean = np.mean(data)

# 標準誤差 (Standard Error)
standard_error = stats.sem(data)

# t検定の実行 (Performing t-test)
t_statistic, p_value = stats.ttest_1samp(data, population_mean)

# 有意水準 (Significance Level)
alpha = 0.05

# 結果の表示 (Display Results)
print(f"Sample Mean (標本平均): {sample_mean}")
print(f"Population Mean (母平均): {population_mean}")
print(f"T-statistic: {t_statistic}")
print(f"P-value (P値): {p_value}")

# 棄却域の判断 (Decision on Rejection Region)
if p_value < alpha:
    print(f"Reject the null hypothesis (帰無仮説を棄却します), P-value is less than {alpha}.")
else:
    print(f"Fail to reject the null hypothesis (帰無仮説を棄却しません), P-value is greater than {alpha}.")
```

### データを標準正規分布に変換し、期待値（平均）、分散、および標準誤差を計算するPythonコード


```python
import numpy as np

# サンプルデータ (Sample Data)
data = np.array([9.5, 10.5, 10.3, 10.1, 9.8, 10.6, 9.7, 10.0, 10.4, 9.9])

# 元データの期待値 (Mean of original data)
mean = np.mean(data)

# 元データの標準偏差 (Standard Deviation of original data)
std_dev = np.std(data)

# 標準正規分布への変換 (Transforming data to Standard Normal Distribution)
z_scores = (data - mean) / std_dev

# 標準正規分布に変換されたデータの期待値 (Mean of Z-scores)
z_mean = np.mean(z_scores)

# 標準正規分布に変換されたデータの分散 (Variance of Z-scores)
z_variance = np.var(z_scores)

# 標準誤差 (Standard Error)
standard_error = np.std(data) / np.sqrt(len(data))

# 結果の表示 (Displaying Results)
print(f"Original Data Mean (期待値): {mean}")
print(f"Original Data Standard Deviation (標準偏差): {std_dev}")
print(f"Z-scores (標準正規分布): {z_scores}")
print(f"Mean of Z-scores (標準正規分布の期待値): {z_mean}")
print(f"Variance of Z-scores (標準正規分布の分散): {z_variance}")
print(f"Standard Error (標準誤差): {standard_error}")

```
### 信頼区間をグラフにプロット


```python
import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt

# 母集団データの生成 (Generating Population Data)
population = np.random.normal(loc=50, scale=10, size=10000)  # 平均50、標準偏差10の母集団

# サンプルデータを抽出 (Extract Sample Data)
sample = np.random.choice(population, size=30, replace=False)  # 母集団から30の標本を抽出

# 標本平均 (Sample Mean)
sample_mean = np.mean(sample)

# 標本分散と標本標準偏差 (Sample Variance and Standard Deviation)
sample_std_dev = np.std(sample, ddof=1)

# 信頼区間95% (95% Confidence Interval)
confidence_level = 0.95
alpha = 1 - confidence_level
n = len(sample)
t_value = stats.t.ppf(1 - alpha / 2, df=n - 1)  # t分布を使用
margin_of_error = t_value * (sample_std_dev / np.sqrt(n))  # 信頼区間の幅
confidence_interval = (sample_mean - margin_of_error, sample_mean + margin_of_error)

# グラフの描画 (Plotting the Graph)
plt.figure(figsize=(8, 6))

# サンプルのヒストグラム (Histogram of the sample)
plt.hist(sample, bins=10, alpha=0.6, color='blue', label='Sample Data')

# 標本平均のプロット (Plotting the Sample Mean)
plt.axvline(sample_mean, color='red', linestyle='--', label=f'Sample Mean: {sample_mean:.2f}')

# 信頼区間のプロット (Plotting the Confidence Interval)
plt.axvline(confidence_interval[0], color='green', linestyle='--', label=f'Lower CI: {confidence_interval[0]:.2f}')
plt.axvline(confidence_interval[1], color='green', linestyle='--', label=f'Upper CI: {confidence_interval[1]:.2f}')

# グラフのタイトルとラベル (Title and Labels)
plt.title('Sample Data with 95% Confidence Interval', fontsize=16)
plt.xlabel('Data Values', fontsize=14)
plt.ylabel('Frequency', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True)
plt.show()

# 結果を表示 (Displaying Results)
print(f"Sample Mean (標本平均): {sample_mean}")
print(f"95% Confidence Interval (95%信頼区間): {confidence_interval}")
```


### 母比率、標本比率、信頼区間、信頼度、および平均値、分散、期待値、標準偏差を計算するためのPythonコード


```python
import numpy as np
import scipy.stats as stats

# サンプルデータ (Sample Data)
# ここではバイナリデータ (0 = 失敗, 1 = 成功) を使用
data = np.random.choice([0, 1], size=100, p=[0.4, 0.6])  # 0が40%, 1が60%の確率で100個のデータを生成

# 標本比率 (Sample Proportion)
sample_size = len(data)
sample_proportion = np.mean(data)

# 母比率 (Population Proportion)
# 母集団の比率が既知の場合に使用。ここでは母比率60%と仮定。
population_proportion = 0.6

# 信頼区間95% (95% Confidence Interval for Proportion)
confidence_level = 0.95
alpha = 1 - confidence_level
z_value = stats.norm.ppf(1 - alpha / 2)  # 正規分布のZ値 (95%信頼度)

# 標準誤差 (Standard Error for Proportion)
standard_error_proportion = np.sqrt((sample_proportion * (1 - sample_proportion)) / sample_size)

# 信頼区間の計算 (Calculating Confidence Interval for Proportion)
margin_of_error = z_value * standard_error_proportion
confidence_interval_proportion = (sample_proportion - margin_of_error, sample_proportion + margin_of_error)

# 平均値 (Mean)
mean_value = np.mean(data)

# 分散 (Variance)
variance_value = np.var(data, ddof=1)  # 標本分散

# 標準偏差 (Standard Deviation)
std_dev_value = np.std(data, ddof=1)

# 結果を表示 (Display Results)
print(f"Sample Size: {sample_size}")
print(f"Sample Proportion (標本比率): {sample_proportion}")
print(f"Population Proportion (母比率, assumed): {population_proportion}")
print(f"95% Confidence Interval for Proportion (信頼区間): {confidence_interval_proportion}")
print(f"Mean (平均値): {mean_value}")
print(f"Variance (分散): {variance_value}")
print(f"Standard Deviation (標準偏差): {std_dev_value}")

```



```python
import numpy as np
from scipy.stats import norm

# サンプルデータの生成 (Generating Sample Data)
data = np.random.normal(loc=10, scale=2, size=100)  # 平均10、標準偏差2の正規分布からサンプル生成

# 平均 (Mean)
mean = np.mean(data)

# 分散 (Variance) と 標準偏差 (Standard Deviation)
variance = np.var(data)  # 母分散
sample_variance = np.var(data, ddof=1)  # 不偏分散
std_dev = np.std(data, ddof=1)

# 標準誤差 (Standard Error)
standard_error = std_dev / np.sqrt(len(data))

# 結果表示
print(f"Mean (期待値): {mean}")
print(f"Variance (母分散): {variance}")
print(f"Sample Variance (不偏分散): {sample_variance}")
print(f"Standard Deviation (標準偏差): {std_dev}")
print(f"Standard Error (標準誤差): {standard_error}")

```

### 二項分布、ベルヌーイ分布、そして正規分布と中心極限定理を扱うためのPythonコード


```python
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# 1. 二項分布: スマホのガチャの例
n_trials = 100  # ガチャを引く回数 (Number of trials)
p_success = 0.05  # ガチャが当たる確率 (Probability of success)

# 二項分布のサンプル生成 (Generate sample from a binomial distribution)
binomial_data = np.random.binomial(n_trials, p_success, size=1000)

# 二項分布の期待値と分散 (Expected value and variance of binomial distribution)
binomial_mean = n_trials * p_success  # 期待値 E[X] = np
binomial_variance = n_trials * p_success * (1 - p_success)  # 分散 Var(X) = np(1-p)

print(f"Binomial Distribution - Mean (期待値): {binomial_mean}")
print(f"Binomial Distribution - Variance (分散): {binomial_variance}")

# 2. ベルヌーイ分布: 0と1の分布
p_bernoulli = 0.3  # 成功確率
bernoulli_data = np.random.binomial(1, p_bernoulli, size=1000)  # ベルヌーイ試行のデータ生成 (Generate Bernoulli trials)

# ベルヌーイ分布の期待値と分散 (Expected value and variance of Bernoulli distribution)
bernoulli_mean = np.mean(bernoulli_data)
bernoulli_variance = np.var(bernoulli_data, ddof=1)  # 不偏分散 (Sample variance)

print(f"Bernoulli Distribution - Mean (期待値): {bernoulli_mean}")
print(f"Bernoulli Distribution - Variance (分散): {bernoulli_variance}")

# 3. 中心極限定理と正規分布 (Central Limit Theorem and Normal Distribution)
sample_size = 100  # サンプルサイズ (Sample size)
samples = np.random.binomial(n_trials, p_success, size=(1000, sample_size))  # 二項分布からサンプルを取得

# 各サンプルの平均を計算 (Calculate means of each sample)
sample_means = np.mean(samples, axis=1)

# 正規分布の理論的な平均と標準偏差 (Theoretical mean and std of normal distribution)
normal_mean = binomial_mean  # 中心極限定理により、正規分布の平均は二項分布の平均と同じ
normal_std_dev = np.sqrt(binomial_variance / sample_size)  # 標準誤差 (Standard error)

# ヒストグラムのプロット (Plot histogram of sample means)
plt.figure(figsize=(10, 6))
plt.hist(sample_means, bins=30, density=True, alpha=0.6, color='g', label='Sample Means (from Binomial)')
xmin, xmax = plt.xlim()

# 理論的な正規分布をプロット (Plot theoretical normal distribution)
x = np.linspace(xmin, xmax, 100)
pdf_normal = stats.norm.pdf(x, normal_mean, normal_std_dev)
plt.plot(x, pdf_normal, 'r', label='Normal Distribution (CLT)')
plt.title("Central Limit Theorem - Binomial to Normal Distribution")
plt.xlabel("Sample Mean")
plt.ylabel("Density")
plt.legend()
plt.grid(True)
plt.show()
```


### 離散型および連続型の代表的な確率分布を扱うPythonコード


```python
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# グラフの設定 (Plot settings)
fig, axes = plt.subplots(5, 2, figsize=(12, 18))
axes = axes.ravel()

# 1. 離散型分布 (Discrete Distributions)

# 一様分布 (Discrete Uniform Distribution)
uniform_discrete_data = np.random.randint(1, 7, size=1000)  # 1から6までの一様分布
axes[0].hist(uniform_discrete_data, bins=6, density=True, color='lightblue')
axes[0].set_title('Discrete Uniform Distribution')

# 二項分布 (Binomial Distribution)
n_trials = 10
p_success = 0.5
binom_data = np.random.binomial(n_trials, p_success, size=1000)
axes[1].hist(binom_data, bins=n_trials + 1, density=True, color='lightgreen')
axes[1].set_title('Binomial Distribution')

# ポアソン分布 (Poisson Distribution)
lambda_poisson = 5
poisson_data = np.random.poisson(lambda_poisson, size=1000)
axes[2].hist(poisson_data, bins=30, density=True, color='orange')
axes[2].set_title('Poisson Distribution')

# 幾何分布 (Geometric Distribution)
p_geom = 0.3
geom_data = np.random.geometric(p_geom, size=1000)
axes[3].hist(geom_data, bins=30, density=True, color='purple')
axes[3].set_title('Geometric Distribution')

# 2. 連続型分布 (Continuous Distributions)

# 正規分布 (Normal Distribution)
mean_norm = 0
std_dev_norm = 1
norm_data = np.random.normal(mean_norm, std_dev_norm, size=1000)
axes[4].hist(norm_data, bins=30, density=True, color='lightcoral')
axes[4].set_title('Normal Distribution')

# 対数正規分布 (Log-Normal Distribution)
mean_log = 0
sigma_log = 1
lognorm_data = np.random.lognormal(mean_log, sigma_log, size=1000)
axes[5].hist(lognorm_data, bins=30, density=True, color='lightyellow')
axes[5].set_title('Log-Normal Distribution')

# 指数分布 (Exponential Distribution)
lambda_exp = 1
exp_data = np.random.exponential(1/lambda_exp, size=1000)
axes[6].hist(exp_data, bins=30, density=True, color='lightpink')
axes[6].set_title('Exponential Distribution')

# ガンマ分布 (Gamma Distribution)
shape_gamma = 2
scale_gamma = 2
gamma_data = np.random.gamma(shape_gamma, scale_gamma, size=1000)
axes[7].hist(gamma_data, bins=30, density=True, color='lightgray')
axes[7].set_title('Gamma Distribution')

# 負の二項分布 (Negative Binomial Distribution)
r_neg_binom = 5
p_neg_binom = 0.4
neg_binom_data = np.random.negative_binomial(r_neg_binom, p_neg_binom, size=1000)
axes[8].hist(neg_binom_data, bins=30, density=True, color='lightcyan')
axes[8].set_title('Negative Binomial Distribution')

# ワイブル分布 (Weibull Distribution)
shape_weibull = 2
weibull_data = np.random.weibull(shape_weibull, size=1000)
axes[9].hist(weibull_data, bins=30, density=True, color='lightgoldenrodyellow')
axes[9].set_title('Weibull Distribution')

# レイアウト調整 (Layout adjustments)
plt.tight_layout()
plt.show()
```


### 他コピペで学ぶPythonコード
```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# 1. データの生成 (サンプルデータ)
# 説明変数 (Features) と目的変数 (Target)
np.random.seed(0)
X = np.random.rand(100, 3)  # 100個のサンプル、3つの特徴量 (Features)
true_coefficients = [3, 5, 2]  # 実際の係数 (True Coefficients)
y = X @ true_coefficients + np.random.randn(100)  # ターゲット変数 (Target) ＝ 特徴量の線形結合 + ノイズ

# 2. 訓練データとテストデータに分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 3. 重回帰モデルの適合 (Fitting the Multiple Linear Regression Model)
model = LinearRegression()
model.fit(X_train, y_train)

# 4. 予測 (Prediction)
y_pred = model.predict(X_test)

# 5. モデル評価 (Model Evaluation)
mse = mean_squared_error(y_test, y_pred)  # 平均二乗誤差 (Mean Squared Error)
r2 = r2_score(y_test, y_pred)  # 決定係数 (R-squared)
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared: {r2:.2f}")

# 回帰係数 (Coefficients) と切片 (Intercept)
print("Regression Coefficients:", model.coef_)
print("Intercept:", model.intercept_)

# 6. 結果のプロット (Optional: Plotting)
plt.figure(figsize=(8, 6))
plt.scatter(y_test, y_pred)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.title('Observed vs Predicted Values')
plt.xlabel('Observed')
plt.ylabel('Predicted')
plt.grid(True)
plt.show()
```
```
import numpy as np

# 1. サンプルデータの生成 (サンプルデータ)
np.random.seed(0)
sample_data = np.random.normal(loc=50, scale=10, size=100)  # 平均50, 標準偏差10の正規分布に従う100個のデータ

# 2. 点推定の計算
# サンプル平均 (点推定量としての母平均の推定)
sample_mean = np.mean(sample_data)

# サンプル分散 (点推定量としての母分散の推定)
# デフォルトでは numpy.var は母分散を計算するため、不偏分散には ddof=1 を指定
sample_variance = np.var(sample_data, ddof=1)

# 3. 結果の表示
print(f"サンプル平均 (母平均の推定値): {sample_mean:.2f}")
print(f"サンプル分散 (母分散の推定値): {sample_variance:.2f}")

# 4. 信頼区間の計算（区間推定の例）
from scipy import stats

# 95%信頼区間を計算
confidence_level = 0.95
degrees_freedom = len(sample_data) - 1  # 自由度 = サンプル数 - 1
confidence_interval = stats.t.interval(confidence_level, degrees_freedom, loc=sample_mean, scale=stats.sem(sample_data))

print(f"95%信頼区間: {confidence_interval}")

```
```

import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt

# Sample data for the tests
data1 = np.random.normal(loc=10, scale=2, size=30)  # Group 1: Mean=10, StdDev=2
data2 = np.random.normal(loc=12, scale=2, size=30)  # Group 2: Mean=12, StdDev=2

# 1. Confidence Interval
def confidence_interval(data, confidence=0.95):
    """
    Calculate confidence interval for the given data.
    :param data: The sample data
    :param confidence: Confidence level (default 95%)
    :return: Confidence interval
    """
    n = len(data)
    mean = np.mean(data)
    std_err = stats.sem(data)  # Standard error of the mean
    h = std_err * stats.t.ppf((1 + confidence) / 2., n - 1)
    return mean - h, mean + h

ci = confidence_interval(data1)
print(f"Confidence Interval (95%): {ci}")

# 2. t-test (Independent Two-sample t-test)
t_statistic, p_value_ttest = stats.ttest_ind(data1, data2)
print(f"t-test: t-statistic = {t_statistic}, p-value = {p_value_ttest}")

# 3. Chi-squared Test
# Creating a contingency table (e.g., categorical data)
obs = np.array([[30, 10], [20, 40]])  # Example: observed data
chi2_stat, p_value_chi2, dof, expected = stats.chi2_contingency(obs)
print(f"Chi-squared Test: chi2_statistic = {chi2_stat}, p-value = {p_value_chi2}")

# 4. F-test (Comparing variances of two datasets)
f_stat = np.var(data1, ddof=1) / np.var(data2, ddof=1)
dfn = len(data1) - 1  # Degrees of freedom for numerator
dfd = len(data2) - 1  # Degrees of freedom for denominator
p_value_ftest = 1 - stats.f.cdf(f_stat, dfn, dfd)
print(f"F-test: f-statistic = {f_stat}, p-value = {p_value_ftest}")

# 5. Plotting P-value for t-test (visualizing significance)
x = np.linspace(-5, 5, 1000)
t_distribution = stats.t.pdf(x, df=len(data1) - 1)

plt.figure(figsize=(8, 6))
plt.plot(x, t_distribution, label="t-distribution")
plt.fill_between(x, 0, t_distribution, where=(x < -abs(t_statistic)) | (x > abs(t_statistic)), color='red', alpha=0.5, label="p-value region")
plt.axvline(t_statistic, color='blue', linestyle='--', label=f't-statistic = {t_statistic:.2f}')
plt.title('t-test P-value visualization')
plt.xlabel('t-statistic')
plt.ylabel('Probability Density')
plt.legend()
plt.grid(True)
plt.show()

# Displaying results
print(f"Results Summary:\n"
      f"Confidence Interval for Group 1 (95%): {ci}\n"
      f"t-test: t-statistic = {t_statistic:.2f}, p-value = {p_value_ttest:.4f}\n"
      f"Chi-squared Test: chi2-statistic = {chi2_stat:.2f}, p-value = {p_value_chi2:.4f}\n"
      f"F-test: f-statistic = {f_stat:.2f}, p-value = {p_value_ftest:.4f}")
```


```

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, LogisticRegression, Ridge, Lasso
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score, accuracy_score

# Generate some sample data
np.random.seed(0)
X = 2 * np.random.rand(100, 1)  # Independent variable
y = 4 + 3 * X + np.random.randn(100, 1)  # Dependent variable for linear regression

# Split the data into training and testing sets (80% training, 20% testing)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 1. Simple Linear Regression (単回帰分析)
linear_reg_model = LinearRegression()
linear_reg_model.fit(X_train, y_train)
y_pred_linear = linear_reg_model.predict(X_test)

print(f"Simple Linear Regression R-squared: {r2_score(y_test, y_pred_linear):.4f}")
print(f"Simple Linear Regression MSE: {mean_squared_error(y_test, y_pred_linear):.4f}")

# Plot the simple linear regression
plt.scatter(X_test, y_test, color="blue", label="True values")
plt.plot(X_test, y_pred_linear, color="red", label="Predicted (Linear Fit)")
plt.title('Simple Linear Regression')
plt.xlabel('X values')
plt.ylabel('y values')
plt.legend()
plt.grid(True)
plt.show()

# 2. Multiple Linear Regression (重回帰分析)
# Generating multiple features for multiple regression
X_multi = np.random.rand(100, 3)  # 3 independent variables
y_multi = 3 + 2 * X_multi[:, 0] + 4 * X_multi[:, 1] + 5 * X_multi[:, 2] + np.random.randn(100)

X_train_multi, X_test_multi, y_train_multi, y_test_multi = train_test_split(X_multi, y_multi, test_size=0.2, random_state=42)

multi_reg_model = LinearRegression()
multi_reg_model.fit(X_train_multi, y_train_multi)
y_pred_multi = multi_reg_model.predict(X_test_multi)

print(f"Multiple Linear Regression R-squared: {r2_score(y_test_multi, y_pred_multi):.4f}")
print(f"Multiple Linear Regression MSE: {mean_squared_error(y_test_multi, y_pred_multi):.4f}")

# 3. Logistic Regression (ロジスティック回帰)
# Generating binary classification data
X_log = np.random.rand(100, 2)  # 2 features for logistic regression
y_log = (X_log[:, 0] + X_log[:, 1] > 1).astype(int)  # Binary output (0 or 1)

X_train_log, X_test_log, y_train_log, y_test_log = train_test_split(X_log, y_log, test_size=0.2, random_state=42)

log_reg_model = LogisticRegression()
log_reg_model.fit(X_train_log, y_train_log)
y_pred_log = log_reg_model.predict(X_test_log)

print(f"Logistic Regression Accuracy: {accuracy_score(y_test_log, y_pred_log):.4f}")

# 4. Ridge Regression (リッジ回帰)
ridge_reg_model = Ridge(alpha=1.0)  # Alpha is the regularization strength
ridge_reg_model.fit(X_train_multi, y_train_multi)
y_pred_ridge = ridge_reg_model.predict(X_test_multi)

print(f"Ridge Regression R-squared: {r2_score(y_test_multi, y_pred_ridge):.4f}")
print(f"Ridge Regression MSE: {mean_squared_error(y_test_multi, y_pred_ridge):.4f}")

# 5. Lasso Regression (ラッソ回帰)
lasso_reg_model = Lasso(alpha=0.1)  # Alpha is the regularization strength
lasso_reg_model.fit(X_train_multi, y_train_multi)
y_pred_lasso = lasso_reg_model.predict(X_test_multi)

print(f"Lasso Regression R-squared: {r2_score(y_test_multi, y_pred_lasso):.4f}")
print(f"Lasso Regression MSE: {mean_squared_error(y_test_multi, y_pred_lasso):.4f}")


```


```

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.decomposition import FactorAnalysis
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

# Load a sample dataset (Iris dataset)
iris = load_iris()
X = iris.data  # Independent variables
y = iris.target  # Dependent variable (class labels)
features = iris.feature_names

# Standardize the data for better performance
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 1. Principal Component Analysis (PCA)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

print(f'Explained variance by components (PCA): {pca.explained_variance_ratio_}')

# Plot PCA result
plt.figure(figsize=(8, 6))
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis', edgecolor='k', s=150)
plt.title('PCA: Principal Component Analysis')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.grid(True)
plt.show()

# 2. Factor Analysis (FA)
fa = FactorAnalysis(n_components=2)
X_fa = fa.fit_transform(X_scaled)

print(f'Factor Analysis Components (Loadings):\n {fa.components_}')

# Plot Factor Analysis result
plt.figure(figsize=(8, 6))
plt.scatter(X_fa[:, 0], X_fa[:, 1], c=y, cmap='coolwarm', edgecolor='k', s=150)
plt.title('Factor Analysis')
plt.xlabel('Factor 1')
plt.ylabel('Factor 2')
plt.grid(True)
plt.show()

# 3. Discriminant Analysis (LDA)
lda = LDA(n_components=2)
X_lda = lda.fit(X_scaled, y).transform(X_scaled)

print(f'Explained variance by components (LDA): {lda.explained_variance_ratio_}')

# Plot LDA result
plt.figure(figsize=(8, 6))
plt.scatter(X_lda[:, 0], X_lda[:, 1], c=y, cmap='plasma', edgecolor='k', s=150)
plt.title('LDA: Linear Discriminant Analysis')
plt.xlabel('Discriminant Function 1')
plt.ylabel('Discriminant Function 2')
plt.grid(True)
plt.show()

# 4. Cluster Analysis (K-Means Clustering)
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X_scaled)

print(f'Cluster centers:\n{kmeans.cluster_centers_}')

# Plot K-Means Clustering result
plt.figure(figsize=(8, 6))
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=clusters, cmap='rainbow', edgecolor='k', s=150)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s=300, c='black', marker='x', label='Centroids')
plt.title('K-Means Clustering')
plt.xlabel(features[0])
plt.ylabel(features[1])
plt.legend()
plt.grid(True)
plt.show()



```
```

import numpy as np
import pandas as pd
from scipy import stats
from statsmodels.formula.api import ols
import statsmodels.api as sm
from statsmodels.stats.multicomp import pairwise_tukeyhsd

# 1. One-way ANOVA (一元配置分散分析)
# Example: 3 groups with different data points
group1 = np.random.normal(20, 5, size=30)  # Group 1
group2 = np.random.normal(22, 5, size=30)  # Group 2
group3 = np.random.normal(24, 5, size=30)  # Group 3

# Perform one-way ANOVA
f_statistic, p_value_anova = stats.f_oneway(group1, group2, group3)
print(f"One-way ANOVA: F-statistic = {f_statistic:.4f}, p-value = {p_value_anova:.4f}")

# 2. Two-way ANOVA (二元配置分散分析)
# Create a simple DataFrame for two-way ANOVA
np.random.seed(42)
data = {
    'Factor1': np.repeat(['A', 'B', 'C'], 30),
    'Factor2': np.tile(np.repeat(['X', 'Y'], 15), 3),
    'Value': np.concatenate([np.random.normal(20, 5, 30),
                             np.random.normal(22, 5, 30),
                             np.random.normal(24, 5, 30)])
}
df = pd.DataFrame(data)

# Perform two-way ANOVA
model = ols('Value ~ C(Factor1) + C(Factor2) + C(Factor1):C(Factor2)', data=df).fit()
anova_table = sm.stats.anova_lm(model, typ=2)
print("\nTwo-way ANOVA Results:\n", anova_table)

# 3. Post-hoc Tests (多重比較法)
# Combine the groups for Tukey's HSD post-hoc test
data_anova = np.concatenate([group1, group2, group3])
groups = np.array(['Group1'] * 30 + ['Group2'] * 30 + ['Group3'] * 30)

# Tukey's HSD test
tukey_result = pairwise_tukeyhsd(data_anova, groups, alpha=0.05)
print("\nTukey's HSD Test Results:\n", tukey_result)



```





```python



import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats

# 1. 折れ線グラフ (Line Chart)
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(8, 4))
plt.plot(x, y, label='Sine Wave')
plt.title('Line Chart - Sine Wave')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.grid(True)
plt.show()

# 2. ヒストグラム (Histogram)
data = np.random.randn(1000)
plt.figure(figsize=(8, 4))
plt.hist(data, bins=30, color='skyblue', edgecolor='black')
plt.title('Histogram - Random Data')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

# 3. バブルチャート (Bubble Chart)
x = np.random.rand(50)
y = np.random.rand(50)
z = np.random.rand(50) * 1000  # バブルのサイズ
plt.figure(figsize=(8, 4))
plt.scatter(x, y, s=z, alpha=0.5, c=z, cmap='viridis')
plt.title('Bubble Chart')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.colorbar(label='Bubble Size')
plt.show()

# 4. パレード図 (Pareto Chart)
values = [25, 20, 15, 10, 5, 3, 2]
labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
cumulative_percentage = np.cumsum(values) / np.sum(values) * 100

plt.figure(figsize=(8, 4))
plt.bar(labels, values, color='skyblue', label='Values')
plt.plot(labels, cumulative_percentage, color='red', marker='o', label='Cumulative Percentage')
plt.title('Pareto Chart')
plt.xlabel('Categories')
plt.ylabel('Values')
plt.legend()
plt.show()

# 5. ABC分析 (ABC Analysis)
df = pd.DataFrame({'Items': labels, 'Value': values})
df['Cumulative Percentage'] = df['Value'].cumsum() / df['Value'].sum() * 100
abc_thresholds = {'A': 80, 'B': 95}

# ABC分析の分類
df['Category'] = pd.cut(df['Cumulative Percentage'], bins=[0, 80, 95, 100], labels=['A', 'B', 'C'])
plt.figure(figsize=(8, 4))
plt.bar(df['Items'], df['Value'], color=['red' if cat == 'A' else 'orange' if cat == 'B' else 'green' for cat in df['Category']])
plt.title('ABC Analysis')
plt.xlabel('Items')
plt.ylabel('Value')
plt.show()
print(df)

# 6. 時系列分析 (Time Series Analysis)
time_series_data = np.cumsum(np.random.randn(100))  # ランダムウォーク
plt.figure(figsize=(8, 4))
plt.plot(time_series_data, label='Time Series Data')
plt.title('Time Series Analysis')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.show()

# 7. カイ2乗分析 (Chi-squared Test)
observed = np.array([50, 30, 20])
expected = np.array([40, 40, 20])
chi2, p = stats.chisquare(f_obs=observed, f_exp=expected)
print(f"Chi-squared Test\nChi2 Statistic: {chi2}, P-value: {p}")

# 8. ピポットテーブル (Pivot Table)
data = pd.DataFrame({'Category': ['A', 'B', 'A', 'B'], 'Value': [10, 15, 10, 20]})
pivot_table = data.pivot_table(values='Value', index='Category', aggfunc=np.sum)
print("\nPivot Table:\n", pivot_table)

```


```

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
from statsmodels.tsa.stattools import acf
from statsmodels.graphics.tsaplots import plot_acf

# 1. 度数分布表 (Frequency Distribution Table)
data = np.random.randint(1, 100, size=100)
freq_table = pd.cut(data, bins=10).value_counts().sort_index()
print("Frequency Distribution Table:")
print(freq_table)

# 2. ローレンツ曲線とジニ係数 (Lorenz Curve and Gini Coefficient)
income = np.random.rand(1000)
income.sort()
cumulative_income = np.cumsum(income) / income.sum()  # 累積相対度数
lorenz_curve = np.insert(cumulative_income, 0, 0)
gini_index = 1 - 2 * np.trapz(lorenz_curve)

# ローレンツ曲線のプロット
plt.figure(figsize=(8, 4))
plt.plot(np.linspace(0, 1, len(lorenz_curve)), lorenz_curve, label='Lorenz Curve')
plt.plot([0, 1], [0, 1], linestyle='--', color='black', label='Equality Line')
plt.title('Lorenz Curve and Gini Coefficient')
plt.xlabel('Cumulative Share of Population')
plt.ylabel('Cumulative Share of Income')
plt.legend()
plt.grid(True)
plt.show()
print(f"Gini Coefficient: {gini_index:.3f}")

# 3. グラフの指数化 (Graph Indexing)
base_year = 2010
years = np.arange(2010, 2021)
values = np.random.rand(len(years)) * 100 + 100  # ランダムなデータ
index_values = (values / values[0]) * 100  # 基準年に対する指数化

plt.figure(figsize=(8, 4))
plt.plot(years, index_values, label='Indexed Values (Base Year 2010)')
plt.title('Indexed Growth (Base Year 2010)')
plt.xlabel('Year')
plt.ylabel('Index (Base = 100)')
plt.grid(True)
plt.show()

# 4. 変化率と伸び率 (Rate of Change and Growth Rate)
rate_of_change = np.diff(values) / values[:-1] * 100  # 変化率 (パーセント)
growth_rate = ((values[-1] - values[0]) / values[0]) * 100  # 全期間の成長率
print(f"Yearly Rate of Change (%): {rate_of_change}")
print(f"Overall Growth Rate (%): {growth_rate:.2f}")

# 5. ラスパイレス指数 (Laspeyres Index)
base_year_prices = np.array([100, 150, 200])
comparison_year_prices = np.array([110, 140, 220])
base_year_quantities = np.array([10, 5, 8])

laspeyres_index = (np.sum(comparison_year_prices * base_year_quantities) /
                   np.sum(base_year_prices * base_year_quantities)) * 100
print(f"Laspeyres Price Index: {laspeyres_index:.2f}")

# 6. 時系列データ分析 (Time Series Analysis)
np.random.seed(0)
time_series_data = np.cumsum(np.random.randn(100))  # ランダムウォーク
plt.figure(figsize=(8, 4))
plt.plot(time_series_data, label='Time Series Data')
plt.title('Time Series Data')
plt.xlabel('Time')
plt.ylabel('Value')
plt.grid(True)
plt.show()

# 傾向変動 (Trend) を表示
trend = np.polyfit(np.arange(len(time_series_data)), time_series_data, 1)
plt.figure(figsize=(8, 4))
plt.plot(time_series_data, label='Original Data')
plt.plot(np.arange(len(time_series_data)), trend[0] * np.arange(len(time_series_data)) + trend[1], color='red', label='Trend Line')
plt.title('Time Series Data with Trend')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.show()

# 7. 移動平均 (Moving Average)
window = 5
moving_average = pd.Series(time_series_data).rolling(window=window).mean()
plt.figure(figsize=(8, 4))
plt.plot(time_series_data, label='Original Data')
plt.plot(moving_average, color='orange', label=f'{window}-Period Moving Average')
plt.title('Moving Average')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.show()

# 8. コレログラム (Correlogram - ACF Plot)
plot_acf(time_series_data, lags=20)
plt.title('Autocorrelation Function (Correlogram)')
plt.show()



```

```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.cluster import KMeans
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from scipy import stats
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression

# 1. ロジスティック回帰 (Logistic Regression with Odds Calculation)
# 仮想データセット
np.random.seed(0)
data_size = 100
X = np.random.rand(data_size, 2)
y = np.random.randint(0, 2, size=data_size)

# ロジスティック回帰モデル
log_reg = LogisticRegression()
log_reg.fit(X, y)

# ロジスティック回帰のオッズ比を計算
odds_ratios = np.exp(log_reg.coef_)
print(f"Logistic Regression Coefficients (Odds Ratios): {odds_ratios}")

# 2. クラスター分析 (Cluster Analysis)
kmeans = KMeans(n_clusters=3)
kmeans.fit(X)
labels = kmeans.labels_

# クラスターの結果をプロット
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.title("K-Means Clustering")
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

# 3. 多項ロジスティック回帰 (Multinomial Logistic Regression)
# Irisデータセットを使用
from sklearn.datasets import load_iris
iris = load_iris()
X_iris = iris['data']
y_iris = iris['target']

# 多項ロジスティック回帰
multi_log_reg = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=200)
multi_log_reg.fit(X_iris, y_iris)
print("Multinomial Logistic Regression Coefficients:\n", multi_log_reg.coef_)

# 4. K近傍法 (K-Nearest Neighbors)
X_train, X_test, y_train, y_test = train_test_split(X_iris, y_iris, test_size=0.3, random_state=0)
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)

# K近傍の混同行列と結果表示
print("K-Nearest Neighbors Confusion Matrix:\n", confusion_matrix(y_test, y_pred_knn))
print("K-Nearest Neighbors Classification Report:\n", classification_report(y_test, y_pred_knn))

# 5. コンジョイント分析 (Conjoint Analysis)
# サンプルデータ生成
data_conjoint = pd.DataFrame({
    'Price': [10, 10, 20, 20, 30, 30],
    'Quality': [1, 2, 1, 2, 1, 2],
    'Choice': [1, 0, 1, 0, 1, 0]  # 1:選択、0:非選択
})
# コンジョイント分析: ロジスティック回帰を使用
X_conjoint = data_conjoint[['Price', 'Quality']]
y_conjoint = data_conjoint['Choice']
conjoint_model = LogisticRegression()
conjoint_model.fit(X_conjoint, y_conjoint)

# コンジョイント分析の結果
print("Conjoint Analysis Coefficients:\n", conjoint_model.coef_)

# 6. 直交表 (Orthogonal Array)
from itertools import product

# 2つの要因、それぞれに2レベルの直交表を作成
factors = {
    'Factor A': [0, 1],
    'Factor B': [0, 1]
}
orthogonal_array = pd.DataFrame(list(product(factors['Factor A'], factors['Factor B'])), columns=['Factor A', 'Factor B'])
print("Orthogonal Array:\n", orthogonal_array)

# 7. 判別分析 (Linear Discriminant Analysis)
lda = LinearDiscriminantAnalysis()
lda.fit(X_train, y_train)
y_pred_lda = lda.predict(X_test)

# 判別分析結果
print("Linear Discriminant Analysis Classification Report:\n", classification_report(y_test, y_pred_lda))

# 8. t分析 (t-test)
# 2つのグループ間のt検定
group1 = np.random.randn(100)
group2 = np.random.randn(100) + 0.5  # グループ2は平均が異なる
t_stat, p_val = stats.ttest_ind(group1, group2)
print(f"T-test result: t-statistic = {t_stat:.4f}, p-value = {p_val:.4f}")

# 9. 決定木 (Decision Tree)
decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, y_train)
y_pred_tree = decision_tree.predict(X_test)

# 決定木の結果
print("Decision Tree Classification Report:\n", classification_report(y_test, y_pred_tree))

# 10. ランダムフォレスト (Random Forest)
random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, y_train)
y_pred_forest = random_forest.predict(X_test)

# ランダムフォレストの結果
print("Random Forest Classification Report:\n", classification_report(y_test, y_pred_forest))




```


信頼性工学に関連する統計学の手法や概念(メモ）

### 1. **寿命分布 (Life Distributions)**
- **指数分布 (Exponential Distribution)**
  - 故障率が一定の場合に使用され、無記憶性の性質を持つ。
- **ワイブル分布 (Weibull Distribution)**
  - 故障率が時間とともに変化する場合に使用。形状パラメータに応じて異なる故障モードをモデル化。
- **正規分布 (Normal Distribution)**
  - 寿命や特性が中心値を中心に分布する場合に使用。
- **対数正規分布 (Log-Normal Distribution)**
  - 故障や劣化プロセスが複数の小さな要因に依存する場合に使用。
- **ガンマ分布 (Gamma Distribution)**
  - 故障が累積的なプロセスで発生する場合に使用。
- **極値分布 (Extreme Value Distribution)**
  - 最大・最小の極端な値に基づいて分析する場合に使用。

### 2. **信頼度 (Reliability)**
- **信頼度関数 (Reliability Function)**
  - 時刻 \(t\) で故障していない確率。\(R(t) = P(T > t)\)
- **累積分布関数 (CDF: Cumulative Distribution Function)**
  - ある時間 \(t\) までにシステムが故障する確率。\(F(t) = P(T \leq t)\)
- **故障率 (Hazard Rate)**
  - 単位時間あたりの故障確率。ワイブル分布では、形状パラメータによって故障率が変化する。
  
### 3. **信頼性試験 (Reliability Testing)**
- **加速寿命試験 (Accelerated Life Testing, ALT)**
  - システムや部品の寿命を加速させるためのストレス（温度、電圧など）を適用して故障データを収集し、通常使用条件下の寿命を予測。
- **逐次試験 (Sequential Testing)**
  - 試験データに基づいて逐次的に意思決定を行い、信頼性を評価する。

### 4. **故障解析 (Failure Analysis)**
- **FMEA (Failure Mode and Effects Analysis)**
  - 潜在的な故障モードを分析し、それぞれの影響や原因を評価する手法。
- **FTA (Fault Tree Analysis)**
  - システムの故障や異常の原因を論理的に追跡する手法。
- **FMECA (Failure Modes, Effects, and Criticality Analysis)**
  - FMEAに「重大度」を加味して分析する手法。

### 5. **加速モデル (Accelerated Models)**
- **アレニウスモデル (Arrhenius Model)**
  - 温度依存の加速劣化モデルで、温度と寿命の関係を記述するために使用。
- **Eyringモデル**
  - 温度だけでなく、応力や電圧のような複数のストレス要因を考慮する加速劣化モデル。
- **コフィン・メイソンモデル (Coffin-Manson Model)**
  - 熱疲労による低サイクル疲労の予測に使用されるモデル。

### 6. **生存分析 (Survival Analysis)**
- **カプラン・マイヤー推定法 (Kaplan-Meier Estimator)**
  - システムや部品の生存確率を非パラメトリックに推定する方法。右側打ち切り（途中で観測が終了する）データを扱う際に使用。
- **コックス比例ハザードモデル (Cox Proportional Hazards Model)**
  - 共変量が時間依存でないと仮定する、故障率の回帰モデル。

### 7. **信頼性成長モデル (Reliability Growth Models)**
- **デュアンモデル (Duane Model)**
  - 故障率が時間とともに改善することを表現する経験的モデル。
- **ジェルバクモデル (Jelinski-Moranda Model)**
  - ソフトウェアの信頼性を評価するためのモデルで、故障を修正することでシステムが徐々に信頼性を増すことを表現。

### 8. **保全性解析 (Maintainability Analysis)**
- **平均修復時間 (MTTR: Mean Time to Repair)**
  - 故障が発生したとき、修復に必要な平均時間。
- **予防保全 (Preventive Maintenance)**
  - 故障を防ぐために定期的に保全を行う手法。
- **状態基準保全 (Condition-based Maintenance, CBM)**
  - センサーデータやモニタリング情報に基づいて、機器の保全を最適化する手法。

### 9. **システム信頼性解析 (System Reliability Analysis)**
- **シリーズシステム (Series System)**
  - システム全体が一つの部品でも故障すれば、システム全体が故障するモデル。
- **並列システム (Parallel System)**
  - 部品の一部が故障しても、他の部品が動作し続けるシステムモデル。
- **k-out-of-n システム**
  - n個の部品のうちk個が正常に動作していればシステムが動作するモデル。

### 10. **データ解析手法 (Data Analysis Techniques)**
- **累積ハザード関数 (Cumulative Hazard Function)**
  - 故障率の累積値を表す関数。システムの累積的な故障リスクを評価するために使用。
- **ブロック寿命データ解析 (Block Life Data Analysis)**
  - システム全体が複数のサブシステムで構成されている場合に、その各サブシステムの寿命を分析する手法。
- **ベイズ信頼性解析 (Bayesian Reliability Analysis)**
  - ベイズ統計を用いて、信頼性パラメータの事前分布と新しいデータを組み合わせて信頼性を推定する手法。

### 11. **信頼性指標 (Reliability Metrics)**
- **平均故障間隔 (MTBF: Mean Time Between Failures)**
  - システムが故障するまでの平均時間。システムの信頼性を示す指標。
- **平均寿命 (Mean Life)**
  - システムや部品の寿命の平均値を示す指標。
- **リードタイム (Lead Time)**
  - 故障してから修復までの時間。

### 12. **デグレード分析 (Degradation Analysis)**
- **累積損傷モデル (Cumulative Damage Model)**
  - 時間とともに累積される損傷を分析する手法。劣化データから製品寿命を推定。

### 13. **信頼性ブロック図 (Reliability Block Diagram, RBD)**
- システムの信頼性を視覚的に表すために、システム内の部品やサブシステムの接続をブロックとして表現し、全体の信頼性を計算する手法。

---




```