Kommenter tette punktskydata ved hjelp av SageMaker Ground Truth

Autonome kjøretøyfirmaer bruker vanligvis LiDAR sensorer for å generere en 3D-forståelse av miljøet rundt kjøretøyene sine. For eksempel monterer de en LiDAR-sensor på kjøretøyene sine for kontinuerlig å fange øyeblikksbilder av det omkringliggende 3D-miljøet. LiDAR-sensorutgangen er en sekvens av 3D-punktskyrammer (den typiske fangsthastigheten er 10 bilder per sekund). Amazon SageMaker Ground Truth gjør det enkelt å merke objekter i en enkelt 3D-ramme eller på tvers av en sekvens av 3D-punktskyrammer for å bygge maskinlærings (ML) -opplæringsdatasett. Ground Truth støtter også sensorfusjon av kamera og LiDAR-data med opptil åtte videokamerainnganger.

Etter hvert som LiDAR-sensorer blir mer tilgjengelige og kostnadseffektive, bruker kundene i økende grad punktskydata i nye rom som robotikk, signalkartlegging og utvidet virkelighet. Noen nye mobile enheter inkluderer til og med LiDAR-sensorer, hvorav den ene leverte dataene for dette innlegget! Den økende tilgjengeligheten av LiDAR-sensorer har økt interessen for punktskydata for ML-oppgaver, som 3D-gjenstandsdeteksjon og -sporing, 3D-segmentering, 3D-objektsyntese og rekonstruksjon, og til og med å bruke 3D-data for å validere 2D dybdeestimering.

Selv om tette punktskydata er rikt på informasjon (over 1 million punktskyer), er det utfordrende å merke fordi merking av arbeidsstasjoner ofte har begrenset minne, og grafikkfunksjoner og kommentatorer har en tendens til å være geografisk distribuert, noe som kan øke ventetiden. Selv om et stort antall poeng kan gjengis i arbeidsstasjonen til en etiketter, kan etikettens gjennomstrømning reduseres på grunn av gjengivelsestiden når du arbeider med flere millioner store punktskyer, noe som øker merkingskostnadene og reduserer effektiviteten.

En måte å redusere disse kostnadene og tiden på er å konvertere jobber med punktsky-merking til mindre, lettere gjengitte oppgaver som bevarer det meste av punktskyens opprinnelige informasjon for kommentar. Vi refererer til disse tilnærmingene bredt som nedsampling, lik nedsampling i signalbehandlingsdomenet. Som i signalbehandlingsdomenet, forsøker tilnærminger med punktskyprøver å fjerne punkter mens de bevarer trofastheten til den opprinnelige punktskyen. Når du kommenterer nedskyvede punktskyer, kan du bruke utdata 3D kuboider forum gjenstand sporing og objektdeteksjon oppgaver direkte for opplæring eller validering i full-size-skyen, med liten eller ingen innvirkning på modellytelsen mens du sparer merkingstid. For andre modaliteter, som semantisk segmentering, der hvert punkt har sin egen etikett, kan du bruke de nedprøvde etikettene til å forutsi etikettene på hvert punkt i den opprinnelige punktskyen, slik at du kan utveksle mellom merkekostnader (og dermed mengden merkede data) og en liten mengde feilklassifisering av poeng i punktskyen i full størrelse.

I dette innlegget går vi gjennom hvordan du utfører nedprøvingsteknikker for å forberede poengskydataene dine for merking, og demonstrerer deretter hvordan du kan samplere utdataetikettene dine for å bruke det originale datasettet i full størrelse ved hjelp av en inferens i slutten med en enkel ML-modell. For å oppnå dette bruker vi Ground Truth and Amazon SageMaker notatbokforekomster å utføre merking og alle trinn for forbehandling og etterbehandling.

Dataene

Dataene vi bruker i dette innlegget er en skanning av et tak på en bygård som ble generert ved hjelp av 3D-skannerappen på en iPhone12 Pro. Appen lar deg bruke de innebygde LiDAR-skannerne på mobile enheter til å skanne et gitt område og eksportere en punktskyfil. I dette tilfellet er punktskyedataene i xyzrgb-format, et akseptert format for en Ground Truth-punktsky. For mer informasjon om datatypene som er tillatt i en jordens sannhetspunktsky, se Aksepterte rå 3D-dataformater.

Følgende bilde viser vår 3D-skanning.

Metoder

