007 《数据科学 (Data Science) 全面且深度解析》

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            

                        

                            
3
                            
# 向量 (Vector)
                        

                            
4
                            
v = np.array([1, 2, 3])
                        

                            
5
                            
u = np.array([4, 5, 6])
                        

                            
6
                            

                        

                            
7
                            
# 向量加法
                        

                            
8
                            
vector_addition = v + u
                        

                            
9
                            
print(f"向量加法: {vector_addition}") # Output: 向量加法: [5 7 9]
                        

                            
10
                            

                        

                            
11
                            
# 标量乘法
                        

                            
12
                            
scalar = 2
                        

                            
13
                            
scalar_multiplication = scalar * v
                        

                            
14
                            
print(f"标量乘法: {scalar_multiplication}") # Output: 标量乘法: [2 4 6]
                        

                            
15
                            

                        

                            
16
                            
# 点积
                        

                            
17
                            
dot_product = np.dot(v, u)
                        

                            
18
                            
print(f"点积: {dot_product}") # Output: 点积: 32
                        

                            
19
                            

                        

                            
20
                            
# 矩阵 (Matrix)
                        

                            
21
                            
A = np.array([[1, 2], [3, 4]])
                        

                            
22
                            
B = np.array([[5, 6], [7, 8]])
                        

                            
23
                            

                        

                            
24
                            
# 矩阵加法
                        

                            
25
                            
matrix_addition = A + B
                        

                            
26
                            
print(f"矩阵加法:\n{matrix_addition}")
                        

                            
27
                            
# Output:
                        

                            
28
                            
# 矩阵加法:
                        

                            
29
                            
# [[ 6  8]
                        

                            
30
                            
#  [10 12]]
                        

                            
31
                            

                        

                            
32
                            
# 矩阵乘法
                        

                            
33
                            
matrix_multiplication = np.dot(A, B)
                        

                            
34
                            
print(f"矩阵乘法:\n{matrix_multiplication}")
                        

                            
35
                            
# Output:
                        

                            
36
                            
# 矩阵乘法:
                        

                            
37
                            
# [[19 22]
                        

                            
38
                            
#  [43 50]]
                        

                            
39
                            

                        

                            
40
                            
# 矩阵转置
                        

                            
41
                            
matrix_transpose = A.T
                        

                            
42
                            
print(f"矩阵转置:\n{matrix_transpose}")
                        

                            
43
                            
# Output:
                        

                            
44
                            
# 矩阵转置:
                        

                            
45
                            
# [[1 3]
                        

                            
46
                            
#  [2 4]]
                        

                            
47
                            

                        

                            
48
                            
# 张量 (Tensor) - 以三阶张量为例
                        

                            
49
                            
T = np.arange(24).reshape((2, 3, 4)) # 创建一个 2x3x4 的张量
                        

                            
50
                            
print(f"张量:\n{T}")
                        

                            
51
                            
# Output (部分显示):
                        

                            
52
                            
# 张量:
                        

                            
53
                            
# [[[ 0  1  2  3]
                        

                            
54
                            
#   [ 4  5  6  7]
                        

                            
55
                            
#   [ 8  9 10 11]]
                        

                            
56
                            
#
                        

                            
57
                            
#  [[12 13 14 15]
                        

                            
58
                            
#   [16 17 18 19]
                        

                            
59
                            
#   [20 21 22 23]]]
                        
                                
                            

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            

                        

                            
3
                            
# 定义一个方阵
                        

                            
4
                            
A = np.array([[3, 1], [1, 3]])
                        

                            
5
                            

                        

                            
6
                            
# 计算特征值和特征向量
                        

                            
7
                            
eigenvalues, eigenvectors = np.linalg.eig(A)
                        

                            
8
                            

                        

                            
9
                            
print(f"特征值 (Eigenvalues): {eigenvalues}")
                        

                            
10
                            
# Output: 特征值 (Eigenvalues): [4. 2.]
                        

                            
11
                            

                        

                            
12
                            
print(f"特征向量 (Eigenvectors):\n{eigenvectors}")
                        

                            
13
                            
# Output:
                        

                            
14
                            
# 特征向量 (Eigenvectors):
                        

                            
15
                            
# [[ 0.70710678 -0.70710678]
                        

                            
16
                            
#  [ 0.70710678  0.70710678]]
                        

                            
17
                            

                        

                            
18
                            
# 验证： A * v = lambda * v
                        

                            
19
                            
v1 = eigenvectors[:, 0] # 第一个特征向量
                        

                            
20
                            
lambda1 = eigenvalues[0] # 第一个特征值
                        

                            
21
                            
print(f"A * v1: {np.dot(A, v1)}")
                        

                            
22
                            
# Output: A * v1: [2.82842712 2.82842712]
                        

                            
23
                            
print(f"lambda1 * v1: {lambda1 * v1}")
                        

                            
24
                            
# Output: lambda1 * v1: [2.82842712 2.82842712]
                        

                            
25
                            

                        

                            
26
                            
v2 = eigenvectors[:, 1] # 第二个特征向量
                        

                            
27
                            
lambda2 = eigenvalues[1] # 第二个特征值
                        

                            
28
                            
print(f"A * v2: {np.dot(A, v2)}")
                        

                            
29
                            
# Output: A * v2: [-1.41421356  1.41421356]
                        

                            
30
                            
print(f"lambda2 * v2: {lambda2 * v2}")
                        

                            
31
                            
# Output: lambda2 * v2: [-1.41421356  1.41421356]
                        
                                
                            

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            

                        

                            
3
                            
# 定义一个矩阵
                        

                            
4
                            
A = np.array([[1, 2, 3], [4, 5, 6]])
                        

                            
5
                            

                        

                            
6
                            
# 计算 SVD 分解
                        

                            
7
                            
