Scipy otimize curve_fit

A função de mapeamento curve_fit () permite flexibilidade e oferece o controle para definir o tipo de curva em que o processo de otimização é realizado para encontrar certos parâmetros de função otimizados. O método Curve Fit () fornecido pela Scipy será abordado neste artigo. Então, com a ajuda de exemplos, veremos como usar a função da curva ().

No final deste tutorial, descobriremos como executar o encaixe da curva no Python e como o ajuste da curva usa os parâmetros otimizados em uma função que mapeia os exemplos de entrada para saída. Mas primeiro, vamos nos familiarizar com o básico de curve_fit ().

Python Scipy otimizar a função de ajuste da curva usada para?

A função de ajuste da curva de otimização do Python Scipy é amplamente usada para obter os parâmetros de melhor ajuste. A função curve_fit () é uma função de otimização usada para encontrar o conjunto de parâmetros otimizado para uma função declarada que se encaixa perfeitamente no conjunto de dados fornecido.

A função Curve Fit () no Scipy é uma biblioteca de código aberto, usado para encaixar curvas usando mínimos quadrados não lineares. Como argumento, o curve_fit () leva os mesmos dados de entrada, dados de saída e o nome da função de mapeamento que deve ser empregado. A função de mapeamento deve aceitar amostras de dados de entrada, bem como um conjunto de parâmetros.

Ao contrário do aprendizado supervisionado, a função de ajuste da curva precisa definir as funções que mapeiam perfeitamente as entradas nas saídas. A função de mapeamento pode ser simplesmente uma linha reta, como regressão linear ou uma linha curva como uma regressão polinomial, ou pode ser qualquer outra coisa.

Sintaxe do Scipy Python.otimizar.curve_fit ()

A sintaxe da curva scipy () é fornecida abaixo.

# Scipy.otimizar.curve_fit (F, X-Data, Y-Data, Sigma = Nenhum, P0 = Nenhum)

O curve_fit () leva alguns parâmetros necessários e alguns parâmetros opcionais. O 'f' é uma função de modelo, f (a,…). O primeiro argumento é necessário deve ser a variável independente, e os argumentos restantes devem ser os parâmetros para se encaixar.

O parâmetro 'X-Data' é um parâmetro semelhante a uma matriz, que é uma variável independente em que os dados são medidos. O 'y-data' é outro parâmetro semelhante a uma matriz, que é uma variável dependente também conhecida como saída da função.

O 'sigma' é um parâmetro opcional que determina a incerteza em 'y-data'. O valor de 'sigma' poderia ser apenas simples 'nenhum', 'sequência de comprimento m, ou' MXM Array '. O parâmetro 'P0' é um palpite inicial de comprimento para os parâmetros. É um parâmetro opcional e, portanto, se não for fornecido, o valor inicial será 1.

A função curve_fit () retornará os dois valores; Popt e PCov. O 'Popt' é uma matriz que representa os valores ideais para os parâmetros para minimizar a soma dos resíduos quadrados. Ao mesmo tempo, o 'PCOV' é a matriz 2D que representa a covariância estimada de 'Popt'.

Além disso, eleva as três exceções; Erro de valor, erro de tempo de execução e aviso de otimização. O 'erro de valor' é jogado quando X-Data ou Y-Data contém Nans, ou se algum método incompatível for utilizado.

O 'Erro de tempo de execução' é jogado quando a minimização menos quadrada falha. E o 'aviso de otimização' é levantado quando a covariância do parâmetro não pode ser estimada.

Exemplo 1:

No primeiro exemplo, desenharemos uma linha reta que se encaixa nos dados fornecidos para representar a expressão do modelo linear. Depois de importar as bibliotecas Python necessárias, usamos res2 = um*res1+duas equações para criar um conjunto de dados de 30 pontos.

Para tornar o conjunto de dados mais realista, adicionamos algum ruído gaussiano aos valores RES2. Então, nós usamos o Scipy.otimizar.Técnica de ajuste da curva () para estimar os valores dos parâmetros 'um' e 'dois'. Aqui está o código de programação completo do modelo que você pode seguir.