Vi går først gjennom noen tilnærminger for å redusere datasettstørrelsen for merking av punktskyer: flislegging, fast trinnprøve og voxel-gjennomsnitt. Vi demonstrerer hvorfor nedprøvingsteknikker kan øke merkingsgjennomstrømningen din uten å ofre merkekvaliteten, og deretter demonstrerer vi hvordan du bruker etiketter opprettet på den nedsamplede punktskyen og bruker dem på den opprinnelige punktskyen med en oppsamplingsmetode.

Nedprøving nærmer seg

Downsampling tar ditt datasett i full størrelse og velger enten en delmengde poeng fra den til merking, eller oppretter et representativt sett med nye punkter som ikke nødvendigvis er i det opprinnelige datasettet, men som er nær nok til å tillate merking.

flislegging

En naiv tilnærming er å dele poengskyen din i 3D-kuber, ellers kjent som lydelementer, av (for eksempel) 500,000 XNUMX poeng hver som er merket uavhengig parallelt. Denne tilnærmingen, kalt flisleggingreduserer scenestørrelsen effektivt for merking.

Imidlertid kan det øke merkingstiden og kostnadene sterkt, fordi en typisk scene på 8 millioner poeng kan trenge å bli delt opp i over 16 underscener. Det store antallet uavhengige oppgaver som følge av denne metoden betyr at mer tid til kommentatorene brukes på kontekstbytte mellom oppgaver, og arbeidere kan miste kontekst når scenen er for liten, noe som resulterer i feilmerkede data.

Fast trinnprøve

En alternativ tilnærming er å velge eller opprette et redusert antall poeng ved en lineær delprøve, kalt a fast trinnprøve. La oss si at du vil nå et mål på 500,000 XNUMX poeng (vi har observert at dette vanligvis kan gjengis på en bærbar datamaskin for forbrukerne - se Godkjent Raw 3D-dataformat), men du har en poengsky med 10 millioner poeng. Du kan beregne trinnstørrelsen din som step = 10,000,000 / 500,000 = 20. Etter at du har en trinnstørrelse, kan du velge hvert 20. punkt i datasettet ditt og opprette en ny punktsky. Hvis poengskydataene dine har høy nok tetthet, bør etikettere fremdeles kunne finne ut hvilke relevante funksjoner for merking, selv om du kanskje bare har 1 poeng for hver 20 i den originale scenen.

Ulempen med denne tilnærmingen er at ikke alle poeng bidrar til det endelige nedprøvede resultatet, noe som betyr at hvis et punkt er et av få viktige, men ikke en del av prøven, kan kommentatorene dine savne funksjonen helt.

Voxel mener

En alternativ form for downsampling som bruker alle poeng for å generere en downsampled point cloud er å utføre rutenettfiltrering. Rutenettfiltrering betyr at du deler inntastingsrommet i vanlige 3D-bokser (eller voxels) over punktskyen og erstatter alle punkter i en voxel med et enkelt representativt punkt (for eksempel gjennomsnittspunktet). Følgende diagram viser et eksempel på en rød voxel-rute.

Hvis det ikke finnes poeng fra inngangssettet i en gitt voxel, blir det ikke lagt til noe punkt i den nedsamplede punktskyen for den voxel. Rutenettfiltrering skiller seg fra en fast trinnprøve fordi du kan bruke den til å redusere støy og justere den ytterligere ved å justere kjernestørrelsen og gjennomsnittsfunksjonen for å resultere i litt forskjellige sluttpunktskyer. Følgende punktskyer viser resultatene av enkel (fast trinnprøve) og avansert (voxel gjennomsnitt) nedprøving. Punktskyen som ble nedprøvd ved hjelp av den avanserte metoden, er jevnere, dette er spesielt merkbart når man sammenligner den røde murveggen bak på begge scenene.

Oppsamplingstilnærming

Etter nedprøving og merking av dataene dine, kan det være lurt å se etikettene som er produsert på den mindre, nedprøvede punktskyen projisert på punktskyen i full størrelse, som vi kaller oppsampling. Objektgjenkjenning eller sporingsjobber krever ikke etterbehandling for å gjøre dette. Etiketter i den nedsamplede punktskyen (som cuboider) gjelder direkte for den større punktskyen fordi de er definert i et verdenskoordinatrom som deles av punktskyen i full størrelse (x, y, z, høyde, bredde, lengde). Disse etikettene er minimalt utsatt for veldig små feil langs grensene til objekter når et grensepunkt ikke var i datasamplet, men slike sporadiske og mindre feil oppveies av antall ekstra, riktig merkede punkter i kuboidet som også kan trent på.

