adam | Adam is a coroutine-friendly Android Debug

Coming from a controls background, to mimic behavior of an analog device, you could use an exponential (aka low-pass) filter.

There are two types of low-pass filters you can use, depending on what type of behavior you want to see: a first-order or second-order filter. To put it in a nutshell, if your reading was steady at 0 then suddenly changed to 10 and held steady at 10 (a step change), the first order would slowly go to 10, never passing it, then remain at 10 whereas the second order would speed up its progress towards 10, pass it, then oscillate in towards 10.

The function for an exponential filter is simple:

All rows need the same data size, of course some values can be empty in csv.

I've passed your code through gotip that uses a more evolved implementation of the proposal and it does not complain about that part of the code, so I would assume that the problem is with the go2go initial implementation.

Please note that your implementation will not work since you can definitely use parametric interfaces in type assertion expressions, but you can't use interfaces with type lists as you are doing in testDifference[intOrString]

By manually adjusting the position of the image with xmin/xmax & ymin/ymax, fixing the pitch of rows and columns with coord_fixed(clip = "off) and expanding the plot.margin in theme I was able to get something that seems like it will work.

I tried with scikeras but I got errors because it doesn't accept not-numerical inputs (in our case the input is in str format). So I came back to the standard keras wrapper.

The focal point here is that the model is not built correctly. The TextVectorization must be put inside the Sequential model like shown in the official documentation.

So the build_model function becomes:

This seems to be a bug in Tensorflow 2.7 when using model.save combined with the parameter save_format="tf", which is set by default. The layers RandomFlip, RandomRotation, RandomZoom, and RandomContrast are causing the problems, since they are not serializable. Interestingly, the Rescaling layer can be saved without any problems. A workaround would be to simply save your model with the older Keras H5 format model.save("test", save_format='h5'):

First of all, metrics such as Precision and Recall are focused on the positive class only, avoiding the problems encountered by multi-class focus metrics in the case of the class imbalance. Thus, we may not obtain enough information about the performance of the negative class if we keep considering all indicators. Haibo He et al suggest the metrics below to rate both items:

1. Geometric Mean.
2. F-Measure.
3. Macro-Averaged Accuracy.
4. Newer Combinations of Threshold Metrics: Mean-Class-Weighted Accuracy, Optimized Precision, Adjusted Geometric Mean, Index of Balanced Accuracy.

My suggestions:

1. Use the PR-curve and the F1-score.
2. Try with geometric transformations, photometric transformations, random occlusions (to avoid overfitting), SMOTE, Tomek links (for undersampling majorities), etc.
3. Random undersampling may delete relevant features of your dataset. Again, analyze your dataset using KNN and other similar techniques.
4. Check this book: H. He and Y. Ma, Imbalanced Learning: Foundations, Algorithms, and Applications, Hoboken, New Jersey: Wiley-IEEE Press, 2013.

You can try this:

If the hyperspectral dataset is given to you as a large image with many channels, I suppose that the classification of each pixel should depend on the pixels around it (otherwise I would not format the data as an image, i.e. without grid structure). Given this assumption, breaking up the input picture into 1x1 parts is not a good idea as you are loosing the grid structure.

I further suppose that the order of the channels is arbitrary, which implies that convolution over the channels is probably not meaningful (which you however did not plan to do anyways).

Instead of reformatting the data the way you did, you may want to create a model that takes an image as input and also outputs an "image" containing the classifications for each pixel. I.e. if you have 10 classes and take a (145, 145, 200) image as input, your model would output a (145, 145, 10) image. In that architecture you would not have any fully-connected layers. Your output layer would also be a convolutional layer.

That however means that you will not be able to keep your current architecture. That is because the tasks for MNIST/CIFAR10 and your hyperspectral dataset are not the same. For MNIST/CIFAR10 you want to classify an image in it's entirety, while for the other dataset you want to assign a class to each pixel (while most likely also using the pixels around each pixel).

Some further ideas:

• If you want to turn the pixel classification task on the hyperspectral dataset into a classification task for an entire image, maybe you can reformulate that task as "classifying a hyperspectral image as the class of it's center (or top-left, or bottom-right, or (21th, 104th), or whatever) pixel". To obtain the data from your single hyperspectral image, for each pixel, I would shift the image such that the target pixel is at the desired location (e.g. the center). All pixels that "fall off" the border could be inserted at the other side of the image.
• If you want to stick with a pixel classification task but need more data, maybe split up the single hyperspectral image you have into many smaller images (e.g. 10x10x200). You may even want to use images of many different sizes. If you model only has convolution and pooling layers and you make sure to maintain the sizes of the image, that should work out.