SWwgdHJhZGluZyBzdGFiaWxlIHZpbmNlIG5lbCBsdW5nbyBwZXJpb2RvISBTZm9yemF0aSBkaSBkaXZlbnRhcmUgdW4gdHJhZGVyIHN0YWJpbGUgbGVhZGVyOyBjb21iYXR0aSBjb250cm8gbCdvcnNvIQ==

2023-01-13, 08:29

<p><img src="https://gimg2.gateimg.com/image/article/1673601397110411.jpg" alt=""><br>Quasi tutti hanno sentito parlare dell’ultima parola di moda, chiamata “lavoro invalido”. Gli amanti delle criptovalute scherzano dicendo che la frase si riferisce a lavorare duramente tutto il giorno in un mercato volatile e lento, ma quando controllano il proprio portafoglio di investimenti, si rendono conto di essere stati pagati più del dovuto e che una giornata di lavoro è stata sprecata. In realtà, con la recente volatilità violenta del mercato, sempre più investitori si rendono conto che la “stabilità” è il modo giusto per fare investimenti a lungo termine. Il metodo di investimento dei forti rialzi e ribassi del passato potrebbe aver bisogno di essere modificato.</p>
<p>Questa domanda è una proposta che deve essere risolta per aiutare i lead trader di Gate.io Copy Trading, perché non solo devono salvare se stessi, ma anche salvare gli altri. Essi assumono la responsabilità e la missione di guidare i copiatori per commerciare e guadagnare profitti, e devono compiere ogni passo per guidare i copiatori a superare il mercato orso! In passato, molti lead trader potrebbero aver avuto la tendenza a commerciare con grandi aumenti e diminuzioni al fine di ottenere enormi profitti a breve termine, ma non è adatto alle attuali condizioni di mercato. Al contrario, nel mercato attuale lento e volatile, è più saggio commerciare in modo stabile con un rischio inferiore. Pertanto, Gate.io Copy Trading incoraggia tutti a non cercare un alto rendimento in un singolo commercio, ma a cercare un flusso costante di piccoli rendimenti in ogni commercio e cercare di ridurre i rischi. In questo modo, il rendimento totale è ancora molto considerevole.</p>
<p>Il Copy Trading di Gate.io attualmente ha bisogno anche di trader leader stabili per guidare i copiatori e ottenere una solida posizione nel mercato ribassista. Ciò porterà a maggiori risorse per i trader leader stabili. Pertanto, per attirare più trader leader stabili a unirsi al Copy Trading di Gate.io o incoraggiare più utenti a fare trading stabile, il Copy Trading di Gate.io offre ora diversi vantaggi per i trader leader stabili, tra cui risorse ufficiali e supporto al traffico, premi in denaro e soddisfazione dei requisiti personali, ecc. Più stabile è il trader leader nel trading, più risorse ufficiali possono essere ottenute. Il Copy Trading si concentrerà anche sulle esigenze dei trader leader stabili, regolerà il modello e le funzioni del prodotto e migliorerà in un modo più favorevole alle loro operazioni di trading, per fornire a te e ai copiatori un servizio migliore.</p>
<h2 id="h2-Cos20il20trading20stabile179355"><a name="Cos’è il trading stabile?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il trading stabile?</h2><p>Il cosiddetto scambio stabile significa che il trader principale può ottenere rendimenti stabili e perseguire profitti stabili in una direzione più favorevole rispetto al perseguire eccessivamente alti rendimenti in un singolo scambio. Nel turbolento ambiente di mercato, i trader principali possono controllare i rischi e i rendimenti a un buon livello, e non ci saranno forti aumenti e forti cali nel tasso di ritorno. Non vuoi arricchirti da un giorno all’altro, ma vuoi un reddito costante e graduale? Ci sono tre indicatori che possono essere utilizzati per misurare se un trader principale è un trader stabile o no, ovvero il Rapporto di Sharpe, il Massimo Drawdown e il Tasso di Vittoria del trading.</p>
<p>Prima di tutto, il rapporto di Sharpe può essere semplicemente compreso come un parametro tecnico che giudica rapidamente la capacità di un trader di guidare il trading e la sua stabilità, calcolato da: ROI medio del trader/deviazione standard del ROI del trader, che rappresenta il rendimento corrispondente al rischio unitario. Più grande è il rapporto di Sharpe, maggiore è il rendimento corrispondente al rischio unitario e maggiore è la relazione appropriata tra rischio e rendimento per il trader leader, il che significa che ha una redditività relativamente più forte. Quindi il rapporto di Sharpe può essere utilizzato per misurare la relazione tra il rendimento e il rischio del trader leader. In generale, il rapporto di Sharpe oscilla tra 0 e 1 ed è eccellente quando supera 1.</p>
<p>Il massimo drawdown è anche un indicatore per misurare la capacità di un trader leader di resistere ai rischi. Significa la gamma del valore netto del prodotto che cade dal punto più alto al punto più basso entro un certo periodo di tempo. Più è grande il massimo drawdown, più i fondi del trader leader cadranno, ed è più probabile perdere denaro quando si compra in un punto alto. Di solito, il massimo drawdown è direttamente proporzionale al rischio. Più piccolo è il massimo drawdown, più è forte la capacità di controllare il rischio, e più grande è il drawdown, più difficile è pagare per sé. In generale, è meglio controllare il massimo drawdown a circa il 20% o meno.</p>
<p>Il tasso di vincita si riferisce al numero di transazioni profittevoli/numero totale di transazioni in un determinato periodo di tempo. In realtà, più transazioni profittevoli per unità di tempo sono migliori; maggiore è il tasso di vincita, migliore è. Poiché rappresenta la frequenza dei profitti stabili degli investitori, può misurare la capacità del trader leader di bilanciare rischi e benefici.</p>
<p>Per metterla semplicemente, un eccellente trader principale stabile dovrebbe fare quanto segue: cercare di aumentare il rapporto di Sharpe, cercare di ridurre al massimo il drawdown e cercare di aumentare il tasso di vincita del trading.</p>
<h2 id="h2-Studio20di20caso20di20commercianti20di20piombo20stabili20nel20trading502338"><a name="Studio di caso di commercianti di piombo stabili nel trading" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Studio di caso di commercianti di piombo stabili nel trading</h2><p>Di seguito sono riportate le curve dei rendimenti dei due leader del copy trading, che possono mostrare in modo più concreto cosa sia il ‘trading stabile’.</p>
<h3 id="h3-Lead20Trader20A20alto20Sharpe20Ratio20alta20Win20Rate20basso20Drawdown35007"><a name="Lead Trader A: alto Sharpe Ratio; alta Win Rate; basso Drawdown" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lead Trader A: alto Sharpe Ratio; alta Win Rate; basso Drawdown</h3><p><img src="https://gimg2.gateimg.com/image/1673601001198909608113en1.png" alt=""><br>Dai dati della pagina, il rapporto di Sharpe del trader principale è 6,35, che è a un livello eccellente. Anche il tasso di vincita è piuttosto eccezionale, a un livello medio-superiore, e il massimo drawdown è estremamente basso, solo dello 0,53%. I valori sopra indicati mostrano che la maggior parte delle sue negoziazioni nel mese scorso è stata redditizia e non c’è stato alcun improvviso profitto singolo o brusco calo. Questo tipo di trader principale ha una probabilità relativamente alta di ottenere un profitto in ogni transazione, con un rendimento relativamente stabile e un rischio più contenuto.</p>
<h3 id="h3-Lead20Trader20B20alto20Sharpe20Ratio20alta20percentuale20di20vincita20alto20Drawdown10287"><a name="Lead Trader B: alto Sharpe Ratio; alta percentuale di vincita; alto Drawdown" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lead Trader B: alto Sharpe Ratio; alta percentuale di vincita; alto Drawdown</h3><p><img src="https://gimg2.gateimg.com/image/1673601028927913868113en2.png" alt=""><br>Anche se questo trader leader ha un Sharpe Ratio super elevato, un tasso di vincita molto alto e anche un drawdown elevato, ciò dimostra che alcuni dei suoi singoli trade catturano accuratamente le tendenze dei prezzi e ottengono un intervallo di profitto più ampio. Il suo profitto e la sua perdita complessivi sono relativamente evidenti. Ha una probabilità più alta di ottenere un alto ROI in una singola transazione. È più adatto per i copiatori che si aspettano di ottenere rendimenti elevati in un breve periodo e sono disposti a sfidarsi. Questo trader leader non è adatto al tipo stabile.</p>
<p>Sebbene le curve dei rendimenti di entrambi i lead trader siano in una tendenza costante e in aumento, e il rendimento sia positivo, con conseguente ottenimento di profitti, ciò non significa che siano entrambi lead trader stabili. Al contrario, il lead trader A è più vicino alle caratteristiche del trading stabile, perché è più in linea con lo standard completo di “alto indice di Sharpe; alto tasso di vincita; e basso drawdown”. Pertanto, gli altri lead trader dovrebbero sforzarsi di fare in modo che la loro curva dei rendimenti tenda a quella del lead trader A e sforzarsi di essere un lead trader stabile. Non solo possono ottenere un flusso costante di piccoli profitti, ma possono anche godere dei vantaggi esclusivi dei lead trader stabili.</p>
<h2 id="h2-Quali20sono20i20vantaggi20esclusivi20dei20trader20principali20stabili374537"><a name="Quali sono i vantaggi esclusivi dei trader principali stabili?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i vantaggi esclusivi dei trader principali stabili?</h2><h3 id="h3-120Risorse20ufficiali20della20piattaforma20e20supporto20al20traffico833529"><a name="1. Risorse ufficiali della piattaforma e supporto al traffico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Risorse ufficiali della piattaforma e supporto al traffico</h3><p>Gate.io Copy Trading effettuerà una valutazione dei dati ogni settimana tra i trader leader. Coloro che soddisfano il requisito di essere trader leader stabili otterranno le risorse ufficiali della piattaforma e il supporto del traffico, compresi banner ufficiali di Gate.io, banner di copy trading, lista di raccomandazioni di copy trading, Post ufficiali, gruppi di comunicazione ufficiali su TG, Twitter ufficiale, annunci ufficiali, email ufficiali, ecc. Rispetto ad altre piattaforme, Gate.io ha un ecosistema sociale completo. Abbiamo Gate.io Post per tutti gli utenti per comunicare internamente, un gruppo di comunicazione ufficiale su TG in varie lingue e una piattaforma Live. I trader leader possono facilmente utilizzare questi canali per promuoversi e ottenere fedeli fan di copy.</p>
<h3 id="h3-220Ricompense20in20contanti172849"><a name="2. Ricompense in contanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Ricompense in contanti</h3><p>Copy Trading selezionerà 5 trader leader stabili ogni quindici giorni e fornirà a ciascuno premi in denaro corrispondenti, che vanno da 10 a 100 USDT.</p>
<h3 id="h3-320Adozione20di20Opinioni20Personali8286"><a name="3. Adozione di Opinioni Personali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Adozione di Opinioni Personali</h3><p>Il Copy Trading selezionerà il miglior trader leader stabile ogni mese e entrerà in contatto con lui tramite email, inviandogli un Modulo di Raccolta Opinioni, chiedendo informazioni sui suoi bisogni e suggerimenti sull’uso dei prodotti di copy trading. Successivamente, il team di copy trading regolerà attivamente il modello e le funzioni del prodotto di conseguenza, e farà del suo meglio per soddisfare i requisiti del miglior trader leader.</p>
<h2 id="h2-Impegna20a20essere20un20commerciante20leader20stabile20combatti20contro20il20mercato20dellorso4611"><a name="Impegna a essere un commerciante leader stabile; combatti contro il mercato dell’orso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impegna a essere un commerciante leader stabile; combatti contro il mercato dell’orso</h2><p>Durante il calo del mercato, fare grandi profitti e piccole perdite dovrebbe essere la nostra norma di trading. Ottenere piccoli guadagni gradualmente dovrebbe essere il nostro obiettivo di trading. Invece di perseguire grandi profitti in un singolo trade, è più saggio perseguire rendimenti stabili a lungo termine. Specialmente nel periodo di mercato ribassista, quando è più difficile ottenere profitti e le perdite si verificano frequentemente, i trader leader devono considerare pienamente la sicurezza dei propri fondi e anche quelli dei loro copiatori. Devono utilizzare la leva con attenzione, controllare i rischi e ridurre le perdite il più possibile. Inoltre, dovrebbero operare con cautela, e sforzarsi di aumentare il Sharpe Ratio e il Win Rate, e ridurre al minimo il Max Drawdown. Impegnandosi per l’obiettivo di “fare trading in modo stabile, vincere a lungo termine”, i trader leader dovrebbero guidare i loro copiatori a sopravvivere alla maratona del mercato ribassista. Solo così potranno ancora restare nel mercato crittografico e godersi il divertimento dell’apprezzamento degli asset dopo aver vissuto molte conversioni toro-orso e vicissitudini!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Gate.io Copy Trading.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>