目前碰到的数据集以及读取方式

正在深度学习的入门阶段，把现在完成的任务中所碰到的一些数据集进行一个汇总，方便以后应用。

1. 在做吴恩达老师的课后作业时，是一个二分类的神经网络，就是判断是猫不是猫的一个功能，这个应该是老师自己做的一个数据集，在文件夹中的显示如下：

以下是老师的程序中给的参考代码：

def load_data():
    """
    加载数据集
    :return: 训练集、标签、测试集、标签、类别信息；
    """
    train_dataset = h5py.File("D:/360安全浏览器下载/train_catvnoncat.h5", "r")
    train_x_orig = np.array(train_dataset['train_set_x'][:])
    train_y_orig = np.array(train_dataset['train_set_y'][:])  # shape：(209,)-->不是列向量---向量化,or bugs

    test_dataset = h5py.File("D:/360安全浏览器下载/test_catvnoncat.h5", "r")
    test_x_orig = np.array(test_dataset['test_set_x'][:])
    test_y_orig = np.array(test_dataset['test_set_y'][:])

    classes = np.array(test_dataset['list_classes'][:])  # 类别信息

    train_y_orig = train_y_orig.reshape((1, train_y_orig.shape[0]))
    test_y_orig = test_y_orig.reshape((1, test_y_orig.shape[0]))
    return train_x_orig, train_y_orig, test_x_orig, test_y_orig, classes

当然如果在程序中使用这个函数，需要调用以下两个库：

import h5py
import numpy as np

有h5py的详细介绍，我转载了另外一篇博文，现在我们直接使用它。

我们将读进去的图片打印出来看一看

可以看到这个数据集中训练集一共有209张图片，而测试集中有50张图片。

我们也可以进行把数据集中的图片读出一张来看一看：

index = 25
plt.imshow(train_set_x_orig[index])

2.后来在做一个浅层的神经网络并拿mnist数据作为训练与测试的时候，采用的mnist数据集是直接采用Keras框架下的数据集
首先我们需要导入如下的库：

from keras.datasets import mnist 

然后我们就直接对数据进行读入，代码如下，先读入图片，然后把训练集中的手写黑白字体变成四维张量的形式（样本数量，长， 宽， 1（通道）），然后将像素值控制到0-1内，最后再对标签进行一个one hot编码，代码如下：

#先读入数据
(x_train, y_train), (x_test, y_test) = mnist.load_data("../test_data_home")
#看一下数据集的样子
print(x_train[0].shape)         #图片的长宽
print(y_train[0])               #标签的长度

#把训练集中的手写黑白字体变成四维张量的形式（样本数量，长， 宽， 1（通道））
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype('float32')

#将像素值控制在0-1之内
x_train /= 255
x_test /= 255
#输入层需要10个节点，所以把目标数字0-9做成One Hot编码的形式
def tran_y(y):
    y_ohe = np.zeros(10)
    y_ohe[y] = 1
    return y_ohe
#把标签用One Hot编码重新表示一下
y_train_ohe = np.array([tran_y(y_train[i]) for i in range(len(y_train))])
y_test_ohe = np.array([tran_y(y_test[i]) for i in range(len(y_test))])

这里的one hot编码的函数是自己编写的，其实有直接的one hot函数，导入keras框架之后可以直接用，代码如下：

#进行OneHot编码
train_label = keras.utils.to_categorical(train_label, 2)
test_label = keras.utils.to_categorical(test_label, 2)

3.然后采用的VGG16网络针对cifar-10数据集进行训练和识别
首先我们可以看一下cifar-10数据集长什么样子

from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
y_train = keras.utils.to_categorical(y_train, 10)#转One Hot
y_test = keras.utils.to_categorical(y_test, 10)

很有意思的是我在整个程序中没有看到将0-256转换到0-1的代码，这个疑问以后再解决吧。

4.后来又用AlexNet做的猫狗大战，猫狗大战就直接是图片
我们可以看到整个数据集训练集有猫狗图片各13000张，而测试集有打乱的猫狗图片12500张。然而我的电脑性能比较差，我就选择800张图片，前400选200作为训练集，后400选200作为测试集。具体代码如下：

