SciPy é uma biblioteca python útil na solução de muitas equações matemáticas e algoritmos. Ele é projetado no topo da biblioteca Numpy que dá mais extensão para encontrar fórmulas matemáticas científicas como Matrix Rank, Inverse, equações polinomiais, LU Decomposition, etc. Usar suas funções de alto nível reduzirá significativamente a complexidade do código e ajudará na melhor análise os dados. SciPy é uma sessão Python interativa usada como uma biblioteca de processamento de dados feita para competir com seus concorrentes como MATLAB, Octave, R-Lab, etc. Possui muitas funções amigáveis, eficientes e fáceis de usar que ajudam a resolver problemas como integração numérica, interpolação, otimização, álgebra linear e estatística.

A vantagem de usar a biblioteca SciPy em Python ao fazer modelos de ML é que ela também disponibiliza uma linguagem de programação forte para uso no desenvolvimento de programas e aplicativos menos complexos.

# import numpy library
import numpy as np
A = np.array([[1,2,3],[4,5,6],[7,8,8]])

Álgebra Linear

  1. Determinante de uma Matriz




    # importing linalg function from scipy
    from scipy import linalg
      
    # Compute the determinant of a matrix
    linalg.det(A)
    Saída :
2,999999999999999

  2. Calcule a decomposição LU pivotada de uma matriz A
     decomposição LU é um método que reduz a matriz em partes constituintes que ajuda no cálculo mais fácil de operações de matriz complexas. Os métodos de decomposição, também chamados de métodos de fatoração de matrizes, são a base da álgebra linear em computadores, mesmo para operações básicas como resolver sistemas de equações lineares, calcular o inverso e calcular o determinante de uma matriz. 
    A decomposição é: 
    A = PLU 
    onde P é uma matriz de permutação, L triangular inferior com elementos diagonais unitários e U triangular superior.



    P, L, U = linalg.lu(A)
    print(P)
    print(L)
    print(U)
    # print LU decomposition
    print(np.dot(L,U))
    Saída :
array ([[0., 1., 0.],
       [0., 0., 1.],
       [1., 0., 0.]])

array ([[1., 0., 0.],
       [0,14285714, 1., 0.],
       [0,57142857, 0,5, 1.]])

matriz ([[7., 8., 8.],
       [0, 0,85714286, 1,85714286],
       [0., 0., 0.5]])

matriz ([[7., 8., 8.],
       [1., 2., 3.],
       [4., 5., 6.]])

  3. Valores próprios e vetores próprios desta matriz



    eigen_values, eigen_vectors = linalg.eig(A)
    print(eigen_values)
    print(eigen_vectors)
    Saída :
matriz ([15.55528261 + 0.j, -1.41940876 + 0.j, -0.13587385 + 0.j])

matriz ([[- 0,24043423, -0,67468642, 0,51853459],
       [-0,54694322, -0,23391616, -0,78895962],
       [-0,80190056, 0,70005819, 0,32964312]])

  4. A resolução de sistemas de equações lineares também pode ser feita



    v = np.array([[2],[3],[5]])
    print(v)
    s = linalg.solve(A,v)
    print(s)
    Saída :
array ([[2],
       [3],
       [5]])

array ([[- 2,33333333],
       [3,666666667],
       [-1. ]])



Álgebra Linear Esparsa


SciPy tem algumas rotinas para computação com matrizes esparsas e potencialmente muito grandes. As ferramentas necessárias estão no submódulo scipy.sparse. 
Vamos ver como construir uma grande matriz esparsa:


# import necessary modules
from scipy import sparse
# Row-based linked list sparse matrix
A = sparse.lil_matrix((1000, 1000))
print(A)
  
A[0,:100] = np.random.rand(100)
A[1,100:200] = A[0,:100]
A.setdiag(np.random.rand(1000))
print(A)


Output :
<1000x1000 sparse matrix of type ''
    with 0 stored elements in LInked List format>