importar numpy como p
importar matplotlib.Pyplot como mtb
Importar Scipy
De importação ccepy otimize
Def func (res1, um, dois):
retornar um*res1 + dois
res1 = p.linspace (start = -40, stop = 12, num = 30)
res2 = func (res1, 4, 2)
p.aleatório.semente (4)
ruído = 10*p.aleatório.Normal (tamanho = res2.tamanho)
res2 = res2 + ruído
Popt, Cov = Scipy.otimizar.curve_fit (func, res1, res2)
um, dois = popt
x_new_value = p.Arange (min (res1), 20, 5)
y_new_value = func (x_new_value, um, dois)
mtb.dispersão (res1, res2, color = "vermelho")
mtb.plot (x_new_value, y_new_value, color = "roxo")
mtb.xlabel ('x')
mtb.ylabel ('y')
print ("Valor estimado de um:"+ str (um))
print ("Valor estimado de dois:" + str (dois))
mtb.mostrar()

Abaixo, você pode encontrar o resultado do código anexado acima. Os pontos vermelhos na tela resultante representam os pontos de dados reais do conjunto de dados.

Por outro.otimizar.Método Curve Fit (). Além disso, ele também fornece o valor estimado dos parâmetros 'One' e 'Two', que também é calculado pelo Scipy.otimizar.Técnica de ajuste da curva ().

Exemplo 2:

No segundo exemplo, explicaremos o uso do Scipy.otimizar.Método curve_fit () para plotar a curva exponencial que se encaixa em nossos dados.

Aqui, usamos res2 = um*res2+uma equação para criar um conjunto de dados de pontos diferentes. O código restante do programa é o mesmo que o exemplo acima. Aqui está o código para plotar a curva exponencial com a função curve_fit ().

Importar numpy como p
importar matplotlib.Pyplot como mtb
Importar Scipy
De importação ccepy otimize
Def func (res1, um, dois):
Retorne um*P.exp (dois*res1)
res1 = p.Linspace (12, 20, 30)
res2 = func (res1, 0.4, 0.3)
Imprimir (res2)
ruído = 100*p.aleatório.Normal (tamanho = res2.tamanho)
res2 = res2 + ruído
Imprimir (res2)
Popt, Cov = Scipy.otimizar.curve_fit (func, res1, res2)
um, dois = popt
x_new_value = p.Arange (min (res1), max (res1), 1)
y_new_value = func (x_new_value, um, dois)
mtb.dispersão (res1, res2, color = "verde")
mtb.plot (x_new_value, y_new_value, color = "azul")
mtb.xlabel ('x')
mtb.ylabel ('y')
Imprimir (“Valor estimado de um:“+ str (um))
Imprimir (“Valor estimado de dois:“ + str (dois))
mtb.mostrar()

Vamos ver a saída.

Aqui, você pode ver a representação gráfica.

Exemplo 3:

No terceiro exemplo, plotamos as duas curvas simultaneamente em torno da linha real para ver a diferença entre os dois valores. Veja o código abaixo.

No código, importamos os módulos e definimos a função (indicada como func_one). Depois disso, definimos os valores e chamamos a função curve_fit para plotar esses valores no gráfico.

importar matplotlib.Pyplot como mtb
importar numpy como p
de Scipy.Otimize a importação curve_fit
def func_one (res1, um, dois, três):
Retorne um * P.exp (-two * res1) + três
res1_data = p.Linspace (0, 2, 40)
res2 = func_one (res1_data, 1.5, 1.2, 0.6)
rng = p.aleatório.default_rng ()
res2_noise = 0.2 * rng.Normal (tamanho = res1_data.tamanho)
res2_data = res2 + res2_noise
mtb.plot (res1_data, res2_data, 'b-', etiqueta = 'dados')
Popt, pcov = curve_fit (func_one, res1_data, res2_data)
Popt
mtb.plot (res1_data, func_one (res1_data, *popt), 'r-',
Label = 'Fit: One =%5.3f, dois =%5.3f, três =%5.3F ' % de tupla (popt))
Popt, pcov = curve_fit (func_one, res1_data, res2_data, limites = (0, [3., 1., 0.5]))
Popt
mtb.plot (res1_data, func_one (res1_data, *popt), 'g--',
Label = 'Fit: One =%5.3f, dois =%5.3f, três =%5.3F ' % de tupla (popt))
mtb.xlabel ('x')
mtb.ylabel ('y')
mtb.lenda()
mtb.mostrar()

A saída está abaixo de onde você pode ver as curvas resultantes.

Conclusão

Neste artigo, fornecemos todos os detalhes sobre o uso da função Cuver_fit () fornecida pela Scipy. Começamos com a introdução da função curve_fit () e depois aprendemos a sintaxe da função curve_fit (). Depois disso, vimos alguns exemplos úteis de como a função curve_fit () é usada para plotar as linhas e curvas no python. Você pode executar esses exemplos por conta própria para ver a produção e uma melhor compreensão geral de todo o conceito.