Über diesen Artikel

Dieser Artikel ist eine Fortsetzung des Artikels, den ich neulich gepostet habe.

Dieses Mal habe ich persönlich BitCoint-Preisschwankungsdaten mit einer bestimmten Rest-API gesammelt und diese wurden zu umfangreich. Daher werde ich darüber schreiben, wann ich die Anzahl der Dokumente heruntergerechnet und reduziert habe.

Was ist Aggregat

Es ist ein Aggregationsprozess. In Pymongo wird die Aggregationsverarbeitung ausgeführt, indem eine Pipeline (bedingte Anweisung) an die Aggregatfunktion übergeben wird. Die Pileline besteht aus Stufe und Operator, und jede Stufe entspricht "Auswählen", "Gruppieren nach", "Wobei" usw. für SQL, und der Operator entspricht "Summe", "Max", "Min" usw. ..

Referenz: Aggregate Pipeline (Stufe) Referenz: Aggregate Pileline (Operator)

Hintergrund

Als Ergebnis der Aufnahme des Erfassungsergebnisses von Rest API in die Sammlung, wie es ist, Ich habe viele Daten wie die folgenden vergeblich gestellt (51240). (Wenn ich es mehrere Tage im Abstand von 10 Minuten stehen gelassen hätte, hätte es sich angesammelt, bevor ich es wusste ...) Da es ärgerlich ist, habe ich es heruntergesampelt, um die Anzahl der Daten zu reduzieren.

`In der Sammlung gespeicherte Dokumente`


client = MongoClient()
db = client["BitCoin"]["document"]
pprint(db.count()) #Funktion zum Abrufen der Anzahl der Dokumente in der Sammlung
pprint(db.find_one())

"""
#Ausgabeergebnis
51240
{'_id': ObjectId('5f328ad85ae5ac59aee515cb'),
 'best_ask': 1245419.0,
 'best_ask_size': 0.02,
 'best_bid': 1244658.0,
 'best_bid_size': 0.05,
 'ltp': 1245615.0,
 'product_code': 'BTC_JPY',
 'tick_id': 10956004,
 'timestamp': 1597115465.0,
 'total_ask_depth': 1364.44898005,
 'total_bid_depth': 1637.4300907,
 'volume': 126756.67774321,
 'volume_by_product': 6571.45287901
}
"""

Die Grafik sieht so aus ... Es gibt zu viele Punkte und es ist wirklich nervig

Pipeline-Einstellungen für Aggregat

Vorläufig haben wir die Daten in Intervallen von 10 Minuten in tägliche Daten gruppiert, jeden Wert gemittelt und ein Downsampling durchgeführt.

Unten sehen Sie die in Pymongo verwendete aggregierte Pipeline.

`pipeline`


coin = "BTC_JPY"
interval = 60*60*24 # 24hour 
pipeline = [
    # match stage 
    {"$match": {"product_code": coin} },
    # group stage
    {"$group": {
        "_id":
        {"timestamp":
            {"$subtract":  ["$timestamp", { "$mod": ["$timestamp", interval]}]
             }
         ,
        "product_code": "$product_code"
        },
        "timestamp":{"$avg": "$timestamp"},
        "ltp": {"$avg": "$ltp"},
        "best_ask": {"$avg": "$best_ask"},
        "best_ask_size": {"$avg": "$best_ask_size"},
        "best_bid_size": {"$avg": "$best_bid_size"},
        "total_ask_depth": {"$avg": "$total_ask_depth"},
        "total_bid_depth": {"$avg": "$total_bid_depth"},
        "volume": {"$avg": "$volume"},
        "volume_by_product": {"$avg": "$volume_by_product"},
    }},
    # presentation stage
    {"$project": {
        "product_code": "$_id.product_code",
        "_id": 0, "timestamp": 1,"ltp": 1,
        "best_ask": 1,"best_ask_size":   1,
        "best_bid_size": 1,
        "total_ask_depth": 1,
        "total_bid_depth": 1,
        "volume": 1, "volume_by_product": 1,
        }
    }
]

Ich werde die Pipeline erklären.

Holen Sie sich das zu aggregierende Ziel ($ match) Dieses Mal habe ich diejenigen mit dem gleichen "Produktcode" bekommen. (Sie können es genauso angeben wie find.)

{"$match": {"product_code": coin} }, ```

Gruppierung ($ group) Der Produktcode und der Zeitstempel wurden so gruppiert, dass sie zur Unixtime in Intervallen von 1 Tag übereinstimmen, und die anderen Werte wurden gemittelt. Die folgenden zwei Punkte können erwähnt werden.
Legen Sie das zu gruppierende Ziel in "_id" fest

Geben Sie nach _id den gewünschten Schlüssel, den Maximalwert usw. und die Berechnungsmethode (Operator) an.

{"$group": {
    "_id": #Legen Sie hier das zu gruppierende Ziel fest
    {"timestamp":
        {"$subtract":  
            ["$timestamp", 
                { "$mod": ["$timestamp", interval]}]
         }
     ,
    "product_code": "$product_code"
    },
    "timestamp":{"$avg": "$timestamp"},
    "ltp": {"$avg": "$ltp"},

Geben Sie die anzuzeigenden Daten an ($ project) (Sie können dies mit der gleichen Operation wie das Projekt in find tun.)

 {"$project": {
     "product_code": "$_id.product_code",
     "_id": 0, "timestamp": 1,"ltp": 1,
     "best_ask": 1,"best_ask_size":   1,
     "best_bid_size": 1,
     "total_ask_depth": 1,
     "total_bid_depth": 1,
     "volume": 1, "volume_by_product": 1,
     }
 }

Downsampled-Ergebnis

Ich habe die von der Pipeline zuvor heruntergetasteten Daten mit den Originaldaten verglichen. Der rote Punkt steht vor dem Downsampling und der blaue Punkt nach dem Downsampling. Sie können sehen, dass die Daten gut ausgedünnt sind.

import matplotlib.pyplot as plt

plt.figure()
for i in db.find( filter= {"product_code": coin
                          } ):
    plt.scatter(i["timestamp"], i["ltp"], marker=".", color="r")
for i in  db.aggregate(pipeline=pipeline):
    plt.scatter(i["timestamp"], i["ltp"], marker=".", color="b")
plt.grid()
plt.xlabel("Data[unixtime]")
plt.ylabel(coin)
plt.savefig("test2.jpg ")
plt.show()

Nun, es gibt immer noch viele Dinge über Aggregate, aber es gibt zu viele, also werde ich dieses Mal hier enden. Ich werde Korrekturen, Fragen und alles hinzufügen, was Sie schreiben sollen.

[PYTHON] Arbeitsmemorandum (Pymongo) Teil 3. Ich möchte es nicht noch einmal überprüfen, also notieren Sie es sich (Aggregat)