{
  "version": 3,
  "sources": ["ssg:https://framerusercontent.com/modules/GRQPbsSNLbAUn00qGznl/Guay6vnGLtHP8uT8veKs/Y122M6z_Y-2.js"],
  "sourcesContent": ["import{jsx as e,jsxs as t}from\"react/jsx-runtime\";import{Link as a}from\"framer\";import*as o from\"react\";export const richText=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we discuss V7\u2019s Auto-Annotate feature - a powerful tool for creating pixel-perfect masks in 2D computer vision. This feature is a key favorite for V7 users, for its ability to save time, save costs, and complete datasets 90% faster.\"}),/*#__PURE__*/e(\"p\",{children:\"Achieving pixel-perfect masks can be a time-consuming process, particularly if you\u2019re having to do it manually. That\u2019s why V7\u2019s Auto-Annotate was built, to prioritize impressive accuracy, while rapidly increasing the rate of annotation. So much so, that the Auto-Annotate feature completes polygon mask annotations in approx 2.5 seconds, compared to the industry average of 34 seconds.\"}),/*#__PURE__*/t(\"p\",{children:[\"Did you know, we\u2019ve created a SAM-enhanced version of the Auto-Annotate feature? Head to our \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/product-update/sam-auto-annotate\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"product update section\"})}),\" to discover the new and improved features of this tool.\"]}),/*#__PURE__*/e(\"p\",{children:\"In this tutorial, we demonstrate the Auto-Annotate feature in action, explain the deep learning model used to train it, and showcase how you can use the feature in your own projects.\"}),/*#__PURE__*/t(\"p\",{children:[\"We also tackle the tool's compatibility with various image domains, resolutions, file types, and sizes - including video frames. The Auto-Annotate feature can also be fine-tuned for specific datasets to handle unusual objects, allowing you to further fuel your product pipeline process. Keen to discover other annotation methods within V7? Dive into our Darwin Fundamentals session on \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy/annotations-getting-started\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"annotation techniques\"})}),\".\"]}),/*#__PURE__*/e(\"p\",{children:\"The advantages of the Auto-Annotate feature are innumerable, from reducing labeling time by 65 to 90% to reducing the mental fatigue that often comes with manual annotation. The tool\u2019s pixel-perfect accuracy dramatically cuts down on the need for humans to follow pixel gradients exactly, making it a particularly useful tool for tedious tasks.\"})]});export const richText1=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Pixel perfect masks are the most accurate type of label that you can have in 2D computer vision but also the most expensive to create. The average time it takes to complete a polygon mask annotation is about 34 seconds across the industry. Auto annotate helps you reduce that to about 2. 5 seconds.\"}),/*#__PURE__*/e(\"p\",{children:\"What this ultimately means is that in five hours, you're able to create almost 10, 000 labels. This makes it as fast as creating bounding boxes without the mental fatigue of having to perfectly align crosshairs and edges. It's able to learn anything from these tools on this image. to clustered objects like the ones that you're looking at now.\"}),/*#__PURE__*/e(\"p\",{children:\"It doesn't matter what angle they have, what lighting conditions you're looking at, and it's not just simply a statistical type of hackery. It's actually using a deep learning model that is trained on such a large variety of items. That it's now able to segment almost everything. Why do we recommend using this tool?\"}),/*#__PURE__*/e(\"p\",{children:\"Firstly, it's faster. This is easy to measure, and it will save you between 65% and 90% of your time spent labeling. Secondly, it reduces your mental fatigue a lot. One of the most difficult things about labeling images is not necessarily the act of clicking, it's the mental fatigue that comes from accurately clicking around pixels for hours every day.\"}),/*#__PURE__*/e(\"p\",{children:\"Finally, it's pixel perfect. Humans aren't that good at following pixel gradients exactly. It's a tedious job, and it's one best left to machines. What Auto Annotate helps you do is simply define a rough bounding box around each object. You don't really have to align the crosshairs exactly to the corners, you can simply create a very broad region of interest, and then it will understand the most salient object within that boundary.\"}),/*#__PURE__*/e(\"p\",{children:\"If you zoom into one of those output masks, you notice that the border is exactly mid gradient. This gives the best result when training an object, and Auto Annotate helps you do this effortlessly rather than having to manually move the borders of each mask. Even if objects overlap such as these x rays, it's still able to understand what object you intended to focus on.\"}),/*#__PURE__*/e(\"p\",{children:\"Another difficult case, for example, is people in difficult lighting or behind smoke. Auto Annotate is able to cover this case perfectly, which is something that SuperPixels or traditional computer version methods would never be able to achieve. It might make a mistake, and you can simply click to correct it immediately.\"}),/*#__PURE__*/e(\"p\",{children:\"If you want an object to be expanded beyond what it seems to be the most reasonable item within that region, Keep clicking outside of the object and Auto Annotate will rerun the same model to include those new parts. It's meant to work hand in hand with you as you label these images or have them labeled by your workforce of choice.\"}),/*#__PURE__*/e(\"p\",{children:\"If you're labeling images yourself, this is both a great time saver and a sanity saver. And if you have a workforce currently labeling images, it's hopefully a huge money saver as well. Auto Annotate is available within any image domain including medical and pathology images. any image resolution, file type, or size, including video frames.\"}),/*#__PURE__*/e(\"p\",{children:\"We are also able to fine tune it to specific data sets once you have some training data should your objects be particularly strange to the point where Auto Annotate doesn't fit to them perfectly on the first go. Auto Annotate currently covers the vast majority of pixel masks done on V7 Darwin and we hope you'll get a chance to try it out as well and complete your data sets 90% faster and more accurately.\"})]});export const richText2=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we provide a comprehensive overview of annotations within the Darwin Platform. We\u2019ll tackle shortcuts, annotation techniques, layers, classifications, and much more.\"}),/*#__PURE__*/e(\"p\",{children:\"V7\u2019s Darwin is a powerful platform that allows individuals and businesses alike to create state-of-the-art AI models. As an advanced AI engine - with easy-to-use UI - the platform has a number of features designed to advance, fast-track and simplify the process of creating AI products.\"}),/*#__PURE__*/e(\"p\",{children:\"In this tutorial, we first tackle V7 hotkeys, allowing you to pan and zoom with W, A, S, and D keys.\"}),/*#__PURE__*/t(\"p\",{children:[\"Next up, we dive into annotation techniques, from how to create bounding boxes to leveraging the Auto-Annotate feature. For a bit more detail on this feature, you can head to our Darwin Fundamentals session on the \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy/annotations-auto-annotate\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Auto-Annotate tool\"})}),\".\"]}),/*#__PURE__*/e(\"p\",{children:\"Moving on, we explore layers, which allow annotations to overlap without deletion to provide greater flexibility. Following layers, we explore classification tags (to allow users to add detailed information to their annotations), dataset review (to apply corrections and leave comments), and additional tools native to V7 (such as the brush and eraser tools). In particular, this tutorial will highlight time-saving features, such as copying annotations between images, to get you up and running to leverage Darwin with best practices in mind.\"}),/*#__PURE__*/t(\"p\",{children:[\"You\u2019ll come away from this video with a strong foundational understanding of the V7 platform, the features it offers, and how you can enhance annotation proficiency, image processing, and dataset management. Searching for something more? You can explore our \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/docs/annotation-101\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Annotation 101 session just here\"})}),\".\"]})]});export const richText3=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"By the end of this tutorial, you'll know most of the basics of using V7 Darwin. Let's start with camera movements. To pan around, you can press the middle click or scroll wheel on your mouse. Hold and drag and move the image around. You can use the scroll wheel also to zoom in or the shift button and two finger drag if you are on a trackpad.\"}),/*#__PURE__*/e(\"p\",{children:\"You can also use the W, A, S, and D keys. Press the Z key to activate the zoom tool. You can click, or shift click to zoom out. You can also drag in a certain region to zoom right into it. When you're done, press zero to reset. When you're familiar with these controls, you can press the period button to cycle to the next image.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's start with some bounding boxes. You can press the B key or the bounding box button here on the left. to activate this tool. Let's enclose this lantern by first zooming into it and making sure that we align the crosshairs to make sure that we capture the pixels that only belong to this lantern.\"}),/*#__PURE__*/e(\"p\",{children:\"Hold and drag and release and then we can double click on the lantern class to select it. Now we can zoom back out and continue with other lanterns. We can zoom all the way into this one and see the very pixels of the image. And then enclose it in a bounding box. When done, I'll press zero to look at the whole image, make sure I've included all the lanterns and I haven't, but I'll skip it for this tutorial.\"}),/*#__PURE__*/e(\"p\",{children:\"And when I am done, I will press the center review button here on the top right, which also has a shortcut of enter or shift enter in some cases. Now let's switch classes. There are many ways to do this. The first one is to simply double click on the label that appears when you're looking at a class. In this case, I can press the edit tool, V, and click on this lantern label here with a double click, and then select the person class.\"}),/*#__PURE__*/e(\"p\",{children:\"You can also use this class selector, which is present in every tool. In this case, these are the bounding box classes that we can select, and I can press person. And we'll annotate another person here. You can also use Alt V to paste a class name onto another. And obviously, Ctrl C, or Command C in a Mac, and Ctrl V, or Command V on a Mac, to paste classes.\"}),/*#__PURE__*/e(\"p\",{children:\"Get familiar with copying and pasting classes and moving them around. Or repeat some bounding boxes to enclose some additional people in this much larger image. When you're done, take a look at these keyboard shortcuts on the top right by pressing this command button over here. These keyboard shortcuts are going to be essential for becoming a power user in Darwin, and they will save you a lot of time as you get familiar with the tool.\"}),/*#__PURE__*/e(\"p\",{children:\"There are many keyboard shortcuts to learn, so make sure you keep referring to this keyboard shortcut panel when you want to improve your speed. When you're familiar with this image, Press the center review button to continue. Now let's start using some polygons. You can press the P key to activate the polygon tool.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's zoom into this large car at the front. We can click to add some points and move the mouse to start building a polygon around it. We can click as fast as we need to, to enclose this car. You can close the polygon by clicking on the last vertex, or by pressing enter, as I will do now. Again, since we haven't selected a class before hand, it will prompt us to do so.\"}),/*#__PURE__*/e(\"p\",{children:\"I'll select the car class, and it will complete my polygon. Now let's find a better way of making these polygons. Let's use the auto annotate tool. AutoAnnotate is a very powerful AI based tool that knows any class or any object and encloses it with a pixel perfect polygon. Let's select the car class, and by default we will have the generalized model.\"}),/*#__PURE__*/e(\"p\",{children:\"This will know practically any object. We'll try to enclose this vintage car next to our other friend here, and it will do a much better job at enclosing it in the first go. But sometimes it won't be perfect. It forgot a bit of wheel, so we will click on this region to include some more pixels. And we'll click again if we want to include another piece.\"}),/*#__PURE__*/e(\"p\",{children:\"I also want to include this rearview mirror, so I will simply click and it will expand to include a new object. Let's try it on some other objects, such as this other car,\"}),/*#__PURE__*/e(\"p\",{children:\"and you can also try it on other objects that are not cars, simply to try things out, such as perhaps this road sign.\"}),/*#__PURE__*/e(\"p\",{children:\"When you're familiar with auto annotate and its command, including the addition of points, The clear button and the rerun, which also activates whenever you resize auto annotate, you can continue to the next image. You can also spend some time here, familiarizing yourself with the polygon tool, as you may use it frequently in your annotation.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's deal with some layers. Layers are used to save you time without having to delete objects that are next to one another. You can simply have them overlap. For example. Let's select the sky class and make a very rough polygon around this image. I will make four points and we'll enclose this image with a large sky.\"}),/*#__PURE__*/e(\"p\",{children:\"I'll select the polygon tool again, select the wall class, and I can type in to filter it quickly, and add five points to include a wall. You'll notice that on this panel on the right, wall is now on top of sky. This means that in the JSON order or XML order that we will export the file in, the wall will be placed in a position above it.\"}),/*#__PURE__*/e(\"p\",{children:\"In the JSON order, it is technically below. But if you were to export a PNG mask of this image, the wall would be covering the blue color of the sky, therefore being true to what's represented on the image. Let's finish this image off by adding some chimney stacks here. I'm going to press CH to filter to chimney stack, and then start adding the chimney stacks from the back to the foreground.\"}),/*#__PURE__*/e(\"p\",{children:\"We'll add the first, the second, the third, and the last one.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's say that for some reason we want the sky to be above all the other annotations. You can click and drag and reorder it to the very front. I'll move it in between the first chimney stack and the second. And to demonstrate how this works, I'm going to ramp up the annotation fill opacity. And you'll notice that the sky polygon is now overshadowing all the other ones.\"}),/*#__PURE__*/e(\"p\",{children:\"If you ramp it to 100%, this gives us an idea of how this image will look like as a PNG export. I'm going to move the sky now back to the background. Now that looks a lot better. This new image looks different than the other. It has a yellow border around it saying, Reviewing, and then potentially your name.\"}),/*#__PURE__*/e(\"p\",{children:\"This is a review image. It has been annotated by someone before you, and it's now your turn to mark it as complete, or reject it back to them, or apply some corrections and then mark it as complete. In this case, the error seems quite evident. We're going to make a correction, select a dog class for this guy, and maybe just for the completeness sake, we're going to annotate this other dog as well.\"}),/*#__PURE__*/e(\"p\",{children:\"And I think that looks like a pretty good annotation to me. What you can also do in datasets outside of this tutorial is leave comments. This will allow you to communicate with the users that have worked on this image with you. In this case, another version of myself. You can leave comments such as mentioning that someone forgot an annotation or that an annotation is wrong.\"}),/*#__PURE__*/e(\"p\",{children:\"Note that applying corrections to images in review will affect the score of the person that worked on this image before you. So be mindful of whether you want to apply the corrections yourself or send the image back. Projecting the image with comments provide them with some textual feedback so they may know what they did wrong.\"}),/*#__PURE__*/e(\"p\",{children:\"Likewise making a correction will impact their score and allow them to review the image later. Now let's move forward and mark this as complete. Here we have a bunch of horses and if we cycle forward one image we'll notice that this is somewhat temporal. It is not quite like two video frames but there is some consistency with these six horses on the frame.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's label one with auto annotate. I'm going to pick this one on the front.\"}),/*#__PURE__*/e(\"p\",{children:\"We have an annotation of the horse. Note that there is a figure over here saying 0. This is an instance ID. It is a sub annotation selected for this class that tells us that this is horse number 0, and it is a unique identifier for this horse. This is quite useful if this specific horse may reappear in the dataset and we want to re identify it.\"}),/*#__PURE__*/e(\"p\",{children:\"We can also add an attribute to the source by defining its color. In this case, we'll say it's brown. Moving on to the next image, we'll notice that the very same horses have moved around. I can press this copy instances button on the right to copy over whatever annotations were in the previous frame.\"}),/*#__PURE__*/e(\"p\",{children:\"The horse annotation from the previous image has reappeared, but it is clearly in the wrong spot. If we want to make a comparison, one handy trick is pressing this reset zoom lock button until it is in the crosshair mode, which will fix zoom whenever we switch images. So if I press comma to switch back, and period to switch forward, I can see exactly where the camera corresponds to in the next image.\"}),/*#__PURE__*/e(\"p\",{children:\"In this case, fixing this will be easy. I'm going to move this annotation to the position of the new horse, and press the Edit Auto Annotate button. I'll make an adjustment to the box around Auto Annotate, and it will automatically adapt to this new position and pose of the horse. With one error here, which I can correct by clicking, and having it exclude the head of what is clearly another horse.\"}),/*#__PURE__*/e(\"p\",{children:\"We can now compare the two images. and see that there is consistency in the instance ID, which is also marked by a unique set of three colors and obviously the horse itself. You can edit any auto annotate by pressing this button over here, or the shortcut of M for Mike. We have an image here that probably won't give our model any further learning.\"}),/*#__PURE__*/e(\"p\",{children:\"It is blurry, you can't really distinguish objects, but before we discard it with this button over here, let's make sure that we're not missing out on anything. Open the image manipulation panel and set the brightness up a little bit. Clearly we cannot see any further objects and I think it's the right decision to discard this image.\"}),/*#__PURE__*/e(\"p\",{children:\"We'll click on this trash can and pick motion blur as a reason as it is the most prevalent prevalent error in this image. This image will be set as discarded and will be sent to review automatically. I can either press the period button or press the sending to review button to cycle forwards automatically.\"}),/*#__PURE__*/e(\"p\",{children:\"Before you do so, make sure that you press this reset button over here to put the parameters of image manipulation back to the default setting. Otherwise, all the images you will see will have very high brightness. This is also quite useful if your entire data set is very dark or perhaps very low in contrast.\"}),/*#__PURE__*/e(\"p\",{children:\"We have a very simple task here. We only need to classify this image with a classification tag. Classification tags are present in the bottom right of the image in this tag applier section. You can simply click on a tag to apply it to the specific image. And you can also type to create new tags. You can press enter or this button over here to create a new underwater tag, which will be usable throughout the whole dataset.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's play some sub annotations. These are like annotations on top of annotations, a bit like attributes before or instance IDs. There are many of them available on Darwin. We'll pick the gauge class here and zoom onto this pressure gauge and close it with auto annotate. And then select the directional vector sub annotation over here.\"}),/*#__PURE__*/e(\"p\",{children:\"This will allow us to give a direction to this object. Whether it's a person, car, animal. It can set a value between 0 and 365. In this case, we will use it to define its hand. We can also add attributes to it. For example, the fact that its pressure is 0. You can always paste sub annotations to other annotations of the same class by using Ctrl Shift V or Cmd Shift V on a Mac.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's move forward. Okay, we will play a bit with the brush tool here. The brush tool shortcut is F. and it has some additional commands on the top. You can increase its size with these buttons, or by using these square brackets, as you would in most image editing software. We're going to zoom into these windows and make a very simple annotation of them.\"}),/*#__PURE__*/e(\"p\",{children:\"Note that while in edit mode, the brush tool will always make a red mask. This is because it's not converted to a polygon yet. All annotations in V7 Darwin are stored as vectors. These are both lighter and much easier to manipulate than raw pixel values. To confirm your annotation, press enter or switch to any other tool such as the edit tool with V.\"}),/*#__PURE__*/e(\"p\",{children:\"This will prompt you to name this class and we will make it a window. Now that we have this window class, in its instructions, it mentions that if objects are visible through the glass, exclude it. In this case, we will select it and press E to access the eraser tool, which is also available through a button in the brush tool.\"}),/*#__PURE__*/e(\"p\",{children:\"When we have the eraser tool selected, we can start editing polygon annotations and create holes within them. We can also create compound annotations with multiple parts. In this case, we will create four holes into this window so that we may exclude the glass. If I want to correct issues such as this, I can simply switch back to the brush tool with F, reduce the brush size, and paint in these pixels of the window.\"}),/*#__PURE__*/e(\"p\",{children:\"When I'm done, I can press enter and note that it now has four holes within it. Another tip is to press shift to switch between the eraser and brush whenever the other is selected. We're almost at the end of this short tutorial. The last annotation type that we will play with is text. Let's select a bounding box tool and the printed text class.\"}),/*#__PURE__*/e(\"p\",{children:\"Enclose one of these words and then use the text sub annotation to define whatever text is contained here. You can press enter to confirm. This is used in OCR or text detection or simply to add free text to any annotation. Before we conclude, a few extra tips here is that you can hide any annotations by pressing the I button here, or delete them by pressing the trash can.\"}),/*#__PURE__*/e(\"p\",{children:\"You can also hide all annotations by pressing this teal colored I, and you can hide any sub annotations, or the colored label of each annotation, by pressing this circle. This may be useful when your annotations start getting really, really dense. Finally, you may have noted that there is a timer at the top.\"}),/*#__PURE__*/e(\"p\",{children:\"You can pause this anytime and it will pause automatically whenever you leave this tab. You can also move between images with these top buttons or press undo and redo with these two. Finally, this timeline at the top can be navigated to see how annotations were at a previous stage by simply clicking on it and going into time travel mode.\"}),/*#__PURE__*/e(\"p\",{children:\"This will be particularly useful if your annotation workflow has many, many steps. We're at the end of this tutorial where this amazing cat will greet us.\"}),/*#__PURE__*/e(\"p\",{children:\"If you'd like to get in touch with myself or any of the developers on the V7 Darwin team, you can always use this feedback button on the left, click on it and enter some text here, you can use this to report bugs or even for feature requests. We implement many feature requests that our users put forward to us.\"}),/*#__PURE__*/t(\"p\",{children:[\"And finally, if you want to learn from more tutorials like this, you can go on \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"v7labs.com/academy\"})}),\". That is all for now. To return home, simply press this team icon on the top left and it will get, and it will send you back to your dataset panel. Thank you.\"]})]});export const richText4=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"In this Darwin Advanced session, we discuss how you can import annotations to V7 by using the command line interface (CLI) or the software development kit (SDK) - in any of our supported file formats. Head to our \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/docs/import-annotations-made-outside-of-v7\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Import Annotations documentation\"})}),\" to access a detailed overview of the process and the scripts discussed in the video.\"]}),/*#__PURE__*/t(\"p\",{children:[\"This tutorial begins with a breakdown of the \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/reference/darwin-json\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Darwin JSON file format\"})}),\", the most versatile and widely used option for importing annotations. However, if you require another format - don\u2019t worry, we support COCO, YOLO, Instances PNG, CVAT, and many others.\"]}),/*#__PURE__*/e(\"p\",{children:\"We begin by breaking down the makeup of the Darwin JSON format, highlighting the annotation and item data specific to the image or video you\u2019re importing. To get started with annotations import, we showcase two methods: the CLI and the SDK.\"}),/*#__PURE__*/e(\"p\",{children:\"The step-by-step run-through of the CLI method includes how users can authenticate themselves using the \u201Cdarwin authenticate\u201D command, and how they can access datasets by using \u201Cdarwin datasets remote\u201D.\"}),/*#__PURE__*/e(\"p\",{children:\"Next, we demonstrate the process of using the SDK, with code examples. Here we walk you through initiating the client and specifying the annotation format, to uploading the annotations to the dataset hosted on V7.\"}),/*#__PURE__*/e(\"p\",{children:\"You\u2019ll come away with a detailed and accessible explanation of how to import annotations to V7, allowing you to organize and drive your computer vision projects forward.\"})]});export const richText5=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"You can use the command line interface or SDK to import annotations in any of our supported file formats.\"}),/*#__PURE__*/e(\"p\",{children:\"We currently support the formats, Coco, YOLO, Pascal, VOC, and more, but we are always looking to extend this list. That said, the default and most versatile format is our own Darwin JSON format, so let's have a brief look at how it is defined.\"}),/*#__PURE__*/e(\"p\",{children:\"The content of each Darwin JSON file can be summarized by the following specifications.\"}),/*#__PURE__*/e(\"p\",{children:\"An export includes all the information about the exported resource. The most important information hereby is the item and annotations field. The dataset field simply encodes the Darwin dataset name that the resource belongs to. The slots field again describes a resource that can be of type image or video, uploaded to Darwin, including its original metadata. The version field will simply be 2.0 when the export format is Darwin JSON 2.0.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, the item field includes information about the referenced resource, that is the image or the video, uploaded to Darwin within particular slots. Finally, the annotations field actually lists all the annotations within Darwin for that resource, be it bounding boxes or polygons.\"}),/*#__PURE__*/e(\"p\",{children:\"Outside of the annotation data, the only really required field, in the imports for Darwin JSON, is the filename. That is used to associate the annotations to the corresponding images in V7 upon import.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, enough boring definitions. Let's look at some code. As you can see, we have already uploaded the images in our dataset to V7, but we now want to also upload our existing annotations using the SDK.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's first see how to access our datasets that are stored on V7 using the command line interface. If we haven't already, we need to authenticate ourselves using the command \u201CDarwin authenticate\u201D, where we'll be asked to enter our API key. Those can be found and generated when going to our settings in V7 and then to the tab for API keys.\"}),/*#__PURE__*/e(\"p\",{children:\"Now that we are authenticated, we can view which datasets we have by entering \u201CDarwin datasets remote\u201D. We now have everything that we need to actually import our annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"The easiest method to do so is using the command line interface. We simply use the command \u201CDarwin datasets import\u201D and provide the following arguments.\"}),/*#__PURE__*/e(\"p\",{children:\"First, we specify the slugified team and dataset names. If the term slugified is new to you, please have a look at documentation and everything should be clear.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, the missing important arguments are the annotation format and the path to the annotations themselves, and, that's actually it. Now, using the SDK is really not much more work.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's have a look at the simple scripts to upload our annotations. We again start by initializing our client, where there are multiple ways of doing so, for example, directly via the API key or using the local authentication that we just set up when using the command line interface.\"}),/*#__PURE__*/e(\"p\",{children:\"We also figured out the dataset identifier that we can now use to target the dataset in V7.\"}),/*#__PURE__*/e(\"p\",{children:\"Next, we need to specify the annotation format and we can fetch the necessary parcel object. Finally, we can upload our annotations to our dataset hosted on V7. This append argument here specifies whether an already existing annotation will be overwritten or not. That means setting append to true will add the imported annotation without overriding the existing ones.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, cool. Let's see the script in action.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, we have already looked at this dataset right here and know that we have some annotations here. For example, those with the green mark are in the complete stage and some images don't have annotations. For example, this little image right here of this nightingale.\"}),/*#__PURE__*/e(\"p\",{children:\"So, let's go ahead and look at the code and upload the annotation that I have already done and stored on my local machine. So, we'll go ahead and look at the code.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, as with every script that we write, we first need to import our dependencies. While going through the code, we'll look at what each individual module actually does.\"}),/*#__PURE__*/e(\"p\",{children:\"So, let's go ahead and import our dependencies. We now are at the point where we want to authenticate our client, right? We need to somehow have an interface to V7 itself. There are multiple ways of doing this, for example, one is to directly use your API key or the other is to, as already discussed, use the local authentication method, which we have set up when using the command line interface.\"}),/*#__PURE__*/e(\"p\",{children:\"The code is already familiar to you. We already looked at it, but let's just see how it works in action. So now we are at the point where we want to specify our dataset. Our dataset is our team name or slugified team name, Boris Moinados, and then the dataset that we are working with. So when you run this, we actually get access to our remote datasets and we have our dataset manager.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's run this. So now going through a code step by step, we now want to get the parser object that we need for our importerTherefore, we'll just specify our format name. In my case, we are again using the nice Darwin JSON format. So let's just run the cell and fetch our parser object and then we need to specify the list of annotations that we have.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, in this case, I'll just be showing you how to upload one annotation, but you can always append this list with all the parts to all the annotations that you have and that you want to upload to V7.\"}),/*#__PURE__*/e(\"p\",{children:\"So, again, in this case, I have my annotations path, which is a list of just strings with the path to this one annotation that I have.\"}),/*#__PURE__*/e(\"p\",{children:\"Right, if you look at what the annotations look like, I can go into my bird species, which has all the images, and then I go to my releases and to my annotations, and here I have my list with all annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay. So let's just create this little list and we are almost done. Okay. We can now simply use our importer object to actually import the annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"We hereby again specify to which dataset we want to import our annotations to, we provide our parser, (which is now set for the Darwin JSON file format), we have our list of annotations and we have our append true arguments. So let's just run the cell.\"}),/*#__PURE__*/e(\"p\",{children:\"We can see that we are already done.\"}),/*#__PURE__*/e(\"p\",{children:\"It's just one file, so let's go ahead and look at our UI. This is the image that we want to upload our annotation to. Let's just refresh this website, you can see, here we have the annotation. If I just reduce the brightness, you can see the annotation even better.\"}),/*#__PURE__*/e(\"p\",{children:\"And that's it. It's as simple as that.\"}),/*#__PURE__*/e(\"p\",{children:\"Again, not that crazy, right?\"}),/*#__PURE__*/e(\"p\",{children:\"You now know how to import your existing annotations into V7.\"}),/*#__PURE__*/e(\"p\",{children:\"I hope this video helped you with getting started with, well, V7.\"})]});export const richText6=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"The Auto-Annotate feature in V7 can automatically segment objects without the need for loading specific models. It uses a generalized neural network that has been trained on a wide range of items. All you need to do is draw a rough bounding box around the object, and Auto-Annotate will take care of the rest.\"}),/*#__PURE__*/e(\"p\",{children:\"The video will guide you through the process of using Auto-Annotate in the most effective way. One important aspect is to provide enough padding around the objects in your bounding boxes. This ensures that the AI can produce more accurate results. You will also learn how to fine-tune the segmentation by including or excluding specific parts of objects.\"}),/*#__PURE__*/e(\"p\",{children:\"The collaboration between you and the AI comes into play when dealing with occluded objects or objects with unclear boundaries. Auto-Annotate will make its best attempt, and you can easily make corrections by adding or removing parts of the segmentation with just a few clicks. In a dedicated section, we also demonstrate how Auto-Annotate efficiently works with video data \u2013 enabling you to quickly create segmentation masks and interpolate them.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you will have the necessary skills to fully utilize Auto-Annotate, making your annotation process smoother and more accurate. With the convenience of Auto-Annotate, you can save valuable time during annotation and achieve high-quality results without the need for manual pixel-by-pixel labeling.\"})]});export const richText7=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"During this session, we will explore the process of adding comments in V7. When reviewing annotations, comments can be used to notify the author about any necessary corrections or the need to add additional labels. The author will receive a notification with a direct link to the image, allowing them to make the necessary adjustments.\"}),/*#__PURE__*/t(\"p\",{children:[\"Comments are particularly valuable when seeking expert input, such as in the case of \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/industry/healthcare\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"radiological images\"})}),\" or other scientific fields. You can engage professional team members, like doctors, to provide feedback on specific images, ensuring a more accurate and reliable annotation process.\"]}),/*#__PURE__*/e(\"p\",{children:\"The best part is that comments will remain visible until they are resolved, either by an admin or the author of the annotation. This ensures that no feedback goes unnoticed, and you can easily keep track of any pending actions.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you will have a clear understanding of how to use comments in V7 Darwin to enhance communication and documentation within your datasets. Whether you are part of a team collaborating on image recognition projects or require expert input for specific images, comments can significantly improve your QA processes and enhance the accuracy of your machine learning workflows.\"})]});export const richText8=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Comments. They're a type of annotation you can use to communicate with the rest of your team asynchronously or leave a message about something that's present in an image. You'll find the comment button on the toolbar on the left, and you can use it both in review and in annotation mode. You can leave comments in review to communicate with the author of an annotation and let them know that something needs correction or that they need to add another object.\"}),/*#__PURE__*/e(\"p\",{children:\"Once you've done that, they will receive a notification linking them to the image that you commented on. This allows them to quickly learn what they need to fix and improve your quality control. Comments can be particularly useful if you need a set of images to receive the input of an expert, such as a doctor for radiological images or a similar scientific field.\"}),/*#__PURE__*/e(\"p\",{children:\"These comments remain there until an admin or its author decide to resolve them. You can start using comments now in Darwin to improve the documentation of any of your datasets.\"})]});export const richText9=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Darwin JSON serves as the core export format for V7 annotations and model predictions. In this video, we will explore its structure and advantages over other data annotation formats. You\u2019ll also learn how to convert your labels to and from Darwin JSON. Whether you want to import existing annotations into V7 or export your annotations to other formats, this tutorial has got you covered.\"}),/*#__PURE__*/e(\"p\",{children:\"Darwin JSON contains essential specifications, including the item and annotations fields, providing all the necessary information about the exported resource. It includes details about datasets, teams, and resource URLs, making it a rich source of metadata.\"}),/*#__PURE__*/e(\"p\",{children:\"You'll learn how to access essential data, such as image dimensions, thumbnail URLs, and the original image file name and URL. Then, we\u2019ll explore different annotations, covering various types like bounding boxes or polygons. You'll discover how to represent annotation data in Darwin JSON, including optional sub-annotation data and annotation authorship information. For video annotations, the video annotation object is explained, encompassing frame annotation data and interpolation information.\"}),/*#__PURE__*/e(\"p\",{children:\"Converting annotations to and from Darwin JSON is a crucial skill for integrating V7 into your existing workflows and tech stack. The video demonstrates how to convert annotations using the Darwin command line interface function library. Converting from Darwin to other formats, like YOLO, is as simple as calling a function with the right arguments.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you'll have a solid understanding of Darwin JSON and its benefits. You'll be equipped with the knowledge to import your existing annotations into V7, export your annotations to other formats, and leverage Darwin JSON's flexibility for seamless integration into your computer vision projects.\"}),/*#__PURE__*/t(\"p\",{children:[\"V7 Darwin JSON reference: \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/reference/darwin-jso\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"https://docs.v7labs.com/reference/darwin-jso\"})})]})]});export const richText10=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Our Darwin JSON output format is the most versatile format out of all common computer vision formats.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's have a look at its structure, advantages, and also how to convert your labels to Darwin JSON, so that you can easily import the existing annotations you have created outside of V7.\"}),/*#__PURE__*/e(\"p\",{children:\"Oh, and why not also the other way around?\"}),/*#__PURE__*/e(\"p\",{children:\"The content of each Darwin JSON file can be summarized by the following specifications.\"}),/*#__PURE__*/e(\"p\",{children:\"An export includes all the information about the exported resource. The most important information here is the item and annotations field. The dataset field simply encodes the Darwin dataset name that the resource belongs to.\"}),/*#__PURE__*/e(\"p\",{children:\"The version field will be 2.0 when the export format is Darwin JSON 2.0. The slots field again describes a resource that can be an image or video uploaded to V7, including its original metadata.\"}),/*#__PURE__*/e(\"p\",{children:\"We're dealing with images, this item includes the internal file name of a particular slot on Darwin, the height and width of the image, the URL of the image thumbnail, and a list of the source file's metadata, which itself, contains the name of the original image and its URL.\"}),/*#__PURE__*/e(\"p\",{children:\"A video item contains similar information as an image, since it is just a sequence of images. It also includes the frame rate in which the video has been annotated on Darwin, the number of frames generated from the original video, the URLs of the frames generated from the original video, and the path of the file within Darwin.\"}),/*#__PURE__*/e(\"p\",{children:\"The item field includes information about the referenced resource. That is - the image or video uploaded to Darwin within particular slots.\"}),/*#__PURE__*/e(\"p\",{children:\"This, for example, includes the internal filename of the item on V7 - not of the particular slot, but the entire item that includes the slots.Then we have a list of slots metadata, which includes source information like the dataset and team information that the item belongs to. This includes the URL of the image on Darwin, that routes directly to the Darwin work view.\"}),/*#__PURE__*/e(\"p\",{children:\"Slots are a powerful concept where you can view multiple images or files at once in the V7 UI. These are especially useful, for example, in medical image labeling when dealing with mammography hanging protocols.\"}),/*#__PURE__*/e(\"p\",{children:\"We have a full video on slots, so feel free to check that one out and also look at the documentation.\"}),/*#__PURE__*/e(\"p\",{children:\"Finally, the annotations field actually lists all the annotations created on Darwin for that resource, be it bounding boxes or polygons in images or videos.\"}),/*#__PURE__*/e(\"p\",{children:\"This is how an image annotation is defined. We have an optional list of annotators and reviewers of the image, the annotation class name, a list of the different slot names, and the actual data of the annotation with optional sub-annotation data. A main annotation type simply encodes a string of one of the main annotation types available on Darwin and is used as a key to the actual annotation data.\"}),/*#__PURE__*/e(\"p\",{children:\"Note that a single annotation includes one and only one main annotation type. The annotation data now actually represents the core data of an annotation created on Darwin. Here we have many options to choose from, like bounding boxes, instance ID numbers, polygon paths, and more. For a full-up-to-date definition, please have a look at the amazing documentation.\"}),/*#__PURE__*/e(\"p\",{children:\"The video annotation object is built very similarly and encodes the information of an annotation created on a video in Darwin. It includes all the frame annotation data, but also the annotation class name, and interpolation information, and it may optionally include authorship information. Each frame can now be described as annotation data, but with additional data depending on the way the frame was created on Darwin - for example, manually by an annotator, or programmatically by the interpolation algorithm.\"}),/*#__PURE__*/e(\"p\",{children:\"Outside the annotation data, the only required field for imports in Darwin JSON is the file name. That is what's used for associating the name with the corresponding file in V7 upon import.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, that was a lot.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, let's have a look at how simple it is to convert annotations to and from Darwin JSON - Despite the complexity of the Darwin JSON format.\"}),/*#__PURE__*/e(\"p\",{children:\"Converting from Darwin to another annotation format, as you can see, is really simple. We luckily already have a function that does exactly what we want in the Darwin command line interface function library.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's go ahead and import that dependency and directly get to the function call.\"}),/*#__PURE__*/e(\"p\",{children:\"We need to provide three arguments: the annotation format that we want to convert to, the list of files that we want to convert from Darwin (YOLO in this case), and the output directory where we want to store the annotations or the converted annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"And that's really it.\"}),/*#__PURE__*/e(\"p\",{children:\"Let me just execute the cell. You can see that I have successfully created the converted file in this directory right here. I've already pulled it right out right here and you can see, this is the file in the YOLO format of a bounding box that was stored in the Darwin JSON format.\"}),/*#__PURE__*/e(\"p\",{children:\"It's as simple as that.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's have a look at how to do it the other way around.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, if you want to convert proprietary or your own custom annotation format to Darwin JSON, you will need to write a custom script. But since we know how the Darwin JSON format is defined, we can simply plug in the missing values.\"}),/*#__PURE__*/e(\"p\",{children:\"For example, simply filling in the name of the file, the corresponding dataset, and the team name into the respective item entry.\"}),/*#__PURE__*/e(\"p\",{children:\"When it comes to the actual annotation data, you'll need to write a custom conversion function to convert your format to the respective Darwin definition. If you're looking for a hand when creating those custom conversion scripts, don't forget that there are products like ChatGPT or GitHubCopilot that can do a lot of the legwork for you,\"}),/*#__PURE__*/e(\"p\",{children:\"Bounding boxes require you to specify the height and width of the bounding box. The reference coordinate on the image is the top left corner, so naturally the x and y values for the bounding box are also the leftmost and topmost coordinates. If you want to convert your skeleton annotations to Darwin's definition, you will need to provide a list with all the nodes.\"}),/*#__PURE__*/e(\"p\",{children:\"These nodes include the name of the node, a boolean value that is true when the node is occluded, and the key points.\"}),/*#__PURE__*/e(\"p\",{children:\"For polygons, you will need to simply provide a list with all vertices as we have already seen before. Again, Darwin supports a few such formats. To have a detailed overview of those, have a look at the documentation.\"}),/*#__PURE__*/e(\"p\",{children:\"Great, we're done. You now have a very good understanding of the Darwin JSON format and how to convert your existing annotations to the Darwin JSON format, and vice versa.\"}),/*#__PURE__*/e(\"p\",{children:\"I hope this video helped you with getting started with V7.\"})]});export const richText11=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"During this session, we will guide you through the various methods of uploading data to V7, the all-in-one platform for efficient \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/dataset-management\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"training data management\"})}),\" and AI development. We understand that handling sensitive data or dealing with unique formats like multi-slot files can pose challenges. That's why we are here to assist you every step of the way.\"]}),/*#__PURE__*/e(\"p\",{children:\"Firstly, we will explore V7's user-friendly interface, where you will learn how to effortlessly create datasets and upload images and videos through the intuitive GUI. You can easily connect your dataset to existing workflows or build new ones from scratch without the need for any coding.\"}),/*#__PURE__*/e(\"p\",{children:\"Next, we will introduce you to the command line interface (CLI), demonstrating how to register local data using simple commands. Gain insights into optional arguments for video extraction frame rates, file exclusion, and multiple uploads to enhance your data management experience.\"}),/*#__PURE__*/e(\"p\",{children:\"If your data is stored in an external storage bucket and privacy concerns require it to remain there, we have a dedicated method for you. We will guide you through the process of registering files from an external storage bucket directly into V7 using the REST API. This way, you can annotate your data without it ever leaving your secure storage, ensuring the utmost data privacy and compliance.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you will have a comprehensive understanding of the three different methods for uploading data to V7: UI, CLI, and REST API. Whether you are new to V7 or looking to refine your data management skills, this video will empower you to handle your data efficiently and with confidence. For those dealing with sensitive data or working with multi-slotted items like DICOMs, this video will be particularly valuable, as we address those specific scenarios.\"})]});export const richText12=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Dealing with your own data always comes with challenges, but V7 is here to assist you with all your data management needs. It's always possible to import data to V7 from the UI and command line interface. But, did you know you can also programmatically upload files to V7 using the REST API as part of your data pipeline?\"}),/*#__PURE__*/e(\"p\",{children:\"There\u2019s also no need for data privacy concerns. V7 also enables you to register files from an external storage bucket if your data is for example stored in an AWS S3, GCP, or Azure Blob Storage. This will enable you to annotate your data without it ever leaving your own storage bucket.\"}),/*#__PURE__*/e(\"p\",{children:\"But first, let's have a look at how to upload your data using the UI.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, let's start by creating a new dataset, which is really simple. We'll go ahead and click on this new dataset button. The first thing that we need to do is provide a name. Let's call our dataset \u201CCats\u201D. Now if we continue, we can see that we have the option to click to upload or drag and drop some images in any of our supported file formats.\"}),/*#__PURE__*/e(\"p\",{children:\"Here, we already have the command line interface commands that we'll get to in a second, ready to copy and paste. So let's first go ahead and drag in those three images of those pretty cats, and then continue. Here we can create new classes for our dataset, but for now, let's just skip that. We can now connect a new workflow, either one that you've already created or just a new basic workflow.\"}),/*#__PURE__*/e(\"p\",{children:\"Here in this dataset view, we can already see that all three images have been uploaded. We can click on one of the images and start with the annotation process, but that is not the focus of this video. Now, I've already teased it, but another very simple method of uploading data to V7 is using the command line interface.\"}),/*#__PURE__*/e(\"p\",{children:\"To do so, we use the Darwin dataset push command. We then specify to which team and dataset we want to upload the data and we provide the path to the locally stored data. The optional path argument can be used to upload files into a specified directory. However, if you want to just copy over your own directory structure, you can add a \u201Cp argument\u201D to your command and you'll see the folders mirrored within the dataset in V7.\"}),/*#__PURE__*/e(\"p\",{children:\"When dealing with videos, you can optionally specify the extraction rate by adding the \u201Cfps\u201D argument. When leaving this argument out, you would use the intrinsic frame rate of the video. Finally, to indicate file extensions that are to be ignored from being uploaded, you can use the optional \u201Cexclude\u201D argument.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, that was easy.\"}),/*#__PURE__*/e(\"p\",{children:\"We can also upload images from our local storage using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, let's look at the code and start with the import. Since we're using the REST API, the only import that we really need is the requests library. I also imported my API key which is stored in a separate file, so I just don't have to show you what my API key is.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, then let's get to step 0. Which data do we want to register or upload. Here I just manually specify the paths to the two images that I want to upload, but you can of course loop over your whole directory and collect the paths that way. Then, I also create a dictionary with the file names as the key and the file paths as the value, to easier iterate the images and automate the whole uploading process.\"}),/*#__PURE__*/e(\"p\",{children:\"In the end, I will have this little dictionary right here, which has, the name as the key, and the path as the value.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we can get to the actual step one. We need to register the data to V7 - we tell V7 how many images we want to upload, and what their names are.\"}),/*#__PURE__*/e(\"p\",{children:\"So, for that, let's construct our message that we want to send using a post request. So, the first thing that we need to specify is, of course, the URL. For that, you always have the same URL, but you always need to provide the team slug, the slugified team name and the slugified dataset name.\"}),/*#__PURE__*/e(\"p\",{children:\"If you're not familiar with the term slugified, take a look at the documentation and everything should be clear.\"}),/*#__PURE__*/e(\"p\",{children:\"So after plugging in the team slug into the url, we can get to constructing the actual payload of the message. We can now iterate over all the items. That's why I've created this nice little dictionary. We then append a list with the following messages or information. We'll have the slots key and we'll here pretty much only need to provide the filename and again have to provide the filename a second time.\"}),/*#__PURE__*/e(\"p\",{children:\"This list of all slots will then be added to the payload in the items key and in the payload itself - \\xa0we also only need to provide the dataset slot to just know which dataset we want to upload our items to.\"}),/*#__PURE__*/e(\"p\",{children:\"The payload will pretty much always be the same. We want to specify what type of data we accept as a response, with what type of data we are working with, and of course the API key for authorization.\"}),/*#__PURE__*/e(\"p\",{children:\"After that is done, we can post our payload to the URL including the header. If we look at the response, we can see that we have a list of all items. All items have a specific ID - we can see the name. M\"}),/*#__PURE__*/e(\"p\",{children:\"Most importantly, we can see that we have an upload ID for each item. This is important because this is our registration ID that we will then use to sign our upload, to upload the data, and then confirm it.\"}),/*#__PURE__*/e(\"p\",{children:\"So, from this response, we want to extract those upload IDs. This is what we are doing in this little loop right here.\"}),/*#__PURE__*/e(\"p\",{children:\"So let me quickly just execute the cell.\"}),/*#__PURE__*/e(\"p\",{children:\"You know what? Let's just go ahead and also look at this dictionary. We can see that we have our upload ID as the key corresponding to one certain path.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we can get to steps 2, 3, and 4, which are pretty much things that you need to do for every single image or item that you want to upload.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, let's have a look at what this is.\"}),/*#__PURE__*/e(\"p\",{children:\"So for every upload ID, we have now registered our data. V7 knows which items we want to upload, what they are called and how many.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we need to sign the upload and store the upload URL to then upload the data or the file using this URL for the specific item. After this one specific item has been uploaded, we need to confirm this one upload. This needs to be done for every single item. That's why we loop over all of those upload IDs, which are necessary or corresponding to one specific item.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, that might have been a bit fast, so let's have a look at the code in a bit more detail.\"}),/*#__PURE__*/e(\"p\",{children:\"Step number two. We first need to sign our upload. So what we have again done is that we have registered that we want to upload two files. We have received a specific upload ID for every single file.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we want to sign this one item using this upload ID. We are going item by item. Then with the response that we get, we want to extract the actual upload URL. So we are signing one item that we have registered, and we have got permission to upload the data to this specific URL which we are going to extract.\"}),/*#__PURE__*/e(\"p\",{children:\"In step three, we are going to read this one file, this one image, and then upload it using the URL that this image has been assigned. So this is one simple PUT request to the URL and the data is, again, the image. With this response, we will just have a look when uploading it.\"}),/*#__PURE__*/e(\"p\",{children:\"Then we pretty much already done. We now simply need to confirm the upload where we just have one specific URL that we need to send a message towards, which again needs our slugified team name and the upload ID. We want to see if this one specific upload or this one image with the corresponding upload ID has been uploaded successfully.\"}),/*#__PURE__*/e(\"p\",{children:\"This is really important, you need to do that.\"}),/*#__PURE__*/e(\"p\",{children:\"We can see that all the responses were successful, and let's see in the UI if we have successfully uploaded our data. Here it is, Cat4 and Cat5 have been successfully uploaded. Now, that's already pretty cool, but you can also use V7's Slots feature to upload multiple images or files into one item.\"}),/*#__PURE__*/e(\"p\",{children:\"The most common use case that we see this feature used for is mammography hanging protocols. However, slots can be used to display any pair or group of files on screen, at once. For more information on that, please refer to the documentation.\"}),/*#__PURE__*/e(\"p\",{children:\"That wasn't too bad, was it?\"}),/*#__PURE__*/e(\"p\",{children:\"However, if you're dealing with sensitive data, uploading those images to V7 might not be an option for you.\"}),/*#__PURE__*/e(\"p\",{children:\"That's why we offer you a solution to connect your external storage bucket and register the images to V7 so that Darwin simply knows where to access the images in your own external storage. That means your data never leaves your trustworthy storage. So let's have a look at how you can register your bucket and your files.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, let's start with the first step of registering your data from external storage: configuring the storage bucket. Doing that is really simple.\"}),/*#__PURE__*/e(\"p\",{children:\"We first need to go to our settings and then click on our storage tab. Here, we can here now add a new storage integration.\"}),/*#__PURE__*/e(\"p\",{children:\"We then need to select the provider, in this case, let's just go with AWS S3, and we can select a name for our storage bucket. This is the name that we can define ourselves that is then used in V7 itself. The actual S3 bucket name is then provided right here.\"}),/*#__PURE__*/e(\"p\",{children:\"Optionally, you can also provide the prefix to the data - for example, when your images or files are stored in a certain directory in your bucket.\"}),/*#__PURE__*/e(\"p\",{children:\"We then of course also specify the region that we are in, let's say we are in EU North. We can then specify if we only want to have read-only access, and that's it - we can save our configuration.\"}),/*#__PURE__*/e(\"p\",{children:\"After the external bucket is ready, and you have populated it with images, you need to notify Darwin which images you want to list, and for which dataset they are.\"}),/*#__PURE__*/e(\"p\",{children:\"This is done via a REST PUT request. If we look at the code for registering files from your external bucket, the code is pretty similar to the just discussed code for uploading images to V7 from local storage.\"}),/*#__PURE__*/e(\"p\",{children:\"We again need to authenticate ourselves using our API key. We also need to provide our team and dataset names.\"}),/*#__PURE__*/e(\"p\",{children:\"This time we also need our storage bucket name and our header section is the same. In the payload, we now list all items that we want to register.\"}),/*#__PURE__*/e(\"p\",{children:\"The path argument tells us in what directory V7 will display the items in the UI. The name argument is the name of the file that you want to register from your storage, including its extension.\"}),/*#__PURE__*/e(\"p\",{children:\"The as_frames argument is a boolean value denoting whether you want a video to be registered as a video or as frames. We here provide the name of the slot. We have a whole separate video on slots, so feel free to look at that or read the documentation. If you only have one item in an image, then you can just enter this value as 0.\"}),/*#__PURE__*/e(\"p\",{children:\"The storage key is the path to your file in your storage container. For example, you have a folder called \u201Ccar\u201D, and there you have one image called \u201Ccars\u201D. The file name is the name of the file in a particular slot. Note, that this will only be relevant to those with multi-slotted items, such as hanging DICOMs.\"}),/*#__PURE__*/e(\"p\",{children:\"Of course, we again need to add which dataset we want to register the files to. We also need to provide the name of the bucket we want to be using.\"}),/*#__PURE__*/e(\"p\",{children:\"That's it!\"}),/*#__PURE__*/e(\"p\",{children:\"You can add more files in the same structure to this list of items. You can automatically generate the payload with multiple items by looping through all items in your own directory and appending them to the list, given the just discussed syntax.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, dealing with videos and read-only access storage is handled very similarly, just with tiny tweaks. Feel free to look at the documentation.\"}),/*#__PURE__*/e(\"p\",{children:\"After watching this video, you should be equipped with the most important skills.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we're done. You now know how to upload your own locally stored data to V7 using the UI, command line interface, and also using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"If you don't want your data to leave your storage buckets, you now also know how to register this data, again using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, I hope this video helped you with getting started with V7.\"})]});export const richText13=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we tackle Exports and outline the step-by-step process to leveraging Exports within Darwin. Ready for something a bit more detailed? Head to our Darwin Advanced session on Exports.\"}),/*#__PURE__*/t(\"p\",{children:[\"Darwin Users can leverage the dataset versioning model, which is a powerful tool for managing and exporting datasets in 2D computer vision projects. This tutorial begins with an explanation of how to navigate to the export function, how to create a \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/docs/create-an-export-version\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"dataset version\"})}),\", and the formats available for version formats (including JSON, COCO, VOC, and more).\"]}),/*#__PURE__*/e(\"p\",{children:\"The tutorial also goes into detail on filters you can apply to your Exports, including exporting based on annotation class, annotator/reviewer metadata, and exporting explicitly selected images.\"}),/*#__PURE__*/e(\"p\",{children:\"Finally, we touch on some of the collaborative opportunities that can come with Exports, such as the Export Token - which gives permission to anyone with the export file, regardless of whether they have a V7 account or not, to download the corresponding image for each annotation.\"}),/*#__PURE__*/t(\"p\",{children:[\"For products seeking FDA or HIPAA compliance, you\u2019ll need to be particularly mindful of how you approach Exports. You can read more about V7\u2019s commitment to \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/terms/security\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"security standards here\"})}),\", and dive into detail of our approach to \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/news/v7-is-now-fda-part-11-compliant\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"FDA compliance here\"})}),\".\"]}),/*#__PURE__*/t(\"p\",{children:[\"With this tutorial, you\u2019ll come away with a clear understanding of how to handle Exports - whether you\u2019re tackling research or creating FDA-focused solutions. For those looking to go a little further, developers and data scientists can also explore our \",/*#__PURE__*/e(a,{href:\"https://docs.v7labs.com/\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Darwin documentation\"})}),\", which includes commands for listing and downloading Exports.\"]})]});export const richText14=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Press the export button on the top right to bring up the dataset versioning model. This will list all the available export versions for this dataset. You can download any of these locally or click on a version name to copy a CLI command to your clipboard. If you're new to Darwin, you probably haven't created one yet, so let's make one.\"}),/*#__PURE__*/e(\"p\",{children:\"Start by giving it a name and then we'll pick a format. Darwin supports many of these like popular formats like Coco XML formats from inferior labeling tools like C V A T. A versatile Darwin JS format that resembles the coco format with se added features, a Darwin xml Pascal VAK for the old school, as well as semantic masks and p and g and instance masks following the open images standard.\"}),/*#__PURE__*/e(\"p\",{children:\"By default, Darwin will only prompt you to export completed images, but you can also choose selected images to export images that may be incomplete or perhaps archived. You can also add class filters to exports. For example, only export the car class and leave out any others. You can choose to include annotator metadata to the export files, which will include the first name, last name, and username of the people who created the labels in this data set.\"}),/*#__PURE__*/e(\"p\",{children:\"This means each label with an adjacent or XML file will have a named author. This is very important if you're working in the medical field, for example, and want to seek F D a approval for your algorithms one day. Finally, you can add an export token to each export file. This will allow anyone with the export file, whether they have an account with V seven or not, to download the image that corresponds to each annotation.\"}),/*#__PURE__*/e(\"p\",{children:\"This is very useful if you're collaborating with external parties or when to publish your data set. However, this will leave your images unencrypted, so do not select this option if you need to abide to encryption rules such as HIPAAs. All of these export versions are also available within open data sets.\"}),/*#__PURE__*/e(\"p\",{children:\"You can make a data set open from the setting tab, and it's a great way to share your research with the world and give any visitor a graphical user interface to browse and filter your data set. For developers and data scientists, there is a lot more that you can do with Darwin exports by visiting the Darwin PI documentation, there are commands to list exports.\"}),/*#__PURE__*/e(\"p\",{children:\"Download them locally. As well as bindings for PyTorch to load data into Torch Vision or detect run two. Make sure to give those a look. And don't forget to star us on GitHub.\"})]});export const richText15=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"In this session, we will walk you through the process of registering and running inference on your own models in V7. Our recent Bring Your Own Model (BYOM) update has made it easier than ever to \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/product-update/register-external-models\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"register external models\"})}),\" with just a few clicks, unlocking a world of possibilities for your AI projects.\"]}),/*#__PURE__*/t(\"p\",{children:[\"External models can be a game-changer, helping you accelerate your work or solve industry-specific challenges. For instance, if you require a tool for segmenting pieces of clothing, you can utilize an existing third-party \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/blog/instance-segmentation-guide\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"instance segmentation\"})}),\" model that has been fine-tuned specifically for clothing items.\"]}),/*#__PURE__*/e(\"p\",{children:\"To get started, we'll provide an overview of the setup, followed by a detailed explanation of the Darwin JSON structure and how request processing works. We will then guide you step-by-step through the process of registering an endpoint, setting up the web app, deploying the model, and finally, connecting and testing the model.\"}),/*#__PURE__*/e(\"p\",{children:\"With the BYOM feature, you have the freedom to register custom models and integrate them seamlessly into V7. You can also leverage open-source models or connect with public models available online on platforms like Hugging Face. This flexibility empowers you to tailor your AI workflows to meet your specific requirements and harness the power of diverse AI models. It's worth noting that when using models hosted on Hugging Face, the process becomes even simpler. You can easily add the inference URL and upload a test photo to capture the response and map your classes.\"}),/*#__PURE__*/t(\"p\",{children:[\"Link to the model used in the tutorial: \",/*#__PURE__*/e(a,{href:\"https://huggingface.co/facebook/detr-resnet-50\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"DETR (End-to-End Object Detection)\"})})]})]});export const richText16=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"There are so many different open source models or ones which you have trained yourself that can assist you with labeling further data.\"}),/*#__PURE__*/e(\"p\",{children:\"What does that mean? And how does it work?\"}),/*#__PURE__*/e(\"p\",{children:\"Well, in this video, I'll show you how to register and run inference on such a model in V7's Darwin via the UI in just a few clicks.\"}),/*#__PURE__*/e(\"p\",{children:\"What this allows you to do is get instant access to open-source models and map their output classes to V7 labels, connect V7 workflows with your own image processing models to automate complex tasks, and enhance the auto annotate tool with custom models to tackle unique challenges.\"}),/*#__PURE__*/e(\"p\",{children:\"Ultimately this will help you develop better models faster and leverage humans in the loop a lot more effectively.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, on a high level, what will we be doing? Our register external model feature allows you to set up an HTTP endpoint address and authentication method. You can also specify the output classes to be extracted from the JSON responses and map them as V7 annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"To leverage those external models in V7, we will configure an inference endpoint for any AI model that is hosted online and meets minimal requirements.\"}),/*#__PURE__*/e(\"p\",{children:\"This extends to services such as AWS, Azure, Google Cloud, and other servers that accept and respond to web requests via the HTTP protocol. In the near future, integration with Hugging Face models directly will also be supported.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's go into a bit more detail. How this works is that V7 sends a JSON payload using the POST method to a specific inference endpoint. This JSON includes information such as the image URL, along with an authentication token and additional parameters, such as the coordinates of the image area outlined with the auto annotate box.\"}),/*#__PURE__*/e(\"p\",{children:\"This JSON payload example is sent to our registered inference endpoint when we send an image to the model stage with the external model connected. Note that there are no additional parameters.\"}),/*#__PURE__*/e(\"p\",{children:\"The contents of this JSON file can now be processed by our web app, for example, a Flask server to extract the image or its relevant area.Then the image can be processed by our AI model and our web app can send a response. Our response will then look something like this and will automatically, for example, add a bounding box annotation to the area where a face was detected.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's get practical. You can use an external model in V7 via the following four steps.\"}),/*#__PURE__*/e(\"p\",{children:\"First, set up your server or app to accept HTTP requests. Then, ensure that your requests and responses conform to the Darwin JSON format. We actually have a very useful full video on our Darwin JSON format which you can take a look at.\"}),/*#__PURE__*/e(\"p\",{children:\"With that, you can now register your external model's endpoint in the model page and finally use the model as a workflow stage or via auto annotate.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, let's walk through this together.\"}),/*#__PURE__*/e(\"p\",{children:\"Step 1. Register a new external model. Go to the models panel and click the register external model button. You can change the endpoint URL address, classes, and name of your external model at any time. Therefore, it makes sense to register the model from the start, even if it's not active yet.\"}),/*#__PURE__*/e(\"p\",{children:\"Also, you can set up a temporary endpoint to capture your HTTP requests. This may be useful as a starting point for coding your app for handling the model.\"}),/*#__PURE__*/e(\"p\",{children:\"I'm going to use a hugging face object detection model with the ResNet backbone on some images of traffic lights. A link to the model is in the description.\"}),/*#__PURE__*/e(\"p\",{children:\"I got the model API, again, through HuggingFace, and I will use it in my Python code that will run the whole logic. To familiarize yourself with the way V7 sends requests, you can use popular tools like RackBin or Insomnia for experimentation.\"}),/*#__PURE__*/e(\"p\",{children:\"Step 2. Prepare your web application and define the necessary functions.\"}),/*#__PURE__*/e(\"p\",{children:\"This is probably the most complicated part, but after walking through it together, you'll see that it really isn't that bad. Of course, the level of complexity may vary depending on the framework you use. However, your application should achieve the following:\"}),/*#__PURE__*/e(\"p\",{children:\"Set up a web application, such as a Flask app. Define an endpoint in the app to receive incoming data, for example, \u201C/infer\u201D. Configure the endpoints to handle post requests. Retrieve the incoming data, which as mentioned will be in the form of a JSON payload. Extract the image data from the JSON. Implement the necessary logic to analyze the image with your AI model.\"}),/*#__PURE__*/e(\"p\",{children:\"In this hugging face example, this includes adding the API token to the message header and calling the model via the API while providing the image data.\"}),/*#__PURE__*/e(\"p\",{children:\"Then convert the annotations from the HuggingFace response format to the Darwin JSON format. Finally, have your app return those results to V7.\"}),/*#__PURE__*/e(\"p\",{children:\"In our example here, we want to detect traffic lights.\"}),/*#__PURE__*/e(\"p\",{children:\"A response JSON object is prepared depending on whether a traffic light is detected or not. The object includes the confidence, label, name, and bounding box coordinates.\"}),/*#__PURE__*/e(\"p\",{children:\"Next up, step three, deploy your model using a solution that accepts HTTP requests.\"}),/*#__PURE__*/e(\"p\",{children:\"There are multiple deployment options available for your model, including cloud platforms like Azure and AWS, as well as platforms such as Heroku.\"}),/*#__PURE__*/e(\"p\",{children:\"In our example, we'll simply use a free tier ec2 Ubuntu instance on Amazon Web Services for deployment. This instance enables you to create a public IPv4 address that can serve as the endpoint for the deployed model. Just add \u201C/infer\u201D or whatever URL you used in the previous step to access the model.\"}),/*#__PURE__*/e(\"p\",{children:\"The deployment setup is based on Flask, Gunicorn, and Nginx. By combining these three core libraries, you can establish a reliable and scalable deployment infrastructure for your model. Flask enables the development of the API for our model. Gunicorn effectively manages concurrent requests and Nginx acts as a gateway, ensuring proper routing of requests to the Gunicorn server.\"}),/*#__PURE__*/e(\"p\",{children:\"Finally, step four, setting up the correct endpoint address and testing the model. After deploying your web application, update the endpoint address as shown here on the left-hand side. Classes can now be registered manually through the register classes section on the right-hand side. Now you can finally add a new model stage in your workflow.\"}),/*#__PURE__*/e(\"p\",{children:\"Connect your external model and map the output classes. You can now navigate to your dataset and send several images to the model. If everything went correctly, they should pass to the model stage and then to the review stage. almost immediately. Here you can review the results and any potential errors or issues encountered during the analysis.\"}),/*#__PURE__*/e(\"p\",{children:\"And done!\"}),/*#__PURE__*/e(\"p\",{children:\"That wasn't too difficult, was it?\"}),/*#__PURE__*/e(\"p\",{children:\"Let's again go over why this is particularly useful.\"}),/*#__PURE__*/e(\"p\",{children:\"You get direct access to open-source models: You can solve tasks such as pose estimation with OpenPose, or use external libraries for facial landmark detection. While models trained on V7 are perfect for classification, object detection, and instance segmentation tasks, you can leverage the power of external models to expand on those capabilities.\"}),/*#__PURE__*/e(\"p\",{children:\"Easier benchmarking and model performance testing: Running an external model, for example, as shown as a Flask-based app, allows you to collect more information and generate additional logs for your models and their interactions with your dataset. You can also connect multiple external models using a consensus stage and compare their level of overlap.\"}),/*#__PURE__*/e(\"p\",{children:\"Additionally, you can use models across multiple V7 teams. Since models trained and deployed with V7 use the same JSON structure, it is extremely easy to connect models and use them across multiple accounts. This can be useful if you need to discuss an experiment with solutions and use cases.\"}),/*#__PURE__*/e(\"p\",{children:\"The ability to connect V7 native models with just a few clicks can be helpful for troubleshooting and finding the best solutions for your use case.\"}),/*#__PURE__*/e(\"p\",{children:\"That was it. Using your own models has never been easier with V7.\"}),/*#__PURE__*/e(\"p\",{children:\"We're excited to see what you build using V7.\"})]});export const richText17=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"Without Folders in place - particularly for large, sprawling enterprises - your data will become increasingly difficult to manage. In this Darwin Fundamentals session, we tackle Folders, and outline how you can use them to simplify and \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/dataset-management\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"categorize your datasets\"})}),\".\"]}),/*#__PURE__*/e(\"p\",{children:\"For teams frequently annotating thousand of datasets, a clean and organized approach to data is paramount to success. That\u2019s why Folders are a particularly useful feature within V7\u2019s Darwin, allowing you to easily organize, manage, and navigate through your data.\"}),/*#__PURE__*/e(\"p\",{children:\"We tackle how to create new folders, how to add data to these folders, and how to \u201Cnest\u201D folders inside other folders to create a directory structure.\"}),/*#__PURE__*/e(\"p\",{children:\"We also showcase how to toggle Folders on and off as a view, to allow Users to easily switch between seeing all images and videos together or filtering based on folder organization.\"}),/*#__PURE__*/t(\"p\",{children:[\"Finally, we outline what Folders can, and can\u2019t do - including the fact that your Folders will have no impact on Exports and will not restrict annotators from \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/image-annotation\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"labeling images\"})}),\" within them.\"]}),/*#__PURE__*/e(\"p\",{children:\"You\u2019ll come away from this video with a detailed understanding of how to create a well-structured dataset to enhance your annotation and classification workflows. With this feature, you\u2019ll understand how to seamlessly manage data, making image and annotation tasks more streamlined in the process.\"})]});export const richText18=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Press the folder icon on the top right to activate a direct review. You won't just be seeing images and video. Now, you'll also see folders. Click on an image or video or shifts. Click to select more than one and press the add to folder button at the bottom to create a new folder. Simply type whatever you want to name it and press this folder icon or enter the images you had selected will now be there. You can also nest folders inside of other folders. To create a directory structure, just select images from anywhere on the dataset. It doesn't have to be from a parent folder. You can help yourself by making the icons bigger and selecting the images you need. Then again, add to folder.\"}),/*#__PURE__*/e(\"p\",{children:\"This time we will type in a path burger slash fries. This will create a fries folder inside the burger folder. If the burger folder didn't exist beforehand, it would've created one. You can view the nested structure of your folder by clicking on the add to folder button. Clicking on any of these entries will add your images to them.\"}),/*#__PURE__*/e(\"p\",{children:\"You can also send images back to the root directory by clicking on the top. Entry. Folders can be toggled on and off as a view, so if you prefer see all images and video at the same time and filter from there. You can always turn this off. It's a handy feature to replicate the directory structure of legacy data sets or to organize data with labels that wouldn't serve classification purposes, such as camera views or batches.\"}),/*#__PURE__*/e(\"p\",{children:\"And you can always use them to bundle data and classify it from there. Note that folders don't affect your exports in any way, nor do they prevent annotators from labeling images within them.\"})]});export const richText19=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we tackle Images Statuses within the V7 platform. We address the importance of Image Statuses, explain what each one means, and underline how to use Image Statuses to effectively manage your data quality.\"}),/*#__PURE__*/t(\"p\",{children:[\"This tutorial begins with a breakdown of the four progress statuses for images in V7: uploading, new, annotate, and review. We also address the three potential end states: complete, discarded, and error. You can use these statuses as filters for your \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/dataset-management\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"dataset management\"})}),\", to ensure only necessary images are exported and browsed depending on their status.\"]}),/*#__PURE__*/e(\"p\",{children:\"Getting into detail, this video demonstrates a step-by-step process for understanding Image Statuses, from exploring the platform timeline (indicating the status and next stage of images), the function of the \u201Cprogress\u201D button, and how the in-built timer works. It also tackles how to leverage the annotate and review stages (to allow images to be assigned to specific individuals) and acknowledges the many status lifecycles an image can go through in the process.\"}),/*#__PURE__*/e(\"p\",{children:\"You\u2019ll come away with a clear understanding of Image Statuses, what each one means, and how to use them to create a data management process that ensures the quality and accuracy of annotated images.\"})]});export const richText20=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Statuses are made to keep track of your image data's quality. There are four progress statuses, uploading, new, annotate, and review, and three potential end states, complete, discarded, and in some cases error. These statuses can be used as filters in dataset management to make sure you're only exporting images you need, or to browse images pending review, like this one.\"}),/*#__PURE__*/e(\"p\",{children:\"On the top, we notice a timeline that indicates the current status of the image. On the top right, the progress button shows us the next stage that it will go to. Pressing this button will progress this image from In Review to Complete, and take us to the next one. When we send an image to the next stage, a timer starts.\"}),/*#__PURE__*/e(\"p\",{children:\"This gives us a time span of 30 seconds before this image's status is officially changed, in case we want to change our decision. Once elapsed, this image becomes officially complete. It is immutable, and only an admin can change its status. Within the annotate and review status, an image may also be assigned to a person.\"}),/*#__PURE__*/e(\"p\",{children:\"If I select these images pending review and assign them to a user on my team, their avatar will appear within the yellow circle of the review status. New images are considered such because they've never been assigned to anyone and contain no annotations. Finally, archived images have been discarded either during review or by an admin.\"}),/*#__PURE__*/e(\"p\",{children:\"Depending on your workflow, your images may go through many statuses. From new to annotated, to in review, and back to annotated, and finally to complete.\"})]});export const richText21=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we tackle Instance Tracking IDs, which play a crucial role in providing object permanence in 2D computer vision. We explore what they mean, how they work, and why they\u2019re so important to your development process.\"}),/*#__PURE__*/t(\"p\",{children:[\"We start the process with an explanation of Tracking IDs, through the use of an in-process dataset featuring a motorcycle. Here, we demonstrate the process of labeling and creating \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/image-annotation\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"auto annotations\"})}),\" within the image, across a series of frames. Through the use of the Instance Tracking ID function, we explain how you can manually edit IDs to ensure tracking is accurate across each of these frames.\"]}),/*#__PURE__*/t(\"p\",{children:[\"Want to know a bit more about annotation methods within V7? Dive into our Darwin Fundamentals session on \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy/annotations-getting-started\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"annotation methods\"})}),\".\"]}),/*#__PURE__*/e(\"p\",{children:\"Next, we touch on an interesting feature of Instance Tracking IDs: Chroma Hashing. Chroma Hashing allows you to assign a unique combination of colors to each Tracking ID, to allow you to easily recognize and make comparisons across a large set of ID values. Similarly, Users can copy annotations and sub-annotations between frames, making the tracking of moving objects easy and efficient.\"}),/*#__PURE__*/e(\"p\",{children:\"To fuel your development even further, we include a helpful breakdown of platform shortcuts for annotation manipulation, allowing you to streamline and optimize your development pipeline.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you\u2019ll have a comprehensive understanding of Instance Tracking IDs, how they impact object tracking in computer vision projects, and how to leverage them for your own projects.\"})]});export const richText22=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"Instance IDs or tracking IDs help give machines some degree of object permanence. Imagine you have an object and you need to make sure your model knows that it's the same object throughout different frames as it moves around. Or imagine this object is visible by multiple cameras at the same time.\"}),/*#__PURE__*/e(\"p\",{children:\"This is where Instance IDs do their part. Let's take a look at this picture. Suddenly there's a moped driving through. We're going to label this and create an auto annotation around it. We're going to be adding the points that are missing from it until the annotation is complete. You can notice that it's been given the ID number three. Move to the next image, and the moped has driven forward, so we're going to create another annotation around it and once complete we'll notice that the ID given to it is actually number four. This is because it's a brand new annotation and the system doesn't yet know that it's the same motorcycle. After completing this annotation, though, we can amend this. By hovering over the cent, we can notice that there is an ID button here. We can click it and edit this number to any value we wish.\"}),/*#__PURE__*/e(\"p\",{children:\"In this case, we'll set it back to three. You'll also notice that these IDs have a unique combination of three colors. This is called chroma hashing. It allows us to present the number with a set of colors that is entirely unique up to 999 billion. It's particularly useful if IDs start to become huge numbers such as this one.\"}),/*#__PURE__*/e(\"p\",{children:\"And it's going to be easier to compare them by color than by a massive value. Going back to our annotation, we'll switch to the next frame and notice that the moped has driven even forward. We'll press the copy instance button on the right and this will copy over annotations and their sub annotations. In this case, the instance ID we will press the edit auto annotate button to change the shapes boundaries, and reset it to the new location and scale of the moped.\"}),/*#__PURE__*/e(\"p\",{children:\"We will also press the clear button to get rid of those previous clicks, and it will adapt to its new shape. The shortcut for this is M right next to the N button for auto annotate. And before switching to the next image, here's a quick tip. You can press this button to lock the zoom into position so that when you switch images using the period and comma button.\"}),/*#__PURE__*/e(\"p\",{children:\"The zooming level and position of the camera will stay the same. This way we can track our friend on the moped and create yet another annotation by copying instances, moving it to his new location, and then pressing the M key or the edit auto annotate button. We'll resize this, and every time a resize is done, Auto annotate will readjust itself to the new shape.\"}),/*#__PURE__*/e(\"p\",{children:\"Bear in mind that every annotation carries with itself the auto annotate box around the centroid, so wherever you move around, it will carry the clicks and auto annotate settings with it. Let's say we forgotten this case to copy over the annotations. Instead we created a new one. We could edit the figure manually, but if it is a particularly large one, we can simply go back one image.\"}),/*#__PURE__*/e(\"p\",{children:\"Control C to copy or Command C on a Mac and then paste it using Shift control V or Shift Command V on a Mac. This is the paste sub annotation shortcut, which will allow you to paste the instance ID only in this case and would also paste attributes if they were present on the image. Finally, as our friend drives away, we can continue to copy instances, move the annotation and restart auto annotate to fit a polygon to the new shape.\"}),/*#__PURE__*/e(\"p\",{children:\"By simply adjusting the box or moving it in cases where there is only a translation and not a change in scale. If you're watching this video past July, 2020, much of this work can also be automated using auto complete. You can refer to the tutorial and auto complete in the description of this video or the sidebar to the right.\"}),/*#__PURE__*/e(\"p\",{children:\"You can activate instance IDs at any point by editing a class settings, and you'll find an object's instance ID within the export of every annotation.\"})]});export const richText23=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this session, we are exploring the process of training and utilizing your own models in V7, the MLOps platform designed for efficient AI product development. Custom models provide you with the ability to develop AI solutions that can effortlessly handle any computer vision task, whether it involves image classification, object detection, or instance segmentation.\"}),/*#__PURE__*/t(\"p\",{children:[\"To get started, we will guide you through the models tab in V7, where you can initiate the training process. We will explain the distinctions between various \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/model-management\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"computer vision models\"})}),\", highlighting the advantages and use cases of each type. For the purpose of this video, we will specifically focus on training an instance segmentation model for bird species detection.\"]}),/*#__PURE__*/e(\"p\",{children:\"You will learn the significance of having an adequate number of labeled instances for each class in your dataset, as this greatly impacts the performance of the model. With just 100 labeled instances, you can train a dependable custom model to assist with various tasks such as data labeling, quality testing, and even for production use via the V7 API.\"}),/*#__PURE__*/e(\"p\",{children:\"We will walk you through the training process step by step. Once the training is complete, we will demonstrate how to deploy the model with a simple click. Moreover, we will delve into how you can integrate your model with your Python script using V7's REST API. With just a few lines of code, you can submit an image to the model and receive predictions for the detected objects, along with their labels and instance segmentation.\"}),/*#__PURE__*/e(\"p\",{children:\"Whether you are new to V7 or an experienced user, this video will empower you to harness the full potential of custom models to expedite your AI projects and streamline your data annotation process.\"})]});export const richText24=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"You can train models in V7 with as few as 100 labeled instances. These models can then be used to help label additional data, test labeling quality and quantity, and can be used in production by calling them via the API. Or, you can use one of the already trained models for tasks like document scanning.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, that sounds like a lot, but let me show you how easy it is to train and use a model with V7.\"}),/*#__PURE__*/e(\"p\",{children:\"To train a model we first need to go to the models tab. Here we can click on this train a model button and are already introduced to the first decision that we need to make. Here we have the option to train an instance segmentation model, an object detection model, or a simple classification model.\"}),/*#__PURE__*/e(\"p\",{children:\"Classification models just provide a certain tag to one frame or one image that it sees, like in this specific example. It sees an image, or in this case, multiple frames, and can associate a class label to it.\"}),/*#__PURE__*/e(\"p\",{children:\"Object detection models can provide bounding boxes to certain items, but those bounding boxes are not the most accurate representation or not the most accurate annotation. You have some dead space that the bounding box cannot cover correctly.\"}),/*#__PURE__*/e(\"p\",{children:\"Therefore, we have instance segmentation models that have polygon shapes and can mold around every single item we want to detect. It has the highest accuracy in general.\"}),/*#__PURE__*/e(\"p\",{children:\"Since we have the options of those three, let's go ahead and select an instance segmentation model and call it \u201Cbird species\u201D because we will want to train a model that can detect different bird species. As mentioned, the model that we're going to train is one that can detect bird species and we can already see here which class we have in this specific dataset and how many instances we have of those annotations.\"}),/*#__PURE__*/e(\"p\",{children:\"To have a pretty decently performing model you want at least 100 instances per class. The data amount and data quality will pretty much be the bottleneck of the performance of your model.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, since we have selected our dataset and chosen which class we want to include, we could potentially just train our model on European Robins and Nightingales, but we'll go ahead and train on all three of the classes. We can just continue. Now we are already at the point where we can just click start training and the model will automatically be trained and will take up to three hours because our dataset is pretty large.\"}),/*#__PURE__*/e(\"p\",{children:\"In this case, we'll again have a split in machine learning, we want to usually have a training, validation, and testing split to reduce overfitting. The split that they will be using is an 80-10-10 split. So 80% of the training area of the data that we have will be used for training. 10% will be used for the validation set and 10% will be used for the testing set.\"}),/*#__PURE__*/e(\"p\",{children:\"Let me just go ahead and start the training and we'll see each other when the training is done.\"}),/*#__PURE__*/e(\"p\",{children:\"The training really just took 45 minutes and we can go ahead and start the model. We can deploy it and it's as simple as just pressing one button to start the model.\"}),/*#__PURE__*/e(\"p\",{children:\"Here we can specify some parameters. How many handles do we want to have per minute? What will the performance be? How much throughput do we need? Then some parameters where we can start the model when it receives a request, and stop it when it is idle.\"}),/*#__PURE__*/e(\"p\",{children:\"It will cost 0. 03 credits per minute, which is really not that much. And let's just go ahead and start our model. And that's it!\"}),/*#__PURE__*/e(\"p\",{children:\"Our model is now up and running.\"}),/*#__PURE__*/e(\"p\",{children:\"We can click on our model and look at some metrics. We can see that we have a 95% mean average precision score, which is really good. We can see how our loss progressed during the training and our model performs really well. We can also on this page how to integrate the model into our Python script, which we will be looking at in a second.\"}),/*#__PURE__*/e(\"p\",{children:\"Our model is up and running. Now, at this point, you could just drag in an example image and have a look at the prediction that your model would return. You could look at the predicted segmentation map overlaid over your example image, but let's implement that ourselves and look at how we would call this model using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, since we're using the REST API to get our predictions from our model that is running on V7, we only really need to import our requests library. We also need to provide the API key that I stored in a separate file so that you can't see what my API key is. We also need the URL through which we will access our model.\"}),/*#__PURE__*/e(\"p\",{children:\"If you're wondering where I got this URL from, you can just go to your model card and when going to Python for example, you'll see here that you can find the URL itself. Everything that you really need is directly in this model card. So let's just go ahead and run this cell and progress with the code.\"}),/*#__PURE__*/e(\"p\",{children:\"Again, the first step that we want to do is we'll get one example image.\"}),/*#__PURE__*/e(\"p\",{children:\"Why am I doing this base encoding here? Again, just something that is done in the code right here and we can pretty much just proceed.\"}),/*#__PURE__*/e(\"p\",{children:\"Now to get the prediction again, it is really really simple. We want to build up our payload in our header. As you can see, it's only two lines of code.\"}),/*#__PURE__*/e(\"p\",{children:\"Our header only includes our authorization, which is our API key and our payload, our JSON, includes the image data which is then again, decoded. If I just run the cell and run the next cell to dissect the whole payload a bit, we can look at what it contains. Now, when dissecting the response, what can we see right here?\"}),/*#__PURE__*/e(\"p\",{children:\"We can see that our results will contain some results: all the predictions that it has made, and all the instances that it has detected. In this case, it will have detected only one instance. Now, we'll be accessing this first instance right here, just the \u201C0\u201D element, the first element, and look at the keys that it has.\"}),/*#__PURE__*/e(\"p\",{children:\"We can see that for this one object that it has detected, we have a bounding box, even though we have trained an instance segmentation model. We'll have the label, and we'll have the polygon, the actual instance segmentation. Now, for example, when we look at the label, we'll see the label is an African Grey Parrot, which is correct, as I know what the image is.\"}),/*#__PURE__*/e(\"p\",{children:\"Then here, when looking at the polygon and at the path, we'll see that this is the actual polygon with all the key points.\"}),/*#__PURE__*/e(\"p\",{children:\"Now from here on, you can do whatever you want with your prediction. I just went ahead and wrote a custom script to plot this data to have a nice visualization.\"}),/*#__PURE__*/e(\"p\",{children:\"If I just run this script, let me hide this one here, we can see that we have a prediction for an African Grey Parrot. The green part right here is the actual segmentation map, and we can see that it ran successfully.\"}),/*#__PURE__*/e(\"p\",{children:\"We can again go ahead, and change the image.\"}),/*#__PURE__*/e(\"p\",{children:\"We can go to image 2. Rerun every cell. Get our prediction.\"}),/*#__PURE__*/e(\"p\",{children:\"We can see we again have one object, which is an African Grey Parrot. We can again visualize it. And, would you look at that, we have a really nice prediction of our African Grey Parrot. I also went ahead and wrote a script to do a prediction on a video that I will show you right now.\"}),/*#__PURE__*/e(\"p\",{children:\"You can see everything works really fine. But you know, that's only one thing that you can do with this model. Let me show you what else you can do with this powerful tool. This is the dataset that I used for training and as you can see, everything already has an annotation, and everything has a label, except for those two images right here.\"}),/*#__PURE__*/e(\"p\",{children:\"Now what we can go ahead and do is click on our workflow that is used for this specific dataset and we can see it's a very simple one. What we can now do is add a model stage and we'll look at what this does. We can connect a model. This model is running right here, this is our bird species model and we can go ahead and connect the model to this specific stage.\"}),/*#__PURE__*/e(\"p\",{children:\"What we can now do is just plug this model stage right between the dataset and the annotation stage. So what will happen now is when some images from the dataset stage pass progress into the next stage, it will go into the AI model stage.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's see what happens there.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's look at the two images that are missing.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's say we want to open this image right here, and we can see there is no label. However, can send it to the model stage. Now, this bird is the second image that has no annotation, and we will send it as well to the model stage. We can now go back and look at all images that are not complete, and that are now in the annotation stage, and if we now again open our image, we can see they are already annotated.\"}),/*#__PURE__*/e(\"p\",{children:\"We can just pre-annotate our images by passing them automatically through this model stage. They are now in the annotation stage with already existing annotations. So what we can now do is just zoom in and do some fine-tuning of the annotation and this is just really, really powerful.\"}),/*#__PURE__*/e(\"p\",{children:\"We can use the model that we have trained to help us label new data and with this new data that we have trained or created using the model that we have trained we could, in theory, train a new model that is even better performing. This is a human-in-the-loop system where you can continuously train a model, use the model for labeling, train a new model, and so on.\"}),/*#__PURE__*/e(\"p\",{children:\"What we have seen so far is that we can easily train a custom model on our own dataset. We can then deploy this model in just a few clicks and run inference calls using the REST API in really just a few lines of code.\"}),/*#__PURE__*/e(\"p\",{children:\"What we have also seen is that we can use this model in our workflow, in our annotation pipeline, to pre-annotate our data automatically and then just do a little fine-tuning. If you don't have enough data to start this training process to then build a model that you can use to speed up your annotation process, you can just use one of the public models that have been already trained.\"}),/*#__PURE__*/e(\"p\",{children:\"For example, this receipt scanner is a text scanner or an OCR model that we can just start. In the same way that we have used our bird species model, we can integrate it into a workflow and use that one.\"}),/*#__PURE__*/e(\"p\",{children:\"Let's relax a bit. That was a lot, but nothing too difficult.\"}),/*#__PURE__*/e(\"p\",{children:\"You now know how to train a model on your own custom data. How to use that model or any other public model to help you with the annotation process, and how to use it in production using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"I hope this video helped you with getting started with V7.\"})]});export const richText25=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/t(\"p\",{children:[\"In this Darwin Advanced session, we take a close look at Exports. We tackle the four ways to export a dataset you\u2019ve created within Darwin - the V7 user interface, CLI, SDK, or REST API - and provide a step-by-step guide on how to use each of these methods to export your data. Looking for something simpler? Head to our Darwin Fundamentals session on \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy/exports\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Exports\"})}),\".\"]}),/*#__PURE__*/t(\"p\",{children:[\"V7\u2019s Darwin is built to flex around your needs, which is why you\u2019ll find Exports an intuitive process. When exporting from Darwin, you have a host of supported file formats, including COCO, Darwin JSON, \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/blog/cvat-guide\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"CVAT\"})}),\", Instance PNG, \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/blog/yolo-object-detection\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"YOLO\"})}),\", and many others.\"]}),/*#__PURE__*/e(\"p\",{children:\"In this tutorial, we take you through the export process beginning with the V7 UI. This is a simple-to-use interface that allows you to export complete annotations, specifically selected files, or apply filters to export specific data.\"}),/*#__PURE__*/e(\"p\",{children:\"Next, we explore the SDK. We discuss the necessity to import your dependencies - as with any script or code you write - and outline how to connect to V7 using an API key. After the SDK, we explore how to use the REST API to export data, making note of dependencies, targeting datasets, and defining parameters for your export version.\"}),/*#__PURE__*/e(\"p\",{children:\"By the end of this video, you\u2019ll have a comprehensive understanding of how to export datasets within V7, backed by best practices tips, and tricks to effectively leverage your data for training models.\"})]});export const richText26=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"If you want to export a dataset you have created using V7 for model training, there are four ways of doing so. These are: using the V7 UI, command line interface, SDK, or REST API. Let's go ahead and look at how to use all four of these methods to export any data in the supported formats.\"}),/*#__PURE__*/e(\"p\",{children:\"When looking at my \u201Cbirds\u201D dataset here, we can see that some images are completed and have annotations and some don't. Out of these 79 complete annotations, I have samples of African grey parrots, European robins, and Nightingales. Now to export this dataset, we simply need to click on the export data button in the upper right corner.\"}),/*#__PURE__*/e(\"p\",{children:\"We can now create a new export version. We hereby need to specify the version name and can select one annotation format out of the supported ones. We now need to decide whether we want to export the data that actually has complete annotations, only specifically selected files, or all data given a specific filter.\"}),/*#__PURE__*/e(\"p\",{children:\"We can of course create multiple different export versions of the same dataset. These can be used for model training as a way of creating training experiments between different versions, or as a form of version control. From here on we can directly download the annotations with one click from the browser or we can copy the command line interface command and download the whole dataset, including images. We now have pulled our dataset into our Darwin datasets directory on our local machine, and it's as simple as that!\"}),/*#__PURE__*/e(\"p\",{children:\"Let's now look at how to export data using the SDK.\"}),/*#__PURE__*/e(\"p\",{children:\"As with any script or code that you write, the first thing that you want to do is import your dependencies.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, in this example, we'll just look at the functionalities of the specific modules when actually using them. So let's go ahead and import our dependencies and we arrive at this specific cell here. Now, we somehow need to connect to V7 and authorize ourselves using our API key. There are multiple different versions, of course, for example, you could directly provide your API key when using the client's module.\"}),/*#__PURE__*/e(\"p\",{children:\"In this case, we are using our local authorization. This can be set up very simply using the command line interface. There you will be asked to provide your API key and everything will be stored in a config file on your local machine.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's create our client module with our local authorization to have an interface with V7.\"}),/*#__PURE__*/e(\"p\",{children:\"Now that we have our client set up, we can now actually get access to our dataset. We're therefore going to use the method called \u201Cget remote datasets\u201D. We need to provide our team name or team slug: in this case, Boris Mainatus. That's me.\"}),/*#__PURE__*/e(\"p\",{children:\"We also need to provide the dataset that we want to access. We'll again use our \u201Cbirds\u201D dataset. What we end up with is a dataset manager with which we have access to our remote dataset. We can then use this to then create our specific export version.\"}),/*#__PURE__*/e(\"p\",{children:\"We therefore again just specify a release name. In this case, we will call it v1-all-sdk, just to again, differentiate between the different versions and know that this one was created using the SDK.\"}),/*#__PURE__*/e(\"p\",{children:\"If we run the cell, nothing will print out, but we'll have created a release name. We can actually verify that by looking into our UI.If we go to our export data and we'll see that we have actually created an export called v1-all-sdk.\"}),/*#__PURE__*/e(\"p\",{children:\"Now we have created this export but we haven't actually pulled anything. That is what we'll do in the next cell. In this cell, we'll be using a \u201Cwhile true loop\u201D and always be waiting for 10 seconds for V7 to actually create the export version because depending on the filter complexity or the size of the dataset, it might take a bit on V7's side.\"}),/*#__PURE__*/e(\"p\",{children:\"Once everything is set up, we simply can again use our dataset manager and get the release. by providing the specific release name. If we don't provide a release name, it will just take the latest version of this dataset, of the export. In our case, in this specific instance, again, our latest version is our v1-all-sdk version, but you know, you get the point.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay.\"}),/*#__PURE__*/e(\"p\",{children:\"So now we have our interface to our release and therefore we can actually download it into a zip file and let me just run this cell and we'll see the results. Let's wait for a second for this to happen and we'll see each other again in a bit.\"}),/*#__PURE__*/e(\"p\",{children:\"So that went pretty fast and we can also verify that we actually have downloaded our data by going into our directory. We can see here that we have our zip file, we can unzip our data, and here we have a directory with all our annotations. Great.\"}),/*#__PURE__*/e(\"p\",{children:\"So now let's look at how we can do pretty much the same, but using the REST API.\"}),/*#__PURE__*/e(\"p\",{children:\"So again, let's import our dependencies. As we are working with the REST API, we only need our requests module and also our API key I have stored in a separate file to not share my API key.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, after that is done, we need to define which dataset we actually want to target. For that, we again use the exact same team name or team slug as before, and we'll again be targeting the exact same dataset as before.\"}),/*#__PURE__*/e(\"p\",{children:\"Those two parameters will be plugged into the URL that we'll be then requesting from and we'll continue to the next cell. As you can see, the amount of code that we need is really not that much. We again specify our release name, which in this case will be v1-all-REST to specify that we're using the REST API and that we are now using a filter, which was a fun little thing.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay, so the header is pretty much always the same. We need to specify which format we are accepting with our responses. We then also define which content type we are working with ourselves. Then we also need to provide the API key for authorization. Now in the payload, we again have a few parameters that we can specify, for example, the format, we are working with, and if we want to include authorship or not. If this is set to true, we'll provide the metadata of every annotator for the respective annotations. We then can also specify whether or not we want to include export tokens. What are export tokens? It\u2019s a pending URL with a specific export token that then allows pretty much any user, whether they have V7 or not, access to the original image. When setting this to true, be aware that your data is not encrypted anymore.\"}),/*#__PURE__*/e(\"p\",{children:\"Okay. We now also have, of course, the release name and the filters. In this case, I have just selected the filter item name contains, which just says that the name of the specific image contains this specific sequence of numbers, or just characters. This is really helpful, if in your dataset, your images already follow a specific naming convention. That way you can just directly filter through your images.\"}),/*#__PURE__*/e(\"p\",{children:\"That\u2019s pretty much it. Let's just run the cell and look at the export version that we have created. Let's just pull in again our UI, let's refresh and we can see we have our v1-all-REST with the filter applied.\"}),/*#__PURE__*/e(\"p\",{children:\"There's only one image in this dataset or in this export version, rather, because only one image actually contains this string that I've provided in the filter. Now, this hasn't really pulled any data yet. It has only created the export version. Now to pull this data, you can use the different versions that we talked about, including directly pulling from the UI with the download button, copying the command line interface command, using the SDK, or using the REST API itself.\"}),/*#__PURE__*/e(\"p\",{children:\"So if you use the REST API, we simply want to get a list of all the export versions that we have. Those export versions will include a download URL. So as you can see, we have now received our list of all the different download versions. In this case, the first one it lists out is V1 All.\"}),/*#__PURE__*/e(\"p\",{children:\"What we'd want to do is just click on the link or access the link and that will automatically download our zip file as we have done in the SDK approach and that's it. We have pulled our export version.\"}),/*#__PURE__*/e(\"p\",{children:\"Actually that was it for the whole video. You now know how to quickly export datasets from V7.\"}),/*#__PURE__*/e(\"p\",{children:\"I hope this video helped you out with getting started with V7.\"})]});export const richText27=/*#__PURE__*/e(o.Fragment,{children:/*#__PURE__*/t(\"p\",{children:[\"In this Darwin Advanced session, we explore how to leverage V7's Darwin Torch API to seamlessly create PyTorch DataLoaders from your V7 datasets. While V7 excels at annotation and dataset management, the SDK and API unlock additional powerful capabilities for machine learning workflows.\",/*#__PURE__*/e(\"br\",{}),'We begin with a practical demonstration using a \"bird species dataset\" which contains instance segmentation polygons across 1,909 labels and 3 classes. Using the command line interface, we show how to export and access your dataset efficiently.',/*#__PURE__*/e(\"br\",{}),\"The tutorial walks through the straightforward process of creating DataLoaders using the Darwin Torch API. With just a few lines of code, you'll learn how to specify your dataset ID, define dataset types, and access your data for machine learning applications. We demonstrate how to view dataset statistics and examine individual images within your dataset.\",/*#__PURE__*/e(\"br\",{}),\"We then dive into creating data partitions - a crucial step in machine learning workflows. Using V7's command line interface, we show how to split your dataset into training (70%), validation (10%), and testing (20%) sets, with both random and stratified splitting options available. The tutorial covers how to apply transformations to your training data using the Darwin transforms API, including techniques like random horizontal flips and tensor conversions.\",/*#__PURE__*/e(\"br\",{}),\"Finally, we put everything together in a complete PyTorch training example using a Mask R-CNN model from TorchVision. The demonstration includes setting up the model architecture, configuring optimizers, and implementing a basic training loop.\",/*#__PURE__*/e(\"br\",{}),\"By the end of this video, you'll understand how to seamlessly integrate V7 datasets into your PyTorch workflows, combining V7's powerful dataset management capabilities with the flexibility of PyTorch for model training.\"]})});export const richText28=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"We know that V7 is an amazing tool for annotation and dataset management, but you can use the SDK and API to accomplish so much more.\"}),/*#__PURE__*/e(\"p\",{children:\"One amazing feature is the Darwin Torch API, with which you can very easily create your beloved PyTorch dataloaders from your V7 datasets. Let me quickly show you how simple it is.\"}),/*#__PURE__*/e(\"p\",{children:\"Again, as always, the first thing that we need to do when writing a script or coding is import our dependencies and, we'll look at what each individual module does when getting to that actual point.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's look at the dataset that we want to use for our dataloaders. In this case, we'll be using the \u201Cbird species dataset\u201D that is on the V7 Open Datasets page.\"}),/*#__PURE__*/e(\"p\",{children:\"Here we have some instance segmentation polygons, with 1,909 labels, and 3 classes.\"}),/*#__PURE__*/e(\"p\",{children:\"To get that dataset, we'll use the command line interface. That is a whole separate video on how to export datasets from V7. I recommend you watch that but again, in this case, I'll be using the command line interface, which in my opinion, is the most comfortable or easiest way of exporting your data.\"}),/*#__PURE__*/e(\"p\",{children:\"So now we have downloaded our dataset and we can also look at our dataset in Darwin's dataset directory here in the team V7 open datasets.\"}),/*#__PURE__*/e(\"p\",{children:\"Here we have the bird species, all of our images, and the releases with all the annotations. Since we have that, we can continue and load our datasets into our main memory using the PyTorch or Darwin Torch API. It\u2019s really, really simple.\"}),/*#__PURE__*/e(\"p\",{children:\"We first need to specify the dataset ID, which consists of the team name or the team's log again, in this case, V7 open datasets, and then the dataset name \u201Cbird species\u201D. which we have just looked at in our directory.\"}),/*#__PURE__*/e(\"p\",{children:\"We then call this one function that is provided by our Darwin Torch API, which is called \u201Cget dataset\u201D. Here we provide our dataset ID to just specify which dataset we want to access. We also specify the dataset type. Here we have instance segmentation labels so that is what we will provide as an argument.\"}),/*#__PURE__*/e(\"p\",{children:\"And, that's pretty much it.\"}),/*#__PURE__*/e(\"p\",{children:\"You now have your dataset in your dataset manager, and we can now just access the dataset and look at some statistics, for example.\"}),/*#__PURE__*/e(\"p\",{children:\"Here we can see that our dataset has 1,909 labels and 3 classes. In this case, it has the African gray parrot, European robin, and nightingale. We can also look at one image or the first image, in this case of our dataset, which is this nice little nightingale. And honestly, that's pretty much it. You now have your dataset and can just plug it into your PyTorch dataloaders and that's it.\"}),/*#__PURE__*/e(\"p\",{children:\"But you can do a bit more with Darwin, and that's why I want to continue this little video and look at what it can do.\"}),/*#__PURE__*/e(\"p\",{children:\"So in machine learning, we all know that it's really common to create different partitions for your data. You want to have a training, validation, and testing split. You can already directly do that using V7's command line interface.\"}),/*#__PURE__*/e(\"p\",{children:\"That is what we'll be doing in this cell.\"}),/*#__PURE__*/e(\"p\",{children:\"So to perform this action, we'll just call Darwin dataset split, provide the dataset that we want to split, and the splitting ratio.\"}),/*#__PURE__*/e(\"p\",{children:\"In this case, we'll be using 70% of the data for training. For validation, we'll be using 10%, and for testing, 20%.\"}),/*#__PURE__*/e(\"p\",{children:\"So let me just run this command and then we'll look at what Darwin does in the background.\"}),/*#__PURE__*/e(\"p\",{children:\"That's it.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's look at what Darwin did in the background. So if we go to the releases, go to the latest, go to the lists, and then to this specific split that you can also see down right here. We can see that Darwin has created two different splits, one random split, and one stratified split.\"}),/*#__PURE__*/e(\"p\",{children:\"In general, stratified is a bit better performing, so you can just select what you would like, a random split or a training split. Then have those as TXT files, which just specified which of the images with the corresponding labels are then associated with the testing split, with the training split, and the validation split.\"}),/*#__PURE__*/e(\"p\",{children:\"We have the stratified polygons for the testing split, for the training split and for the validation split - and that's it. We now have our dataset split into training validation and testing sets.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's look at how we can create our datasets using those partitions.\"}),/*#__PURE__*/e(\"p\",{children:\"We'll be using the exact same function as we have done right above here with the \u201Cget datasets\u201D call, but this time we'll be providing a few more arguments.\"}),/*#__PURE__*/e(\"p\",{children:\"So we again have the dataset ID, which just for completeness I've again written down right here. We\u2019ll then call our \u201Cget dataset\u201D function.\"}),/*#__PURE__*/e(\"p\",{children:\"So we'll again provide our dataset ID, we'll provide the dataset type, and then we'll have to specify which partition we want. In this case, this will be the dataset training partition. Then we'll provide the splitting type. We'll use the stratified partition instead of the random partition and then we can also directly provide a list of different transforms.\"}),/*#__PURE__*/e(\"p\",{children:\"When training computer vision models on images, it's useful to apply different transformations to your images for your model to generalize better. In this case, we'll be using the transforms API, which is again provided by the Darwin torch transforms API. We'll have a composition of random horizontal flips, and then we'll transform our images directly into tensors.\"}),/*#__PURE__*/e(\"p\",{children:\"The same applies to our validation dataset.\"}),/*#__PURE__*/e(\"p\",{children:\"Instead we'll selecting the partition validation and we'll only be applying a \u201Cto transform\u201D transformation because usually you want to see the performance of your model on the raw images that you provide.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, since this is done, let's go ahead and just run the cell and we can again look at some statistics just to verify that everything is going as we expected.\"}),/*#__PURE__*/e(\"p\",{children:\"If you look at the normal datasets, we again have our original 1,909 images or labels. If we look at our training dataset, we have 1,338, which is 70%. Then we have 190 images in our authorization dataset, which corresponds to our 10% respectively. That is how you can easily create your dataset splits using Darwin.\"}),/*#__PURE__*/e(\"p\",{children:\"Now let's go one tiny step further and just look at some actual PyTorch training code for some computer vision models using TorchVision and the actual PyTorch dataloaders. I'm sure that you're already very familiar with all the code from here, so let's just go ahead and run through it.\"}),/*#__PURE__*/e(\"p\",{children:\"So in this cell we are creating the PyTorch data loader, and this is using the standard PyTorch data loader API call. Here we provide the dataset that we've created using the Darwin torch API, right? Then we again continue with the standard arguments that you would provide using the dataloaders like the batch size, if you want to shuffle your data or not, and so on.\"}),/*#__PURE__*/e(\"p\",{children:\"So let's just quickly run the cell, create our data loader for our training dataset and get to the next cell that instantiates our model, which in this case will be a mask RCNN model using our torch vision API.\"}),/*#__PURE__*/e(\"p\",{children:\"So what we'll just do here is we'll quickly load in a model from our torch vision API, and in this case we were using the ResNet 50 mask RCNN model that is pre-trained on the COCO dataset.\"}),/*#__PURE__*/e(\"p\",{children:\"Now, since it is pre-trained, we'll need to replace the actual prediction heads. We\u2019ll do that in this case for our bounding box predictor, here we will replace it with a new newly initialized fast RCNN predictor, and then we'll do the same for the mask predictor. We won't go into details about the mask RCNN model itself, but it can predict bounding boxes and segmentation maps.\"}),/*#__PURE__*/e(\"p\",{children:\"So again, we'll place our bounding box predictor of our model with a freshly initialized fast RCNN predictor. We\u2019ll replace the mask predictor with a freshly initialized mask RCNN predictor. And that is how we will get our model.\"}),/*#__PURE__*/e(\"p\",{children:\"So we can now get to the basic optimization setup. First, we'll start with selecting the device that we are using.\"}),/*#__PURE__*/e(\"p\",{children:\"In my case, I'll be having a CPU. Then we'll get our segmentation model by providing the number of classes. In this case, we'll be using the number of classes that we have in our dataset plus one, because we also want to include one background class. Once we have instantiated our model, we'll then push it to our device and then get to constructing our optimizer.\"}),/*#__PURE__*/e(\"p\",{children:\"This is done by extracting the parameters that require gradients that will be trained, or in other words, that are not frozen. Then we'll just select our optimizer. In my case, I'm using \u201CAdam\u201D, but you can, of course, use whatever you want or whatever works best for you.\"}),/*#__PURE__*/e(\"p\",{children:\"For example, stochastic gradient descent or Adam W.\"}),/*#__PURE__*/e(\"p\",{children:\"What we'll also be doing here is just selecting a learning rate scheduler, because why not?\"}),/*#__PURE__*/e(\"p\",{children:\"Let me run the cell and we can go to the training loop. This is again, your standard training loop. You have the outer loop, which runs over the epochs. In this case, we have selected 10 epochs and in the inner loop, we'll be going off the whole dataset using our dataloader that has been created using the dataset.\"}),/*#__PURE__*/e(\"p\",{children:\"We'll collect our images and push them to our device. We'll get our ground truth labels, push them to the device and then run everything through our model and compute the loss. We then of course zero out the gradients of our optimizer and then back-propagate the computed loss.\"}),/*#__PURE__*/e(\"p\",{children:\"Then we update the weights using our optimizer. For model performance tracking, we'll just accumulate the loss. After 10 iterations, we'll just print out the loss we have received or the mean loss rather and then reset our accumulated loss. After we're done with one iteration, iterating over one entire dataset, we then repeat the same process all over again for the next epoch.\"}),/*#__PURE__*/e(\"p\",{children:\"This just shows how easy and fast you can create a dataset and a data loader using Darwin Torch.\"}),/*#__PURE__*/e(\"p\",{children:\"And that was it for this video. With V7 you have an amazing interface for creating and managing datasets with different versions. With the Darwin Torch API, you can easily start your standard PyTorch training using dataloaders. It's really the best of both worlds so that you can focus on training amazing models.\"}),/*#__PURE__*/e(\"p\",{children:\"I hope this video helped you with getting started with V7.\"})]});export const richText29=/*#__PURE__*/t(o.Fragment,{children:[/*#__PURE__*/e(\"p\",{children:\"In this Darwin Fundamentals session, we explore the Keypoint Skeleton feature, a particularly useful tool for 2D image and video annotation. In simple terms, Keypoint Skeletons are sets of predefined points, joints, and shapes that can be adjusted to match an object\u2019s pose. They\u2019re an efficient way to define object poses or create custom polygons for reuse in projects.\"}),/*#__PURE__*/t(\"p\",{children:[\"Eager to explore keypoint annotation tools and tricks in more detail? Explore our guide to \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/blog/keypoint-annotation-guide\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"keypoints and skeletons\"})}),\".\"]}),/*#__PURE__*/t(\"p\",{children:[\"In this video, we start by demonstrating how to create a Keypoint Skeleton for a human hand, mapping each point and joint to the fingers. From here, we explain how to change the \",/*#__PURE__*/e(a,{href:\"https://www.v7labs.com/academy/instance-tracking-ids\",nodeId:\"Y122M6z_Y\",openInNewTab:!1,smoothScroll:!1,children:/*#__PURE__*/e(\"a\",{children:\"Instance Tracking ID\"})}),\" of each point, to make use of the Keypoint Skeleton simple for your use case.\"]}),/*#__PURE__*/e(\"p\",{children:\"Next, we explore how to use the Keypoint Skeleton within your datasets once it's been set up. We showcase how to drag and drop the Keypoint Skeleton onto your frame, manipulate it to an object, and adapt it per frame. We also explain how the Keypoint Skeleton tool behaves in video, showcasing how the tool interpolates between varying frames so you only have to label a few frames to get a smooth transition that represents ground truth.\"}),/*#__PURE__*/e(\"p\",{children:\"We also note one important thing: the Keypoint Skeleton is versatile, and not limited to specific object types. For example, it can be used to create custom polygons, such as cuboids or pentagons, to represent different objects.\"}),/*#__PURE__*/e(\"p\",{children:\"You\u2019ll come away with a clear understanding of the Keypoint Skeleton tool, how it works, and how you can use it within your project to save time and bolster your overall annotation process.\"})]});\nexport const __FramerMetadata__ = {\"exports\":{\"richText2\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText6\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText12\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText20\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText24\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText22\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText21\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText8\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText18\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText13\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText16\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText3\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText25\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText26\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText7\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText9\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText29\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText28\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText5\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText11\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText14\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText19\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText10\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText1\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText23\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText4\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText27\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText17\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText15\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"richText\":{\"type\":\"variable\",\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}"],
  "mappings": "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",
  "names": ["richText", "u", "x", "p", "Link", "richText1", "richText2", "richText3", "richText4", "richText5", "richText6", "richText7", "richText8", "richText9", "richText10", "richText11", "richText12", "richText13", "richText14", "richText15", "richText16", "richText17", "richText18", "richText19", "richText20", "richText21", "richText22", "richText23", "richText24", "richText25", "richText26", "richText27", "richText28", "richText29", "__FramerMetadata__"]
}