For semantiske segmenteringsjobber for 3D-punktskyer er imidlertid etikettene ikke direkte gjeldende for datasettet i full størrelse. Vi har bare et delsett av etikettene, men vi vil forutsi resten av hele datasettetikettene basert på dette delsettet. For å gjøre dette kan vi bruke en enkel K-nærmeste nabo (K-NN) klassifisering med de allerede merkede poengene som fungerer som treningssett. K-NN er en enkel overvåket ML-algoritme som forutsier etiketten til et punkt ved å bruke de "K" nærmeste merkede punktene og en vektet stemme. Med K-NN kan vi forutsi poengklassen til resten av de umerkede punktene i datasettet i full størrelse basert på majoritetsklassen til de tre nærmeste (av euklidiske avstand) poeng. Vi kan avgrense denne tilnærmingen ytterligere ved å variere hyperparametrene til en K-NN-klassifikator, som antall nærmeste punkter som skal vurderes, samt avstandsmåling og vektingsskjema for poeng.

Etter at du har tilordnet eksempeletikettene til hele datasettet, kan du visualisere fliser i datasettet i full størrelse for å se hvor godt oppsamplingsstrategien fungerte.

Nå som vi har gjennomgått metodene som brukes i dette innlegget, demonstrerer vi disse teknikkene i en SageMaker-notatbok på et eksempel på semantisk segmenteringspunktskyscene.

Forutsetninger

For å gå gjennom denne løsningen trenger du følgende:

• An AWS-konto.
• En notatbok AWS identitets- og tilgangsadministrasjon (IAM) rolle med tillatelsene som kreves for å fullføre denne gjennomgangen. IAM-rollen din må ha følgende AWS-administrerte retningslinjer:
  • AmazonS3FullAccess
  • AmazonSageMakerFullAccess
• An Amazon enkel lagringstjeneste (Amazon S3) bøtte der bærbare gjenstander (inndata og etiketter) er lagret.
• Et SageMaker arbeidsteam. For dette innlegget bruker vi et privat arbeidsteam. Du kan opprette et arbeidsteam på SageMaker-konsollen.

Oppsett av bærbar PC

Vi bruker notatboken ground_truth_annotation_dense_point_cloud_tutorial.ipynb i SageMaker Eksempler delen av en notatbokforekomst for å demonstrere disse tilnærmingene til nedsampling og oppsampling. Denne notatblokken inneholder all kode som kreves for å utføre forbehandling, merking og etterbehandling.

Gjør følgende for å få tilgang til notatboken:

1. Opprett en notisbokforekomst. Du kan bruke forekomsttypen, ml.t2.xlarge, for å starte notatblokkforekomsten. Velg en forekomst med minst 16 GB RAM.
   1. Du må bruke den bærbare IAM-rollen du opprettet tidlig. Denne rollen lar den bærbare datamaskinen din laste opp datasettet ditt til Amazon S3 og ringe løsningen API-er.
2. Åpne Jupyter Lab eller Jupyter til få tilgang til notatbokforekomsten.
3. I Jupyter velger du SageMaker Eksempler Velg SageMaker-ikonet i Jupyter Lab.
4. Velg Bakkenes sannhetsmerkejobber og velg deretter ipynb notisbok.
5. Hvis du bruker Jupyter, velger du Bruk for å kopiere notatboken til din forekomst og kjøre den. Hvis du er i Jupyter lab, velg Lag en kopi.

Gi bærbare innganger

Først endrer vi notatboken for å legge til vårt private arbeidsteam ARN og bøtteplasseringen vi bruker for å lagre datasettet vårt samt etikettene våre.

Seksjon 1: Hent datasettet og visualiser punktskyen

Vi laster ned dataene våre ved å kjøre del 1 av notatboken, som laster ned datasettet vårt fra Amazon S3 og laster poengskyen inn i notatbokforekomsten. Vi laster ned tilpassede data fra en AWS-eid bøtte. Et objekt som heter rooftop_12_49_41.xyz skal være i roten til S3-skuffen. Disse dataene er en skanning av en spesialtilpasset takbygning generert på en mobil enhet. I dette tilfellet er punktskyedataene i xyzrgb-format.

