2. 程式人生 > >3D肺結節分類網路

3D肺結節分類網路

阿新 • • 發佈：2018-12-11 
import keras
from keras.callbacks import EarlyStopping     
from keras.models import load_model
from keras.layers import Conv2D, MaxPooling2D, MaxPooling2D,merge,MaxPooling3D,Conv3D,concatenate
from keras.layers import Activation, Dropout, Flatten, Dense,Merge,Input, Dense,Reshape,BatchNormalization
from
 
 keras import backend as K
from keras.models import Model
from keras import regularizers 
import pprint
import random
import numpy as np
import os
import cv2
import math
from keras.layers.normalization import BatchNormalization as bn
from scipy.misc import imsave
import numpy as np
import time
from sklearn import
 
 metrics

 
l2_lambda = 0.0002
DropP = 0.3
kernel_size=3


inputthree=Input(shape=(100,100,10,1), dtype='float32',name='inputthree')      
prepool= MaxPooling3D(pool_size=(2,2,2))(inputthree)

#分支1開始
#殘差塊1

conv1a = Conv3D( 12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same', 
               kernel_regularizer=
 
regularizers.l2(l2_lambda) )(prepool)
conv1a = bn()(conv1a)
conv1b = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(conv1a)
conv1b = bn()(conv1b)
merge1=concatenate([conv1a,conv1b])  
conv1c = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge1)
conv1c = bn()(conv1c)
merge2=concatenate([conv1a,conv1b,conv1c])
conv1d = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge2)
conv1d = bn()(conv1d)
pool1 = MaxPooling3D(pool_size=(2, 2, 1))(conv1d)
pool1 = Dropout(DropP)(pool1)

flatten1=Flatten()(pool1)
output1=Dense(1,activation='sigmoid')(flatten1)
#--------------------------------------------------------------------------------------------------
#殘差塊2
conv2a = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(pool1)
conv2a = bn()(conv2a)
conv2b = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(conv2a)
conv2b = bn()(conv2b)
merge1=concatenate([conv2a,conv2b])
conv2c = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge1)
conv2c = bn()(conv2c)
merge2=concatenate([conv2a,conv2b,conv2c])
conv2d = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge2)
conv2d = bn()(conv2d)
merge3=concatenate([conv2a,conv2b,conv2c,conv2d])
conv2e = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge3)
conv2e = bn()(conv2e)
merge4=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e])
conv2f = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge4)
conv2f = bn()(conv2f)
merge5=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f])
conv2g = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge5)
conv2g = bn()(conv2g)
merge6=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g])
conv2h = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge6)
conv2h = bn()(conv2h)
merge7=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g,conv2h])
conv2i = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge7)
conv2i = bn()(conv2g)
merge8=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g,conv2h,conv2i])
conv2j = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge8)
conv2j = bn()(conv2g)
pool2 = MaxPooling3D(pool_size=(2, 2, 1))(conv2j)
pool2 = Dropout(DropP)(pool2)

flatten2=Flatten()(pool2)
output2=Dense(1,activation='sigmoid')(flatten2)

#--------------------------------------------------------------------------------------------------
#殘差塊3

