onnx 1.18.0__cp310-cp310-win_amd64.whl → 1.19.1rc1__cp310-cp310-win_amd64.whl

onnx/version_converter/adapters/batch_normalization_13_14.h

@@ -17,12 +17,10 @@ class BatchNormalization_13_14 final : public Adapter {
  public:
   explicit BatchNormalization_13_14() : Adapter("BatchNormalization", OpSetID(13), OpSetID(14)) {}
 
-  void adapt_batch_normalization_13_14(Node* node) const {
-    ONNX_ASSERTM(
-        node->outputs().size() < 4,
-        "BatchNormalization outputs 4 and 5 are not "
-        "supported in Opset 14.");
-  }
+  void adapt_batch_normalization_13_14(Node* node) const {ONNX_ASSERTM(
+      node -> outputs().size() < 4,
+      "BatchNormalization outputs 4 and 5 are not "
+      "supported in Opset 14.")}
 
   Node* adapt(std::shared_ptr<Graph>, Node* node) const override {
     adapt_batch_normalization_13_14(node);

onnx/version_converter/adapters/broadcast_backward_compatibility.h

@@ -42,7 +42,7 @@ class BroadcastBackwardCompatibility final : public Adapter {
         "not have broadcastable inputs.",
         name().c_str(),
         initial_version().version(),
-        target_version().version());
+        target_version().version())
     if (req_broadcast == 1) {
       // If conditional is not fulfilled, we have a default broadcast
       // Add broadcast attribute

onnx/version_converter/adapters/extend_supported_types.h

@@ -58,9 +58,9 @@ struct ExtendSupportedTypes final : public Adapter {
     };
 
     ONNX_ASSERTM(
-        unsupported_version9_types.find(input_type) == unsupported_version9_types.end(), "Unsupported Input Type");
+        unsupported_version9_types.find(input_type) == unsupported_version9_types.end(), "Unsupported Input Type")
     ONNX_ASSERTM(
-        unsupported_version9_types.find(output_type) == unsupported_version9_types.end(), "Unsupported Output Type");
+        unsupported_version9_types.find(output_type) == unsupported_version9_types.end(), "Unsupported Output Type")
 
     bool castInput = (node->kind() != kConstant);
     bool castOutput = (node->kind() != kGreater && node->kind() != kLess);

onnx/version_converter/adapters/gemm_6_7.h

@@ -42,7 +42,7 @@ class Gemm_6_7 final : public Adapter {
     ONNX_ASSERTM(
         check_numpy_unibroadcastable_and_require_broadcast(MN, C_shape) != -1,
         "Gemm being converted from 6 to 7 does not have "
-        "broadcastable inputs.");
+        "broadcastable inputs.")
     if (node->hasAttribute(kbroadcast))
       node->removeAttribute(kbroadcast);
   }

onnx/version_converter/adapters/gemm_7_6.h

@@ -47,7 +47,7 @@ class Gemm_7_6 final : public Adapter {
         "not have broadcastable inputs.",
         name().c_str(),
         initial_version().version(),
-        target_version().version());
+        target_version().version())
     if (req_broadcast == 1) {
       node->i_(kbroadcast, 1);
     }

onnx/version_converter/adapters/maxpool_8_7.h

