tp1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP1\n",
    "# Utiliser ATOM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objectifs\n",
    "\n",
    "Utiliser ATOM tel quel en écrivant un minimum code. Manipuler / Vérifier les\n",
    "traces\n",
    "\n",
    "Documentation Atom : http://atom.univ-lille1.fr/AtomDoc.html  \n",
    "Documentation R : https://www.r-project.org/manuals.html\n",
    "\n",
    "**Connaissances préalables** : Un peu de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  Rappels :  \n",
    "  - Le prix d'un ordre BID est un prix maximum (at worst)\n",
    "  - le BID le plus élevé est prioritaire\n",
    "  - Le prix d'un ordre ASK est un prix minimum (at least)\n",
    "  - Le ASK le plus faible est prioritaire\n",
    "  - Les ordres sont triés par prix, puis date\n",
    "  - Quand une fixation est possible, c'est le prix du premier\n",
    "    arrivé qui est utilisé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from atom import *\n",
    "import numpy as np      # principalement pour une gaussienne avec mean et std\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (10,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Expériences de fixation de prix\n",
    "\n",
    "ATOM contient une commande `replay` qui permet d'exécuter une\n",
    "série d'ordres. Tout agent cité dans ce fichier est\n",
    "automatiquement créé avec cash et invests à 0. Tout asset cité\n",
    "implique la création d'un orderbook pour son\n",
    "traitement. `replay` est donc multi-agents et multi-carnets et\n",
    "permet lors d'une exécution d'accéder à la richesse de trace d'ATOM (Order,Price, OrderBook, Agent,Exec,ticks,days)\n",
    "```\n",
    "m = Market(['LVMH'], trace=['price'], fix='S')  \n",
    "m.replay('orderFileEx1.dat')  \n",
    "m.print_state()  \n",
    "```\n",
    "**1. Regardez le fichier `orderFileEx1.dat`. La syntaxe des ordres est indiquée dedans. Combien de prix sont fixés ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Market(['LVMH'], trace=['price'], fix='S')\n",
    "m.replay('orderFileEx1.dat')\n",
    "m.print_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Modifiez la fixation de prix de short en long. Combien de prix sont fixés ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Market(['LVMH'], trace=['price'], fix='L')\n",
    "m.replay('orderFileEx1.dat')\n",
    "m.print_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Créez votre propre fichier contenant 3 limitOrders maxi, tous à des\n",
    "  prix différents, et tels que tous les ordres soient exécutés\n",
    "  complètement et que le nombre de prix fixés en `Short` et en\n",
    "  `Long` soit différent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('myOrderFile.dat',\"w\")\n",
    "file.write(\"\"\"\n",
    "NewAgent;paul;0;LVMH:0\n",
    "NewAgent;alan;0;LVMH:0\n",
    "NewAgent;bob;0;LVMH:0\n",
    "LimitOrder;LVMH;paul;BID;110;1\n",
    "LimitOrder;LVMH;bob;BID;120;1\n",
    "LimitOrder;LVMH;alan;ASK;100;2\n",
    "\"\"\")\n",
    "file.close()\n",
    "\n",
    "print(\"Short\")\n",
    "m = Market(['LVMH'], trace=['price'],fix=\"S\")\n",
    "m.replay('myOrderFile.dat')\n",
    "m.print_state()\n",
    "\n",
    "print(\"\\nLong\")\n",
    "m = Market(['LVMH'], trace=['price'],fix=\"L\")\n",
    "m.replay('myOrderFile.dat')\n",
    "m.print_state()\n",
    "\n",
    "# 2 en Long, 1 en Short\n",
    "# Si on permute la dernière ligne en première position, ce n'est plus vrai !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Donnez un fichier minimal d'ordres ne contenant qu'un seul ASK, et tel que 3 prix soient fixés (en L) en ordre décroissant**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('myOrderFile.dat',\"w\")\n",
    "file.write(\"\"\"\n",
    "NewAgent;alan;0;LVMH:0\n",
    "NewAgent;bob;0;LVMH:0\n",
    "LimitOrder;LVMH;bob;BID;110;1\n",
    "LimitOrder;LVMH;bob;BID;120;1\n",
    "LimitOrder;LVMH;bob;BID;130;1\n",
    "LimitOrder;LVMH;alan;ASK;100;3\n",
    "\"\"\")\n",
    "file.close()\n",
    "m = Market(['LVMH'], trace=['price'],fix=\"L\")\n",
    "m.replay('myOrderFile.dat')\n",
    "m.print_state()\n",
    "\n",
    "\n",
    "#  On note que ici c'est bob-3 qui est exécuté en premier, et bob-1 en \n",
    "#  dernier\n",
    "#  On note aussi que les ordres sont placés de manière croissante !\n",
    "#  Si on place le ASK en début de fichier, les 3 prix seront fixés à 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Donnez un fichier minimal d'ordres ne contenant qu'un seul ASK, et tel que 3 prix soient fixés en ordre croissant.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " C'est IMPOSSIBLE :  \n",
    "    Si le ask est en tête, c'est lui qui fournit le prix : tous les\n",
    "    prix seront identiques.   \n",
    "    Si le ask est en fin, les 3 bid arrivent donc avant, et seront\n",
    "    ordonnés par prix croissant (le plus élevé en prioritaire), donc\n",
    "    l'exécution donnera forcément\n",
    "    des prix décroissants.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Génération de prix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ATOM contient une commande `Generate` qui permet de créer des\n",
    "séries de prix ou d'ordres à partir d'expériences simples utilisant\n",
    "des Zero Intelligence Traders (appelés dans le fichier généré `ZIT 1` à `ZIT n`) générant chacun un ordre à\n",
    "chaque tour. La génération d'une série d'ordres est immédiatement\n",
    "exécutée fournissant ainsi une trace ATOM, reproductible par\n",
    "`Replay`.\n",
    "\n",
    "```\n",
    "m.generate(<nb_ZIT>, <nb_turn>, <init_assets>, <init_cash>)\n",
    "```\n",
    "**1. Générez un fichier `myfile.dat` à 3 agents et 1 seul carnet d'ordres s'exécutant durant 100 tours de parole.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open('myfile.dat', 'w')\n",
    "m = Market(['Apple'], out=file)\n",
    "m.generate(3, 100, 0, 0)\n",
    "m.print_state()\n",
    "\n",
    "# On en profite pour extraire les noms des différents agents utilisés\n",
    "#traders_id = []\n",
    "#for trader in m.traders:\n",
    "#    traders_id.append(trader.trader_id)\n",
    "#file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fois fait, jetez quand même un oeil à ce fichier histoire d'en appréhender la syntaxe.\n",
    "\n",
    "**2. A partir de `myfile.dat`, générez `myfile.orders.dat` et `myfile.prices.dat` contenant respectivement les ordres et les prix générés par cette expérience.**\n",
    "\n",
    "Sous Unix ou MacOS c'est facile, mais en Python il faut extraire les lignes :-()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orders = open(\"myfile.orders.dat\",\"w\")\n",
    "prices = open(\"myfile.prices.dat\",\"w\")\n",
    "myfile = open(\"myfile.dat\",\"r\")\n",
    "line = myfile.readline()\n",
    "while(line!=\"\"):\n",
    "    if line[0]!='#':\n",
    "        if \"Price;\" in line:\n",
    "            prices.write(line)\n",
    "        elif \"LimitOrder;\" in line:\n",
    "            orders.write(line)\n",
    "    line = myfile.readline()\n",
    "orders.close()\n",
    "prices.close()\n",
    "myfile.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Combien y-a t-il d'ordres et de prix dans ces deux fichiers ?**\n",
    "\n",
    "Sous Unix ou MacOS c'est facile, mais en Python il faut compter les lignes :-("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_lines(filename):\n",
    "    file = open(filename,\"r\")\n",
    "    line = file.readline()\n",
    "    c=0\n",
    "    while(line!=\"\"):\n",
    "        c+=1\n",
    "        line = file.readline()\n",
    "    return c\n",
    "print(\"Nombre de prix :\",count_lines(\"myfile.prices.dat\"))\n",
    "print(\"Nombre d'ordres :\",count_lines(\"myfile.orders.dat\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Tracez la courbe d'évolution des prix de cette expérience**\n",
    "\n",
    "La fonction `extract_prices` permet d'extraire toutes les lignes de prix d'un fichier de log. Elle renvoie un dictionnaire dont les clés sont les assets et dont les valeurs sont tuples de 2 listes : la liste des prix et la liste des ticks correspondants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Prices = extract_prices('myfile.dat')\n",
    "\n",
    "plt.plot(Prices[\"Apple\"][0], Prices[\"Apple\"][1], '-', label='Apple')\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Price')\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On rappelle que dans les fichiers générés les lignes de prix sont de la forme\n",
    "\n",
    "`Price;asset;bider;asker;price;qty;timestamp(µs)`\n",
    "\n",
    "Cette série d'instructions parcourt le fichiers de prix de manière à en extraire trois listes : `prices`, `quty` directement issus d'une ligne, et la volatilité `vol` que nous calculons entre deux prix.\n",
    "Ces trois listes nous permettront de plus facilement manipuler les données."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prices = []\n",
    "qty = []\n",
    "vol = []\n",
    "\n",
    "file = open('myfile.prices.dat', 'r')\n",
    "file.readline()\n",
    "line = file.readline()\n",
    "while(line!=\"\"):\n",
    "    l = line.split(\";\")\n",
    "    prices.append(int(l[4]))\n",
    "    qty.append(int(l[5]))\n",
    "    if(len(prices)>1):\n",
    "        vol.append((prices[-2]-prices[-1])/prices[-1])\n",
    "    line = file.readline()\n",
    "\n",
    "print(len(prices), len(qty), len(vol))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Tracez la série chronologique (barplot) d'évolution des quantités**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar([i for i in range(len(qty))],qty)\n",
    "plt.title(\"Quantités échangées\",{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"n-ème vente\")\n",
    "plt.ylabel('Quantité échangée')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Tracez la série chronologique (barplot) des volatilités (variation de prix en pourcentage)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar([i for i in range(len(vol))],vol)\n",
    "plt.title(\"Différence de profits\",{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"n-ème vente\")\n",
    "plt.ylabel('Différence')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7. Tracez l'histogramme de distribution des volatilités**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(vol, bins=50)\n",
    "plt.title(\"Histogramme des profits\",{'fontsize': 20})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**8. Comparez avec une gaussienne de même moyenne et écart-type**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-1.5, 2.5, 1000)\n",
    "mu = np.mean(vol)\n",
    "sigma = np.std(vol)\n",
    "y = (9 / (np.sqrt(2 * np.pi * np.power(sigma, 2)))) * \\\n",
    "    (np.power(np.e, -(np.power((x - mu), 2) / (2 * np.power(sigma, 2)))))\n",
    "plt.hist(vol, bins=50)\n",
    "plt.title(\"Histogramme des profits\",{'fontsize': 20})\n",
    "plt.plot(x, y);\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Est-ce un cours vraisemblable ?\n",
    "\n",
    "Sachant que la commande `Generate` utilise des agents ZIT dont chaque ordre envoyé est un ordre dont le prix est tiré uniformément entre 1000 et 9999 et la quantité entre 1 et 9. Refaire les mêmes\n",
    "courbes mais avec des données purement aléatoires."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_ordres = 300\n",
    "pricesR = [random.randint(1000,9999) for i in range(nb_ordres)]\n",
    "qtyR = [random.randint(1,9) for i in range(nb_ordres)]\n",
    "diffR = []\n",
    "\n",
    "for i in range(1,206):\n",
    "    diffR.append((pricesR[i-1]-pricesR[i])/pricesR[i])\n",
    "    \n",
    "plt.plot(pricesR)\n",
    "plt.title(\"Prix\",{'fontsize': 20})\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Price')\n",
    "plt.show()\n",
    "\n",
    "plt.bar([i for i in range(len(qtyR))],qtyR)\n",
    "plt.title(\"Quantités échangées\",{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"n-ème vente\")\n",
    "plt.ylabel('Quantité échangée')\n",
    "plt.show()\n",
    "\n",
    "plt.bar([i for i in range(len(diffR))],diffR)\n",
    "plt.title(\"Différence de profits\",{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"n-ème vente\")\n",
    "plt.ylabel('Différence')\n",
    "plt.show()\n",
    "\n",
    "mR = np.mean(diffR)\n",
    "sR = np.std(diffR)\n",
    "\n",
    "plt.hist(diffR, bins=50)\n",
    "plt.title(\"Histogramme des profits\",{'fontsize': 20})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Évolution du portefeuille d'un agent\n",
    "**1. Tracez l'évolution du cash du 3e agent issu de ce\n",
    "  fichier. Chaque opération sur les avoirs d'un agent étant tracées\n",
    "  dans une ligne `Agent`, cette courbe est facile à obtenir.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zitnames = [\"ZIT \"+str(t.trader_id) for t in m.traders]\n",
    "\n",
    "# Comme précédemment une première fonction extrait une liste avec l'évolution du cash de l'agent\n",
    "def extract_cash(filename,agent):\n",
    "    cash = []\n",
    "    file = open(filename,\"r\")\n",
    "    line = file.readline()\n",
    "    while(line!=\"\"):\n",
    "        if \"Agent;\"+agent in line and not \"NewAgent\" in line:\n",
    "            cash.append(int(line.split(\";\")[2]))\n",
    "        line = file.readline()\n",
    "    file.close()\n",
    "    return cash\n",
    "\n",
    "cash = extract_cash('myfile.dat',zitnames[2])\n",
    "\n",
    "# puis on trace la courbe avec ces informations\n",
    "plt.plot(cash)\n",
    "plt.title(\"Cash de \"+zitnames[2],{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"tick\")\n",
    "plt.ylabel('Cash')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Tracez l'évolution du portefeuille (wealth) du troisième agent issu de ce fichier (facile car il y n'a qu'un seul asset)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wealths = extract_wealths('myfile.dat')       \n",
    "\n",
    "plt.plot(wealths[zitnames[2]][1])\n",
    "plt.title(\"Wealth de \"+zitnames[2],{'fontsize': 20})\n",
    "plt.grid()\n",
    "plt.xlabel(\"n-ème vente\")\n",
    "plt.ylabel('Wealth')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Déterminez quel est celui des 3 agents qui s'en est sorti le\n",
    "  mieux ? Est-ce que la somme des 3 valuations est nulle ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"À la fin : \")\n",
    "\n",
    "wealths_end = []\n",
    "for i in range(3):\n",
    "    wealths_end.append(wealths[zitnames[i]][1][-1])\n",
    "    \n",
    "for i in range(3):\n",
    "    print(zitnames[i]+\" : \"+str(wealths_end[i]))\n",
    "\n",
    "print(\"Somme :\",sum(wealths_end))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Comparer le wealth de plusieurs agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for agent in wealths.keys():\n",
    "    T, W = wealths[agent]\n",
    "    plt.plot(T, W, '-', label=agent)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.xlabel('Tick')\n",
    "plt.ylabel('Wealth')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Rejouer un fichier généré\n",
    "\n",
    "Les fichiers obtenus avec `Generate` sont totalement\n",
    "compatibles avec `Replay`. Ils peuvent donc être rejoués tels\n",
    "quels sans aucun problème. Dans le cas d'un `Replay` d'un tel\n",
    "fichier, seules les lignes `Orders` seront prises en compte. Les\n",
    "autres lignes (Ticks ou commandes par exemple) sont simplement recopiées.\n",
    "\n",
    "\n",
    "**1. Rejouez `myfile.dat` et affichez le résultat.**  \n",
    "**2. Vérifiez que ce résultat correspond à `myfile.dat`**\n",
    "\n",
    "_Problème de trace :  agents renommés, trace forcément affichée, jamais les ticks.._\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Market(['Apple'])\n",
    "m.replay('myfile.dat')\n",
    "print(\"\\nÉtat des traders à la fin : \")\n",
    "for t in m.traders: # On parcourt l'ensemble des traders\n",
    "    print(\"Agent \"+t.get_infos(m))\n",
    "#m.print_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Afin de vérifier qu'ATOM n'a pas \"triché\", refaites la même\n",
    "  expérience mais en ne reprenant que les ordres du fichier\n",
    "  initial.**\n",
    "\n",
    "  * Séparer le fichier `myfile` initial en deux fichiers\n",
    "    `init.orders` et `init.prices`\n",
    "  * Rejouez `init.orders` et ne conservez que les prix\n",
    "    générés dans `final.prices`\n",
    "  * comparez `init.prices` et `final.prices`\n",
    "  \n",
    "  _les fichiers ne sont pas identiques : pas de triche possible_"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}