ⴰⵏⵥⴰⵔ Nowcasting ⵙ ⵓⵍⵎⴰⴷ ⵏ ⵜⵎⴰⵛⵉⵏⵉⵏ

ⵉⵎⵉⵔⴰ, ⵉⵎⵓⵙⵏⴰⵡⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵜⵜⵡⴰⵍⵉⵏ ⴷⴰⴽⴽⴻⵏ 90% ⵙⴻⴳ ⵢⵉⵙⴰⵍⴰⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⴷ ⵜⵉⴷⴻⵜ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵡⴰⴽⵓⴷ ⵏ 5 ⵏ ⵡⵓⵙⵙⴰⵏ. ⵜⵉⴳⵏⴰⵜⵉⵏ ⵢⴻⵜⵜⵡⴰⵅⴻⴷⵎⴻⵏ ⵙ ⵓⵎⴰⵜⴰ ⵜⵜⵡⴰⴱⵏⴰⵏⵜ ⵖⴻⴼ ⵙⵏⴰⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵎⴳⴰⵔⴰⴷⴻⵏ :

Tignatin ⵏ ⵜⴼⵉⵣⵉⴽⵜ : Tignatina ⵙⵙⴻⵇⴷⴰⵛⴻⵏⵜ ⵉⵎⵓⴷⴻⵍ (modèles) ⴰⵢ ⴷⵢⴻⵙⴷⵓⴽⴽⵍⴻⵏ ⵜⵉⵖⴰⵡⵙⵉⵡⵉⵏ ⴰⵢ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴱⵍⴻⵏ ⴰⵎ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⴰⵃⵔⵉⵛ ⵏ ⵢⵉⴳⴻⵏⵏⵉ, ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵢⵉⴳⴻⵏⵏⵉ... Tiwwura ⴰⵎ ⵜⵉⴳⵉ ⵍⵀⴰⵏ ⴷⴻⴳ ⵓⵙⵙⴻⴼⵇⴻⴷ ⵏ ⵜⴻⴳⵏⵉⵜ ⵏ ⵜⴻⴳⵏⴰⵡⵜ ⴷⴻⴳ ⵡⵓⵙⵙⴰⵏ ⵏⴻⵖ ⴷⴻⴳ ⴷⴷⵓⵕⵜ ⴰⵢ ⴷⵢⴻⵜⵜⴻⴷⴷⵓⵏ.
Tignatin ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⵜⴰⴼⵉⵣⵉⴽⵜ (ⴷⴰⵜⴰⴱⴰⵙⴻⴷ) : Tignatina ⵙⵙⴻⵇⴷⴰⵛⴻⵏⵜ ⵉⵙⴻⴼⴽⴰ ⵏ ⵓⵎⴻⵣⵔⵓⵢ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵙⵏⵓⵍⴼⵓⵏⵜ ⵉⵎⵓⴷⴻⵍ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⴷⴳⴻⵏ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉ. ⵉⵎⴻⵏⵣⴰⵢⴻⵏ ⴰⵎ ⵡⵉ ⵙⵙⴻⴽⵏⴻⵏⴷ ⵉⴳⵎⴰⴹ ⵢⴻⵍⵀⴰⵏ ⴷⴻⴳ ⵓⵙⴽⴰⵙⵉ ⵏ ⵜⴻⴳⵏⵉⵜ ⵏ ⵜⴻⴳⵏⴰⵡⵜ ⴰⵍⴰⵎⵎⴰ ⴷ 6 ⵏ ⵜⵙⴰⵄⵜⵉⵏ ⵏⴻⵖ ⴰⵢⴻⵏ ⵓⵎⵉ ⵇⵇⴰⵔⴻⵏ ⵡⴻⴰⵜⵀⴻⵔ nowcasting.

ⴷⴻⴳ ⵓⵎⴰⴳⵔⴰⴷⴰ, ⴰⴷ ⴷⵏⴻⵎⵎⴻⵙⵍⴰⵢ ⵖⴻⴼ ⵜⵖⴰⵡⵙⴰ ⵜⵉⵙ ⵙⵏⴰⵜ ⵏ ⵜⵎⵓⵖⵍⵉⵡⵉⵏ. ⴰⴷ ⴷⵏⴻⵎⵎⴻⵙⵍⴰⵢ ⵖⴻⴼ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵎⴳⴻⵔⵔⴰⴷⴻⵏ ⵏ ⵢⵉⵙⴻⴼⴽⴰ ⵏ ⵜⴻⴳⵏⵉⵜ, ⴰⵎⴻⴽ ⴰⵔⴰ ⵢⴻⵜⵜⵡⴰⵙⵙⴻⵇⴷⴻⵛ ⵓⵍⵎⴰⴷ ⵏ ⵜⵎⴰⵛⵉⵏⵉⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⵅⴷⴻⵎ ⵡⴻⴰⵜⵀⴻⵔ nowcasting, ⴷ ⵡⴰⵎⴻⴽ ⴰⵢ ⵣⴻⵎⵔⴻⵏⵜ ⵜⵎⴻⵚⴽⵉⵡⵉⵏ ⴰⵢ ⴷⵢⴻⵜⵜⵡⴰⵙⵏⵓⵍⴼⴰⵏ ⴰⴷ ⵉⵍⵉⵏⵜ ⴷ ⵜⵉⵏ ⴰⵢ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵍⴼⴰⵢⴷⴰ ⵉ ⵜⵉⴼⵔⴰⵜ ⵏ ⵡⵓⴳⵓⵔ ⴰⵎ ⵡⵉ.

ⵉⵙⴻⴼⴽⴰ ⵉ ⵓⵄⴻⵢⵢⴻⵏ ⵏ ⵓⵏⴻⵣⵡⵓ