U, S, V_T = np.linalg.svd(A)
                        

                            
8
                            

                        

                            
9
                            
print(f"U:\n{U}")
                        

                            
10
                            
# Output (近似):
                        

                            
11
                            
# U:
                        

                            
12
                            
# [[-0.3863177  -0.92236578]
                        

                            
13
                            
#  [-0.92236578  0.3863177 ]]
                        

                            
14
                            

                        

                            
15
                            
print(f"奇异值 S: {S}")
                        

                            
16
                            
# Output: 奇异值 S: [9.508032   0.77286964]
                        

                            
17
                            

                        

                            
18
                            
print(f"V^T:\n{V_T}")
                        

                            
19
                            
# Output (近似):
                        

                            
20
                            
# V^T:
                        

                            
21
                            
# [[-0.21483724 -0.52058739 -0.82633754]
                        

                            
22
                            
#  [ 0.9746794  -0.22490545  0.0248685 ]
                        

                            
23
                            
#  [ 0.09744345  0.82814319 -0.54425629]]
                        

                            
24
                            

                        

                            
25
                            
# 验证： A ≈ U * Σ * V^T
                        

                            
26
                            
Sigma = np.zeros((A.shape[0], A.shape[1]))
                        

                            
27
                            
Sigma[:A.shape[0], :A.shape[0]] = np.diag(S) # 构建奇异值矩阵 Σ
                        

                            
28
                            
A_reconstructed = U.dot(Sigma.dot(V_T))
                        

                            
29
                            

                        

                            
30
                            
print(f"重构的矩阵 A_reconstructed:\n{A_reconstructed}")
                        

                            
31
                            
# Output (近似，由于浮点数精度):
                        

                            
32
                            
# 重构的矩阵 A_reconstructed:
                        

                            
33
                            
# [[1. 2. 3.]
                        

                            
34
                            
#  [4. 5. 6.]]
                        

                            
35
                            

                        

                            
36
                            
# 低秩近似，例如保留前 1 个奇异值
                        

                            
37
                            
k = 1
                        

                            
38
                            
U_k = U[:, :k]
                        

                            
39
                            
Sigma_k = np.diag(S[:k])
                        

                            
40
                            
V_Tk = V_T[:k, :]
                        

                            
41
                            
A_k = U_k.dot(Sigma_k.dot(V_Tk))
                        

                            
42
                            

                        

                            
43
                            
print(f"秩为 {k} 的近似矩阵 A_k:\n{A_k}")
                        

                            
44
                            
# Output (近似):
                        

                            
45
                            
# 秩为 1 的近似矩阵 A_k:
                        

                            
46
                            
# [[1.34264247 2.1574903  2.97233813]
                        

                            
47
                            
#  [3.21428571 5.15714286 7.1       ]]
                        
                                
                            

                                
                                    

                            
1
                            
# 假设：
                        

                            
2
                            
# 事件 A: 一个人患有某种疾病， P(A) = 0.01 (先验概率)
                        

                            
3
                            
# 事件 B: 疾病检测结果为阳性， P(B|A) = 0.95 (患病时检测为阳性的概率，灵敏度)
                        

                            
4
                            
#        P(B|~A) = 0.05 (未患病时检测为阳性的概率，假阳性率)
                        

                            
5
                            

                        

                            
6
                            
P_A = 0.01 # 先验概率 P(A)
                        

                            
7
                            
P_B_given_A = 0.95 # 似然度 P(B|A)
                        

                            
8
                            
P_B_given_not_A = 0.05 # 假阳性率 P(B|~A)， ~A 表示事件 A 的对立事件
                        

                            
9
                            

                        

                            
10
                            
# 计算 P(~A) = 1 - P(A)
                        

                            
11
                            
P_not_A = 1 - P_A
                        

                            
12
                            

                        

                            
13
                            
# 使用全概率公式计算 P(B)
                        

                            
14
                            
P_B = P_B_given_A * P_A + P_B_given_not_A * P_not_A
                        

                            
15
                            

                        

                            
16
                            
# 使用贝叶斯定理计算后验概率 P(A|B)
                        

                            
17
                            
P_A_given_B = (P_B_given_A * P_A) / P_B
                        

                            
18
                            

                        

                            
19
                            
print(f"患病先验概率 P(A): {P_A:.4f}")
                        

                            
20
                            
# Output: 患病先验概率 P(A): 0.0100
                        

                            
21
                            
print(f"检测阳性似然度 P(B|A): {P_B_given_A:.4f}")
                        

                            
22
                            
# Output: 检测阳性似然度 P(B|A): 0.9500
                        

                            
23
                            
print(f"假阳性率 P(B|~A): {P_B_given_not_A:.4f}")
                        

                            
24
                            
# Output: 假阳性率 P(B|~A): 0.0500
                        

                            
25
                            
print(f"检测阳性的概率 P(B): {P_B:.4f}")
                        

                            
26
                            
# Output: 检测阳性的概率 P(B): 0.0590
                        

                            
27
                            
print(f"检测阳性条件下患病的后验概率 P(A|B): {P_A_given_B:.4f}")
                        

                            
28
                            
# Output: 检测阳性条件下患病的后验概率 P(A|B): 0.1610
                        
                                
                            

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            
import matplotlib.pyplot as plt
                        

                            
3
                            
from scipy import stats
                        

                            
4
                            

                        

                            
5
                            
# 离散型分布
                        

                            
6
                            

                        

                            
7
                            
# 1. 伯努利分布
                        

                            
8
                            
p_bernoulli = 0.3
                        

                            
9
                            
bernoulli_dist = stats.bernoulli(p_bernoulli)
                        

                            
10
                            
x_bernoulli = [0, 1]
                        

                            
11
                            
