2018-02-06 18:21:19 oHanTanYanYing 阅读数 1517
  • Fast.ai 深度学习实战课程「中文字幕」

    本课程由 Jeremy Howard 教授开设,共8节。目的是让大家在不需要深入研究高水平数学问题的情况下,学习如何建立先进的深度学习模型。 Jeremy Howard 教授结合自己参加 Kaggle 大赛并夺魁的经验认为,传统学院派的教学方式对于大多数学习者来说已经不适用,应该以问题为引导,以实践为驱动,尽快切入到核心理论和核心工具的使用上,掌握深度学习优模型的构建方法。

    16204 人正在学习 去看看 AI100讲师

  自从意识到深度学习是未来之后,自己看了相关的书籍三本,看了吴恩达和李飞飞两位神级人物的课程,配置了caffe,torch,pytorch等等开源架构,也跑了几个开源工程,却始终都感觉似懂非懂,实在是糟心。
  经过了严肃认真的思考后,本人决定从最底层开始,自己写一个架构,进而可以深入了解深度学习的方方面面。
  本篇作为系列文章的开篇总览,目的就是给自己挖个坑,以提醒自己要好好努力。并且也给这一系列文章定出规则,以时时回望。
  因为本人最熟悉的是C++,所以会用C++实现一个架构。另外python作为机器学习的近乎官方语言,在这一系列文章中也会实现一个架构。最后,本人最喜欢pytorch架构,也会用其实现想要做的东西(分成cpu和gpu两个版本)。
  因此,本系列每篇文章将涉及到的内容如下:


  1. 原理的理解(其中有可能大部分都借鉴网上优秀的博客或者书籍中的内容,因而如有雷霆,是本人抄的。但绝非不过脑子的抄,当然也会标明出处)
  2. C++实现
  3. python实现
  4. pytorch的CPU实现
  5. pytorch的GPU实现

  需要说明一下的是本人自行实现的代码(也有可能借鉴别人)书写肯定受限于本人水平,几乎不可能有现成架构的效率和规范,只作为本人练习之用。工程中本人将用成熟的框架进行,这也才有了4,5点。
  如果有看本人之前写的一些博文可能会觉得很多只讲实现没讲原理,那是因为相关内容本人在工程中用到于是就快速实现出来,有些原理本人也不知道。但这一系列本人将力求做到自己透彻理解,并把涉及到的原理认真仔细的整理出来。
  那么预告一下下一篇,深度学习1—最简单的全连接神经网络

2018-10-03 21:56:07 weixin_42749767 阅读数 5082
  • Fast.ai 深度学习实战课程「中文字幕」

    本课程由 Jeremy Howard 教授开设,共8节。目的是让大家在不需要深入研究高水平数学问题的情况下,学习如何建立先进的深度学习模型。 Jeremy Howard 教授结合自己参加 Kaggle 大赛并夺魁的经验认为,传统学院派的教学方式对于大多数学习者来说已经不适用,应该以问题为引导,以实践为驱动,尽快切入到核心理论和核心工具的使用上,掌握深度学习优模型的构建方法。

    16204 人正在学习 去看看 AI100讲师

背景


最近实验室要参加一个目标检测的比赛,这段时间一直在跑ssd模型,最开始根据作者给的文档成功编译后,可以在VOC数据集上进行训练。由于要用比赛官方的数据集,因此做了几天的数据集,然后拿自己的数据集训练的时候,出现了以下报错:Check failed: a <= b (0 vs. -1.192093-07)

在这里插入图片描述

去网上搜了相关的解决方法,全都是说把math_functions.cpp第250行注释掉,重新编译,这种方案一看就不靠谱,而且也没人说个所以然,但是还是抱着试一试的心态照做了,果然又出现了新的bug。查了几天的资料也没找到解决方案,一开始我怀疑可能是我的数据集做的有问题,然后我又重新在VOC数据集上训练,结果会出现同样的问题,联想到前两天实验室服务器重装了系统,然后cuda从8.0换到了9.1版本,会不会是这个原因导致了现在的报错呢?但是因为实验室服务器是大家共用的,把cuda改回到8.0版本可能给其他人带来困扰,刚好实验室有其他同学在搞nvidia docker,干脆直接用nvidia docker来跑模型,就不用考虑环境问题了。

