uno, uso
Se utiliza principalmente para probar la eficacia del método, aumentar la carga de trabajo y aumentar la cantidad de palabras en el documento. , para verificación comparativa.
Visualice dos gráficos, usando el nuevo método y el anterior, compárelos, escriba un artículo basado en el contenido del ícono y explique el rol del nuevo método.
Dos pasos
1. Cargar datos y preprocesar
Cargando datos : genera iteradores de carga de datos a través de classdataset. (Solo se carga una imagen aquí, omita esta operación)
Preprocesamiento de datos (imagen) : cambio de tamaño - conversión a formato Tensor - normalización - mejora de datos - procesamiento de datos de imagen, etc. (tome los tres primeros aquí)
def image_proprecess(img_path):
img = Image.open(img_path)
data_transforms = transforms.Compose([
transforms.Resize((384, 384), interpolation=3),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data = data_transforms(img)
data = torch.unsqueeze(data,0)
return data
Al cargar un gráfico, use torch.unsqueeze para convertir el tensor 3D en 4D.
2. Modificar la red
Cuando necesite visualizar el mapa de características de una determinada capa, debe devolver el mapa de características de esta capa, así que modifique la función de reenvío en la red:
def forward(self, x):
x = self.model.conv1(x)
x = self.model.bn1(x)
x = self.model.relu(x)
x = self.model.maxpool(x)
feature = self.model.layer1(x)
x = self.model.layer2(feature)
x = self.model.layer3(x)
x = self.model.layer4(x)
return feature,x
3, defina la red y cargue el modelo pre-entrenado
def Init_Setting(epoch):
dirname = '/mnt/share/VideoReID/share/models/Methods5_trial1'
model = siamese_resnet50(701, stride=1, pool='avg')
trained_path = os.path.join(dirname, 'net_%03d.pth' % epoch)
print("load %03d.pth" % epoch)
model.load_state_dict(torch.load(trained_path))
model = model.cuda().eval()
return model
Nota: La última línea es para configurar la red en modo de inferencia
4. Visualización de mapas de características
Convierta un canal del mapa de características en un mapa para su visualización：
def visualize_feature_map(img_batch,out_path,type,BI):
feature_map = torch.squeeze(img_batch)
feature_map = feature_map.detach().cpu().numpy()
feature_map_sum = feature_map[0, :, :]
feature_map_sum = np.expand_dims(feature_map_sum, axis=2)
for i in range(0, 2048):
feature_map_split = feature_map[i,:, :]
feature_map_split = np.expand_dims(feature_map_split,axis=2)
if i > 0:
feature_map_sum +=feature_map_split
feature_map_split = BI.transform(feature_map_split)
plt.imshow(feature_map_split)
plt.savefig(out_path + str(i) + "_{}.jpg".format(type) )
plt.xticks()
plt.yticks()
plt.axis('off')
feature_map_sum = BI.transform(feature_map_sum)
plt.imshow(feature_map_sum)
plt.savefig(out_path + "sum_{}.jpg".format(type))
print("save sum_{}.jpg".format(type))
-
El parámetro img_batch es el mapa de características devuelto por una determinada capa en la red, y BI es una función de interpolación bilineal, que se autodefine y se analizará a continuación.
-
Dado que solo se visualiza una imagen, img_batch tiene cuatro dimensiones y la dimensión del tamaño del lote es 1. La tercera línea lo lleva de la GPU a la CPU y en formato numpy.
-
La parte restante es principalmente para convertir cada canal en una imagen y agregar las posiciones correspondientes de cada elemento de todos los canales y guardarlos.
Interpolación bilineal
Después de varias veces de reducción de resolución de la red, el mapa de características de la última capa generalmente se convierte en un tamaño de solo 7×7, 16×16. Es muy pequeño después de la visualización, por lo que debe aumentarse la muestra. La interpolación bilineal es uno de los métodos de sobremuestreo,
class BilinearInterpolation(object):
def __init__(self, w_rate: float, h_rate: float, *, align='center'):
if align not in ['center', 'left']:
logging.exception(f'{
align} is not a valid align parameter')
align = 'center'
self.align = align
self.w_rate = w_rate
self.h_rate = h_rate
def set_rate(self,w_rate: float, h_rate: float):
self.w_rate = w_rate # w 的缩放率
self.h_rate = h_rate # h 的缩放率
# 由变换后的像素坐标得到原图像的坐标 针对高
def get_src_h(self, dst_i,source_h,goal_h) -> float:
if self.align == 'left':
# 左上角对齐
src_i = float(dst_i * (source_h/goal_h))
elif self.align == 'center':
# 将两个图像的几何中心重合。
src_i = float((dst_i + 0.5) * (source_h/goal_h) - 0.5)
src_i += 0.001
src_i = max(0.0, src_i)
src_i = min(float(source_h - 1), src_i)
return src_i
# 由变换后的像素坐标得到原图像的坐标 针对宽
def get_src_w(self, dst_j,source_w,goal_w) -> float:
if self.align == 'left':
# 左上角对齐
src_j = float(dst_j * (source_w/goal_w))
elif self.align == 'center':
# 将两个图像的几何中心重合。
src_j = float((dst_j + 0.5) * (source_w/goal_w) - 0.5)
src_j += 0.001
src_j = max(0.0, src_j)
src_j = min((source_w - 1), src_j)
return src_j
def transform(self, img):
source_h, source_w, source_c = img.shape # (235, 234, 3)
goal_h, goal_w = round(
source_h * self.h_rate), round(source_w * self.w_rate)
new_img = np.zeros((goal_h, goal_w, source_c), dtype=np.uint8)
for i in range(new_img.shape[0]): # h
src_i = self.get_src_h(i,source_h,goal_h)
for j in range(new_img.shape[1]):
src_j = self.get_src_w(j,source_w,goal_w)
i2 = ceil(src_i)
i1 = int(src_i)
j2 = ceil(src_j)
j1 = int(src_j)
x2_x = j2 - src_j
x_x1 = src_j - j1
y2_y = i2 - src_i
y_y1 = src_i - i1
new_img[i, j] = img[i1, j1]*x2_x*y2_y + img[i1, j2] * \
x_x1*y2_y + img[i2, j1]*x2_x*y_y1 + img[i2, j2]*x_x1*y_y1
return new_img
#使用方法
BI = BilinearInterpolation(8, 8)
feature_map = BI.transform(feature_map)
5. Proceso de función principal
imgs_path = "/path/to/imgs/"
save_path = "/save/path/to/output/"
model = Init_Setting(120)
BI = BilinearInterpolation(8, 8)
data = image_proprecess(out_path + "0836.jpg")
data = data.cuda()
output, _ = model(data)
visualize_feature_map(output, save_path, "drone", BI)
Solo para aprender a compartir registros, eliminar intrusiones.