Tensorflow2.0使用keras搭建神经网络（第二节）

最新推荐文章于 2023-03-02 16:16:21 发布
最新推荐文章于 2023-03-02 16:16:21 发布
阅读量722 收藏 2
点赞数
分类专栏： Tensorflow2.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34964399/article/details/104084070
版权 
import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import pandas as pd
import os
import sys
import time
import sklearn
from tensorflow import keras

import tensorflow as tf
print(tf.__version__)
print(sys.version_info)
for module in mpl, np, pd, sklearn, tf, keras:
    print(module.__name__, module.__version__)

2.0.0
sys.version_info(major=3, minor=7, micro=3, releaselevel=‘final’, serial=0)
matplotlib 3.0.3
numpy 1.16.2
pandas 0.24.2
sklearn 0.20.3
tensorflow 2.0.0
tensorflow_core.keras 2.2.4-tf

2.4 实战分类模型之模型构建

fashion_mnist = keras.datasets.fashion_mnist
(x_train_all, y_train_all),(x_test, y_test) = fashion_mnist.load_data()
x_valid, x_train = x_train_all[:5000], x_train_all[5000:]
y_valid, y_train = y_train_all[:5000], y_train_all[5000:]
# 数据归一化
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
x_train_scaled = scaler.fit_transform(
    x_train.astype(np.float32).reshape(-1,1)).reshape(-1, 28, 28)
x_valid_scaled = scaler.transform(
    x_valid.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)
x_test_scaled = scaler.transform(
    x_test.astype(np.float32).reshape(-1,1)).reshape(-1,28,28)
x_train_scaled.shape, y_train.shape

((55000, 28, 28), (55000,))

def show_imgs(n_rows, n_cols, x_data, y_data, class_names):
    fig = plt.figure(figsize=(1.4*n_cols, 1.5*n_rows))
    for row in range(n_rows):
        for col in range(n_cols):
            index = row * n_cols + col
            plt.subplot(n_rows, n_cols, index+1)
            plt.imshow(x_data[index], cmap='binary', interpolation='nearest')
            plt.axis('off')
            plt.title(class_names[y_data[index]])
    plt.show()
class_names = ['T-shirt', 'Trouser', 'Pullover', 'Dress', 'Coat',
                      'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
show_imgs(3, 5, x_train_scaled, y_train, class_names)

在这里插入图片描述

# 构建model
'''
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape = [28, 28]))
model.add(keras.layers.Dense(300, activation='relu'))
model.add(keras.layers.Dense(100, activation='relu'))
model.add(keras.layers.Dense(10, activation='softmax'))
'''
# 构建model
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape = [28, 28]),
    keras.layers.Dense(300, activation='relu'),
    keras.layers.Dense(100, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])
# relu : y = max(0, x)
# softmax: 将向量变成概率分布， x = [x1, x2, x3]
#           y = [e^x1/sum, e^x2/sum, e^x3/sum], sum = e^x1 + e^x2 + e^x3
# reason for sparse: y-> index, y已经是一个向量用categorical_crossentropy，y只是一个数用'sparse_categorical_crossentropy
model.compile(loss='sparse_categorical_crossentropy', # 损失函数：交叉熵
                     optimizer = 'sgd',
                     metrics = ['accuracy'])

# 查看model的信息
model.layers

[<tensorflow.python.keras.layers.core.Flatten at 0x1a5a76ee10>,
<tensorflow.python.keras.layers.core.Dense at 0x1a5a76e048>,
<tensorflow.python.keras.layers.core.Dense at 0x1a5a76e198>,
<tensorflow.python.keras.layers.core.Dense at 0x1a5a7b62b0>]

model.summary()
# 输入层 -> 隐藏层 （w: 权重(784,300) ，b：偏置项 (300,) ）, 235500 = 784 * 300  + 300
# [样本数, 784] * w + b -> [样本数, 300]

在这里插入图片描述

history = model.fit(x_train_scaled, y_train, epochs=10, validation_data=(x_valid_scaled, y_valid)) # 遍历10次，每次遍历会拿验证集来验证准确率

在这里插入图片描述

def plot_learning_curving(history):
    pd.DataFrame(history.history).plot(figsize=(8, 5))
    plt.grid(True)
    plt.gca().set_ylim(0, 1)
    plt.show()
plot_learning_curving(history)

在这里插入图片描述

# 验证测试机
model.evaluate(x_test_scaled, y_test)

2.6 使用回调函数

# 构建model
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape = [28, 28]),
    keras.layers.Dense(300, activation='relu'),
    keras.layers.Dense(100, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(loss='sparse_categorical_crossentropy',  
                     optimizer = 'sgd',
                     metrics = ['accuracy'])
logdir = './callbacks'
if not os.path.isdir(logdir):
    os.mkdir(logdir)
output_model_file = os.path.join(logdir, 'fashion_mnist_model.h5')
callbacks = [
    keras.callbacks.TensorBoard(logdir),  # 训练过程中保存相关数据
    keras.callbacks.ModelCheckpoint(output_model_file, save_best_only=True), # 每隔一段时间保存数据
    keras.callbacks.EarlyStopping(patience=5, min_delta=1e-3) # min_delta：两次间隔损失值的差值与min_delta比较
                                                                                        # patience: 多次达到了min_delta则提前停止
]
history = model.fit(x_train_scaled, y_train, epochs=10, 
                    validation_data=(x_valid_scaled, y_valid),
                   callbacks = callbacks) # 遍历10次，每次遍历会拿验证集来验证准确率
# 到callbacks的外层目录下执行 tensorboard --logdir callbacks，可查看accuracy，loss图

2.9 构建深度神经网络

# 构建model
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28]))
for _ in range(20):
    model.add(keras.layers.Dense(100, activation='relu'))
model.add(keras.layers.Dense(10, activation='softmax'))

model.compile(loss='sparse_categorical_crossentropy',
                     optimizer = 'sgd',
                     metrics = ['accuracy'])
logdir = './dnn-callbacks'
if not os.path.isdir(logdir):
    os.mkdir(logdir)
output_model_file = os.path.join(logdir, 'fashion_mnist_model.h5')
callbacks = [
    keras.callbacks.TensorBoard(logdir),  # 训练过程中保存相关数据
    keras.callbacks.ModelCheckpoint(output_model_file, save_best_only=True), # 每隔一段时间保存数据
    keras.callbacks.EarlyStopping(patience=5, min_delta=1e-3) # min_delta：两次间隔损失值的差值与min_delta比较
                                                                                        # patience: 多次达到了min_delta则提前停止
]
history = model.fit(x_train_scaled, y_train, epochs=10, 
                    validation_data=(x_valid_scaled, y_valid),
                   callbacks = callbacks) # 遍历10次，每次遍历会拿验证集来验证准确率
# 到callbacks的外层目录下执行 tensorboard --logdir callbacks，可查看accuracy，loss图
plot_learning_curving(history)
# 在视频中在前3次训练中损失值曲线不下降主要由以下2个原因引起（我的曲线正常）
# 1.参数众多，训练不充分
# 2. 梯度消失主要发生在深度神经网络中，因为梯度是由链式法则进行求导的，链式法则就是复合函数求导，导致梯度消失

在这里插入图片描述

2-11 wide&deep模型

  1. 稀疏特征

    • 离散值特征
    • One-hot表示
      • eg: 专业 = [计算机, 美术] 则美术的One-hot为[0, 1]
      • 上面的例子只有2个值，看上去觉得不稀疏，再举例：词表 = [人工智能，孙悟空，年龄…] ,那么“年龄”的One-hot=[0,0,1,…]
    • 叉乘 = {(计算机，人工智能),(计算机，孙悟空),…}
      • 稀疏特征做叉乘可以记住这个样本( 如果一个物体用离散特征来表达他的信息，那么叉乘后就是他的全部信息集合，如果来了一个新的样本，也必定属于这个集合，所以也就能正确预测这个样本了)

  2. 稀疏特征优缺点

    • 优点
      • 有效，广泛应用于工业界
    • 缺点
      • 需要人工设计（只能人工选取几个特征做叉乘，不能将每个离散特征都两两做叉乘，否则特征空间过大，还容易记住这个样本出现过拟合）
      • 泛化能力差，没出现过就不会起效果

  3. 密集特征

    • 向量表达(带有语义)
      • 还是用上面的例子， 词表 = [人工智能，孙悟空，年龄…]，里面的“年龄”=[0.3, 0.2, 0.4, (n维向量)]
    • Word2vec工具
      • 男 + 女 = 国王 + 王后 （男和女的特征相加 = 国王和王后的特征相加，因为是带有语义的，从这个里面就可以解读一些有趣的信息，可能是国王也是男的，王后是女的所以加起来 和 男加女的值一样）

  4. 密集特征优缺点

    • 优点：
      • 带有语义信息，不同向量之间可以通过计算距离查看相关性，从而可以把相似的样本预测对，兼容没有出现过的特征组合
      • 更少人工参与（是通过模型训练出来的）
    • 缺点：
      • 如果这种特征比较泛滥，容易过度泛化，推荐不怎么相关的产品
        在这里插入图片描述
        sparse feature为稀疏特征，Dense为sparse稀疏特征的一个密集表达
        在这里插入图片描述
        上图为google pay的一个wide-deep网络，左侧为deep模型，continuous特征无需做密集特征处理，categorical离散特征做密集
        特征处理，User Installed App和Impression App做叉乘作为wide模型的输入

输入数据准备

使用房价预测数据
from sklearn.datasets import fetch_california_housing
housing = fetch_california_housing()
from sklearn.model_selection import train_test_split
x_train_all, x_test, y_train_all, y_test = train_test_split(
    housing.data, housing.target, random_state = 7)
x_train, x_valid, y_train, y_valid = train_test_split(
    x_train_all, y_train_all, random_state = 11)
x_train_all.shape, x_test.shape, x_train.shape, x_valid.shape

((15480, 8), (5160, 8), (11610, 8), (3870, 8))

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
x_train_scaled = scaler.fit_transform(x_train)
x_valid_scaled = scaler.transform(x_valid)
x_test_scaled = scaler.transform(x_test)

def plot_learning_curving(history):
    pd.DataFrame(history.history).plot(figsize=(8, 5))
    plt.grid(True)
    plt.gca().set_ylim(0, 1)
    plt.show()

2-12 函数式API实现wide&deep模型

# deep模型
input = keras.layers.Input(shape=x_train.shape[1:])
hidden1 = keras.layers.Dense(30, activation='relu')(input)
hidden2 = keras.layers.Dense(30, activation='relu')(hidden1)

# 假设wide模型的输入也是同一个input，连接wide和deep模型
concat = keras.layers.concatenate([input, hidden2])
# wide和deep模型都输出到同一个unit
output = keras.layers.Dense(1)(concat)
model = keras.models.Model(inputs = [input], outputs = [output])

model.summary()
model.compile(loss='mean_squared_error', optimizer='adam', # 用sgd的loss会变nan，应该是学习率太大
                     patience=5, min_delta=1e-2)
callbacks = [keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)
            ]
history = model.fit(x_train_scaled, y_train, epochs=10, 
                    validation_data=(x_valid_scaled, y_valid),
                    callbacks = callbacks) # 遍历10次，每次遍历会拿验证集来验证准确率
# 到callbacks的外层目录下执行 tensorboard --logdir callbacks，可查看accuracy，loss图

2-13 子类API实现wide & deep模型

class WideDeepModel(keras.models.Model):
    def __init__(self):
        super(WideDeepModel, self).__init__()
        # 定义模型层次
        self.hidden1_layer = keras.layers.Dense(30, activation='relu')
        self.hidden2_layer = keras.layers.Dense(30, activation='relu')
        self.output_layer = keras.layers.Dense(1)
    
    def call(self, input):
        # 完成模型的正向计算
        hidden1 = self.hidden1_layer(input)
        hidden2 = self.hidden2_layer(hidden1)
        concat = keras.layers.concatenate([input, hidden2])
        output = self.output_layer(concat)
        return output

model = WideDeepModel()
model.build(input_shape = (None, 8))
model.summary()
model.compile(loss='mean_squared_error', optimizer='adam',
                     patience=5, min_delta=1e-2)
                     
callbacks = [keras.callbacks.EarlyStopping(
                patience=5, min_delta=1e-2)]
history = model.fit(x_train_scaled, y_train, epochs=10, 
                    validation_data=(x_valid_scaled, y_valid),
                    callbacks = callbacks)

2-14 模型的多输入和多输出实战

多输入单输出
input_wide = keras.layers.Input(shape=[5])
input_deep = keras.layers.Input(shape=[6])
hidden1 = keras.layers.Dense(30, activation='relu')(input_deep)
hidden2 = keras.layers.Dense(30, activation='relu')(hidden1)
concat = keras.layers.concatenate([input_wide, hidden2])
output = keras.layers.Dense(1)(concat)
model = keras.models.Model(inputs = [input_wide, input_deep], outputs = [output])
model.summary()
model.compile(loss="mean_squared_error", optimizer='sgd')
callbacks = [keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]

x_train_scaled_wide = x_train_scaled[:,:5]
x_train_scaled_deep = x_train_scaled[:,2:]
x_valid_scaled_wide = x_valid_scaled[:,:5]
x_valid_scaled_deep = x_valid_scaled[:,2:]
x_test_scaled_wide = x_test_scaled[:,:5]
x_test_scaled_deep = x_test_scaled[:,2:]

history = model.fit([x_train_scaled_wide, x_train_scaled_deep], y_train,
                   validation_data=([x_valid_scaled_wide, x_valid_scaled_deep], y_valid),
                    epochs=100,
                    callbacks = callbacks
                   )
多输入多输出

比如当前预测的房价是今年的房价，如果还要预测明年的房价就要使用多输出

# input_wide和input_deep结合到一个输出，再input_deep的DNN单独一个输出
input_wide = keras.layers.Input([5])
input_deep = keras.layers.Input([6])
hidden1 = keras.layers.Dense(30, activation='relu')(input_deep)
hidden2 = keras.layers.Dense(30, activation='relu')(hidden1)
concat = keras.layers.concatenate([input_wide, hidden2])
output1 = keras.layers.Dense(1)(concat)
output2 = keras.layers.Dense(1)(hidden2)

model = keras.models.Model(inputs = [input_wide, input_deep],
                                      outputs = [output1, output2])
model.summary()
model.compile(loss='mean_squared_error', optimizer='sgd')
callbacks = [keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]

在这里插入图片描述

x_train_scaled_wide = x_train_scaled[:,:5]
x_train_scaled_deep = x_train_scaled[:,2:]
x_valid_scaled_wide = x_valid_scaled[:,:5]
x_valid_scaled_deep = x_valid_scaled[:,2:]
x_test_scaled_wide = x_test_scaled[:,:5]
x_test_scaled_deep = x_test_scaled[:,2:]
history = model.fit([x_train_scaled_wide, x_train_scaled_deep],[y_train, y_train],
         validation_data=([x_valid_scaled_wide, x_valid_scaled_deep], [y_valid, y_valid]),
          epochs=100,
          callbacks = callbacks
         )

2-15 超参数搜索

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2-16 超参数搜索

    model = keras.models.Sequential([
        keras.layers.Input(shape = [8]),
        keras.layers.Dense(30, activation='relu'),
        keras.layers.Dense(1)
    ])
    lr= 0.0001
    optimizer = keras.optimizers.SGD(lr)
    model.compile(loss='mean_squared_error', optimizer=optimizer)
    callbacks =[keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]
    history = model.fit(x_train_scaled, y_train,
                       validation_data = (x_valid_scaled, y_valid),
                       epochs=1,
                       callbacks = callbacks)

