예제 #1
0
def create_label(fn_proj, fn_vol, rec, geom):
    proj = dennerlein.read_noqueue(fn_proj)
    volume = rec.apply(proj, geom,
                       fullscan=True)  #MUDAR DEPOIS PARA TRUE!!!!!!
    return dennerlein.write(fn_vol, volume)
예제 #2
0
def my_train():

    EPOCHS = 10
    BATCH_SIZE = 16

    train_proj = [
        "/home/davi/Documentos/ConeDeepLearningCT2/phantoms/lowdose/binary0.proj.bin",
    ]

    train_label = [
        "/home/davi/Documentos/ConeDeepLearningCT2/phantoms/lowdose/binary0.vol.bin",
    ]

    save_path = '/home/davi/Documentos/train/model_%d/' % 0
    with tf.Session() as sess:

        train_list = []
        label_list = []
        for i in range(len(train_proj)):

            train_list_ = sess.run(dennerlein.read_noqueue(train_proj[i]))
            train_list.append(train_list_)

            label_list_ = sess.run(dennerlein.read_noqueue(train_label[i]))
            label_list.append(label_list_)

    geom, angles = projtable.read(DATA_P + 'projMat.txt')
    # Beleza, temos as amostras em train_proj e os labels em train_label

    BATCH_SIZE = 1
    features, labels = (train_list, label_list)
    dataset = tf.data.Dataset.from_tensor_slices(
        (np.asarray(features), np.asarray(labels))).repeat().batch(BATCH_SIZE)
    iter = dataset.make_one_shot_iterator()
    x, y = iter.get_next()

    EPOCHS = 100000
    with tf.Session(config=tf.ConfigProto(gpu_options=GPU_OPTIONS)) as sess:

        global LEARNING_RATE
        # Ajeita as coisas para printar um slice antes de comçar a treinar
        re = ct.Reconstructor(CONF_LA,
                              angles[0:LIMITED_ANGLE_SIZE],
                              DISPLACEMENT,
                              name='LAReconstructor',
                              weights_type=WEIGHTS_TYPE)

        volume_la = re.apply(x, geom)

        # Esse reconstructor será utilizado para corrigir a imagem durante as EPOCHS do treinamento
        re = ct.Reconstructor(CONF_LA,
                              angles[0:LIMITED_ANGLE_SIZE],
                              DISPLACEMENT,
                              trainable=True,
                              name='LAReconstructor',
                              weights_type=WEIGHTS_TYPE)

        if not tf.train.get_global_step():
            tf.train.create_global_step()

        sess.run(tf.global_variables_initializer())
        sess.run(tf.local_variables_initializer())

        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess, coord=coord)

        saver = tf.train.Saver(max_to_keep=TRACK_LOSS)

        # Printa
        write_png = png.writeSlice(
            volume_la[0],
            '/home/davi/Documentos/train/test_model_0/slice_qualquer_antes_treinamento.png'
        )
        sess.run(write_png)

        try:
            for i in range(EPOCHS):

                #				if i % 30 == 0:
                #					print("Abaixando a LEARNING RATE")
                #					LEARNING_RATE /= 10

                proj = train_list[0]
                label = label_list[0]

                train_step = tf.no_op()

                volume_la = re.apply(x, geom)
                volume_la = tf.expand_dims(volume_la, axis=0)

                t1 = tf.math.reduce_max(y)
                t2 = tf.math.reduce_max(volume_la)
                label_ = y * (255 / t1)
                volume_la_ = volume_la * (255 / t2)

                # Add a extension to the tensor
                write_png = png.writeSlice(
                    volume_la_[0][0],
                    '/home/davi/Documentos/train/test_model_0/slice_qualquer_depois_treinamento.png'
                )
                sess.run(write_png)

                loss = tf.losses.mean_squared_error(label_, volume_la_)

                with tf.control_dependencies([train_step]):
                    gstep = tf.train.get_global_step()

                    train_step = tf.train.GradientDescentOptimizer(
                        LEARNING_RATE).minimize(
                            loss,
                            colocate_gradients_with_ops=True,
                            global_step=gstep)

                step = sess.run(tf.train.get_global_step())
                if step % 10:
                    print("Salvando o modelo")
                    saver.save(sess, save_path + 'model', global_step=step)

                # Treinando
                print("Treinando")
                sess.run(train_step)

        except tf.errors.OutOfRangeError:
            print('Done.')
        finally:

            coord.request_stop()