1, primero en UIUC de datos de imágenes para el conjunto de datos de formación descarga Detección de coches.
Descargar: http: //cogcomp.org/Data/Car/
Después de la descarga, descomprimir el directorio de archivos como se muestra, aquí que necesitamos es TrainImages esta carpeta carpeta y TestImages.
2, la imagen de entrada es una escala de grises 100 * 40 * 1, usando la red CNN, después de varios resultados de convolución obtuvieron y se agruparon 1 * 1 * 1, como se muestra en los siguientes parámetros de cada capa.
Mi archivo de directorio de organización:
-CarDetect
--CarDetect.py
--datas
--- CarData
--models
entrada: [Ninguno, 40, 100, 1]
conv-pool1:
f: 5 * 5
pasos: 1
nc: 6
padding: VÁLIDO
maxpool: 2
conv-pool2:
f: 5 * 5
pasos: 1
nc: 16
padding: VALID
maxpool: 2
CONV3:
f: 5 * 5
pasos: 1
nc: 32
padding: VÁLIDO
conv4:
f: 3 * 18
pasos: 1
nc: 64
padding: VÁLIDO
conv5:
f: 1 * 1
pasos: 1
nc: 1
padding: VÁLIDO
salida: [Ninguno, 1, 1, 1]
tensorflow TF AS Importación
Importación numpy, como NP
importación matplotlib.pyplot PLT AS
función, tenga en cuenta la posición de los datos de entrenamiento de almacenamiento de datos de carga #define
load_carDats DEF ():
Importación CV2
Importación OS
ruta_archivo = './datas/CarData/TrainImages/'
Archivos = la os.listdir (FILE_PATH)
las muestras = []
para file_name en archivos:
datos = cv2.imread (FILE_PATH file_name +, 0) .reshape (-1) / 255
etiqueta file_name.split = 0 IF ( '-') [0] == 'NEG' la persona. 1
samples.append ((datos, etiqueta))
de regreso las muestras
de datos # loading
DATAS load_carDats = ()
# interrumpida datos aleatorios
np.random.shuffle (DATAS)
de datos # dividida, xs, ys para la formación red, x_test, y_test utiliza para probar el efecto del entrenamiento de la red
= XS [I [0] para DATAS en I [: 1000]]
YS = np.reshape ([I [1] para I en DATAS [:. 1000]], = newshape (- 1,1))
x_test = [I [0] para DATAS I en [1000:]]
android.permission.FACTOR = np.reshape ([I [1.] para I en DATAS [1000:]], = newshape (- 1,1)).
# ------- --------- funciones de red definido utilizan con frecuencia, se reconstituye # ------
# variable de ponderación
weight_variables DEF (forma):
pesos = tf.truncated_normal (forma, STDDEV = 0,1, DTYPE = tf.float32)
regresan tf.Variable (pesos)
# compensados variables
biase_variables DEF (forma):
sesgos tf.constant = (valor = 1,0, Forma = Shape)
de retorno TF. variable (sesgos)
# convolución
DEF conv2d (X, W es):
'' 'calcula la convolución, x es la capa de entrada (forma = [- 1, la anchura , la altura, el canal]),
W es f * f compartían forma correcta matriz de pesos = [f, f, in_layers_num , out_layers_num],
la horizontal y la etapa de dirección vertical son 1 '' '
retorno tf.nn.conv2d (X, W, Strides = [1,1,1,1], = relleno "la VÁLIDO")
# máximo agrupado
DEF max_pooling (X):
'' 'híbrido cálculo de la máxima, x es la capa de entrada (típicamente resultado de convolución) Forma = [- 1, anchura, altura, canales.]
ksize es puesta en común mixto de tamaño del núcleo 2 * 2, y la etapa horizontal en la dirección vertical son ambos 2 '' '
tf.nn.max_pool de retorno (X, ksize = [1,2,2,1], Strides = [1,2,2,1], = relleno "la VÁLIDO")
# --------------------- red antes de propagar porción ----------------- - #
DEF deepnn (X, keep_prop):
'' 'de la red profunda convolucional está definido, que comprende la convolución dos - tres convolución capa y las capas mixto' ''
# Paso 1: para convertir los datos en bruto en un 2-dimensional y tienen dimensión, representa un primer número de muestras, las filas segundos tres, el último es el número de canal
# tf.reshape X = (X, Forma = [- 1, 40, 100 ,. 1.])
# Paso 2: la definición de una primera de convolución - capa de mezcla
con tf.name_scope ( "conv-pooling1" ):
W_conv1 = weight_variables ([5,5,1,6])
= Biase_variables b_conv1 ([. 6])
ret_conv1 = tf.nn.relu (conv2d (x, W_conv1) + b_conv1) # de cálculo de convolución, y de corrección de medios para utilizar el resultado de la convolución se procesa adicionalmente
ret_pooling1 = max_pooling (ret_conv1) # realizar mezclando operación
# step3: para definir un segundo volumen trama - capa de mezcla
con tf.name_scope ( "CONV-pooling2"):
W_conv2 weight_variables = ([5,5,6,16])
b_conv2 biase_variables = ([16])
ret_conv2 = tf.nn.relu (conv2d (ret_pooling1, W_conv2) + b_conv2)
ret_pooling2 = max_pooling (ret_conv2)
# Paso 4: convolución definir una tercera capa
con tf.name_scope ( "CONV-pooling3"):
W_conv3 weight_variables = ([5,5,16,32])
b_conv3 = biase_variables ([32])
ret_conv3 = tf.nn.relu (conv2d (ret_pooling2, W_conv3) + b_conv3)
# Paso 5: cuarto convolución definido capas
con tf.name_scope ( "CONV4"):
W_conv4 weight_variables = ([3,18,32,64])
b_conv4 biase_variables = ([64])
ret_conv4 tf.nn.relu = ( conv2d (ret_conv3, W_conv4) + b_conv4)
# Paso 6: quinto convolución capas definidas
con tf.name_scope ( "conv5"):
W_conv5 weight_variables = ([1,1,64,1])
b_conv5 biase_variables = ([. 1] )
ret_conv5 = conv2d (ret_conv4, W_conv5) + b_conv5
retorno ret_conv5
# --------------------- ---------- listo antes de red de formación ------------- #
de marcador de posición # indica datos de entrada y etiquetas
x = tf.placeholder (dtype = tf.float32, forma = [Nada, Nada, ninguno, 1], = nombre "X-INPUT")
Etiquetas = tf.placeholder (DTYPE = tf.float32, Forma = [Ninguno ,. 1], name = "Y-Output")
# afirmada abstuvieron marcador de posición
keep_prop = tf.placeholder (DTYPE = tf.float32, name = "kprob")
# crea un modelo de clasificación
RET = deepnn (X, keep_prop)
# En este momento el valor de retorno es -1 * 1 * 1 * 1 con el fin de obtener el resultado de la comodidad de cálculo, aquí la RESHAPE
Y = tf.reshape (RET, Forma = [- 1,1])
# función pérdida definida
con tf.name_scope ( "loss_function"):
pérdida = tf.nn .sigmoid_cross_entropy_with_logits (= Y-logit, etiquetas = Etiquetas)
coste = tf.reduce_mean (Pérdida)
# define el modelo de formación (modelo de optimización)
con tf.name_scope ( "optimizor"):
tren = tf.train.AdamOptimizer (0,0005) .minimize ( coste)
# definen la precisión del proceso de validación del modelo
con tf.name_scope ( "precisión"):
y_hat = tf.nn.sigmoid (Y)
accuracy_rate = tf.abs (y_hat - Etiquetas) <0,5
accuracy_rate = tf.cast (accuracy_rate, DTYPE = tf.float32)
= Precisión tf.reduce_mean (accuracy_rate)
# -------------- comenzar a entrenar a la red, y guardar los resultados en un archivo --------------- formación #
Ahorro = tf.train.Saver ()
sess = tf.Session ()
variables de sess.run (tf.global_variables_initializer ()) # Inicializar
para I en cobertura (10):
Skip = 10
para K en el rango (0,1000, Saltar):
x_train = np.reshape (XS [K: K + Skip], = newshape (- 1, 40, 100 ,. 1.))
sess.run (tren, feed_dict = {X: x_train, Etiquetas: YS [K: k + skip], keep_prop: 0,5 }) # formación modelo
# si (i + 1)% 10 == 0:.
train_accuracy = sess.run (precisión, feed_dict = {X: np.reshape (XS, (-1,40,100 , 1)), etiquetas:. YS, keep_prop: 1.0})
de impresión ( '% PASO D, G tren% de precisión' % (I, train_accuracy))
saver.save (sess, "./models/carDetect_model.ckpt", global_step = i)
Se trata de los resultados de mi formación:
el paso 0, Tren de Precisión 0,859
el PASO 1, Tren de Precisión 0,934
el PASO 2, Tren de Precisión 0,965
el PASO 3, Tren de Precisión 0.971
STEP. 4, tren Precisión 0.985
STEP. 5, tren Precisión 0.991
STEP. 6, tren Precisión 0.995
STEP. 7, tren Precisión 0.994
STEP. 8, tren Precisión 0.995
STEP. 9, tren Precisión 0.997
# ----------------------- -------------- ------------------- # comienza con la detección de nuevas imágenes
de importación CV2
# importar imágenes
pic = cv2.imread ( "../../datas/CarData/TestImages/test-100.pgm", 0)
size = pic.shape
IMG = np.reshape (PIC, (-1, tamaño [0], tamaño [. 1], 1))
# Uso de la red entrenada por encima empieza a detectar nuevas imágenes
= Sess.run Resultado (RET, feed_dict = {X: IMG})
# Los resultados del ensayo muestran
pt1 = np.array ([result.argmax () // result.shape [2], result.argmax () resultado%. Forma [2]]). 4 *
PT2 + np.array PT1 = ([40, 100])
PIC_2 = cv2.rectangle (PIC, (PT1 [. 1], PT1 [0]), (PT2 [. 1], PT2 [ 0]), 0, 2)
plt.imshow (PIC_2, "gris")
plt.show ()
3. resultados
modo de adquisición de la fuente, el número total de RaoRao1994 públicas afectadas, en maravillosa de ver - de todos los artículos, puede obtener los recursos del enlace de descarga
Obtener más recursos, por favor preste atención al público el número total de RaoRao1994