ⵉⵎⵉ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⵜⴰⴼⵉⵣⵉⴽⵜ ⵙⵙⴻⵇⴷⴰⵛⴻⵏⵜ ⵉⵙⴻⴼⴽⴰ ⵏ ⵓⵎⴻⵣⵔⵓⵢ, ⴰⴷ ⵏⴻⴱⴷⵓ ⵙ ⵜⵎⵓⵖⵍⵉ ⴷⴻⴳ ⵢⵉⵙⴻⴼⴽⴰ ⵢⴻⵍⵍⴰⵏ.

ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⵙⵉⵏ ⵏ ⵢⵉⵖⴱⵓⵍⴰ ⵉⴳⴻⵊⴷⴰⵏⴻⵏ ⵏ ⵢⵉⵙⴻⴼⴽⴰ:

Isefka ⵏ ⵜⵓⴳⵏⴰ : Isefkaa ⵜⵜⴰⵡⵉⵏⴷ ⵜⴰⵍⵖⴰ ⵏ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵏ ⵔⵔⴰⴷⴰⵔ ⵏⴻⵖ ⵏ ⵓⴳⴻⵏⵙⴰ ⵏ ⵢⵉⵡⴻⵜ ⵏ ⵜⴻⵎⵏⴰⴹⵜ ⵜⴰⵊⵓⵖⵔⴰⴼⵉⵜ ⵢⴻⵜⵜⵡⴰⵙⵏⴻⵏ. ⵢⴻⵜⵜⵡⴰⵙⴻⵇⴷⴰⵛ ⵉ ⵓⵄⴻⵢⵢⴻⵏ ⵏ ⵓⴳⴻⴼⴼⵓⵔ, ⴰⵎⵓⵙⵙⵓ ⵏ ⵡⴰⴹⵓ ⵏⴻⵖ ⵏ ⵜⵎⴻⵥⵥⵓⵖⵜ.

Isefka ⵏ ⵜⴼⴻⵍⵡⵉⵜ : Isefkaa ⵜⵜⴰⵡⵉⵏⴷ ⵜⴰⵍⵖⴰ ⵏ ⵢⵉⴹⵔⵉⵙⴻⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵇⴻⴱⵍⴻⵏ ⴰⵎ ⵜⵎⴻⵙ, ⵍⵃⴻⵎⵍⴰ ⵏⴻⵖ ⵜⴰⵣⵎⴻⵔⵜ ⵏ ⵡⴰⴹⵓ.

ⵎⴰ ⵢⴻⵍⵍⴰ ⵙⵉⵏⴰ ⵏ ⵢⵉⵖⴱⵓⵍⴰ ⵏ ⵢⵉⵙⴻⴼⴽⴰ ⵙⵄⴰⵏ ⴰⵣⴰⵍ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵢⵉⵎⵓⴽⴰⵏ ⵉⵊⴻⵀⴷⴻⵏ, ⴰⴷ ⵏⴻⴱⴷⴻⵔ ⵖⴻⴼ ⵡⵉⴷ ⵉⵎⴻⵣⵡⵓⵔⴰ (ⵉⵙⴻⴼⴽⴰ ⵏ ⵜⵓⴳⵏⴰ ⴰⵢ ⴷⵢⴻⵜⵜⵡⴰⵊⴻⵎⵄⴻⵏ ⵙⴻⴳ ⵢⵉⵔⴰⴷⴰⵔⴻⵏ ⵏⴻⵖ ⵙⴻⴳ ⵢⵉⴳⴻⵏⵙⴰⵜⴻⵏ) ⵖⴻⴼ ⵙⵙⴻⴱⴱⴰⵜ ⵏ ⵜⴼⴻⵀⵍⵉⵜ. ⵉⵎⴻⵏⵣⴰⵢⴻⵏ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵙ ⵡⴰⵟⴰⵙ ⵙ ⵢⵉⵙⴻⴼⴽⴰ ⵏ ⵜⵓⴳⵏⴰ ⴷ ⵉⵥⴻⴹⵡⴰⵏ ⵏ ⵢⵉⵥⵓⵔⴰⵏ ⵉⵎⴻⵥⵥⵢⴰⵏⴻⵏ.

ⵖⴻⴼ ⵍⴻⵃⵙⴰⴱ ⵏ [ⵓⵅⴻⴷⴷⵉⵎ]-ⴰ (ⴰⵙⴻⵇⴷⴻⵛ ⵏ ⵓⵍⵎⴰⴷ ⵏ ⵜⵎⴰⵛⵉⵏⵉⵏ ⵖⴻⵔ ⵓⵙⵎⴻⵍ ⵏ ⵜⵓⵔⴰ.ⵀⵜⵎⵍ), ⴰⴷ ⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⵜⴰⵙⴻⴳⴷⴰ ⵏ UNet ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⴱⵏⵓ ⴰⵎⴹⵉⵇⵏⵏⴻⵖ ⵏ ⵓⵙⵎⴻⵍ ⵏ ⵜⵓⵔⴰ.

ⵜⴰⵙⴻⴳⴷⴰ

ⴰⴷ ⵜⴻⴱⴷⵓⴹ ⵙⴻⴳ ⵜⵎⴻⵚⴽⵉⵡⵜ ⵢⴻⵍⵍⴰⵏ ⵢⴰⴽⴰⵏ, ⴷ ⵜⵉⵏ ⵉ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵍⴼⴰⵢⴷⴰ ⵖⴻⴼ ⵡⴰⵟⴰⵙ ⵏ ⵙⵙⴻⴱⴱⴰⵜ, ⴳⴰⵔⴰⵙⴻⵏⵜ:

ⴰⵔⵛⵀⵉⵜⴻⵛⵜⵓⵔⴻⵙ ⵜⵜⵡⴰⵅⴻⴷⵎⴻⵏⵜ ⴷ ⵜⵜⴰⵡⵉⵍⴰⵜ ⵏ ⵓⵙⵏⵓⵍⴼⵓ ⵏ ⵢⵉⵎⵓⴽⴰⵏ ⵉⵎⴰⵢⵏⵓⵜⴻⵏ. ⵉⵎⴷⴰⵏⴻⵏ ⴰⵢ ⴷⵢⴻⵙⵏⵓⵍⴼⵓⵢⴻⵏ ⵜⵉⴳⴻⵎⵎⵉⵡⵉⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ ⵜⵜⵇⴰⴷⴰⵔⴻⵏ ⴰⴱⵔⵉⴷ ⵏ ⵜⵖⵓⵔⵉ ⴷ ⵜⵓⵛⵛⴹⴰ ⴰⴽⴽⴻⵏ ⴰⴷ ⴰⵡⴹⴻⵏ ⵖⴻⵔ ⵢⵉⴳⵎⴰⴹⵏⵙⴻⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ. ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵢⵉⴳⴻⵎⵎⴰⴹⵏⵙⴻⵏ ⵉⵏⴻⴳⴳⵓⵔⴰ, ⵏⴻⵣⵎⴻⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵖⴻⵔ ⴰⵟⴰⵙ ⵏ ⵡⴰⴽⵓⴷ.

ⵉⵎⵣⵓⵏⴻⵏ ⵢⴻⵜⵜⵡⴰⵙⵍⴻⵖⵎⴻⵏ ⵓⵇⴱⴻⵍ ⵙ ⵓⵎⴰⵜⴰ ⵍⵍⴰⵏ ⵉ ⵓⵙⴻⵇⴷⴻⵛ ⵙ ⵜⵖⴰⵡⵍⴰ. ⵎⵉ ⴰⵔⴰ ⴷⵙⵙⵓⴼⴼⵖⴻⵏ ⵢⵉⵏⴰⴳⵎⴰⵢⴻⵏ ⵜⵉⴳⴻⵎⵎⵉⵡⵉⵏⵏⵙⴻⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ, ⵙ ⵓⵎⴰⵜⴰ ⵙⵙⵓⴼⴼⵓⵖⴻⵏⴷ ⵓⵍⴰ ⴷ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵢⴻⵜⵜⵡⴰⵙⵍⴻⵖⵎⴻⵏ, ⴰⴽⴽⴻⵏ ⵉⵙⴻⵇⴷⴰⵛⴻⵏ ⵓⵔ ⵜⵜⵄⴻⴷⴷⴰⵢⴻⵏ ⴰⵔⴰ ⵖⴻⴼ ⵡⵓⴳⵓⵔⴻⵏ ⵏ ⵓⵙⵙⵉⵍⴻⵖ/ⴰⵙⵏⴻⵔⵏⵉ ⵙⴻⴳ ⵍⵇⴰⵄⴰ. ⴰⵢⴰ ⴷ ⴰⵢⴻⵏ ⵉ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵏⵏⴼⴻⵄ ⵍⴰⴷⵖⴰ ⵉ [ⵉⵎⴷⴰⵏⴻⵏ ⵉⵎⴻⵇⵔⴰⵏⴻⵏ ⴰⵟⴰⵙ, ⵉⵃⴻⵎⵎⵍⴻⵏ ⵜⵜⴰⵡⵉⵍⴰⵜ].

ⴰⵎⴻⴷⵢⴰ ⵏ ⵜⵎⴻⵚⴽⵉⵡⵜ ⵏ ⵜⵎⵓⵖⵍⵉ ⵢⴻⵜⵜⵡⴰⵙⵙⵏⴻⵏ ⴷⴻⴳⵙⴻⵏⵜ:

ⵍⴻⵏⴻⵜ (60k ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ)

ⴰⵍⴻⴽⵙNet (60 ⵏ ⵢⵉⵎⵉⵜⵔⴻⵏ ⵏ ⵢⵉⵙⵓⴹⴰⴼ)

VGG16 (138 ⵏ ⵢⵉⵙⵓⴹⴰⴼ)

ⵓⵏⴻⵟ

ⵓⵏⴻⵜ ⴷ ⵜⴰⵙⴻⴳⴷⴰ ⵉ ⴷⵢⴻⵙⴱⴻⴷⴷⴻⵏ ⴰⵥⴻⴹⴹⴰ ⵏ ⵓⵙⵎⴻⵍ ⵙ ⵍⴻⴽⵎⴰⵍⵉⵙ, ⴰⵏⴰⵎⴻⴽⵉⵙ ⵓⵔ ⵜⴻⵙⵄⵉ ⴰⵔⴰ ⴽⵔⴰ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵉⵛⵓⴷⴷⴻⵏ ⵙ ⵍⴻⴽⵎⴰⵍⵏⵙⴻⵏⵜ. ⵜⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵎ ⵜⵉⴽⴽⴻⵍⵜ ⵜⴰⵎⴻⵣⵡⴰⵔⵓⵜ ⵉ ⵢⵉⵡⴻⵏ ⵏ ⵓⵎⴰⵀⵉⵍ ⵏ ⵓⵙⵙⴻⵎⵔⴻⵙ ⵏ ⵜⵓⴳⵏⴰ ⵜⴰⵙⵏⴰⵊⵢⴰⵏⵜ. ⵉⴳⵎⴰⴹⴰ ⵙⵙⴰⵡⴹⴻⵏ ⴰⴷ ⵙⵇⴻⴷⵛⴻⵏ ⵉⵏⴰⴳⵎⴰⵢⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⵙⵏⴻⵔⵏⵉⵏ ⵖⴻⵔ ⵍⴻⵛⵖⴰⵍ ⵏⵉⴹⴻⵏ ⴷⴻⴳ ⵜⵎⵓⵖⵍⵉ ⵏ ⵓⵙⴻⵍⴽⵉⵎ.

ⴷⴻⴳ 2019, Google ⵢⴻⵙⵙⴻⵇⴷⴻⵛ ⵜⴰⵙⴻⴳⴷⴰ [ⵢⴻⴱⵏⴰⵏ ⵖⴻⴼ UNet] ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵢⴻⵙⵏⵓⵍⴼⵓ ⴰⵎⵣⵓⵏ ⵏ ⵓⵙⵏⵓⵍⴼⵓ ⵏ ⵓⴳⴻⴼⴼⵓⵔ.

