Feature Highlight

Say goodbye to manual frame-by-frame labeling. Speed up video annotation workflows with SAM 2 Tracker by CVAT. *** Note: This feature is available only to CVAT Enterprise Basic and Premium accounts. We're excited to announce that CVAT now supports automated video annotation with Segment Anything Model 2 (SAM 2) Tracker. SAM 2 is the successor to Meta AI's advanced foundation model, designed for real-time, comprehensive object segmentation in images and video. SAM 2, released in July 2024, allows users to detect and segment any object in an image or video based on specific input prompts, like interactive points, bounding boxes, or masks. Once segmented, the model tracks them across video frames in real-time, ensuring accuracy and consistency. Evolution of SAM-powered annotation in CVAT When SAM's first edition was released in 2023, we integrated it into CVAT's SaaS and on-premises versions within weeks, allowing customers to enhance their image annotation tasks. When SAM 2 was released in 2024, we quickly followed suit to provide faster and more accurate segmentation. An aerial view demonstrating automated segmentation of agricultural fields and crop health conditions using SAM 2 in CVAT. We’ve extended its object segmentation and tracking capabilities to video, building on the success of these integrations. Let's examine how SAM 2 Tracker works and how it can improve your video annotation workflows. Bringing the power of SAM 2 to video annotation Labeling videos is essential for training AI models in industries relying on video data, like autonomous vehicles, sports analysis, and robotics. Those models need a large amount of accurately labeled data—from hundreds to millions of videos—to function reliably. Labeling vast data is a challenging task. Video annotation, unlike image labeling, adds a temporal dimension, increased data volume, and the need for frame consistency. Automated annotation tools like CVAT’s new SAM 2 Tracker are essential to alleviating these challenges by streamlining the process and reducing manual effort. In CVAT, there are a few methods to annotate videos: The old-school manual, frame-by-frame labeling which requires drawing annotations on every frame. And, interpolation-based labeling, where annotations are placed on keyframes and automatically propagated across intermediate frames. While those two options remain viable for simpler scenarios or limited-scope projects, SAM 2 Tracker significantly enhances the convenience and speed of object segmentation and tracking in videos, especially for complex scenes with rapid movements or frequent obstructions. https://elements.envato.com/protozoa-single-cell-organisms-in-microscope-brigh-7BQPJJP https://www.pexels.com/video/aerial-view-of-industrial-site-2073129/ Key features of CVAT’s SAM 2 Tracker Instant segmentation: The SAM 2 Tracker outlines the contours of an object in a single frame when you click on it. Automatic tracking: The tracker preserves the object's shape and position as it moves across frames. Support for complex objects: Works effectively with partial overlaps or changes in the background. Interactive refinement: Adjust annotations at any stage. How to Use SAM 2 Tracker in CVAT Follow these steps to segment and track objects in your videos with SAM 2: Open your CVAT account and select the video you want to annotate from the list of the annotation tasks. In the annotation toolbar, select the "Magic Wand." Then, use the Interactor tab to choose the label and SAM 2 to generate a segmentation mask for your object on the first (zero) frame. Important: For the Tracker to work, don't forget to turn on the "Convert the mask into a polygon" slider, because the mask cannot be further converted into a "Track" mode, and the Tracker will not be able to track an object annotated with a mask as a single element across multiple frames. In the right-hand Objects panel, click the three-dot menu (⋮) next to your polygon, then select "Run annotation action." Select "SAM 2 Tracker" from the pop-up menu and set the number of frames to track. Important: If you annotated the object with a polygon “Shape,” don’t forget to convert them into “Track” mode before running the Tracker. SAM 2 will track your polygon across subsequent frames. Note: Due to deployment requirements, SAM 2 Tracker is currently available exclusively for CVAT’s On-Prem paid accounts (Enterprise Basic and Premium). Getting started For more information about SAM 2 Tracker, visit our documentation. For SAM 2 details, visit its site and GitHub. If you have an Enterprise account and want to install SAM 2 Tracker, contact our support team. If you don’t have a CVAT On-prem account or use CVAT Online and want to try SAM 2 for video annotation, contact our sales team.

