Crazy Studio: dataset editor for images, text, audio, and video

I work in the field of artificial intelligence development and constantly face tasks where it's not enough to simply take a ready-made model and run it on my data. The model might perform well on standard tests but start making mistakes as soon as the conditions differ slightly from those it was trained on.

In such cases, the model needs to be fine-tuned. And for fine-tuning, you need your own data: images, texts, audio recordings, or videos with annotations that match the specific task.

Recently, I needed to experiment with models capable of detecting objects in the sky and identifying their types. For example, distinguishing between an airplane, helicopter, drone, bird, or another small object. I needed my own datasets for testing, collected from materials from specific cameras and annotated according to my own rules.

I looked at existing solutions, but for small experiments, many of them turned out to be too overloaded. In some cases, you have to spend a long time setting up a project, in others, the interface is designed for large teams, and in some, half of the features are simply unnecessary for me.

So I created Crazy Studio — my browser-based dataset editor. It allows you to quickly create a project, upload materials, add classes, and move on to annotation without lengthy preparation.

Why You Need Your Own Datasets

Ready-made models are usually trained on large, universal datasets. This is a useful starting point, but real tasks almost always have their own peculiarities.

Suppose a model can find airplanes in photographs. It works well on ordinary pictures from the internet: the airplane is large, the background is clear, and the angle is obvious. But a surveillance camera may provide a completely different image. The object occupies only a few dozen pixels, the sky is covered with clouds, the picture is noisy, and the shape of the airplane is nearly indistinguishable.

For the model, this is now a different dataset. If it hasn't seen similar examples during training, the outcome may be weak.

Therefore, for specific tasks, I try to collect materials precisely from the conditions in which the system will operate:

• from different cameras and lenses;
• in clear and cloudy weather;
• during daytime, evening, and twilight;
• with large and very small objects;
• with blurring, digital noise, and heavy zoom;
• from different angles and distances to the object.

After collecting images, they still need to be annotated. It's essential to indicate to the model where exactly the object is located and to which class it belongs. This is exactly why I needed a separate tool.

How Crazy Studio Works

Crazy Studio works in the browser. To start, you need to create a project and choose the type of data you'll work with:

• images;
• texts;
• audio recordings;
• videos.

The type is set when creating the project. This is done intentionally: the tools for annotating images differ significantly from those for text or audio, so mixing everything in one workspace doesn't make sense.

Within a project, you can create several datasets. For example, you can store training, validation, and final testing data separately:

TrainingValidationTest

Another option is to separate materials by source or shooting conditions:

Camera 1Camera 2DayNightCloudy

Such separation helps understand which data has already been collected and on which materials the model shows weak results.

Annotation of Objects in Images

For images, Crazy Studio provides rectangular areas and polygons.

Rectangles

The rectangle is suitable for most object detection tasks. The user selects the desired area in the image and assigns it a class.

In my case, the set of classes might look like this:

airplanehelicopterdronebirdunknown

If one frame contains an airplane and several birds, each object is annotated separately. As a result, the model receives not only the class name but also the coordinates of the object in the image.

This format can be applied not just to the sky. Rectangular areas are suitable for annotating people, cars, animals, road signs, products, details, and other objects.

Polygons

Sometimes the rectangle captures too much background. Then the object can be outlined with a polygon by sequentially placing points along its boundary.

Polygons are helpful for annotating objects with complex shapes:

• roads and sidewalks;
• buildings;
• fields and bodies of water;
• cracks and other damages;
• equipment parts;
• areas in medical images.

For my tests in the sky, a polygon might be necessary when I need to highlight the precise silhouette of the object, not just its approximate position.

Multiple Classes for One Object

One object is not always described by one label. For example, a drone can be designated not only with the class drone, but also with additional characteristics:

dronesmallfarblurred

In Crazy Studio, one area can be assigned multiple classes. This is more convenient than creating separate categories for each combination of attributes.

Instead of the class small_blurred_drone, the object receives three independent labels:

dronesmallblurred

In the future, such data is easier to filter and convert into the necessary training format.

Text Annotation

Crazy Studio can be used not only for computer vision. In a text project, the user highlights individual words, sentences, or arbitrary fragments.

