Anote dados de nuvem de pontos densos usando SageMaker Ground Truth

As empresas de veículos autônomos normalmente usam LiDAR sensores para gerar uma compreensão 3D do ambiente em torno de seus veículos. Por exemplo, eles montam um sensor LiDAR em seus veículos para capturar continuamente instantâneos pontuais do ambiente 3D circundante. A saída do sensor LiDAR é uma sequência de quadros de nuvens de pontos 3D (a taxa de captura típica é de 10 quadros por segundo). Verdade no solo do Amazon SageMaker facilita rotular objetos em um único quadro 3D ou em uma sequência de quadros de nuvens de pontos 3D para criar conjuntos de dados de treinamento de aprendizado de máquina (ML). O Ground Truth também oferece suporte à fusão de sensores de dados de câmera e LiDAR com até oito entradas de câmera de vídeo.

À medida que os sensores LiDAR se tornam mais acessíveis e econômicos, os clientes estão usando cada vez mais os dados da nuvem de pontos em novos espaços, como robótica, mapeamento de sinal e realidade aumentada. Alguns novos dispositivos móveis até incluem sensores LiDAR, um dos quais forneceu os dados para este post! A crescente disponibilidade de sensores LiDAR aumentou o interesse em dados de nuvem de pontos para tarefas de ML, como detecção e rastreamento de objetos 3D, segmentação 3D, síntese e reconstrução de objetos 3D e até mesmo o uso de dados 3D para validar a estimativa de profundidade 2D.

Embora os dados de nuvens de pontos densos sejam ricos em informações (mais de 1 milhão de nuvens de pontos), é difícil rotular porque as estações de trabalho de rotulagem geralmente têm memória limitada e recursos gráficos e anotadores tendem a ser distribuídos geograficamente, o que pode aumentar a latência. Embora um grande número de pontos possa ser renderizado na estação de trabalho de um rotulador, a taxa de transferência do rotulador pode ser reduzida devido ao tempo de renderização ao lidar com nuvens de pontos de vários milhões, aumentando muito os custos de rotulagem e reduzindo a eficiência.

Uma maneira de reduzir esses custos e tempo é converter os trabalhos de rotulagem da nuvem de pontos em tarefas menores e mais facilmente renderizadas que preservam a maior parte das informações originais da nuvem de pontos para anotação. Nós nos referimos a essas abordagens amplamente como redução de amostragem, igual a redução de amostragem no domínio de processamento de sinal. Como no domínio do processamento de sinal, as abordagens de downsampling de nuvens de pontos tentam remover pontos enquanto preservam a fidelidade da nuvem de pontos original. Ao anotar nuvens de pontos com resolução reduzida, você pode usar a saída 3D cubóides para rastreamento de objetos e detecção de objetos tarefas diretamente para treinamento ou validação na nuvem de pontos em tamanho real com pouco ou nenhum impacto no desempenho do modelo enquanto economiza tempo de rotulagem. Para outras modalidades, como segmentação semântica, em que cada ponto tem seu próprio rótulo, você pode usar seus rótulos reduzidos para prever os rótulos em cada ponto na nuvem de pontos original, permitindo realizar uma compensação entre o custo do rotulador (e, portanto, a quantidade de dados rotulados) e uma pequena quantidade de classificações incorretas de pontos na nuvem de pontos em tamanho real.

Nesta postagem, mostramos como realizar técnicas de redução de amostragem para preparar seus dados de nuvem de pontos para rotulagem e, em seguida, demonstramos como aumentar a amostra de seus rótulos de saída para aplicar ao seu conjunto de dados original em tamanho real usando alguma inferência na amostra com um modelo de ML simples. Para conseguir isso, usamos o Ground Truth e Instâncias de notebook do Amazon SageMaker para executar a rotulagem e todas as etapas de pré-processamento e pós-processamento.

Os dados

Os dados que usamos neste post são uma varredura do telhado de um prédio de apartamentos gerada usando o aplicativo 3D Scanner em um iPhone12 Pro. O aplicativo permite que você use os scanners LiDAR integrados em dispositivos móveis para digitalizar uma determinada área e exportar um arquivo de nuvem de pontos. Nesse caso, os dados da nuvem de pontos estão no formato xyzrgb, um formato aceito para uma nuvem de pontos do Ground Truth. Para obter mais informações sobre os tipos de dados permitidos em uma nuvem de pontos do Ground Truth, consulte Formatos de dados 3D brutos aceitos.