ⵉⵙⴻⵎ ⵏ “UNet” ⵢⴻⴽⴽⴰⴷ ⵙⴻⴳ ⵜⴰⵍⵖⴰ ⵏ “U” ⵏ ⵜⵎⴻⵚⴽⵉⵡⵜⵉⵙ.

ⵏⴻⵙⴱⴰⵏⴷ ⴽⵔⴰⴹ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵉⴳⴻⵊⴷⴰⵏⴻⵏ:

Contracting / Encoder: Asemres ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⵥⵓⵖⵜ/ⵜⵎⴻⵥⵥⵓⵖⵜ ⵉ ⵢⴻⵜⵜⵃⴻⵜⵜⵉⵎⴻⵏ ⵜⵓⴳⵏⴰ ⵏ ⵓⵙⵎⴻⵍ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⵙⵎⴻⵍ ⵏ ⵜⵎⴻⵥⵥⵓⵖⵜ ⵜⴰⵎⴻⵛⵟⵓⵃⵜ.
ⴱⵔⵉⴷⴳⴻ / Bottleneck : ⴰⵃⵔⵉⵛ ⵏ ⴷⴷⴰⵡ ⵏ “ⵓ” ⵢⴻⵇⵇⴻⵏ ⴰⵙⴻⴽⴽⵉⵍ ⵖⴻⵔ ⵓⵙⴻⴽⴽⵉⵍ. ⵢⴻⵜⵜⵡⴰⵅⴷⴻⵎ ⵙ ⵜⵎⴻⵥⵔⵉ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ ⵏ ⵜⵎⴻⵥⵔⵉ.
Decontracting / Decoder : Asemres ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⴷ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵜⴼⴻⵍⵡⵉⵜ, ⵉ “ⵢⴻⵙⴼⴻⴹⴹⴻⵏ” ⴰⵙⴻⵏⴼⴰⵔ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵜⴼⴻⵍⵡⵉⵜ.

ⴰⵔⵛⵀⵉⵜⴻⵛⵜⵓⵔⴻ ⵏ UNet ⵜⴱⴰⵏⴷ ⴰⵎ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⴰⵔ ⴰⵙⵙⴰ. ⵎⴰⵛⴰ, ⴰⵎⴳⵉⵔⴻⴷ ⵢⴻⵍⵍⴰ ⴷⴻⴳ ⵢⵉⵙⴰⵍⵍⴻⵏ ⵢⴻⵜⵜⵄⴻⴷⴷⴰⵢⴻⵏ ⴳⴰⵔ ⵓⵎⵙⴻⴹⵔⵓ ⴷ ⵓⵎⵙⴻⴹⵔⵓ. ⵉⵙⴰⵍⴰⵏⴰ ⵜⵜⵡⴰⵄⴻⴷⴷⴰⵢⴻⵏ ⵙ ⵓⵙⴷⵓⴽⴽⴻⵍ ⵏ ⵢⵉⴳⴻⵎⵎⴰⴹ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ ⵙⴻⴳ ⵓⵙⵏⵉⵍⴻⵙ ⴰⴽⴽⴻⴷ ⵜⵉⵏ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ ⵏ ⵓⵙⵏⵉⵍⴻⵙ. ⴰⴱⴻⴷⴷⴻⵍⴰ ⵢⴻⵙⵏⴻⵔⵏⴰⵢ ⵜⵉⴼⵔⴰⵜ, ⵢⴻⵔⵏⴰ ⵢⴻⵜⵜⴰⴵⴵⴰ ⴰⵎⴹⴰⵏ ⴰⴷ ⴷⵢⴻⵙⵙⵓⴼⴼⴻⵖ ⴰⵙⴻⵏⴼⴰⵔ ⵙ ⵜⵖⴰⵡⵍⴰ ⵓⴳⴰⵔ ⴷⴻⴳ ⵓⵎⴹⵉⵇ (ⴰⵎⴽⴰⵏ ⵏ yipixel ⴷⴻⴳ ⵓⵙⴻⴽⵛⴻⵎ ⴰⴷ ⵢⵉⵍⵉ ⴷ ⴰⵢⴻⵏ ⵉⴳⴻⵔⵔⵣⴻⵏ ⵓⴳⴰⵔ, ⴰⴷ ⵢⴻⴼⵔⵓ ⵓⴳⵓⵔ ⵉ ⴷⵢⴻⴹⵔⴰⵏ ⴷⴻⴳ ⵢⵉⵎⵓⴽⴰⵏ ⵓⵔ ⵏⴻⵙⵄⵉ ⴰⵔⴰ ⴰⵙⴻⵎⵔⴻⵙ). ⵜⴰⵙⴻⵎⵍⵉⵍⵜ ⵜⴻⵜⵜⵡⴰⵅⴷⴻⵎ ⵙ ⵜⵎⴻⵥⵔⵉ (symétrie).

Lebni ⵏ Umyag ⵏ UNet ⵉ ⵓⵙⴽⴰⵙⵉ ⵏ ⵡⴰⵙⵙⴰ ⵏ ⵓⴳⴻⴼⴼⵓⵔ

ⴷⴻⴳ ⵓⵃⵔⵉⵛⴰ, ⴰⴷ ⵏⴻⴱⵏⵓ ⴰⵎⵣⵓⵏ ⵏ UNet ⵉ ⵡⴰⴽⴽⴻⵏ ⴰⴷ ⵏⵡⴰⵍⵉ ⵍⵃⴰⵍⴰ ⵏ ⵜⴻⴳⵏⴰⵡⵜ ⵙⴻⴳ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵏ ⵢⵉⴳⴻⵏⵙⴰⵜⴻⵏ. ⴰⴷ ⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⴰⵎⴹⵉⵇ ⵢⴻⵜⵜⵡⴰⵙⵍⴻⵖⵎⴻⵏ ⵓⵇⴱⴻⵍ ⵙ ⵢⵉⵙⴻⵎ ⵏ [RainNet].