@@ -21,7 +21,7 @@ class MaxPool_8_7 final : public Adapter {
 
   void adapt_maxpool_8_7(const std::shared_ptr<Graph>&, Node* node) const {
     const ArrayRef<Value*>& outputs = node->outputs();
-    ONNX_ASSERTM(outputs.size() != 2, "Opset version 7 of MaxPool cannot include Indices output");
+    ONNX_ASSERTM(outputs.size() != 2, "Opset version 7 of MaxPool cannot include Indices output")
     if (node->hasAttribute(kstorage_order))
       node->removeAttribute(kstorage_order);
   }

onnx/version_converter/adapters/no_previous_version.h

@@ -23,7 +23,7 @@ class NoPreviousVersionAdapter final : public Adapter {
       : Adapter(op_name, initial, target) {}
 
   Node* adapt(std::shared_ptr<Graph>, Node* node) const override {
-    ONNX_ASSERTM(false, "No Previous Version of %s exists", name().c_str());
+    ONNX_ASSERTM(false, "No Previous Version of %s exists", name().c_str())
     return node;
   }
 };

onnx/version_converter/adapters/reshape_5_4.h

@@ -36,7 +36,7 @@ class Reshape_5_4 final : public Adapter {
         std::string raw_data = node_ptr->t(kvalue).raw();
         ONNX_ASSERTM(
             !raw_data.empty() && raw_data.size() % 8 == 0,
-            "Raw Data must be non-empty and size must be a multiple of 8");
+            "Raw Data must be non-empty and size must be a multiple of 8")
         int64_t* raw = reinterpret_cast<int64_t*>(raw_data.data());
         node->is_(kshape, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
@@ -60,7 +60,7 @@ class Reshape_5_4 final : public Adapter {
         }
       }
     }
-    ONNX_ASSERTM(node->hasAttribute(kshape), "No initializer or constant input to Reshape node found");
+    ONNX_ASSERTM(node->hasAttribute(kshape), "No initializer or constant input to Reshape node found")
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

onnx/version_converter/adapters/resize_10_11.h

@@ -21,7 +21,7 @@ class Resize_10_11 final : public Adapter {
   explicit Resize_10_11() : Adapter("Resize", OpSetID(10), OpSetID(11)) {}
 
   void adapt_resize_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
-    int input_rank = node->inputs()[0]->sizes().size();
+    int64_t input_rank = node->inputs()[0]->sizes().size();
 
     Value* scales_input = node->inputs()[1];
     node->addInput(scales_input);

onnx/version_converter/adapters/scan_8_9.h

@@ -36,7 +36,7 @@ struct Scan_8_9 final : public Adapter {
 
     node->removeAllInputs();
 
-    ONNX_ASSERTM(inputs[0]->uniqueName().empty(), "Unsupported conversion to opset 9");
+    ONNX_ASSERTM(inputs[0]->uniqueName().empty(), "Unsupported conversion to opset 9")
 
     for (Value* input : inputs) {
       if (!input->sizes().empty()) {

onnx/version_converter/adapters/scan_9_8.h

@@ -37,7 +37,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(output_dirs)) {
       const std::vector<int64_t> scan_output_directions(node->is(output_dirs));
       for (int64_t x : scan_output_directions) {
-        ONNX_ASSERTM(x == 0, "Unsupported output direction for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported output direction for Version 8")
       }
       node->removeAttribute(output_dirs);
     }
@@ -46,7 +46,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(input_axes)) {
       const std::vector<int64_t> scan_input_axes(node->is(input_axes));
       for (int64_t x : scan_input_axes) {
-        ONNX_ASSERTM(x == 0, "Unsupported input axes for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported input axes for Version 8")
       }
       node->removeAttribute(input_axes);
     }
@@ -55,7 +55,7 @@ struct Scan_9_8 final : public Adapter {
     if (node->hasAttribute(output_axes)) {
       const std::vector<int64_t> scan_output_axes(node->is(output_axes));
       for (int64_t x : scan_output_axes) {
-        ONNX_ASSERTM(x == 0, "Unsupported output axes for Version 8");
+        ONNX_ASSERTM(x == 0, "Unsupported output axes for Version 8")
       }
       node->removeAttribute(output_axes);
     }

onnx/version_converter/adapters/split_13_12.h

@@ -37,7 +37,7 @@ class Split_13_12 : public Adapter {
         std::string raw_data = node_ptr->t(kvalue).raw();
         ONNX_ASSERTM(
             !raw_data.empty() && raw_data.size() % 8 == 0,
-            "Raw Data must be non-empty and size must be a multiple of 8");
+            "Raw Data must be non-empty and size must be a multiple of 8")
         int64_t* raw = reinterpret_cast<int64_t*>(raw_data.data());
         node->is_(ksplit, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
@@ -61,7 +61,7 @@ class Split_13_12 : public Adapter {
         }
       }
     }
-    ONNX_ASSERTM(node->hasAttribute(ksplit), "No initializer or constant input to node found");
+    ONNX_ASSERTM(node->hasAttribute(ksplit), "No initializer or constant input to node found")
     return node;
   }
 };