import os
import numpy as np
import keras
import cv2
def load_data():
    imgs = os.listdir("./catvsdog/")
    #返回指定路径下的文件和文件夹列表。
    #选择800张图片，前400选200作为训练集，后400选200作为测试集，下面相当于是一个手动打乱的操作，定义一个读图片的数组
    #将数组中偶数下标读为狗，奇数读为猫
    num = len(imgs)
    train_data = np.empty((150, resize, resize, 3), dtype="int32")
    train_label = np.empty((150, ), dtype="int32")
    test_data = np.empty((150, resize, resize, 3), dtype="int32")
    test_label = np.empty((150, ), dtype="int32")
    for i in range(150):
        if i % 2:
            train_data[i] = cv2.resize(cv2.imread('./catvsdog/' + 'dog.' + str(i) + '.jpg'), (resize, resize))
            train_label[i] = 1
        else:
            train_data[i] = cv2.resize(cv2.imread('./catvsdog/' + 'cat.' + str(i) + '.jpg'), (resize, resize))
            train_label[i] = 0
    for i in range(150, 300):
        if i % 2:
            test_data[i - 150] = cv2.resize(cv2.imread('./catvsdog/' + 'dog.' + str(i) + '.jpg'), (resize, resize))
            test_label[i - 150] = 1
        else:
            test_data[i - 150] = cv2.resize(cv2.imread('./catvsdog/' + 'cat.' + str(i) + '.jpg'), (resize, resize))
            test_label[i - 150] = 0
    return train_data, train_label, test_data, test_label
#读入数据并进行类型转换
train_data, train_label, test_data, test_label = load_data()
train_data, test_data = train_data.astype('float32'), test_data.astype('float32')
train_data, test_data = train_data/255, test_data/255
#因为彩色图片默认通道为BGR，所以采用cv2的库将其转化为RGB，然后显示一张图片
img = train_data[0]
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
plt.axis("off")
plt.show()

#进行OneHot编码
train_label = keras.utils.to_categorical(train_label, 2)
test_label = keras.utils.to_categorical(test_label, 2)

以上是一个读入图片，选取测试图片和训练图片并显示的过程，很有意思的是只有训练集和测试集的图片一样多的时候这个程序才是正确的。这也是一个疑问

5.后来又开始学习语义分割先关的知识，语义分割U-net采用的细胞的图片，我们来看一看。
语义分割和前面的图像分类优点不同，特别是U-net这个网络，是用来处理医疗影像的一个专用网络，所以信息及数据集就比较稀有。所以我们需要做数据增强，但在增强的同时，我们对应的mask（也就是语义分割中的图片的标签）也要跟着变，这样我们用了增强，一共产生了60张图片以及对应的mask用来作为训练集。同时用30张图片用来作为测试集。他的数据读入是这样的：

from __future__ import print_function
from keras.preprocessing.image import ImageDataGenerator
import numpy as np 
import os
import glob
import skimage.io as io
import skimage.transform as trans

Sky = [128,128,128]
Building = [128,0,0]
Pole = [192,192,128]
Road = [128,64,128]
Pavement = [60,40,222]
Tree = [128,128,0]
SignSymbol = [192,128,128]
Fence = [64,64,128]
Car = [64,0,128]
Pedestrian = [64,64,0]
Bicyclist = [0,128,192]
Unlabelled = [0,0,0]

COLOR_DICT = np.array([Sky, Building, Pole, Road, Pavement,
                          Tree, SignSymbol, Fence, Car, Pedestrian, Bicyclist, Unlabelled])


def adjustData(img,mask,flag_multi_class,num_class):
    if(flag_multi_class):
        img = img / 255
        mask = mask[:,:,:,0] if(len(mask.shape) == 4) else mask[:,:,0]
        new_mask = np.zeros(mask.shape + (num_class,))
        for i in range(num_class):
            #对于图像中的一个像素，在掩码中找到该类并将其转换为单热矢量
            new_mask[mask == i, i] = 1#将平面的mask的每类，都单独变成一层
        new_mask = np.reshape(new_mask, (new_mask.shape[0], new_mask.shape[1]*new_mask.shape[2], new_mask.shape[3])) if flag_multi_class else np.reshape(new_mask,(new_mask.shape[0]*new_mask.shape[1],new_mask.shape[2]))
        mask = new_mask
    elif(np.max(img) > 1):
        img = img / 255
        mask = mask /255
        mask[mask > 0.5] = 1
        mask[mask <= 0.5] = 0
    return (img,mask)
#上面这个函数主要是对训练集的数据和标签的像素值进行归一化


def trainGenerator(batch_size, train_path, image_folder,
                   mask_folder, aug_dict, image_color_mode="grayscale",
                    mask_color_mode="grayscale", image_save_prefix="image",
                   mask_save_prefix="mask", flag_multi_class=False, num_class=2,
                   save_to_dir=None, target_size=(256, 256), seed=1):
    '''
    可以生成图像和mask同时使用相同的seed确定image_datagen和mask_datagen，
    以确保图像和mask的变换是相同的，如果你想要显示生成器的结果，设置save_to_dir =“你的路径”
    '''
    image_datagen = ImageDataGenerator(**aug_dict)#字典前面加两个星号，是将字典解开成独立的元素作为形参
    mask_datagen = ImageDataGenerator(**aug_dict)
    image_generator = image_datagen.flow_from_directory(
        train_path,
        classes = [image_folder],
        class_mode = None,
        color_mode = image_color_mode,
        target_size = target_size,
        batch_size = batch_size,
        save_to_dir = save_to_dir,
        save_prefix  = image_save_prefix,
        seed = seed)
    mask_generator = mask_datagen.flow_from_directory(
        train_path,
        classes = [mask_folder],
        class_mode = None,
        color_mode = mask_color_mode,
        target_size = target_size,
        batch_size = batch_size,
        save_to_dir = save_to_dir,
        save_prefix  = mask_save_prefix,
        seed = seed)
    train_generator = zip(image_generator, mask_generator)
    for (img,mask) in train_generator:
        img,mask = adjustData(img,mask,flag_multi_class,num_class)
        yield (img,mask)