Vi kan visualisere poengskyen vår ved hjelp av Matplotlib scatter3d funksjon. Punktskyfilen inneholder alle riktige punkter, men roteres ikke riktig. Vi kan rotere objektet rundt sin akse ved å multiplisere punktskyen med en rotasjonsmatrise. Vi kan få en rotasjonsmatrise ved hjelp av scipy og spesifiser gradendringene vi vil gjøre på hver akse ved hjelp av from_euler metode:

!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)) 

Seksjon 2: Nedprøver datasettet

Deretter nedprøver vi datasettet til mindre enn 500,000 XNUMX poeng, som er et ideelt antall poeng for visualisering og merking. For mer informasjon, se Punktskyoppløsningsgrenser in Aksepterte rå 3D-dataformater. Deretter plotter vi resultatene av vår nedprøving ved å kjøre avsnitt 2.

Som vi diskuterte tidligere, er den enkleste formen for nedprøving å velge verdier ved hjelp av en fast trinnstørrelse basert på hvor stor vi vil at vår resulterende punktsky skal være.

En mer avansert tilnærming er å dele inngangsrommet i kuber, ellers kjent som voxels, og velge et enkelt punkt per boks ved hjelp av en gjennomsnittsfunksjon. En enkel implementering av dette vises i følgende kode.

Du kan innstille målet antall poeng og størrelsen på boksen som brukes til å se reduksjonen i klarhet i punktskyen når mer aggressiv nedprøving utføres.

#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) 

Seksjon 3: Visualiser 3D-gjengivelse

Vi kan visualisere punktskyer ved hjelp av et 3D-spredningsdiagram av punktene. Selv om punktskyene våre har farger, har transformasjonene våre forskjellige effekter på farge, så det å sammenligne dem i en enkelt farge gir en bedre sammenligning. Vi kan se at den avanserte metoden for voxel-middel skaper en jevnere punktsky fordi gjennomsnitt har en støyreduksjonseffekt. I den følgende koden kan vi se på punktskyene våre fra to separate perspektiver ved å multiplisere punktskyene våre med forskjellige rotasjonsmatriser.

Når du kjører seksjon 3 i notatboken, ser du også en sammenligning av en lineær trinntilnærming mot en boksnetttilnærming, spesielt i hvordan boksnettfilteret har en liten utjevningseffekt på den samlede punktskyen. Denne utjevningen kan være viktig avhengig av støynivået i datasettet ditt. Endring av rutenettfiltreringsfunksjonen fra middel til median eller en annen gjennomsnittsfunksjon kan også forbedre den endelige punktskyens klarhet. Se nøye på bakveggen til de enkle (faste trinnstørrelsen) og avanserte (voxel-middel) eksempler, og legg merke til den utjevnende effekten voxel-gjennomsnittsmetoden har sammenlignet med metoden med fast trinnstørrelse.

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)) 

Seksjon 4: Start en semantisk segmenteringsjobb

Kjør seksjon 4 i notatboken for å ta denne punktskyen og start en semantisk merkingsjobb for Ground Truth-punktsky med den. Disse cellene genererer den nødvendige inndata manifestfilen og formaterer poengskyen i en Ground Truth-kompatibel representasjon.

For å lære mer om inngangsformatet til Ground Truth når det gjelder punktsky-data, se Inngangsdata og Aksepterte rå 3D-dataformater.

I denne delen utfører vi også merkingen i arbeiderportalen. Vi merker et delsett av punktskyen for å ha noen merknader å utføre sampling med. Når jobben er fullført, laster vi inn merknadene fra Amazon S3 i et NumPy-utvalg for etterbehandling. Følgende er et skjermbilde fra semantisk segmenteringsverktøy for Ground Truth point cloud.

Del 5: Utfør prøvetaking av etiketter

Nå som vi har de nedprøvde etikettene, trener vi en K-NN-klassifiseringsenhet fra SKLearn for å forutsi hele datasettetikettene ved å behandle våre merkede poeng som treningsdata og utføre slutning på resten av de umerkede punktene i vår punktsky i full størrelse.

Du kan stille inn antall punkter som brukes, samt avstandsmåling og vektingsskjema for å påvirke hvordan etikettledningen utføres. Hvis du merker noen få fliser i datasettet i full størrelse, kan du bruke de merkede flisene som bakkesannhet for å evaluere nøyaktigheten av K-NN-spådommene. Du kan da bruke denne nøyaktighetsberegningen for hyperparameter-innstilling av K-NN eller for å prøve forskjellige inferensalgoritmer for å redusere antall feilklassifiserte punkter mellom objektgrensene, noe som resulterer i lavest mulig feilfrekvens i prøven. Se følgende kode:

