21、（DNN）深度神经网络

最新推荐文章于 2024-10-05 15:29:40 发布
最新推荐文章于 2024-10-05 15:29:40 发布
阅读量116 收藏
点赞数
文章标签： dnn 机器学习 深度学习 人工智能 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38251900/article/details/130435180
版权

一、神经网络(DNN算法)

实例网站：[http://playground.tensorflow.org

深度神经.png
image.png
image.png
image.png
  • 激活函数：relu,sigmoid,
  • 作用：由直变曲

  • 值代表线性问题

    image.png
    image.png

三、神经网络算法代码实现

  • prefetch ---预先取出数据，加快计算的数据、
    *什么是激活函数？激活函数有哪些？

(1)代码--自己写多层隐藏层

import warnings
warnings.filterwarnings('ignore')
import numpy as np

import tensorflow as tf

from tensorflow.keras.datasets import mnist

加载数据，处理数据

(X_train,y_train),(X_test,y_test) = mnist.load_data()

# 归一化
X_train = (X_train/255.0).astype(np.float32)
X_test = (X_test/255.0).astype(np.float32)

# reshape,二维的数据，矩阵运算了
X_train = X_train.reshape(-1,784)
X_test = X_test.reshape(-1,784)

# one-hot 概率表示类别
y_train = tf.one_hot(y_train,depth=10)
y_test = tf.one_hot(y_test,depth=10)

# prefetch fetch取出来的意思，预先取出来，更快，加快计算速度
# 训练数据
data_train = tf.data.Dataset.from_tensor_slices((X_train,y_train)).repeat(50).shuffle(1000).batch(512).prefetch(1)
# 测试数据，验证模型好坏！每训练50次，取出一批测试数据，进行测试准确率
data_test = tf.data.Dataset.from_tensor_slices((X_test,y_test)).repeat(10).shuffle(1000).batch(512).prefetch(1)

构建模型

# 系数，3层隐含层
# 数据 X_train 样本，特征 784
# 第一层隐含层，多少个神经元：256个神经元，相当于线性方程，矩阵运算批量的计算
w1 = tf.Variable(tf.random.normal(shape = [784,256],stddev = 0.01))
b1 = tf.Variable(tf.random.normal(shape = [256],stddev = 0.01))

# 第二层隐含层，给256个神经元
w2 = tf.Variable(tf.random.normal(shape = [256,256],stddev = 0.01))
b2 = tf.Variable(tf.random.normal(shape = [256],stddev = 0.01))

#第三层，使用第二层数据的输出为数据
# 第三层给，512个神经元
w3 = tf.Variable(tf.random.normal(shape = [256,512],stddev = 0.01))
b3 = tf.Variable(tf.random.normal(shape = [512],stddev = 0.01))

# 输出层，输出几个类别，10分类问题，确定了，输出的类别是10个

out_w = tf.Variable(tf.random.normal(shape = [512,10],stddev = 0.01))
out_b = tf.Variable(tf.random.normal(shape = [10],stddev = 0.01))

def dnn(X):#深度神经网络
#     第一层的连接：矩阵运算
    d1 = tf.matmul(X,w1) + b1
    d1 = tf.nn.relu(d1) # 激活函数
    
#     第二层的连接，矩阵运算
    d2 = tf.nn.relu(tf.matmul(d1,w2) + b2)
    
#     第三层的连接，矩阵预算
    d3 = tf.nn.relu(tf.matmul(d2,w3) + b3)
    
#     输出层连接，矩阵运算，softmax概率问题
    y_pred = tf.nn.softmax(tf.matmul(d3,out_w) + out_b)
    return y_pred

# 损失函数，样本平均cross_entropy交叉熵
def cross_entropy(y_true,y_pred):
    y_pred = tf.clip_by_value(y_pred,1e-9,1.0)
    loss = tf.reduce_mean(tf.reduce_sum(y_true*tf.math.log(1/y_pred),axis = -1))#数据是二维的
    return loss

# 计算准确率
def accuracy(y_pred,y_true):#y_和y_true,都是tensor
    y_pred = y_pred.numpy().argmax(axis = -1)
    y_true = y_true.numpy().argmax(axis = -1)
    acc = (y_pred == y_true).mean()
    return acc #返回准确率
# 优化算法，梯度下降
# 学习率，太小，学的太慢！
sgd = tf.optimizers.SGD(learning_rate=0.2)

定义运行方法

def run_optimizer(X_train,y_train):
    with tf.GradientTape() as g:
        y_pred = dnn(X_train)
        loss = cross_entropy(y_train,y_pred)
    gradients = g.gradient(loss,[w1,b1,w2,b2,w3,b3,out_w,out_b])
    sgd.apply_gradients(zip(gradients,[w1,b1,w2,b2,w3,b3,out_w,out_b]))

for循环运行代码

for i,(X_train,y_train) in enumerate(data_train.take(1000),1):
    run_optimizer(X_train,y_train)
    if i%10 == 0:
        #计算准确率
        for (X_test,y_test) in data_test.take(1):
            y_pred = dnn(X_test)
            acc = accuracy(y_pred,y_test)
            print('执行次数：%d。准确率是：%0.4f'%(i,acc))
执行次数：10。准确率是：0.1348
执行次数：20。准确率是：0.1191
执行次数：30。准确率是：0.1133
执行次数：40。准确率是：0.1270
执行次数：50。准确率是：0.1152
执行次数：60。准确率是：0.1270
执行次数：70。准确率是：0.1016
执行次数：80。准确率是：0.1328
执行次数：90。准确率是：0.1211
执行次数：100。准确率是：0.1191
执行次数：110。准确率是：0.1406
执行次数：120。准确率是：0.1289
执行次数：130。准确率是：0.1309
执行次数：140。准确率是：0.1348
执行次数：150。准确率是：0.1367
执行次数：160。准确率是：0.1309
执行次数：170。准确率是：0.1191
执行次数：180。准确率是：0.1113
执行次数：190。准确率是：0.1250
执行次数：200。准确率是：0.1191
执行次数：210。准确率是：0.1309
执行次数：220。准确率是：0.1348
执行次数：230。准确率是：0.1191
执行次数：240。准确率是：0.1074
执行次数：250。准确率是：0.1035
执行次数：260。准确率是：0.1328
执行次数：270。准确率是：0.1250
执行次数：280。准确率是：0.1035
执行次数：290。准确率是：0.1348
执行次数：300。准确率是：0.1211
执行次数：310。准确率是：0.1367
执行次数：320。准确率是：0.1426
执行次数：330。准确率是：0.1309
执行次数：340。准确率是：0.1426
执行次数：350。准确率是：0.1973
执行次数：360。准确率是：0.2012
执行次数：370。准确率是：0.2129
执行次数：380。准确率是：0.2285
执行次数：390。准确率是：0.2461
执行次数：400。准确率是：0.3496
执行次数：410。准确率是：0.4570
执行次数：420。准确率是：0.3867
执行次数：430。准确率是：0.4336
执行次数：440。准确率是：0.5566
执行次数：450。准确率是：0.5293
执行次数：460。准确率是：0.5938
执行次数：470。准确率是：0.5664
执行次数：480。准确率是：0.6406
执行次数：490。准确率是：0.5977
执行次数：500。准确率是：0.5488
执行次数：510。准确率是：0.6602
执行次数：520。准确率是：0.5996
执行次数：530。准确率是：0.7031
执行次数：540。准确率是：0.7227
执行次数：550。准确率是：0.7520
执行次数：560。准确率是：0.7246
执行次数：570。准确率是：0.8223
执行次数：580。准确率是：0.8047
执行次数：590。准确率是：0.8301
执行次数：600。准确率是：0.8105
执行次数：610。准确率是：0.7988
执行次数：620。准确率是：0.8633
执行次数：630。准确率是：0.8047
执行次数：640。准确率是：0.8594
执行次数：650。准确率是：0.8516
执行次数：660。准确率是：0.8594
执行次数：670。准确率是：0.8887
执行次数：680。准确率是：0.8594
执行次数：690。准确率是：0.8555
执行次数：700。准确率是：0.8848
执行次数：710。准确率是：0.8789
执行次数：720。准确率是：0.8574
执行次数：730。准确率是：0.8848
执行次数：740。准确率是：0.9023
执行次数：750。准确率是：0.8711
执行次数：760。准确率是：0.8945
执行次数：770。准确率是：0.8242
执行次数：780。准确率是：0.8887
执行次数：790。准确率是：0.8906
执行次数：800。准确率是：0.8945
执行次数：810。准确率是：0.9023
执行次数：820。准确率是：0.8984
执行次数：830。准确率是：0.9102
执行次数：840。准确率是：0.9160
执行次数：850。准确率是：0.8906
执行次数：860。准确率是：0.9141
执行次数：870。准确率是：0.9277
执行次数：880。准确率是：0.9023
执行次数：890。准确率是：0.9141
执行次数：900。准确率是：0.9180
执行次数：910。准确率是：0.9258
执行次数：920。准确率是：0.9238
执行次数：930。准确率是：0.9277
执行次数：940。准确率是：0.9297
执行次数：950。准确率是：0.9336
执行次数：960。准确率是：0.9199
执行次数：970。准确率是：0.9277
执行次数：980。准确率是：0.9336
执行次数：990。准确率是：0.9336
执行次数：1000。准确率是：0.9199

(2)代码(tensorflow封装好的)：

import warnings
warnings.filterwarnings('ignore')
import numpy as np

import tensorflow as tf

from tensorflow.keras.datasets import mnist
from tensorflow.keras import Model,layers
# model 模型--就是算法数学的公式，深度神经网络，3层的隐含层
# layers 定义好的层
(X_train,y_train),(X_test,y_test) = mnist.load_data()

# 归一化
X_train = (X_train/255.0).astype(np.float32)
X_test = (X_test/255.0).astype(np.float32)

# reshape,二维的数据，矩阵运算了
X_train = X_train.reshape(-1,784)
X_test = X_test.reshape(-1,784)

# one-hot 概率表示类别
y_train = tf.one_hot(y_train,depth=10)
y_test = tf.one_hot(y_test,depth=10)

# prefetch fetch取出来的意思，预先取出来，更快，加快计算速度
# 训练数据
data_train = tf.data.Dataset.from_tensor_slices((X_train,y_train)).repeat(50).shuffle(1000).batch(512).prefetch(1)
# 测试数据，验证模型好坏！每训练50次，取出一批测试数据，进行测试准确率
data_test = tf.data.Dataset.from_tensor_slices((X_test,y_test)).repeat(10).shuffle(1000).batch(512).prefetch(1)

构建模型--tf2.0写法，损失，准确率\学习率

class Dnn(Model):
#     layers 会自动的帮助我们写出变量
#     变量是对应神经元的数量
    def __init__(self):
        super(Dnn,self).__init__() #调用父类的方法
        self.h1=layers.Dense(256,activation="relu") # Dense相当于矩阵运算128神经元
        self.h2=layers.Dense(256,activation="relu")
        self.h3=layers.Dense(512,activation="relu")
        self.out=layers.Dense(10,activation=tf.nn.softmax)
#       #tf.nn.softmax--转为概率的问题
    def call(self,x,is_training=False): 
        # is_training=False区分训练和测试的情况
        x=self.h1(x)
        x=self.h2(x)
        x=self.h3(x)
        y_pred=self.out(x)
        return y_pred
dnn=Dnn()
# 损失函数，样本平均cross_entropy交叉熵
def cross_entropy(y_true,y_pred):
    y_pred = tf.clip_by_value(y_pred,1e-9,1.0)
    loss = tf.reduce_mean(tf.reduce_sum(tf.multiply(y_true,tf.math.log(1/y_pred)),axis=1))#数据是二维的
    return loss


# 声明准确率
def accuracy(y_pred,y_true):#y_和y_true,都是tensor
    y_pred =tf.argmax(y_pred,axis = -1)
    y_true =tf.argmax(y_true,axis = -1)
#     acc = (y_pred == y_true).mean()
    acc=tf.reduce_mean(tf.cast(tf.equal(y_true,y_pred),tf.float16)).numpy()
    return acc #返回准确率
sgd = tf.optimizers.SGD(learning_rate=0.1)

优化算法

def run_optimizer(X_train,y_train):
    with tf.GradientTape() as g:
        y_pred = dnn(X_train)
        loss = cross_entropy(y_train,y_pred)
#  cross_entropy交叉熵       
    gradients = g.gradient(loss,dnn.trainable_variables)
#     dnn可以直接获取到系数--dnn为我们声明好的
    sgd.apply_gradients(zip(gradients,dnn.trainable_variables))

for循环运行代码

for i,(X_train,y_train) in enumerate(data_train.take(1000),1):
    run_optimizer(X_train,y_train)
    if i%10 == 0:
        #计算准确率
        for (X_test,y_test) in data_test.take(1):
            y_pred = dnn(X_test)
            acc = accuracy(y_pred,y_test)
            print('执行次数：%d。准确率是：%0.4f'%(i,acc))
执行次数：10。准确率是：0.5723
执行次数：20。准确率是：0.6660
执行次数：30。准确率是：0.7402
执行次数：40。准确率是：0.7422
执行次数：50。准确率是：0.7422
执行次数：60。准确率是：0.8496
执行次数：70。准确率是：0.7910
执行次数：80。准确率是：0.8496
执行次数：90。准确率是：0.8691
执行次数：100。准确率是：0.8535
执行次数：110。准确率是：0.8750
执行次数：120。准确率是：0.8652
执行次数：130。准确率是：0.8809
执行次数：140。准确率是：0.8359
执行次数：150。准确率是：0.8906
执行次数：160。准确率是：0.8730
执行次数：170。准确率是：0.8887
执行次数：180。准确率是：0.9043
执行次数：190。准确率是：0.8867
执行次数：200。准确率是：0.8906
执行次数：210。准确率是：0.8848
执行次数：220。准确率是：0.8984
执行次数：230。准确率是：0.9082
执行次数：240。准确率是：0.8945
执行次数：250。准确率是：0.9180
执行次数：260。准确率是：0.9395
执行次数：270。准确率是：0.9180
执行次数：280。准确率是：0.9082
执行次数：290。准确率是：0.9219
执行次数：300。准确率是：0.9141
执行次数：310。准确率是：0.9277
执行次数：320。准确率是：0.9160
执行次数：330。准确率是：0.9141
执行次数：340。准确率是：0.9004
执行次数：350。准确率是：0.9082
执行次数：360。准确率是：0.9121
执行次数：370。准确率是：0.9238
执行次数：380。准确率是：0.9102
执行次数：390。准确率是：0.9238
执行次数：400。准确率是：0.9219
执行次数：410。准确率是：0.9355
执行次数：420。准确率是：0.9141
执行次数：430。准确率是：0.9336
执行次数：440。准确率是：0.9180
执行次数：450。准确率是：0.9336
执行次数：460。准确率是：0.9316
执行次数：470。准确率是：0.9238
执行次数：480。准确率是：0.9395
执行次数：490。准确率是：0.9219
执行次数：500。准确率是：0.9297
执行次数：510。准确率是：0.9355
执行次数：520。准确率是：0.9258
执行次数：530。准确率是：0.9258
执行次数：540。准确率是：0.9297
执行次数：550。准确率是：0.9375
执行次数：560。准确率是：0.9336
执行次数：570。准确率是：0.9238
执行次数：580。准确率是：0.9180
执行次数：590。准确率是：0.9180
执行次数：600。准确率是：0.9297
执行次数：610。准确率是：0.9375
执行次数：620。准确率是：0.9414
执行次数：630。准确率是：0.9375
执行次数：640。准确率是：0.9238
执行次数：650。准确率是：0.9199
执行次数：660。准确率是：0.9355
执行次数：670。准确率是：0.9375
执行次数：680。准确率是：0.9316
执行次数：690。准确率是：0.9570
执行次数：700。准确率是：0.9531
执行次数：710。准确率是：0.9453
执行次数：720。准确率是：0.9395
执行次数：730。准确率是：0.9512
执行次数：740。准确率是：0.9336
执行次数：750。准确率是：0.9512
执行次数：760。准确率是：0.9375
执行次数：770。准确率是：0.9414
执行次数：780。准确率是：0.9453
执行次数：790。准确率是：0.9277
执行次数：800。准确率是：0.9336
执行次数：810。准确率是：0.9414
执行次数：820。准确率是：0.9570
执行次数：830。准确率是：0.9473
执行次数：840。准确率是：0.9609
执行次数：850。准确率是：0.9473
执行次数：860。准确率是：0.9570
执行次数：870。准确率是：0.9414
执行次数：880。准确率是：0.9434
执行次数：890。准确率是：0.9434
执行次数：900。准确率是：0.9629
执行次数：910。准确率是：0.9414
执行次数：920。准确率是：0.9492
执行次数：930。准确率是：0.9473
执行次数：940。准确率是：0.9590
执行次数：950。准确率是：0.9473
执行次数：960。准确率是：0.9492
执行次数：970。准确率是：0.9531
执行次数：980。准确率是：0.9375
执行次数：990。准确率是：0.9570
执行次数：1000。准确率是：0.9590
影子传说--通关版本
关注
dnn神经网络和bp神经网络,dnn深度神经网络原理
ynca67269的博客
10-17 2627
如减小像素的颜色值，可以解决曝光过度的问题，模糊的图像也可以进行锐化处理，清晰的图像可以使用模糊处理模拟摄像机滤色镜产生的柔和效果。模糊处理——模糊的卷积核由一组系数构成，每个系数都小于1，但它们的和恰好等于1，每个像素都吸收了周围像素的颜色，每个像素的颜色分散给了它周围的像素，最后得到的图像中，一些刺目的边缘变得柔和。要进行水彩处理，首先要对图像中的色彩进行平滑处理，把每个像素的颜色值和它周围的二十四个相邻的像素颜色值放在一个表中，然后由小到大排序，把表中间的一个颜色值作为这个像素的颜色值。
python构建深度神经网络（DNN）
12-23
本文学习Neural Networks and Deep Learning 在线免费书籍，用python构建神经网络识别手写体的一个总结。 代码主要包括两三部分： 1）、数据调用和预处理 2）、神经网络类构建和方法建立 3）、代码测试文件 1）数据...
深度神经网络模型（DNN）与前向传播算法
sihuachun的博客
05-27 3136
    \quad\;\;深度神经网络（Deep Neural Networks， 以下简称DNN）是深度学习的基础，而要理解DNN，首先我们要理解DNN模型，下面我们就对DNN的模型与前向传播算法做一个总结。 1. 从感知机到神经网络     \quad\;\;在感知机原理小结中，我们介绍过感知机的模型，它是一个有若干输入和一个输出的模型，如下图:     \quad\;\;输出和输入之间学习到一个线性关系，得到中间输出结果： z=∑i=1mwixi+bz=\sum\limits_{i=1}^mw_ix
用python计算准确率_python – 获得scikit-learn中多标签预测的准确性
weixin_39540020的博客
11-24 348
您可以自己编写一个版本,这是一个不考虑权重和规范化的示例.import numpy as npy_true = np.array([[0,1,0],[0,1],[1,1]])y_pred = np.array([[0,0]])def hamming_score(y_true,y_pred,normalize=True,sample_weight=None):'''Compute the Hammi...
Numpy实现accuracy
AI浩
10-09 3298
def accuracy_score(y_true, y_pred): """ Compare y_true to y_pred and return the accuracy """ accuracy = np.sum(y_true == y_pred, axis=0) / len(y_true) return accuracy
【DNN】研习深度神经网络DNN
qq_54432917的博客
11-21 9045
层层深入，循序渐进来理解深度神经网络
DNN(深度神经网络)
热门推荐
云计算、数据库、大数据、容器、微服务、深度学习、NLP、Python
05-09 2万+
深度神经网络（Deep Neural Networks， 以下简称DNN） 神经网络发展 第一代神经网络又称为感知器，由科学家Frank Rosenblatt发明于1950至1960年代，它的算法只有两层，输入层输出层，，主要使用的是一种叫做sigmoid神经元（sigmoid neuron）的神经元模型，主要是线性结构。它不能解决线性不可分的问题，如异或操作。 为了解决第一代神经网络的缺陷，在1980年左右提出第二代神经网络多层感知器（MLP）。和第一代神经网络相比，第二代在输入输出层之间有增加了
3、深度神经网络（DNN）
m0_56642803的博客
05-22 9916
​ 深度神经网络是基于上述MLP感知机的扩展，DNN可以理解为的神经网络。MLP可以视为DNN的前身，大致可以分为三层：输入层，隐藏层，输出层，MLP通常很浅，隐藏层就一二层。DNN一般隐藏层大于二，而且的种类更多。
DNN-深度神经网络
2301_78731684的博客
12-09 3312
深度神经网络（DNN）是一种多层神经网络，通过将多个神经元连接在一起，形成一种深度结构。DNN可以用于处理各种类型的数据，包括图像、文本、语音等。在深度神经网络中，隐含层的数量和每层的神经元数量可以视具体任务和数据类型而定。DNN的训练过程通常采用反向传播算法和梯度下降优化方法，通过不断地调整神经网络的参数，以最小化预测误差和损失函数。深度神经网络具有多个非线性映射的特征变换，可以对高度复杂的函数进行拟合。相比浅层建模方式，深层建模能更细致高效的表示实际的复杂非线性问题。
深入理解深度神经网络（DNN）
聚娃科技开发者博客
06-28 290
每个神经元接收来自前一层神经元的输入，应用权重和偏置，然后通过激活函数输出结果，这些结果作为下一层神经元的输入。通过这种逐层传递和学习权重的方式，DNN能够在训练过程中逐步优化模型，使其能够准确预测或分类新的未知数据。深度神经网络作为机器学习领域的重要技术，其强大的数据学习和表示能力使其在各种复杂问题的解决中发挥着重要作用。通过不断优化网络结构和训练算法，DNN能够处理更多种类和更大规模的数据，为现代技术和应用带来了巨大的推动力。例如，在图像识别中，DNN可以识别和分类图像中的对象；
深度学习基础篇之深度神经网络（DNN）
Fluentwater的博客
04-13 1万+
神经网络不应该看做是一个算法，应该看做是一个特征挖掘方法。在实际的业界发展过程中，数据的作用往往大于模型，当我们把数据的隐藏特征提取出来之后，用很简单的模型也能预测的很好。神经网络模型由生物神经中得到启发。在生物神经元细胞中，神经突触接收到信号，经过接收并处理信号后判断信号的信息强弱，来做出不同神经电位变化反应。受此启发，科研人员设计出基础的神经网络模型结构，神经元模型（Neuron Model）。
Matlab实现DNN深度神经网络多变量时间序列预测（完整程序和数据）
04-07
Matlab实现DNN深度神经网络多变量时间序列预测（完整程序和数据） 1.输入多个特征，输出单个变量； 2.考虑历史特征的影响，多变量时间序列预测； 4.excel数据，方便替换； 5.运行环境Matlab2018b及以上； 6.输出R2、...
DNN深度神经网络多变量时间序列预测（Matlab完整程序和数据）
04-07
DNN深度神经网络多变量时间序列预测（Matlab完整程序和数据） DNN深度神经网络多变量时间序列预测（Matlab完整程序和数据） DNN深度神经网络多变量时间序列预测（Matlab完整程序和数据） 输入多个特征，输出单个变量...
如何用深度神经网络预测潜在消费者
深度学习实战训练营，一起交流探索深度学习
10-04 761
将FM模型的线性部分、二阶交互部分以及DNN部分的输出拼接在一起，最终通过Sigmoid层输出预测结果（适用于二分类任务）。模型，其结构结合了FM（因子分解机）与深度神经网络（DNN），实现了低阶与高阶特征交互的有效建模。每个类别型特征通过嵌入层转换为低维的稠密向量，便于后续的FM和DNN层处理。这里模拟了不同的用户行为类型，可能为了确保数据的多样性或处理数据的平衡性。：构建FM模型的一阶线性部分，将稀疏和密集特征的线性嵌入结果结合，形成线性组合。：构建FM部分的二阶交互层，计算嵌入向量的内积并通过。
yolov5-7.0模型DNN加载函数及参数详解(重要)
最新发布
qq_44870829的博客
10-05 747
理论上，有了onnx模型，有了该网络模型的输入输出各个参数含义，就可以使用任意的可以读取onnx模型的部署框架进行部署推理。与指针相比，通过mat数组获取对应的第4列的数据是对应的起来的，如下应该使用32F数据格式即可（要将其结果转为（25200*6格式的数据保存到mat中））Forward函数有很多，可以得到如下，有的是将所有的输出结果得到（有时输出层有多个），有的是将对应层的输出结果得到，这里直接得到所有最终输出结果就行了。上图最右侧的第6列的数据是类的分数（虽然显示1，但实际上分值是浮点数接近1的）
【机器学习-无监督学习】降维与主成分分析
Morse_Chen的博客
10-01 2116
本文介绍了数据降维的常用算法之一：PCA算法。数据降维是无监督学习的重要问题，在机器学习中有广泛的应用。利用特征分解进行PCA，动手实现了PCA算法，并使用sklearn实现PCA算法。
机器学习框架总结
weixin_42462436的博客
10-04 994
机器学习框架是用于构建、训练、评估和部署机器学习模型的工具和库的集合。它们简化了模型开发过程，并提供了预构建的功能、优化的计算性能和对深度学习、监督学习、无监督学习等技术的支持。下面是一些主要的机器学习框架的详细介绍：
GAN生成对抗网络介绍
m0_58941767的博客
10-04 571
生成对抗网络（Generative Adversarial Networks，简称GANs）是由Ian Goodfellow等人在2014年提出的一种深度学习模型。它由两部分组成：生成器（Generator）和判别器（Discriminator），两者在训练过程中相互竞争，从而提高生成数据的质量和判别数据真伪的能力。一、GAN是什么？Generative Adversarial Networks ,生成对抗网络是一种深度学习模型。
dnn深度神经网络python
05-26
好的，您想了解关于使用Python构建DNN深度神经网络的相关内容，我可以为您提供一些基本的信息。 Python是一种功能强大的编程语言，它具有广泛的应用领域，其中包括人工智能和深度学习。深度神经网络是一种强大的机器学习技术，可以用于处理各种类型的数据，并表现出出色的性能。 要使用Python构建DNN深度神经网络，您需要掌握一些基本的编程技巧和深度学习的相关知识。以下是一些您可以开始学习的主题： 1. Python编程语言的基础知识，包括变量、条件语句、循环和函数等。 2. NumPy和Pandas等Python库，这些库提供了各种数据结构和函数，用于处理和分析数据。 3. TensorFlow、PyTorch或Keras等深度学习框架，这些框架提供了各种工具和函数，用于构建和训练深度神经网络。 4. 神经网络的基本概念，包括前向传播、反向传播、激活函数和损失函数等。 5. 深度学习的常见应用，包括图像分类、目标检测、自然语言处理和强化学习等。 以上是一些您可以开始学习的主题，如果您需要更具体的信息或有任何问题，请随时向我提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值