def testGenerator(test_path,
                  num_image = 30,
                  target_size=(256,256),
                  flag_multi_class = False,
                  as_gray = True):
    for i in range(num_image):
        img = io.imread(os.path.join(test_path,"%d.png"%i),as_gray = as_gray)
        img = img / 255
        img = trans.resize(img,target_size)
        img = np.reshape(img,img.shape+(1,)) if (not flag_multi_class) else img
        img = np.reshape(img,(1,)+img.shape)
        yield img


def geneTrainNpy(image_path,mask_path,flag_multi_class = False,num_class = 2,image_prefix = "image",mask_prefix = "mask",image_as_gray = True,mask_as_gray = True):
    image_name_arr = glob.glob(os.path.join(image_path,"%s*.png"%image_prefix))
    image_arr = []
    mask_arr = []
    for index,item in enumerate(image_name_arr):
        img = io.imread(item,as_gray = image_as_gray)
        img = np.reshape(img,img.shape + (1,)) if image_as_gray else img
        mask = io.imread(item.replace(image_path,mask_path).replace(image_prefix,mask_prefix),as_gray = mask_as_gray)
        mask = np.reshape(mask,mask.shape + (1,)) if mask_as_gray else mask
        img,mask = adjustData(img,mask,flag_multi_class,num_class)
        image_arr.append(img)
        mask_arr.append(mask)
    image_arr = np.array(image_arr)
    mask_arr = np.array(mask_arr)
    return image_arr,mask_arr


def labelVisualize(num_class,color_dict,img):
    img = img[:,:,0] if len(img.shape) == 3 else img
    img_out = np.zeros(img.shape + (3,))
    for i in range(num_class):
        img_out[img == i,:] = color_dict[i]
    return img_out / 255



def saveResult(save_path,npyfile,flag_multi_class = False,num_class = 2):
    for i,item in enumerate(npyfile):
        img = labelVisualize(num_class,COLOR_DICT,item) if flag_multi_class else item[:,:,0]
        io.imsave(os.path.join(save_path,"%d_predict.png"%i),img)

6.值得一提的是，同样是这个U-net语义分割，学长也给了我们一个读数据的方法，在这里也展示出来

`imgpath = "D:/QLJ/train-volume"
labelPath ="D:/QLJ/train-label"
def getImg(imgPath,labelPath):
    imgfiles = os.listdir(imgPath)
    labelfiles = os.listdir(labelPath)
    imgs = []
    labels = []
    for file in imgfiles:
        img = np.expand_dims(np.array(imageio.imread(imgpath+"/"+file),dtype= np.float32),axis=-1)
        imgs.append(img)
    for labelfile in labelfiles:
        label = np.expand_dims(np.array(imageio.imread(labelPath+"/"+labelfile),dtype=  np.float32),axis=-1)
        labels.append(label)
    imgs = np.array(imgs)
    imgs -= imgs.mean()
    imgs /= imgs.std()
    labels = np.array(labels).clip(0,1)
    return imgs, labels

imgs,labels = getImg(imgpath,labelPath)`.

7.后来研究到了普通GAN网络，这时就没有所谓的标签的概念了，有的就是一张张图片，也是mnist数据集：

(X_train, y_train), (X_test, y_test) = mnist.load_data()
    # 转换字段类型，并将数据导入变量中
    X_train = (X_train.astype(np.float32) - 127.5) / 127.5

由于没有了标签，我们做数据导入的时候还是挺方便的，也只使用了X_train,其他都没有用到

8.最后研究的是DCGAN网络，也是一堆图片文件，这个文件有点大，一共有50000张图片，我们看看是怎么处理的

def sample_real_X(fileLists,image_shape=(64,64,3),batch_size=32):
    sample_dim = (batch_size,) + image_shape
    sample = np.empty(sample_dim, dtype=np.float32)
    selected = random.sample(fileLists,batch_size)
    #print(selected)
    # sample_names = [os.path.join(samplePath,x) for x in selected]
    for i,file in enumerate(selected):
        file_path = os.path.join(samplePath,file)
        # print(file_name)
        img = cv2.imread(file_path)
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        img = norm_pic(img)
        sample[i,...]=img
    #print(sample.shape)
    return sample

也是定义了一个函数，但是我们看这个函数，他的一个形参是batch_size，说明我们取图片是一批一批取的，而不是像原先一下子全部取出来。
先这样吧，以后随着这方面知识的理解加深，再继续补充