conv3a = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(pool2)
conv3a = bn()(conv3a)
conv3b = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(conv3a)
conv3b = bn()(conv3b)
merge1=concatenate([conv3a,conv3b])
conv3c = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge1)
conv3c = bn()(conv3c)
merge2=concatenate([conv3a,conv3b,conv3c])
conv3d = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge2)
conv3d = bn()(conv3d)
merge3=concatenate([conv3a,conv3b,conv3c,conv3d])
conv3e = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge3)
conv3e = bn()(conv3e)
merge4=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e])
conv3f = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge4)
conv3f = bn()(conv3f)
merge5=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f])
conv3g = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge5)
conv3g = bn()(conv3g)
merge6=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g])
conv3h = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge6)
conv3h = bn()(conv3h)
merge7=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h])
conv3i = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge7)
conv3i = bn()(conv3i)
merge8=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i])
conv3j = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge8)
conv3j = bn()(conv3j)
merge9=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j])
conv3k = Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge9)
conv3k = bn()(conv3k)
merge10=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k])
conv3l=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge10)
conv3l = bn()(conv3l)
merge11=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l])
conv3m=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge11)
conv3m = bn()(conv3m)
merge12=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m])
conv3n=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge12)
conv3n = bn()(conv3n)
merge13=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n])
conv3o=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge13)
conv3o = bn()(conv3o)
merge14=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o])
conv3p=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge14)
conv3p = bn()(conv3p)
merge15=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p])
conv3q=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge15)
conv3q = bn()(conv3q)
merge16=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q])
conv3r=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge16)
conv3r = bn()(conv3r)
merge17=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q,conv3r])
conv3s=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge17)
conv3s = bn()(conv3s)
merge18=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q,conv3r,conv3s])
conv3t=Conv3D(12, (kernel_size, kernel_size, kernel_size), activation='relu', padding='same',
               kernel_regularizer=regularizers.l2(l2_lambda) )(merge18)
conv3t = bn()(conv3t)
merge19=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q

相關推薦

3D肺結節分類網路

import keras from keras.callbacks import EarlyStopping from keras.models import load_model from keras.layers import Conv2D, Ma

更少的圖片標註工作，更棒的分類效果。肺結節診斷論文筆記。

寫在最前面 只有少量的標記的資料集或是隻有少量的資料集往往是我們工作的實際情況，這是一種不完美或是說不完備的情景。我對此想到了RWBY中的一句話"我們的敵人不會等著我們學成畢業再行動，我們必須時刻準備著"。作為即將步入研究生的我，我想未來的專案也不會等著我什麼都學明白了再出現，我們

基於深度學習的CT影象肺結節自動檢測技術四—資料增強—定義神經網路並訓練

開發環境 jupyter notebook # -- coding: utf-8 -- #訓練影象分割網路(u-net)模型 import csv import glob import random import cv2 import numpy import

如何用深度學習進行CT影像肺結節探測（附有基於Intel Extended Caffe的3D Faster RCNN程式碼開源）

1.資料預處理首先用SimpleITK把mhd圖片讀入，對每個切片使用Gaussian filter然後使用閾值-600把肺部圖片二值化，然後再分析該切片的面積，去掉面積小於30mm2的區域和離心率大於0.99的區域，找到3D的連通區域。只保留0.68L到8.2L體積的區域，並且如果大於6000 mm2的區域

醫學CT圖像特征提取（三）--肺結節CT影像特征提取系統軟件設計

文件 nod 處理器 size ima ray tex log -s 　　肺結節的特征提取在臨床中有著重要應用，在上篇文章已經對肺結節的基本特征和CT影像特征提取算法有了介紹，提出了三類肺結節CT影像特征提取算法。本文重點介紹肺結節CT影像特征提取系統的功能介紹及使用，利用

分類網路

具體解釋： 1．A類IP地址 一個A類IP地址由1位元組（每個位元組是8位）的網路地址和3個位元組主機地址組成，網路地址的最高位必須是“0”,即第一段數字範圍為0～127。 2．B類IP地址 一個B類IP地址由2個位元組的網路地址和2個位元組的主機地址組成，網路地址的最高位必

學習筆記之——基於深度學習的分類網路

       之前博文介紹了基於深度學習的常用的檢測網路《學習筆記之——基於深度學習的目標檢測演算法》，本博文為常用的CNN分類卷積網路介紹，本博文的主要內容來自於R&C團隊的成員的調研報告以及本人的理解~如有不當之處，還請各位看客賜教哈~好，下面

Tensorflow+SSD使用原始權重並修改分類網路進行單目標檢測

