timm | Immutability helpers with fast reads and acceptable writes

The positional embedding is a parameter that gets included in the computational graph and gets updated during training. So, it doesn't matter if you initialize with zeros; they are learned during training.

setattr(net, "head.fc", torch.nn.Linear(1111, 2))

will create head.fc attribute on net.

I guess you want to create
setattr(net.head, "fc", torch.nn.Linear(1111, 2))

or dynamically:

setattr(getattr(net, "head"), "fc", torch.nn.Linear(1111, 2)).

If you want an even more general nested dynamic atrribute, you'll add to build some helper functions for this, like described here.

Try out this one:

May be this should work. We extract the words from the 'name', 'email' (after removing the suffix starting with @), then we loop over each of the list elements, collapse the split elements into a single expression with |, use that in str_detect to check whether those elements are all present, negate (!) and coerce to integer (+)

Try going with pandas here. It uses beautifulsoup under the hood. I can't test it on your URL since you havent provided one.

If you want a new array of a certain size, and want to ignore the very confusing y from your sample code, you could do something like this:

I think you might be overcomplicating your styles, specially with the pointer-events styles and whatnot. If all the elements in your menus and submenus are links/hoverable items, you should not be removing the pointer-events or their individual visibility, and instead make the parent container invisible.

Additionally, since you're styling with SCSS, you're nesting your .sub-menu inside a path that makes the .sub-menu quite a specific CSS rule. Your CSS reads like so:

Because you don't have any break in your switch cases.

Check the documentation for the switch statement on MDN. It says the following about break (emphasis mine)

The optional break statement associated with each case label ensures that the program breaks out of switch once the matched statement is executed and continues execution at the statement following switch. If break is omitted, the program continues execution at the next statement in the switch statement.

So update your cases to look like

I think you should not need to use Threads or Queues instead of wx.Timers. But, I also think you actually need only 1 wx.Timer that checks for and grabs data from the serial port (or other data source). I would suggest that the handler for the wx.Timer events (probably running at ~2Hz if you expect data at 1Hz) should do the following:

1. check for new data. if there is not new data, return immediately, waiting for next wx.Timer event.

2. if there is new data, parse and do the calculations based on that data right away and append it to the data arrays within that event handler. Just drop all the storing and later deleting of temporary data and have you self.x1, self.y1 etc up-to-date when the data-event-handler ends. All those del XXX in your code -- especially since one event handler deletes data created in another place - look like they could be a problem.

3. and then update the plots. If you believe the plotting will be slow, you could use a second timer event that looks at whether the length of self.x1 has changed and remake the plot(s). But, I believe you should not need to use a second timer, and can just update the plots in the data-event-handler.

For an example of how this might be done, see https://github.com/newville/wxmplot/blob/master/examples/stripchart.py That uses just one wx.Timer that fetches new data and updates the plot. Note that it uses wxmplot.PlotPanel.update_line() which is much faster at updating an existing plot than redoing wxmplot.PlotPanel.plot() for each new data set.

The next_data() function in that example is a bit simpler and more deterministic than what you would need to do to read data from the serial port. But you're already doing that part and what you're doing doesn't look too hard or slow.