LINUX.ORG.RU

История изменений

Исправление peregrine, (текущая версия) :

Я спал. Чекнул, проверяй, чёт ничего не изменилось у меня по скорости, какие-то доли секунды. А я даже сделал размер 3840x2160, результат в случае изменения цикла и без: 

0:00:24.901781
0:00:25.444802
Ух, прямо в разы. Ух оптимизация. В 100 раз размер увеличивать чтобы точно ни в какой кеш не влезло, мне лень, один фиг таких мониторов нету. Ну или я не правильно понял и ты предлагаешь и алгоритм генерации поменять (расположение пикселей), давай сюда правильный цикл. На всякий случай дам тебе код изменённой версии, а то вдруг ты изменять сам результат предлагаешь (по вертикали там картинку развернуть или отзеркалить как-то): 
from PIL import Image
import sympy
import random
from datetime import datetime

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = (0, 0, 0, 255)  # цвет фона RGBA
front_color = (109, 167, 65, 255)  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
im = Image.new('RGBA', (x, y))  # создание "пустой" картинки в RGBA формате
for i in range(0, y):
    for j in range(0, x):
        if sympy.isprime((j + shift_x) ^ (i + shift_y)):
            im.putpixel((j, i), front_color)
        else:
            im.putpixel((j, i), background_color)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
А всё потому, что putpixel пипец какая медленная функция и то как pillow в недрах хранит картинку я, да и ты не смотрели. И да, у нас Python, а не сишка, как Python памятью управляет вообще не очевидно. Но вдруг я ничего не понимаю и размер надо ещё больше? Кеш моего процессора 6 MB, размер сырого пикселя в RGBA (а тут она используется) 4*8=32 бита. В таком случае, размер картинки, чтобы она не влезла в него должен превышать 50331648 бит, т.е. должно быть не менее 1 572 864 пикселей. Картинка 3840x2160 содержит в себе 8 249 400 пикселей, что явно больше. Может это надо по одной оси, чтобы он строчку кешировать не мог, тогда, извините, время на работу увеличится в 167 770 раз при сохранении пропорций, что составит каких-то жалких 48.5 дней. Ух как много смысла оптимизировать, это же типичный юзкейс алгоритма на поиграться — генерировать картинки по 38 терапикселей (и вообще преждевременные оптимизации — зло)! Где ошибка?

Ну а вот оптимизация с добавлением капельки ума: 

from PIL import Image
import sympy
import random
from datetime import datetime
import numpy as np

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = np.array([0, 0, 0, 255], dtype='uint8')  # цвет фона RGBA
front_color = np.array([109, 167, 65, 255], dtype='uint8')  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
image_pixels = np.tile(background_color, (y, x, 1))
for i in range(0, x):
    for j in range(0, y):
        if sympy.isprime((i + shift_x) ^ (j + shift_y)):
            image_pixels[j, i] = front_color
im = Image.fromarray(image_pixels)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
Что характерно время стало: 
0:00:17.416809
Я не знаю, что у вас там за калькуляторы с магнитной лентой вместо оперативки или перфолентами, чтобы доступ был последовательным, единственное что на ум приходит, так это свап на HDD и оптимизация для него, но моему ноуту уже лет 6, а проц в нём вообще 2013 года выпуска.

Исправление peregrine, :

Я спал. Чекнул, проверяй, чёт ничего не изменилось у меня по скорости, какие-то доли секунды. А я даже сделал размер 3840x2160, результат в случае изменения цикла и без: 

0:00:24.901781
0:00:25.444802
Ух, прямо в разы. Ух оптимизация. В 100 раз размер увеличивать чтобы точно ни в какой кеш не влезло, мне лень, один фиг таких мониторов нету. Ну или я не правильно понял и ты предлагаешь и алгоритм генерации поменять (расположение пикселей), давай сюда правильный цикл. На всякий случай дам тебе код изменённой версии, а то вдруг ты изменять сам результат предлагаешь (по вертикали там картинку развернуть или отзеркалить как-то): 
from PIL import Image
import sympy
import random
from datetime import datetime

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = (0, 0, 0, 255)  # цвет фона RGBA
front_color = (109, 167, 65, 255)  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
im = Image.new('RGBA', (x, y))  # создание "пустой" картинки в RGBA формате
for i in range(0, y):
    for j in range(0, x):
        if sympy.isprime((j + shift_x) ^ (i + shift_y)):
            im.putpixel((j, i), front_color)
        else:
            im.putpixel((j, i), background_color)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
