onnx 1.13.1__cp311-cp311-macosx_10_12_universal2.whl → 1.14.1__cp311-cp311-macosx_10_12_universal2.whl

onnx/defs/tensor/utils.cc

@@ -3,6 +3,7 @@
  */
 
 #include "onnx/defs/tensor/utils.h"
+#include <numeric>
 
 namespace ONNX_NAMESPACE {
 void resizeShapeInferenceHelper(
@@ -164,6 +165,9 @@ void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
   std::vector<int64_t> axes;
   if (axes_attr) {
     axes = RetrieveValues<int64_t>(*axes_attr);
+    checkAxesRange(axes, rank_x);
+    adjustNegativeAxes(axes, rank_x);
+    checkDuplicateAxes(axes, rank_x);
   }
   if (hasSizesInput) {
     if (!axes.empty()) {
@@ -175,14 +179,6 @@ void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
             axes.size(),
             ").");
       }
-
-      std::vector<bool> tmp(rank_x, false);
-      for (auto axis : axes) {
-        if (tmp[axis]) {
-          fail_shape_inference("Repeated axis: ", axis);
-        }
-        tmp[axis] = true;
-      }
     } else {
       // sizes_data contains scales for all axes
       if (sizes_data.size() != rank_x) {
@@ -247,6 +243,10 @@ void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
   } // nullptr != scales
 }
 
+void resizeShapeInference_opset18_to_19(InferenceContext& ctx) {
+  resizeShapeInferenceVersioned(ctx, 19);
+}
+
 void resizeShapeInference_opset13_to_18(InferenceContext& ctx) {
   resizeShapeInferenceVersioned(ctx, 13);
 }
@@ -322,4 +322,126 @@ void resizeShapeInference_opset7_to_10(InferenceContext& ctx) {
   }
 }
 
+std::function<void(OpSchema&)> PadDocGenerator(const char* description, const char* mode_description) {
+  return [=](OpSchema& schema) {
+    schema.SetDoc(description);
+    schema.Attr("mode", mode_description, AttributeProto::STRING, std::string("constant"));
+    schema.Input(0, "data", "Input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "pads",
+        "Tensor of integers indicating the number of padding elements to add or remove (if negative) "
+        "at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. "
+        "`pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number "
+        "of elements in the `axes` input or the input rank if `axes` are not provided explicitly. "
+        "`pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], "
+        "where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and "
+        "xi_end, the number of pad values added at the end of axis `axes[i]`.",
+        "tensor(int64)",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        2,
+        "constant_value",
+        "(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, "
+        "empty string or False).",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        3,
+        "axes",
+        "1-D tensor of axes that `pads` apply to. Negative value means counting dimensions "
+        "from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an "
+        "axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).",
+        "Tind",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+
+    schema.Output(0, "output", "Tensor after padding.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.");
+    schema.TypeConstraint("Tind", {"tensor(int32)", "tensor(int64)"}, "Constrain indices to integer types");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // Type inference
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      // Shape inference needs the input data shape
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      const auto input_rank = input_shape.dim_size();
+
+      std::vector<int64_t> axes;
+      if (hasInputShape(ctx, 3)) { //'axes' input
+        auto axes_initializer = ctx.getInputData(3);
+        if (axes_initializer == nullptr)
+          return; // can't do shape inference then
+
+        axes = ParseData<int64_t>(axes_initializer);
+        checkAxesRange(axes, input_rank);
+        adjustNegativeAxes(axes, input_rank);
+        checkDuplicateAxes(axes, input_rank);
+      } else {
+        axes.resize(input_rank);
+        std::iota(axes.begin(), axes.end(), 0);
+      }
+
+      int num_axes = axes.size();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+      // Populating default dims
+      std::vector<TensorShapeProto_Dimension*> out_dims(input_rank);
+      for (int i = 0; i < input_rank; ++i) {
+        out_dims[i] = output_shape->add_dim();
+      }
+
+      // Shape Inference if
+      //     1. 'pads' are available.
+      // and 2. 'axes' are available, or default.
+      const TensorProto* pads_initializer = ctx.getInputData(1);
+      if (nullptr != pads_initializer && !axes.empty()) {
+        if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
+          fail_shape_inference("'pads' input must be a 1D (shape: [2 * num_axes]) tensor of type int64");
+        }
+
+        const auto& pads_data = ParseData<int64_t>(pads_initializer);
+        if (pads_data.size() != static_cast<size_t>(2 * num_axes)) {
+          fail_shape_inference(
+              "Pads has incorrect number of values. Expected 2 * ",
+              num_axes,
+              " values. Got ",
+              pads_data.size(),
+              " values.");
+        }
+
+        // Set default dim values
+        for (int i = 0; i < input_rank; ++i) {
+          const auto& input_dim = input_shape.dim(i);
+          if (input_dim.has_dim_value()) {
+            out_dims[i]->set_dim_value(input_dim.dim_value());
+          }
+        }
+
+        for (int i = 0; i < num_axes; ++i) {
+          auto axis = axes[i];
+          const auto& input_dim = input_shape.dim(axis);
+          auto& out_dim = *out_dims[axis];
+          auto total_pad = pads_data[i] + pads_data[num_axes + i];
+          if (input_dim.has_dim_value()) {
+            out_dim.set_dim_value(input_dim.dim_value() + total_pad);
+          } else if (total_pad == 0) {
+            out_dim = input_dim;
+          }
+        }
+      }
+    });
+  };
+};
 } // namespace ONNX_NAMESPACE