pmf_bernoulli = bernoulli_dist.pmf(x_bernoulli)
                        

                            
12
                            

                        

                            
13
                            
plt.figure(figsize=(6, 4))
                        

                            
14
                            
plt.stem(x_bernoulli, pmf_bernoulli, use_line_collection=True)
                        

                            
15
                            
plt.title("伯努利分布 (Bernoulli Distribution)")
                        

                            
16
                            
plt.xticks(x_bernoulli)
                        

                            
17
                            
plt.ylabel("PMF")
                        

                            
18
                            
plt.show()
                        

                            
19
                            

                        

                            
20
                            

                        

                            
21
                            
# 2. 二项分布
                        

                            
22
                            
n_binomial = 10
                        

                            
23
                            
p_binomial = 0.5
                        

                            
24
                            
binomial_dist = stats.binom(n_binomial, p_binomial)
                        

                            
25
                            
x_binomial = np.arange(n_binomial + 1)
                        

                            
26
                            
pmf_binomial = binomial_dist.pmf(x_binomial)
                        

                            
27
                            

                        

                            
28
                            
plt.figure(figsize=(6, 4))
                        

                            
29
                            
plt.stem(x_binomial, pmf_binomial, use_line_collection=True)
                        

                            
30
                            
plt.title("二项分布 (Binomial Distribution)")
                        

                            
31
                            
plt.xticks(x_binomial)
                        

                            
32
                            
plt.ylabel("PMF")
                        

                            
33
                            
plt.show()
                        

                            
34
                            

                        

                            
35
                            

                        

                            
36
                            
# 3. 泊松分布
                        

                            
37
                            
lambda_poisson = 3
                        

                            
38
                            
poisson_dist = stats.poisson(lambda_poisson)
                        

                            
39
                            
x_poisson = np.arange(15)
                        

                            
40
                            
pmf_poisson = poisson_dist.pmf(x_poisson)
                        

                            
41
                            

                        

                            
42
                            
plt.figure(figsize=(6, 4))
                        

                            
43
                            
plt.stem(x_poisson, pmf_poisson, use_line_collection=True)
                        

                            
44
                            
plt.title("泊松分布 (Poisson Distribution)")
                        

                            
45
                            
plt.xticks(x_poisson)
                        

                            
46
                            
plt.ylabel("PMF")
                        

                            
47
                            
plt.show()
                        

                            
48
                            

                        

                            
49
                            

                        

                            
50
                            
# 连续型分布
                        

                            
51
                            

                        

                            
52
                            
# 1. 正态分布
                        

                            
53
                            
mu_normal = 0
                        

                            
54
                            
sigma_normal = 1
                        

                            
55
                            
normal_dist = stats.norm(mu_normal, sigma_normal)
                        

                            
56
                            
x_normal = np.linspace(-4, 4, 100)
                        

                            
57
                            
pdf_normal = normal_dist.pdf(x_normal)
                        

                            
58
                            

                        

                            
59
                            
plt.figure(figsize=(6, 4))
                        

                            
60
                            
plt.plot(x_normal, pdf_normal)
                        

                            
61
                            
plt.title("正态分布 (Normal Distribution)")
                        

                            
62
                            
plt.xlabel("x")
                        

                            
63
                            
plt.ylabel("PDF")
                        

                            
64
                            
plt.show()
                        

                            
65
                            

                        

                            
66
                            

                        

                            
67
                            
# 2. 均匀分布
                        

                            
68
                            
a_uniform = 0
                        

                            
69
                            
b_uniform = 1
                        

                            
70
                            
uniform_dist = stats.uniform(a_uniform, b_uniform - a_uniform)
                        

                            
71
                            
x_uniform = np.linspace(-0.5, 1.5, 100)
                        

                            
72
                            
pdf_uniform = uniform_dist.pdf(x_uniform)
                        

                            
73
                            

                        

                            
74
                            
plt.figure(figsize=(6, 4))
                        

                            
75
                            
plt.plot(x_uniform, pdf_uniform)
                        

                            
76
                            
plt.title("均匀分布 (Uniform Distribution)")
                        

                            
77
                            
plt.xlabel("x")
                        

                            
78
                            
plt.ylabel("PDF")
                        

                            
79
                            
plt.show()
                        

                            
80
                            

                        

                            
81
                            

                        

                            
82
                            
# 3. 指数分布
                        

                            
83
                            
lambda_exponential = 0.5
                        

                            
84
                            
exponential_dist = stats.expon(scale=1/lambda_exponential) # scale = 1/lambda
                        

                            
85
                            
x_exponential = np.linspace(0, 10, 100)
                        

                            
86
                            
pdf_exponential = exponential_dist.pdf(x_exponential)
                        

                            
87
                            

                        

                            
88
                            
plt.figure(figsize=(6, 4))
                        

                            
89
                            
plt.plot(x_exponential, pdf_exponential)
                        

                            
90
                            
plt.title("指数分布 (Exponential Distribution)")
                        

                            
91
                            
plt.xlabel("x")
                        

                            
92
                            
plt.ylabel("PDF")
                        

                            
93
                            
plt.show()
                        
                                
                            

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            
import pandas as pd
                        

                            
3
                            
from scipy import stats
                        

                            
4
                            

                        

                            
5
                            
# 样本数据
                        

                            
6
                            
data = pd.Series([1, 2, 2, 3, 4, 5, 5, 5, 6])
                        

                            
7
                            

                        

                            
8
                            
# 描述性统计
                        

                            
9
                            
print("描述性统计:")
                        

                            
10
                            
print(data.describe())
                        

                            
11
                            
# Output (部分):
                        

                            
12
                            
# 描述性统计:
                        

                            
13
                            
# count    9.000000
                        

                            
14
                            
# mean     3.666667
                        

                            
15
                            
# std      1.732051
                        

                            
16
                            
# min      1.000000
                        

                            
17
                            
# 25%      2.000000
                        

                            
18
                            
# 50%      4.000000
                        

                            
19
                            
# 75%      5.000000
                        

                            
20
                            
# max      6.000000
                        

                            
21
                            

                        

                            
22
                            
print(f"偏度 (Skewness): {data.skew():.4f}")
                        

                            
23
                            
# Output: 偏度 (Skewness): -0.0535
                        

                            
24
                            
print(f"峰度 (Kurtosis): {data.kurtosis():.4f}")
                        

                            
25
                            
# Output: 峰度 (Kurtosis): -1.1178
                        

                            
26
                            

                        

                            
27
                            
# 参数估计 (均值的置信区间)
                        

                            
28
                            
sample_mean = data.mean()
                        

                            
29
                            
sample_std = data.std(ddof=1) # 样本标准差，ddof=1 表示自由度为 n-1
                        

                            
30
                            
n = len(data)
                        

                            
31
                            
confidence_level = 0.95
                        

                            
32
                            
alpha = 1 - confidence_level
                        

                            
33
                            
t_value = stats.t.ppf(1 - alpha/2, df=n-1) # t 分布的分位数
                        

                            
34
                            

                        

                            
35
                            
margin_of_error = t_value * (sample_std / np.sqrt(n))
                        

                            
36
                            
confidence_interval = (sample_mean - margin_of_error, sample_mean + margin_of_error)
                        

                            
37
                            

                        

                            
38
                            
print(f"均值的 {confidence_level*100:.0f}% 置信区间: {confidence_interval}")
                        

                            
39
                            
# Output (近似): 均值的 95% 置信区间: (2.32, 5.01)
                        

                            
40
                            

                        

                            
41
                            

                        

                            
42
                            
# 假设检验 (单样本 t 检验，检验均值是否为 3)
                        

                            
43
                            
pop_mean_null_hypothesis = 3
                        

                            
44
                            
t_statistic, p_value = stats.ttest_1samp(data, pop_mean_null_hypothesis)
                        

                            
45
                            

                        

                            
46
                            
print(f"t 统计量: {t_statistic:.4f}")
                        

                            
47
                            
# Output: t 统计量: 1.2500
                        

                            
48
                            
print(f"p 值 (p-value): {p_value:.4f}")
                        

                            
49
                            
# Output: p 值 (p-value): 0.2462
                        

                            
50
                            

                        

                            
51
                            
alpha_significance_level = 0.05
                        

                            
52
                            
if p_value < alpha_significance_level:
                        

                            
53
                            
    print(f"在显著性水平 alpha = {alpha_significance_level} 下，拒绝零假设，接受备择假设。")
                        

                            
54
                            
else:
                        

                            
55
                            
    print(f"在显著性水平 alpha = {alpha_significance_level} 下，不拒绝零假设。")
                        

                            
56
                            
# Output: 在显著性水平 alpha = 0.05 下，不拒绝零假设。
                        

                            
57
                            
# 结论：没有充分证据拒绝均值为 3 的零假设。
                        
                                
                            

                                
                                    

                            
1
                            
from scipy.optimize import minimize
                        

                            
2
                            

                        

                            
3
                            
# 定义目标函数 (例如： Rosenbrock 函数)
                        

                            
4
                            
def rosenbrock(x):
                        

                            
5
                            
    return (1-x[0])**2 + 100*(x[1]-x[0]**2)**2
                        

                            
6
                            

                        

                            
7
                            
# 初始猜测值
                        

                            
8
                            
x0 = np.array([2, 2])
                        

                            
9
                            

                        

                            
10
                            
# 使用 minimize 函数进行无约束优化，方法选择 'Nelder-Mead' (单纯形法)
                        

                            
11
                            
result = minimize(rosenbrock, x0, method='Nelder-Mead')
                        

                            
12
                            

                        

                            
13
                            
print("优化结果:")
                        

                            
14
                            
print(result)
                        

                            
15
                            
# Output (部分):
                        

                            
16
                            
# 优化结果:
                        

                            
17
                            
#  final_simplex: (array([[0.99997501, 0.99995004],
                        

                            
18
                            
#                        [1.00004514, 1.00009036],
                        

                            
19
                            
#                        [1.00002645, 1.00005289]]), array([2.49878572e-09, 1.72864631e-08, 2.67794598e-08]))
                        

                            
20
                            
#           fun: 2.498785717719227e-09
                        

                            
21
                            
#       message: 'Optimization terminated successfully.'
                        

                            
22
                            
#          nfev: 119
                        

                            
23
                            
#           nit: 66
                        

                            
24
                            
#        njev: 0
                        

                            
25
                            
#      status: 0
                        

                            
26
                            
#     success: True
                        

                            
27
                            
#           x: array([0.99997501, 0.99995004])
                        

                            
28
                            

                        

                            
29
                            
# 最优解
                        

                            
30
                            
optimal_x = result.x
                        

                            
31
                            
print(f"最优解 x*: {optimal_x}")
                        

                            
32
                            
# Output (近似): 最优解 x*: [0.99997501 0.99995004]
                        

                            
33
                            
# 最优值
                        

                            
34
                            
optimal_value = result.fun
                        

                            
35
                            
print(f"最优值 f(x*): {optimal_value}")
                        

                            
36
                            
# Output (近似): 最优值 f(x*): 2.498785717719227e-09
                        
                                
                            

                                
                                    

                            
1
                            
from scipy.optimize import minimize
                        

                            
2
                            
import numpy as np
                        

                            
3
                            

                        

                            
4
                            
# 目标函数 (Rosenbrock 函数) 和梯度
                        

                            
5
                            
def rosenbrock(x):
                        

                            
6
                            
    return (1-x[0])**2 + 100*(x[1]-x[0]**2)**2
                        

                            
7
                            

                        

                            
8
                            
def rosenbrock_grad(x):
                        

                            
9
                            
    return np.array([
                        

                            
10
                            
        -2*(1-x[0]) - 400*x[0]*(x[1]-x[0]**2),
                        

                            
11
                            
        200*(x[1]-x[0]**2)
                        

                            
12
                            
    ])
                        

                            
13
                            

                        

                            
14
                            
# 初始猜测值
                        

                            
15
                            
x0 = np.array([2, 2])
                        

                            
16
                            

                        

                            
17
                            
# 1. 梯度下降法 (CG - 共轭梯度法)
                        

                            
18
                            
result_cg = minimize(rosenbrock, x0, method='CG', jac=rosenbrock_grad)
                        

                            
19
                            
print("CG 优化结果:")
                        

                            
20
                            
print(result_cg.x)
                        

                            
21
                            
# Output (近似): CG 优化结果: [1.00000002 1.00000004]
                        

                            
22
                            

                        

                            
23
                            
# 2. 牛顿法 (Newton-CG)
                        

                            
24
                            
# 需要提供 Hessian 矩阵 (或 Hessian 矩阵与向量的乘积)
                        

                            
25
                            
def rosenbrock_hess(x):
                        

                            
26
                            
    H = np.array([
                        

                            
27
                            
        [1200*x[0]**2 - 400*x[1] + 2, -400*x[0]],
                        

                            
28
                            
        [-400*x[0], 200]
                        

                            
29
                            
    ])
                        

                            
30
                            
    return H
                        

                            
31
                            

                        

                            
32
                            
result_newton_cg = minimize(rosenbrock, x0, method='Newton-CG', jac=rosenbrock_grad, hess=rosenbrock_hess)
                        

                            
33
                            
print("Newton-CG 优化结果:")
                        

                            
34
                            
print(result_newton_cg.x)
                        

                            
35
                            
# Output (近似): Newton-CG 优化结果: [1. 1.]
                        

                            
36
                            

                        

                            
37
                            

                        

                            
38
                            
# 3. 拟牛顿法 (BFGS)
                        

                            
39
                            
result_bfgs = minimize(rosenbrock, x0, method='BFGS', jac=rosenbrock_grad)
                        

                            
40
                            
print("BFGS 优化结果:")
                        

                            
41
                            
print(result_bfgs.x)
                        

                            
42
                            
# Output (近似): BFGS 优化结果: [1.00000001 1.00000002]
                        

                            
43
                            

                        

                            
44
                            

                        

                            
45
                            
# 4. 拟牛顿法 (L-BFGS-B)
                        

                            
46
                            
result_lbfgsb = minimize(rosenbrock, x0, method='L-BFGS-B', jac=rosenbrock_grad)
                        

                            
47
                            
print("L-BFGS-B 优化结果:")
                        

                            
48
                            
print(result_lbfgsb.x)
                        

                            
49
                            
# Output (近似): L-BFGS-B 优化结果: [1.00000001 1.00000002]
                        
                                
                            

                                
                                    

                            
1
                            
import tensorflow as tf
                        

                            
2
                            
from tensorflow import keras
                        

                            
3
                            
from tensorflow.keras import layers
                        

                            
4
                            
import numpy as np
                        

                            
5
                            

                        

                            
6
                            
# 1. 构建模型 (简单的多层感知机 MLP)
                        

                            
7
                            
model = keras.Sequential([
                        

                            
8
                            
    layers.Dense(64, activation='relu', input_shape=(784,)),
                        

                            
9
                            
    layers.Dense(10, activation='softmax') # 10个类别 (例如 MNIST 数字分类)
                        

                            
10
                            
])
                        

                            
11
                            

                        

                            
12
                            
# 2. 选择优化器 (Optimizer), 损失函数 (Loss Function), 评估指标 (Metrics)
                        

                            
13
                            
optimizer = keras.optimizers.Adam(learning_rate=0.001) # Adam 优化器
                        

                            
14
                            
loss_function = keras.losses.CategoricalCrossentropy() # 交叉熵损失
                        

                            
15
                            
metrics = ['accuracy'] # 评估指标：准确率
                        

                            
16
                            

                        

                            
17
                            
model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)
                        

                            
18
                            

                        

                            
19
                            
# 3. 准备数据 (例如 MNIST 数据集)
                        

                            
20
                            
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
                        

                            
21
                            
x_train = x_train.reshape(60000, 784).astype('float32') / 255 # 展平并归一化
                        

                            
22
                            
x_test = x_test.reshape(10000, 784).astype('float32') / 255
                        

                            
23
                            
y_train_categorical = keras.utils.to_categorical(y_train, num_classes=10) # one-hot 编码
                        

                            
24
                            
y_test_categorical = keras.utils.to_categorical(y_test, num_classes=10)
                        

                            
25
                            

                        

                            
26
                            
# 4. 训练模型 (使用 fit 方法)
                        

                            
27
                            
batch_size = 128
                        

                            
28
                            
epochs = 10
                        

                            
29
                            
model.fit(x_train, y_train_categorical, batch_size=batch_size, epochs=epochs, validation_split=0.2)
                        

                            
30
                            
# Output (部分):
                        

                            
31
                            
# Epoch 1/10
                        

                            
32
                            
# 375/375 [==============================] - 2s 4ms/step - loss: 0.4310 - accuracy: 0.8783 - val_loss: 0.2266 - val_accuracy: 0.9368
                        

                            
33
                            
# Epoch 2/10
                        

                            
34
                            
# 375/375 [==============================] - 1s 3ms/step - loss: 0.2087 - accuracy: 0.9409 - val_loss: 0.1691 - val_accuracy: 0.9528
                        

                            
35
                            
