lasso | Convex optimizers for LASSO , including subgradient | Portfolio library

Here's one example of completely custom ChartXY interactions. Key points:

• Default rectangle fit & zoom interactions are disabled.

• Line series data is cached to a variable which can be used for custom statistics.

• RectangleSeries is used for visualizing drag area on chart.

• UI elements are used for displaying statistics of selected area.

• ChartXY.onSeriesBackgroundMouseDrag event is used for hooking custom actions to user interactions.

Below you'll find a code snippet where dragging with left mouse button creates a rectangular area which shows highlighted X area and solved Y data range within. Releasing the mouse button results in the full selected data points array being solved (length is logged to console).

Your question is pretty light on specifics. What's even the problem you're running into? Do you know how to draw points in a (Py)Qt GUI? Do you know how to select points with geopandas? (This is easily googled: https://gis.stackexchange.com/questions/279670/geopandas-equivalent-to-select-by-location)

Did you actually try the matplotlib lasso selector? This example works interactively: https://matplotlib.org/stable/gallery/widgets/lasso_selector_demo_sgskip.html

If you just want to plot and select points, it's likely sufficient. No need for a Qt GUI.

Anyway, if you really need a Qt application... I'm assuming you already have a a GeoDataFrame containing the data, e.g. called points.

1. Design something in (Py)Qt which allows drawing a geometry on your plot.
2. Collect the vertices of the drawn geometry.
3. Convert the vertices into a shapely polygon (via shapely.geometry.Polygon).
4. Find the points within in the polygon, points.within(polygon).

Here are two ways - unsatisfactory, especially because the variables labels seem to be gone once the regression gets going:

simply use the | character to set an "or" in the pattern.

If I understand your requirements correctly then maybe this will work for you. If not then maybe you can use the concepts to meet your needs.

Create a list with your numeric predictor values: (I created some representative via range())

You can create an empty dataframe first outside the loop:

You have NA value in your test dataset, you can avoid the error by using : lasso.pred <- predict(lasso.fit2, newdata = test.dat,na.action = na.pass, type="raw")

From this issue there is no solution using keras as sklearn wrapper is not maintained and will be removed

Fortunately scikeras package solve this issue.

I advice you to read docs or tutorials but here a simple example using subclassing:

Provided

1. There is a unique solution (which should be true if your objective is regularized, which it appears to be by the last term.)
2. There are no bugs in either implementation.

Both implementations should return the exact same solution as the problem is a convex semidefinite program. The difference you should observe is

1. Runtime, one will likely run longer than the other, I would bet your implementation uses a general-purpose solver package (CVX) so should be slower.
2. Memory usage, once again, I would expect the general purpose (unutuned) package should consume more memory.
3. Numerical stability, in general this some implementations will be much more numerically stable. That is, if you use a weak regularization (very small lambda) you may find that some implementations fail to converge while others still work.

For small and toy problems this should not be a big deal (which is usually the case if you are an academic.) If you are a person trying to do something useful in the real world, runtime & memory usage tend to be extremely important, as they control what size problems you can tackle with your approach.

The only way to know the relative limitations to each approach is to implement and try both! At the very least, I would implement and run both approaches as a sanity check that both implementations are likely correct (the chance of both implementations being incorrect and reporting the same results across a range on inputs is very low.)