onnx/defs/tensor/utils.h

@@ -27,6 +27,7 @@ void resizeShapeInferenceHelper(
 void resizeShapeInference_opset7_to_10(InferenceContext& ctx);
 void resizeShapeInference_opset11_to_12(InferenceContext& ctx);
 void resizeShapeInference_opset13_to_18(InferenceContext& ctx);
+void resizeShapeInference_opset18_to_19(InferenceContext& ctx);
 
 void resizeShapeInferenceHelper_opset7_to_10(
     const TensorShapeProto& input_shape,
@@ -47,4 +48,5 @@ void KeepAspectRatioHelper(
 
 extern const char* NonZero_ver9_doc;
 
+std::function<void(OpSchema&)> PadDocGenerator(const char* description, const char* mode_description);
 } // namespace ONNX_NAMESPACE

onnx/defs/tensor_proto_util.cc

@@ -79,6 +79,9 @@ namespace ONNX_NAMESPACE {
     /* The given tensor does have raw_data itself so parse it by given type */                                     \
     /* make copy as we may have to reverse bytes */                                                                \
     std::string raw_data = tensor_proto->raw_data();                                                               \
+    if (raw_data.empty()) {                                                                                        \
+      return res;                                                                                                  \
+    }                                                                                                              \
     /* okay to remove const qualifier as we have already made a copy */                                            \
     char* bytes = const_cast<char*>(raw_data.c_str());                                                             \
     /* onnx is little endian serialized always-tweak byte order if needed */                                       \

onnx/defs/traditionalml/defs.cc

@@ -85,7 +85,8 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             "T",
             {"tensor(float)", "tensor(double)", "tensor(int64)", "tensor(int32)"},
             "The input must be a tensor of a numeric type. The output will be of the same tensor type.")
-        .Attr("threshold", "Values greater than this are mapped to 1, others to 0.", AttributeProto::FLOAT, 0.f));
+        .Attr("threshold", "Values greater than this are mapped to 1, others to 0.", AttributeProto::FLOAT, 0.f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
 
 static const char* CastMap_ver1_doc = R"DOC(
     Converts a map to a tensor.<br>The map key must be an int64 and the values will be ordered
@@ -603,7 +604,23 @@ ONNX_ML_OPERATOR_SET_SCHEMA(
             "zeros",
             "If true and category is not present, will return all zeros; if false and a category if not found, the operator will fail.",
             AttributeProto::INT,
-            static_cast<int64_t>(1)));
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<int64_t> cats_int64s;
+          bool has_int64s = getRepeatedAttribute(ctx, "cats_int64s", cats_int64s);
+          std::vector<std::string> cats_strings;
+          bool has_strings = getRepeatedAttribute(ctx, "cats_strings", cats_strings);
+          if (has_int64s == has_strings) {
+            fail_shape_inference("Exactly one of 'cats_*' attributes must be provided.");
+          }
+          const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          TensorShapeProto* shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          for (int i = 0; i < input_shape.dim_size(); i++) {
+            *shape->add_dim() = input_shape.dim(i);
+          }
+          shape->add_dim()->set_dim_value(std::max(cats_int64s.size(), cats_strings.size()));
+          updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+        }));
 
 static const char* Scaler_ver1_doc = R"DOC(
     Rescale input data, for example to standardize features by removing the mean and scaling to unit variance.