onnx/version_converter/adapters/transformers.h

@@ -34,7 +34,7 @@ inline NodeTransformerFunction RemoveAttribute(Symbol attr) {
 inline NodeTransformerFunction RemoveAttribute(Symbol attr, int64_t value) {
   return NODE_TRANSFORMER(node) {
     if (node->hasAttribute(attr)) {
-      ONNX_ASSERTM(node->i(attr) == value, "Attribute %s must have value %" PRId64, attr.toString(), value);
+      ONNX_ASSERTM(node->i(attr) == value, "Attribute %s must have value %" PRId64, attr.toString(), value)
       node->removeAttribute(attr);
     }
     return node;
@@ -44,7 +44,7 @@ inline NodeTransformerFunction RemoveAttribute(Symbol attr, int64_t value) {
 inline NodeTransformerFunction RemoveAttributeNotEq(Symbol attr, int64_t value) {
   return NODE_TRANSFORMER(node) {
     if (node->hasAttribute(attr)) {
-      ONNX_ASSERTM(node->i(attr) != value, "Attribute %s must not have value %" PRId64, attr.toString(), value);
+      ONNX_ASSERTM(node->i(attr) != value, "Attribute %s must not have value %" PRId64, attr.toString(), value)
       node->removeAttribute(attr);
     }
     return node;

onnx/version_converter/adapters/type_restriction.h

@@ -53,7 +53,7 @@ class TypeRestriction : public Adapter {
         " of operator '%s' is unallowed for Opset Version %d.",
         val->elemType(),
         name().c_str(),
-        target_version().version());
+        target_version().version())
   }
 };
 

onnx/version_converter/adapters/upsample_6_7.h

@@ -25,13 +25,13 @@ struct Upsample_6_7 final : public Adapter {
     Symbol height_scale_symbol = Symbol("height_scale");
     ONNX_ASSERTM(
         node->hasAttribute(width_scale_symbol) && node->hasAttribute(height_scale_symbol),
-        "Upsample in opset 1 needs to have width_scale and height_scale attributes");
+        "Upsample in opset 1 needs to have width_scale and height_scale attributes")
 
     auto width_scale = node->f(width_scale_symbol);
     auto height_scale = node->f(height_scale_symbol);
 
     auto input_shape = node->inputs()[0]->sizes();
-    ONNX_ASSERTM(input_shape.size() == 4, "Upsample in opset 1 supports only 4D input tensor");
+    ONNX_ASSERTM(input_shape.size() == 4, "Upsample in opset 1 supports only 4D input tensor")
     std::vector<double> scales = {1.0, 1.0, height_scale, width_scale};
 
     node->fs_(kscales, std::move(scales));

onnx/version_converter/adapters/upsample_9_8.h

@@ -26,7 +26,7 @@ struct Upsample_9_8 final : public Adapter {
     const ArrayRef<Value*>& inputs = node->inputs();
     const std::vector<Tensor>& initializers = graph->initializers();
 
-    ONNX_ASSERTM(inputs.size() == 2, "Upsample in opset 9 needs to have 2 inputs.");
+    ONNX_ASSERTM(inputs.size() == 2, "Upsample in opset 9 needs to have 2 inputs.")
     std::string scale_input_name = node->inputs()[1]->uniqueName();
 
     for (const auto& initializer : initializers) {
@@ -66,7 +66,7 @@ struct Upsample_9_8 final : public Adapter {
       }
     }
 
-    ONNX_ASSERTM(false, "Unsuppported conversion due to unavailable input: scale");
+    ONNX_ASSERTM(false, "Unsuppported conversion due to unavailable input: scale")
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

onnx/version_converter/convert.cc

@@ -132,7 +132,7 @@ ModelProto DefaultVersionConverter::convert_version(
   for (auto it = mp_in.opset_import().begin(); it != mp_in.opset_import().end(); ++it) {
     if (it->domain() == initial_version.domain()) {
       ONNX_ASSERTM(
-          initial_version.version() == it->version(), "initial_version does not reflect current state of model");
+          initial_version.version() == it->version(), "initial_version does not reflect current state of model")
     }
   }
 

onnx/version_converter/convert.h

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "onnx/version_converter/BaseConverter.h"
+#include "onnx/version_converter/adapters/Attention_24_23.h"
 #include "onnx/version_converter/adapters/axes_attribute_to_input.h"
 #include "onnx/version_converter/adapters/axes_input_to_attribute.h"
 #include "onnx/version_converter/adapters/axis_attribute_to_input.h"
@@ -89,7 +90,7 @@ class DefaultVersionConverter : public BaseVersionConverter {
         version >= version_range.first && version <= version_range.second,
         "Warning: invalid version (must be between %d and %d)",
         version_range.first,
-        version_range.second);
+        version_range.second)
   }
 
   void assertDefaultDomain(const std::string& initial_domain, const std::string& target_domain) const {
@@ -97,8 +98,8 @@ class DefaultVersionConverter : public BaseVersionConverter {
         (initial_domain.empty() || initial_domain == "ai.onnx") &&
             (target_domain.empty() || target_domain == "ai.onnx"),
         "Warning: default onnx version converter can only convert "
-        " between default domain opset versions ('' or 'ai.onnx')\n");
-    ONNX_ASSERTM(initial_domain == target_domain, "initial_version and target_version must have the same domains");
+        " between default domain opset versions ('' or 'ai.onnx')\n")
+    ONNX_ASSERTM(initial_domain == target_domain, "initial_version and target_version must have the same domains")
   }
 
   void convert_graph(const std::shared_ptr<Graph>& g, const OpSetID& initial_version, const OpSetID& target_version)
@@ -127,8 +128,9 @@ class DefaultVersionConverter : public BaseVersionConverter {
           }
         }
         if (min_version > 1) {
-          registerAdapter(std::make_unique<NoPreviousVersionAdapter>(
-              op_pair.first, OpSetID(min_version), OpSetID(min_version - 1)));
+          registerAdapter(
+              std::make_unique<NoPreviousVersionAdapter>(
+                  op_pair.first, OpSetID(min_version), OpSetID(min_version - 1)));
         }
       }
     }