A imagem a seguir mostra nossa digitalização 3D.

De Depósito

Primeiro, percorremos algumas abordagens para reduzir o tamanho do conjunto de dados para rotular nuvens de pontos: ladrilhos, amostra de etapa fixa e média de voxels. Demonstramos por que as técnicas de downsampling podem aumentar a taxa de transferência de rotulagem sem sacrificar significativamente a qualidade da anotação e, em seguida, demonstramos como usar rótulos criados na nuvem de pontos com downsampling e aplicá-los à sua nuvem de pontos original com uma abordagem de upsampling.

Abordagens de downsampling

A redução da resolução é pegar seu conjunto de dados em tamanho real e escolher um subconjunto de pontos dele para rotular ou criar um conjunto representativo de novos pontos que não estão necessariamente no conjunto de dados original, mas estão próximos o suficiente para permitir a rotulagem.

Tiling

Uma abordagem ingênua é quebrar seu espaço de nuvem de pontos em cubos 3D, também conhecidos como voxels, de (por exemplo) 500,000 pontos cada um que são rotulados independentemente em paralelo. Essa abordagem, chamada revestimento, reduz efetivamente o tamanho da cena para rotulagem.

No entanto, pode aumentar muito o tempo e os custos de rotulagem, porque uma cena típica de 8 milhões de pontos pode precisar ser dividida em mais de 16 subcenas. O grande número de tarefas independentes resultantes desse método significa que mais tempo do anotador é gasto na alternância de contexto entre as tarefas, e os trabalhadores podem perder o contexto quando a cena é muito pequena, resultando em dados rotulados incorretamente.

Amostra de passo fixo

Uma abordagem alternativa é selecionar ou criar um número reduzido de pontos por uma subamostra linear, chamada de amostra de passo fixo. Digamos que você queira atingir uma meta de 500,000 pontos (observamos que isso geralmente pode ser renderizado em um laptop de consumo - consulte Formato de dados 3D brutos aceitos), mas você tem uma nuvem de pontos com 10 milhões de pontos. Você pode calcular o tamanho do seu passo como step = 10,000,000 / 500,000 = 20. Depois de definir o tamanho do passo, você pode selecionar cada vigésimo ponto em seu conjunto de dados, criando uma nova nuvem de pontos. Se os dados da sua nuvem de pontos tiverem densidade alta o suficiente, os rotuladores ainda serão capazes de identificar quaisquer recursos relevantes para a rotulagem, mesmo que você tenha apenas 20 ponto para cada 1 na cena original.

A desvantagem dessa abordagem é que nem todos os pontos contribuem para o resultado final reduzido, o que significa que, se um ponto for um dos poucos importantes, mas não fizer parte da amostra, seus anotadores podem perder totalmente o recurso.

voxel significa

Uma forma alternativa de redução da resolução que usa todos os pontos para gerar uma nuvem de pontos reduzida é executar filtragem de grade. A filtragem de grade significa que você divide o espaço de entrada em caixas 3D regulares (ou voxels) na nuvem de pontos e substitui todos os pontos dentro de um voxel por um único ponto representativo (o ponto médio, por exemplo). O diagrama a seguir mostra um exemplo de caixa vermelha de voxel.

Se nenhum ponto existir no conjunto de dados de entrada em um determinado voxel, nenhum ponto será adicionado à nuvem de pontos reduzida para aquele voxel. A filtragem de grade difere de uma amostra de etapa fixa porque você pode usá-la para reduzir o ruído e ajustá-la ainda mais ajustando o tamanho do kernel e a função de média para resultar em nuvens de pontos finais ligeiramente diferentes. As nuvens de pontos a seguir mostram os resultados do downsampling simples (amostra de etapa fixa) e avançado (média de voxels). A nuvem de pontos reduzida usando o método avançado é mais suave, isso é particularmente perceptível ao comparar a parede de tijolos vermelhos na parte de trás de ambas as cenas.

Abordagem de upsampling