For example, the text can annotate:

• people’s names;
• company names;
• countries and cities;
• dates;
• addresses;
• products;
• events;
• device models.

In the sentence:

The company CrazyLayer has developed a new dataset editor.

the word CrazyLayer can be highlighted and assigned the class company.

Such datasets are suitable for training models that extract entities from news, documents, contracts, user messages, and other textual materials.

Text projects can also be used for content classification. For example, annotating messages by categories:

spamadvertisinginsultthreatnormal

On such a sample, you can fine-tune a model for moderating comments or automatically sorting requests.

Audio Recording Annotation

In audio projects, the annotation is created on the timeline. The user specifies the start and end of the desired fragment and then assigns it a class.

For example, in a conversation recording, you can annotate:

operatorclientsilencebackground_noise

In a sound recognition project, the set of classes will be different:

enginealarmmusicdogshot

Created intervals can be moved and adjusted in length. This is useful when the boundaries of an event have been better defined after the first listening.

For the task with objects in the sky, you can collect recordings of aircraft, helicopters, and drones, and then mark the segments where the sound is actually heard.

Video Annotation

Video is annotated by time intervals in a similar principle. The user indicates the start moment of the event and the moment it ends.

This allows you to mark:

• the appearance of an object in the frame;
• the start of movement;
• a person falling;
• a car stopping;
• scene change;
• a specific action;
• a violation of safety regulations.

In my case, an interval can denote the time during which an airplane or drone remains visible in the shot.

This does not replace frame-by-frame annotation if it is truly needed by the model. But for tasks detecting events over time, intervals allow data preparation to be significantly faster.

What Formats Can the Dataset Be Exported To

Making annotations is only half the job. Next, it needs to be passed to the training script, computer vision library, or your own handler. That’s why in Crazy Studio, I added several export options for different types of projects.

When exporting, you can choose the current dataset or the entire project. You can also add the original images, texts, audio, and video in a ZIP file. If the files are already stored separately and only annotations are needed, this option can be turned off.

Universal JSON

The universal JSON is available for images, text, audio, and video. It saves the entire project structure: classes, datasets, materials, annotation objects, geometry, and assigned labels.

This format is convenient for backups, transferring data to your own service, or writing your converter. If I need the maximum information without being tied to a specific framework, I choose Universal JSON.

JSON Lines

In the JSON Lines format, each material is recorded as a separate line in the dataset.jsonl file. The line contains project data, dataset name, file information, and all its annotations.

This option is easier to read sequentially without loading the entire export into memory. It’s suitable for large datasets, server processing, and your own Python scripts.

YOLO

YOLO is available for image projects. For rectangular annotations, the class number, center of the box, width, and height are saved. All coordinates are normalized and recorded in the range from 0 to 1.

Polygons are also supported: after the class number, the coordinates of all points are recorded in the line. Therefore, the same exporter can be used for both object detection and segmentation.

The archive includes dataset.yaml, classes.txt, a labels directory, and, if the corresponding option is enabled, a images directory. I use this format when I want to quickly move from annotation to training a YOLO family model.

Crazy Studio does not automatically split one export into train, validation, and test. To do this, I create separate datasets for Training, Validation, and Test and export them separately.

COCO JSON

COCO JSON is also designed for images. In one annotations.json file, a list of images, categories, and annotations is saved. Rectangles are recorded as bounding boxes, and polygons as segmentation with a set of points.

This format is convenient when the training code or a ready-made library already expects the COCO structure. It’s also suitable for sharing datasets between different computer vision tools.

Pascal VOC

When exporting to Pascal VOC, a separate XML file is created for each image with image dimensions, class name, and coordinates of the rectangular area.

Pascal VOC is useful for older projects and tools that work with XML annotations. It should be noted that a polygon in this export turns into a regular rectangular boundary around its outer edges. The exact shape of the object in this format is not preserved.

spaCy JSON

For text projects, export to spaCy JSON is available. It saves the original text and a list of highlighted entities: start position, end position, and class name.

For example, a highlighted company name can be exported as an entity company, and a person's name — as person. Such a file can be used when preparing data for named entity recognition and other text processing tasks.

