HandWrite | 手写字体在线识别app。

Your kernel size, 60 by 60, is quite big. Try 3 by 3 kernel or 5 by 5 kernel. It doesn't seem that image size is the problem since you are resizing from (3508, 2480) to (438, 310).

Also notice that the number of weights you have is very, very large. It is around 24 million. This is because you are flattening a (189, 125, 32) shape array and then your next layer (Dense) has 32 units, so 189 * 125 * 32 * 32 weights for that layer. That will take very, very long to train.

Try to add one or two more conv layers + pooling layers so that the number of weights when flattened is manageable.

As a first pass at the problem, I'd probably want to just count the number of pixels that are different between the two images. It has several desirable properties:

1. It's an actual distance metric.
2. It's dirt-cheap computationally.
3. Slides with more handwriting are farther from the original than slides with little writing (e.g. if you progressively added more writing and wanted to order those).
4. If there's even a moderate amount of content on the slides, you'll plausibly (not necessarily) have any two unrelated slides be farther from each other than two slides which are the same but just differ in the handwriting (especially with thin writing like that).

It's not a perfect solution of course -- e.g., if you acquire the slides by taking photos then almost every slide will differ at every pixel. Take a moment to think about it with respect to your use case and data collection methods.

It's pretty common for images in python to be represented as numpy arrays. Supposing that's the case for you as well, the following example would compute the metric in question (or could be readily modified to give you similarity rather than distance):

The following seems to work for the example inputs you provided. We're only interested in finding the leading integer digits and a potential separator followed by more digits. We don't actually need to look for any whitespace or percentage signs, since we're only interested in replacing the digits in any given match, anyway. Let me know if I missed something:

You might be able to do that with

The output you've shown is for a debug build. With a release build (or basically with optimizations turned on) the C# compiler generates the same IL you'd have written by hand.

I strongly suspect that this is all to make the debugger's work easier, basically - to make it simpler to break, and also see the return value before it's returned.

Moral: when you want to run optimized code, make sure you're not asking the compiler to generate code that's aimed at debugging :)

You cannot pattern match on private fields because they are private. You have to use the accessors the library decides to provide. The serde_json documentation for Number shows that it has methods like as_u64:

Have you tried ListView.Footer?

Gets or sets the string, binding, or view that will be displayed at the bottom of the list view.

So you would have something like: