Python人工智能基础题目提交样例

## Python版本
Python版本为3.10.14
==出题时内存需使用2048M==
## 1. numpy样例
numpy==1.21.5
如题目P42307(https://mxt.cn/submit/7/42307/) ：数组统计分析
```python
import numpy as np
import sys

# 读取输入并转换为NumPy数组
input_line = sys.stdin.readline().strip()
numbers = list(map(int, input_line.split()))
arr = np.array(numbers, dtype=np.float64)

# 计算平均值并保留一位小数
mean_value = round(arr.mean(), 1)

# 将大于平均值的元素替换为平均值
arr[arr > mean_value] = mean_value

# 格式化输出，每个元素保留一位小数
output = ' '.join(f'{x:.1f}' for x in arr)
print(output)
```
输入：
```
1 2 3 4 5
```
输出：
```
1.0 2.0 3.0 3.0 3.0
```
## 2. scipy样例
scipy==1.7.3
### 例1
```
import numpy as np
from scipy import linalg, interpolate, stats

def main():
    # 1. 线性代数示例
    print("=== 线性代数示例 ===")
    # 创建一个3x3的矩阵
    A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    print("矩阵A:")
    print(A)
    
    # 计算行列式
    det = linalg.det(A)
    print(f"行列式: {det:.6f}")
    
    # 计算逆矩阵（如果存在）
    try:
        inv_A = linalg.inv(A)
        print("逆矩阵:")
        print(inv_A)
    except linalg.LinAlgError:
        print("矩阵不可逆")
    
    # 2. 插值示例
    print("\n=== 插值示例 ===")
    # 已知数据点
    x = np.linspace(0, 10, 11)
    y = np.sin(x)
    
    print("原始数据点:")
    for xi, yi in zip(x, y):
        print(f"x={xi:.1f}, y={yi:.6f}")
    
    # 创建插值函数
    f = interpolate.interp1d(x, y, kind='cubic')
    
    # 在新的点上进行插值
    x_new = np.array([1.5, 3.5, 5.5, 7.5, 9.5])
    y_new = f(x_new)
    
    print("\n插值结果:")
    for xi, yi in zip(x_new, y_new):
        print(f"x={xi:.1f}, 插值y={yi:.6f}, 实际sin(x)={np.sin(xi):.6f}")
    
    # 3. 统计分析示例
    print("\n=== 统计分析示例 ===")
    # 生成随机数据
    np.random.seed(42)  # 设置随机种子，保证结果可重现
    data = np.random.normal(loc=0, scale=1, size=1000)  # 生成1000个正态分布随机数
    
    # 基本统计量
    mean = np.mean(data)
    median = np.median(data)
    std = np.std(data)
    print(f"均值: {mean:.6f}")
    print(f"中位数: {median:.6f}")
    print(f"标准差: {std:.6f}")
    
    # 假设检验：检验数据是否来自均值为0的正态分布
    t_stat, p_value = stats.ttest_1samp(data, 0)
    print(f"t统计量: {t_stat:.6f}")
    print(f"p值: {p_value:.6f}")
    print("结论: " + ("接受原假设（均值为0）" if p_value > 0.05 else "拒绝原假设（均值不为0）"))

if __name__ == "__main__":
    main()
    
```
输出结果:
```
=== 线性代数示例 ===
矩阵A:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
行列式: 0.000000
矩阵不可逆

=== 插值示例 ===
原始数据点:
x=0.0, y=0.000000
x=1.0, y=0.841471
x=2.0, y=0.909297
x=3.0, y=0.141120
x=4.0, y=-0.756802
x=5.0, y=-0.958924
x=6.0, y=-0.279415
x=7.0, y=0.656987
x=8.0, y=0.989358
x=9.0, y=0.412118
x=10.0, y=-0.544021

插值结果:
x=1.5, 插值y=0.987787, 实际sin(x)=0.997495
x=3.5, 插值y=-0.350077, 实际sin(x)=-0.350783
x=5.5, 插值y=-0.703177, 实际sin(x)=-0.705540
x=7.5, 插值y=0.935733, 实际sin(x)=0.938000
x=9.5, 插值y=-0.063195, 实际sin(x)=-0.075151

=== 统计分析示例 ===
均值: 0.019332
中位数: 0.025301
标准差: 0.978726
t统计量: 0.624309
p值: 0.532567
结论: 接受原假设（均值为0）
```
### 例2
```
import numpy as np
from scipy import linalg  # 导入scipy线性代数模块

# 1. 构造方程组的系数矩阵 A 和常数项向量 b
# 方程组标准形式：A * [x, y]^T = b
A = np.array([[2, 3],  # 第一行：2x + 3y 的系数
              [1, -2]]) # 第二行：1x - 2y 的系数
b = np.array([8, -3])   # 常数项：[8, -3]

# 2. 求解方程组（scipy.linalg.solve 专门用于解线性方程组）
x, y = linalg.solve(A, b)

# 3. 验证解的正确性（代入原方程，检查结果是否接近 b）
verify = np.dot(A, np.array([x, y]))  # A 与解向量的点积

# 4. 输出结果
print(f"方程组的解：x = {x:.2f}, y = {y:.2f}")
print(f"验证结果（应接近 [8, -3]）：{verify.round(2)}")
```
输出
```
方程组的解：x = 1.00, y = 2.00
验证结果（应接近 [8, -3]）：[ 8. -3.]
```
## 3. pandas样例
pandas==1.3.5
如题目P42306([https://mxt.cn/submit/7/42306/](https://mxt.cn/submit/7/42306/ "https://mxt.cn/submit/7/42306/"))：员工数据统计分析：
```
import sys
from pandas import DataFrame

def main():
    # 从标准输入读取数据
    data_lines = []
    for line in sys.stdin:
        data_lines.append(line.strip())
    
    # 解析数据
    if len(data_lines) < 2:
        print("输入数据不足")
        return
    
    # 第一行是表头
    headers = data_lines[0].split()
    
    # 后续行是数据
    data = {header: [] for header in headers}
    for line in data_lines[1:]:
        values = line.split()
        for i, value in enumerate(values):
            if headers[i] in ['年龄', '工资']:
                data[headers[i]].append(int(value))
            else:
                data[headers[i]].append(value)
    
    # 创建DataFrame
    df = DataFrame(data)
    print("员工数据:")
    print(df)

# 计算统计信息
    print(f"\n统计信息:")
    print(f"平均年龄: {df['年龄'].mean():.1f}")
    print(f"平均工资: {df['工资'].mean():.1f}")
    print(f"总人数: {len(df)}")

if __name__ == "__main__":
    main()
```
输入：
```
姓名 年龄 工资
张三 25 5000
李四 30 7000
王五 35 6000
赵六 28 5500
```
输出：
```
员工数据:
   姓名  年龄    工资
0  张三  25  5000
1  李四  30  7000
2  王五  35  6000
3  赵六  28  5500

统计信息:
平均年龄: 29.5
平均工资: 5875.0
总人数: 4
```

## 4. scikit-learn 样例
scikit-learn==0.23.2
```
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import numpy as np

# 生成数据
X, _ = make_blobs(n_samples=300, centers=4, random_state=42)

# 测试不同的聚类数
k_range = range(2, 8)
results = []

for k in k_range:
    kmeans = KMeans(n_clusters=k, random_state=42)
    y_pred = kmeans.fit_predict(X)
    silhouette_avg = silhouette_score(X, y_pred)
    results.append((k, silhouette_avg, kmeans.inertia_))
    print(f"K={k}: 轮廓系数={silhouette_avg:.3f}, 惯性={kmeans.inertia_:.2f}")

# 找到最佳K值
best_k, best_score, _ = max(results, key=lambda x: x[1])
print(f"\n最佳聚类数: K={best_k}, 轮廓系数={best_score:.3f}")
```
输出：
```
K=2: 轮廓系数=0.590, 惯性=9416.21
K=3: 轮廓系数=0.757, 惯性=2110.41
K=4: 轮廓系数=0.792, 惯性=564.91
K=5: 轮廓系数=0.689, 惯性=512.24
K=6: 轮廓系数=0.551, 惯性=460.65
K=7: 轮廓系数=0.468, 惯性=411.28

最佳聚类数: K=4, 轮廓系数=0.792
```
## 5. torch 样例
torch==1.8.0a0
```
#线性回归模型
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

print("=== 线性回归样例 ===")

# 生成模拟数据
torch.manual_seed(42)
X = torch.linspace(0, 10, 100).reshape(-1, 1)
y = 2 * X + 1 + torch.randn(100, 1) * 2  # y = 2x + 1 + 噪声

print(f"数据形状: X{X.shape}, y{y.shape}")

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)  # 输入1维，输出1维
    
    def forward(self, x):
        return self.linear(x)

# 创建模型、损失函数和优化器
model = LinearRegression()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

print(f"初始权重: {model.linear.weight.data.item():.3f}")
print(f"初始偏置: {model.linear.bias.data.item():.3f}")

# 训练模型
epochs = 100
for epoch in range(epochs):
    # 前向传播
    predictions = model(X)
    loss = criterion(predictions, y)
    
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch + 1) % 20 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')

# 最终参数
print(f"训练后权重: {model.linear.weight.data.item():.3f}")
print(f"训练后偏置: {model.linear.bias.data.item():.3f}")

# 预测
with torch.no_grad():
    test_x = torch.tensor([[5.0]])
    prediction = model(test_x)
    print(f"输入 x=5.0, 预测 y={prediction.item():.3f}")
```
输出：
```
=== 线性回归样例 ===
数据形状: Xtorch.Size([100, 1]), ytorch.Size([100, 1])
初始权重: 0.156
初始偏置: -0.880
Epoch [20/100], Loss: 4.4902
Epoch [40/100], Loss: 4.3750
Epoch [60/100], Loss: 4.2805
Epoch [80/100], Loss: 4.2031
Epoch [100/100], Loss: 4.1397
训练后权重: 2.148
训练后偏置: 0.118
输入 x=5.0, 预测 y=10.856
```