Dataset Viewer
instruction
stringclasses 1
value | output
stringclasses 13
values | image
imagewidth (px) 48
1.64k
|
|---|---|---|
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 2} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 1, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 3} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 3} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} | |
Examine the total number of persons wearing a helmet and those without a helmet. The output should be formatted as a JSON instance that conforms to the schema below.
For example, given the schema:
```json
{"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
```
A well-formatted instance would be:
```json
{"foo": ["bar", "baz"]}
```
while the object:
```json
{"properties": {"foo": ["bar", "baz"]}}
```
is not well-formatted.
Here is the required output schema:
```json
{"properties": {"person-with-helmet": {"title": "Person with Helmet", "description": "Total count of persons wearing a helmet", "type": "integer"}, "person-without-helmet": {"title": "Person without Helmet", "description": "Total count of persons not wearing a helmet", "type": "integer"}}, "required": ["person-with-helmet", "person-without-helmet"]}
```
Here is the fromat output based on that schema
```json
{"person-with-helmet": [Number of detected person wearing helmet], "person-without-helmet": [Number of detected person not wearing helmet]}
``` | {"person-with-helmet": 0, "person-without-helmet": 1} |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 33