QmljYXNzbyAtIERlIGRvb3IgQUkgYWFuZ2VkcmV2ZW4gTkZULWdlbmVyYXRvcg==

2023-03-21, 07:32

<p><img src="https://gimg2.gateimg.com/blog/1679447253722320711jiami.jpeg" alt=""><br>Binance heeft op 1 maart haar AI-aangedreven NFT-generator tool genaamd Bicasso gelanceerd.</p>
<p>Met Bicasso kunnen gebruikers beschrijvingsteksten gebruiken om NFT’s te genereren.</p>
<p>Google Afbeelding, DALL.E2 van Open AI en Stable Diffusion zijn andere opmerkelijke door AI aangedreven platforms die digitale kunst genereren.</p>
<p>Aangezien de Bicasso Beta Test succesvol was, streeft Binance ernaar om het te perfectioneren om mogelijke glitches te verwijderen.</p>
<h2 id="h2-Introductie2329"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Kunstmatige intelligentie maakt grote vorderingen in de blockchainsector, omdat het op verschillende manieren nuttig blijkt te zijn, zoals het genereren van NFT’s. Ook wordt het nu veel gebruikt bij het genereren van digitale kunstwerken. Vandaag richten we ons op hoe blockchains kunstmatige intelligentie kunnen gebruiken om niet-fungible tokens (NFT’s) te genereren.</p>
<h2 id="h2-Bicasso20AIaangedreven20NFT20Generator227725"><a name="Bicasso AI-aangedreven NFT Generator" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bicasso AI-aangedreven NFT Generator</h2><p>Op 1 maart 2023 introduceerde de Binance crypto exchange een door kunstmatige intelligentie aangedreven NFT-generator tool in zijn NFT-marktplaats, die op een vergelijkbare manier werkt als Dawn AI en DALL-E. Deze unieke tool kan enkele teksten of gebruikersprofielen binnen korte tijd omzetten in niet-fungibele tokens.</p>
<p>Binance’s Bicasso is geïntroduceerd op een moment dat er veel opwinding is rond NFT’s en door AI gegenereerde kunst <a href="https://www.gate.io/blog_detail/407/web-3.0-blue-ocean-of-value-brought-by-blockchain" target="_blank">kunst in web3</a> Deze technologie stelt veel digitale kunstenaars in staat om zich te begeven in non-fungible tokens die zeer waardevol en uniek kunnen zijn.</p>
<h2 id="h2-Bicasso20Betatest20een20groot20succes711407"><a name="Bicasso Beta-test een groot succes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bicasso Beta-test een groot succes</h2><p>De Bicasso Beta-test werd gelanceerd op 1 maart 2023 en duurde slechts 2,5 uur, wat een grote vraag naar AI-generatieve kunst laat zien. De muntgegevens van het NFT-platform tonen aan dat 9.909 gebruikers binnen de 2,5 uur ten minste 1 NFT hebben geslagen met behulp van deze technologie. Binance had als doel gesteld om 10.000 gratis NFT-munten te slaan.</p>
<p>Het mintproces begon toen Changpeng Zhao, de CEO van Binance, algemeen bekend als CZ, tweette: “Je kunt je creatieve visies omzetten in NFT’s met AI. Probeer het eens en laat me zien wat je ermee maakt.”</p>
<p>Enkele uren na die post namen veel mensen deel aan het gratis NFT-muntproces, waarbij binnen 2,5 uur een limiet van 10.000 werd bereikt. Zhao gaf echter aan dat de AI NFT-generator tijdens het muntproces op de een of andere manier onder druk stond, wat wees op de noodzaak van dringende verbetering. In dat opzicht zei hij: ‘BICASSO’s eerste pilot is net afgerond met 10K NFT’s gemunt in 2,5 uur. De AI was een beetje gestrest, maar heeft nu adem gehaald.’</p>
<p>Het is de moeite waard om op te merken dat de door Bicasso AI gegenereerde NFT’s nog niet op de markt zijn, omdat ze slechts een onderdeel waren van een pilotproject. Momenteel werkt het team aan het doorvoeren van de nodige verbeteringen om eventuele hinder bij het aanmaken van NFT’s in de toekomst te voorkomen. Dat is de reden waarom de beurs verklaarde: “Ons team werkt momenteel aan het verbeteren van de capaciteiten van de server om fouten te verminderen en het aanmaakproces soepeler te maken.”</p>
<h2 id="h2-Hoe20werkt20Bicasso7081"><a name="Hoe werkt Bicasso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt Bicasso?</h2><p>Nu is het tijd om precies te kijken hoe de Bicasso <a href="https://www.gate.io/blog_detail/2239/ai-focused-cryptocurrencies-outperforming-bitcoin" target="_blank">AI-technologie werkt</a>. Er zijn twee hoofdmanieren waarop de kunstenaar de instructies aan de Bicasso AI-tool kan invoeren. Ten eerste kan hij/zij een foto uploaden die hij/zij wil omzetten in een NFT. Die foto fungeert echter alleen als een aanwijzing voor de tool om een niet-vervangbare token te genereren.<br><img src="https://gimg2.gateimg.com/image/article/16793838581.png" alt=""><br>AI in digitale kunst - CryptoSlate</p>
<p>Ten tweede kan de kunstenaar een ruwe beschrijving invoeren van het soort niet-vervangbare token dat hij/zij wil genereren. Dit sluit aan bij wat de AI-productpagina van de Binance Exchange zegt: “De geavanceerde AI-technologie van Bicasso stelt u in staat om eenvoudig uw droombeeld te schilderen. Voer gewoon een beschrijving in van wat u wilt zien - een ‘prompt’ (alleen in het Engels), en kijk hoe onze Bicasso-tool uw ideeën binnen enkele seconden tot leven brengt.”</p>
<h3 id="h3-AI20gegenereerde20kunst20blijft20vooruitgang20boeken20op20de20markt577926"><a name="AI gegenereerde kunst blijft vooruitgang boeken op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI gegenereerde kunst blijft vooruitgang boeken op de markt</h3><p>Kunstmatige intelligentie (AI) technologie in de kunst, crypto en NFT sectoren werd populair na de succesvolle lancering van de <a href="https://www.gate.io/blog_detail/1908/gate.io-asks-openai-chatbot-about-satoshi-s-identity-blockchain-and-web3" target="_blank">AI-aangedreven chatbot, ChatGPT</a>. Opmerkelijk genoeg hebben we ook het succes gezien van met AI aangedreven blockchains en cryptocurrencies.</p>
<p>Blockchain-ontwikkelaars hebben veel geleerd van deze evoluerende technologie in die mate dat ze de AI-aangedreven NFT-generatoren hebben geïntroduceerd. Met deze technologie is het heel goed mogelijk en gemakkelijk voor algoritmen om onberispelijke afbeeldingen te genereren met behulp van louter beschrijvende tekst.</p>
<p>Deze tekst-naar-beeldsynthesetechnologie heeft waarschijnlijk een echte revolutie teweeggebracht in de kunst-, communicatie-, reclame- en entertainmentindustrieën. Er zijn al verschillende web2- en web3-bedrijven die deze technologie gebruiken. Voorbeelden van deze projecten zijn Google Imagen, DALL.E2 van Open AI, Stable Diffusion by Stability, Ai Deepswap, Midjourney, NightCafe, Deep Dream Generator en DeepArt Neural Style.</p>
<p>Het is belangrijk op te merken dat al deze door AI aangedreven platforms op een vergelijkbare manier werken. Ze gebruiken AI-algoritmen om verschillende kunstwerken te genereren die afhankelijk zijn van de beschrijvingstekst die u levert. Desalniettemin zijn sommige van deze afbeeldingen abstract of surrealistisch. Neem bijvoorbeeld een afbeelding van een bij die een olifant begroet. Hoewel het artistiek en aantrekkelijk is, is het abstract.</p>
<h2 id="h2-Hoe20kunst20kopen20op20Gateio98085"><a name="Hoe kunst kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunst kopen op Gate.io</h2><p>Zoals we hebben opgemerkt, is de vraag naar kunstwerken hoog in onze moderne tijd. Het is bemoedigend dat iedereen kunstwerken kan kopen van veel platforms, waaronder gevestigde crypto-beurzen zoals Gate.io. Laten we illustreren hoe je dit kan doen. <a href="https://www.gate.io/blog_detail/1681/how-to-buy-and-store-non-fungible-tokens" target="_blank">kan kunstwerken kopen op Gate.io</a> met behulp van cryptocurrencies.</p>
<p>Zoals u wellicht weet, zijn er verschillende kunstwerken in de vorm van NFT’s op Gate.io, de gecentraliseerde cryptobeurs. Om kunstwerken te kopen, gaat u naar de Gate.io NFT-marktplaats genaamd <a href="https://www.gate.io/nft" target="_blank">Magische doos</a>. U zult verschillende kunstwerken zien in de vorm van NFT’s. Onthoud dat u ervoor kunt kiezen het kunstwerk te kopen via het veiling- of vaste prijssysteem.</p>
<p>De eerste stap is om te klikken op het kunstwerk (NFT) dat je wilt kopen, zodat je de volledige details krijgt. Als je tevreden bent met de vastgestelde prijs, klik je op “Aankoop”.<br><img src="https://gimg2.gateimg.com/image/article/16793839132.png" alt=""><br>Van daaruit klik je op ‘Weet je zeker dat je wilt kopen’.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16793839373.png" alt=""><br>Als de aankoop succesvol is, wordt de betaling afgetrokken van uw spot-account.</p>
<h2 id="h2-Conclusie142404"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De bètatest voor de door Bicasso aangedreven NFT-generator, gelanceerd op 1 maart 2023, was een succes. 9.909 gebruikers slaagden erin om in 2,5 uur in totaal 10.000 NFT’s te maken. Nu werken de ontwikkelaars aan het verbeteren van de technologie om eventuele storingen te voorkomen die kunnen optreden tijdens toekomstige creatieperiodes.</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 beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>