def quantile_transform2(input_path, output_path):
folder_creator(output_path, 1)
for crypto in os.listdir(input_path):
df = pd.read_csv(input_path + crypto, sep=",", header=0)
qt = QuantileTransformer(n_quantiles=50,
random_state=0,
output_distribution="normal")
for feature in df.columns.values:
#todo aggironare con il while qua...
if feature not in [
'Date', 'Open', 'High', 'Close', 'Low', 'Adj Close'
]:
stat, p = stats.normaltest(df[feature])
if p <= 0.05:
print('transforming:' + feature)
p = -1
n_t = 1
while p <= 0.05:
qt = QuantileTransformer(n_quantiles=n_t,
random_state=0,
output_distribution="normal")
quanrtil = qt.fit_transform(df[feature].values.reshape(
-1, 1))
new_values = pd.Series(quanrtil.reshape(-1))
stat, p = stats.normaltest(new_values)
if p > 0.05:
df[feature] = pd.Series(new_values)
print('num_quantiles:' + str(n_t))
elif (n_t < 100):
n_t += 1
else:
break
df.to_csv(output_path + crypto, sep=",", index=False)
def quantile_transform(input_path, output_path):
folder_creator(output_path, 1)
for crypto in os.listdir(input_path):
print(crypto)
df = pd.read_csv(input_path + crypto, sep=",", header=0)
for feature in df.columns.values:
if feature != "Date":
print('transforming:' + feature)
p = -1
n_t = 1
while p <= 0.05:
qt = QuantileTransformer(n_quantiles=n_t,
random_state=0,
output_distribution="normal")
quanrtil = qt.fit_transform(df[feature].values.reshape(
-1, 1))
new_values = pd.Series(quanrtil.reshape(-1))
stat, p = stats.normaltest(new_values)
if p > 0.05:
df[feature] = pd.Series(new_values)
print('num_quantiles:' + str(n_t))
else:
n_t += 1
df.to_csv(output_path + crypto, sep=",", index=False)
def AR_model(X, data_in, lag, i):
model = AR(data_in)
results_AR = model.fit(maxlag=lag, disp=0)
AR_data = results_AR.fittedvalues
act = data_in[3:]
print("Parameters of Autoregressive Model AR(%d) are:" % lag)
print(results_AR.params)
plt.figure()
plt.plot(act, color='blue', label='Actual Value')
plt.plot(results_AR.fittedvalues, color='red', label="Predicted Value")
plt.legend(loc='best')
plt.xlabel("Time")
plt.ylabel("Time series values")
plt.title('AR(' + str(lag) + ")" + "Model with RMSE:" +
str(np.sqrt((np.sum(np.square(AR_data - act))) / len(act))))
plt.title("AR Fit (not scaled)")
plt.savefig("AR fit not scaled" + str(i))
#plt.show()
inverted_in = [
inverse_difference(X[i], data_in[i]) for i in range(len(AR_data))
]
inverted_AR = [
inverse_difference(X[i], AR_data[i]) for i in range(len(AR_data))
]
plt.figure()
plt.plot(inverted_in, color='red', label="actual value")
plt.plot(inverted_AR, color='blue', label="predicted value")
plt.legend(loc='upper left')
plt.title(
"Comparison of predicted and actual values for Autoregression model, lag"
+ str(lag))
plt.savefig(" AR Fit Final" + str(i))
print("RMSE on the Data is:" +
str(np.sqrt((np.sum(np.square(AR_data - act))) / len(act))))
residuals = results_AR.resid
plt.figure()
plt.title("Residual Scatter Plot")
plt.scatter(AR_data, residuals)
plt.savefig("residuals" + str(i))
#plt.show()
plt.figure()
qqplot(residuals)
plt.title("Residual Q-Q Plot")
plt.savefig("QQ" + str(i))
plt.figure()
plt.hist(residuals)
plt.title("Residual Histogram")
plt.savefig("Hist" + str(i))
k2, p = stats.normaltest(residuals)
alpha = 0.001
print("Chi-Square Test : k2 = %.4f p = %.4f" % (k2, p))
print("two sided chi squared probability :" + str(p))
def normality_test(df, features, crypto_name, output_path):
alpha = 0.05
res = {'feature': [], 'statistics': [], 'p-value': [], 'is_gaussian': []}
for feature in features:
if feature != "Date":
#trasform to be stationary
df = df.dropna(subset=[feature])
stat, p = stats.normaltest(df[feature])
res['feature'].append(feature)
res['statistics'].append(stat)
res['p-value'].append(p)
if p > alpha: #fail to reject H0
res['is_gaussian'].append('True')
else:
res['is_gaussian'].append('False')
pd.DataFrame(data=res).to_csv(output_path + crypto_name + ".csv",
sep=",",
index=False)
data -= mean sigma = data.dot(data.T) U, S, V = np.linalg.svd(sigma) eps = 1e-8 ZCAMatrix = np.dot(np.dot(U, np.diag(1.0/np.sqrt(S + eps))), U.T) data = np.dot(ZCAMatrix, data) cov = np.diag(np.cov(data)) data = data / cov.reshape(2, 1) print data.mean(axis=1) print np.cov(data) print normaltest(data.T) # hists = np.zeros((bins, timesteps)) # for t in xrange(timesteps): # hists[:, t] = create_hist(100, bins, dims, basis[t]) # # # fig = plt.figure() # ax = fig.add_subplot(1, 1, 1) # line = ax.plot(hists[:, 0])[0] # for t in xrange(1, timesteps): # line.set_ydata(hists[:, t]) # plt.pause(0.1) # # plt.show()
def def_normaltest(a1):
res = normaltest(a=a1, nan_policy='propagate')
return res
data -= mean sigma = data.dot(data.T) U, S, V = np.linalg.svd(sigma) eps = 1e-8 ZCAMatrix = np.dot(np.dot(U, np.diag(1.0 / np.sqrt(S + eps))), U.T) data = np.dot(ZCAMatrix, data) cov = np.diag(np.cov(data)) data = data / cov.reshape(2, 1) print data.mean(axis=1) print np.cov(data) print normaltest(data.T) # hists = np.zeros((bins, timesteps)) # for t in xrange(timesteps): # hists[:, t] = create_hist(100, bins, dims, basis[t]) # # # fig = plt.figure() # ax = fig.add_subplot(1, 1, 1) # line = ax.plot(hists[:, 0])[0] # for t in xrange(1, timesteps): # line.set_ydata(hists[:, t]) # plt.pause(0.1) # # plt.show() #
def describe_numeric_1d(series: pd.Series, series_description: dict) -> dict:
"""Describe a numeric series.
Args:
series: The Series to describe.
series_description: The dict containing the series description so far.
Returns:
A dict containing calculated series description values.
Notes:
When 'bins_type' is set to 'bayesian_blocks', astropy.stats.bayesian_blocks is used to determine the number of
bins. Read the docs:
https://docs.astropy.org/en/stable/visualization/histogram.html
https://docs.astropy.org/en/stable/api/astropy.stats.bayesian_blocks.html
This method might print warnings, which we suppress.
https://github.com/astropy/astropy/issues/4927
"""
quantiles = config["vars"]["num"]["quantiles"].get(list)
stats = {
"mean": series.mean(),
"std": series.std(),
"variance": series.var(),
"min": series.min(),
"max": series.max(),
"kurtosis": series.kurt(),
"skewness": series.skew(),
"sum": series.sum(),
"mad": series.mad(),
"n_zeros": (len(series) - np.count_nonzero(series)),
"histogram_data": series,
"scatter_data": series, # For complex
}
chi_squared_threshold = config["vars"]["num"]["chi_squared_threshold"].get(
float)
if chi_squared_threshold > 0.0:
histogram = np.histogram(series[series.notna()].values, bins="auto")[0]
stats["chi_squared"] = chisquare(histogram)
stats["normal_test"] = normaltest(series)
stats["range"] = stats["max"] - stats["min"]
stats.update({
"{:.0%}".format(percentile): value
for percentile, value in series.quantile(quantiles).to_dict().items()
})
stats["iqr"] = stats["75%"] - stats["25%"]
stats["cv"] = stats["std"] / stats["mean"] if stats["mean"] else np.NaN
stats["p_zeros"] = float(stats["n_zeros"]) / len(series)
bins = config["plot"]["histogram"]["bins"].get(int)
# Bins should never be larger than the number of distinct values
bins = min(series_description["distinct_count_with_nan"], bins)
stats["histogram_bins"] = bins
bayesian_blocks_bins = config["plot"]["histogram"][
"bayesian_blocks_bins"].get(bool)
if bayesian_blocks_bins:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
ret = bayesian_blocks(stats["histogram_data"])
# Sanity check
if not np.isnan(ret).any() and ret.size > 1:
stats["histogram_bins_bayesian_blocks"] = ret
return stats
def liczCechy(dane, sciezka, czyAtrybutDecyzyjny, indeksAtrybutuDecyzyjnego,
czyAtrybutIndeksujacy, indeksAtrybutuIndeksujacego):
cechy = []
daneDF = dane.copy()
iloscWIerszy = daneDF.shape[0]
iloscKolumn = daneDF.shape[1]
###############################ZMIANA WARTOSCI SYMBOLICZNYCH NA NUMERYCZNE#############
if 'biodegSDC.tab' in sciezka:
daneDF['experimental_class'] = pd.factorize(
daneDF['experimental_class'])[0] + 1
elif 'ozoneSDC.tab' in sciezka:
daneDF['Date'] = pd.factorize(dane['Date'])[0] + 1
elif '.tab' in sciezka:
pass
else:
for i in range(0, iloscKolumn, 1):
if 'object' in str(daneDF[daneDF.columns[i]].dtype):
daneDF[daneDF.columns[i]] = pd.factorize(
daneDF[daneDF.columns[i]])[0] + 1
pass
#################################UZUPELNIANIE i PUSTE##################################
pusteKolumna = []
pusteCaleDane = 0
sredniaIloscPustych = 0
pusteAtrybut = 0
for j in tqdm(range(0, iloscKolumn), desc='Kolumny', dynamic_ncols=True):
for i in range(0, iloscWIerszy):
komorka = pd.to_numeric(daneDF.iloc[i, j], errors='coerce')
if pd.isna(komorka):
pusteCaleDane += 1
pusteAtrybut += 1
if czyAtrybutDecyzyjny:
atrybutDecyzyjnyNazwa = list(
daneDF.columns.values)[indeksAtrybutuDecyzyjnego - 1]
klasaDlaTegoWiersza = daneDF.iloc[
i, indeksAtrybutuDecyzyjnego - 1]
daneKopia2 = daneDF.loc[daneDF[atrybutDecyzyjnyNazwa] ==
klasaDlaTegoWiersza]
daneKopia3 = daneKopia2[daneKopia2.columns.values[j]]
daneKopia3 = pd.to_numeric(daneKopia3, errors='coerce')
srednia = np.mean(daneKopia3).round(2)
moda = daneKopia3.mode()
moda = moda[0]
if daneKopia3.nunique() <= 20:
daneDF.iat[i, j] = moda
if daneKopia3.nunique() > 20:
daneDF.iat[i, j] = srednia
else:
daneKopia2 = daneDF[daneDF.columns.values[j]]
srednia = np.mean(daneKopia2).round(2)
moda = daneKopia2.mode()
moda = moda[0]
if daneKopia2.nunique() <= 20:
daneDF.iat[i, j] = moda
if daneKopia2.nunique() > 20:
daneDF.iat[i, j] = srednia
pusteKolumna.append(pusteAtrybut)
pusteAtrybut = 0
sredniaIloscPustych = functools.reduce(lambda x, y: x + y, pusteKolumna)
sredniaIloscPustych = sredniaIloscPustych / (iloscKolumn)
minIloscPustych = min(pusteKolumna)
maxIloscPustych = max(pusteKolumna)
#print("Ile pustych wartosci")
#print(pusteKolumna)
#print(pusteCaleDane)
#print(sredniaIloscPustych)
############################################################################
###################################################################
daneWyznaczanieWartosci = daneDF.copy()
if czyAtrybutIndeksujacy:
daneWyznaczanieWartosci = daneWyznaczanieWartosci.drop(
daneWyznaczanieWartosci.columns[indeksAtrybutuIndeksujacego],
axis=1)
sredniaZKolumn = []
sredniaWszystkichDanych = 0
medianaZKolumn = []
medianaWszystkichDanych = 0
modaZKolumn = []
sredniaModaWszystkichKolumn = 0
odchylenieStandardoweWKolumnie = []
srednieodchylenieStandardowe = 0
wariancjaWKolumnie = []
sredniaWariancja = 0
odchylenieStandardoweWKolumnie = []
srednieodchylenieStandardowe = 0
wariancjaWKolumnie = []
sredniaWariancja = 0
skosnoscWKolumnie = []
sredniaSkosnosc = 0
kurtozaWKolumnie = []
sredniaKurtoza = 0
minWKolumnie = []
srednieMin = 0
maxWKolumnie = []
srednieMax = 0
kwartyl25ProcWKolumnie = []
sredniKwartyl25Proc = 0
kwartyl50ProcWKolumnie = []
sredniKwartyl50Proc = 0
kwartyl75ProcWKolumnie = []
sredniKwartyl75Proc = 0
rozstepWKolumnie = []
sredniRozstep = 0
ileAtrybutow = daneWyznaczanieWartosci.shape[1]
for i in range(0, ileAtrybutow, 1):
bufor = daneWyznaczanieWartosci[daneWyznaczanieWartosci.columns[i]]
bufor = pd.to_numeric(bufor)
srednia = bufor.describe()[1]
sredniaZKolumn.append(srednia)
mediana = np.median(bufor)
medianaZKolumn.append(mediana)
moda = bufor.mode()
moda = moda[0]
modaZKolumn.append(moda)
odchylenieStandardowe = bufor.describe()[2]
odchylenieStandardoweWKolumnie.append(odchylenieStandardowe)
wariancja = bufor.var()
wariancjaWKolumnie.append(wariancja)
skosnosc = bufor.skew()
skosnoscWKolumnie.append(skosnosc)
kurtoza = bufor.kurt()
kurtozaWKolumnie.append(kurtoza)
minWartosc = bufor.min()
minWKolumnie.append(minWartosc)
maxWartosc = bufor.max()
maxWKolumnie.append(maxWartosc)
kwartyl25Proc = bufor.describe()[4]
kwartyl25ProcWKolumnie.append(kwartyl25Proc)
kwartyl50Proc = bufor.describe()[5]
kwartyl50ProcWKolumnie.append(kwartyl50Proc)
kwartyl75Proc = bufor.describe()[6]
kwartyl75ProcWKolumnie.append(kwartyl75Proc)
rozstep = maxWartosc - minWartosc
rozstepWKolumnie.append(rozstep)
sredniaWszystkichDanych = functools.reduce(lambda x, y: x + y,
sredniaZKolumn)
sredniaWszystkichDanych = sredniaWszystkichDanych / (ileAtrybutow)
minSrednia = min(sredniaZKolumn)
maxSrednia = max(sredniaZKolumn)
sredniaMedianaWszystkichDanych = functools.reduce(lambda x, y: x + y,
medianaZKolumn)
sredniaMedianaWszystkichDanych = sredniaMedianaWszystkichDanych / (
ileAtrybutow)
minMediana = min(medianaZKolumn)
maxMediana = max(medianaZKolumn)
sredniaModaWszystkichKolumn = functools.reduce(lambda x, y: x + y,
modaZKolumn)
sredniaModaWszystkichKolumn = sredniaModaWszystkichKolumn / (ileAtrybutow)
minModa = min(modaZKolumn)
maxModa = max(modaZKolumn)
srednieodchylenieStandardowe = functools.reduce(
lambda x, y: x + y, odchylenieStandardoweWKolumnie)
srednieodchylenieStandardowe = srednieodchylenieStandardowe / (
ileAtrybutow)
minOdchylenieStandardowe = min(odchylenieStandardoweWKolumnie)
maxOdchylenieStandardowe = max(odchylenieStandardoweWKolumnie)
sredniaWariancja = functools.reduce(lambda x, y: x + y, wariancjaWKolumnie)
sredniaWariancja = sredniaWariancja / (ileAtrybutow)
minWariancja = min(wariancjaWKolumnie)
maxWariancja = max(wariancjaWKolumnie)
sredniaSkosnosc = functools.reduce(lambda x, y: x + y, skosnoscWKolumnie)
sredniaSkosnosc = sredniaSkosnosc / (ileAtrybutow)
minSkosnosc = min(skosnoscWKolumnie)
maxSkosnosc = max(skosnoscWKolumnie)
sredniaKurtoza = functools.reduce(lambda x, y: x + y, kurtozaWKolumnie)
sredniaKurtoza = sredniaKurtoza / (ileAtrybutow)
minKurtoza = min(kurtozaWKolumnie)
maxKurtoza = max(kurtozaWKolumnie)
srednieMin = functools.reduce(lambda x, y: x + y, minWKolumnie)
srednieMin = srednieMin / (ileAtrybutow)
minMinWartosc = min(minWKolumnie)
maxMinWartosc = max(minWKolumnie)
srednieMax = functools.reduce(lambda x, y: x + y, maxWKolumnie)
srednieMax = srednieMax / (ileAtrybutow)
minMaxWartosc = min(maxWKolumnie)
maxMaxWartosc = max(maxWKolumnie)
sredniKwartyl25Proc = functools.reduce(lambda x, y: x + y,
kwartyl25ProcWKolumnie)
sredniKwartyl25Proc = sredniKwartyl25Proc / (ileAtrybutow)
minKwartyl25 = min(kwartyl25ProcWKolumnie)
maxKwartyl25 = max(kwartyl25ProcWKolumnie)
sredniKwartyl50Proc = functools.reduce(lambda x, y: x + y,
kwartyl50ProcWKolumnie)
sredniKwartyl50Proc = sredniKwartyl50Proc / (ileAtrybutow)
minKwartyl50 = min(kwartyl50ProcWKolumnie)
maxKwartyl50 = max(kwartyl50ProcWKolumnie)
sredniKwartyl75Proc = functools.reduce(lambda x, y: x + y,
kwartyl75ProcWKolumnie)
sredniKwartyl75Proc = sredniKwartyl75Proc / (ileAtrybutow)
minKwartyl75 = min(kwartyl75ProcWKolumnie)
maxKwartyl75 = max(kwartyl75ProcWKolumnie)
sredniRozstep = functools.reduce(lambda x, y: x + y, rozstepWKolumnie)
sredniRozstep = sredniRozstep / (ileAtrybutow)
minRozstep = min(rozstepWKolumnie)
maxRozstep = max(rozstepWKolumnie)
#########################################################################
#################ILE UNIKALNYCH WARTOSCI W KLASIE #################
if czyAtrybutDecyzyjny:
ileUnikalnychWartosciAD = daneDF[daneDF.columns[
indeksAtrybutuDecyzyjnego - 1]].nunique()
else:
ileUnikalnychWartosciAD = 0
##print("Liczba unikalnych wartosci w klasie")
##print(ileUnikalnychWartosciAD)
########################################################################
#####################LICZBA UNIKALNYCH WARTOŚCI W KOLUMNIE##############
ileUnikalnychWartosciWKolumnie = []
sredniaIloscUnikalnychWartosci = 0
for i in range(0, ileAtrybutow, 1):
ileUnikalnychWartosci = daneWyznaczanieWartosci[
daneWyznaczanieWartosci.columns[i]].nunique()
ileUnikalnychWartosciWKolumnie.append(ileUnikalnychWartosci)
sredniaIloscUnikalnychWartosci = functools.reduce(
lambda x, y: x + y, ileUnikalnychWartosciWKolumnie)
sredniaIloscUnikalnychWartosci = sredniaIloscUnikalnychWartosci / (
ileAtrybutow)
minIloscUnikalnychWartosci = min(ileUnikalnychWartosciWKolumnie)
maxIloscUnikalnychWartosci = max(ileUnikalnychWartosciWKolumnie)
#print("Liczba unikalnych wartosci")
##print(ileUnikalnychWartosciWKolumnie)
##print(sredniaIloscUnikalnychWartosci)
#########################################################################
########################ROZKLAD NORMALNY###############################
daneTestNormalnosci = daneDF.copy()
rozkladNormalnyShapiroTakNie = 0
rozkladNormalnyAndersonDarlingTakNie = 0
rozkladNormalnyDAgostinosTakNie = 0
rozkladNormalnyAndersonDarling = 0
####SHAPIRO
testRozkladuShapiro = daneTestNormalnosci.to_numpy(dtype=float64)
stat, p = shapiro(testRozkladuShapiro)
alpha = 0.05
if p > alpha:
rozkladNormalnyShapiroTakNie = 1
else:
rozkladNormalnyShapiroTakNie = 0
####D’Agostino’s
testRozkladuDAgostinos = daneTestNormalnosci.to_numpy(dtype=float64)
# for j in range(0, iloscKolumn):
# if daneKopia.columns[0] == 0 and daneKopia.columns[1] == 1:
# stat, p = stats.normaltest(testRozkladuDAgostinos[j])
# else:
# stat, p = stats.normaltest(testRozkladuDAgostinos[testRozkladuDAgostinos.columns[j]])
#
# ##print('Statistics=%.3f, p=%.3f' % (stat, p))
# alpha = 0.05
# if p > alpha:
# rozkladNormalnyDAgostinos += 1
#
# ##print("Rozkład normalny D’Agostino’s")
# ##print(str(rozkladNormalnyDAgostinos) + " " + str(iloscKolumn))
# if rozkladNormalnyDAgostinos < iloscKolumn:
# rozkladNormalnyDAgostinosTakNie = 0
# else:
# rozkladNormalnyDAgostinosTakNie = 1
stat1, p2 = stats.normaltest(testRozkladuDAgostinos)
alpha = 0.05
if p2.all() > alpha:
rozkladNormalnyDAgostinosTakNie = 1
else:
rozkladNormalnyDAgostinosTakNie = 0
####Anderson-Darling
testRozkladuAndersonDarling = daneTestNormalnosci.copy()
testRozkladuAndersonDarling = testRozkladuAndersonDarling.astype(float64)
for j in range(0, iloscKolumn):
if testRozkladuAndersonDarling.columns[
0] == 0 and testRozkladuAndersonDarling.columns[1] == 1:
result = anderson(testRozkladuAndersonDarling[j])
else:
result = anderson(testRozkladuAndersonDarling[
testRozkladuAndersonDarling.columns[j]])
for i in range(len(result.critical_values)):
sl, cv = result.significance_level[i], result.critical_values[i]
if result.statistic < result.critical_values[i]:
#print('%.3f: %.3f, data looks normal (fail to reject H0)' % (sl, cv))
#print(result.statistic)
pass
else:
##print('%.3f: %.3f, data does not look normal (reject H0)' % (sl, cv))
##print(result.statistic)
break
rozkladNormalnyAndersonDarling += 1
##print(str(rozkladNormalnyAndersonDarling) + " " + str(iloscKolumn))
if rozkladNormalnyAndersonDarling < iloscKolumn:
rozkladNormalnyAndersonDarlingTakNie = 0
else:
rozkladNormalnyAndersonDarlingTakNie = 1
##print("Rozkład normalny Anderson-Darling")
#print(rozkladNormalnyAndersonDarlingTakNie)
cechy = {
"Ile wierszy": iloscWIerszy,
"Ile atrybutów": iloscKolumn,
"Ilość pustych wartości": pusteCaleDane,
"Minimalna ilość pustych w kolumach": minIloscPustych,
"Średnia ilosc pustych w kolumnach": sredniaIloscPustych,
"Maksymalna ilosc pustych w kolumnach": maxIloscPustych,
"Minimalna srednia w kolumnach": minSrednia,
"Srednia średnich": sredniaWszystkichDanych,
"Maksymalna srednia w kolumnach": maxSrednia,
"Minimalna mediana": minMediana,
"Średnia mediana danych": sredniaMedianaWszystkichDanych,
"Maksymalna mediana": maxMediana,
"Minimalna moda": minModa,
"Średnia moda danych": sredniaModaWszystkichKolumn,
"Maksymalna moda": maxModa,
"Minimalne odchylenie standardowe": minOdchylenieStandardowe,
"Średnie odchylenie standardowe": srednieodchylenieStandardowe,
"Maksymalne odchylenie standardowe": maxOdchylenieStandardowe,
"Minimalna wariancja": minWariancja,
"Średnia wariancja": sredniaWariancja,
"Maksymalna wariancja": maxWariancja,
"Minimalna skośność": minSkosnosc,
"Średnia skośność": sredniaSkosnosc,
"Maksymalna skośność": maxSkosnosc,
"Minimalna kurtoza": minKurtoza,
"Średnia kurtoza": sredniaKurtoza,
"Maksymalna kurtoza": maxKurtoza,
"Minimalna wartosc danych": minMinWartosc,
"Maksymalna wartość w danych": maxMaxWartosc,
"Minimalny kwartyl 25%": minKwartyl25,
"Średni kwartyl 25%": sredniKwartyl25Proc,
"Maksymalny kwartyl 25%": maxKwartyl25,
"Minimalny kwartyl 50%": minKwartyl50,
"Średni kwartyl 50%": sredniKwartyl50Proc,
"Maksymalny kwartyl 50%": maxKwartyl50,
"Minimalny kwartyl 75%": minKwartyl75,
"Średni kwartyl 75%": sredniKwartyl75Proc,
"Maksymalny kwartyl 75%": maxKwartyl75,
"Minimalny rozstęp": minRozstep,
"Średni rozstęp": sredniRozstep,
"Maksymalny rozstęp": maxRozstep,
"Ilość unikalnych wartości atrybutu decyzyjnego":
ileUnikalnychWartosciAD,
"Minimalna liczba unikalnych wartości": minIloscUnikalnychWartosci,
"Średnia ilość unikalnych wartości atrybutów":
sredniaIloscUnikalnychWartosci,
"Maksymalna liczba unikalnych wartości": maxIloscUnikalnychWartosci,
"Rozkład normalny Shapiro": rozkladNormalnyShapiroTakNie,
"Rozkład normalny D’Agostino’s": rozkladNormalnyDAgostinosTakNie,
"Rozkład normalny Anderson-Darling":
rozkladNormalnyAndersonDarlingTakNie
}
return cechy, daneDF
def histograms(self, ntest):
print "hISTOGRAMs"
np.random.seed(seed=44)
myfile = open('prove.csv', 'wb')
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
nprints = 0
mostres = 200
positions = np.zeros((2, mostres), dtype='uint16')
vImg = np.zeros((self.rows, self.cols), dtype='uint16')
examples = []
#examples = [3,6,9,15,16,19,20,22,26,27,41]
wr.writerow(examples)
while nprints < mostres:
nprints += 1
#Random position
i = np.random.randint(0,479)
j = np.random.randint(0,639)
s = set(self.values[:, i, j])
nValues = len(s)
if vImg[i,j] == 0 and nValues > 1:
positions[:,nprints] = (i,j)
vImg[i,j] = 1
pValues = np.array(self.values[:, i, j])
xno = pValues
std = np.std(pValues)
mu = np.mean(pValues)
pValues = ( pValues - mu ) / float(std)
#Write a file pixel Values
if nprints in examples:
wr.writerow([nprints])
print str(nprints) +", p("+str(i)+","+str(j)+")"
print self.values[:,i,j]
print pValues
wr.writerow(self.values[:,i,j])
wr.writerow(pValues)
#Normaltest
z,pval = stats.normaltest(xnr)
#Visualization stuff
xmin = int(min(pValues))
xmax = int(max(pValues))
#Fig1
fig = plt.figure(figsize=(14,8))
ax = fig.add_subplot(121)
xs = sorted(pValues)
lspace = np.linspace(int(xmin-1),int(xmax+1),100)
gkde=stats.gaussian_kde(xs)
egkde = gkde.evaluate(lspace)
if pval < 0.01 or np.isnan(pval): #ntest[i,j]):
clr = "b"
else:
clr = "r"
arsd = range(xmin, xmax)
ax.plot(lspace, mlab.normpdf(lspace, np.mean(pValues), np.std(pValues)), color=clr, label = "Pvalue: "+str(pval)) #ntest[i,j]))
ax.hist(xnr, normed=True, histtype='bar', stacked=True, alpha=0.5, label="Standarized N(0,1)") # bins=(xmax-xmin)+1
ax.plot(lspace, egkde, label=' Standard kde', color="g")
ax.legend()
#fig2
ax = fig.add_subplot(122)
xmin = int(min(xno))
xmax = int(max(xno))
brum = self.hist[xmin:xmax+1,i,j]
vrange = range(xmin,xmax+1)
x = np.linspace(int(xmin-1),int(xmax+1),100)
gkde=stats.gaussian_kde(sorted(xno),bw_method='silverman')
print gkde
egkde = gkde.evaluate(vrange)
ax.bar(vrange, brum/sum(brum), align='center')
ax.plot(vrange, egkde, label='kde', color="g")
ax.legend()
plt.savefig("dist"+str(nprints)+".png")
plt.clf()
plt.close()