А всё потому, что putpixel пипец какая медленная функция и то как pillow в недрах хранит картинку я, да и ты не смотрели. И да, у нас Python, а не сишка, как Python памятью управляет вообще не очевидно. Но вдруг я ничего не понимаю и размер надо ещё больше? Кеш моего процессора 6 MB, размер сырого пикселя в RGBA (а тут она используется) 4*8=32 бита. В таком случае, размер картинки, чтобы она не влезла в него должен превышать 50331648 бит, т.е. должно быть не менее 1 572 864 пикселей. Картинка 3840x2160 содержит в себе 8 249 400 пикселей, что явно больше. Может это надо по одной оси, чтобы он строчку кешировать не мог, тогда, извините, время на работу увеличится в 167 770 раз при сохранении пропорций, что составит каких-то жалких 48.5 дней. Ух как много смысла оптимизировать, это же типичный юзкейс алгоритма на поиграться — генерировать картинки по 38 терапикселей (и вообще преждевременные оптимизации — зло)! Где ошибка?

Ну а вот оптимизация с добавлением капельки ума: 

from PIL import Image
import sympy
import random
from datetime import datetime
import numpy as np

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = np.array([0, 0, 0, 255], dtype='uint8')  # цвет фона RGBA
front_color = np.array([109, 167, 65, 255], dtype='uint8')  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
image_pixels = np.tile(background_color, (y, x, 1))
for i in range(0, x):
    for j in range(0, y):
        if sympy.isprime((i + shift_x) ^ (j + shift_y)):
            image_pixels[j, i] = front_color
im = Image.fromarray(image_pixels)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
Что характерно время стало: 
0:00:17.416809
Я не знаю, что у вас там за калькуляторы с магнитной лентой вместо оперативки, чтобы доступ был последовательным, единственное что на ум приходит, так это свап на HDD и оптимизация для него, но моему ноуту уже лет 6, а проц в нём вообще 2013 года выпуска.

Исправление peregrine, :

Я спал. Чекнул, проверяй, чёт ничего не изменилось у меня по скорости, какие-то доли секунды. А я даже сделал размер 3840x2160, результат в случае изменения цикла и без: 

0:00:24.901781
0:00:25.444802
Ух, прямо в разы. Ух оптимизация. В 100 раз размер увеличивать чтобы точно ни в какой кеш не влезло, мне лень, один фиг таких мониторов нету. Ну или я не правильно понял и ты предлагаешь и алгоритм генерации поменять (расположение пикселей), давай сюда правильный цикл. На всякий случай дам тебе код изменённой версии, а то вдруг ты изменять сам результат предлагаешь (по вертикали там картинку развернуть или отзеркалить как-то): 
from PIL import Image
import sympy
import random
from datetime import datetime

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = (0, 0, 0, 255)  # цвет фона RGBA
front_color = (109, 167, 65, 255)  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
im = Image.new('RGBA', (x, y))  # создание "пустой" картинки в RGBA формате
for i in range(0, y):
    for j in range(0, x):
        if sympy.isprime((j + shift_x) ^ (i + shift_y)):
            im.putpixel((j, i), front_color)
        else:
            im.putpixel((j, i), background_color)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
А всё потому, что putpixel пипец какая медленная функция и то как pillow в недрах хранит картинку я, да и ты не смотрели. И да, у нас Python, а не сишка, как Python памятью управляет вообще не очевидно. Но вдруг я ничего не понимаю и размер надо ещё больше? Кеш моего процессора 6 MB, размер сырого пикселя в RGBA (а тут она используется) 4*8=32 бита. В таком случае, размер картинки, чтобы она не влезла в него должен превышать 50331648 бит, т.е. должно быть не менее 1 572 864 пикселей. Картинка 3840x2160 содержит в себе 8 249 400 пикселей, что явно больше. Может это надо по одной оси, чтобы он строчку кешировать не мог, тогда, извините, время на работу увеличится в 167 770 раз при сохранении пропорций, что составит каких-то жалких 48.5 дней. Ух как много смысла оптимизировать, это же типичный юзкейс алгоритма на поиграться — генерировать картинки по 38 терапикселей (и вообще преждевременные оптимизации — зло)! Где ошибка?

Ну а вот оптимизация с добавлением капельки ума: 