@@ -826,12 +828,66 @@ class DefaultVersionConverter : public BaseVersionConverter {
     registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
     registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
     registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+
+    /******** 23 -> 24 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Attention", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(23), OpSetID(24)));
+
+    // TopK and SplitToSequence 23=>24 update adds bfloat16 support
+    registerAdapter(std::make_unique<CompatibleAdapter>("TopK", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("SplitToSequence", OpSetID(23), OpSetID(24)));
+
+    /******** 24 -> 23 ********/
+    registerAdapter(std::make_unique<Attention_24_23>());
+    const std::vector<TensorProto_DataType> ir12_types_not_in_ir11 = {TensorProto_DataType_FLOAT8E8M0};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+
+    registerAdapter(std::make_unique<TypeRestriction>("TopK", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("SplitToSequence", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
   }
 
   ModelProto convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version)
       const override;
 };
 
-ModelProto ConvertVersion(const ModelProto& mp_in, int target_version);
+ONNX_API ModelProto ConvertVersion(const ModelProto& mp_in, int target_version);
 } // namespace version_conversion
 } // namespace ONNX_NAMESPACE

onnx/version_converter/helper.cc

@@ -57,13 +57,13 @@ void assert_numpy_multibroadcastable(
         i,
         B,
         axis + i,
-        A);
+        A)
   }
 }
 
 void assertNotParams(const std::vector<Dimension>& sizes) {
   for (const Dimension& dim : sizes) {
-    ONNX_ASSERTM(dim.is_int, "%s Dimension is a param instead of an int.", dim.param.c_str());
+    ONNX_ASSERTM(dim.is_int, "%s Dimension is a param instead of an int.", dim.param.c_str())
   }
 }
 
