Inpainting | Healing holes in Python arrays | Machine Learning library

If all your images are like this and have a watermark as shown in the question having a light gray watermark then a simple thresholding operation will work.

You are accessing the tensor's .shape property which gives you Dimension objects and not actually the shape values. You have 2 options:

1. If you know the shape and it's fixed at layer creation time you can use K.int_shape(x)[0] which will give the value as an integer. It will however return None if the shape is unknown at creation time; for example if the batch_size is unknown.
2. If shape will be determined at runtime then you can use K.shape(x)[0] which will return a symbolic tensor that will hold the shape value at runtime.

Mainly, dilate the mask used for the inpainting. Also, enlarging the inpaint radius will give slightly better results.

That'd be my suggestion:

It's rather hard to help you because you haven't provided a Minimum Complete Verifiable Example of your code with all the import statements and code showing how you open your images, or even indicated whether you are using OpenCV or PIL or skimage. Also, you haven't provided the second file with the mask of all the points that need in-painting, nor do I know what you are actually trying to achieve, so for the moment, I am just trying to provide a method that looks to me like it gets a similar result to the one you show.

Anyway, here's a method that uses morphology and takes 100 microseconds on my Mac - which may not be anything like whatever you are using ;-)

I've try many ways and my final thought is that pre trained keras models are not compatible. I changed it to a tensorflow VGG16 model and it works slower but at least it works.

It's the slice operator being applied to the lists, it just looks odd because of the long names, and because there's a space after the colon. If you simplify a bit, it's just:

This exception happens whenever an orchestrator function does async work in an unsupported way. "Unsupported" in this context effectively means that await was used on a non-durable task (and "non-durable" means that it was a task that came from some API other than DurableOrchestrationContext).

You can find more information on the code constraints for orchestrator functions here: https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-checkpointing-and-replay#orchestrator-code-constraints.

Here are the rules that were broken in your code when I quickly scanned it:

• Orchestrator code should be non-blocking. For example, that means no I/O and no calls to Thread.Sleep or equivalent APIs. If an orchestrator needs to delay, it can use the CreateTimer API.

• Orchestrator code must never initiate any async operation except by using the DurableOrchestrationContext API. For example, no Task.Run, Task.Delay or HttpClient.SendAsync. The Durable Task Framework executes orchestrator code on a single thread and cannot interact with any other threads that could be scheduled by other async APIs.

This exception specifically occurs when we detect that an unsupported async call is made. I noticed that is happening in this code:

sum_norm2 = tf.reduce_sum(prod,0) - I don't think this is doing what you want it to do.

Say y and y_ have values for 500 images and you have 10 labels for a 500x10 matrix. When tf.reduce_sum(prod,0) processes that you will have 1 value that is the sum of 500 values each which will be the sum of all values in the 2nd rank.

I don't think that is what you want, the sum of the error across each label. Probably what you want is the average, at least in my experience that is what works wonders for me. Additionally, I don't want a whole bunch of losses, one for each image, but instead one loss for the batch.

My preference is to use something like

Text here has a different intensity than the watermark. You could play around with a simple brightness/contrast transformation, i.e. increasing gain/contrast until the watermark vanishes and reducing brightness to compensate.

See OpenCV docs for a simple tutorial.

Here's a quick attempt in Python, not really using OpenCV because it's not needed IMHO for such a simple linear transformation. Play around with alpha (contrast) and beta (brightness) parameters until you get the result you want