from PIL import Image
import sympy
import random
from datetime import datetime
import numpy as np

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = np.array([0, 0, 0, 255], dtype='uint8')  # цвет фона RGBA
front_color = np.array([109, 167, 65, 255], dtype='uint8')  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
image_pixels = np.tile(background_color, (y, x, 1))
for i in range(0, x):
    for j in range(0, y):
        if sympy.isprime((i + shift_x) ^ (j + shift_y)):
            image_pixels[j, i] = front_color
im = Image.fromarray(image_pixels)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
Что характерно время стало: 
0:00:17.416809
Я не знаю, что у вас там за калькуляторы с магнитной лентой вместо оперативки, чтобы доступ был последовательным, единственное что на ум приходит, так это свап, но моему ноуту уже лет 6, а проц в нём вообще 2013 года выпуска.

Исходная версия peregrine, :

Я спал. Чекнул, проверяй, чёт ничего не изменилось у меня по скорости. А я даже сделал размер 3840x2160, результат в случае изменения цикла и без: 

0:00:24.901781
0:00:25.444802
Ух, прямо в разы. Ух оптимизация. В 100 раз размер увеличивать чтобы точно ни в какой кеш не влезло, мне лень, один фиг таких мониторов нету. Ну или я не правильно понял и ты предлагаешь и алгоритм генерации поменять (расположение пикселей), давай сюда правильный цикл. На всякий случай дам тебе код изменённой версии, а то вдруг ты изменять сам результат предлагаешь (по вертикали там картинку развернуть или отзеркалить как-то): 
from PIL import Image
import sympy
import random
from datetime import datetime

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = (0, 0, 0, 255)  # цвет фона RGBA
front_color = (109, 167, 65, 255)  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
im = Image.new('RGBA', (x, y))  # создание "пустой" картинки в RGBA формате
for i in range(0, y):
    for j in range(0, x):
        if sympy.isprime((j + shift_x) ^ (i + shift_y)):
            im.putpixel((j, i), front_color)
        else:
            im.putpixel((j, i), background_color)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
А всё потому, что putpixel пипец какая медленная функция и то как pillow в недрах хранит картинку я, да и ты не смотрели. И да, у нас Python, а не сишка, как Python памятью управляет вообще не очевидно. Но вдруг я ничего не понимаю и размер надо ещё больше? Кеш моего процессора 6 MB, размер сырого пикселя в RGBA (а тут она используется) 4*8=32 бита. В таком случае, размер картинки, чтобы она не влезла в него должен превышать 50331648 бит, т.е. должно быть не менее 1 572 864 пикселей. Картинка 3840x2160 содержит в себе 8 249 400 пикселей, что явно больше. Может это надо по одной оси, чтобы он строчку кешировать не мог, тогда, извините, время на работу увеличится в 167 770 раз при сохранении пропорций, что составит каких-то жалких 48.5 дней. Ух как много смысла оптимизировать, это же типичный юзкейс алгоритма на поиграться — генерировать картинки по 38 терапикселей (и вообще преждевременные оптимизации — зло)! Где ошибка?

Ну а вот оптимизация с добавлением капельки ума: 

from PIL import Image
import sympy
import random
from datetime import datetime
import numpy as np

start_time = datetime.now()
x = 3840  # разрешение по оси x
y = 2160  # разрешение по оси y
background_color = np.array([0, 0, 0, 255], dtype='uint8')  # цвет фона RGBA
front_color = np.array([109, 167, 65, 255], dtype='uint8')  # цвет рисунка RGBA
shift_x = random.randint(0, 10000)  # сдвиг по оси x
shift_y = random.randint(0, 10000)  # сдвиг по оси y
image_pixels = np.tile(background_color, (y, x, 1))
for i in range(0, x):
    for j in range(0, y):
        if sympy.isprime((i + shift_x) ^ (j + shift_y)):
            image_pixels[j, i] = front_color
im = Image.fromarray(image_pixels)
im.save(f'img_x{shift_x}_y{shift_y}.png')  # сохранение картинки
print(datetime.now() - start_time)
Что характерно время стало: 
0:00:17.416809
Я не знаю, что у вас там за калькуляторы с магнитной лентой вместо оперативки, чтобы доступ был последовательным, единственное что на ум приходит, так это свап, но моему ноуту уже лет 6, а проц в нём вообще 2013 года выпуска.