Audacity Labels

For audio and video, you can choose Audacity Labels. Crazy Studio creates a text file where each line contains the start time, end time, and class names of the time interval.

The file can be opened with the recording in Audacity or processed with your own script. This format is suitable for annotating speech, noise, music, equipment sounds, and events in videos.

What Happens with Multiple Classes

In Crazy Studio, one object can be assigned multiple classes. Universal formats save them along with the object. If a format is selected where one record is designed for only one class, the editor creates a separate record for each label.

For example, an object with classes drone, small, and blurred will appear in YOLO as three lines with the same coordinates but different class numbers. This should be considered before training: additional attributes don't always need to be mixed with the primary object categories.

What Tasks the Editor Can Be Used For

Initially, I made Crazy Studio for my own experiments, but the very principle of annotation is suitable for different areas.

Object Detection

You can collect datasets with cars, people, animals, products, documents, objects in the sky, or equipment parts.

Defect Detection

In images, you can mark cracks, chips, scratches, corrosion, contamination, and other damages. These data are then used to train a model that should automatically find similar defects.

Document Processing

In texts, you can highlight dates, amounts, contract numbers, organizations, names, and addresses. Such datasets are useful for processing bills, contracts, forms, and requests.

Sound Recognition

Audio recordings can be annotated by voices, noise types, signals, transport sounds, or equipment sounds.

Event Analysis in Video

In videos, you can mark the moment an object appears, the start of an action, or the needed episode. This is suitable for video surveillance, sports analytics, and analyzing long recordings.

How I Usually Start a New Dataset

I try not to upload thousands of files to the project at once. First, I take a small batch of examples and go through the entire process from start to finish.

1. Create a project of the required type.
2. Add a test dataset.
3. Upload several dozens of materials.
4. Create main classes.
5. Annotate the first examples.
6. Check if the chosen classes are sufficient.
7. Change the annotation rules if necessary.
8. Only after that, upload the main sample.

In the first twenty or thirty examples, it becomes clear what situations I may have overlooked.

For example, in the project about objects in the sky, a question quickly arises: what to do with a small dot that cannot be confidently identified? Should it be considered a drone, should I use the class unknown, or is it better not to add such a frame to the training sample at all?

Such rules are better defined before the bulk annotation. Otherwise, identical cases will be marked inconsistently, and extraneous noise will appear in the data.

Why Annotation Quality Is More Important than Quantity

A large dataset does not guarantee a good result by itself. If classes are mixed up, objects are missed, or boundaries are inaccurately drawn, the model will learn from these mistakes.

Let’s imagine that a similar small dot in the sky is annotated as drone in one image, as bird in another, and is not marked at all in a third. To a human, the reason may be clear: the object is poorly distinguishable. The model sees only conflicting answers.

Therefore, I prefer to first create a small but tidy dataset. If it yields the desired result, the volume can be gradually increased.

Why I Didn’t Overload Crazy Studio

Large annotation systems have user roles, complex workflows, quality control, task distribution, and dozens of additional tools. For large teams, all of this may be necessary.

My task was different. I needed a simple editor that could quickly check the idea:

1. Create a project.
2. Upload materials.
3. Add classes.
4. Annotate data.
5. Export results.

I did not try to replace all existing platforms. I built a tool for situations where you need to quickly prepare your own dataset and move on to testing or fine-tuning the model.

What I Plan to Add Next

Crazy Studio remains a work-in-progress project that I continue to improve as new tasks arise.

In the future, the editor may feature new import formats, additional exporters, annotation verification tools, class statistics, preliminary automatic annotations, and more convenient handling of large samples.

But I want to maintain the core principle: there should be as few unnecessary actions as possible between uploading a file and creating the first annotation.

How to Try Crazy Studio

The editor is available at studio.crazylayer.com .

After logging in, you can create a project for images, text, audio, or video, add your own classes, and upload test materials.

To start, it’s better to take a small real example from your task. This way, it becomes clearer if the chosen annotation method is suitable and which classes are truly needed.

In general, use the Crazy Studio dataset editor — it’s absolutely free! And I will try to update, improve, and add new features regularly.

Open Crazy Studio and create your first dataset