onnx/examples/Protobufs.ipynb

@@ -2,9 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {
-    "collapsed": true
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:50.826940Z",
+     "iopub.status.busy": "2023-04-04T17:07:50.826940Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.182950Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.182950Z"
+    }
    },
    "outputs": [],
    "source": [
@@ -13,8 +18,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
+   "execution_count": 2,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.186951Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.186951Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.309954Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.308951Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -31,6 +43,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# Int Attibute\n",
     "arg = helper.make_attribute(\"this_is_an_int\", 1701)\n",
     "print(\"\\nInt attribute:\\n\")\n",
@@ -39,8 +54,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.334952Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.334952Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.450951Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.449950Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -50,14 +72,16 @@
       "Float attribute:\n",
       "\n",
       "name: \"this_is_a_float\"\n",
-      "f: 3.1400001049\n",
-      "type: 1\n",
+      "f: 3.140000104904175\n",
+      "type: FLOAT\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "# NBVAL_IGNORE_OUTPUT\n",
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# Float Attribute\n",
     "arg = helper.make_attribute(\"this_is_a_float\", 3.14)\n",
     "print(\"\\nFloat attribute:\\n\")\n",
@@ -66,8 +90,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
+   "execution_count": 4,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.453950Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.453950Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.555948Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.555948Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -84,6 +115,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# String Attribute\n",
     "arg = helper.make_attribute(\"this_is_a_string\", \"string_content\")\n",
     "print(\"\\nString attribute:\\n\")\n",
@@ -92,8 +126,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.558950Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.558950Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.662949Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.662949Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -113,6 +154,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# Repeated Attribute\n",
     "arg = helper.make_attribute(\"this_is_a_repeated_int\", [1, 2, 3, 4])\n",
     "print(\"\\nRepeated int attribute:\\n\")\n",
@@ -121,8 +165,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
+   "execution_count": 6,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.665950Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.665950Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.774949Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.774949Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -139,6 +190,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# node\n",
     "node_proto = helper.make_node(\"Relu\", [\"X\"], [\"Y\"])\n",
     "\n",
@@ -148,8 +202,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
+   "execution_count": 7,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.778952Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.777951Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.883948Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.883948Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -187,8 +248,13 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# node with args\n",
-    "node_proto = helper.make_node(\"Conv\", [\"X\", \"W\", \"B\"], [\"Y\"], kernel=3, stride=1, pad=1)\n",
+    "node_proto = helper.make_node(\n",
+    "    \"Conv\", [\"X\", \"W\", \"B\"], [\"Y\"],\n",
+    "    kernel=3, stride=1, pad=1)\n",
     "\n",
     "# This is just for making the attributes to be printed in order\n",
     "node_proto.attribute.sort(key=lambda attr: attr.name)\n",
@@ -201,8 +267,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.886948Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.886948Z",
+     "iopub.status.idle": "2023-04-04T17:07:51.992949Z",
+     "shell.execute_reply": "2023-04-04T17:07:51.992949Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -329,6 +402,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# graph\n",
     "graph_proto = helper.make_graph(\n",
     "    [\n",
@@ -338,7 +414,7 @@
     "    ],\n",
     "    \"MLP\",\n",
     "    [\n",
-    "        helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [1]),\n",
+    "        helper.make_tensor_value_info(\"X\" , TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"W1\", TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"B1\", TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"W2\", TensorProto.FLOAT, [1]),\n",
@@ -346,7 +422,7 @@
     "    ],\n",
     "    [\n",
     "        helper.make_tensor_value_info(\"Y\", TensorProto.FLOAT, [1]),\n",
-    "    ],\n",
+    "    ]\n",
     ")\n",
     "\n",
     "print(\"\\ngraph proto:\\n\")\n",
@@ -358,8 +434,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
+   "execution_count": 9,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-04-04T17:07:51.995950Z",
+     "iopub.status.busy": "2023-04-04T17:07:51.995950Z",
+     "iopub.status.idle": "2023-04-04T17:07:52.102950Z",
+     "shell.execute_reply": "2023-04-04T17:07:52.102950Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -484,6 +567,9 @@
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "# An node that is also a graph\n",
     "graph_proto = helper.make_graph(\n",
     "    [\n",
@@ -493,7 +579,7 @@
     "    ],\n",
     "    \"MLP\",\n",
     "    [\n",
-    "        helper.make_tensor_value_info(\"X\", TensorProto.FLOAT, [1]),\n",
+    "        helper.make_tensor_value_info(\"X\" , TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"W1\", TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"B1\", TensorProto.FLOAT, [1]),\n",
     "        helper.make_tensor_value_info(\"W2\", TensorProto.FLOAT, [1]),\n",
@@ -501,7 +587,7 @@
     "    ],\n",
     "    [\n",
     "        helper.make_tensor_value_info(\"Y\", TensorProto.FLOAT, [1]),\n",
-    "    ],\n",
+    "    ]\n",
     ")\n",
     "\n",
     "# output = ThisSpecificgraph([input, w1, b1, w2, b2])\n",
@@ -515,25 +601,37 @@
     "print(\"\\nNodeProto that contains a graph:\\n\")\n",
     "print(node_proto)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.11"
+   "pygments_lexer": "ipython3",
+   "version": "3.9.11"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f9fa6017a53cd3e89c2ae5d3938d7461048c25b2aa8e520267fca421440325a1"
+   }
   }
  },
  "nbformat": 4,