ⴰⴽⴰⵔⴰⵎⴰ ⴷⴷⴰⵡⴰ ⵢⴻⵍⵍⴰ ⴷⴻⴳ [colab]agi (ⴰⵃⵔⵉⵛ).

ⵏⴻⵙⴱⴻⴷⴷⴷ ⴷⵉ ⵜⴰⵣⵡⴰⵔⴰ ⵡⵔⴰⴷⵍⵉⴱ, ⴷ ⵜⴰⵎⴽⴻⵔⴹⵉⵜ ⵏ ⵓⵖⴱⴰⵍⵓ ⵢⴻⵍⴷⵉⵏ ⵉ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵢⵉⵙⴻⴼⴽⴰ ⵏ ⵔⴰⴷⴰⵔ ⵏ ⵜⴻⴳⵏⴰⵡⵜ

!pip install wradlib
import wradlib as wrl

ⵙⵢⵉⵏ, ⵏⴻⵜⵜⴰⵔⵓ ⵙⵏⴰⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵎⴻⵥⵍⴰ (utilité) ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵏⴻⵙⵙⴻⴽⵛⴻⵎ ⵉⵙⴻⴼⴽⴰ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵙⴻⴳ ⴰⵇⴻⴷⴷⴰⵛ ⵏ ⵢⵉⵙⴻⴼⴽⴰ ⵢⴻⵍⴷⵉⵏ ⵏ DWD


import urllib.request
import io
import numpy as np
import datetime

def download_and_read_RY(RY_timestamp):
   url = f"https://opendata.dwd.de/weather/radar/radolan/ry/raa01-ry_10000-{RY_timestamp}-dwd---bin"
   data_binary = urllib.request.urlopen(url).read()
   data, attr = wrl.io.read_radolan_composite(io.BytesIO(data_binary), missing = 0)
   data = data.astype("float32")
   return data,attr

def download_data():
   latest_scan, latest_attr = download_and_read_RY("latest")
   latest_datetime = latest_attr["datetime"]
   list_for_downloading = [ts.strftime("%y%m%d%H%M") for ts in
       [latest_datetime - datetime.timedelta(minutes=t) for t in [15, 10, 5]]]
   previous_scans = np.array([download_and_read_RY(ts)[0] for ts in list_for_downloading])
   print(list_for_downloading)
   scans = np.concatenate([previous_scans, latest_scan[np.newaxis, ::, ::]], axis = 0)

   return scans, latest_datetime

ⵜⵉⵙⵏⴰⵜⵡⵉⵍⵉⵏⴰ ⵜⵜⴰⴵⴵⴰⵏⵜⴰⵖ ⴰⴷ ⴷⵏⴻⵙⵙⴻⴽⵛⴻⵎ 4 ⵏ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ ⵏ ⵢⵉⴳⴻⵏⵙⴰⵜⴻⵏ, ⴷ ⴰⵎⴹⴰⵏ ⵏ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵏ ⵢⵉⴳⴻⵏⵙⴰⵜⴻⵏ ⴰⵢ ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵜⴻⵏⵜⵏⴻⵅⴷⴻⵎ ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵙ ⵍⴻⵎⵜⴻⵍⵏⵏⴻⵖ ⴰⵢ ⴷⵏⴻⵙⵙⴻⵍⵎⴻⴷ ⵓⵇⴱⴻⵍ.

ⵏⴻⵣⵎⴻⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⵜⵉⵖⴱⵓⵍⴰ ⵢⴻⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵏⴰⵡⵉ 4 ⵏ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵜⵉⵎⴰⵢⵏⵓⵜⵉⵏ


RY_latest, RY_latest_timestep = download_data()

ⵎⵉ ⴰⵔⴰ ⴷⵏⴰⵡⵉ ⵜⵓⴳⵏⵉⵡⵉⵏ, ⵏⴻⵙⵙⴻⵅⴷⴰⵎ ⵜⴰⵔⵔⴰⵢⵜ ⵏ ⵡⵔⴰⴷⵍⵉⴱ [vis.plot_ppi.ⵀⵜⵎⵍ) ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵏⴻⵙⵙⴻⴽⵛⴻⵎ ⵉⵙⴻⴼⴽⴰ .

for i in range(RY_latest.shape[0]):
   wrl.vis.plot_ppi(RY_latest[i])

ⵏⴻⵙⵙⴻⴽⵛⴻⵎⴷ ⵜⵓⵔⴰ ⵉⵙⴻⴼⴽⴰⵏⵏⴻⵖ. ⴰⴷ n’err l’modèle ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ.

ⵏⴻⴱⴷⴰ ⵙ ⵓⵙⵙⴻⴽⵛⴻⵎ ⵏ ⵢⵉⵖⴻⵔⴱⴰⵣⴻⵏ ⵉⵛⵓⴷⴷⴻⵏ ⵖⴻⵔ ⵡⴰⵢⴰ. ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ TensorFlow ⴷⴻⴳ ⵓⵎⴰⴳⵔⴰⴷⴰ.

ⵙⴻⴳ tensorflow.ⴽⴻⵔⴰⵙ.ⵍⴰⵢⴻⵔⵙ ⵙⵙⴻⴽⵛⴻⵎⴷ ⴰⵙⴻⴽⵛⴻⵎ, Conv2D, ⴰⵙⴻⴽⵛⴻⵎ, ⴰⵙⴷⵓⴽⴽⴻⵍ, ⴰⵙⴻⵏⵇⴻⴷ ⵏ Conv2D, MaxPool2D

ⵙⴻⴳ tensorflow.ⴽⴻⵔⴰⵙ.ⵉⵎⵓⴷⴻⵍ ⵏ ⵓⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵎⵓⴷⴻⵍ

ⴰⴷ ⵏⴻⴱⵏⵓ 3 ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵍⴻⴱⵏⵉ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ. "ⵉⴼⴻⵔⴷⵉⵙⴻⵏⴰ ⵏ ⵍⴻⴱⵏⵉ" ⴰⴷ ⵜⵜⵡⴰⵙⴻⵇⴷⴰⵛⴻⵏ ⵉ ⵓⵙⵙⴻⴹⵔⵓ ⵏ ⵜⵎⴻⵚⴽⵉⵡⵜ ⴰⴽⴽ, ⵙ [ⴰⵙⴻⴹⵔⵓ]-ⴰ.

ⴰⵃⵔⵉⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⴻⵜⵜⴻⵎⵛⴰⴱⵉ ⵖⴻⵔ ⵜⵎⴻⵥⵥⵓⵖⵜ ⵏ ⵜⴻⵙⴼⵉⴼⵉⵏ ⵏ ⵜⵎⴻⵥⵥⵓⵖⵜ, ⵏⴻⵙⵙⴰⵡⴰⵍⴰⵙ "conv_block".

def conv_block(input, num_filters):
   x = Conv2D(num_filters, 3, padding ="same", kernel_initializer="he_normal"(input))
   x = Activation("relu")(x)
   x = Conv2D(num_filters, 3, padding ="same", kernel_initializer="he_normal"(x))
   x = Activation("relu")(x)
   return x

Blok ⵡⵉⵙ ⵙⵉⵏ ⵢⴻⵜⵜⵡⴰⵙⴻⵇⴷⴻⵛ ⵉ ⵍⴻⴱⵏⵉ ⵏ ⵙⴻⴳ ⵓⵃⵔⵉⵛ ⵏ ⵓⵙⴻⴽⵍⴻⵙ (blok ⵏ ⵜⵎⴻⵥⴷⵉⵜ + ⵎⴰⵅ pooling). ⵏⴻⵙⵙⴰⵡⴰⵍⴰⵙ “aḥbas_n usekles”

def encoder_block(input, num_filters):
   x = conv_block(input, num_filters)
   p = MaxPool2D((2,2))(x)
   return x,p

ⴰⵃⵔⵉⵛ ⵡⵉⵙ ⴽⵔⴰⴹ ⴷ ⴰⵏⴻⴳⴳⴰⵔⵓ ⴷ “decoder_block” (ⴰⵙⴻⵏⵇⴻⴷ + ⵓⵙⴷⵓⴽⴽⴻⵍ + ⴰⵙⵏⴻⴼⵍⵉ).

def decoder_block(input, skip_features, num_filters):
   x = Conv2DTranspose(num_filters, (2,2), strides=2, padding="same", kernel_initializer="he_normal")
   x = Concatenate()([x, skip_features])
   x = conv_block(x, num_filters)
   return x

ⵏⴻⵙⴷⵓⴽⴽⴻⵍ ⵉⵃⵔⵉⵛⴻⵏⴰⴳⵉ ⵏ ⵍⴻⴱⵏⵉ ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⴱⵏⵓ ⴰⵎⵣⵓⵏ ⵏ UNet

def build_unet(input_shape = (928, 928, 4)):

   inputs = Input(input_shape)
   e1, p1 = encoder_bock(inputs, 64)
   e2, p2 = encoder_bock(p1, 128)
   e3, p3 = encoder_bock(p2, 256)
   e4, p4 = encoder_bock(p3, 512)

   b1 = conv_block(p4, 1024)

   d1 = decoder_block(b1, e4, 512)
   d2 = decoder_block(d1, e3, 256)
   d3 = decoder_block(d2, e2, 128)
   d4 = decoder_block(d3, e1, 64)

   outputs = Conv2D(1, 1, padding="same", activation="linear")(d4)

   unet = Model(inputs, outputs, name="U-Net")

   return unet

ⵃⵓⵍⴼⵓⴷ ⵙ ⵍⵃⵉⵔ ⴰⴷ ⵜⵓⵔⴰⵔⴻⴹ ⵙ ⵓⵙⴻⴹⵔⵓ, ⴰⴷ ⵜⵜⴻⵙⵙⴻⵍⵀⵓⴹ ⵏⴻⵖ ⴰⴷ ⵜⵜⴻⵙⵙⴻⵎⵍⵉⵍⴹ ⵙ ⵜⵖⴰⵡⵙⵉⵡⵉⵏⵉⴽ ⵎⴰ ⵜⴻⴱⵖⵉⴹ ⴰⴷ ⵜⵜⴻⵙⵇⴻⴷⵛⴻⴹ ⵉ ⵡⴰⵢⴻⵏ ⵏⵏⵉⴹⴻⵏ.

ⴰⵙⵍⴻⵖⵎⵓ ⵏ ⵍⴻⵎⵜⴻⵍⴰ ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵢⴻⵟⵟⴻⴼ ⴰⵟⴰⵙ ⵏ ⵡⴰⴽⵓⴷ. ⵙ ⵍⵅⵉⵔ, ⵢⴻⵍⵍⴰ ⵢⵉⵡⴻⵏ ⵏ ⵍⴻⵎⵜⴻⵍ ⵓⵎⵉ ⵙⴻⵎⵎⴰⵏ RainNet, ⴰⵢ ⴷⵢⴻⵜⵜⵡⴰⵅⴻⵍⵇⴻⵏ ⵙ ⵍⵙⴰⵙ ⵏ ⵜⵎⴻⵚⴽⵉⵡⵜ ⵏ UNet, ⵢⴻⵔⵏⴰ ⵢⴻⵜⵜⵡⴰⵙⵙⴻⵏ ⴷⴻⴳ ⵓⵙⵙⴻⴼⵇⴻⴷ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ (nowcasting) ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ.

ⴰⴷ ⵏⵙⵏⵓⵍⴼⵓ ⴰⵖⴻⵔⴱⴰⵣⵉⵙ ⵏ GitHub

! git clone https://github.com/hydrogo/rainnet.git

