pycharm线性相关代码

PyCharm是一款功能强大的Python集成开发环境（IDE），它提供了许多方便的功能来帮助开发者编写、调试和管理Python代码。下面是一些与线性相关的代码示例：

1. 导入相关库：

import numpy as np
from sklearn.linear_model import LinearRegression

2. 创建输入数据：

X = np.array([[1, 2], [3, 4], [5, 6]])  # 特征矩阵
y = np.array([3, 5, 7])  # 目标变量

3. 创建线性回归模型对象：

model = LinearRegression()

4. 拟合模型：

model.fit(X, y)

5. 预测新数据：

new_data = np.array([[7, 8], [9, 10]])
predictions = model.predict(new_data)

以上代码演示了使用PyCharm进行线性回归的基本步骤。首先导入必要的库，然后创建输入数据，接着创建线性回归模型对象，通过拟合模型来训练模型，最后使用训练好的模型进行预测。

相关问题

使用gurobipy在pycharm中编写代码，建立车联网中路径规划优化模型，车辆数为10，道路数为10，节点数为8，各车辆的起始点与终点各不相同，各道路存在限速，以及道路容量，在有车辆在此道路行驶时，道路容量数减少1，当道路数小于0时，视为该道路封闭，为不可通行状态，在车辆行驶时可能存在中间节点的情况，需要在某节点等待一段时间，在此等待时视为行驶成本增加，目标函数为行驶时间最短，车辆行驶时能耗与行驶路径长度呈线性关系

首先，需要导入相关的库和数据：

from gurobipy import *

# 车辆数为10
n_vehicles = 10

# 道路数为10
n_roads = 10

# 节点数为8
n_nodes = 8

# 道路限速
road_speed_limit = [40, 40, 60, 60, 60, 80, 100, 100, 120, 120]

# 道路容量
road_capacity = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 起始点与终点(仅示例，具体根据实际情况设置)
start_nodes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
end_nodes = [8, 7, 6, 5, 4, 3, 2, 1, 10, 9]

# 行驶时间
travel_time = [
    [0, 10, 20, 30, 40, 50, 60, 70],
    [10, 0, 10, 20, 30, 40, 50, 60],
    [20, 10, 0, 10, 20, 30, 40, 50],
    [30, 20, 10, 0, 10, 20, 30, 40],
    [40, 30, 20, 10, 0, 10, 20, 30],
    [50, 40, 30, 20, 10, 0, 10, 20],
    [60, 50, 40, 30, 20, 10, 0, 10],
    [70, 60, 50, 40, 30, 20, 10, 0]
]

# 等待时间
wait_time = [
    [0, 1, 2, 3, 4, 5, 6, 7],
    [1, 0, 1, 2, 3, 4, 5, 6],
    [2, 1, 0, 1, 2, 3, 4, 5],
    [3, 2, 1, 0, 1, 2, 3, 4],
    [4, 3, 2, 1, 0, 1, 2, 3],
    [5, 4, 3, 2, 1, 0, 1, 2],
    [6, 5, 4, 3, 2, 1, 0, 1],
    [7, 6, 5, 4, 3, 2, 1, 0]
]

接下来，需要定义模型和变量：

# 创建模型
model = Model("vehicle_routing")

# 创建变量
# 路径变量
x = [[[0] * n_nodes for i in range(n_nodes)] for j in range(n_vehicles)]
for k in range(n_vehicles):
    for i in range(n_nodes):
        for j in range(n_nodes):
            if i != j:
                x[k][i][j] = model.addVar(lb=0, ub=1, vtype=GRB.BINARY, name=f'x_{k}_{i}_{j}')

# 等待时间变量
w = [[0] * n_nodes for i in range(n_vehicles)]
for k in range(n_vehicles):
    for i in range(n_nodes):
        w[k][i] = model.addVar(lb=0, ub=10, vtype=GRB.INTEGER, name=f'w_{k}_{i}')

# 道路容量变量
c = [[0] * n_roads for i in range(n_nodes)]
for i in range(n_nodes):
    for j in range(n_roads):
        c[i][j] = model.addVar(lb=0, ub=road_capacity[j], vtype=GRB.INTEGER, name=f'c_{i}_{j}')