Depois de reduzir a resolução e rotular seus dados, você pode querer ver os rótulos produzidos na nuvem de pontos menor e reduzida projetada na nuvem de pontos em tamanho real, que chamamos de aumento da resolução. Os trabalhos de detecção ou rastreamento de objetos não requerem pós-processamento para fazer isso. Os rótulos na nuvem de pontos reduzida (como cubóides) são diretamente aplicáveis ​​à nuvem de pontos maior porque são definidos em um espaço de coordenadas mundial compartilhado pela nuvem de pontos em tamanho real (x, y, z, altura, largura, comprimento). Esses rótulos são minimamente suscetíveis a erros muito pequenos ao longo dos limites dos objetos quando um ponto de limite não estava no conjunto de dados reduzido, mas esses erros ocasionais e menores são superados pelo número de pontos extras rotulados corretamente dentro do cubóide que também podem ser treinado em.

Para tarefas de segmentação semântica de nuvem de pontos 3D, no entanto, os rótulos não são diretamente aplicáveis ​​ao conjunto de dados em tamanho real. Temos apenas um subconjunto dos rótulos, mas queremos prever o restante dos rótulos completos do conjunto de dados com base nesse subconjunto. Para fazer isso, podemos usar um simples Classificador K-Nearest Neighbours (K-NN) com os pontos já rotulados servindo como conjunto de treinamento. K-NN é um algoritmo de ML supervisionado simples que prevê o rótulo de um ponto usando os “K” pontos rotulados mais próximos e um voto ponderado. Com K-NN, podemos prever a classe de pontos do restante dos pontos não rotulados no conjunto de dados em tamanho real com base na classe majoritária dos três pontos mais próximos (por distância euclidiana). Podemos refinar ainda mais essa abordagem variando os hiperparâmetros de um classificador K-NN, como o número de pontos mais próximos a serem considerados, bem como a métrica de distância e o esquema de ponderação dos pontos.

Depois de mapear os rótulos de amostra para o conjunto de dados completo, você pode visualizar os blocos no conjunto de dados em tamanho real para ver como a estratégia de upsampling funcionou.

Agora que revisamos os métodos usados ​​nesta postagem, demonstramos essas técnicas em um bloco de anotações do SageMaker em um exemplo de cena de nuvem de pontos de segmentação semântica.

Pré-requisitos

Para percorrer esta solução, você precisa do seguinte:

• An Conta da AWS.
• Um caderno Gerenciamento de acesso e identidade da AWS (IAM) com as permissões necessárias para concluir este passo a passo. Sua função do IAM deve ter as seguintes políticas gerenciadas pela AWS anexadas:
  • AmazonS3FullAccess
  • AmazonSageMakerFullAccess
• An Serviço de armazenamento simples da Amazon (Amazon S3) bucket onde os artefatos do notebook (dados de entrada e rótulos) são armazenados.
• Uma equipe de trabalho SageMaker. Para esta postagem, utilizamos uma equipe de trabalho particular. Você pode criar uma equipe de trabalho no console do SageMaker.

Configuração do notebook

Usamos o caderno ground_truth_annotation_dense_point_cloud_tutorial.ipynb no Exemplos SageMaker seção de uma instância de notebook para demonstrar essas abordagens de redução e aumento da resolução. Este bloco de anotações contém todo o código necessário para realizar pré-processamento, rotulagem e pós-processamento.

Para acessar o notebook, conclua as seguintes etapas:

1. Crie uma instância do notebook. Você pode usar o tipo de instância, ml.t2.xlarge, para iniciar a instância do notebook. Escolha uma instância com pelo menos 16 GB de RAM.
   1. Você precisa usar a função do IAM do notebook criada anteriormente. Essa função permite que seu bloco de anotações carregue seu conjunto de dados no Amazon S3 e chame as APIs da solução.
2. Abra o Jupyter Lab ou Jupyter para acessar sua instância de notebook.
3. No Jupyter, escolha o Exemplos SageMaker No Jupyter Lab, escolha o ícone SageMaker.
4. Escolha Empregos de rotulagem de verdade fundamental e depois escolha o ipynb notebook.
5. Se você estiver usando o Jupyter, escolha Use para copiar o notebook para sua instância e executá-lo. Se você estiver no laboratório Jupyter, escolha Crie uma cópia.

Forneça entradas de notebook

