python实现logistic模型的分叉与混沌现象的代码

在Python中，要模拟Logistic Map的分叉与混沌现象，可以使用著名的Chirikov-Taylor映射或者Lorenz方程等简单的非线性动力系统。这里以经典的Logistic Map为例，它是一种描述种群动态的数学模型。以下是使用Python的基本实现：

import matplotlib.pyplot as plt
import numpy as np

# Logistic Map函数
def logistic_map(r, x):
    return r * x * (1 - x)

# 参数设置
r_values = np.linspace(0, 4, 1000)  # 现代混沌区域通常从r=3开始
x0 = 0.5  # 初始值
iterations = 1000  # 迭代次数

# 模拟并绘制分叉图
plt.figure(figsize=(8, 6))
for r in r_values:
    values = [x0]
    for _ in range(iterations):
        x0 = logistic_map(r, x0)
        values.append(x0)

    plt.plot(np.array(values), label=f'r={r:.2f}')

plt.xlabel('迭代次数')
plt.ylabel('x值')
plt.title('Logistic Map的分叉图')
plt.legend()
plt.show()

相关问题

用python实现logistic模型

可以使用 scikit-learn 库中的 LogisticRegression 模型来实现 logistic 模型。以下是一个简单的示例代码：

import numpy as np
from sklearn.linear_model import LogisticRegression

# 生成随机数据
X = np.random.randn(1000, 10)
y = np.random.randint(0, 2, size=1000)

# 训练 logistic 模型
lr = LogisticRegression()
lr.fit(X, y)

# 使用模型进行预测
y_pred = lr.predict(X)

# 计算准确率
acc = np.mean(y == y_pred)
print("Accuracy = ", acc)

这个代码示例中我们首先生成了一个 1000 行 10 列的随机数据作为样本特征，以及一个二元分类任务的标签。然后使用 LogisticRegression 模型进行训练，并使用训练好的模型对样本进行预测。最后计算分类准确率。

用Python实现Logistic模型，并绘图

好的，以下是用Python实现Logistic模型并绘图的代码：

import numpy as np
import matplotlib.pyplot as plt

# 定义sigmoid函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义损失函数
def loss(h, y):
    return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()

# 定义训练函数
def train(X, y, lr, epochs):
    # 初始化参数
    theta = np.zeros(X.shape[1])
    # 记录损失值
    losses = []
    for i in range(epochs):
        # 计算预测值
        z = np.dot(X, theta)
        h = sigmoid(z)
        # 计算梯度
        gradient = np.dot(X.T, (h - y)) / y.size
        # 更新参数
        theta -= lr * gradient
        # 记录损失值
        losses.append(loss(h, y))
    return theta, losses

# 生成数据
np.random.seed(0)
X = np.random.randn(100, 2)
y = np.array([int(x1 + x2 > 0) for x1, x2 in X])
# 绘制数据散点图
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()

# 在X中添加一列1，方便计算theta0
X = np.hstack((np.ones((X.shape[0], 1)), X))

# 训练模型
theta, losses = train(X, y, lr=0.1, epochs=1000)
print('theta:', theta)

# 绘制损失函数值随迭代次数的变化图
plt.plot(losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.show()

# 绘制决策边界
x1_min, x1_max = X[:, 1].min() - 1, X[:, 1].max() + 1
x2_min, x2_max = X[:, 2].min() - 1, X[:, 2].max() + 1
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max, 100), np.linspace(x2_min, x2_max, 100))
Z = sigmoid(np.c_[np.ones((xx1.ravel().shape[0], 1)), xx1.ravel(), xx2.ravel()].dot(theta))
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, alpha=0.4)
plt.scatter(X[:, 1], X[:, 2], c=y, alpha=0.8)
plt.show()

这段代码首先生成了一个二维的随机数据集，然后使用Logistic模型进行训练，并绘制了数据散点图、损失函数值随迭代次数的变化图和决策边界图。其中，sigmoid函数用于将预测值映射到[0,1]之间，损失函数使用交叉熵损失函数，训练函数使用批量梯度下降法更新参数，lr为学习率，epochs为迭代次数。训练完成后，通过计算得到的参数theta可以绘制决策边界。