接着，需要定义约束条件：

# 每个车辆只能从起始点出发一次，到达终点一次
for k in range(n_vehicles):
    model.addConstr(quicksum(x[k][start_nodes[k]][j] for j in range(n_nodes) if j != start_nodes[k]) == 1)
    model.addConstr(quicksum(x[k][i][end_nodes[k]] for i in range(n_nodes) if i != end_nodes[k]) == 1)

# 保证路径连通性
for k in range(n_vehicles):
    for j in range(n_nodes):
        if j != start_nodes[k] and j != end_nodes[k]:
            model.addConstr(quicksum(x[k][i][j] for i in range(n_nodes) if i != j) ==
                            quicksum(x[k][j][i] for i in range(n_nodes) if i != j))

# 道路容量约束
for j in range(n_roads):
    for i in range(n_nodes):
        model.addConstr(quicksum(x[k][i][j] for k in range(n_vehicles)) <= c[i][j])
        model.addConstr(c[i][j] <= road_capacity[j])

# 每个节点的入度等于出度
for k in range(n_vehicles):
    for i in range(n_nodes):
        model.addConstr(quicksum(x[k][j][i] for j in range(n_nodes) if j != i) ==
                        quicksum(x[k][i][j] for j in range(n_nodes) if j != i))

# 限速约束
for k in range(n_vehicles):
    for i in range(n_nodes):
        for j in range(n_nodes):
            if i != j:
                model.addConstr(travel_time[i][j] / x[k][i][j] <= 3600 / road_speed_limit[i])

# 等待时间约束
for k in range(n_vehicles):
    for i in range(n_nodes):
        for j in range(n_nodes):
            if i != j:
                model.addConstr(w[k][j] <= 10 * (1 - x[k][i][j]))
                model.addConstr(w[k][j] >= wait_time[i][j] - 10 * (1 - x[k][i][j]))

最后，需要定义目标函数并求解：

# 定义目标函数
obj = quicksum(travel_time[i][j] * x[k][i][j] + w[k][j] * x[k][i][j] for k in range(n_vehicles)
               for i in range(n_nodes) for j in range(n_nodes) if i != j)
model.setObjective(obj, GRB.MINIMIZE)

# 求解模型
model.optimize()

完整代码如下：

用pycharm画散点图（正相关 负相关 无相关）

在PyCharm中画散点图通常使用matplotlib库，这是一个非常流行的数据可视化工具。为了展示正相关、负相关和无相关的散点图，你可以按照以下步骤操作：

1. 首先，确保已经安装了`matplotlib`和`numpy`库，如果没有，可以使用pip进行安装：

   pip install matplotlib numpy

2. 导入所需的库：

   import matplotlib.pyplot as plt
   import numpy as np

3. 创建数据集，分别代表正相关、负相关和无相关的情况：
- 正相关：两个变量的变化方向大致相同。
- 负相关：一个变量增加时，另一个变量减少。
- 无相关：两个变量之间不存在显著的线性关系。

   # 正相关示例
   x = np.linspace(0, 10, 50)
   y = x + np.random.normal(0, 2, len(x))

   # 负相关示例
   x2 = np.linspace(0, 10, 50)
   y2 = -x2 + np.random.normal(0, 2, len(x2))

   # 无相关示例（随机数据）
   x3 = np.random.rand(50)
   y3 = np.random.rand(50)

4. 绘制散点图：

   fig, axs = plt.subplots(1, 3, figsize=(12, 4))
   
   axs[0].scatter(x, y)
   axs[0].set_title('正相关')

   axs[1].scatter(x2, y2)
   axs[1].set_title('负相关')

   axs[2].scatter(x3, y3)
   axs[2].set_title('无相关')
   
   for ax in axs:
       ax.grid(True)  # 添加网格线
       ax.set_xlabel('X轴')
       ax.set_ylabel('Y轴')
   plt.tight_layout()  # 自动调整子图间的间距
   plt.show()

完成以上代码后，你会看到三个散点图，分别表示三种相关性情况。