ⵙⵙⵉⵏ ⴰⴽⵉⵏ ⴰⴷ ⴷⵏⴻⵙⵙⵓⴼⴻⵖ ⵜⵉⵥⴻⴹⵡⴰ ⵢⴻⵜⵜⵡⴰⵙⵍⴻⵖⵎⴻⵏ ⵓⵇⴱⴻⵍ ⵉ ⵍⴻⵎⵜⴻⵍⴰ

!wget -O /content/rainnet/rainnet_weights.h5 https://zenodo.org/record/3630429/files/rainnet_weights.h5

ⴰⴹⵔⵉⵙ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ ⴷ ⴰⵙⴻⵏⴼⴰⵔ ⵏ ⵓⵎⴹⴰⵏ ⵙ ⵍⵙⴰⵙ ⵏ ⵜⵎⴻⵚⴽⵉⵡⵜ ⵉ ⴷⵢⴻⵜⵜⵡⴰⴼⴽⴰⵏ ⴷⴻⴳ ⵓⵙⵎⴻⵍ ⵙⵢⴻⵏ ⴰⴷ ⵜⵉⴷⵜⴻⵙⵙⵓⴼⵖⴻⴹ ⵙ ⵍⵇⵉⴷⴰⵔ ⵉ ⴷⵢⴻⵜⵜⵡⴰⵙⵏⴻⵇⵙⴻⵏ ⴷⴻⴳ ⵓⵎⴹⴰⵏⴰ .

import sys
from rainnet import rainnet
model = rainnet.rainnet()
model.load_weights('/content/rainnet/rainnet_weights.h5')
model.summary()

ⵜⵓⴳⵏⵉⵡⵉⵏ ⵉ ⴷⵏⴻⵙⵙⵓⴼⴻⵖ ⵙⵄⴰⵏⵜ ⴰⵣⴰⵍ ⵏ 900*900 ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ. ⴰⴷ ⵏⴱⴻⴷⴷⴻⵍ ⵜⵓⴳⵏⵉⵡⵉⵏⴰ ⴰⴽⴽⴻⵏ ⴰⴷ ⵎⵇⴰⴱⴰⵍⴻⵏⵜ ⴷ ⵓⵙⴻⴽⵛⴻⵎ ⵢⴻⵜⵜⵡⴰⵕⴵⴰⵏ ⵏ RainNet .

def Scaler(array):
   return np.log(array+0.01)


def invScaler(array):
   return np.exp(array) - 0.01


def pad_to_shape(array, from_shape=900, to_shape=928, how="mirror"):
   # calculate how much to pad in respect with native resolution
   padding = int( (to_shape - from_shape) / 2)
   # for input shape as (batch, W, H, channels)
   if how == "zero":
       array_padded = np.pad(array, ((0,0),(padding,padding),(padding,padding),(0,0)), mode="constant", constant_values=0)
   elif how == "mirror":
       array_padded = np.pad(array, ((0,0),(padding,padding),(padding,padding),(0,0)), mode="reflect")
   return array_padded


def pred_to_rad(pred, from_shape=928, to_shape=900):
   # pred shape 12,928,928
   padding = int( (from_shape - to_shape) / 2)
   return pred[::, padding:padding+to_shape, padding:padding+to_shape].copy()

'''
the spatial extent of input data has to be a multiple of 2n+1
where n is the number of max pooling layers
'''

def data_preprocessing(X):

   # 0. Right shape for batch
   X = np.moveaxis(X, 0, -1)
   X = X[np.newaxis, ::, ::, ::]
   # 1. To log scale
   '''
   We use a log scale to respond to skewness towards large values
   '''
   X = Scaler(X)
   # 2. from 900x900 to 928x928
   X = pad_to_shape(X)

   return X


def data_postprocessing(nwcst):

   # 0. Squeeze empty dimensions
   nwcst = np.squeeze(np.array(nwcst))
   # 1. Convert back to rainfall depth
   nwcst = invScaler(nwcst)
   # 2. Convert from 928x928 back to 900x900
   nwcst = pred_to_rad(nwcst)
   # 3. Return only positive values
   nwcst = np.where(nwcst>0, nwcst, 0)
   return nwcst

ⵏⴻⵙⵏⵓⵍⴼⴰⴷ ⵙⵢⵉⵏ ⵜⴰⵖⵓⵍⵜ ⵉ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵜⵉⴳⵏⴰⵜⵉⵏ.

def prediction(model_instance, input_data, lead_time=24):

   input_data = data_preprocessing(input_data)
   nwcst = []

   for _ in range(lead_time):
       pred = model_instance.predict(input_data)
       nwcst.append(pred)
       input_data = np.concatenate([input_data[::, ::, ::, 1:], pred], axis = -1)

   nwcst = data_postprocessing(nwcst)

   return nwcst

ⵙⵙⵉⵏ ⴰⴽⵉⵏ ⴰⴷ ⵏⴻⵙⵙⴰⵡⴻⵍ ⵉ ⵜⴻⵖⵍⵉⴼⵜⴰ ⵖⴻⴼ ⵢⵉⵙⴻⴼⴽⴰ ⴰⵢ ⴷⵏⴻⵙⵙⵓⴼⴻⵖ ⵣⵉⴽ

Y_pred = prediction(model, RY_latest)

ⵏⴻⵣⵎⴻⵔ ⴰⴷ ⵏⴻⵙⵙⴻⵎⵔⴻⵙ ⵜⵉⴳⵏⴰⵜⵉⵏ, ⵢⴻⵔⵏⴰ ⴰⴷ ⵜⴻⵏⵜⵏⴻⵃⵔⴻⵣ ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⵉⴳⵎⴰⴹ ⵢⴻⵜⵜⵡⴰⵃⴻⵔⵣⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵏⴻⵙⵏⵓⵍⴼⵓ ⵜⵓⴳⵏⴰ ⵏ ⴳⵉⴼ ⴰⵔⴰ ⴰⵖⵢⴻⴵⴵⴻⵏ ⴰⴷ ⵏⵡⴰⵍⵉ ⵜⵉⴳⵏⴰⵜⵉⵏ .