<1000x1000 sparse matrix of type ''
    with 1199 stored elements in LInked List format>



  1. Álgebra Linear para Matrizes Esparsas



    from scipy.sparse import linalg
      
    # Convert this matrix to Compressed Sparse Row format.
    A.tocsr()
      
    A = A.tocsr()
    b = np.random.rand(1000)
    ans = linalg.spsolve(A, b)
    # it will print ans array of 1000 size
    print(ans)
    Saída :
matriz ([- 2,53380006e + 03, -1,25513773e + 03, 9,14885544e-01, 2,74521543e + 00,
        5.99942835e-01, 4.57778093e-01, 1.87104209e-01, 2.15228367e + 00,
        8.78588432e-01, 1.85105721e + 03, 1.00842538e + 00, 4.33970632e + 00,
        5.26601699e + 00, 2.17572231e-01, 1.79869079e + 00, 3.83800946e-01,
        2.57817130e-01, 5.18025462e-01, 1.68672669e + 00, 3.07971950e + 00,
        6.20604437e-01, 1.41365890e-01, 3.18167429e-01, 2.06457302e-01,
        8.94813817e-01, 5.06084834e + 00, 5.00913942e-01, 1.37391305e + 00,
        2.32081425e + 00, 4.98093749e + 00, 1.75492222e + 00, 3.17278127e-01,
        8.50013844e-01, 1.17524493e + 00, 1.70173722e + 00, .............))



Integração


Quando uma função é muito difícil de integrar analiticamente, basta encontrar uma solução por meio de métodos de integração numérica. SciPy também tem a capacidade de fazer integração numérica. Scipy possui métodos de integração no módulo scipy.integrate .


  1. Integrais simples
     A rotina Quad é a função importante das funções de integração do SciPy. Se a integração em mais de f (x) funcionar onde x varia de a a b, a integral se parece com isto. 
                                              \ displaystyle \ int_ {a} ^ {b} f (x) dx                                       
    Os parâmetros de quad são scipy.integrate.quad (f, a, b), onde 'f' é a função a ser integrada. Considerando que, 'a' e 'b' são os intervalos inferior e superior do limite x. Vejamos um exemplo de integração $e ^ {- x ^ 2} $no intervalo de 0 e 1 em relação a dx . 
    Vamos primeiro definir a função f (x) = e ^ (- x ^ 2), isso é feito usando uma expressão lambda e, em seguida, usar a rotina quad.



    import scipy.integrate
    f= lambda x:np.exp(-x**2)
    # print results
    i = scipy.integrate.quad(f, 0, 1)
    print(i)
    (0,7468241328124271, 8,291413475940725e-15)

    A função quad retorna os dois valores, em que o primeiro número é o valor da integral e o segundo valor é o erro provável no valor da integral.
  2. Integrais duplos
     Os parâmetros da função dblquad são scipy.integrate.dblquad (f, a, b, g, h) . Onde, 'f' é a função a ser integrada, 'a' e 'b' são as faixas inferior e superior da variável x, respectivamente, enquanto 'g' e 'h' são as funções que indicam os limites inferior e superior da variável y. 
    Como exemplo, vamos realizar a integral dupla de x * y ^ 2 no intervalo de x de 0 a 2 ey varia de 0 a 1. 
     \ newcommand {\ Int} {\ int \ limits} \ displaystyle \ Int_ {0} ^ {1} \ Int_ {0} ^ {2} x * y ^ 2 \, dx \, dy 
    Definimos as funções f, g e h, usando as expressões lambda. Observe que mesmo se geh forem constantes, como podem ser em muitos casos, elas devem ser definidas como funções, como fizemos aqui para o limite inferior.



    from scipy import integrate
    f = lambda y, x: x*y**2
    i = integrate.dblquad(f, 0, 2, lambda x: 0, lambda x: 1)
    # print the results
    print(i)
    Saída :
 (0,66666666666666667, 7,401486830834377e-15)



Há muito mais que o SciPy é capaz, como transformadas de Fourier, funções de Bessel, etc. 
Você pode consultar a documentação para obter mais detalhes!