# 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]) 

Del 6: Visualiser de samplede etikettene

Nå som vi har utført sampling av de merkede dataene våre, kan vi visualisere en flis av den opprinnelige punktskyen i full størrelse. Vi gjengir ikke hele punktskyen i full størrelse fordi det kan forhindre at visualiseringsverktøyet vårt gjengis. Se følgende kode:

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) 

Fordi datasettet vårt er tett, kan vi visualisere de samplede etikettene i en flis for å se de samplede etikettene som er samplet til punktskyen i full størrelse. Selv om det kan eksistere et lite antall feilklassifiseringer langs grenseregioner mellom objekter, har du også mange mer riktig merkede punkter i punktskyen i full størrelse enn den opprinnelige punktskyen, noe som betyr at den totale ML-nøyaktigheten din kan bli bedre.

Opprydding

Notatbokforekomst: du har to alternativer hvis du ikke vil holde den opprettede notatbokforekomsten i gang. Hvis du vil lagre den til senere, kan du stoppe i stedet for å slette den.

• Til stoppe en notatbokforekomst: klikk på Notatboksforekomster i venstre rute på startsiden til SageMaker-konsollen. Klikk deretter på Stopp lenke under "Handlinger" -kolonnen til venstre for navnet på den bærbare PC-forekomsten. Etter at notatbokforekomsten er stoppet, kan du starte den på nytt ved å klikke på Start lenke. Husk at hvis du stopper i stedet for å slette det, blir du belastet for lagringen som er knyttet til det.
• Til slette en notatbokforekomst: stopp først den i henhold til instruksjonene ovenfor. Deretter klikker du på alternativknappen ved siden av notatbokforekomsten, og velger deretter Delete fra handlinger nedtrekksmenyen.

konklusjonen

Nedskyvningspunktskyer kan være en levedyktig metode når man forhåndsbehandler data for gjenkjenning av objekter og merking av objektsporing. Det kan redusere merkingskostnadene samtidig som det genererer utskriftsetiketter av høy kvalitet, spesielt for 3D-gjenkjennings- og sporingsoppgaver. I dette innlegget demonstrerte vi hvordan nedprøvingsmetoden kan påvirke klarheten i poengskyen for arbeidere, og viste noen tilnærminger som har kompromisser basert på støynivået i datasettet.

Til slutt viste vi at du kan utføre semantiske segmenteringsjobber for 3D-punktskyer på datasamlinger med nedsamplet og kartlegge etikettene til punktskyen i full størrelse gjennom prediksjon. Vi oppnådde dette ved å trene en klassifiseringsenhet for å gjøre slutning på de gjenværende full datasettstørrelsespoengene, ved å bruke de allerede merkede poengene som treningsdata. Denne tilnærmingen muliggjør kostnadseffektiv merking av svært tette punktsky-scener, samtidig som den opprettholder god generell etikettkvalitet.

Test ut denne notatboken med dine egne tette punktskyscener i Ground Truth, prøv nye nedprøvingsteknikker, og til og med prøv nye modeller utover K-NN for endelig prediksjon i prøven for å se om nedprøving og oppsamplingsteknikker kan redusere merkingskostnadene dine.

Om forfatterne

 Vidya Sagar Ravipati er en dyp læringsarkitekt ved Amazon ML Solutions Lab, der han utnytter sin store erfaring innen store distribuerte systemer og sin lidenskap for maskinlæring for å hjelpe AWS-kunder på tvers av forskjellige bransjevirksomheter, få fart på AI og sky-adopsjon. Tidligere var han maskinlæringsingeniør i Connectivity Services hos Amazon som bidro til å bygge personaliserings- og prediktive vedlikeholdsplattformer.

Isaac Privitera er en Machine Learning Specialist Solutions Architect og hjelper kunder med å designe og bygge datamaskinsyn på AWS i bedriftsklasse. Isaac har bakgrunn i bruk av maskinlæring og akselerert databehandling for datasyn og signalanalyse. Isaac liker også å lage mat, vandre og følge med på de siste fremskrittene innen maskinlæring på fritiden.

Jeremy Feltracco er en programvareutviklingsingeniør med Amazon ML Solutions Lab hos Amazon Web Services. Han bruker sin bakgrunn innen datasyn, robotteknologi og maskinlæring for å hjelpe AWS-kunder med å få fart på AI-adopsjonen.

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