U3RhYmllbCBoYW5kZWxlbiB3aW50IG9wIGRlIGxhbmdlIHRlcm1pam4hIFN0cmV2ZW4gbmFhciBlZW4gc3RhYmllbGUgbGVpZGVuZGUgaGFuZGVsYWFyOyBWZWNodCB0ZWdlbiBkZSBiZWVyIQ==

2023-01-13, 08:29

<p><img src="https://gimg2.gateimg.com/image/article/1673601397110411.jpg" alt=""><br>Bijna iedereen heeft gehoord van de recente buzzwoord, genaamd ‘ongeldig werk’. Crypto liefhebbers grapten dat de uitdrukking verwijst naar de hele dag hard werken in een volatiele en trage markt, maar toen ze hun investeringsportefeuille controleerden, bleek dat ze meer betaald kregen dan hun salaris, en een dag werken was verspild. In feite beseffen steeds meer investeerders met de recente gewelddadige marktvolatiliteit dat ‘stabiliteit’ de juiste manier is om op lange termijn te investeren. De beleggingsmethode van scherpe stijgingen en dalingen in het verleden moet mogelijk worden aangepast.</p>
<p>Deze vraag is een voorstel dat moet worden opgelost om Gate.io Copy Trading leiders te helpen, omdat ze niet alleen zichzelf moeten redden, maar ook anderen moeten redden. Ze nemen de verantwoordelijkheid en missie op zich om kopieerders te leiden bij het handelen en winst te maken, en ze moeten elke stap nemen om kopieerders door de berenmarkt te leiden! In het verleden hebben veel leiders handel gedreven met grote stijgingen en dalingen om korte-termijn enorme winsten te behalen, maar dat is niet geschikt voor de huidige marktomstandigheden. Integendeel, in de huidige trage en volatiele markt is het verstandiger om stabiel te handelen met minder risico. Daarom moedigt Gate.io Copy Trading iedereen aan om niet te streven naar een hoog rendement in een enkele handel, maar om een gestage stroom van kleine rendementen in elke handel na te streven en risico’s te verminderen. Op deze manier is het totale rendement nog steeds aanzienlijk.</p>
<p>Gate.io Copy Trading heeft momenteel ook stabiele hoofdhandelaren nodig om kopieerders te leiden en een stevige positie in de berenmarkt te krijgen. Dit zal leiden tot meer middelen voor stabiele hoofdhandelaren. Daarom biedt Gate.io Copy Trading nu verschillende voordelen voor stabiele hoofdhandelaren, waaronder officiële middelen en verkeersondersteuning, geldbeloningen en voldoening aan persoonlijke vereisten, enz. Hoe stabieler de hoofdhandelaar in de handel, hoe meer officiële middelen er kunnen worden verkregen. Copy Trading zal zich ook richten op de behoeften van stabiele hoofdhandelaren, het productmodel en de functies aanpassen en verbeteren op een manier die meer bevorderlijk is voor hun handelsactiviteiten, om u en de kopieerders betere service te bieden.</p>
<h2 id="h2-Wat20is20stabiele20handel899779"><a name="Wat is stabiele handel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is stabiele handel?</h2><p>De zogenaamde stabiele transactie betekent dat de hoofdhandelaar stabiele rendementen kan behalen en stabiele winsten kan nastreven in een meer bevorderlijke richting dan het overdreven nastreven van hoge rendementen in een enkele transactie. In de turbulente marktomgeving kunnen hoofdhandelaren de risico’s en rendementen op een goed niveau beheersen en er zullen geen scherpe stijgingen en scherpe dalingen zijn in het rendementspercentage. Wilt u niet snel rijk worden, maar geleidelijk een gestaag klein inkomen verdienen? Er zijn drie indicatoren die kunnen worden gebruikt om te meten of een hoofdhandelaar een stabiele handelaar is of niet, namelijk de Sharpe Ratio, Max Drawdown en de handelswinstpercentage.</p>
<p>Allereerst kan de Sharpe-ratio eenvoudig worden opgevat als een technische parameter die snel het vermogen van een handelaar om de handel te leiden en zijn stabiliteit beoordeelt, berekend door: de gemiddelde ROI van de handelaar/de ROI-standaarddeviatie van de handelaar, die het rendement vertegenwoordigt dat overeenkomt met het eenheidsrisico. Hoe groter de Sharp Ratio, hoe hoger het rendement dat overeenkomt met het eenheidsrisico, en hoe geschikter de verhouding tussen risico en rendement voor de hoofdhandelaar, wat betekent dat hij/zij een relatief sterkere winstgevendheid heeft. De Sharpe Ratio kan dus worden gebruikt om de relatie tussen het rendement en het risico van de lead trader te meten. Over het algemeen schommelt de Sharpe-ratio tussen 0 en 1, en het is uitstekend als deze hoger is dan 1.</p>
<p>Maximaal verlies is ook een indicator om het vermogen van een hoofdhandelaar om risico’s te weerstaan te meten. Het betekent het bereik van de nettowaarde van het product dat binnen een bepaalde periode vanaf het hoogste punt naar het laagste punt daalt. Hoe groter het maximale verlies, hoe meer de fondsen van de hoofdhandelaar zullen dalen en hoe waarschijnlijker het is om geld te verliezen bij het kopen op een hoogtepunt. Over het algemeen is het maximale verlies recht evenredig met het risico. Hoe kleiner het maximale verlies, hoe sterker het vermogen om het risico te beheersen, en hoe groter het verlies, hoe moeilijker het is om zichzelf terug te betalen. Over het algemeen is het beter om het maximale verlies tot ongeveer 20% of minder te beheersen.</p>
<p>De winstpercentage verwijst naar het aantal winstgevende transacties/totaal aantal transacties binnen een bepaalde periode. Eigenlijk geldt: hoe meer winstgevende transacties per eenheid van tijd, hoe beter; hoe hoger het winstpercentage, hoe beter. Omdat het de frequentie van stabiele winsten van investeerders vertegenwoordigt, kan het de capaciteit van de hoofdhandelaar om risico’s en voordelen in evenwicht te brengen meten.</p>
<p>Om het eenvoudig te zeggen, zou een uitstekende stabiele leidende handelaar het volgende moeten doen: proberen de Sharpe Ratio te verhogen, proberen de maximale drawdown te verminderen en proberen het handelswinstpercentage te verhogen.</p>
<h2 id="h2-Case20Study20van20Stable20Lead20Traders20in20Trading311168"><a name="Case Study van Stable Lead Traders in Trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Case Study van Stable Lead Traders in Trading</h2><p>Hieronder vindt u de rendementscurves van de twee copy trading leidende handelaren, die meer concreet kunnen laten zien wat ‘stabiele handel’ betekent.</p>
<h3 id="h3-Lead20Trader20A20hoge20Sharpe20Ratio20hoge20Win20Rate20lage20Drawdown890569"><a name="Lead Trader A: hoge Sharpe Ratio; hoge Win Rate; lage Drawdown" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lead Trader A: hoge Sharpe Ratio; hoge Win Rate; lage Drawdown</h3><p><img src="https://gimg2.gateimg.com/image/1673601001198909608113en1.png" alt=""><br>Uit de paginagegevens blijkt dat de Sharpe Ratio van de hoofdhandelaar 6,35 is, wat op een uitstekend niveau ligt. Het winstpercentage is ook behoorlijk indrukwekkend, op een boven-midden niveau, en de maximale drawdown is extreem laag, slechts 0,53%. Bovenstaande indexwaarden laten zien dat de meeste van zijn transacties in de afgelopen maand winstgevend zijn geweest en dat er geen plotselinge winst of scherpe daling is geweest. Dit type hoofdhandelaar heeft een relatief hoge kans om winst te maken bij elke transactie, met een relatief stabiel rendement en kleinere risico’s.</p>
<h3 id="h3-Lead20Trader20B20hoge20Sharpe20Ratio20hoge20Win20Rate20Hoge20Drawdown475113"><a name="Lead Trader B: hoge Sharpe Ratio; hoge Win Rate; Hoge Drawdown" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lead Trader B: hoge Sharpe Ratio; hoge Win Rate; Hoge Drawdown</h3><p><img src="https://gimg2.gateimg.com/image/1673601028927913868113en2.png" alt=""><br>Hoewel deze hoofdhandelaar een super hoge Sharpe Ratio, een zeer hoog winstpercentage en ook een hoog drawdown heeft, blijkt dat sommige van zijn enkele transacties de prijstrends nauwkeurig vastleggen en een groter winstbereik behalen. Zijn algehele winst en verlies zijn relatief duidelijk. Hij heeft een hogere kans om een hoog ROI te behalen bij een enkele transactie. Hij is meer geschikt voor kopieerders die verwachten om in een korte periode een hoog rendement te behalen en bereid zijn zichzelf uit te dagen. Deze hoofdhandelaar past niet bij het type stabiele handelaar.</p>
<p>Hoewel de rendementscurves van beide hoofdhandelaren in een gestage en stijgende trend zijn en het rendement positief is, wat resulteert in het behalen van winst, betekent dit niet dat ze beide stabiele hoofdhandelaren zijn. In tegenstelling daartoe is hoofdhandelaar A dichter bij de kenmerken van stabiele handel, omdat hij meer in lijn is met de uitgebreide norm van ‘hoge Sharpe Ratio; hoge Win Rate; en lage drawdown’. Daarom zouden andere hoofdhandelaren moeten streven naar het laten neigen van hun rendementscurve naar die van hoofdhandelaar A en streven naar een stabiele hoofdhandelaar te zijn. Ze kunnen niet alleen een gestage stroom van kleine winsten behalen, maar ze kunnen ook genieten van de exclusieve voordelen van stabiele hoofdhandelaren.</p>
<h2 id="h2-Wat20zijn20de20exclusieve20voordelen20van20Stable20Lead20Traders42315"><a name="Wat zijn de exclusieve voordelen van Stable Lead Traders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de exclusieve voordelen van Stable Lead Traders?</h2><h3 id="h3-120Officile20Platformbronnen20en20Verkeersondersteuning808571"><a name="1. Officiële Platformbronnen en Verkeersondersteuning" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Officiële Platformbronnen en Verkeersondersteuning</h3><p>Gate.io Copy Trading zal elke week gegevensuatie uitvoeren onder hoofdhandelaren. Degenen die voldoen aan de standaard van stabiele hoofdhandelaren krijgen de officiële platformmiddelen en verkeersondersteuning, inclusief Gate.io officiële banners, copy trading banners, copy trading aanbevelingslijst, officiële berichten, officiële TG-communicatiegroepen, officiële Twitter, officiële aankondigingen, officiële e-mails, enz. In vergelijking met andere platforms heeft Gate.io een compleet sociaal ecosysteem. We hebben Gate.io Post voor alle gebruikers om intern te communiceren, een officiële TG-communicatiegroep in verschillende talen, en een Live-platform. Hoofdhandelaren kunnen deze kanalen gemakkelijk gebruiken om zichzelf te promoten en loyale copy-fans te krijgen.</p>
<h3 id="h3-220Cash20Rewards904747"><a name="2. Cash Rewards" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Cash Rewards</h3><p>Copy Trading zal elke halve maand 5 stabiele hoofdhandelaren selecteren en aan elke handelaar de bijbehorende geldbeloningen geven, variërend van 10 tot 100 USDT.</p>
<h3 id="h3-320Aannemen20van20persoonlijke20meningen211224"><a name="3. Aannemen van persoonlijke meningen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Aannemen van persoonlijke meningen</h3><p>Bij het kopiëren van handel zal elke maand de beste stabiele hoofdhandelaar geselecteerd worden en per e-mail contact met hem/haar opnemen, en hem/haar een formulier voor meningenverzameling sturen, waarin wordt gevraagd naar zijn behoeften en suggesties over het gebruik van kopiëren handelsproducten. Vervolgens zal het kopiëren handelsteam actief het productmodel en de functies aanpassen, en zijn best doen om te voldoen aan de eisen van de beste hoofdhandelaar.</p>
<h2 id="h2-Streef20ernaar20een20stabiele20hoofdhandelaar20te20zijn20vecht20tegen20de20bearmarkt774006"><a name="Streef ernaar een stabiele hoofdhandelaar te zijn; vecht tegen de bearmarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Streef ernaar een stabiele hoofdhandelaar te zijn; vecht tegen de bearmarkt</h2><p>Tijdens de marktdownturn moet het maken van grote winsten en kleine verliezen onze handelsnorm zijn. Het geleidelijk behalen van kleine rendementen moet ons handelsdoel zijn. In plaats van te streven naar grote winst in slechts één transactie, is het verstandiger om te streven naar langdurige stabiele rendementen. Vooral in de bearmarktperiode, wanneer het moeilijker is om winst te maken en verliezen vaak voorkomen, moeten leidende handelaren volledig rekening houden met de veiligheid van hun eigen middelen en die van hun volgers. Ze moeten voorzichtig omgaan met hefboomwerking, risico’s beheersen en verliezen zoveel mogelijk beperken. Daarnaast moeten ze voorzichtig opereren en streven naar een hogere Sharpe Ratio en Win Rate, en een lagere Max Drawdown. Door zich te committeren aan het doel van ‘stabiel handelen, winst op de lange termijn’, moeten de leidende handelaren hun volgers leiden om de berenmarktmarathon te overleven. Alleen dan kunnen ze nog steeds in de cryptomarkt staan en genieten van de waardevermeerdering van activa na het ervaren van vele stieren- en berenomzettingen en wisselvalligheden!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Gate.io Copy Trading.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>