Manual data labeling can be a real slog, especially when you’re working with massive datasets. That’s why automated annotation is such a lifesaver—it speeds up the process, ensures consistency, and frees you up to focus on building smarter machine learning models. CVAT OGs know that both our platforms (SaaS and on-premises) support a number of options for automated annotation using AI models, including:‍Nuclio platformRoboflow and Hugging Face integrationCLI-based annotation on your own hardwareThese methods are used and loved by thousands of users, but because data annotation projects come in all shapes and sizes, they may not work for everyone. Nuclio functions, for example, are currently managed by the CVAT administrator and are limited to CVAT On-prem installations. Roboflow and Hugging Face support a limited range of model architectures. CLI-based annotation requires users to set up and run models only on their own machines, which can be hardware-intensive and time-consuming for some teams.‍Today, we’re excited to share that CVAT is addressing all these limitations with the launch of AI agents. ‍What is a CVAT AI agent?An AI agent in CVAT is a process (or service) that runs on your hardware or infrastructure and acts as a bridge between the CVAT platform and your AI model. Its main role is to receive auto-annotation requests from CVAT, transfer data (e.g., images) to your model for processing, retrieve the resulting annotations (e.g., object coordinates, masks, polygons), and send these results back to CVAT for automatic inclusion in your task. ‍In other words, CVAT AI agents work as a bridge between your custom model and the CVAT platform, enabling seamless integration of your model into the auto-annotation process.‍How are CVAT AI agents different from other automation methods?‍Customization and accuracy: Unlike with Roboflow, or Hugging Face integrations, you can now use your own AI models, tailored specifically to your datasets and tasks, to produce precise annotations that meet your exact training requirements.Collaboration and accessibility: Unlike CLI-based annotations, AI agents allow you to centralize your model setup and share it across your organization. Team members can access and use the models without any additional setup.‍‍Flexibility across platforms: AI agents don’t require CVAT administrator control and are available on both CVAT Online and On-prem (Enterprise, version 2.25 or later), giving you the freedom to deploy and manage your models in any environment.These features make CVAT AI agents a powerful tool for scaling your annotation processes while maintaining accuracy, collaboration, and control.‍How to annotate data with CVAT AI agentNow, let’s see how to set up automated data annotation with a custom model using a CVAT AI agent. For that, you will need:An account on a CVAT instance. In the tutorial we’ll use CVAT Online, but you can use your own CVAT On-prem instance if you wish - just substitute your instance’s URL in the commands.A CVAT task with labels from the COCO dataset (or a subset of them) and some images.You will also need to install Python and CVAT CLI to your machine.‍Refresher: CLI-based annotationLet’s first briefly review how CLI-based annotation works, since the agent-based method has a lot in common with it.‍First, you need a Python module that implements the auto-annotation function interface from the CVAT SDK. These modules will serve as bridges between CVAT and whatever deep learning framework you might use. For brevity, we will refer to such modules as native functions. ‍The CVAT SDK includes some predefined native functions (using models from torchvision), but for this article, we’ll use a custom function that uses YOLO11 from Ultralytics. ‍Here it is:‍import PIL.Image from ultralytics import YOLO import cvat_sdk.auto_annotation as cvataa _model = YOLO("yolo11n.pt") spec = cvataa.DetectionFunctionSpec( labels=[cvataa.label_spec(name, id) for id, name in _model.names.items()], ) def _yolo_to_cvat(results): for result in results: for box, label in zip(result.boxes.xyxy, result.boxes.cls): yield cvataa.rectangle(int(label.item()), [p.item() for p in box]) def detect(context, image): conf_threshold = 0.5 if context.conf_threshold is None else context.conf_threshold return list(_yolo_to_cvat(_model.predict( source=image, verbose=False, conf=conf_threshold)))‍Save it to yolo11_func.py., and then run:‍cvat-cli --server-host https://app.cvat.ai --auth "<user>:<password>" task auto-annotate <task id> --function-file yolo11_func.py --allow-unmatched-labels‍This will make the CLI download the images from your task, run the model on them and upload the resulting annotations back to the task.‍Note: long-time readers might notice a few changes since the last time we talked about CLI-based annotation on this blog. In particular, we changed the command structure of CVAT so that you have to use task auto-annotate rather than just auto-annotate. In addition, native functions can now support custom confidence thresholds, so our YOLO11 example reflects that.‍Registering the function with CVATNow, let’s see how we can integrate the same model as an agent-based function.‍An important thing to know is that the agent-based functions feature also uses native functions. In other words, if you already have a native function you’ve used with the cvat-cli task auto-annotate command, you can use the same function as an agent-based function, and vice versa. So let’s reuse the yolo11_func.py file we just created.‍First, we must let CVAT know about our function. Use the following command:‍cvat-cli --server-host https://app.cvat.ai --auth “<user>:<password>” function create-native "YOLO11" --function-file yolo11_func.py‍The string “YOLO11” here is just a name that CVAT will use for display purposes; you can use any name of your choosing.‍Now, if you open CVAT and go to the Models tab, you will see our model there, looking something like this:‍‍You can click on it and check that it has all the expected properties, such as label names. However, if you actually try to use this model for automatic annotation, it will not work. The request will stay “queued”, and after a while, it will automatically be aborted. That’s because we need to do one final step.‍Note: At no point in the process does the function itself (like the Python code or weights) get uploaded to CVAT. The only information the registration process transfers to CVAT is metadata about the function, such as the name and list of labels.‍Powering the function with an agentWe must now run an agent that will process requests for the function. Use the following command:‍cvat-cli --server-host https://app.cvat.ai --auth “<user>:<password>” function run-agent 58 --function-file yolo11_func.py‍Instead of 58, substitute the model ID you see in the CVAT UI. You can also find the same ID in the output of the function create-native command. This command starts an agent for our function, which runs indefinitely. The job of the agent is to process all incoming auto-annotation requests involving the function.‍While the agent is running, open your task in CVAT and click Actions -> Automatic annotation. You’ll be able to select the YOLO11 model and set the auto-annotation parameters, like for any other type of model CVAT supports.‍Click "Annotate." After a short delay, you should see the agent start printing messages about processing the new request. Once it’s done, CVAT should notify you that the annotation is complete. You can then examine the jobs of your task to see the new bounding boxes. The agent will keep running, ready to process more requests.‍CleanupNow that we’re done testing the function, we can remove it from CVAT. First, interrupt the agent by pressing Ctrl+C in the terminal. Second, delete the function by running the following command:‍cvat-cli --server-host https://app.cvat.ai --auth “<user>:<password>” function delete 58‍Alternatively, you can do this through the UI: find the model in the Models tab, click the ellipsis and select Delete.‍Working in an organizationIn the preceding tutorial, you added the function to your personal workspace. In this case, only you can annotate with it. Now let’s discuss what’s needed to share a function with an organization.‍First, you’ll need to add an --org parameter to all of your CLI commands:‍cvat-cli --org <your organization slug> ...‍Second, you should be aware of the permission policy when you work in an organization. A function can be…‍… added by any organization supervisor.… removed by its owner or any organization maintainer.… used to auto-annotate a task by any user that has write access to that task.These rules are the same as for Roboflow and Hugging Face functions.‍In addition, to power a function, an agent must run as that function’s owner or any organization maintainer. However, an agent must be able to access data for tasks it’s requested to process. So if you want to make it possible to use the function on any task in the organization, you should run the agent as a user with the maintainer role.‍Technical detailsThe following diagram shows the major components involved in agent-based functions. In the general case, the agent can run in a completely separate infrastructure from the CVAT server. The only requirement is that it’s able to connect to the CVAT server via the usual HTTPS port. The agent does not need to accept any incoming connections. Of course, if you run your own CVAT instance, you can run the agent in the same infrastructure, even on the same machine if you’d like.‍While so far we’ve been talking about the agent, you’re not actually limited to running one agent per function. If you’d like to be able to annotate more than one task at a time, you can run multiple agents:All annotation requests coming from the users are placed in a queue and distributed to agents on a first-come-first-serve basis. If one agent crashes or hangs while processing a request, that request will eventually be reassigned to another agent.‍What AI agents can’t do (yet)AI agents are still pretty new, so there are a few things they can’t do just yet (but don’t worry, we’re on it and will roll out updates soon): ‍Annotate just one frame,Work with skeletons,Handle videos or 3D data tasks, orSupport shapes with attributes.‍Get started with CVAT AI agentsCVAT AI agents are here to level up how teams automate data annotation. Now, you can use models trained just for your unique datasets or tasks, no matter if you’re on CVAT Online or On-Prem. This means: ‍✅ more precise annotations that are better aligned with your requirements, ✅ less manual fixing, and ✅ datasets that are ready to go for AI training or deployment. ‍And, with a centralized setup, your whole team can easily access the model, speeding up workflows and improving collaboration.‍Ready to take your automated annotation to the next level? Sign up or log in to your CVAT Online account or contact us to get CVAT with AI agents support on your server.‍