本文的原始碼地址是https://github.com/balancap/SSD-Tensorflow 由於專案需要，需要對場景中的人體進行檢測，但是原始的SSD網路是20種類別的網路，而只需要獲取人的分類即可，當我按照其說明在具有兩塊1080Ti的伺服器上訓練8個小時，損失值降低到10左右

Pytorch實現PointNet中的點雲分類網路。

下面是PointNet論文中分類模型的結構： 但是對於模型的細節，PointNet論文中並沒有詳細的解釋，尤其是T-Net，可以參考PointNet的supplemental部分。如果找不到，可以留言找我要。 話不多說，下面是程式碼，基本上完全還原了論文中的PointNet分類模型

CNN分類網路架構演進：從LeNet到Densnet解析及其keras實現

文章轉自：http://www.cnblogs.com/skyfsm/p/8451834.html 卷積神經網路可謂是現在深度學習領域中大紅大紫的網路框架，尤其在計算機視覺領域更是一枝獨秀。CNN從90年代的LeNet開始，21世紀初沉寂了10年，直到12年AlexNet開始又再煥發第二春，從Z

分類網路中為影象類別打標籤

#labels=[‘cube’,‘fourpyramid’,‘quadrangular’,‘tripyramid’] #labels字串長為400 from sklearn.preprocessing import LabelBinarizer lb = LabelBinarizer(

基於Tensorflow的cifar10分類網路模型

       Tensorflow算是老牌深度學習框架了，但是相比Pytorch來說，會稍微顯得有些笨重，主要是計算必須在session中進行，在編寫某些更為靈活的網路結構時，會比較麻煩。不過Tensorflow對分散式訓練的支援較好，所以如果是需要使用分散式

基於Pytorch的cifar10分類網路模型

       Pytorch作為新興的深度學習框架，目前的使用率正在逐步上升。相比TensorFlow，Pytorch的上手難度更低，同時Pytorch支援對圖的動態定義，並且能夠方便的將網路中的tensor格式資料與numpy格式資料進行轉換，使得其對某些特

keras實現多種分類網路的實現

Keras應該是最簡單的一種深度學習框架了,入門非常的簡單. 簡單記錄一下keras實現多種分類網路:如AlexNet、Vgg、ResNet 採用kaggle貓狗大戰的資料作為資料集. 由於AlexNet採用的是LRN標準化,Keras沒有內建函式實現,這裡用batchNormali

影象分類網路模組化,深度化,輕量化

Residual Network在深度網路變得越來越深的情況下，研究員發現的第一個問題就是退化現象，網路越深，對計算資源的要求就越高，並且當深度達到一定程度後，增加網路層數不但沒有準確性上的提升，反而出現了退化。解決或降低退化現象的第一款神器就是ResNet。ResNet引入了殘差網路結構(Residual

基於深度學習的CT影象肺結節自動檢測技術六—模型預測

#模型預測的相關功能 from chapter4 import get_unet from chapter5 import get_3dnnnet, stack_2dcube_to_3darray, prepare_image_for_net3D, MEAN_

基於深度學習的CT影象肺結節自動檢測技術五—3dcnn優化模型

import os import random from keras import layers from keras import backend as K from keras.layers import Input, Convolution3D, MaxP

基於深度學習的CT影象肺結節自動檢測技術一——資料預處理（歸一化，資料增強，資料標記）

開發環境 Anaconda:jupyter notebook /pycharm pip install SimpleItk # 讀取CT醫學影象 pip install tqdm # 可擴充套件的Python進度條，封裝

深度學習之3D卷積神經網路

一、概述 3D CNN主要運用在視訊分類、動作識別等領域，它是在2D CNN的基礎上改變而來。由於2D CNN不能很好的捕獲時序上的資訊，因此我們採用3D CNN，這樣就能將視訊中時序資訊進行很好的利用。首先我們介紹一下2D CNN與3D CNN的區別。如圖1所示，a)和b

keras實現基於vgg16的貓-狗二分類網路

import keras from keras.models import Sequential from keras.layers import Dense,MaxPooling2D,Input,Flatten,Convolution2D,Dropout from kera