V2F0IHdlZXQgdSBvdmVyIGRlIHJlbnRlY3VydmU/IEhvZSBrdW50IHUgaW4gw6nDqW4gb29nb3BzbGFnIGRlIHRvZWtvbXN0aWdlIG9wYnJlbmdzdCB2YW4gZWVuIHN0cmF0ZWdpZSB2b29yc3BlbGxlbiE=

2023-01-09, 10:40

<p><img src="https://gimg2.gateimg.com/image/1673331128761483241110411.jpg" alt=""><br>Veel gebruikers kijken alleen naar de ROI of het rendementsbedrag bij het kiezen van een geschikte strategie of leidende handelaar. In feite is dit erg eenzijdig. Het is verstandiger om meer indicatoren te combineren voor een uitgebreide uatie, zoals Sharpe Ratio, winstpercentage, maximale drawdown en de opbrengstcurve.</p>
<p>Allereerst kan de Sharpe-ratio eenvoudig worden begrepen als een technische parameter, en het heeft een berekeningsformule: gemiddeld rendement/standaardafwijking van het rendement, wat het rendement dat overeenkomt met het eenheidsrisico vertegenwoordigt. Hoe groter de Sharp Ratio, hoe hoger het rendement dat overeenkomt met het eenheidsrisico, en hoe meer passende relatie tussen het risico en rendement voor de hoofdhandelaar, wat betekent dat hij/zij relatief sterkere winstgevendheid heeft. Daarom kan de Sharpe-ratio worden gebruikt om de relatie tussen het rendement en risico van de hoofdhandelaar te meten.</p>
<p>Wat betreft de maximale drawdown. Het betekent het bereik van de nettowaarde van het product dat binnen een bepaalde periode van het hoogste punt naar het laagste punt daalt. Hoe groter de maximale drawdown, hoe meer de fondsen van de hoofdhandelaar zullen dalen, en het is waarschijnlijker dat er geld verloren gaat bij het kopen op een hoog punt. Gewoonlijk is de maximale drawdown recht evenredig met het risico. Hoe kleiner de maximale drawdown, hoe sterker het vermogen om risico te beheersen, en hoe groter de drawdown, hoe moeilijker het is om zichzelf te bekostigen.</p>
<p>Wat betreft het winstpercentage, dat verwijst naar het aantal winstgevende transacties/totaal aantal transacties binnen een bepaalde periode. Het winstpercentage van een hoofdhandelaar zal zijn winst en verlies tot op zekere hoogte beïnvloeden, maar het is niet absoluut. Als een hoofdhandelaar bijvoorbeeld in totaal 200 transacties heeft, met 150 keer winst en 50 keer verlies, dan is zijn winstpercentage = 150/200x100% = 75%, wat relatief hoog is. Maar als de 150 winstgevende transacties een totale winst van $15.000 hebben opgeleverd, terwijl de 50 keer verlies een totaal verlies van $50.000 hebben veroorzaakt, dan lijdt de hoofdhandelaar verlies in het geheel. Daarom is het op dit moment noodzakelijk om een oordeel te vellen op basis van andere indicatoren.</p>
<p>De bovenstaande indicatoren vereisen mogelijk dat beleggers bepaalde achtergrondkennis hebben om ze op de juiste manier te gebruiken. In vergelijking is de rendementscurve de meest intuïtieve en uitgebreide indicator om de winstgevendheid van een strategie of een hoofdhandelaar te tonen, en het is ook de gemakkelijkste indicator voor gebruikers om te begrijpen, zelfs beginnende gebruikers kunnen het gemakkelijk begrijpen.</p>
<p>De rendementscurve gebruikt de tijdeenheid van de handelaar als horizontale as en de tweedimensionale coördinatencurve van de strategie of de ROI van de handelaar als verticale as. Zoals getoond in de onderstaande figuur, wordt de rendementscurve weergegeven in de vorm van tijd en rendementscurve, zodat de kopieerders de algehele trend van de leidende ROI van de handelaren intuïtiever kunnen observeren.</p>
<p>Of het nu gaat om investeren, aandelen kopen of fondsen kopen, al het harde werk, alle risico’s, alle strategieën, alle gedachten, alle geluk en alle kosten van beleggers worden uiteindelijk weerspiegeld in een opbrengstcurve. Daarom kan de belangrijkheid van de opbrengstcurve niet genoeg benadrukt worden, het is de microscoop van het handelsniveau van beleggers en kan volledig de handelsvaardigheid van beleggers weerspiegelen. Het volgende vat de gemeenschappelijke en meest representatieve vier soorten opbrengstcurves voor u samen. Hopelijk maakt u een meer uitgebreid en atisch oordeel bij het kiezen van een strategie of hoofdhandelaar.</p>
<h2 id="h2-Vier20veelvoorkomende20opbrengstkrommen20omhoog20of20omlaag283088"><a name="Vier veelvoorkomende opbrengstkrommen: omhoog of omlaag?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vier veelvoorkomende opbrengstkrommen: omhoog of omlaag?</h2><p>Allereerst moet een goede rentecurve een trend zijn van gestage groei zonder grote fluctuaties en met een lage maximale drawdown. We moeten ons ervan bewust zijn dat drawdowns onvermijdelijk zijn bij investeringen in cryptocurrency. Daarom zijn perfectionisten niet geschikt om in te investeren, omdat beleggen een praktische kunst is, niet een kunst van het nastreven van perfectie zoals wiskunde. Kort door de bocht gezegd, drawdown betekent dat de marktsituatie u tijdelijk verslaat. Dit is een feit, en we moeten het toegeven. Hoe perfect uw lay-out ook is, het is onmogelijk om bij elke transactie geld te verdienen, omdat de markt altijd de kans zal grijpen om u te verslaan. Mensen die vele malen hebben geïnvesteerd, kunnen begrijpen dat het aantal keren dat u door de markt wordt geraakt, eigenlijk meer is dan het aantal keren dat u profiteert. Dus wat een goede belegger moet doen, is de drawdown minimaliseren.</p>
<h3 id="h3-Curve20120Grote20stijgingen20en20kleine20dalingen529284"><a name="Curve 1: Grote stijgingen en kleine dalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve 1: Grote stijgingen en kleine dalingen</h3><p>Dit soort opbrengstcurve is de optimale, met over het algemeen een stabiele en stijgende trend en een lage drawdown. Ook is er geen duidelijke schommeling. Met frequente transacties maar uitstekende vermogen om posities te beheersen, toont de optimale opbrengstcurve een balans tussen de risico’s en opbrengsten. De figuur hieronder is de opbrengstcurve van een bepaalde strategie van Gate.io Strategy Bot. Het voordeel van de Gate.io strategie bot is dat het niet alleen de trend van de ROI van een strategie in de afgelopen 7 dagen vergelijkt met de ROI van BTC, maar ook de real-time ROI vergelijkt met de real-time ROI van BTC. Het kan gebruikers helpen om de winstgevendheid van een strategie meer allesomvattend te begrijpen.<br><img src="https://gimg2.gateimg.com/image/1673329780811838700110en1.png" alt=""><br>Over het algemeen, hoewel de yield curve van deze strategie heeft gefluctueerd, toont het over het geheel genomen een stijgende trend. En er is geen duidelijke daling, wat aangeeft dat het geen ernstig verlies heeft geleden, wat betekent dat er minder kans is op verlies wanneer je het kopieert. En wanneer BTC verliest, maakt het ook winst, waarvan de ROI altijd hoger is geweest dan die van BTC, nog steeds met een veelbelovende trend in de toekomst. Gebruikers kunnen er dus over nadenken om het te kopiëren. Over het algemeen kunnen gebruikers bij het kiezen van een strategie een alomvattend oordeel vellen op basis van de vroegere, huidige en toekomstige rendementstrends.</p>
<h3 id="h3-Curve20220Grote20stijgingen20en20middelmatige20dalingen292143"><a name="Curve 2: Grote stijgingen en middelmatige dalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve 2: Grote stijgingen en middelmatige dalingen</h3><p>Over het algemeen is de opbrengst niet slechter dan kromme 1, maar er is een grotere fluctuatie, met een hoge max drawdown, zonder het principe te verliezen. Gebruikers moeten zeer vertrouwd zijn met en vertrouwen hebben in de kenmerken van de positiemap om geduldig posities in te houden tijdens periodes van grote fluctuaties. Zo’n curve vertegenwoordigt uitstekende mogelijkheid om posities te controleren maar gemiddelde mogelijkheid om risico’s te controleren. Over het algemeen is het een test van het hart.<br><img src="https://gimg2.gateimg.com/image/1673330104273995507110en2.png" alt=""><br>Dit is de rendementscurve van een bepaalde lrad-handelaar van Gate.io Copy Trading. Over het algemeen is de hoofdhandelaar relatief stabiel en betrouwbaar in het leiden waarvan het ROI over het algemeen stijgt. Er is ook een intermitterende, kleine daling in ROI, maar hij heeft goede controle over het stop loss, en er zijn geen verliezen van deposito’s opgetreden, wat aangeeft dat de hoofdhandelaar voldoende middelen heeft om met de volatiele marktsituatie om te gaan. U kunt overwegen hem te volgen.</p>
<h3 id="h3-Curve20320Grote20pieken20en20diepe20dalen447560"><a name="Curve 3: Grote pieken en diepe dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve 3: Grote pieken en diepe dalen</h3><p>Dit soort opbrengstcurve kent een grote stijging, maar ook een grote daling, wat de opbrengsten en risico’s niet effectief in balans kan brengen en zelfs kan leiden tot verlies van het kapitaal. De meeste beginners zullen zo’n opbrengstcurve hebben met weinig controle over posities en risico’s. Het kapitaal is aangetast tijdens een grote terugval, wat een grote test van mentaliteit is. In dit g zullen beleggers uiterst bezorgd zijn. Het is een typisch voorbeeld van geld verdienen door geluk. Het zal lang duren voordat het kan stijgen naar de staat van opbrengstcurve 1 en opbrengstcurve 2. Zo’n curve betekent dat de belegger enige bewustzijn heeft van het controleren van posities, maar een zwak vermogen en bewustzijn heeft van het controleren van risico’s.<br><img src="https://gimg2.gateimg.com/image/1673330145662719567110en3.png" alt=""></p>
<h3 id="h3-Curve20420Kleine20Ups20En20Grote20Downs556125"><a name="Curve 4: Kleine Ups En Grote Downs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Curve 4: Kleine Ups En Grote Downs</h3><p>Uit de rendementscurve is te zien dat de mentaliteit van de belegger in het begin goed was en dat er op korte termijn winst was en vervolgens een voortdurende daling doormaakte. Nadat het verlies de bodem had bereikt, worstelde de investeerder en redde, die uiteindelijk de transactie direct opgaf toen hij ontdekte dat zijn inspanningen niet werkten. Met een chaotische positie ontbreekt het de beleggers aan geduld bij het aanhouden van posities. Het is in een langdurige opschortingsperiode nadat hij vaak van positie veranderde, wat aantoont dat de belegger de markt opnieuw moet onderzoeken om zijn eigen tekortkomingen te ontdekken en het defect beetje bij beetje te verhelpen. Maar de meeste mensen hebben misschien niet zo’n vastberadenheid en doorzettingsvermogen, dus vertrekken ze haastig. In dit g kunnen beleggers overwegen om handelshulpmiddelen te gebruiken - Strategy Bot &amp; Copy Trading - om zichzelf te helpen hun posities te beheren en het vertrouwen in de markt terug te winnen. Met behulp van handelshulpmiddelen hoeven gebruikers de markt niet in de gaten te houden om complexe marktomstandigheden te bestuderen en te beoordelen, en kunnen ze moeiteloos winnen.<br><img src="https://gimg2.gateimg.com/image/1673330194976626345110en4.png" alt=""></p>
<h2 id="h2-Conclusie72997"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De rentecurve is een samenvatting van de winnende en verliezende voorwaarden van de investeerders in het marktspel. Bedrijven zijn als slagvelden, en dat geldt ook voor investeringen. Uw energie, onderzoek en oordeel, investeringsniveau, controlevermogen van risico en rendement, evenals aanpassingsvermogen ter plaatse, worden alleen weerspiegeld op de rentecurve. Daarom kan de rentecurve vaak de algehele kwaliteit en vaardigheid van een investeerder onthullen. Als u de beste rentecurve wilt behalen, zoals curve 1, moet u diepgaand onderzoek doen in verschillende belangrijke richtingen, zoals risicobeheersing, positiebeheer en mentaliteitsbeheersing. Door zorgvuldig te denken en te analyseren, kunt u uw eigen tekortkomingen vinden en deze voortdurend corrigeren.</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 mening 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 op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>