什么是nvidia docker


介绍nvidia docker之前,首先要了解什么是docker。

Docker 是一个开源的应用容器引擎,基于 GO语言并遵从Apache2.0协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux 机器上,可以实现虚拟化。

Docker所代表的容器虚拟化技术属于操作系统级虚拟化:内核通过创建多个虚拟的操作系统实例(内核和库)来隔离不同的进程。并且传统虚拟化技术是在硬件层面实现虚拟化,增加了系统调用链路的环节,有性能损耗;容器虚拟化技术以共享Kernel的方式实现,几乎没有性能损耗。

这里可以将容器理解为一种沙盒。每个容器内运行一个应用,不同的容器相互隔离,容器之间可以建立通信机制。容器的创建和停止都十分快速(秒级),容器自身对资源的需求十分有限,远比虚拟机本身占用的资源少。

关于Docker更详细的介绍,请参照几张图帮你理解docker基本原理及快速入门,感觉介绍的很不错

docker一般服务于基于cpu 的应用,而我们的深度学习模型是跑在gpu上面的,因此需要用nvidia docker。nvidia docker的运行需要基于一定的硬件环境,需要安装nvidia driver,docker容器本身并不支持nvidia gpu。最开始的解决方法是在容器内部安装nvidia driver,然后通过设置相应的设备参数来启动container,但是这样做带来一个弊端就是可能导致image无法共享,因为宿主机的driver的版本必须完全匹配容器内的driver版本,很可能本地机器的不一致导致每台机器都需要去重复操作,这很大的违背了docker的初衷。nvidia docker实际上是一个docker plugin,它在docker上做了一层封装,对docker进行调用,类似一个守护进程,发现宿主机驱动文件以及gpu 设备,并且将这些挂载到来自docker守护进程的请求中,以此来支持docker gpu的使用。

安装docker


  1. GPU driver安装

nvidia官网下载安装对应型号的显卡驱动:链接
如果安装成功,在终端中输入 lspci | grep -i nvidia ,会显示自己的NVIDIA GPU版本信息

  1. CUDA安装

实验室服务器是ubuntu 18.04版本,可以直接sudo apt install nvidia-cuda-toolkit安装

  1. docker安装
  • 安装必要的一些系统工具
sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common
  • 安装GPG证书
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
  • 写入软件源信息
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
  • 更新并安装 docker-ce
sudo apt-get -y update
sudo apt-get -y install docker-ce
  • 验证
sudo service docker status 			#或者sudo systemctl status service.docker 检查Docker服务的状态 
sudo docker run hello-world			#测试Docker安装是否成功

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

  1. nvidia-docker安装
  • 如果之前安装过docker1.0版本,需要先删掉该版本和之前创建的容器
docker volume ls -q -f driver=nvidia-docker | xargs -r -I{} -n1 docker ps -q -a -f volume={} | xargs -r docker rm -f
sudo apt-get purge -y nvidia-docker
  • 添加代码仓库
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | \
sudo apt-key add -
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update
  • 安装docker 2
sudo apt-get install -y nvidia-docker2
sudo pkill -SIGHUP dockerd
  • 测试
docker run --runtime=nvidia --rm nvidia/cuda:9.0-base nvidia-smi
  1. 安装过程中遇到的问题

网上有的教程会设置阿里云加速器,是因为官方Docker Hub网络速度较慢,所以使用阿里云提供的Docker Hub,然后需要配置阿里云加速器。具体步骤如下:

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-‘EOF’ 
{ 
   “registry-mirrors”: [“https://fird1mfg.mirror.aliyuncs.com“] 
} 
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

结果我在重启docker服务的时候,产生了如下报错:

docker.service - LSB: Create lightweight, portable, self-sufficient containers
Loaded: loaded (/etc/init.d/docker; generated)
Active: failed (Result: exit-code) since Wed 2018-09-26 10:11:16 CST; 28s ago
Docs: man:systemd-sysv-generator(8)
Process: 18639 ExecStart=/etc/init.d/docker start (code=exited, status=1/FAILULURE)
Main PID: 15621 (code=exited, status=1/FAILURE)

9月 26 10:11:16 archlab-X10DRG systemd[1]: Starting LSB: Create lightweight, portable, self-sufficient containers....
9月 26 10:11:16 archlab-X10DRG docker[18639]:  * /usr/bin/dockerd not present or not executable
9月 26 10:11:16 archlab-X10DRG systemd[1]: docker.service: Control process exited, code=exited status=1
9月 26 10:11:16 archlab-X10DRG systemd[1]: docker.service: Failed with result 'exit-code'.
9月 26 10:11:16 archlab-X10DRG systemd[1]: Failed to start LSB: Create lightweight, portable, self-sufficient containers

根绝报错的第二行,发现是dockerd除了问题,dockerd是docker的守护进程,现在提示不存在或不可用,然后我执行了sudo dockerd,打印出了以下报错信息

unable to configure the Docker daemon with file /etc/docker/daemon.json: invalid character ‘h’ after object key

这说明docker的配置文件除了问题,打开daemon.json文件,果然发现刚才设置阿里云加速器的时候,写入的语句有问题,应该是我直接复制粘贴导致的问题,改正之后docker服务可以正常启动了。

用nvidia docker进行训练


  1. 拉取镜像(这里拉取了阿里云的一个镜像,里面自带了编译好的caffe,不过由于在实验室的宿主机上已经有编译好的caffe,可以直接将宿主机的目录挂载到容器中,这个后面有说)
sudo nvidia-docker pull registry.cn-hangzhou.aliyuncs.com/docker_learning_aliyun/caffe:v1
  1. 查看拉取的镜像信息
sudo nvidia-docker images

在这里插入图片描述

  1. 利用拉取的镜像启动容器,并把宿主机的caffe目录挂载到容器上
sudo nvidia-docker run -it –v $CAFFE_ROOT:/workspace 4e33(镜像id前4位即可)/bin/bash

这样就启动了一个容器,并且把caffe目录挂载到了容器的/workspace下。这样操作的好处是,训练完的数据可以直接存放在宿主机,省略了从容器中拷贝的繁琐步骤。

剩下的就是将caffe模型跑起来等待结果就可以了。

2018-05-06 15:42:26 mohuak 阅读数 422
  • Fast.ai 深度学习实战课程「中文字幕」

    本课程由 Jeremy Howard 教授开设,共8节。目的是让大家在不需要深入研究高水平数学问题的情况下,学习如何建立先进的深度学习模型。 Jeremy Howard 教授结合自己参加 Kaggle 大赛并夺魁的经验认为,传统学院派的教学方式对于大多数学习者来说已经不适用,应该以问题为引导,以实践为驱动,尽快切入到核心理论和核心工具的使用上,掌握深度学习优模型的构建方法。

    16204 人正在学习 去看看 AI100讲师

深度学习实训周报

1、Grad-CAM(Gradient-weighted Class Activation Mapping)

Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization

GAM

这次的任务 主要是跑代码和理解Grad CAM,通过训练和测试猫和狗的图片集,并且对这些图片进行辨别,可以分辨出哪些是猫哪些是狗。
如:
这里写图片描述这里写图片描述
这里写图片描述这里写图片描述

然后跑了一下Grad-CAM的代码,大概如下,然后查看照片,亦和上图一样。

这里写图片描述


还有另外一份关于Grad-CAM的github。

大致模型如下,

跑了代码之后,产生如下结果,
test.jpg
这里写图片描述
result.jpg

这里写图片描述
很清晰地划分出了人所在的部分。

2.对抗攻击和防守(Adversarial Attacks and Defenses)

初步了解

一副图片,经过识别之后,判定为Alps,但是经过一些噪点处理过后,却被判别器判定为Dog而且其精确度极高,这就是对抗攻击的一个简单的例子,同时也是对抗攻击实现的结果。
这里写图片描述

攻击方法(白盒攻击和黑盒攻击)

白盒攻击
攻击者能够获知机器学习所使用的算法,以及算法所使用的参数。攻击者在产生对抗性攻击数据的过程中能够与机器学习的系统有所交互。

黑盒攻击
攻击者并不知道机器学习所使用的算法和参数,但攻击者仍能与机器学习的系统有所交互,比如可以通过传入任意输入观察输出,判断输出。

这里写图片描述

防守方法(黑盒防守和白盒防守)

黑盒攻击防御策略:训练其他的分类器来检测对抗输入。

白盒攻击防御策略:实行对抗训练程序。

黑盒攻击防御策略不仅可以帮助防止过度拟合,让分类器的鲁棒性变强,还可以让你的模型加速收敛。但是根据最近的研究结果,这也不能消除所有对抗攻击带来的问题。而且,增加一个分类器也会大大降低分类效率,实现这两个分类器也要求你具备更多 GANs 的经验,因此这种解决方案都不是最优的。

2016-11-11 13:34:16 skyinmoon 阅读数 9584
  • Fast.ai 深度学习实战课程「中文字幕」

    本课程由 Jeremy Howard 教授开设,共8节。目的是让大家在不需要深入研究高水平数学问题的情况下,学习如何建立先进的深度学习模型。 Jeremy Howard 教授结合自己参加 Kaggle 大赛并夺魁的经验认为,传统学院派的教学方式对于大多数学习者来说已经不适用,应该以问题为引导,以实践为驱动,尽快切入到核心理论和核心工具的使用上,掌握深度学习优模型的构建方法。

    16204 人正在学习 去看看 AI100讲师

     mxnet是一个深度学习的框架,我们可以在上面运行我们所需要的神经网络及各种深度学习的东西。这里总结一下在ubuntu上安装mxnet以及怎么使用我们自己的数据让mxnet跑起来。很遗憾的是我们的电脑gpu还不能用,只能先讲用cpu的。网上有很多关于这类的东西,我也看了很多,但感觉只有总结后才是自己的东西,不然看过之后不久又忘得干干净净。

    (1)基本依赖安装

           sudo apt-get update

           sudo apt-get install -y build-essential git libblas-dev libopencv-dev

    (2)从github下载mxnet

           git clone --recursive https://github.com/dmlc/mxnet

    (3)用python编译(用于在python上开发,import mxnet as mx)

         cd python  (切换到mxnet里的python文件夹)

         python setup.py install

     (4)上面是基本步骤,如果有需要,还要安装numpy,scipy,sklean,matplotlib,opencv,setuptools,用gpu的话,要安装cuda,然后make -j4(4核是-j4,8核是-j8)


       安装好后,mxnet/examples里有很多可以测试的例子,比如运行python train_minst.py.接下来最重要的是用我们自己的数据进行神经网络的训练。有几个步骤,

        (1)先将我们要训练的数据放在不同的文件夹里,每个文件夹代表不同的分类,就是labels

          (2) 生成.lst文本,用于数据的索引

                            python im2rec.py --list  ../histcut6/cut6  ../histcut6  --recursive=true         #--list指生成.lst文件,../histcut6/cut6指生成.lst的位置和前缀名,../histcut6指原始数据的位置。

           (3)生成.rec二进制文件

                            python im2rec.py   ../histcut6/cut6_train ../histcut6

                             (python im2rec.py -h   查看帮助)

           (4)将生成好的文件送入网络进行训练。在mxnet/example/image-classification里,有多个网络模型,inception-bn,alexnet,googlenet,vggnet.跑一个网络,我们需要用到find_mxnet.py   train_model.py    train_imagenet.py     symbol_alexnet.py

              之后,运行train_imagenet.py,并设置命令行参数。

                                  python train_imagenet.py  --network=alexnet   --data-dir=../histcut6  --num-epochs=20 ........

                                  (python train_imagenet.py  -h  查看帮助)

           (5)训练完成后就可以用训练好的模型进行predict,需要用到.params和.json文件,在mxnet/example/cpp/image-classification里有用于分类预测的image-classification-predict.cc,我们需要修改一下里面的.params和.json文件路径,以及图片大小等,然后编译,之后就可以用编译好的文件进行predict



mxnet的初级运用就这样完成了。

2019-11-27 11:04:33 weixin_42380114 阅读数 3
  • Fast.ai 深度学习实战课程「中文字幕」

    本课程由 Jeremy Howard 教授开设,共8节。目的是让大家在不需要深入研究高水平数学问题的情况下,学习如何建立先进的深度学习模型。 Jeremy Howard 教授结合自己参加 Kaggle 大赛并夺魁的经验认为,传统学院派的教学方式对于大多数学习者来说已经不适用,应该以问题为引导,以实践为驱动,尽快切入到核心理论和核心工具的使用上,掌握深度学习优模型的构建方法。

    16204 人正在学习 去看看 AI100讲师

深度学习之坑(0)

第一次写博客,不足之处望大家多多指教,主要是为了记录从一开始接触深度学习到目前为止的一些过程。

LeNet网络

刚开始接触深度学习的时候就是从LeNet模型开始入手,参考的是https://www.cnblogs.com/skyfsm/p/8051705.html的文章,主要是通俗易懂,但是我也花了一段时间才跑起来的。

数据集

由于我的主要研究方向是基于机器视觉的煤料产品分类,所以我的数据集主要就是一些煤料图片
下面是数据类别,总共分为了四类
在这里插入图片描述
在这里插入图片描述

LeNet网络构建`

# set the matplotlib backend so figures can be saved in the background
import matplotlib
matplotlib.use("Agg")

# import the necessary packages
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam
from sklearn.model_selection import train_test_split
from keras.preprocessing.image import img_to_array
from keras.utils import to_categorical
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import cv2
import os
import sys
sys.path.append('..')
from lenet import LeNet
import tensorflow as tf






def args_parse():
    # construct the argument parse and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-d", "--dataset", required=True,
        help="path to input dataset")
    ap.add_argument("-m", "--model", required=True,
        help="path to output model")
    ap.add_argument("-p", "--plot", type=str, default="plot.png",
        help="path to output accuracy/loss plot")
    args = vars(ap.parse_args()) 
    return args

# initialize the number of epochs to train for, initial learning rate,
# and batch size
EPOCHS = 100
INIT_LR = 1e-3
BS = 32
CLASS_NUM = 3
norm_size = 32

def load_data2(path):
    print("[INFO] loading images...")
    data = []
    labels = []
    # grab the image paths and randomly shuffle them
    imagePaths = sorted(list(paths.list_images(path)))
    random.seed(42)
    random.shuffle(imagePaths)
    # loop over the input images
    for imagePath in imagePaths:
        # load the image, pre-process it, and store it in the data list
        image = cv2.imread(imagePath)
        image = cv2.resize(image, (norm_size, norm_size))
        image = img_to_array(image)
        data.append(image)

        # extract the class label from the image path and update the
        # labels list
        label = int(imagePath.split(os.path.sep)[-2])       
        labels.append(label)  
        
    # scale the raw pixel intensities to the range [0, 1]
    data = np.array(data, dtype="float") / 255.0
    labels = np.array(labels)


    # partition the data into training and testing splits using 75% of
    # the data for training and the remaining 25% for testing
    (trainX, testX, trainY, testY) = train_test_split(data,
            labels, test_size=0.2, random_state=42)

    # convert the labels from integers to vectors
    trainY = to_categorical(trainY, num_classes=CLASS_NUM)
    testY = to_categorical(testY, num_classes=CLASS_NUM)   
    return trainX,trainY,testX,testY

def load_data(path):
    print("[INFO] loading images...")
    data = []
    labels = []
    # grab the image paths and randomly shuffle them
    imagePaths = sorted(list(paths.list_images(path)))
    random.seed(42)
    random.shuffle(imagePaths)
    # loop over the input images
    for imagePath in imagePaths:
        # load the image, pre-process it, and store it in the data list
        image = cv2.imread(imagePath)
        image = cv2.resize(image, (norm_size, norm_size)) 
        image = img_to_array(image)
        data.append(image)

        # extract the class label from the image path and update the
        # labels list
        label = int(imagePath.split(os.path.sep)[-2])    
        labels.append(label)
    
    # scale the raw pixel intensities to the range [0, 1]
    data = np.array(data, dtype="float") / 255.0
    labels = np.array(labels)

    # convert the labels from integers to vectors
    labels = to_categorical(labels, num_classes=CLASS_NUM)                         
    return data,labels

def train(aug,trainX,trainY,testX,testY,args):
    # initialize the model

    print("[INFO] compiling model...")
    model = LeNet.build(width=norm_size, height=norm_size, depth=3, classes=CLASS_NUM)
    opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
    model.compile(loss="binary_crossentropy", optimizer=opt,
        metrics=["accuracy"])

    # train the network
    print("[INFO] training network...")
    H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
        validation_data=(testX, testY), steps_per_epoch=len(trainX) // BS,
        epochs=EPOCHS, verbose=1)

    # save the model to disk
    print("[INFO] serializing network...")
    model.save(args["model"])
    
    # plot the training loss and accuracy
    plt.style.use("ggplot")
    plt.figure()
    N = EPOCHS
    plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
    plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
    plt.plot(np.arange(0, N), H.history["acc"], label="train_acc")
    plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc")
    plt.title("Training Loss and Accuracy on traffic-sign classifier")
    plt.xlabel("Epoch #")
    plt.ylabel("Loss/Accuracy")
    plt.legend(loc="lower left")
    plt.savefig(args["plot"])
    plt.show()
    sess=tf.Session()
    writer=tf.summary.FileWriter('C:/Users/zzw/Desktop/logs',sess.graph)#把图片load到log的文件夹里,在浏览器里浏览。
    #important step
    sess.run(tf.global_variables_initializer())

#python train.py --dataset_train ../../traffic-sign/train --dataset_test ../../traffic-sign/test --model traffic_sign.model
if __name__=='__main__':
    args = args_parse()
    file_path = args["dataset"]
     
    trainX,trainY,testX,testY = load_data2(file_path)
    
    # construct the image generator for data augmentation
    aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1,
        height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
        horizontal_flip=True, fill_mode="nearest")
    train(aug,trainX,trainY,testX,testY,args)

其中import中的Lenet库为:`

# import the necessary packages
from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dense
from keras import backend as K

class LeNet:
    @staticmethod
    def build(width, height, depth, classes):
        # initialize the model
        model = Sequential()
        inputShape = (height, width, depth)
        # if we are using "channels last", update the input shape
        if K.image_data_format() == "channels_first":   #for tensorflow
            inputShape = (depth, height, width)
        # first set of CONV => RELU => POOL layers
        model.add(Conv2D(20, (5, 5),padding="same",input_shape=inputShape))
        model.add(Activation("relu"))
        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
        #second set of CONV => RELU => POOL layers
        model.add(Conv2D(50, (5, 5), padding="same"))
        model.add(Activation("relu"))
        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
        # first (and only) set of FC => RELU layers
        model.add(Flatten())
        model.add(Dense(500))
        model.add(Activation("relu"))

        # softmax classifier
        model.add(Dense(classes))
        model.add(Activation("softmax"))

        # return the constructed network architecture
        return model

还有一个问题就是运行问题,刚开始只会在编辑器里面进行运行,还不熟悉在cmd里面运行代码,这个代码要在cmd里面进行运行,下面是我的运行代码:
直接在cmd里面输入:python C:/Users/zzw/Desktop/1/coal/code/train.py --dataset C:/Users/zzw/Desktop/1/coal/dataset\ --model coal.model
主要就是要注明训练文件的路径,还有就是数据集路径,最后一个就是训练后的模型保存名称。特别要注意路径的斜杠问题,很容易出问题。

结语

以上就是我步入深度学习踩的第一个坑,主要是为了记录,为了节省码字时间就不进行运行了,训练精度为75%左右,精度低主要是因为LeNet网络创立时间早,只有仅仅5层,建立之初只是为了做一些简单的图像识别,矿物类的图像比较复杂,而且我只训练了100步,如果有什么问题,希望各位大佬指正。

没有更多推荐了,返回首页