learning_rates = [1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2]
historys = []
for lr in learning_rates:
    model = keras.models.Sequential([
        keras.layers.Flatten(input_shape = [8]),
        keras.layers.Dense(30, activation='relu'),
        keras.layers.Dense(1)
    ])
    optimizer = keras.optimizers.SGD(lr)
    model.compile(loss='mean_squared_error', optimizer=optimizer)
    callbacks =[keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]
    history = model.fit(x_train_scaled, y_train,
                       validation_data = (x_valid_scaled, y_valid),
                       epochs=20,
                       callbacks = callbacks)
    historys.append(history)
    
for lr, history in zip(learning_rates, historys):
    print("lr", lr)
    plot_learning_curving(history)

2-17 使用sklearn封装keras模型

# 1. 转化为sklearn的model
def build_model(hidden_layers = 1, layer_size = 30, learning_rate = 3e-3):
    model = keras.models.Sequential()
    model.add(keras.layers.Dense(layer_size, activation='relu', 
                   input_shape=x_train_scaled.shape[1:] )) # 
    # 可以将input和第一个隐藏层写到Dense中
    for _ in range(hidden_layers-1):
        model.add(keras.layers.Dense(layer_size, activation='relu'))
    model.add(keras.layers.Dense(1))
    optimizer = keras.optimizers.SGD(learning_rate)
    model.compile(loss='mse', optimizer=optimizer)
    return model

callbacks = [keras.callbacks.EarlyStopping(patience=5, min_delta=1e-2)]
sklearn_model = keras.wrappers.scikit_learn.KerasRegressor(build_fn = build_model)
history = sklearn_model.fit(x_train_scaled, y_train, validation_data = (
                        x_valid_scaled, y_valid),
                         epochs = 10, 
                         callbacks = callbacks)

2-18 sklearn封装的模型进行随机超参数搜索

from scipy.stats import reciprocal
# f(x) = 1/(x*log(b/a)) a <= x <= b
param_distribution = {
    "hidden_layers" : [1,2,3,4],
    "layer_size" : np.arange(1,100),
    "learning_rate" : reciprocal(1e-4, 1e-2)
}
from sklearn.model_selection import RandomizedSearchCV
random_search_cv = RandomizedSearchCV(sklearn_model,
                                     param_distribution,
                                     n_iter = 10,
                                     cv = 3,
                                     n_jobs = 1)  # cv:不写默认为3，将训练集分割成3份，前两份作为训练集，后一份作为cv
                                                        # x_train_scaled 总量11610，下面训练使用7740 ，最后
random_search_cv.fit(x_train_scaled, y_train, 
                                epochs = 100,
                                validation_data = (x_valid_scaled, y_valid),
                                callbacks = callbacks
                    )

