Keras入门+简单实践例题

最新推荐文章于 2024-07-23 22:38:20 发布
最新推荐文章于 2024-07-23 22:38:20 发布
阅读量1.2k 收藏 15
点赞数 1
分类专栏： ML-learning 文章标签： 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamingnini/article/details/111320004
版权

目录

 

线性回归：

非线性回归：

MNIST数据集分类：

loss---交叉熵

添加隐藏层

使用Dropout后：

正则化：如果模型很适合就不需要正则化和Dropout

7.优化器 Adam

8.CNN手写数字识别

9.RNN应用

​10.模型保存 默认在当前路径

11.载入模型

线性回归：

加噪音后再回归预测

 

import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

#使用numpy随机生成100个点
x_data = np.random.rand(100)
noise = np.random.normal(0, 0.02, x_data.shape)
y_data = x_data*0.1 + 0.2 + noise

#打印
plt.scatter(x_data, y_data)
plt.show()

 

import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

#使用numpy随机生成100个点
x_data = np.random.rand(100)
noise = np.random.normal(0, 0.02, x_data.shape)
y_data = x_data*0.1 + 0.2 + noise

#打印
# plt.scatter(x_data, y_data)
# plt.show()

#构建顺序模型
model = Sequential()
#在模型中添加一个全连接层
model.add(Dense(units=1, input_dim=1))
model.compile(optimizer='sgd', loss='mse')

#一次在模型中放入一个批次 循环3001次
for step in range(3001):
    #数据量小  全放进去
    cost = model.train_on_batch(x_data, y_data)
    #每500个batch打印一次cost值
    if step % 5 == 0:
        print('cost:', cost)
#打印权值和偏置值
w, b = model.layers[0].get_weights()
print('W:', w, 'b:', b)

#x_data输入网络中，得到预测值y_pred
y_predict = model.predict(x_data)

#打印
plt.scatter(x_data,y_data)
plt.scatter(x_data, y_predict, c='red')

plt.show()

非线性回归：

线性回归不能很好的拟合数据

import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

#-0.5  0.5  之间均匀分布的200个点
x_data = np.linspace(-0.5, 0.5, 200)
noise = np.random.normal(0,0.02,x_data.shape)
y_data = np.square(x_data) + noise

#打印
plt.scatter(x_data,y_data)
plt.show()

import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense

#-0.5  0.5  之间均匀分布的200个点
x_data = np.linspace(-0.5, 0.5, 200)
noise = np.random.normal(0,0.02,x_data.shape)
y_data = np.square(x_data) + noise

#打印
# plt.scatter(x_data,y_data)
# plt.show()

#构建顺序模型
model = Sequential()
#在模型中添加一个全连接层
model.add(Dense(units=1, input_dim=1))
model.compile(optimizer='sgd', loss='mse')

#一次在模型中放入一个批次 循环3001次
for step in range(3001):
    #数据量小  全放进去
    cost = model.train_on_batch(x_data, y_data)
    #每500个batch打印一次cost值
    if step % 500 == 0:
        print('cost:', cost)
#打印权值和偏置值
w, b = model.layers[0].get_weights()
print('W:', w, 'b:', b)

#x_data输入网络中，得到预测值y_pred
y_predict = model.predict(x_data)

#打印
plt.scatter(x_data,y_data)
plt.scatter(x_data, y_predict, c='red')

plt.show()

 

 

import keras
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
#-0.5  0.5  之间均匀分布的200个点
x_data = np.linspace(-0.5, 0.5, 200)
noise = np.random.normal(0,0.02,x_data.shape)
y_data = np.square(x_data) + noise

#打印
# plt.scatter(x_data,y_data)
# plt.show()

#构建顺序模型
model = Sequential()
#在模型中添加一个全连接层
#1-10-1
model.add(Dense(units=10, input_dim=1))
model.add(Activation('tanh'))
#不设置默认上一层的输出时这一层的输入维度10
model.add(Dense(units=1))
model.add(Activation('tanh'))

#定义优化算法
sgd = SGD(lr=0.3)
#sed 随机梯度下降
#mse 均方误差
model.compile(optimizer=sgd, loss='mse')

#一次在模型中放入一个批次 循环3001次
for step in range(3001):
    #数据量小  全放进去
    cost = model.train_on_batch(x_data, y_data)
    #每500个batch打印一次cost值
    if step % 500 == 0:
        print('cost:', cost)
#打印权值和偏置值
w, b = model.layers[0].get_weights()
print('W:', w, 'b:', b)

#x_data输入网络中，得到预测值y_pred
y_predict = model.predict(x_data)

#打印
plt.scatter(x_data, y_data)
plt.scatter(x_data, y_predict, c='red')

plt.show()

MNIST数据集分类：

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)

 

 

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=10, input_dim=784, bias_initializer='one', activation='softmax')
 ])
#定义优化器 loss function
sgd = SGD(lr=0.2)
model.compile(
    optimizer=sgd,
    loss='mse',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

loss---交叉熵

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=10, input_dim=784, bias_initializer='one', activation='softmax')
 ])
#定义优化器 loss function
sgd = SGD(lr=0.2)
model.compile(
    optimizer=sgd,
    #交叉熵分类问题准确率提升  收敛速度快
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

添加隐藏层

trian训练集的准确率很高

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import SGD

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=200, input_dim=784, bias_initializer='one', activation='tanh'),
    Dense(units=100, bias_initializer='one', activation='tanh'),
    Dense(units=10, bias_initializer='one', activation='softmax')
 ])
#定义优化器 loss function
sgd = SGD(lr=0.2)
model.compile(
    optimizer=sgd,
    #交叉熵分类问题准确率提升  收敛速度快
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

loss,accuracy = model.evaluate(x_train, y_train)
print('\ntrain loss', loss)
print('train accuracy', accuracy)

结果：

使用Dropout后：

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import SGD

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=200, input_dim=784, bias_initializer='one', activation='tanh'),
    #40%神经元不工作
    Dropout(0.4),
    Dense(units=100, bias_initializer='one', activation='tanh'),
    Dropout(0.4),
    Dense(units=10, bias_initializer='one', activation='softmax')
 ])
#定义优化器 loss function
sgd = SGD(lr=0.2)
model.compile(
    optimizer=sgd,
    #交叉熵分类问题准确率提升  收敛速度快
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

loss,accuracy = model.evaluate(x_train, y_train)
print('\ntrain loss', loss)
print('train accuracy', accuracy)

结果：

正则化：如果模型很适合就不需要正则化和Dropout

from keras.regularizers import l2
Dense(units=200, input_dim=784, bias_initializer='one', activation='tanh',kernel_regularizer=l2(0.0003)),
import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from keras.regularizers import l2

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=200, input_dim=784, bias_initializer='one', activation='tanh',kernel_regularizer=l2(0.0003)),

    Dense(units=100, bias_initializer='one', activation='tanh',kernel_regularizer=l2(0.0003)),

    Dense(units=10, bias_initializer='one', activation='softmax',kernel_regularizer=l2(0.0003))
 ])
#定义优化器 loss function
sgd = SGD(lr=0.2)
model.compile(
    optimizer=sgd,
    #交叉熵分类问题准确率提升  收敛速度快
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

loss,accuracy = model.evaluate(x_train, y_train)
print('\ntrain loss', loss)
print('train accuracy', accuracy)

结果：

7.优化器 Adam

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD,Adam

#载入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data()
#(60000,28,28)
print('x_shape:', x_train.shape)
print('y_shape:', y_train.shape)
#(60000,28,28)->(60000,784)
x_train = x_train.reshape(x_train.shape[0], -1)/255.0
x_test = x_test.reshape(x_test.shape[0], -1)/255.0
#换one hot格式
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#创建模型：输入784个神经元  输出10个神经元
model = Sequential([
    Dense(units=10, input_dim=784, bias_initializer='one', activation='softmax')
 ])
#定义优化器 loss function 训练过程中计算准确率
sgd = SGD(lr=0.2)
#lr学习率
adam = Adam(lr=0.001)
model.compile(
    optimizer=adam,
    #交叉熵分类问题准确率提升  收敛速度快
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

#训练模型 60000 每次取32个 为一个epoch 运行10次
model.fit(x_train,  y_train, batch_size=32, epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test, y_test)
print('\ntest loss', loss)
print('accuracy', accuracy)

结果：

8.CNN手写数字识别

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense,Dropout,Convolution2D,MaxPooling2D,Flatten
from keras.optimizers import SGD,Adam
#py3.8
#载入数据
(x_train,y_train),(x_test,y_test) = mnist.load_data()
#(60000,28,28)--->(60000,28,28,1)  个数  长  宽  深度1黑白  彩色是3
#归一化0-1之间 所以除以255
x_train = x_train.reshape(-1, 28, 28, 1)/255.0
x_test = x_test.reshape(-1, 28, 28, 1)/255.0
#换one hot格式
#将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵,
# 用于应用到以categorical_crossentropy为目标函数的模型中.
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)
#定义顺序模型
model = Sequential()

#第一个卷积层
#input_shape输入平面
#filters 卷积核/滤波器个数
#kernel_size 卷积窗口大小
#strides步长
#padding 方式
#activation 激活函数
model.add(Convolution2D(
    input_shape=(28, 28, 1),
    filters=32,
    kernel_size=5,
    strides=1,
    padding='same',
    activation='relu'
))
#第一个池化层
model.add(MaxPooling2D(
    pool_size=2,
    strides=2,
    padding='same',

))
#第二个卷积层
model.add(Convolution2D(64, 5, strides=1, padding='same', activation='relu'))
#第二个池化层
model.add(MaxPooling2D(2,2,'same'))
#把第二个池化层输出扁平化为1维
model.add(Flatten())
#第一个全连接层
model.add(Dense(1024,activation='relu'))
#Dropout
model.add(Dropout(0.5))
#第二个全连接层
model.add(Dense(10,activation='softmax'))

#定义优化器
adam = Adam(lr=1e-4)
#定义优化器 loss function 训练过程中计算准确率
model.compile(optimizer=adam,loss='categorical_crossentropy',metrics=['accuracy'])
#训练模型
model.fit(x_train,y_train,batch_size=64,epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test,y_test)

print('test loss',loss)
print('test accuracy',accuracy)

效果：

9.RNN应用

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense,Dropout,Convolution2D,MaxPooling2D,Flatten
from keras.layers.recurrent import SimpleRNN,LSTM,GRU
from keras.optimizers import SGD,Adam

#数据长度一行有28个像素
input_size = 28
#序列长度一共有28行,所以28*28
time_steps = 28
#隐藏层cell个数
cell_size = 50
#载入数据
(x_train,y_train),(x_test,y_test) = mnist.load_data()
#样本数  time_steps,input_size
#（60000,28,28)
x_train = x_train/255
y_train = y_train/255
#换one hot
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)
#创建模型
model = Sequential()
#循环神经网络
model.add(SimpleRNN(
    units=cell_size,#输出
    input_shape=(time_steps,input_size),#输入

))
#输出层
model.add(Dense(10,activation='softmax'))

#定义优化器
adam=Adam(lr=1e-4)

#定义优化器 loss function 训练总过程中计算准确率
model.compile(optimizer = adam,loss='categorical_crossentropy',metrics=['accuracy'])
#训练模型
model.fit(x_train,y_train,batch_size=64,epochs=10)
#评估模型
loss,accuracy = model.evaluate(x_test,y_test)

print('test loss',loss)
print('test accuracy',accuracy)

效果：。。。。。。过拟合了


10.模型保存 默认在当前路径

#保存模型 添加最后
#HDF5文件 pip install h5py
model.save('model.h5')

11.载入模型

from keras.models import load_model
#载入模型
model = load_model('model.h5')
import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense,Dropout,Convolution2D,MaxPooling2D,Flatten
from keras.optimizers import SGD,Adam

from keras.models import load_model

#py3.8
#载入数据
(x_train,y_train),(x_test,y_test) = mnist.load_data()
#(60000,28,28)--->(60000,28,28,1)  个数  长  宽  深度1黑白  彩色是3
#归一化0-1之间 所以除以255
x_train = x_train.reshape(-1, 28, 28, 1)/255.0
x_test = x_test.reshape(-1, 28, 28, 1)/255.0
#换one hot格式
#将类别向量(从0到nb_classes的整数向量)映射为二值类别矩阵,
# 用于应用到以categorical_crossentropy为目标函数的模型中.
y_train = np_utils.to_categorical(y_train, num_classes=10)
y_test = np_utils.to_categorical(y_test, num_classes=10)

#载入模型
model = load_model('model.h5')
#评估模型
loss,accuracy = model.evaluate(x_test,y_test)

print('test loss',loss)
print('test accuracy',accuracy)



#保存模型
#HDF5文件 pip install h5py
model.save('model.h5')
#保存参数，载入参数
model.save_weights('my_model_weights.h5')
model.load_weights('my_model_weights.h5')
#保存网络结构，载入网络结构
from keras.models import model_from_json
json_string = model.to_json()
model = model_from_json(json_string)

print(json_string)

 

Dreamingnini
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
人工智能、机器学习、深度学习从入门到进阶学习资料整理
the_cleaner的博客
04-01 697
AI方面的学习资料，包含了学习社区、入门教程、汲取学习、深度学习、自然语言处理、计算机视觉、数据分析、面试和书籍等方面的知识。
机器学习、深度学习、神经网络学习资料集合(开发必备)
henhenha的博客
04-01 614
AI方面的学习资料，包含了学习社区、入门教程、汲取学习、深度学习、自然语言处理、计算机视觉、数据分析、面试和书籍等方面的知识。
python编程从入门到实践django-首页
weixin_37988176的博客
10-30 278
[英]马克·阿姆斯特朗孙以丰译本书是一部拓扑学入门书。作者主要介绍了拓扑空间中的拓扑不变量，以及相应的计算方法。本书涉及点集拓扑、几何拓扑、...[德]达恩·巴德尔（Dan Bader）本书致力于帮助Python开发人员挖掘这门语言及相关程序库的优秀特性，避免重复劳动，同时写出简洁、流畅、易读、...结城浩丛熙江志强译《数学女孩》系列以小说的形式展开，重点描述一群年轻人探寻数学中的美。内容由浅入深...
01：神经网络tensorflow入门案例
qq_63119830的博客
02-18 573
人工神经网络（ANN）人工神经网络是深度学习的核心，他们用途广泛，功能强大且可扩展，使其非常适合大型和高度复杂的机器学习任务高度复杂的计算可以通过相当简单的神经元网络来执行，生物神经网络（BNN）的架构仍然是活跃的主题人工神经元的逻辑计算—就是人工神经元的计算基本单元单层感知器（TLU）–注意是单层，而不是一个 就是只有一行TLU的人工神经元，这一行可以有多个TLU也可以只有一个TLU，这样都叫做单层 通过上面的小案例我们可以知道，感知器的学习算法非常类似于随机梯度下降，实际上perceptron类等效
【剑指offer】高频ML/DL面试题
发现问题，并解决问题，批判性思维
05-25 8491
代码层面： 完成强化学习算法（CPG PPO A3C Q-learning DQN）在贪吃蛇环境的应用（即作出控制贪吃蛇的智能体） 在github上找到对应算法的代码并跑通代码 阅读理解代码的实现逻辑，对代码中用到的重要函数查阅和理解 对算法的调试和优化，使贪吃蛇智能体取得更好的分数 理论层面 阅读并理解五大算法的论文（需配合贪吃蛇代码的完成顺序） 对分布式相关知识的学习：按顺序完成学习A3C DPPO IMPALA seed-rl的论文及其相关文章 成果验收 （1）考察智能体在贪吃蛇的得分 三个算.
知识体系结构---备份
Major_S的博客
11-26 661
python基础-》机器学习-》机器学习实战+深度学习框架+深度学习 目前的学习方法的话就是----》看看理论以后，跑跑实验，熟悉熟悉代码 1 常见工程、应用、学习错误与安装问题与实用技巧 2 知识体系结构（副） 3 日常安排 4 论文研究 5 吃生活 知识体系结构 1. 数学基础 2. 计算机基础 3. 计算机语言基础 4. 数据库基础 5. 数字图像处理理论基础 6...
python神经网络编程 代码,python神经网络编程 豆瓣
aifamao6的博客
08-20 867
segmentfault：一家以编程问答为主的网站;下面是Python全栈开发+人工智能的培训内容：阶段一：Python开发基础Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。阶段二：Python高级编程和数据库开发Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。
python教程书籍-python教程书籍
weixin_37988176的博客
11-01 268
广告关闭腾讯云双11爆品提前享，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高满返5000元！keras作者、谷歌大脑franoischollet最新撰写的深度学习python教程实战书籍（2017年12月出版）介绍深入学习使用python语言和强大keras库，详实新颖。 这本书让你通过直观的解释和实例学习深度学习，不得不看。 请关注专知公众号后台回复“dlpy” 就可以获取...
"数据科学概论"课程设计
weixin_45585364的博客
04-11 1146
"数据科学概论"课程设计覃雄派1, 陈跃国1, 杜小勇1, 王伟娟21. 中国人民大学信息学院，北京 1008722. 中国人民大学出版社，北京 100872摘要：数据...
基于Keras框架+Bert开放领域的关系抽取项目源代码+使用说明.zip
06-22
基于Keras框架+Bert开放领域的关系抽取项目源代码+使用说明.zip基于Keras框架+Bert开放领域的关系抽取项目源代码+使用说明.zip基于Keras框架+Bert开放领域的关系抽取项目源代码+使用说明.zip基于Keras框架+Bert开放...
深度学习keras快速入门+tensorflow&keras;深度学习+python数值分析基础.rar
09-05
在“深度学习keras快速入门”部分，你将学习如何使用 Keras 创建基本的神经网络模型，包括卷积神经网络（CNN）和循环神经网络（RNN），以及如何进行模型训练、验证和评估。 TensorFlow 是由 Google 开发的一个开源...
基于keras框架+LSTM或者GRU的音乐生成python源码+文档说明
02-14
采用了keras框架，音乐数据读写采用了python的midi库 不加入Lsystem系统时， 可生成音乐序列 加入Lsystem， 生成和弦分解序列 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试...
基于深度学习的草莓成熟度实时检测系统（UI界面+YOLOv8/v7/v6/v5模型+完整代码与数据集）
a871923942的博客
07-22 507
使用YOLO模型进行草莓成熟度检测。构建一个简单的用户界面，允许用户上传草莓图片，并显示检测结果。提供完整的代码示例和训练数据集。目录1. 引言2. 项目概述3. 环境配置4. 数据集准备5. 模型训练6. 构建UI界面7. 部署与测试8. 结论与声明。
**卷积神经网络典型CNN**
HP2LF的博客
07-23 1134
SeNet(Squeeze-and-Excitation Networks)是ImageNet 2017年分类任务冠军，核心思想是：Squeeze(挤压、压缩)和Excitation(激励)两个操作，其主要目的是通过显示的构建特征通道之间的相互依赖关系，采用特征重定向的策略，通过学习的方式自动的获取每个特征通道的重要程度，然后依据***这个重要程度去提升有用的特征，并抑制对于当前任务用处不大的特征。Squeeze特征压缩操作，将每个feature map的特征数据使用全局平均池化操作转换为一个数值(实数)，
智能路面裂缝检测：基于YOLO和深度学习的全流程实现
最新发布
a871923942的博客
07-23 451
引言路面裂缝检测是维护道路质量和延长道路寿命的重要手段。传统的检测方法往往费时费力且易受人为因素影响。为了提高检测效率和准确性，本文介绍了一种基于深度学习的路面裂缝检测系统。该系统包括用户界面，利用YOLO（You Only Look Once）v8/v7/v6/v5模型进行路面裂缝检测，并提供了完整的实现步骤和详细代码。
长短期记忆网络（LSTM）及其Python和MATLAB实现
qq_45441438的博客
07-22 811
3. 输入门计算：输入门的计算包括两部分，一部分是将上一个时间步的隐藏状态与当前时间步的输入特征拼接后通过两个全连接层分别计算出sigmoid 激活函数和 tanh 激活函数的输出，另一部分是将这两个输出相乘后输出输入门的值。2. 遗忘门计算：遗忘门的计算包括两部分，一部分是将上一个时间步的隐藏状态与当前时间步的输入特征拼接后通过一个全连接层得到一个向量，另一部分是经过一个 sigmoid 激活函数后输出遗忘门的值。6. 更新隐藏状态：根据记忆单元状态和输出门的值计算出下一个时间步的隐藏状态。
python keras cnn+lstm
09-07
Python是一种高级编程语言，Keras是一个用于构建神经网络模型的深度学习库，CNN代表卷积神经网络，LSTM代表长短期记忆。Python的流行性使得它成为使用Keras库构建神经网络模型的理想选择。 卷积神经网络（CNN）是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值