In the dynamic world of computer vision, staying current with technology advancements is not just beneficial—it's critical. This is particularly true for organizations that use self-hosted solutions for the Computer Vision Annotation Tool (CVAT.ai). ‍Regular updates to such a tool are essential for several reasons: security, improved functionality, ensuring compatibility, and maintaining operational efficiency. This article explores why regularly updating your self-hosted CVAT.ai solution is crucial for maintaining a competitive edge and operational reliability.‍This article is divided into two parts: the first addresses 'why' regular updates are necessary, and the second explains 'how' to implement these updates effectively.‍Why is it Necessary to Update CVAT.ai Regularly?‍Improved Security: One of the most compelling reasons to regularly update your self-hosted CVAT is to enhance security. Although the latest version of CVAT.ai is secure, the threat landscape constantly evolves. New vulnerabilities are discovered daily, and the CVAT.ai Team releases patches to mitigate these risks. By staying updated, you safeguard your system against vulnerabilities that malicious actors could otherwise exploit. Regular updates are crucial for maintaining the integrity of your data and ensuring the privacy of the information processed by CVAT.‍Access to Latest Features: CVAT is continuously improved by a community of developers who add new functionalities and enhancements. These updates can include everything from improved annotation algorithms, support for new formats, and enhanced user interfaces to integration capabilities with other tools and platforms. ‍Compatibility and Integration: As your IT environment evolves, new versions of dependent software and hardware are introduced. Regularly updating CVAT ensures compatibility with other software tools and infrastructure changes. For example, updates may be needed for CVAT.ai to operate smoothly with newer versions of browsers, operating systems, or integrations with third-party APIs and services. Maintaining an updated system prevents disruptions caused by compatibility issues, which can be costly and time-consuming to resolve after the fact.‍Operational Reliability: Regular updates introduce new features and improvements, including optimizations that enhance CVAT's performance and stability. These optimizations can lead to faster load times, improved response times, and more efficient data processing, enhancing the system's overall reliability. For businesses relying heavily on computer vision technologies, operational reliability is non-negotiable.‍How to Update CVAT?‍Before we delve into the procedure, it’s important to note that the steps described here apply only to standard CVAT.ai standard public images.‍If you have created a custom image that we need to be aware of, we assume you are technically proficient and can handle the necessary updates tailored to your image.‍Step 1: Back Up Your Data‍Before making any changes to your CVAT installation, it's essential to back up your data. This ensures you can restore your system to its previous state if something goes wrong during the update.For more information, see CVAT.ai Backup Guide.‍Step 2: Stop the Old Version‍You need to stop the currently running version of the application to avoid potential conflicts.Use the Docker compose command to stop the running CVAT.ai container.‍Step 3: Pull Updates from Repository‍Once the system is halted, you can safely update the software by pulling the latest changes from the CVAT GitHub repository. You must download the entire source code, not just the Docker Compose configuration file.To see if the new version was released and to check the latest changes, use CVAT.ai Changelog.You must also check and update the additional components at this stage.‍Step 4: Handle Personal Customizations‍If you have custom configurations, such as a database managed outside Docker, you must ensure these are compatible with the new version. Review your configurations and make necessary adjustments to ensure they work with the new version of CVAT. In some cases, you need to build images locally; see this Guide for details.‍Step 5: Run the New Version‍After updating the software and adjusting your customizations, you can start the new version of CVAT.Start CVAT container: Use Docker commands to run the new CVAT containers; see the Upgrade Guide for details.‍Step 6: Manual Updates Where Needed‍Sometimes, you may need to update custom external components or manually handle migration scripts.‍And that's it!You now have new updates CVAT.ai with all necessary security improvements and features!‍Looks Too Complicated?‍Updating and managing CVAT can sometimes feel complex, mainly when you're focused on annotating and training models for your work or research. If you'd prefer to leave the sysadmin and DevOps tasks to someone else, CVAT offers installation support and help managing Enterprise self-hosted solutions. Explore our enterprise proposals and plans to find the right level of support for your needs. Alternatively, consider using our online version—it's always up-to-date and secure, so you can focus solely on annotating without hassle.‍‍Not a CVAT.ai user? Click through and sign up here‍Do not want to miss updates and news? Have any questions? Join our community:‍Facebook‍DiscordLinkedInGitterGitHub‍