print(random_search_cv.best_params_)
print(random_search_cv.best_score_)
print(random_search_cv.best_estimator_)
model = random_search_cv.best_estimator_.model
model.evaluate(x_test_scaled, y_test)x'c
xiaoa~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tensorflow2.0 keras 图片识别
12-03
TensorFlow是Google开发的一个开源机器学习框架，而Keras则是一个高级神经网络API，它运行在TensorFlow之上，简化了深度学习模型的构建过程。这个项目特别关注图片的预处理和可视化，使得初学者能够更直观地理解图像...
#No module named ‘tensorflow_core.keras‘引发的一连串问题
weixin_46946348的博客
04-22 3537
No module named ‘tensorflow_core.keras’，引发的一连串问题，让头发掉得更猛烈些吧~！ 项目场景： 本人在用研究LSTM算法中遇到了bug,当要构建神经网络时出现了这条报错。 问题描述： 运行算法包 import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers 报错信息 ERROR:root:Internal Python error in the in
【TensorFlow】No module named ‘tensorflow_core.keras‘
Smile
10-13 2807
TensorFlow报错： ModuleNotFoundError: No module named ‘tensorflow_core.keras’ 猜测原因可能是自己根据需要才新安装的TensorFlow，和之前的一些依赖版本不匹配，才用重装大法解决问题 pip install --force-reinstall tensorflow 参考自： ModuleNotFoundError: No module named ‘tensorflow_core.keras’ ...
解决AttributeError: module tensorflow_core.keras has no attribute Dense
com_fang_bean的博客
06-05 7409
使用工具是jupyter notebook，按照视频中代码照敲竟然是错的，无语，使用tab键一步步打开方法选择问题才解决，终于找到Dense方法所在地，附上原代码和改正后代码： model.add(tf.keras.Dense(10,activation = 'softmax')) 改正后： model.add(tf.keras.layers.Dense(10,activation = 'softmax')) ...
解决tensorflow错误ModuleNotFoundError: No module named ‘tensorflow_core.keras‘
qq_39635835的博客
07-24 1967
解决解决tensorflow错误ModuleNotFoundError: No module named 'tensorflow_core.keras' tensorflow版本与keras版本不兼容， 在terminal中升级keras版本 // An highlighted block pip install keras --user --upgrade
TensorFlow 2.0深度学习算法实战 第十章 卷积神经网络
猫敷雪
04-04 3332
当前人工智能还未达到人类 5 岁水平，不过在感知方面进步飞快。未来在机器语音、视觉识别领域，五到十年内超越人类没有悬念。−沈向洋 我们已经介绍了神经网络的基础理论、TensorFlow 的使用方法以及最基本的全连接层网络模型，对神经网络有了较为全面、深入的理解。但是对于深度学习，我们尚存一丝疑惑。深度学习的深度是指网络的层数较深，一般有 5 层以上，而目前所介绍的神经网络层数大都实现为 5 层...
TensorFlow2.0(二)–Keras构建神经网络分类模型
12-21
在本教程中，我们将深入探讨如何使用TensorFlow 2.0中的Keras API构建神经网络分类模型。Keras是一个高级神经网络API，它允许开发者快速地实现和实验神经网络架构，而无需关注底层细节。在TensorFlow 2.0中，Keras被...
使用TensorFlow2.0中的Keras实现基于BiLSTM-CRF的NER.zip
04-03
在本项目中，我们将探讨如何使用TensorFlow 2.0中的Keras库来实现一个基于双向长短期记忆网络（BiLSTM）与条件随机场（CRF）的命名实体识别（NER）系统。命名实体识别是自然语言处理（NLP）领域的一个关键任务，它...
TensorFlow2.0(三)–Keras构建神经网络回归模型
01-20
Keras构建神经网络回归模型1. 前言1. 导入相应的库2. 数据导入与处理2.1 加载数据集2.2 划分数据集2.3 数据归一化3. 模型构建与训练3.1 神经网络回归模型的构建3.2 神经网络回归模型的训练3.3 绘制学习曲线4. 模型...
使用TensorFlow2.0中的Keras实现基于BiLSTM-CRF的NER
最新发布
05-21
其中，CRF通过继承tf.keras.layers.Layer来实现，使用方法与其他Keras网络层类似。 另外，还实现了对应的度量指标F1-Score，即metrics.py文件下的IOBESF1类，使用方法与Keras中其他度量指标类似。 其他 数据集：...
Tensorflow2.x.x全卷积神经网络(CNN)
qq_37340753的博客
05-23 813
Tensorflow2.x.x全卷积神经网络(CNN) 本章节主要使用Tensorflow2.x.x来搭建CNN神经网络。 全卷积神经网络原理 引用小伙伴的原理，作者个人理解为卷积层提取特征而已，每一层提取的特征不一样。所以如果需要对模型进行改进的话就可以从对高级特征和低级特征的提取进行优化。 实现 使用CNN实现对MNIST数据集的分类，最后一层不适用Dense尝试。 import tensorflow as tf # mnist数据集 from tensorflow.keras.datasets imp
Tensorflow2——卷积神经网络的搭建
weixin_45392405的博客
05-09 2092
Tensorflow2卷积神经网络的搭建卷积神经网络Fasion_minst识别卷积神经网络搭建代码 卷积神经网络 1、卷积神经网络 CNN最大的特点就是在于卷积的权值共享，利用空间结构减少学习的参数量，防止过拟合的同时减少计算量。在卷积神经网络中，第一个卷积层直接接受图像像素级的输入，卷积之后传给后面的网络，每一层的卷积操作相当于滤波器，对图像进行特征提取，原则上可保证尺度，平移和旋转不变性。 一般的卷积网络包含一下操作： （1）卷积。图像通过不同卷积核卷积并且加偏置（bias），提取局部特征，每一个卷积
【使用 TensorFlow 2.0 构建简单的卷积神经网络 (CNN)】
qq_34718338的博客
01-17 497
卷积神经网络 (CNN) 是深度学习中最常用的网络类型之一，常用于图像分类和识别。在本文中，我们将使用 TensorFlow 2.0 构建一个简单的 CNN 模型，并在 CIFAR-10 数据集上进行训练和评估。
TensorFlow 2keras开发深度学习模型实例：多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN）...
拓端研究室TRL
03-02 230
原文链接：http://tecdat.cn/?p=15850在本文中，您将发现如何使用标准深度学习模型（包括多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN））开发，评估和做出预测（点击文末“阅读原文”获取完整代码数据）。相关视频开发多层感知器模型多层感知器模型（简称MLP）是标准的全连接神经网络模型。它由节点层组成，其中每个节点连接到上一层的所有输出，每个节点的输出连接到下一层...
tebsorflow2.0 卷积神经网络的实现实例
安静到无声
05-08 1071
本实例主要介绍 利用tf.data读取图片的方法 卷积神经网络的构建 训练以及测试 1. 数据集介绍 本文的应用场景是对于卫星图片数据的分类，图片总共1400张，分为airplane和lake两类，也就是一个二分类的问题，所有的图片已经分别放置在2_class文件夹下的两个子文件夹中。数据集–提取码：7qb0 2. 加载图片 在该过程主要分为两个部分，第一个步骤是读取文件所在的路径，第二个步骤...
用Tensorflow2搭建经典的卷积神经网络（LeNet,AlexNet,VGG16,ResNet50）
QianLong_的博客
06-18 1356
最近看了卷积神经网络的一些经典论文，用Tensorflow2进行了复现，其中包括LeNet,AlexNet,VGG16,ResNet50,并且在数据集上进行了测试，能够正常训练，结果表明搭建的没有问题。 下面进入正题： import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np import matplotlib.pyplot as plt %matpl
tensorflow2.0之卷积神经网络
qq_44971458的博客
07-04 2153
tf.keras实现卷积神经网络 Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。 Keras可以很明确的定义了层的概念，反过来层与层之间的参数反倒是用户不需要关心的对象，所以构建神经网络的方法对于普通开发者来说，相对tensorflow，Keras更易上手。 并且Keras也是tensorflow官方在tensorflow2.0开始极力推荐使用的。 卷积神经网络（Convolutional Neural Ne
【深度学习】利用tensorflow2.0卷积神经网络进行卫星图片分类实例操作详解
lys_828的博客
09-25 4085
本文的应用场景是对于卫星图片数据的分类，图片总共1400张，分为airplane和lake两类，也就是一个二分类的问题，所有的图片已经分别放置在2_class文件夹下的两个子文件夹中。下面将从这个实例的详细拆解中，理解tensorflow2.0对于数据的处理过程。文章的案例数据和代码附在最后，通过点解链接可以直接在gothub上获取。 1 导入库 import tensorflow as t...
TensorFlow 2.0 keras开发深度学习模型实例：多层感知器（MLP），卷积神经网络（CNN）和递归神经网络（RNN）
拓端研究室TRL
01-24 699
最近我们被客户要求撰写关于TensorFlow的研究报告，包括一些图形和统计输出。
tensorflow2.0对应keras版本
03-25
TensorFlow 2.0 对应的 Keras 版本是 Keras 2.3.0 及以上版本。在 TensorFlow 2.0 中，Keras 已经成为了 TensorFlow 的默认...如果你使用的是 TensorFlow 2.0，那么你只需要 import tensorflow.keras 来使用 Keras。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值