def main():
n_samples = 4096
beta = [0, 1, 2]
p = [0.52, 0.62, 0.72]
slope = [-1.66, -0.45, -0.75]
# O exercicio pede 3.85, mas 4 é caos puro, a figura fica perfeita
rho = 3.85
a0 = 0.001
# Exercicio 1.1
S1 = powernoise(beta[0], n_samples)
S2 = powernoise(beta[1], n_samples)
S3 = powernoise(beta[2], n_samples)
# Exercicio 1.2
S4 = logistic(rho, a0, n_samples)
# Exercicio 1.3
S5 = pre.standardize(S1 + S4)
S6 = pre.standardize(S2 + S4)
S7 = pre.standardize(S3 + S4)
# Exercicio 1.4
S8 = pmodel(noValues=n_samples, p=p[0], slope=slope[0])
S9 = pmodel(noValues=n_samples, p=p[1], slope=slope[1])
S10 = pmodel(noValues=n_samples, p=p[2], slope=slope[2])
plt.figure(1)
plt.plot(S4[0:n_samples - 1], S4[1:n_samples], 'b*')
plt.xlabel('A[n]')
plt.ylabel('A[n+1]')
plt.title('Logistic Map')
plt.grid(True)
plt.show()
def main():
n_samples = 4096
beta = [0, 1, 2]
p = [0.52, 0.62, 0.72]
slope = [-1.66, -0.45, -0.75]
rho = 4
a0 = 0.001
S1 = powernoise(beta[0], n_samples)
S2 = powernoise(beta[1], n_samples)
S3 = powernoise(beta[2], n_samples)
S4 = logistic(rho, a0, n_samples)
S5 = pre.standardize(S1, S4)
S6 = pre.standardize(S2, S4)
S7 = pre.standardize(S3, S4)
S8 = pmodel(noValues=n_samples, p=p[0], slope=slope[0])
S9 = pmodel(noValues=n_samples, p=p[1], slope=slope[1])
S10 = pmodel(noValues=n_samples, p=p[2], slope=slope[2])
plt.figure(1)
plt.plot(S4[0:n_samples-1], S4[1:n_samples], 'b*')
plt.xlabel('A[n]')
plt.ylabel('A[n+1]')
plt.title('Logistic Map')
plt.grid(True)
plt.show()
def compute_physics(tx, index_A, index_B, index_C, mean=[], std=[]):
"""add the features that have physics means,
using the particle mass (index_A = 0) as the weight,
and then standardize the features and return mean and std
"""
tx_new = tx[:, index_A] * tx[:, index_B] / tx[:, index_C]
return standardize(tx_new, mean, std)
def main():
n_samples = 1024
# Ruido vermelho
S3 = powernoise(2, n_samples)
# Caos, usado para gerar o sinal S7
rho = 3.85
a0 = 0.001
S4 = logistic(rho, a0, n_samples)
# Soma os sinais e normalizae modo que <A>=0 e std=1
S7 = pre.standardize(S3 + S4)
# Sinal gerado pelo pmodel
S8 = pmodel(noValues=n_samples, p=0.52, slope=-1.66)
data = S8
z = np.linspace(0, 1024, 1024)
data_norm = waipy.normalize(data)
result = waipy.cwt(data_norm,
1,
1,
0.125,
2,
4 / 0.125,
0.72,
6,
mother='h',
name='S8')
waipy.wavelet_plot('S8', z, data_norm, 0.03125, result)
def main():
n_samples = 1024
# Ruido vermelho
S3 = powernoise(2, n_samples)
# Caos, usado para gerar o sinal S7
rho = 3.85
a0 = 0.001
S4 = logistic(rho, a0, n_samples)
# Soma os sinais e normaliza de modo que <A>=0 e std=1
S7 = pre.standardize(S3 + S4)
# Sinal gerado pelo pmodel
S8 = pmodel(noValues=n_samples, p=0.52, slope=-1.66)
data = S3
gammaS3, P_gammaS3, niS3 = SOC(data)
plt.plot(np.log10(P_gammaS3),np.log10(niS3))
plt.show()
gammaS7, P_gammaS7, niS7 = SOC(data)
plt.plot(np.log10(P_gammaS7),np.log10(niS7))
plt.show()
gammaS8, P_gammaS8, niS8 = SOC(data)
plt.plot(np.log10(P_gammaS8),np.log10(niS8))
plt.show()
def main():
S1 = powernoise(0, 2048)
S1 = pre.standardize(S1)
fitted_pdf = np.zeros((9, 2048))
distribution = [
st.uniform, st.norm, st.beta, st.laplace, st.gamma, st.expon, st.chi2,
st.cauchy, st.norm
]
for n in range(0, 9, 1):
fitted_pdf[n, :] = fit_distribution(S1, distribution[n])
x = np.linspace(-5, 5, 2048)
normal_pdf = st.norm.pdf(x)
plt.plot(x,
fitted_pdf[8, :],
"red",
label="Fitted normal dist",
linestyle="--",
linewidth=2)
plt.plot(x,
normal_pdf,
"blue",
label="Normal dist",
linestyle=":",
linewidth=2)
plt.hist(S1, density=1, color="cyan", label="Data", alpha=.5)
plt.title("Normal distribution fitting")
plt.legend()
plt.show()
def compute_theta(tx, index_theta, mean=[], std=[]):
"""compute the cosine value of the angle-like features,
and then standardize the features and return mean and std
"""
tx_new = np.cos(tx[:, index_theta])
return standardize(tx_new, mean, std)
def compute_log(tx, index_log, mean=[], std=[]):
"""compute the log value of the given features,
and then standardize the features and return mean and std
"""
tx_new = np.log10(3 + abs(tx[:, index_log]))
return standardize(tx_new, mean, std)
def main():
"""Funcao com o codigo principal do programa."""
print("\nData Analysis for 3DBMO simulations...\n")
# Desabilita as mensagens de erro do Numpy (warnings)
old_settings = np.seterr(divide='ignore', invalid='ignore', over='ignore')
# Carrega o arquivo de dados
nomeArquivo = 'surftemp504.txt'
data = np.genfromtxt(nomeArquivo, dtype='float32', filling_values=0)
# Numero de amostras do sinal
n_samples = 1024
# Ruido vermelho
S3 = powernoise(2, n_samples)
# Caos, usado para gerar o sinal S7
rho = 3.85
a0 = 0.001
S4 = logistic(rho, a0, n_samples)
# Soma os sinais e normalizae modo que <A>=0 e std=1
S7 = pre.standardize(S3 + S4)
# Sinal gerado pelo pmodel
S8 = pmodel(noValues=n_samples, p=0.52, slope=-1.66)
# data = S8
# Exibe os primeiro N valores do arquivo
N = 10
print("Original time series data (%d points): \n" % (len(data)))
print("First %d points: %s\n" % (N, data[0:10]))
print()
#-----------------------------------------------------------------
# Parametros gerais de plotagem
#-----------------------------------------------------------------
# Define os subplots
fig = plt.figure()
fig.subplots_adjust(hspace=.3, wspace=.2)
# Tamanho das fontes
tamanhoFonteEixoX = 16
tamanhoFonteEixoY = 16
tamanhoFonteTitulo = 16
tamanhoFontePrincipal = 25
# Titulo principal
tituloPrincipal = '3DBMO Time Series Analysis'
#-----------------------------------------------------------------
# Plotagem da serie original
#-----------------------------------------------------------------
# Define as cores da plotagem
corSerieOriginal = 'r'
# Titulo dos eixos da serie original
textoEixoX = 'Tempo'
textoEixoY = 'Amplitude'
textoTituloOriginal = 'Original Time Series Data'
print("1. Plotting time series data...")
# Plotagem da serie de dados
#O = fig.add_subplot(1, 3, 1)
O = fig.add_subplot(2, 1, 1)
O.plot(data, '-', color=corSerieOriginal)
O.set_title(textoTituloOriginal, fontsize=tamanhoFonteTitulo)
O.set_xlabel(textoEixoX, fontsize=tamanhoFonteEixoX)
O.set_ylabel(textoEixoY, fontsize=tamanhoFonteEixoY)
O.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
O.grid()
#-----------------------------------------------------------------
# Calculo e plotagem do PSD
#-----------------------------------------------------------------
# Calcula o PSD
freqs, power, xdata, ydata, amp, index, powerlaw, INICIO, FIM = psd(data)
# O valor do beta equivale ao index
b = index
# Define as cores da plotagem
corPSD1 = 'k'
corPSD2 = 'navy'
# Titulo dos eixos do PSD
textoPSDX = 'Frequencia (Hz)'
textoPSDY = 'Potencia'
textoTituloPSD = r'Power Spectrum Density $\beta$ = '
print("2. Plotting Power Spectrum Density...")
# Plotagem do PSD
PSD = fig.add_subplot(2, 2, 3)
PSD.plot(freqs, power, '-', color=corPSD1, alpha=0.7)
PSD.plot(xdata, ydata, color=corPSD2, alpha=0.8)
PSD.axvline(freqs[INICIO], color=corPSD2, linestyle='--')
PSD.axvline(freqs[FIM], color=corPSD2, linestyle='--')
PSD.plot(xdata,
powerlaw(xdata, amp, index),
'r-',
linewidth=1.5,
label='$%.4f$' % (b))
PSD.set_xlabel(textoPSDX, fontsize=tamanhoFonteEixoX)
PSD.set_ylabel(textoPSDY, fontsize=tamanhoFonteEixoY)
PSD.set_title(textoTituloPSD + '%.4f' % (b),
loc='center',
fontsize=tamanhoFonteTitulo)
PSD.set_yscale('log')
PSD.set_xscale('log')
PSD.grid()
#-----------------------------------------------------------------
# Calculo e plotagem do DFA
#-----------------------------------------------------------------
# Calcula o DFA 1D
alfa, vetoutput, x, y, reta, erro = dfa1d(data, 1)
# Verifica se o DFA possui um valor valido
# Em caso afirmativo, faz a plotagem
if not math.isnan(alfa):
# Define as cores da plotagem
corDFA = 'darkmagenta'
# Titulo dos eixos do DFA
textoDFAX = '$log_{10}$ (s)'
textoDFAY = '$log_{10}$ F(s)'
textoTituloDFA = r'Detrended Fluctuation Analysis $\alpha$ = '
print("3. Plotting Detrended Fluctuation Analysis...")
# Plotagem do DFA
DFA = fig.add_subplot(2, 2, 4)
DFA.plot(x,
y,
's',
color=corDFA,
markersize=4,
markeredgecolor='r',
markerfacecolor='None',
alpha=0.8)
DFA.plot(x, reta, '-', color=corDFA, linewidth=1.5)
DFA.set_title(textoTituloDFA + '%.4f' % (alfa),
loc='center',
fontsize=tamanhoFonteTitulo)
DFA.set_xlabel(textoDFAX, fontsize=tamanhoFonteEixoX)
DFA.set_ylabel(textoDFAY, fontsize=tamanhoFonteEixoY)
DFA.grid()
else:
DFA = fig.add_subplot(2, 2, 4)
DFA.set_title(textoTituloDFA + 'N.A.',
loc='center',
fontsize=tamanhoFonteTitulo)
DFA.grid()
#-----------------------------------------------------------------
# Exibe e salva a figura
#-----------------------------------------------------------------
plt.suptitle(tituloPrincipal, fontsize=tamanhoFontePrincipal)
nomeImagem = '3DBMO_PSD_DFA_2.png'
fig.set_size_inches(15, 9)
plt.savefig(nomeImagem, dpi=300, bbox_inches='tight', pad_inches=0.1)
plt.show()
from pmodel import pmodel
import preprocess as pre
from powernoise import powernoise
import numpy as np
n_samples = 1024
# Ruido vermelho
S3 = powernoise(2, n_samples)
# Caos, usado para gerar o sinal S7
rho = 3.85
a0 = 0.001
S4 = logistic(rho, a0, n_samples)
# Soma os sinais e normalizae modo que <A>=0 e std=1
S7 = pre.standardize(S3 + S4)
# Sinal gerado pelo pmodel
S8 = pmodel(noValues=n_samples, p=0.52, slope=-1.66)
data = S8
n_samples = 1024
np.savetxt('S8.txt', data)
'''
ans = hurst(S3, skip_agg=True)
print(ans)
qorders = list(range(0, 50))
generalized_hurst_expornents = basic_dfa(S3, Q=qorders, skip_agg=True)
print 'Logistic Regression with Standardized Features:'
# print 'parsing...'
# parse train and test text files
train_x = get_features('spam_train.txt')
train_y = get_classification('spam_train.txt')
test_x = get_features('spam_test.txt')
test_y = get_classification('spam_test.txt')
# print 'standardizing features...'
# standardize features
train_x = standardize(train_x)
test_x = standardize(test_x)
# add 1 y-intercept column
train_x = add_ones(train_x)
test_x = add_ones(test_x)
# print 'calculating weights...'
# find W for logistic regression with gradient descent
w = logistic_regression(train_x, train_y)
# print 'predicting...'
# make predictions
train_predictions = predict_y(train_x, w)