onnx/examples/check_model.ipynb

@@ -3,7 +3,14 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2023-03-06T20:16:44.956148Z",
+     "iopub.status.busy": "2023-03-06T20:16:44.956148Z",
+     "iopub.status.idle": "2023-03-06T20:16:45.015963Z",
+     "shell.execute_reply": "2023-03-06T20:16:45.015963Z"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -56,11 +63,15 @@
       "opset_import {\n",
       "  version: 6\n",
       "}\n",
-      "\n"
+      "\n",
+      "The model is valid!\n"
      ]
     }
    ],
    "source": [
+    "# NBVAL_SKIP\n",
+    "# Protobuf 4 and Protobuf 3 might output different order of protobuf fields\n",
+    "\n",
     "import onnx\n",
     "import os\n",
     "\n",
@@ -69,23 +80,8 @@
     "model_path = os.path.join(\"resources\", \"single_relu.onnx\")\n",
     "onnx_model = onnx.load(model_path)\n",
     "\n",
-    "print(\"The model is:\\n{}\".format(onnx_model))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The model is valid!\n"
-     ]
-    }
-   ],
-   "source": [
+    "print(\"The model is:\\n{}\".format(onnx_model))\n",
+    "\n",
     "# Check the model\n",
     "try:\n",
     "    onnx.checker.check_model(onnx_model)\n",
@@ -94,11 +90,18 @@
     "else:\n",
     "    print(\"The model is valid!\")"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -112,7 +115,12 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.2"
+   "version": "3.9.11"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f9fa6017a53cd3e89c2ae5d3938d7461048c25b2aa8e520267fca421440325a1"
+   }
   }
  },
  "nbformat": 4,