Biopython có sử dụng numpy không?

Keras được sử dụng bởi CERN, NASA, NIH và nhiều tổ chức khoa học khác trên thế giới (và vâng, Keras được sử dụng tại LHC). Keras có tính linh hoạt cấp thấp để thực hiện các ý tưởng nghiên cứu tùy ý trong khi cung cấp các tính năng tiện lợi cấp cao tùy chọn để tăng tốc chu kỳ thử nghiệm

Python has momeoryerror is giới hạn của hệ thống RAM của bạn mà bạn đã xác định thủ công với gói

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
0

Nội dung chính Hiển thị

  • Đo lường sử dụng bộ nhớ
  • Điều gì làm cho một số nguyên trong Python
  • Move to Numpy
  • Numpy để giải cứu
  • Python có thể sử dụng nhiều bộ nhớ không?
  • Làm cách nào để giảm sử dụng bộ nhớ?
  • C có sử dụng ít bộ nhớ hơn Python không?

Xác định lớp của bạn với các vị trí làm cho trình thông dịch Python biết rằng các thuộc tính/thành viên trong lớp của bạn đã được chỉnh sửa. Và có thể dẫn đến bộ nhớ tiết kiệm đáng kể

Bạn có thể giảm sự sáng tạo của Dict bằng phiên bản Python bằng cách sử dụng

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
1. Điều này sẽ nói với việc thông dịch viên không tạo ra chính tả trong nội bộ và tái sử dụng cùng một biến

Nếu bộ nhớ được tiêu thụ bởi quá trình Python của bạn sẽ tiếp tục phát triển theo thời gian. This way as the end of the end of

  • Làm thế nào bộ phân bổ bộ nhớ C trong Python đang hoạt động. Điều này nói về cơ bản là phân mảnh bộ nhớ, bởi vì phần bổ sung không thể gọi là 'miễn phí trừ khi toàn bộ khối bộ nhớ không được sử dụng. Nhưng việc sử dụng bộ nhớ thông thường không hoàn toàn phù hợp với các đối tượng mà bạn đang tạo và sử dụng
  • Use a small string to so sánh dữ liệu. Một quy trình được gọi là Interning được sử dụng nội bộ nhưng tạo ra nhiều chuỗi nhỏ mang lại tải xuống cho trình thông dịch

Cách tốt nhất là tạo luồng công nhân hoặc nhóm chủ đề đơn để thực hiện công việc của bạn và làm mất hiệu lực công nhân/giết để giải phóng các tài nguyên được đính kèm/sử dụng trong luồng công nhân

Mã bên dưới để tạo nhân viên chủ đề đơn

__slot__ = ('dna1','dna2','lock','errorResultMap')
lock = threading.Lock()
errorResultMap = []
def process_dna_compare(dna1, dna2):
    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
        futures = {executor.submit(getDnaDict, lock, dna_key): dna_key for dna_key in dna1}
    '''max_workers=1 will create single threadpool'''
    dna_differences_map={}
    count = 0
    dna_processed = False;
    for future in concurrent.futures.as_completed(futures):
        result_dict = future.result()
        if result_dict :
            count += 1
            '''Do your processing XYZ here'''
    logger.info('Total dna keys processed ' + str(count))

def getDnaDict(lock,dna_key):
    '''process dna_key here and return item'''
    try:
        dataItem = item[0]
        return dataItem
    except:
        lock.acquire()
        errorResultMap.append({'dna_key_1': '', 'dna_key_2': dna_key_2, 'dna_key_3': dna_key_3,
                          'dna_key_4': 'No data for dna found'})
        lock.release()
        logger.error('Error in processing dna :'+ dna_key)
    pass

if __name__ == "__main__":
    dna1 = '''get data for dna1'''
    dna2 = '''get data for dna2'''
    process_dna_compare(dna1,dna2)
    if errorResultMap != []:
       ''' print or write to file the errorResultMap'''

Mã dưới đây sẽ giúp bạn hiểu cách sử dụng bộ nhớ

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()

Đầu ra để sử dụng bộ nhớ

list l has 3 objects of type Dna()
function                   2021
wrapper_descriptor         1072
dict                       998
method_descriptor          778
builtin_function_or_method 759
tuple                      667
weakref                    577
getset_descriptor          396
member_descriptor          296
type                       180

Đọc thêm về các khe vui

Hãy nói rằng bạn muốn lưu trữ một danh sách các số nguyên trong Python

list_of_numbers = []
for i in range(1000000):
    list_of_numbers.append(i)

Những con số đó có thể dễ dàng phù hợp với số nguyên 64 bit, vì vậy người ta sẽ hy vọng Python sẽ lưu trữ hàng triệu số nguyên đó không quá ~ 8MB. một triệu đối tượng 8 byte

Trên thực tế, Python sử dụng nhiều RAM hơn 35 MB để lưu trữ các số này. tại sao?

Hãy cùng xem những gì xảy ra dưới mui xe, và sau đó sử dụng Numpy có thể loại bỏ chi phí này

Đo lường sử dụng bộ nhớ

Nếu chúng tôi thiết lập mã hồ sơ mã ở trên, thì đây là phần bổ sung được sử dụng

