Tính toán phái sinh bậc nhất với khung tổng hợp MongoDB

Đây là những gì đang diễn ra bên trong $ map (xem $ map như một vòng lặp for) in biểu thức:

Đối với mỗi tài liệu con, chúng tôi chỉ định giá trị vào một biến bằng cách sử dụng $ let toán tử biến. Sau đó, chúng tôi trừ giá trị của nó khỏi giá trị của trường "giá trị" của phần tử tiếp theo trong mảng.

Vì phần tử tiếp theo trong mảng là phần tử ở chỉ mục hiện tại cộng với một phần tử, tất cả những gì chúng ta cần là sự trợ giúp của $ arrayElemAt toán tử và một $ add đơn giản ý chỉ chỉ mục của phần tử hiện tại và 1 .

$ subtract biểu thức trả về giá trị âm vì vậy chúng ta cần nhân giá trị với -1 bằng cách sử dụng $ nhân nhà điều hành.

Chúng tôi cũng cần $ filter mảng được kết quả vì nó là phần tử cuối cùng Không có hoặc null . Lý do là khi phần tử hiện tại là phần tử cuối cùng, $ subtract return Không vì chỉ số của phần tử tiếp theo bằng kích thước của mảng.

db.collection.aggregate([
  {
    "$unwind": {
      "path": "$time_series",
      "includeArrayIndex": "index"
    }
  },
  {
    "$group": {
      "_id": "$_id",
      "time_series": {
        "$push": {
          "value": "$time_series",
          "index": "$index"
        }
      }
    }
  },
  {
    "$project": {
      "time_series": {
        "$filter": {
          "input": {
            "$map": {
              "input": "$time_series",
              "as": "el",
              "in": {
                "$multiply": [
                  {
                    "$subtract": [
                      "$$el.value",
                      {
                        "$let": {
                          "vars": {
                            "nextElement": {
                              "$arrayElemAt": [
                                "$time_series",
                                {
                                  "$add": [
                                    "$$el.index",
                                    1
                                  ]
                                }
                              ]
                            }
                          },
                          "in": "$$nextElement.value"
                        }
                      }
                    ]
                  },
                  -1
                ]
              }
            }
          },
          "as": "item",
          "cond": {
            "$gte": [
              "$$item",
              0
            ]
          }
        }
      }
    }
  }
])

Một tùy chọn khác mà tôi nghĩ là kém hiệu quả hơn là thực hiện thao tác bản đồ / thu nhỏ trên bộ sưu tập của chúng tôi bằng cách sử dụng map_reduce phương pháp.

>>> import pymongo
>>> from bson.code import Code
>>> client = pymongo.MongoClient()
>>> db = client.test
>>> collection = db.collection
>>> mapper = Code("""
...               function() {
...                 var derivatives = [];
...                 for (var index=1; index<this.time_series.length; index++) {
...                   derivatives.push(this.time_series[index] - this.time_series[index-1]);
...                 }
...                 emit(this._id, derivatives);
...               }
...               """)
>>> reducer = Code("""
...                function(key, value) {}
...                """)
>>> for res in collection.map_reduce(mapper, reducer, out={'inline': 1})['results']:
...     print(res)  # or do something with the document.
... 
{'value': [10.0, 20.0, 30.0, 40.0], '_id': ObjectId('57c11ddbe860bd0b5df6bc64')}

Bạn cũng có thể truy xuất tất cả tài liệu và sử dụng numpy.diff để trả về dẫn xuất như sau:

import numpy as np


for document in collection.find({}, {'time_series': 1}):
    result = np.diff(document['time_series'])