import matplotlib.pyplot as plt
names = []
for i in range(0, 19):
   im = wrl.vis.plot_ppi(Y_pred[i])
   name = '/content/image'+str(i)+'.png'
   names.append(name)
   plt.savefig(name)

import imageio
from google.colab import files

imgs = []

for name in names:
   imgs.append(imageio.imread(name))

imageio.mimsave('/content/pred.gif', imgs, fps=4)
files.download('/content/pred.gif')

ⴰⵢⵓⵣ ⵉⵎⵉ ⵜⵉⴷⵜⴻⵡⵡⵉⴹ ⴰⵔⵎⵉ ⴷ ⴰⴽⴽⴰ! ⵜⵣⴻⵎⵔⴻⴹ ⵜⵓⵔⴰ ⴰⴷ ⵜⴻⵙⵇⴻⴷⵛⴻⴹ RainNet ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⴳⴻⴹ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵢⴻⵔⵏⴰ ⴰⴷ ⵜⴻⵏⵜⵡⴰⵍⵉⴹ.

ⵜⴰⴳⴳⴰⵔⴰ

ⴷⴻⴳ ⵓⵎⴰⴳⵔⴰⴷⴰ, ⵏⴻⵙⵙⴻⵅⴷⴻⵎ ⴰⵎⵓⴷ ⵏ ⵓⵍⵎⴰⴷ ⵏ ⵜⵎⴰⵛⵉⵏⵉⵏ (RainNet) ⴰⴽⴽⴻⵏ ⴰⴷ ⵏⴻⵅⴷⴻⵎ ⴰⵙⴻⵏⵇⴻⴷ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵡⴰⵙⵙⴰ. ⵏⴻⵙⵙⴻⵇⴷⴻⵛ ⵜⴰⵙⴻⴳⴷⴰ ⵏ UNet, ⵉ ⵏⴻⴱⵏⴰ ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ TensorFlow. ⵏⴻⵙⴱⴻⴷⴷⴷ ⵢⵉⵡⴻⵏ ⵏ ⵍⴻⵎⵜⴻⵍ ⵢⴻⵜⵜⵡⴰⵙⵍⴻⵖⵎⴻⵏ ⵓⵇⴱⴻⵍ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵏⴻⴱⴷⴻⵔ ⵜⵓⴳⵏⵉⵡⵉⵏ ⵏ ⵓⴳⴻⵏⵙⴰ.

ⴰⵙⴻⴹⵔⵓⴰ ⵢⴻⵣⵎⴻⵔ ⴰⴷ ⵢⴻⵜⵜⵡⴰⵙⵏⴻⵔⵏⵉ ⵙ ⵡⴰⵟⴰⵙ ⵏ ⵢⵉⴱⴻⵔⴷⴰⵏ. ⴰⵎⴻⴷⵢⴰ:

Ssnefli ⵍⴻⵎⵜⴻⵍ ⴷⴻⴳ ⵜⵎⴻⵣⴳⵓⵏⵜⵉⴽ ⵏ ⵢⵉⵙⴻⴼⴽⴰ
Seqdec ⴰⴼⴻⵔⴷⵉⵙ ⵏ ⵜⵎⵓⵖⵍⵉ, ⴰⵎ CBAM (Aferdis ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵓⴱⵔⵉⴷ ⵏ ⵜⵎⵓⵖⵍⵉ) ⴷⴻⴳ ⵜⵎⴻⵚⴽⵉⵡⵜ.

ⵜⵉⵙⵖⵓⵏⵉⵏ

[ⴰⴽⵓⵍⴰⴱ] (ⴰⵏⴰⴷⵉ.ⴳⵓⴳⵍ.
ⴰⴹⵔⵉⵙ ⵏ UNet ⴰⵏⴰⵚⵍⵉ
[ⴰⴱⵍⵓⴳ ⵏ Google ⵖⴻⴼ ⵍⴻⵎⵜⴻⵍⵏⵙⴻⵏ ⵏ UNet ⵉ ⵓⵄⴻⵢⵢⴻⵏ ⵏ ⵜⴻⴳⵏⵉⵜ ⵏ ⵜⴻⴳⵏⴰⵡⵜ]
[ⴰⵙⵙⴻⴹⵔⵓ ⵏ RainNet]
ⴰⵙⵙⴻⴹⵔⵓ ⵏ UNet

ⴰⵙⴷ ⵖⴻⵔ ⵢⵉⵡⴻⵏ ⵙⴻⴳ ⵢⵉⵅⴻⴷⴷⵉⵎⴻⵏⵏⵏⴻⵖ ⵉⵍⴻⵍⵍⵉⵢⴻⵏ!

ⴱⴷⵓ ⵛⵛⵖⴻⵍⵉⴽ ⴷ ⴰⵎⵓⵙⵏⴰⵡ ⵏ ⵢⵉⵙⴻⴼⴽⴰ ⵙ ⵜⵉⵖⴰⵡⵙⵉⵡⵉⵏⵏⵏⴻⵖ ⵜⵉⵍⴻⵍⵍⵉⵢⵉⵏ, ⴰⵢ ⴷⵢⴻⵍⵍⴰⵏ ⵙ ⵍⵙⴰⵙ ⵏ ⵡⴰⵀⵉⵍ ⵏ ⵓⵙⴻⵍⵎⴻⴷ ⴰⵢ ⵉⵣⴻⵎⵔⴻⵏ ⴰⴷ ⵢⴻⵜⵜⵡⴰⵙⵏⴻⴼⵍⵉ ⵢⴻⵔⵏⴰ ⵜⵜⵡⴰⴹⴻⴼⵔⴻⵏ ⵙⵖⵓⵔ ⵢⵉⵎⴰⵣⵣⴰⵢⴻⵏ ⵏ ⵜⴻⵎⴳⵓⵔⵉ.