# ...
                        

                            
36
                            
# Epoch 10/10
                        

                            
37
                            
# 375/375 [==============================] - 1s 3ms/step - loss: 0.0698 - accuracy: 0.9794 - val_loss: 0.1025 - val_accuracy: 0.9706
                        

                            
38
                            

                        

                            
39
                            
# 5. 评估模型 (在测试集上)
                        

                            
40
                            
loss, accuracy = model.evaluate(x_test, y_test_categorical, verbose=0)
                        

                            
41
                            
print(f"测试集损失 (Test Loss): {loss:.4f}")
                        

                            
42
                            
# Output (近似): 测试集损失 (Test Loss): 0.0932
                        

                            
43
                            
print(f"测试集准确率 (Test Accuracy): {accuracy:.4f}")
                        

                            
44
                            
# Output (近似): 测试集准确率 (Test Accuracy): 0.9730
                        
                                
                            

                                
                                    

                            
1
                            
# 数值类型示例
                        

                            
2
                            
integer_number = 10
                        

                            
3
                            
float_number = 3.14
                        

                            
4
                            
complex_number = 1 + 2j
                        

                            
5
                            

                        

                            
6
                            
print(f"Integer: {integer_number}, Type: {type(integer_number)}")
                        

                            
7
                            
print(f"Float: {float_number}, Type: {type(float_number)}")
                        

                            
8
                            
print(f"Complex: {complex_number}, Type: {type(complex_number)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 布尔类型示例
                        

                            
2
                            
is_true = True
                        

                            
3
                            
is_false = False
                        

                            
4
                            

                        

                            
5
                            
print(f"True value: {is_true}, Type: {type(is_true)}")
                        

                            
6
                            
print(f"False value: {is_false}, Type: {type(is_false)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 字符串类型示例
                        

                            
2
                            
string_single_quotes = 'Hello, Data Science!'
                        

                            
3
                            
string_double_quotes = "Python is powerful."
                        

                            
4
                            

                        

                            
5
                            
print(f"String with single quotes: {string_single_quotes}, Type: {type(string_single_quotes)}")
                        

                            
6
                            
print(f"String with double quotes: {string_double_quotes}, Type: {type(string_double_quotes)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 列表示例
                        

                            
2
                            
my_list = [1, 2.0, 'three', True]
                        

                            
3
                            
print(f"List: {my_list}, Type: {type(my_list)}")
                        

                            
4
                            
print(f"First element: {my_list[0]}") # 索引从 0 开始
                        
                                
                            

                                
                                    

                            
1
                            
# 元组示例
                        

                            
2
                            
my_tuple = (1, 2.0, 'three', True)
                        

                            
3
                            
print(f"Tuple: {my_tuple}, Type: {type(my_tuple)}")
                        

                            
4
                            
print(f"Second element: {my_tuple[1]}")
                        
                                
                            

                                
                                    

                            
1
                            
# 范围示例
                        

                            
2
                            
my_range = range(5) # 生成 0, 1, 2, 3, 4 的序列
                        

                            
3
                            
print(f"Range: {list(my_range)}, Type: {type(my_range)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 集合示例
                        

                            
2
                            
my_set = {1, 2, 3, 3, 2, 1} # 自动去重
                        

                            
3
                            
print(f"Set: {my_set}, Type: {type(my_set)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 冻结集合示例
                        

                            
2
                            
my_frozenset = frozenset([1, 2, 3])
                        

                            
3
                            
print(f"Frozenset: {my_frozenset}, Type: {type(my_frozenset)}")
                        
                                
                            

                                
                                    

                            
1
                            
# 字典示例
                        

                            
2
                            
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
                        

                            
3
                            
print(f"Dictionary: {my_dict}, Type: {type(my_dict)}")
                        

                            
4
                            
print(f"Name: {my_dict['name']}") # 通过键访问值
                        
                                
                            

                                
                                    

                            
1
                            
# 条件语句示例
                        

                            
2
                            
x = 10
                        

                            
3
                            
if x > 0:
                        

                            
4
                            
    print("x is positive")
                        

                            
5
                            

                        

                            
6
                            
if x % 2 == 0:
                        

                            
7
                            
    print("x is even")
                        

                            
8
                            
else:
                        

                            
9
                            
    print("x is odd")
                        

                            
10
                            

                        

                            
11
                            
score = 85
                        

                            
12
                            
if score >= 90:
                        

                            
13
                            
    grade = 'A'
                        

                            
14
                            
elif score >= 80:
                        

                            
15
                            
    grade = 'B'
                        

                            
16
                            
elif score >= 70:
                        

                            
17
                            
    grade = 'C'
                        

                            
18
                            
else:
                        

                            
19
                            
    grade = 'D'
                        

                            
20
                            
print(f"Score: {score}, Grade: {grade}")
                        
                                
                            

                                
                                    

                            
1
                            
# for 循环示例
                        

                            
2
                            
fruits = ['apple', 'banana', 'cherry']
                        

                            
3
                            
for fruit in fruits:
                        

                            
4
                            
    print(fruit)
                        

                            
5
                            

                        

                            
6
                            
for i in range(5): # 使用 range 生成序列
                        

                            
7
                            
    print(i)
                        
                                
                            

                                
                                    

                            
1
                            
# while 循环示例
                        

                            
2
                            
count = 0
                        

                            
3
                            
while count < 5:
                        

                            
4
                            
    print(f"Count is: {count}")
                        

                            
5
                            
    count += 1
                        
                                
                            

                                
                                    

                            
1
                            
# break 语句示例
                        

                            
2
                            
for i in range(10):
                        

                            
3
                            
    if i == 5:
                        

                            
4
                            
        break # 当 i 等于 5 时，终止循环
                        

                            
5
                            
    print(i)
                        
                                
                            

                                
                                    

                            
1
                            
# continue 语句示例
                        

                            
2
                            
for i in range(10):
                        

                            
3
                            
    if i % 2 == 0:
                        

                            
4
                            
        continue # 当 i 是偶数时，跳过本次循环的剩余代码，继续下一次循环
                        

                            
5
                            
    print(f"Odd number: {i}")
                        
                                
                            

                                
                                    

                            
1
                            
# pass 语句示例
                        

                            
2
                            
for i in range(5):
                        

                            
3
                            
    if i == 2:
                        

                            
4
                            
        pass # 当 i 等于 2 时，什么也不做，继续执行循环
                        

                            
5
                            
    else:
                        

                            
6
                            
        print(i)
                        
                                
                            

                                
                                    

                            
1
                            
# 函数定义示例
                        

                            
2
                            
def greet(name):
                        

                            
3
                            
    """
                        

                            
4
                            
    此函数向指定的人打招呼。
                        

                            
5
                            
    """
                        

                            
6
                            
    print(f"Hello, {name}!")
                        

                            
7
                            

                        

                            
8
                            
# 函数调用
                        

                            
9
                            
greet("Alice") # 输出: Hello, Alice!
                        

                            
10
                            
help(greet)    # 查看函数文档字符串 (docstring)
                        
                                
                            

                                
                                    

                            
1
                            
# 函数参数示例
                        

                            
2
                            

                        

                            
3
                            
# 默认参数
                        

                            
4
                            
def power(base, exponent=2): # exponent 默认值为 2
                        

                            
5
                            
    return base ** exponent
                        

                            
6
                            

                        

                            
7
                            
print(power(2))    # 使用默认 exponent: 2^2 = 4
                        

                            
8
                            
print(power(2, 3)) # 显式指定 exponent: 2^3 = 8
                        

                            
9
                            

                        

                            
10
                            
# 可变参数 (*args)
                        

                            
11
                            
def sum_numbers(*args):
                        

                            
12
                            
    total = 0
                        

                            
13
                            
    for number in args:
                        

                            
14
                            
        total += number
                        

                            
15
                            
    return total
                        

                            
16
                            

                        

                            
17
                            
print(sum_numbers(1, 2, 3, 4, 5)) # 计算多个数字的和
                        

                            
18
                            

                        

                            
19
                            
# 关键字可变参数 (**kwargs)
                        

                            
20
                            
def print_info(**kwargs):
                        

                            
21
                            
    for key, value in kwargs.items():
                        

                            
22
                            
        print(f"{key}: {value}")
                        

                            
23
                            

                        

                            
24
                            
print_info(name='Bob', age=25, city='London') # 打印关键字参数信息
                        
                                
                            

                                
                                    

                            
1
                            
# 返回值示例
                        

                            
2
                            
def add_subtract(a, b):
                        

                            
3
                            
    sum_val = a + b
                        

                            
4
                            
    diff_val = a - b
                        

                            
5
                            
    return sum_val, diff_val # 返回多个值，以元组形式
                        

                            
6
                            

                        

                            
7
                            
sum_result, diff_result = add_subtract(10, 5)
                        

                            
8
                            
print(f"Sum: {sum_result}, Difference: {diff_result}")
                        
                                
                            

                                
                                    

                            
1
                            
# Lambda 函数示例
                        

                            
2
                            
square = lambda x: x ** 2 # 定义一个计算平方的 lambda 函数
                        

                            
3
                            
print(square(5))          # 输出: 25
                        

                            
4
                            

                        

                            
5
                            
numbers = [1, 2, 3, 4, 5]
                        

                            
6
                            
squared_numbers = list(map(lambda x: x ** 2, numbers)) # 使用 map 和 lambda 函数
                        

                            
7
                            
print(squared_numbers) # 输出: [1, 4, 9, 16, 25]
                        
                                
                            

                                
                                    

                            
1
                            
# 类定义示例
                        

                            
2
                            
class Dog:
                        

                            
3
                            
    """
                        

                            
4
                            
    这是一个表示狗的类。
                        

                            
5
                            
    """
                        

                            
6
                            
    def __init__(self, name, breed): # 构造函数 (constructor)
                        

                            
7
                            
        self.name = name
                        

                            
8
                            
        self.breed = breed
                        

                            
9
                            

                        

                            
10
                            
    def bark(self):
                        

                            
11
                            
        """
                        

                            
12
                            
        狗叫的方法。
                        

                            
13
                            
        """
                        

                            
14
                            
        print("Woof!")
                        

                            
15
                            

                        

                            
16
                            
    def description(self):
                        

                            
17
                            
        """
                        

                            
18
                            
        返回狗的描述信息。
                        

                            
19
                            
        """
                        

                            
20
                            
        return f"{self.name} is a {self.breed}."
                        

                            
21
                            

                        

                            
22
                            
# 创建对象 (实例)
                        

                            
23
                            
my_dog = Dog("Buddy", "Golden Retriever")
                        

                            
24
                            

                        

                            
25
                            
# 访问属性和调用方法
                        

                            
26
                            
print(f"Dog's name: {my_dog.name}")
                        

                            
27
                            
print(f"Dog's breed: {my_dog.breed}")
                        

                            
28
                            
my_dog.bark() # 输出: Woof!
                        

                            
29
                            
print(my_dog.description())
                        

                            
30
                            
help(Dog) # 查看类文档字符串 (docstring)
                        
                                
                            

                                
                                    

                            
1
                            
# 继承示例
                        

                            
2
                            
class Cat(Dog): # Cat 类继承自 Dog 类
                        

                            
3
                            
    def __init__(self, name, breed, color):
                        

                            
4
                            
        super().__init__(name, breed) # 调用父类的构造函数
                        

                            
5
                            
        self.color = color
                        

                            
6
                            

                        

                            
7
                            
    def meow(self):
                        

                            
8
                            
        """
                        

                            
9
                            
        猫叫的方法。
                        

                            
10
                            
        """
                        

                            
11
                            
        print("Meow!")
                        

                            
12
                            

                        

                            
13
                            
    def description(self): # 重写 (override) 父类的方法
                        

                            
14
                            
        return f"{self.name} is a {self.color} {self.breed} cat."
                        

                            
15
                            

                        

                            
16
                            
my_cat = Cat("Whiskers", "Siamese", "white")
                        

                            
17
                            
print(my_cat.description()) # 调用子类重写的方法
                        

                            
18
                            
my_cat.bark() # 调用父类的方法 (继承)
                        

                            
19
                            
my_cat.meow() # 调用子类自己的方法
                        
                                
                            

                                
                                    

                            
1
                            
# 多态示例
                        

                            
2
                            
def animal_sound(animal):
                        

                            
3
                            
    animal.bark() # 调用 animal 对象的 bark 方法，具体行为取决于 animal 的类型
                        

                            
4
                            

                        

                            
5
                            
animal_sound(my_dog) # Dog 对象的 bark 方法
                        

                            
6
                            
animal_sound(my_cat) # Cat 对象 (继承自 Dog) 的 bark 方法 (虽然 Cat 类没有 bark 方法，但继承了 Dog 类的 bark 方法)
                        

                            
7
                            

                        

                            
8
                            
class Bird:
                        

                            
9
                            
    def bark(self): # Bird 类也有 bark 方法，但行为不同
                        

                            
10
                            
        print("Chirp!")
                        

                            
11
                            

                        

                            
12
                            
my_bird = Bird()
                        

                            
13
                            
animal_sound(my_bird) # Bird 对象的 bark 方法
                        
                                
                            

                                
                                    

                            
1
                            
# 导入模块示例
                        

                            
2
                            

                        

                            
3
                            
import math # 导入 math 模块
                        

                            
4
                            
print(math.sqrt(16)) # 使用模块名.名称访问模块中的函数
                        

                            
5
                            

                        

                            
6
                            
from math import sqrt, pi # 从 math 模块导入 sqrt 和 pi
                        

                            
7
                            
print(sqrt(25))
                        

                            
8
                            
print(pi)
                        

                            
9
                            

                        

                            
10
                            
import pandas as pd # 导入 pandas 模块并指定别名 pd (常用约定)
                        

                            
11
                            
data = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]}) # 使用别名访问模块
                        

                            
12
                            
print(data)
                        
                                
                            

                                
                                    

                            
1
                            
# my_module.py
                        

                            
2
                            
def my_function():
                        

                            
3
                            
    print("Hello from my_module!")
                        

                            
4
                            

                        

                            
5
                            
my_variable = 100
                        
                                
                            

                                
                                    

                            
1
                            
# main.py
                        

                            
2
                            
import my_module
                        

                            
3
                            

                        

                            
4
                            
my_module.my_function() # 调用 my_module 模块中的函数
                        

                            
5
                            
print(my_module.my_variable) # 访问 my_module 模块中的变量
                        
                                
                            

                                
                                    

                            
1
                            
# 标准库模块示例
                        

                            
2
                            
import os
                        

                            
3
                            
print(os.getcwd()) # 获取当前工作目录
                        

                            
4
                            

                        

                            
5
                            
import datetime
                        

                            
6
                            
now = datetime.datetime.now()
                        

                            
7
                            
print(now) # 打印当前日期和时间
                        

                            
8
                            

                        

                            
9
                            
import random
                        

                            
10
                            
print(random.random()) # 生成 0 到 1 之间的随机浮点数
                        
                                
                            

                                
                                    

                            
1
                            
import numpy as np
                        

                            
2
                            

                        

                            
3
                            
# 创建 NumPy 数组
                        

                            
4
                            
a = np.array([1, 2, 3, 4, 5]) # 从列表创建一维数组
                        

                            
5
                            
b = np.array([[1, 2, 3], [4, 5, 6]]) # 从列表的列表创建二维数组
                        

                            
6
                            

                        

                            
7
                            
print(f"1D Array:\n{a}")
                        

                            
8
                            
print(f"2D Array:\n{b}")
                        

                            
9
                            

                        

                            
10
                            
print(f"Array Dimension (a): {a.ndim}") # 数组维度
                        

                            
11
                            
print(f"Array Shape (b): {b.shape}")   # 数组形状 (行数, 列数)
                        

                            
12
                            
print(f"Array Data Type (a): {a.dtype}") # 数组数据类型
                        
                                
                            

                                
                                    

                            
1
                            
# 数组运算示例
                        

                            
2
                            
a = np.array([1, 2, 3])
                        

                            
3
                            
b = np.array([4, 5, 6])
                        

                            
4
                            

                        

                            
5
                            
# 元素级运算
                        

                            
6
                            
print(f"Addition: {a + b}")     # 数组加法
                        

                            
7
                            
print(f"Multiplication: {a * b}") # 数组元素级乘法
                        

                            
8
                            
print(f"Dot Product: {np.dot(a, b)}") # 向量点积
                        

                            
9
                            

                        

                            
10
                            
# 统计运算
                        

                            
11
                            
c = np.array([[1, 2, 3], [4, 5, 6]])
                        

                            
12
                            
print(f"Sum of all elements: {np.sum(c)}")        # 所有元素求和
                        

                            
13
                            
print(f"Mean of each column:\n{np.mean(c, axis=0)}") # 沿 axis=0 (列) 求均值
                        

                            
14
                            
print(f"Max of each row:\n{np.max(c, axis=1)}")   # 沿 axis=1 (行) 求最大值