一个有激活函数和没有激活函数的例子

本文介绍了一种使用TensorFlow实现线性和非线性分类的方法,通过生成和可视化两类不同的测试数据,包括简单的线性分类数据和环形分布数据,展示了如何构建和训练两种模型:一种用于线性分类,另一种用于处理更复杂的非线性分类任务。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

闲来无事写的,本来想可视化一些,但是python编程实在不会,只能简化一下,自己理解吧
PS:环形测试数据的生成代码来自网上

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
#为了说明问题,两个模型都设计为两层隐藏层
tf.reset_default_graph()
#生成测试数据类型1
def create_data1(N):#生成简单线性分类测试数据
    tmpl=np.zeros([N,2])
    mean=np.random.randn(2)
    t1=np.random.multivariate_normal(mean=mean,cov=[[1,0],[0,1]],size=int(N/2))
    t2 = np.random.multivariate_normal(mean=mean+3, cov=[[1, 0], [0, 1]], size=int(N/2))
    tmp1=np.concatenate([t1,t2])
    tmp2=np.zeros(N)
    tmp2[int(N/2):]=1
    tmp2=np.reshape(tmp2,[-1,1])
    return tmp1,tmp2
def create_data2(N):#生成环形测试数据
    tmp1=np.zeros([N,2])
    tmp2=np.zeros(N)
    N = int(N / 2)
    PI=3.1415
    theta = np.linspace(0, 2 * PI, N) + PI * (np.random.rand(N)) / 100
    a = 0.5
    b = 0.5
    r1 = 0.4 + 2 * (np.random.rand(N) - 0.5) / 10
    x1 = a + r1 * np.cos(theta) + (np.random.rand(N) - 0.5) / 50
    y1 = b + r1 * np.sin(theta) + (np.random.rand(N) - 0.5) / 50
    r2 = 0.2 * np.random.rand(N)
    x2 = a + r2 * np.cos(theta) + (np.random.rand(N) - 0.5) / 50
    y2 = b + r2 * np.sin(theta) + (np.random.rand(N) - 0.5) / 50
    tmp1[0:N,0]=x1[:]
    tmp1[0:N, 1] = y1[:]
    tmp1[N:,0]=x2[:]
    tmp1[N:, 1] = y2[:]
    tmp2[N:] = 1
    tmp2 = np.reshape(tmp2, [-1, 1])
    return tmp1,tmp2
data_rows=1000
train_data,train_label=create_data1(data_rows)#这个测试数据可以是data2

plt.subplot(2,1,1)
train_data1,train_label1=create_data1(data_rows)
plt.plot(train_data1[0:500,0],train_data1[0:500,1],'ro')
plt.plot(train_data1[500:,0],train_data1[500:,1],'bo')
plt.subplot(2,1,2)
train_data2,train_label2=create_data2(data_rows)
plt.plot(train_data2[0:500,0],train_data2[0:500,1],'ro')
plt.plot(train_data2[500:,0],train_data2[500:,1],'bo')
plt.show()
#线性的模型
g_line_function=tf.Graph()
with g_line_function.as_default():
    X=tf.placeholder(tf.float32,[None,2])
    Z=tf.placeholder(tf.float32,[None,1])

    Wih=tf.Variable(tf.random_normal([2,2]))
    bih=tf.Variable(tf.zeros([2]))

    Who=tf.Variable(tf.random_normal([2,1]))
    bho=tf.Variable(tf.zeros([1]))

    Zih=tf.matmul(X,Wih)+bih
    Zho=tf.matmul(Zih,Who)+bho

    cost=tf.reduce_mean(tf.square(Z-Zho))
    learning_rate=0.001
    optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

g_active_function=tf.Graph()
with g_active_function.as_default():
    X=tf.placeholder(tf.float32,[None,2])
    Z=tf.placeholder(tf.float32,[None,1])

    Wih=tf.Variable(tf.random_normal([2,2]))
    bih=tf.Variable(tf.zeros([2]))

    Who=tf.Variable(tf.random_normal([2,1]))
    bho=tf.Variable(tf.zeros([1]))

    Zih=tf.nn.sigmoid(tf.matmul(X,Wih)+bih)
    Zho=tf.nn.sigmoid(tf.matmul(Zih,Who)+bho)

    cost=tf.reduce_mean(tf.square(Z-Zho))
    learning_rate=0.001
    optimizer=tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
with tf.Session(graph=g_active_function) as sess:
    sess.run(tf.global_variables_initializer())
    epochs=200
    batch_size=10
    batchs = int(data_rows/batch_size)
    for epoch in range(epochs):
        avg_loss=0
        for i in range(batchs):
            x=train_data[i*batch_size:(i+1)*batch_size,:]
            z=train_label[i*batch_size:(i+1)*batch_size]
            _,c=sess.run([optimizer,cost],feed_dict={X:x,Z:z})
            zho=sess.run(Zho,feed_dict={X:x,Z:z})
            avg_loss+=c/batchs
        print("Epoch=",epoch,"Loss=",avg_loss)
    print("Finished")

### 简单神经网络示例(包含激活函数) 以下是一个简单的神经网络示例,它使用了激活函数。该网络由一个输入层、一个隐藏层一个输出层组成。隐藏层中的神经元应用了一个激活函数,例如 Sigmoid 或 ReLU。 ```python import numpy as np # 定义激活函数及其导数 def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): return x * (1 - x) # 输入数据 X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # 目标输出 y = np.array([[0], [1], [1], [0]]) # 初始化权重 np.random.seed(1) weights_hidden = 2 * np.random.random((2, 2)) - 1 # 输入层到隐藏层的权重 weights_output = 2 * np.random.random((2, 1)) - 1 # 隐藏层到输出层的权重 # 训练过程 for i in range(20000): # 前向传播 hidden_layer_input = np.dot(X, weights_hidden) # 输入层到隐藏层的加权 hidden_layer_output = sigmoid(hidden_layer_input) # 应用激活函数[^1] output_layer_input = np.dot(hidden_layer_output, weights_output) # 隐藏层到输出层的加权 output_layer_output = sigmoid(output_layer_input) # 应用激活函数[^1] # 计算误差 error = y - output_layer_output if i % 5000 == 0: print(f"Error after {i} iterations: {np.mean(np.abs(error))}") # 反向传播 d_output = error * sigmoid_derivative(output_layer_output) # 输出层误差项 error_hidden_layer = d_output.dot(weights_output.T) # 隐藏层误差 d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output) # 隐藏层误差项 # 更新权重 weights_output += hidden_layer_output.T.dot(d_output) weights_hidden += X.T.dot(d_hidden_layer) # 测试网络 hidden_layer_input_test = np.dot(X, weights_hidden) hidden_layer_output_test = sigmoid(hidden_layer_input_test) output_layer_input_test = np.dot(hidden_layer_output_test, weights_output) output_layer_output_test = sigmoid(output_layer_input_test) print("预测输出:") print(output_layer_output_test) ``` 上述代码实现了一个简单的前馈神经网络,其中包含了激活函数 `sigmoid`。在训练过程中,通过反向传播算法调整权重以最小化误差[^2]。 --- ### 关于激活函数的作用 激活函数在网络中起到引入非线性的作用。如果没有激活函数,无论网络有多少层,其本质上仍然是一个线性模型[^3]。因此,激活函数使得神经网络能够学习复杂的模式非线性关系。 常用的激活函数包括: - Sigmoid:将值压缩到 `(0, 1)` 区间。 - ReLU(Rectified Linear Unit):将所有负值变为零,保留正值。 - Tanh:将值压缩到 `(-1, 1)` 区间。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值