Như bạn có thể thấy nếu bạn di chuột hoặc nhấp vào khung hình

  • ~ 8MB được bổ sung cho danh sách
  • ~ 28MB được bổ sung cho các số nguyên

Lưu ý bên cạnh. Bạn sẽ nhận được cùng một cách sử dụng bộ nhớ nếu bạn đã làm

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
2, nhưng tôi đã cấu trúc mã hóa theo cách này để làm cho nó rõ ràng hơn nơi mỗi phần sử dụng bộ nhớ xuất hiện. Bạn sẽ nhận được mức sử dụng bộ nhớ tương tự nếu bạn thực hiện
import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
2, nhưng tôi đã cấu trúc mã theo cách này để làm rõ hơn vị trí của từng đoạn sử dụng bộ nhớ

Danh sách lấy nhiều bộ nhớ đó là một danh sách Python đáng ngạc nhiên về cơ bản là một loạt các gợi ý cho các đối tượng Python có ý nghĩa. Danh sách của chúng tôi có một triệu mục, con trỏ trên máy tính 64 bit hiện mất 8 byte, vì vậy chúng tôi đã quay trở lại RAM 8MB

Nhưng tại sao các số nguyên lấy 28MB?

Điều gì làm cho một số nguyên trong Python

Chúng ta có thể đo mức sử dụng bộ nhớ của các đối tượng Python trong byte bằng cách sử dụng

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
0.
>>> import sys
>>> sys.getsizeof(123)
28

Vì một số nguyên sử dụng 28 byte nên bây giờ chúng ta đã biết lý do tại sao một triệu nguyên làm mất 28 MB RAM. Nhưng tại sao các số nguyên của Python lại mất nhiều bộ nhớ?

Mỗi đối tượng trong khai thác Python mặc định, CPython, cũng là một cấu trúc

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
1 C hoặc một trong các biến thể của nó. Ở đây, những gì
import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
1 trông giống như.
import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
2

Vì vậy, bất kỳ đối tượng Python nào cũng bao gồm ở mức tối thiểu

  • Một lượng tham khảo, theo dõi lượng tài liệu tham khảo có đối tượng
  • Một con trỏ đến loại, trong trường hợp của chúng tôi loại nguyên
  • Bất kỳ dữ liệu nào là cần thiết để lưu trữ đối tượng

Trên hệ điều hành 64 bit, mặc định ngày nay, hai mục đầu tiên có nghĩa là tối thiểu 16 byte chi phí cho mỗi đối tượng

Ngay cả khi bạn có thể tìm thấy dữ liệu của mình thành một byte, điều đó không quan trọng, bạn vẫn phải chịu đựng chi phí đó

Move to Numpy

Để tiết kiệm điện cho bạn chi phí đó, các mảng numpy đang lưu trữ các số không lưu trữ tham chiếu đến các đối tượng Python, giống như một danh sách Python bình thường. Thay vào đó, mảng numpy chỉ lưu trữ các con số

Điều đó có nghĩa là bạn không phải trả phí 16+ byte cho mỗi số trong mảng

Ví dụ. if they ta setting cấu hình cách sử dụng bộ nhớ cho đoạn mã này

import objgraph
import random
import inspect

class Dna(object):
    def __init__(self):
        self.val = None
    def __str__(self):
        return "dna – val: {0}".format(self.val)

def f():
    l = []
    for i in range(3):
        dna = Dna()
        #print “id of dna: {0}”.format(id(dna))
        #print “dna is: {0}”.format(dna)
        l.append(dna)
    return l

def main():
    d = {}
    l = f()
    d['k'] = l
    print("list l has {0} objects of type Dna()".format(len(l)))
    objgraph.show_most_common_types()
    objgraph.show_backrefs(random.choice(objgraph.by_type('Dna')),
    filename="dna_refs.png")

    objgraph.show_refs(d, filename='myDna-image.png')

if __name__ == "__main__":
    main()
3

Chúng ta có thể thấy rằng việc sử dụng bộ nhớ để tạo mảng chỉ là 8 MB, như chúng ta mong đợi, cộng với chi phí bộ nhớ của việc nhập Numpy

Lưu ý bên lề. Đây không phải là cách bạn viết mã không thành ngữ hoặc hiệu quả, tôi chỉ cấu trúc mã theo cách này cho các mục đích giáo dục. Đây không phải là cách bạn viết mã NumPy thành ngữ hoặc hiệu quả, tôi chỉ cấu trúc mã theo cách này cho mục đích giáo dục

Numpy để giải cứu

Đi từ 8MB đến 35MB có thể là thứ bạn có thể sống cùng, nhưng đi từ 8GB đến 35GB có thể sử dụng bộ nhớ quá nhiều. Vì vậy, trong khi rất nhiều lợi ích của việc sử dụng Numpy là CPU cải tiến hiệu suất mà bạn có thể có được cho các hoạt động số, một lý do khác mà nó rất hữu ích là bộ nhớ giảm chi phí

Nếu bạn xử lý danh sách các số lớn trong bộ nhớ, hãy đảm bảo rằng bạn đang sử dụng các mảng Numpy. Và nếu việc sử dụng bộ nhớ vẫn còn quá cao, bạn có thể bắt đầu xem xét các cách giảm sử dụng bộ nhớ nhiều hơn, giống như nén trong bộ nhớ