QW1lcmlrYWFuc2Ugc2VuYXRvcmVuIGludHJvZHVjZXJlbiBObyBGYWtlcy13ZXRzdm9vcnN0ZWwgb20gQUktcmVwbGljYSdzIHRlIHZlcmJpZWRlbg==

2023-10-26, 16:39

<p><img src="https://gimg2.gateimg.com/image/article/1698338021RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen524874"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De Amerikaanse senatoren hebben een wetsvoorstel ingediend met de titel Nurture Originals, Foster Art, and Keep Entertainment Safe Act of 2023 om personen te beschermen tegen ongeoorloofde digitale replica’s.</p>
<p>De No Fakes Act zal de getroffen personen in staat stellen een juridische procedure tegen de dader te ondernemen.</p>
<p>Deepfakes zijn afbeeldingen of video’s met mensen van wie de gezichten, stemmen of het lichaam zijn aangepast om op iemand anders te lijken of iets anders te zeggen.</p>
<h2 id="h2-Kennismaking543868"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Kunstmatige intelligentie, een van de meest transformerende technologische ontwikkelingen van het decennium, heeft zowel voordelen als bedreigingen met zich meegebracht. Als kunstmatige intelligentie (AI) op de juiste manier wordt gebruikt, verbetert het de productiviteit en transparantie, onder andere waarden. Niettemin kan het bij verkeerd gebruik leiden tot rampzalige gevolgen in ons sociale, politieke en economische leven.</p>
<p>Om eventuele potentiële gevaren die door AI worden opgelegd te voorkomen, hebben verschillende Amerikaanse senatoren een wetsvoorstel voorgesteld om het gebruik van kunstmatige intelligentietechnologie te reguleren bij het produceren van ongeautoriseerde AI-kopieën.</p>
<p>Dit artikel zal het doel en de doelstellingen van de No Fake Bill in de Verenigde Staten bespreken. Het zal ook de voordelen en gevaren van AI-replica’s behandelen.</p>
<h2 id="h2-Bepalingen20van20de20Geen20Neprekening969142"><a name="Bepalingen van de Geen Neprekening" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bepalingen van de Geen Neprekening</h2><p>De Amerikaanse senatoren, Amy Klobuchar (D-MN), Sens. Chris Coons (D-DE), Thom Tillis en Marsha Blackburn (R-TN) sponsoren de No Fakes Act, ook wel The Nurture Originals, Foster Art en Keep Entertainment Safe Act van 2023 genoemd, die het ongeoorloofde gebruik van namen, gezichten of stemmen van andere mensen verbiedt om digitale replica’s te produceren.</p>
<p>Als de No Fakes-wet wordt goedgekeurd, kan elke organisatie of persoon die ongeautoriseerde namen, stemmen of gezichten gebruikt om digitale replica’s te produceren, strafrechtelijk worden vervolgd. De benadeelde partijen kunnen ook platforms aanklagen die dergelijke ongeautoriseerde replica’s hosten.</p>
<p>Zelfs als de persoon de stemmen, namen en gezichten van overleden mensen gebruikt, zal hij/zij nog steeds juridische stappen moeten ondernemen als hij/zij hiervoor geen toestemming heeft. Dat betekent dat als een individu de afbeelding of stem van overleden mensen wil gebruiken, hij/zij goedkeuring moet vragen aan relevante partijen zoals geautoriseerde familieleden. De minimale straf voor het overtreden van de wet zal $5.000 per overtreding zijn.</p>
<p>Het is belangrijk om op te merken dat de No Fakes Act een federale wet zal zijn. Ted Kalo van de Human Artistry-campagne legde verder uit. Hij zei,<br><strong>“Dit zal een federale wet zijn die een uniform systeem creëert voor iedereen. En dit is niet het recht van een label. Dit is niet het recht van een uitgever. Dit is het recht van een kunstenaar dat toebehoort aan een kunstenaar dat zij kunnen opeisen.”</strong></p>
<p>De rechten die zijn vastgelegd in de No Fakes Bill zullen van toepassing zijn op elke levende persoon en gedurende 70 jaar na hun dood. Deze wet is gekomen op een moment dat er veel door AI gegenereerde nummers zijn die de stemmen van artiesten imiteren en waarvan velen op YouTube worden gehost. Daarom zei senator Blackburn dat de wet een “…<br><strong>goede eerste stap</strong>“ om songwriters, acteurs en Amerikaanse creatievelingen te beschermen die “het recht verdienen om hun naam, imago en gelijkenis (NIL) te bezitten”.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2239/ai-focused-cryptocurrencies-outperforming-bitcoin" target="_blank">Waarom presteren op AI gerichte cryptocurrencies beter dan Bitcoin?</a></p>
<h2 id="h2-Het20doel20van20de20No20Fakes20Act433745"><a name="Het doel van de No Fakes Act" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het doel van de No Fakes Act</h2><p>Het algemene doel van het No Fakes-wetsvoorstel is om de productie van digitale replicas te voorkomen “zonder toestemming van de betrokken personen of rechthebbenden.” Mensen <a href="https://www.gate.io/price/artificial-intelligence-ai &quot;use artificial intelligence (AI" rel="nofollow noopener noreferrer" target="_blank">gebruik kunstmatige intelligentie (AI)</a>”) om AI-replica’s te genereren. De wet zal het regelgevend kader creëren voor de getroffen personen om juridische stappen te ondernemen.</p>
<p>Volgens het wetsvoorstel kan elke persoon wiens stem of beeld illegaal is gerepliceerd de maker en het platform dat de ongeautoriseerde door kunstmatige intelligentie aangedreven recreatie host en distribueert aanklagen. Dit betekent dat inhoudsontwikkelingsplatforms zoals Tik Tok, YouTube en Spotify strafrechtelijk vervolgbaar zijn als ze ongeautoriseerde AI-gegenereerde inhoud hosten.</p>
<p>Het belangrijkste doel van de wet zal zijn om ‘te voorkomen dat een persoon een ongeautoriseerde door AI gegenereerde replica van een individu produceert of verspreidt om op te treden in een audiovisuele of geluidsopname zonder de toestemming van het gerepliceerde individu’.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/price/view/artificial-intelligence" target="_blank">Top kunstmatige intelligentie (AI) munten &amp; tokens op basis van marktkapitalisatie</a></p>
<h2 id="h2-Het20belangrijkste20probleem20van20door20AI20gegenereerde20inhoud657174"><a name="Het belangrijkste probleem van door AI gegenereerde inhoud" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het belangrijkste probleem van door AI gegenereerde inhoud</h2><p>Artiesten zoals muzikanten zijn degenen die het meest worden getroffen door AI-replica’s. Duncan Crabtree-Ireland zei: ‘De explosie in populariteit en mogelijkheden van generatieve kunstmatige intelligentie heeft het internet overspoeld met door AI gemaakte liedjes, video’s en stemopnames die gebruik maken van de gelijkenis van onze leden zonder toestemming of compensatie’.</p>
<p>Zoals u opmerkt, hebben getalenteerde creatieve gemeenschappen vooroordelen over het potentiële inkomen dat ze zouden moeten verdienen als andere mensen hun prestaties repliceren. Afgezien hiervan kunnen sommige mensen AI-replica’s maken om ze te gebruiken met slechte bedoelingen.</p>
<p>Bijvoorbeeld kunnen sommige oplichters door AI gegenereerde deepfakes creëren om te stelen van organisaties zoals banken. De oplichters kunnen de nagebootste stemmen gebruiken om te communiceren met financiële instellingen.</p>
<p>Sommige individuen of organisaties kunnen deepfakes gebruiken om valse informatie te verspreiden die de integriteit van andere mensen kan schaden. Ook kunnen ze pornografisch materiaal creëren met behulp van aangepaste afbeeldingen van populaire persoonlijkheden.</p>
<p>Verder kunnen ze soortgelijke inhoud gebruiken om andere mensen te bedreigen, ondermijnen en kleineren. Helaas kunnen kwaadwillende actoren in sommige glen valse advertenties maken die ze kunnen gebruiken om argeloze burgers op te lichten.</p>
<p>Lees ook: <a href="https://www.gate.io/de/blog_detail/3105/indian-central-bank-explores-ai-for-instant-payments" target="_blank">Indiase Centrale Bank verkent AI voor directe betalingen</a></p>
<h2 id="h2-Partijen20die20de20No20Fakes20Act20ondersteunen10187"><a name="Partijen die de No Fakes Act ondersteunen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Partijen die de No Fakes Act ondersteunen</h2><p>Veel organisaties en individuen steunen het No Fake-wetsvoorstel. Allereerst steunt de Recording Industry Association of America (RIAA) het wetsvoorstel omdat het kunstenaars beschermt. Volgens de RIAA zal AI-kunst aanzienlijk lijden als de sector ongereguleerd blijft. Dit komt doordat de generatieve AI-modellen vaak inbreuk maken op de rechten van kunstenaars.</p>
<p>De Human Artistry-campagne en SAG-AFTRA roepen op tot een sterke bescherming van de rechten van artiesten. Ze zeiden,<br><strong>“Een artiest zijn stem en uiterlijk maken allemaal deel uit van hun unieke essentie, en het is niet oké wanneer deze zonder toestemming worden gebruikt. Toestemming is essentieel.”</strong></p>
<p>Daarnaast ondersteunt de hele creatieve gemeenschap, bestaande uit auteurs, journalisten, fotografen, liedjesschrijvers en performers, de oprichting van een juridisch kader dat hun rechten beschermt.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2139/ai-tokens-defy-crypto-market-gate.io-market-data-shows" target="_blank">AI-tokens trotseren de cryptomarkt, Gate.io marktgegevens tonen aan</a></p>
<h2 id="h2-Het20behouden20van20een20balans20tussen20vrijheid20van20meningsuiting20artistieke20expressie20en20misbruik20van20AIreplicas139474"><a name="Het behouden van een balans tussen vrijheid van meningsuiting, artistieke expressie en misbruik van AI-replica’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het behouden van een balans tussen vrijheid van meningsuiting, artistieke expressie en misbruik van AI-replica’s</h2><p>Het No Fakes Bill verbiedt niet ongeoorloofde AI-namaak indiscriminately. Er zijn enkele uitzonderingen. Zo staat het bijvoorbeeld toe dat door AI gegenereerde inhoud voor nieuws, documentaires en voor historische of biografische werken. Het staat ook toe dat door AI gemaakte replica’s voor satire, kritiek en parodie.</p>
<p>Daarom kan door AI gegenereerde inhoud die geen schade toebrengt, anderen niet beledigt of hen benadeelt van financiële winsten, wettelijk aanvaardbaar zijn. Zo heeft het wetsvoorstel ruimte om creativiteit en innovatie te bevorderen.</p>
<p>In dit verband zei senator Coons: “Het Congres moet het juiste evenwicht vinden om individuele rechten te verdedigen, zich te houden aan het Eerste Amendement en AI-innovatie en creativiteit te bevorderen.”</p>
<h2 id="h2-Andere20toepassingen20van20AIreplicas967952"><a name="Andere toepassingen van AI-replica’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere toepassingen van AI-replica’s</h2><p>AI-replica’s hebben veel functies in de gemeenschappen van de Verenigde Staten. Bijvoorbeeld, deepfakes, afbeeldingen of video’s waarop mensen te zien zijn wiens gezichten, stemmen of lichaam zijn aangepast om eruit te zien als iemand anders of iets anders te zeggen, kunnen worden gebruikt voor het maken van zakelijke presentaties.</p>
<p>Mensen kunnen valse woorden in de mond van prominente personen leggen als een middel om de samenleving iets belangrijks te leren. Als voorbeeld kunnen de makers van inhoud een situatie faken waarin de president van de Verenigde Staten, Joe Bidden, de burgers bewust maakt van de gevaren van drugsgebruik.</p>
<h2 id="h2-Conclusie659372"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Amerikaanse senator heeft een wetsvoorstel geïntroduceerd, Nurture Originals, Foster Art, and Keep Entertainment Safe Act van 2023, om personen te beschermen tegen ongeautoriseerde digitale replica’s die hen kunnen vernederen, intimideren of ondermijnen. Indien goedgekeurd, stelt het getroffen personen in staat om juridische stappen te ondernemen tegen de makers van deepfakes en de hostingplatforms zoals YouTube.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan ​​mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>