Primeiro, modificamos o notebook para adicionar nosso ARN de equipe de trabalho privado e o local do bucket que usamos para armazenar nosso conjunto de dados, bem como nossos rótulos.

Seção 1: Recupere o conjunto de dados e visualize a nuvem de pontos

Baixamos nossos dados executando a Seção 1 de nosso notebook, que baixa nosso conjunto de dados do Amazon S3 e carrega a nuvem de pontos em nossa instância de notebook. Baixamos dados preparados de forma personalizada de um bucket de propriedade da AWS. Um objeto chamado rooftop_12_49_41.xyz deve estar na raiz do bucket S3. Esses dados são uma varredura de um telhado de prédio de apartamentos personalizado gerado em um dispositivo móvel. Nesse caso, os dados da nuvem de pontos estão no formato xyzrgb.

Podemos visualizar nossa nuvem de pontos usando o Matplotlib dispersão3d função. O arquivo de nuvem de pontos contém todos os pontos corretos, mas não está girado corretamente. Podemos girar o objeto em torno de seu eixo multiplicando a nuvem de pontos por uma matriz de rotação. Podemos obter uma matriz de rotação usando espiar e especifique as alterações de grau que queremos fazer em cada eixo usando o from_euler método:

!aws s3 cp s3://smgt-downsampling-us-east-1-322552456788/rooftop_12_49_41.xyz pointcloud.xyz # Let's read our dataset into a numpy file pc = np.loadtxt("pointcloud.xyz", delimiter=",") print(f"Loaded points of shape {pc.shape}") # playing with view of 3D scene from scipy.spatial.transform import Rotation def plot_pointcloud(pc, rot = [[30,90,60]], color=True, title="Simple Downsampling 1", figsize=(50,25), verbose=False): if rot: rot1 = Rotation.from_euler('zyx', [[30,90,60]], degrees=True) R1 = rot1.as_matrix() if verbose: print('Rotation matrix:','n',R1) # matrix multiplication between our rotation matrix and pointcloud pc_show = np.matmul(R1, pc.copy()[:,:3].transpose() ).transpose() if color: try: rot_color1 = np.matmul(R1, pc.copy()[:,3:].transpose() ).transpose().squeeze() except: rot_color1 = np.matmul(R1, np.tile(pc.copy()[:,3],(3,1))).transpose().squeeze() else: pc_show = pc fig = plt.figure( figsize=figsize) ax = fig.add_subplot(111, projection="3d") ax.set_title(title, fontdict={'fontsize':20}) if color: ax.scatter(pc_show[:,0], pc_show[:,1], pc_show[:,2], c=rot_color1[:,0], s=0.05) else: ax.scatter(pc_show[:,0], pc_show[:,1], pc_show[:,2], c='blue', s=0.05) # rotate in z direction 30 degrees, y direction 90 degrees, and x direction 60 degrees rot1 = Rotation.from_euler('zyx', [[30,90,60]], degrees=True) print('Rotation matrix:','n', rot1.as_matrix()) plot_pointcloud(pc, rot = [[30,90,60]], color=True, title="Full pointcloud", figsize=(50,30)) 

Seção 2: reduza a amostra do conjunto de dados

Em seguida, reduzimos o conjunto de dados para menos de 500,000 pontos, que é um número ideal de pontos para visualização e rotulagem. Para mais informações, consulte o Limites de Resolução da Nuvem de Pontos in Formatos de dados 3D brutos aceitos. Em seguida, plotamos os resultados de nosso downsampling executando a Seção 2.

Como discutimos anteriormente, a forma mais simples de redução da resolução é escolher valores usando um tamanho de passo fixo com base no tamanho que queremos que nossa nuvem de pontos resultante seja.

Uma abordagem mais avançada é dividir o espaço de entrada em cubos, também conhecidos como voxels, e escolher um único ponto por caixa usando uma função de média. Uma implementação simples disso é mostrada no código a seguir.

Você pode ajustar o número alvo de pontos e o tamanho da caixa usados ​​para ver a redução na clareza da nuvem de pontos à medida que uma redução de resolução mais agressiva é executada.

#Basic Approach target_num_pts = 500_000 subsample = int(np.ceil(len(pc) / target_num_pts)) pc_downsample_simple = pc[::subsample] print(f"We've subsampled to {len(pc_downsample_simple)} points") #Advanced Approach boxsize = 0.013 # 1.3 cm box size. mins = pc[:,:3].min(axis=0) maxes = pc[:,:3].max(axis=0) volume = maxes - mins num_boxes_per_axis = np.ceil(volume / boxsize).astype('int32').tolist() num_boxes_per_axis.extend([1]) print(num_boxes_per_axis) # For each voxel or "box", use the mean of the box to chose which points are in the box. means, _, _ = scipy.stats.binned_statistic_dd( pc[:,:4], [pc[:,0], pc[:,1], pc[:,2], pc[:,3]], statistic="mean", bins=num_boxes_per_axis, ) x_means = means[0,~np.isnan(means[0])].flatten() y_means = means[1,~np.isnan(means[1])].flatten() z_means = means[2,~np.isnan(means[2])].flatten() c_means = means[3,~np.isnan(means[3])].flatten() pc_downsample_adv = np.column_stack([x_means, y_means, z_means, c_means]) print(pc_downsample_adv.shape) 

Seção 3: Visualize a renderização 3D

Podemos visualizar nuvens de pontos usando um gráfico de dispersão 3D dos pontos. Embora nossas nuvens de pontos tenham cores, nossas transformações têm efeitos diferentes na cor, portanto, compará-las em uma única cor fornece uma comparação melhor. Podemos ver que o método avançado de média voxel cria uma nuvem de pontos mais suave porque a média tem um efeito de redução de ruído. No código a seguir, podemos observar nossas nuvens de pontos de duas perspectivas separadas, multiplicando nossas nuvens de pontos por diferentes matrizes de rotação.

Ao executar a Seção 3 no notebook, você também vê uma comparação de uma abordagem de passo linear versus uma abordagem de grade de caixa, especificamente em como o filtro de grade de caixa tem um leve efeito de suavização na nuvem de pontos geral. Essa suavização pode ser importante dependendo do nível de ruído do seu conjunto de dados. Modificar a função de filtragem de grade de média para mediana ou alguma outra função de média também pode melhorar a clareza final da nuvem de pontos. Observe atentamente a parede posterior dos exemplos reduzidos simples (tamanho do passo fixo) e avançado (média do voxel), observe o efeito de suavização que o método da média do voxel tem em comparação com o método do tamanho do passo fixo.

rot1 = Rotation.from_euler('zyx', [[30,90,60]], degrees=True) R1 = rot1.as_matrix() simple_rot1 = pc_downsample_simple.copy() simple_rot1 = np.matmul(R1, simple_rot1[:,:3].transpose() ).transpose() advanced_rot1 = pc_downsample_adv.copy() advanced_rot1 = np.matmul(R1, advanced_rot1[:,:3].transpose() ).transpose() fig = plt.figure( figsize=(50, 30)) ax = fig.add_subplot(121, projection="3d") ax.set_title("Simple Downsampling 1", fontdict={'fontsize':20}) ax.scatter(simple_rot1[:,0], simple_rot1[:,1], simple_rot1[:,2], c='blue', s=0.05) ax = fig.add_subplot(122, projection="3d") ax.set_title("Voxel Mean Downsampling 1", fontdict={'fontsize':20}) ax.scatter(advanced_rot1[:,0], advanced_rot1[:,1], advanced_rot1[:,2], c='blue', s=0.05) # to look at any of the individual pointclouds or rotate the pointcloud, use the following function plot_pointcloud(pc_downsample_adv, rot = [[30,90,60]], color=True, title="Advanced Downsampling", figsize=(50,30)) 

Seção 4: iniciar um trabalho de segmentação semântica

Execute a Seção 4 no bloco de anotações para pegar essa nuvem de pontos e iniciar um trabalho de rotulagem de segmentação semântica da nuvem de pontos do Ground Truth usando-a. Essas células geram o arquivo de manifesto de entrada necessário e formatam a nuvem de pontos em uma representação compatível com o Ground Truth.

Para saber mais sobre o formato de entrada do Ground Truth no que se refere aos dados da nuvem de pontos, consulte Dados de entrada e Formatos de dados 3D brutos aceitos.

