Old blob on depthai v3

PepperoniPingu

Hi,

I'm trying to transition one of my applications from Depthai v2 to Depthai v3. I have a custom trained yolov7 model that I converted to a .blob with tools.luxonis.com . In the application I used the YoloDetectionNetwork and set the parser config manually from the config json file like below:

with open(config_path) as f:
    config = json.load(f)

metadata = config["nn_config"]["NN_specific_metadata"]
classes = metadata["classes"]
coordinates = metadata["coordinates"]
anchors = metadata["anchors"]
anchor_masks = metadata["anchor_masks"]
iou_threshold = metadata["iou_threshold"]
confidence_threshold = metadata["confidence_threshold"]

detection_network = pipeline.create(dai.node.YoloDetectionNetwork)
detection_network.setConfidenceThreshold(confidence_threshold)
detection_network.setNumClasses(classes)
detection_network.setCoordinateSize(coordinates)
detection_network.setAnchors(anchors)
detection_network.setAnchorMasks(anchor_masks)
detection_network.setIouThreshold(iou_threshold)
detection_network.setBlobPath(model_path)

In Depthai v3 YoloDetectionNetwork is replaced by the DetectionNetwork node. But DetectionNetwork doesn't have the parser configuration methods like setNumClasses , setCoordinateSize , setAnchors etc. So now I have no way to configure the parser. Resulting in the parser not recognizing any detections.

Can I create the network and parser seperately to get access to the parser settings perhaps?

I've tried to re-convert my models using the HubAI in to a newer format like nnArchive or .superblob. But honestly, HubAI is horrible for productivity and I don't want to use it. It takes 3 times as many clicks to do what used to be quick in tools.luxonis.com . I need to create an account, create a team, create model, create variant etc etc. I have 5 variants of my model in different resolutions so it's not reasonable to do this every time I update my model. Old tool had the settings persistent between runs so you didn't have to input settings, click ok, input settings, click ok, etc over and over like you do now. Please update the old tool to output new archives. Or make a "HubAI Light".

KlemenSkrlj

Hi @PepperoniPingu ,
You are correct, this is a bug that DetectionNetwork doesn't expose its underlying parser and all of its setters. I reported this internally and will be worked on for the next DAIv3 release. What you can do in the meantime is define NeuralNetwork node and then DetectionParser separately and connect these two together. So in your example it would be something like:

nn = depthai.node.NeuralNetwork()
nn.setBlobPath(model_path)

parser = depthai.node.DetectionParser()
parser.setConfidenceThreshold(confidence_threshold)
parser.setNumClasses(classes)
parser.setCoordinateSize(coordinates)
parser.setAnchors(anchors)
parser.setAnchorMasks(anchor_masks)
parser.setIouThreshold(iou_threshold)

nn.out.link(parser.input)
parser.out .... # here output is same as it would be with DetectionNetwork '.out' stream

Let me know this works,
Klemen

PepperoniPingu

KlemenSkrlj

Thanks for the suggestion I'll try as soon as I can!

KlemenSkrlj

But honestly, HubAI is horrible for productivity and I don't want to use it.

Sorry to hear that your experience with HubAI was not up to par. We appreaciate any feedback and suggestions on how can we improve it so that transition from DAIv2 tools to HubAI (DAIv3 NNarchives) is as smooth as possible. I want to focus on this part:

I have 5 variants of my model in different resolutions so it's not reasonable to do this every time I update my model. Old tool had the settings persistent between runs so you didn't have to input settings, click ok, input settings, click ok, etc over and over like you do now

When going through the "YOLO Conversion" on HubAI these are the modals that pop up:

Selecting platform
Upload of .pt weights and naming the model
Setting model instance name and optional change of advanced parameters
Setting model input shape

Comparing this to old https://tools.luxonis.com/ conversion the extra things that are required now are the naming of model and instance since selecting platform, uploading of weights and setting the input shape was requered before as well. So to better understand what do you think are the main pain points:

Is it naming of the model and creating a model card for each one separately? This is currently in the works so you would only need to create the model card once (with the first weights) and then add new variants by going to the existing model card, clicking "+ Add Variant" and uploading new .pt weights.
Is the annoying part maybe that now you have to go through multiple modals in sequence where as before all was on one page?
You mention persistance: You mean that before, because all was on one page you could just swap out the .pt file, the rest would be the same and you'd click "Submit" again? Would pre-populating input shape modal to values from last conversion be better?
Do you have any more suggestions on how to flow could be improved to make your UX better?

A side question: Were you before a user of blobconverter python API and automation of conversions? Note that we now have "online" version of modelconverter which supports also YOLO conversions through Python API and uses HubAI as the backend service. Perhaps this could be good flow for you as well if you are doing multiple conversions with mostly same parameters as in the API calls you could only change the input model path and leave other parameters same between conversions.
As I said we are happy to hear all the comments you have as this helps us improve the platform and UX experience more over time. So thank you for that!

PepperoniPingu

KlemenSkrlj

My problems are:

Login required.
Team required.
What's the difference between "model name" and "model instance name" and "model variant"? I don't want HubAI to group my models, I do that in my git repo. If I wanted groups, that should be "opt-in", i.e. you create a folder in HubAI.
I can create variants now, but they can't have different resolutions. So I need to create different models and model instances for every resolution
Persistence. Yes I would swap the .pt and then click "convert".
Like you said: everything was one page before.

I tried the ModelConverter python API. It's good for the most part. Have two complaints: api key reqiuired, and, can't convert models with the same name twice. So I have to add a uuid to the model name.

Maybe I should just switch to the local modelconverter docker instead, it doesn't seem like HubAI is aimed at my usecase. That would allow scripting the whole training + conversion.