用jupyter画一个二次函数

在Jupyter Notebook中画一个二次函数图形，我们可以使用matplotlib库，这是一个常用的数据可视化工具。这里是一个简单的例子，展示如何绘制y = x^2的函数图像：

# 导入必要的库
import numpy as np
import matplotlib.pyplot as plt

# 创建x轴的范围，通常是-10到10
x = np.linspace(-10, 10, 400)  # 400个点用于更平滑的图像

# 计算对应的y值（二次函数 y = x^2）
y = x**2

# 创建一个新的图形窗口
plt.figure()

# 绘制函数图像
plt.plot(x, y, label='y = x^2')

# 添加图例、标题以及坐标轴标签
plt.legend()
plt.title('二次函数图形')
plt.xlabel('x')
plt.ylabel('y = x^2')

# 显示图形
plt.show()

运行这段代码后，你会看到一个标准的二次函数图像。如果你想改变函数的形式，只需要修改`y = x**2`中的指数即可。

相关问题

在jupyter notebook中完成以下操作： 随机生成两组点，再使用matplotlib画出这些点 给这两组点赋予不同的标签 手工生成一条直线（w1x1+w2x2+b=0）将两组点分开 使用pytorch库构建神经网络，并优化得到网络参数

好的，我来给您详细介绍一下如何完成这个任务。

首先，我们需要导入 matplotlib 和 numpy 库来生成随机点并画图。请确保您已经安装了这些库。

import matplotlib.pyplot as plt
import numpy as np

接下来，我们定义两组随机点。为了方便起见，我们将两组点都设置为二维的，并且每组点有100个。

np.random.seed(0)
N = 100
x1 = np.random.randn(N, 2) + np.array([0, 2])
x2 = np.random.randn(N, 2) + np.array([2, 0])

现在，我们可以用 matplotlib 将这些点可视化出来。我们可以使用 scatter 函数来绘制散点图。

plt.scatter(x1[:,0], x1[:,1], label='x1')
plt.scatter(x2[:,0], x2[:,1], label='x2')
plt.legend()
plt.show()

接下来，我们手工生成一条直线将这两组点分开。这里我们设置 $w_1=1$，$w_2=-1$，$b=0$。这条直线的方程是 $x_1-x_2=0$。

w = np.array([1,-1])
b = 0
x_line = np.linspace(-4, 4, 100)
y_line = -x_line*w[0]/w[1] + b/w[1]
plt.plot(x_line, y_line, 'g-', label='separating line')
plt.scatter(x1[:,0], x1[:,1], label='x1')
plt.scatter(x2[:,0], x2[:,1], label='x2')
plt.legend()
plt.show()

现在，我们开始使用 PyTorch 来构建神经网络并优化得到网络参数。首先，我们需要将数据转换为 PyTorch 张量，并将标签转换为 0 和 1。

import torch

x = np.vstack([x1, x2]).astype(np.float32)
y = np.concatenate([np.zeros(N), np.ones(N)]).astype(np.float32)
x = torch.from_numpy(x)
y = torch.from_numpy(y)

接下来，我们使用 PyTorch 定义一个简单的两层神经网络，并使用交叉熵损失函数和随机梯度下降（SGD）优化器。

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = torch.nn.Linear(2, 1)
        
    def forward(self, x):
        y = torch.sigmoid(self.fc1(x))
        return y
    
net = Net()
criterion = torch.nn.BCELoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)

最后，我们使用 PyTorch 进行训练。我们迭代100次，每次随机选择一个小批量数据进行训练。

for epoch in range(100):
    optimizer.zero_grad()
    outputs = net(x)
    loss = criterion(outputs.view(-1), y)
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print('Epoch [%d/%d], Loss: %.4f' % (epoch+1, 100, loss.item()))

训练完成后，我们可以使用训练好的模型来预测每个点所属的类别，并将分类结果可视化出来。

x_grid, y_grid = np.meshgrid(np.linspace(-4, 4, 100), np.linspace(-4, 4, 100))
xy_grid = np.hstack([x_grid.reshape(-1,1), y_grid.reshape(-1,1)])
xy_grid_tensor = torch.from_numpy(xy_grid.astype(np.float32))
z_grid_tensor = net(xy_grid_tensor).detach().numpy().reshape(x_grid.shape)

plt.contourf(x_grid, y_grid, z_grid_tensor, cmap=plt.cm.binary, alpha=0.3)
plt.scatter(x1[:,0], x1[:,1], label='x1')
plt.scatter(x2[:,0], x2[:,1], label='x2')
plt.legend()
plt.show()

现在，您已经完成了这个任务。如果您在执行过程中遇到了任何问题，请告诉我。

在jupyter使用matplotlib绘制y=x和y=x＊x两个图像的代码

在Jupyter Notebook中使用matplotlib库绘制y=x和y=x*x两个图形的代码可以分为两部分：首先导入需要的模块，然后编写绘制函数。以下是详细的步骤：

# 导入所需的模块
import numpy as np
import matplotlib.pyplot as plt

# 定义绘图函数
def plot_linear_and_quadratic():
    # 创建x轴数据范围
    x = np.linspace(-10, 10, 400)  # 从-10到10，共400个点

    # 计算对应的y值，一次线性(y=x)，一次二次(y=x^2)
    y_linear = x
    y_quadratic = x**2

    # 分别创建两个子图
    fig, axs = plt.subplots(1, 2, figsize=(10, 5))  # 1行2列的子图布局

    # 绘制线性和二次曲线
    axs[0].plot(x, y_linear, label='y=x')
    axs[0].set_title('线性函数')
    axs[0].legend()

    axs[1].plot(x, y_quadratic, label='y=x^2')
    axs[1].set_title('二次函数')
    axs[1].legend()

    # 显示图形
    plt.tight_layout()  # 美化图形间距
    plt.show()

# 调用绘图函数
plot_linear_and_quadratic()

在这个例子中，我们首先导入了`numpy`和`matplotlib.pyplot`，然后定义了一个名为`plot_linear_and_quadratic`的函数，这个函数会创建两个子图，分别画出y=x和y=x*x的图像，并添加标题和图例。

运行上述代码后，你应该能看到两个相邻的图像，一个是直线，另一个是抛物线。