Nesta seção, também realizamos a rotulagem no portal do trabalhador. Rotulamos um subconjunto da nuvem de pontos para ter algumas anotações para realizar o upsampling. Quando o trabalho é concluído, carregamos as anotações do Amazon S3 em uma matriz NumPy para nosso pós-processamento. A seguir, uma captura de tela da ferramenta de segmentação semântica da nuvem de pontos do Ground Truth.

Seção 5: Realizar upsampling de etiquetas

Agora que temos os rótulos reduzidos, treinamos um classificador K-NN do SKLearn para prever os rótulos completos do conjunto de dados tratando nossos pontos anotados como dados de treinamento e realizando inferência no restante dos pontos não rotulados em nossa nuvem de pontos em tamanho real.

Você pode ajustar o número de pontos usados, bem como a métrica de distância e o esquema de ponderação para influenciar como a inferência de rótulos é realizada. Se você rotular alguns ladrilhos no conjunto de dados em tamanho real, poderá usar esses ladrilhos rotulados como base para avaliar a precisão das previsões K-NN. Você pode então usar essa métrica de precisão para ajuste de hiperparâmetros de K-NN ou para tentar diferentes algoritmos de inferência para reduzir o número de pontos mal classificados entre os limites do objeto, resultando na menor taxa de erro possível na amostra. Veja o seguinte código:

# There's a lot of possibility to tune KNN further # 1) Prevent classification of points far away from all other points (random unfiltered ground point) # 2) Perform a non-uniform weighted vote # 3) Tweak number of neighbors knn = KNeighborsClassifier(n_neighbors=3) print(f"Training on {len(pc_downsample_adv)} labeled points") knn.fit(pc_downsample_adv[:,:3], annotations) print(f"Upsampled to {len(pc)} labeled points") annotations_full = knn.predict(pc[:,:3]) 

Seção 6: Visualize os rótulos com upsampling

Agora que realizamos o upsampling de nossos dados rotulados, podemos visualizar um bloco da nuvem de pontos original em tamanho real. Não estamos renderizando toda a nuvem de pontos em tamanho real porque isso pode impedir que nossa ferramenta de visualização seja renderizada. Veja o seguinte código:

pc_downsample_annotated = np.column_stack((pc_downsample_adv[:,:3], annotations)) pc_annotated = np.column_stack((pc[:,:3], annotations_full)) labeled_area = pc_downsample_annotated[pc_downsample_annotated[:,3] != 255] min_bounds = np.min(labeled_area, axis=0) max_bounds = np.max(labeled_area, axis=0) min_bounds = [-2, -2, -4.5, -1] max_bounds = [2, 2, -1, 256] def extract_tile(point_cloud, min_bounds, max_bounds): return point_cloud[ (point_cloud[:,0] > min_bounds[0]) & (point_cloud[:,1] > min_bounds[1]) & (point_cloud[:,2] > min_bounds[2]) & (point_cloud[:,0] < max_bounds[0]) & (point_cloud[:,1] < max_bounds[1]) & (point_cloud[:,2] < max_bounds[2]) ] tile_downsample_annotated = extract_tile(pc_downsample_annotated, min_bounds, max_bounds) tile_annotated = extract_tile(pc_annotated, min_bounds, max_bounds) rot1 = Rotation.from_euler('zyx', [[30,90,60]], degrees=True) R1 = rot1.as_matrix() down_rot = tile_downsample_annotated.copy() down_rot = np.matmul(R1, down_rot[:,:3].transpose() ).transpose() down_rot_color = np.matmul(R1, np.tile(tile_downsample_annotated.copy()[:,3],(3,1))).transpose().squeeze() full_rot = tile_annotated.copy() full_rot = np.matmul(R1, full_rot[:,:3].transpose() ).transpose() full_rot_color = np.matmul(R1, np.tile(tile_annotated.copy()[:,3],(3,1))).transpose().squeeze() fig = plt.figure(figsize=(50, 20)) ax = fig.add_subplot(121, projection="3d") ax.set_title("Downsampled Annotations", fontdict={'fontsize':20}) ax.scatter(down_rot[:,0], down_rot[:,1], down_rot[:,2], c=down_rot_color[:,0], s=0.05) ax = fig.add_subplot(122, projection="3d") ax.set_title("Upsampled Annotations", fontdict={'fontsize':20}) ax.scatter(full_rot[:,0], full_rot[:,1], full_rot[:,2], c=full_rot_color[:,0], s=0.05) 