@@ -73,9 +73,9 @@ void assertInputsAvailable(const ArrayRef<Value*>& inputs, const char* name, uin
       "%s in opset version 6 can only broadcast"
       " between %d inputs",
       name,
-      num_inputs);
+      num_inputs)
   for (int i = 0; i < (int)num_inputs; i++) {
-    ONNX_ASSERTM(inputs[i]->has_sizes(), "Shape of input %d is not available.", num_inputs);
+    ONNX_ASSERTM(inputs[i]->has_sizes(), "Shape of input %d is not available.", num_inputs)
     assertNotParams(inputs[i]->sizes());
   }
 }

{onnx-1.18.0.dist-info → onnx-1.19.1rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx
-Version: 1.18.0
+Version: 1.19.1rc1
 Summary: Open Neural Network Exchange
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License: Apache License v2.0
@@ -13,8 +13,8 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.22
 Requires-Dist: protobuf>=4.25.1
 Requires-Dist: typing_extensions>=4.7.1
+Requires-Dist: ml_dtypes>=0.5.0
 Provides-Extra: reference
-Requires-Dist: google-re2; python_version < "3.13" and extra == "reference"
 Requires-Dist: Pillow; extra == "reference"
 Dynamic: license-file
 
@@ -76,12 +76,14 @@ The schedules of the regular meetings of the Steering Committee, the working gro
 
 Community Meetups are held at least once a year. Content from previous community meetups are at:
 
-* 2020.04.09 <https://wiki.lfaidata.foundation/display/DL/LF+AI+Day+-ONNX+Community+Virtual+Meetup+-+Silicon+Valley+-+April+9>
-* 2020.10.14 <https://wiki.lfaidata.foundation/display/DL/LF+AI+Day+-+ONNX+Community+Workshop+-+October+14>
-* 2021.03.24 <https://wiki.lfaidata.foundation/pages/viewpage.action?pageId=35160391>
-* 2021.10.21 <https://wiki.lfaidata.foundation/pages/viewpage.action?pageId=46989689>
-* 2022.06.24 <https://wiki.lfaidata.foundation/display/DL/ONNX+Community+Day+-+June+24>
-* 2023.06.28 <https://wiki.lfaidata.foundation/display/DL/ONNX+Community+Day+2023+-+June+28>
+* 2020.04.09 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14091402/LF+AI+Day+-ONNX+Community+Virtual+Meetup+-+Silicon+Valley+-+2020+April+9>
+* 2020.10.14 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14092138/LF+AI+Day+-+ONNX+Community+Workshop+-+2020+October+14>
+* 2021.03.24 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14092424/Instructions+for+Event+Hosts+-+LF+AI+Data+Day+-+ONNX+Virtual+Community+Meetup+-+March+2021>
+* 2021.10.21 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14093194/LF+AI+Data+Day+ONNX+Community+Virtual+Meetup+-+October+2021>
+* 2022.06.24 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14093969/ONNX+Community+Day+-+2022+June+24>
+* 2023.06.28 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14094507/ONNX+Community+Day+2023+-+June+28>
+
+
 
 # Discuss
 
@@ -112,7 +114,7 @@ Detailed install instructions, including Common Build Options and Common Errors
 ONNX uses [pytest](https://docs.pytest.org) as test driver. In order to run tests, you will first need to install `pytest`:
 
 ```sh
-pip install pytest nbval
+pip install pytest
 ```
 
 After installing pytest, use the following command to run tests.