Data annotation is key to training machine learning models, especially in computer vision. As the CVAT.ai team, we recommend using CVAT for annotation. However, once annotation is done, you'll need to export the data in a suitable format.‍ One of the most commonly requested formats is YOLOv8. While not directly supported by CVAT, there's a straightforward workaround that allows you to convert data from the COCO format (which CVAT does support) to YOLOv8, a format that supports polygons.‍In this article, we’ll show how you can get the annotations needed from CVAT in a few simple steps and then convert them into YOLO8. For this, we’ll use another intermediate format, capable of representing the same annotations - COCO. ‍Let’s start with annotation, for this article we use a fraction of Cats and Dogs dataset with two classes: cats and dogs, we’ve selected 10 random images. ‍‍For the purpose of this article, we've annotated the dataset with polygons. You can do this manually or use automatic annotation if you're on the paid plan.‍ After annotation was done, we’ve exported the annotations in COCO format and named the resulting JSON file coco_annotations.json.‍The annotations in our JSON file look like this:‍ { "id": 9, "width": 359, "height": 269, "file_name": "dog.4121.jpg", "license": 0, "flickr_url": "", "coco_url": "", "date_captured": 0 }, { "id": 10, "width": 200, "height": 297, "file_name": "dog.4123.jpg", "license": 0, "flickr_url": "", "coco_url": "", "date_captured": 0 } ], "annotations": [ { "id": 1, "image_id": 1, "category_id": 1, "segmentation": [ [ 479.0, 63.0, 471.0, 63.0, 463.0, 69.0, 460.0, 75.0, 460.0, 86.0, 450.0, 101.0, 425.0, 110.0, 415.0, 116.0, 398.0, 120.0, 392.0, 120.0, 390.0, 118.0, 389.0, 106.0, 386.0, 101.0, 385.0, 69.0, 381.0, 63.0, 372.0, 66.0, 345.0, 86.0, 333.0, 87.0, 326.0, 90.0, 309.0, 90.0, 295.0, 86.0, 286.0, 86.0, 283.0, 89.0, 283.0, 100.0, 289.0, 111.0, 289.0, 116.0, 283.0, 123.0, 276.0, 143.0, 264.0, 159.0, 250.0, 172.0, 223.0, 213.0, 206.0, 247.0, 192.0, 286.0, 186.0, 324.0, 191.0, 335.0, 190.0, 353.0, 197.0, 362.0, 218.0, 370.0, 237.0, 374.0, 257.0, 375.0, 277.0, 380.0, 293.0, 377.0, 296.0, 369.0, 292.0, 357.0, 307.0, 342.0, 314.0, 331.0, 323.0, 308.0, 323.0, 286.0, 325.0, 284.0, 330.0, 288.0, 333.0, 307.0, 337.0, 316.0, 342.0, 321.0, 355.0, 323.0, 360.0, 318.0, 363.0, 309.0, 360.0, 277.0, 353.0, 262.0, 339.0, 250.0, 343.0, 235.0, 354.0, 222.0, 364.0, 193.0, 372.0, 183.0, 392.0, 168.0, 409.0, 163.0, 427.0, 152.0, 445.0, 135.0, 475.0, 112.0, 483.0, 87.0, 483.0, 70.0 ] ],‍To convert annotations from COCO to YOLOv8 format, we'll use the official COCO Dataset Format to YOLO Format tool provided by Ultralytics. ‍Follow these steps to achieve the result:‍Let's get your COCO annotations organized just right. The snippet below shows the folder structure: ‍coco/ └── annotations/ └── coco_annotations.json‍Next up, you're going to create a .py file with the COCO snippet inside. Call it whatever feels right to you; we went with coco_to_yolo.py. Any text editor will do the trick, but Visual Studio Code is a solid choice. Here's a peek at what your file should look like:‍from ultralytics.data.converter import convert_coco convert_coco(labels_dir='annotations', use_segments=True)‍When your file is all set, place it right next to the COCO annotations folder. Your setup should look something like this:‍coco/ └── annotations/ └── coco_annotations.json coco_to_yolo.py‍Time to create a virtual environment! Here's how:‍Open PowerShell, and head over to your project folder with running cd command:‍cd path\to\your\project\directory‍Once you're in, create a virtual environment by running the following command:‍python -m venv venv‍Get that environment going with (you might need to allow scripts in PowerShell):‍.\venv\Scripts\activate‍If the command above for some reason doesn’t work, try the following:‍.\venv\Scripts\activate.ps1‍You'll know it's ready when you see (venv) before your command prompt.‍Now, let's install Ultralytics. Just type in:‍pip install ultralytics‍And wait; this part might take a little bit.All set? Great! Now, just run:‍python coco_to_yolo.py‍And there you have it—done! Your converted annotations are now neatly organized in the coco_converted folder, located alongside the other files. Please note that the coco_annotations part might have a different name in your case if you named the exported .json file differently.‍coco/ └── annotations/ └── coco_annotations.json coco_to_yolo.py coco_converted/ ├── images/ └── labels/ └── coco_annotations/ └── image1.txt └── image2.txt‍Inside this folder, you'll find a list of .txt files that have the same names as the images in the dataset.‍‍Each .txt file contains annotations in YOLO8 format.‍‍Now that your data is in the YOLOv8 format, you're ready to use it in your models. This opens up exciting new possibilities and improves your machine learning projects. Keep an eye out for our next articles. We'll go deeper into how to use these converted annotations in your models effectively.This is just the start of a journey toward more efficient, powerful, and flexible machine learning models.‍And that’s it for today. Let us know what you think? ‍Happy annotating!Not a CVAT.ai user? Click through and sign up here‍Do not want to miss updates and news? Have any questions? Join our community:‍Facebook‍DiscordLinkedInGitterGitHub

In the realm of computer vision, handling large-scale datasets can be a challenging task. That's where CVAT.ai steps in, offering a streamlined approach for simultaneous annotation and task distribution among several annotators. Our latest video provides hands-on guidance for teams and organizations eager to accelerate their annotation process with CVAT. ‍‍Consider the scenario of leading an organization swamped with a vast array of images and videos needing annotation. The efficiency of your project hinges on effectively sharing these tasks among your team members. It all starts with creating a project in CVAT and carefully adding the necessary labels, but then what? The real question is, how do you ensure that the workload is evenly split and managed efficiently?‍CVAT.ai offers a solution by allowing you to segment your image dataset into distinct parts, with each segment assigned as a separate job. This method enables team members to work on different segments at the same time, thereby greatly enhancing the speed of the annotation process.‍Our guide dives into the nitty-gritty of optimizing your workflow in CVAT.ai, highlighting the best practices for dividing annotation tasks in a collaborative setting. This approach not only fosters efficient team collaboration but also ensures quick turnaround times for your computer vision projects.‍To gain more insights into efficient data annotation and task distribution in CVAT, make sure to watch our video. And if you find it helpful, don't hesitate to like, subscribe, and share. Stay tuned for more tips and techniques to streamline your image annotation processes in the field of computer vision.‍‍Happy annotating!‍Not a CVAT.ai user? Click through and sign up here‍Do not want to miss updates and news? Have any questions? Join our community:‍Facebook‍DiscordLinkedInGitterGitHub

Computer Vision Annotation Tool (CVAT) has been a game-changer for many businesses and researchers in the field of computer vision. Its intuitive interface and powerful features have made it a go-to solution for annotating images and videos. While the self-hosted version of CVAT has its merits, there's a compelling case to be made for transitioning to CVAT.ai Cloud with its paid plans.‍Here's why:‍Scalability and Performance‍One of the most significant advantages of CVAT.ai Cloud is its scalability. With the self-hosted solution, you're limited by your own infrastructure. As your projects grow, you will find yourself investing more in hardware and maintenance that, in the end, will result in bigger expenses. With CVAT.ai Cloud, you can easily scale up or down based on your needs, ensuring optimal performance without the hassle of managing the infrastructure yourself.‍Reliability and Uptime‍CVAT.ai Cloud is designed with a robust infrastructure, aiming to provide consistent availability for your needs. This means you can rely on the platform to be available whenever you need it. With a self-hosted solution, you're responsible for ensuring uptime, which can be challenging especially if you don't have a dedicated IT team.‍Enhanced Security‍Data security is paramount for us, especially when dealing with sensitive information. CVAT.ai Cloud is encrypted end-to-end. We perform automated as well as manual security audits, and are compliant with data protection laws. This ensures that your data is protected from potential threats and leaks.‍Automatic Updates and New Features ‍With CVAT.ai Cloud, you'll always have access to the latest features and updates without having to worry about manual upgrades or potential compatibility issues. This not only saves time but ensures that you're always using the most advanced and efficient version of the platform.‍Dedicated Support‍Paid plans on CVAT.ai Cloud come with dedicated customer support. This means that if you ever run into issues or have questions, you can quickly get the help you need. With a self-hosted solution, you're largely on your own unless you have an in-house expert (exception: if you’re a CVAT.ai Enterprise customer you get even more care from our support organization). ‍Collaboration and Accessibility‍CVAT.ai Cloud is accessible from anywhere there is an internet connection, making collaboration easier. Team members can work on projects from different locations, ensuring continuity and efficiency. With a self-hosted solution, remote access might require additional setup and could pose security risks.‍Paid features exclusive to CVAT.ai Cloud‍CVAT.ai Cloud stands out with its exclusive paid features, ensuring a seamless and enhanced user experience. ‍One of the standout offerings is Single Sign-On (SSO), which simplifies user management by allowing users to access multiple applications with a single set of credentials. This not only enhances security but also streamlines the user experience. ‍Furthermore, CVAT.ai Cloud's integration with platforms like Roboflow and Hugging Face elevates its capabilities. Users can effortlessly tap into the power of state-of-the-art machine learning models from Roboflow and Hugging Face for preprocessing and augmenting datasets. ‍In essence, choosing CVAT.ai Cloud over self-hosted solutions means opting for convenience, advanced features, and a future-proof annotation environment.Conclusion‍While the self-hosted version of CVAT has served many users well, the benefits of switching to CVAT.ai Cloud with paid plans are undeniable. From scalability and performance to enhanced security and support, CVAT.ai Cloud offers a comprehensive solution that can cater to the evolving needs of businesses and researchers in the field of computer vision.‍If you're looking for a hassle-free, efficient, and secure annotation tool, it might be time to make the switch to CVAT.ai.‍‍Remember to like, share, and subscribe for more updates!Happy Annotating!‍‍Not a CVAT.ai user? Click through and sign up here‍Do not want to miss updates and news? Have any questions? Join our community:‍Facebook‍DiscordLinkedInGitterGitHub‍‍

Image Annotation and Video Annotation play a vital role in various fields; from computer vision to machine learning. These annotations enable us to understand and interpret visual content. But what if we could add even more meaning to these Annotations? That's where CVAT.ai Label Attributes come into play! In this article, we'll explore how CVAT.ai Label Attributes add an additional semantic layer, enhancing the data via a more specific set of annotations that will improve context and insights.‍What is CVAT.ai?‍CVAT.ai is a powerful computer vision annotation tool used to mark objects and define their boundaries in images and videos. It simplifies the process of creating annotated datasets, making it easier for machines to understand visual data.‍CVAT.ai Attributes‍Imagine taking the already efficient CVAT annotation process to a whole new level with CVAT.ai Label Attribute. These Attributes are like descriptive tags or labels that provide additional information about each annotated object. They act as tiny pieces of context, guiding both humans and machines towards better comprehension.‍Using CVAT.ai Label Attributes is as simple as it gets. For each annotated object, you can assign relevant Attributes to add more meaning to the Annotation. For instance, if you are annotating Traffic Signs, you can tag the primary Label, Traffic Signs, with attributes like "Stop Sign," "Yield Sign," or even "Damaged Sign" to provide precise details.‍Why CVAT.ai Attributes Matter‍1. Enhanced Context: Imagine annotating a dataset with just bounding boxes around cars that have a simple, single Label. With CVAT.ai Label Attributes, you can add labels like "SUV," "Sedan," or "Convertible." This additional context empowers ML algorithms to better recognize different car types, leading to more accurate model results.‍2. Improved Analysis: When dealing with complex data, such as medical images, CVAT.ai Label Attributes enable annotators to include critical details like "Benign Tumor," "Malignant Tumor," or "Inflammation." This extra layer of information allows researchers medical-centric ML algorithms to perform more insightful analysis and make better-informed decisions.‍3. Enriched Machine Learning: ML models thrive on data diversity. With CVAT.ai label attributes, you can feed the model with richer data that goes beyond simple annotations. This exposure to varied Attributes helps to train the model to be more adaptive and versatile.‍And many more!Want to know more about how to use them? Watch the video! ‍‍And share your feedback!‍Happy annotating!Do not want to miss updates and news? Have any questions? Join our community:‍Facebook‍DiscordLinkedInGitterGitHub‍‍

Are you tired of the hassle involved in providing instructions to your annotation team? CVAT has introduced an exciting new feature that streamlines the annotation process by simplifying how you share instructions with your annotators.‍In today's article, we'll explore this feature and how it can enhance your annotation workflow.‍‍Introducing the built-in data annotation instructions‍The feature eliminates the need for separate tools or external resources when providing data annotation specification. Previously, you had to create specifications using tools like Google Docs and then link or send them separately via CVAT or email. ‍However, CVAT has made it easier by integrating markdown instructions for your data annotation team directly into the CVAT interface. Available in one click.‍‍Creating and modifying data annotation instructions‍CVAT now has an built-in Markdown editor where you can easily create and modify a document with annotation instructions for your team. The editor provides a live preview of the formatted text, allowing you to see the results as you type. You can use the top toolbar for formatting options or write directly in raw Markdown. For more information, see Markdown Cheat Sheet.‍‍Adding Text, Visuals, and Code‍The new feature supports various media types, including text, images and links. You can add images by providing the URL or by drag-and-drop or pasting directly into the editor. Additionally, you can include links to external resources. If code examples are needed, you can seamlessly incorporate them into the instructions using Markdown's code formatting.‍Enhanced Collaboration and Accessibility‍With the feature, collaboration becomes more efficient, as data annotation instructions can be shared through CVAT and tasks.‍But who can edit the created annotation instructions? ‍If you are an individual user, and the instructions are linked to a project, only the project owner and assignee will have the authority to modify the markdown document. ‍If the instructions are linked to the task, then the owner of the tasks and assignee can modify it as needed.‍For organizations, editing rights will have owner, assignee and maintainer for both projects and tasks. ‍In all cases, annotators assigned to the job can view the data annotation instructions but cannot make changes. ‍Instant Access and Improved Workflow‍The data annotation instructions can be easily accessed. ‍By clicking on the guide icon in the top right corner of the screen, annotators can quickly access all the necessary information without navigating through multiple tabs or external resources. ‍This streamlines the workflow and ensures a smoother annotation process.‍Watch the Video for a Visual Overview‍Watch the video for a visual demonstration of the feature and discover how it can improve your data annotation experiece and collaboration.‍‍Thank you for choosing CVAT!‍Stay tuned and follow the news here:‍Facebook‍DiscordLinkedInGitterGitHub‍‍

Have you ever sat back and wondered: “how productive my annotation team is?” or "How much time does an annotator take to complete a task?" Well, you're not alone in this, and we've got the perfect solution for you - CVAT Analytics!‍Picture this: you've got a magic telescope that lets you peek into the realm of your team's productivity, task completion rates, and even helps you spot the bottlenecks. Sounds awesome, right? This isn't magic, but it's the next best thing - it's the range of dashboards available in CVAT Analytics (powered by Grafana). We've made an easy-to-understand video just for you, which you can check out at the end of this post.‍CVAT Analytics is like your personal productivity wizard, and it comes with three magical lenses (dashboards): All Events, Management, and Monitoring. Let's dive into what each of them does.‍The "All Events" Lens‍The "All Events" lens, or dashboard, is like a bird's-eye view of your team's work landscape. It lets you see all events, when they happened, and who triggered them. You can think of it like your detective tool, keeping an eye on everything that's going on.‍There's a neat activity graph at the top and some handy filters that act like magnifying glasses, letting you zoom in on specific users, tasks, or projects. It's perfect for understanding your team's overall performance and making decisions that'll help everyone be more productive. Isn't that cool?‍The "Management" Lens‍Next up, we've got the "Management" lens. This one is like your team captain, helping you oversee your team's work in a simple and powerful way. There's another activity graph here, and you can click on a team member's ID to see what they've been up to.‍The best part? There's a handy table at the bottom that tells you who's been working on what and how long it took them. This lens helps you manage your projects efficiently, understand how your team works, and make decisions that'll lead to even better results.‍The "Monitoring" Lens‍Last but not least, there's the "Monitoring" lens. This one is like a health check-up for your projects. It gives you a snapshot of what everyone's up to, how active they are, and even shows you if any errors popped up.‍There's a graph for overall activity, one for the duration of events, and an "Exceptions" graph that's like your team's error weather forecast. Each error is described in detail, which is super useful for understanding what went wrong and how to fix it.‍This lens is great for keeping track of your annotators' work hours, getting weekly statistics for each annotator, and managing productivity across all tasks.‍All in all, these magical lenses of CVAT Analytics are your best friends for monitoring tasks, evaluating your team's productivity, spotting errors, and simplifying project management. ‍They're packed full of valuable insights that can help you make smarter decisions and solve problems quicker.‍And remember, we've only just scratched the surface here. The possibilities with CVAT Analytics are endless!Ready to see this in action? Here is the video:‍‍For more information, see CVAT Analytics and Monitoring.Happy annotating!Stay tuned and follow the news here:‍Facebook‍DiscordLinkedInGitterGitHub‍‍

Today we're going to talk about something really cool and useful. It's called "webhooks". We will show where to find them in CVAT, how to configure them, and the final result of their work.‍‍But before we dive into technical stuff, let’s explain the basics in simple words.For example, imagine a situation: you're waiting for a friend to come over and play. You could sit by the window and keep looking outside until your friend shows up, right? But wouldn't it be easier if your friend just rang the doorbell when he or she arrived? That way, you could do other fun stuff instead of just waiting.That's pretty much how webhooks work. They're like the doorbell of the internet.‍Now, we're going to talk about a specific tool called CVAT (which stands for Computer Vision Annotation Tool). This tool is used for image annotation and video annotation for further processing of the data in the ML models.‍When you're using CVAT, you might be working solo or with a team. In the second case, the team might be working on a lot of different things at the same time. For example, they might teach the computer to recognize different types of dogs or to understand what's happening in a video. ‍While they are doing all of this, wouldn't it be nice to know when a specific task is done, or when something changes, without having to keep checking all the time? That's where webhooks come in.‍CVAT webhooks are like little messengers. You don't have to keep checking on your annotators by yourself anymore. Instead, these webhooks will let you know when something new happens in CVAT. So, if a task gets started or finished, or if there's a problem or a change, you'll get a message straight away. It's a simple and fluent way to stay updated!‍But how does this work? When you're setting up a CVAT webhook, you're basically giving it a special online address (a URL) where it can send its updates. You set the other details, hit the Submit button, and you're good to go! ‍Now, whenever something changes in CVAT, your webhook gets to work. It sends a message to the address you provided, telling you all about the event, like what happened and all the specific details.‍Curious about how it all works in action? Take a look at this short video that walks you through the whole process:‍‍And that's the basics of CVAT webhooks! They might seem a little complicated at first, but once you understand how they work, they're actually pretty simple and really useful.‍So remember, next time you're using CVAT and you want to know how things are going with the tasks, just set up a webhook. It's like setting up a doorbell so you know when your friend has come over. Happy annotating!‍Stay tuned and follow the news here:‍Facebook‍DiscordLinkedInGitterGitHub‍‍

Our previous article was an overview of what you can expect from our Enterprise plan. In this article, we'll explain how to request premium features and become a Corporate client. We will dive deeper into benefits and present future gains.Let’s start with a simple use case: a medical research company uses annotated data for studies. As the company grows, the amount of data to be labeled increases accordingly, making manual annotation time-consuming and error-prone. So they start using CVAT's self-hosted platform, as it can be customized to meet internal requirements and has integrated models for automatic labeling.The company starts with a free version but finds some important features missing, so they submit feature requests to CVAT's GitHub and wait for them to be added to the platform.‍However, there is no guarantee that the requested features will be implemented or when they will be delivered.‍Because once you submit the feature request, you must wait in hope that it will be selected for development, keeping in mind that there are some drawbacks to this approach:‍The feature might not be selected for development.The feature might not be implemented as requested.There's no guarantee for how long development will take.‍This is where requesting a Feature Boost can help. You can directly contact the CVAT developer team because, at CVAT.ai, we are eager to listen to your needs and prioritize your requests ahead of our roadmap.‍Now to start working with CVAT.ai there is a list of requirements you need to fit:‍Price: The agreement we make with you comes with a price of $50,000 and up per contract. The contract can include one or several big features or many small ones. Availability: As CVAT is an open-source platform, most of the features we develop are added to the public repository. We can include exclusive features in the contract as an exception, but they should not be core features and must be discussed and agreed upon first.Deployment: We will help you to deploy your features, but the CVAT team will not rework your company’s infrastructure or adjust internal services.‍If you fit all three points above, then the process will look like this:Step 1: You contact CVAT.ai through one of our communication channels. We advise LinkedIn or Sales.‍Step 2: We sign an NDA first. Then the CVAT team will listen to your request, discuss all the details, and ask for additional materials from your side if needed. ‍Step 3: CVAT.ai will process the request internally, breaking it down into stages and estimating the costs. Some additional information from you might be needed at this stage, so we will stay in touch with you. ‍Step 4: Once costs and stages are estimated internally, CVAT.ai will make a proposal, and start a discussion with you regarding the pricing options, project stages, and timelines for implementing the project. If everything aligns with your needs, we will proceed to sign the contract.‍Note: This step may also include procurement procedures and other additional activities on both sides.‍Step 5: Development starts as agreed in the contract. What will you get?The ready project will come in two parts:‍MVP: the first prototype that we will show to you, so adjustments can be done if needed. Also at this stage, you can stop the development. You will pay only 20% of the agreed price in this case.All the rest: after MVP is approved, we go on with the rest of the development and release the feature.‍After the feature is deployed we will help with the integration of this feature into your workflow.‍We will provide support for a month to make sure the feature works as you desire and you feel comfortable using it. If there are any bugs, they will be fixed with no additional payment. ‍The feature will be updated on time if it is not exclusive and went into the CVAT open-source repository. ‍If you are curious about real-life examples, here is a list of the features that we created with Feature Boost plans:‍‍Annotation with skeletons.‍ Analytics and monitoring, also known as audit logs.‍‍‍ Webhooks for Projects and Organizations that are used to handle application notifications about changes in a specific project or organization.‍‍Any questions left? Feel free to contact us!DiscordLinkedInGitterGitHub‍‍

We are excited to introduce the 6th video in the Computer Video Annotation Course, which will guide you through using the CVAT SDK.‍In the video we demonstrate the CVAT SDK that is a Python library that provides functionality to simplify the integration of CVAT API into your application. The SDK is open-source, platform-independent, and easy to install with “pip”. ‍The library functionality can be divided into three parts: ‍low-level API;high-level API;and various utilities and helpers.‍The low-level API provides server API wrappers, while the high-level API allows you to interact with the server objects using object-oriented API. ‍The Client class ties together the functionality of the high-level API and provides simple access to the server entities such as tasks and projects. The library also includes data validation, response parsing, error handling, and inline documentation for each layer. With the CVAT SDK, you can save time on writing integration code and focus more on your tasks.‍We are waiting for your feedback here:DiscordLinkedInGitterGitHub‍You can find more information on our YouTube channel‍