Como nosso conjunto de dados é denso, podemos visualizar os rótulos com amostragem aumentada em um bloco para ver os rótulos com amostragem reduzida ampliada para a nuvem de pontos em tamanho real. Embora um pequeno número de erros de classificação possa existir ao longo das regiões de limite entre os objetos, você também tem muito mais pontos rotulados corretamente na nuvem de pontos em tamanho real do que na nuvem de pontos inicial, o que significa que sua precisão geral de ML pode melhorar.

Limpar

Instância de notebook: você tem duas opções se não quiser manter a instância de notebook criada em execução. Se você quiser salvá-lo para mais tarde, pode interrompê-lo em vez de excluí-lo.

• Para Pare uma instância de notebook: clique no Instâncias de notebook link no painel esquerdo da página inicial do console SageMaker. A seguir, clique no Dê um basta link na coluna 'Ações' à esquerda do nome da sua instância de notebook. Depois que a instância do bloco de anotações for interrompida, você poderá iniciá-la novamente clicando no botão Início link. Lembre-se de que, se você interrompê-lo em vez de excluí-lo, será cobrado pelo armazenamento associado a ele.
• Para excluir uma instância de notebook: primeiro pare de acordo com as instruções acima. Em seguida, clique no botão de opção ao lado de sua instância de bloco de anotações e selecione Apagar do Opções menu suspenso.

Conclusão

A redução da amostragem de nuvens de pontos pode ser um método viável ao pré-processar dados para detecção de objetos e rotulagem de rastreamento de objetos. Ele pode reduzir os custos de etiquetagem enquanto ainda gera etiquetas de saída de alta qualidade, especialmente para detecção de objetos 3D e tarefas de rastreamento. Nesta postagem, demonstramos como o método de redução da resolução pode afetar a clareza da nuvem de pontos para os trabalhadores e mostramos algumas abordagens que têm compensações com base no nível de ruído do conjunto de dados.

Por fim, mostramos que você pode executar trabalhos de segmentação semântica de nuvem de pontos 3D em conjuntos de dados com amostragem reduzida e mapear os rótulos para a nuvem de pontos de tamanho completo por meio de previsão na amostra. Conseguimos isso treinando um classificador para fazer inferência nos pontos restantes do tamanho do conjunto de dados completo, usando os pontos já rotulados como dados de treinamento. Essa abordagem permite a rotulagem econômica de cenas de nuvens de pontos altamente densas, mantendo a boa qualidade geral da etiqueta.

Testar este caderno com suas próprias cenas densas de nuvens de pontos no Ground Truth, experimente novas técnicas de downsampling e até mesmo novos modelos além do K-NN para previsão final na amostra para ver se as técnicas de downsampling e upsampling podem reduzir seus custos de rotulagem.

Sobre os autores

 Vidya Sagar Ravipati é arquiteto de aprendizado profundo na Laboratório de soluções de ML da Amazon, onde ele aproveita sua vasta experiência em sistemas distribuídos de grande escala e sua paixão pelo aprendizado de máquina para ajudar os clientes da AWS em diferentes setores da indústria a acelerar sua adoção de IA e nuvem. Anteriormente, ele foi engenheiro de aprendizado de máquina em serviços de conectividade na Amazon, que ajudou a construir plataformas de personalização e manutenção preditiva.

Isaac Privitera é arquiteto de soluções especialista em aprendizado de máquina e ajuda os clientes a projetar e construir soluções de visão computacional de nível empresarial na AWS. Isaac tem experiência no uso de aprendizado de máquina e computação acelerada para visão computacional e análise de sinais. Isaac também gosta de cozinhar, fazer caminhadas e acompanhar os últimos avanços em aprendizado de máquina em seu tempo livre.

Jeremy Feltracco é engenheiro de desenvolvimento de software no Amazon ML Solutions Lab na Amazon Web Services. Ele usa sua experiência em visão computacional, robótica e aprendizado de máquina para ajudar os clientes da AWS a acelerar sua adoção de IA.

Fonte: https://aws.amazon.com/blogs/machine-learning/annotate-dense-point-cloud-data-using-sagemaker-ground-truth/