def _setPortfolioInfo(self):
port_annual_var: float = round(np.dot(self._weights.T, np.dot(self._dataSimpleCovarianceAnnual, self._weights)), 5)
port_annual_volatility: float = round(np.sqrt(port_annual_var), 5)
port_annual_simple_ret: float = round(np.sum(self._stats.SimpleReturnsNan.mean() * self._weights) * 252, 5)
print('Port Ann Ret', str(round(port_annual_var, 5)*100)+'%')
print('Port Ann Volatility/ Risk', str(round(port_annual_volatility, 5)*100)+'%')
print('Port Ann Variance', str(round(port_annual_simple_ret, 5)*100)+'%')
'''
def f1(y_hat, y_true, THRESHOLD=0.5):
'''
y_hat是未经过sigmoid函数激活的
输出的f1为Macro-F1
'''
epsilon = 1e-7
y_hat = y_hat > THRESHOLD
y_hat = np.int8(y_hat)
tp = np.sum(y_hat * y_true, axis=0)
fp = np.sum(y_hat * (1 - y_true), axis=0)
fn = np.sum((1 - y_hat) * y_true, axis=0)
p = tp / (tp + fp + epsilon) # epsilon的意义在于防止分母为0，否则当分母为0时python会报错
r = tp / (tp + fn + epsilon)
f1 = 2 * p * r / (p + r + epsilon)
f1 = np.where(np.isnan(f1), np.zeros_like(f1), f1)
return np.mean(f1)
def printst(step, seg_source,seg_ed,seg_es,labeled,labeles):
mm = seg_source[0, 1, :, :, :] * 1 + seg_source[0, 2, :, :, :] * 2 + seg_source[0, 3, :, :, :] * 3
pt = mm.data.cpu().numpy()
# pt = np.transpose(pt, (2, 1, 0))
# pt = start_seg[0, 0, :, :, :].data.cpu().numpy()
out = sitk.GetImageFromArray(pt)
out.SetSpacing((1, 1, 1))
sitk.WriteImage(out, './state/seg_source' + str(step) + '.nii')
# pt=np.argmax(pt[1],axis=1)
# out = sitk.GetImageFromArray(seg_source)
# out.SetSpacing((1.000, 1.000, 1.000))
# sitk.WriteImage(out, './state/seg-source' + str(step) + '.nii')
dice_result_ed = []
mm1 = seg_ed[0, 1, :, :, :] * 1 + seg_ed[0, 2, :, :, :] * 2 + seg_ed[0, 3, :, :, :] * 3
mm2 = labeled[0, 1, :, :, :] * 1 + labeled[0, 2, :, :, :] * 2 + labeled[0, 3, :, :, :] * 3
pt1 = mm1.data.cpu().numpy()
pt1 = threshold(pt1)
pt2 = mm2.data.cpu().numpy()
# print(pt1.shape)
# print(pt2.shape)
# labeled=labeled.data.cpu.numpy()
diceresult_ed = dice(pt1, pt2, nargout=1)
dice_result_ed.append(diceresult_ed)
dice_result_ed = np.array(dice_result_ed)
dice_sum = np.sum(dice_result_ed, axis=0)
print('step' + str(step) + 'diceresult_ed:|' + str(dice_sum))
dice_result_es = []
mm1 = seg_es[0, 1, :, :, :] * 1 + seg_es[0, 2, :, :, :] * 2 + seg_es[0, 3, :, :, :] * 3
mm2 = labeles[0, 1, :, :, :] * 1 + labeles[0, 2, :, :, :] * 2 + labeles[0, 3, :, :, :] * 3
pt1 = mm1.data.cpu().numpy()
pt1=threshold(pt1)
pt2= mm2.data.cpu().numpy()
# print(pt1.shape)
# print(pt2.shape)
# labeled=labeled.data.cpu.numpy()
diceresult_es=dice(pt1,pt2,nargout=1)
dice_result_es.append(diceresult_es)
dice_result_es = np.array(dice_result_es)
dice_sum = np.sum(dice_result_es, axis=0)
print('step'+str(step)+'diceresult_es:|'+str(dice_sum))
def run(self):
folders = how_many_fatherFolder(self.path)
for experiemnt in folders:
logging.debug("Folder under analysis -> " + str(experiemnt))
second_path = self.path + experiemnt + "/"
res = how_many_folder(second_path)
num_folder = len(res)
logging.debug("Folder to analise -> " + str(num_folder))
for el in res:
path_here = second_path + str(el) + "/"
names = []
for i in os.listdir(path_here):
if os.path.isfile(
os.path.join(path_here, i)
) and 'trajectory-generate-aSs-' in i and ".zip" in i:
names.append(i)
names = sorted_nicely(names)
pops = Populations()
# find the trajectories ID and Points
trajectories = self.read_trajectory_info(path_here +
"trajectory.zip")
for tra in trajectories:
pops.add_population(Population(tra))
number_of_trajectories = pops.get_number_trajectories()
total_distances = []
numb = 0
logging.debug("Analysing Trajectories...")
for i in tqdm.tqdm(range(len(names))):
name = names[i]
# obtain info from the file
individuals = self.read_info(path_here + name)
# store the msd per trajectory
distance_per_trajectories = {}
for j in range(number_of_trajectories):
distances = []
for indiv in individuals:
if indiv.trajectoryID == pops.get_population(
j).tra.trajectoryID:
distances.append(indiv.MSD)
array = np.array(distances)
MSD = (np.sum(array)) / len(array)
distance_per_trajectories.update({j: MSD})
total_distances.append(distance_per_trajectories)
self.print_graph(total_distances, path_here)
def dice(img1, img2, labels=None, nargout=1):
'''
Dice [1] volume overlap metric
The default is to *not* return a measure for the background layer (label = 0)
[1] Dice, Lee R. "Measures of the amount of ecologic association between species."
Ecology 26.3 (1945): 297-302.
Parameters
----------
vol1 : nd array. The first volume (e.g. predicted volume)
vol2 : nd array. The second volume (e.g. "true" volume)
labels : optional vector of labels on which to compute Dice.
If this is not provided, Dice is computed on all non-background (non-0) labels
nargout : optional control of output arguments. if 1, output Dice measure(s).
if 2, output tuple of (Dice, labels)
Output
------
if nargout == 1 : dice : vector of dice measures for each labels
if nargout == 2 : (dice, labels) : where labels is a vector of the labels on which
dice was computed
'''
if labels is None:
labels = np.unique(np.concatenate((img1, img2))) # 输出一维数组
labels = np.delete(labels, np.where(labels == 0)) # remove background
dicem = np.zeros(len(labels))
for idx, lab in enumerate(labels):
top = 2 * np.sum(np.logical_and(img1 == lab, img2 == lab))
bottom = np.sum(img1 == lab) + np.sum(img2 == lab)
bottom = np.maximum(bottom, np.finfo(float).eps) # add epsilon. 机器最小的正数
dicem[idx] = top / bottom
if nargout == 1:
return dicem
else:
return (dicem, labels)
def _setMatrices(self, portfolio_data: DataFrame, log_ret: DataFrame,
cov_mat: DataFrame):
for i in range(self._threshold):
weight_arr: np.ndarray = np.random.uniform(
size=len(portfolio_data.columns))
weight_arr = weight_arr / np.sum(weight_arr)
# saving weights in the array
self._weight_matrix[i, :] = weight_arr
# Portfolio Returns
annual_weighted_log_ret: float = (
(np.sum(log_ret.mean() * weight_arr)) + 1)**252 - 1
# Saving Portfolio returns
self._annual_weighted_log_return_matrix[
i] = annual_weighted_log_ret
# Saving Portfolio Risk
portfolio_sd: float = np.sqrt(
np.dot(weight_arr.T, np.dot(cov_mat, weight_arr)))
self._risk_matrix[i] = portfolio_sd
# Portfolio Sharpe Ratio
# Assuming 0% Risk Free Rate
sr: float = annual_weighted_log_ret / portfolio_sd
self._sharpe_ratio_matrix[i] = sr
def __init__(self, trajectoryID, classification, generetedPoint, realPoint):
self.trajectoryID = trajectoryID
self.classification = classification
self.generetedPoint = generetedPoint
self.realPoint = realPoint
self.max_x = 0
self.max_y = 0
self.min_x = 0
self.min_y = 0
self.xs_real = []
self.ys_real = []
self.xs_generated = []
self.ys_generated = []
# compute max and minimum of the individual
xs = []
ys = []
for el in self.realPoint:
xs.append(el.x)
ys.append(el.y)
if el.x not in self.xs_real:
self.xs_real.append(el.x)
if el.y not in self.ys_real:
self.ys_real.append(el.y)
for el in self.generetedPoint:
xs.append(el.x)
ys.append(el.y)
if el.x not in self.xs_generated:
self.xs_generated.append(el.x)
if el.y not in self.ys_generated:
self.ys_generated.append(el.y)
self.max_x = np.amax(np.array(xs))
self.min_x = np.amin(np.array(xs))
self.max_y = np.amax(np.array(ys))
self.min_y = np.amin(np.array(ys))
# compute mse points this trajectory
distances = []
for i in range(len(self.generetedPoint)):
a = np.array((self.xs_real[i], self.ys_real[i]))
b = np.array((self.xs_generated[i], self.ys_generated[i]))
value = np.linalg.norm(a - b) * 100000
distances.append(pow(value, 2))
self.array = np.array(distances)
self.MSD = (np.sum(self.array)) / len(self.array)
def evaluate(model, X_test, y_test):
y_pred = model.predict(X_test)
cf_matrix = confusion_matrix(y_test, y_pred)
categories = ['Negative', 'Positive']
group_names = ['True Neg', 'False Pos', 'False Neg', 'True Pos']
group_percentages = [
'{0:.2%}'.format(value)
for value in cf_matrix.flatten() / np.sum(cf_matrix)
]
labels = [f'{v1}\n{v2}' for v1, v2 in zip(group_names, group_percentages)]
labels = np.asarray(labels).reshape(2, 2)
sns.heatmap(cf_matrix,
annot=labels,
cmap='Blues',
fmt='',
xticklabels=categories,
ytick=categories)
plt.xlabel("Predicted values", fontdict={'size': 14}, labelpad=10)
plt.xlabel("Actual values", fontdict={'size': 14}, labelpad=10)
plt.xlabel("Confusion Matrix", fontdict={'size': 18}, labelpad=10)
def wgn(X, snr):
P_signal = np.sum(abs(X)**2) / (len(X))
P_noise = P_signal / 10**(snr / 10.0)
#return np.random.randn(X.shape[1])*np.sqrt(P_noise)
return np.random.randn(len(X)) * np.sqrt(P_noise)
def __init__(self, y_stocks: list):
self._a_float = 3 * math.log(y_stocks[0].TimeSpan.MonthCount)
self._a_suffix = y_stocks[0].Column
self._a_ts = y_stocks[0].TimeSpan
self._a_length = len(y_stocks)
iso_weight: float = round(1.0 / len(y_stocks), 3)
self._stocks = y_stocks
self._weights = np.array(len(y_stocks) * [iso_weight], dtype=float)
self._basics = PortfolioBasics(y_stocks, self._a_float, self._legend_place)
self._stats = PortfolioStats(self._weights, self._basics)
self._final = PortfolioFinal(y_stocks, self._a_float, self._legend_place)
print('Volatility\t\t\t\t\t', self._final.Volatility)
print('Annual Expected Return\t\t', self._final.AnnualExpectedReturn)
print('Risk Free Rate\t\t\t\t', self._final.RiskFreeRate)
print('Free 0.005 Sharpe Ratio\t\t', self._final.Free005SharpeRatio)
print('Kurtosis\n', self._final.KurtosisSeries)
print('Skewness\n', self._final.SkewnessSeries)
print('Frequency\n', self._final.Frequency)
self._final.Plot().show()
exit(1234)
self._dataSimpleCorrelation = self._stats.SimpleReturnsNan.corr()
self._dataSimpleCovariance = self._stats.SimpleReturnsNan.cov()
self._dataSimpleCovarianceAnnual = self._dataSimpleCovariance * 252
self._dataSimpleSummary = self._stats.SimpleReturnsNanSummary
self._dataWeightedReturns = self._stats.SimpleWeightedReturns
# axis =1 tells pandas we want to add the rows
self._portfolio_weighted_returns = round(self._dataWeightedReturns.sum(axis=1), 5)
print('7', self._portfolio_weighted_returns.head())
print('7', self._stats.SimpleWeightedReturnsSum.head())
#self._dataWeightedReturns['PORTFOLIOWeighted'] = portfolio_weighted_returns
portfolio_weighted_returns_mean = round(self._portfolio_weighted_returns.mean(), 5)
print('port_ret mean', portfolio_weighted_returns_mean)
print(round(self._stats.SimpleWeightedReturnsSum.mean(), 5))
portfolio_weighted_returns_std = round(self._portfolio_weighted_returns.std(), 5)
print('port_ret std', portfolio_weighted_returns_std)
self._portfolio_weighted_returns_cum: Series = round((self._portfolio_weighted_returns + 1).cumprod(), 5)
#self._dataWeightedReturns['PORTFOLIOCumulative'] = self._portfolio_weighted_returns_cum
print('$', self._dataWeightedReturns.head())
self._portfolio_weighted_returns_geom = round(np.prod(self._portfolio_weighted_returns + 1) ** (252 / self._portfolio_weighted_returns.shape[0]) - 1, 5)
print('geometric_port_return', self._portfolio_weighted_returns_geom)
self._portfolio_weighted_annual_std = round(np.std(self._portfolio_weighted_returns) * np.sqrt(252), 5)
print('port_ret annual', self._portfolio_weighted_annual_std)
self._portfolio_weighted_sharpe_ratio = round(self._portfolio_weighted_returns_geom / self._portfolio_weighted_annual_std, 5)
print('port_sharpe_ratio', self._portfolio_weighted_sharpe_ratio)
print('%', self._stats.Returns.head())
self._data_returns_avg = self._getDataReturnsAverage(self._stats.Returns)
print('^', self._data_returns_avg.head())
daily_log_pct_changes: DataFrame = np.log(self._stats.Returns.pct_change() + 1) #avant portfolio
daily_log_pct_changes.columns = daily_log_pct_changes.columns + 'LogReturn'
print('&', daily_log_pct_changes.head())
daily_log_volatilities: DataFrame = (daily_log_pct_changes.std() * np.sqrt(252)).to_frame()
daily_log_volatilities.columns = ['Volatility']
print('*', daily_log_volatilities)
port_daily_simple_ret: float = round(np.sum(self._stats.SimpleReturnsNan.mean()*self._weights), 5)
port_weekly_simple_ret: float = round(4.856 * port_daily_simple_ret, 5)
port_monthly_simple_ret: float = round(21 * port_daily_simple_ret, 5)
port_quarterly_simple_ret: float = round(63 * port_daily_simple_ret, 5)
port_yearly_simple_ret: float = round(252 * port_daily_simple_ret, 5)
print('port_daily_simple_ret', str(100*port_daily_simple_ret) + '%')
print('port_weekly_simple_ret', str(100*port_weekly_simple_ret) + '%')
print('port_monthly_simple_ret', str(100*port_monthly_simple_ret) + '%')
print('port_quarterly_simple_ret', str(100*port_quarterly_simple_ret) + '%')
print('port_yearly_simple_ret', str(100*port_yearly_simple_ret) + '%')
self._setPortfolioInfo()
self._optimizer = PortfolioOptimizer(self._legend_place, self._a_float, self._stats, self._basics.Data)
self._stock_market_index = SnP500Index('yahoo', "^GSPC", self._a_ts)
self._linear_reg = PortfolioLinearReg(self._stock_market_index, self._stats.Returns)
print(f'The portfolio beta is {self._linear_reg.Beta}, for each 1% of index portfolio will move {self._linear_reg.Beta}%')
print('The portfolio alpha is ', self._linear_reg.Alpha)
print('_', self._basics.DataLogReturns.head())
cov_mat_annual = self._basics.DataLogReturns.cov() * 252
print('-', cov_mat_annual)
def run(self):
folders = how_many_fatherFolder(self.path)
folders = [s for s in folders if not re.search('txt', s)]
folders = [s for s in folders if not re.search('jpg', s)]
folders = [s for s in folders if not re.search('png', s)]
for experiemnt in folders:
logging.debug("Folder under analysis -> " + str(experiemnt))
second_path = self.path + experiemnt + "/"
res = how_many_folder(second_path)
folders = [s for s in folders if not re.search('txt', s)]
folders = [s for s in folders if not re.search('jpg', s)]
folders = [s for s in folders if not re.search('png', s)]
num_folder = len(res)
logging.debug("Folder to analise -> " + str(num_folder))
for el in res:
logging.debug("Folder under analysis -> " + str(el))
path_here = second_path + str(el) + "/"
names = []
for i in os.listdir(path_here):
if os.path.isfile(
os.path.join(path_here, i)
) and 'trajectory-generate-aSs-' in i and ".zip" in i:
names.append(i)
names = sorted_nicely(names)
pops = Populations()
# find the trajectories ID and Points
trajectories = self.read_trajectory_info(path_here +
"trajectory.zip")
for tra in trajectories:
pops.add_population(Population(tra))
# analysing the fitness
logging.debug("Analysing the fitness...")
max_agent, max_classifier = self.find_max_values_fitness(
path_here)
agent_generations_info, classifier_generations_info = self.read_fitness(
path_here, max_agent, max_classifier)
x = np.arange(len(agent_generations_info))
y_agent = []
std_agent = []
for element in agent_generations_info:
y_agent.append(element.mean)
std_agent.append(element.std)
y_classifier = []
std_classifier = []
for element in classifier_generations_info:
y_classifier.append(element.mean)
std_classifier.append(element.std)
# print fitnes
self.print_fitnes(x, y_agent, std_agent, y_classifier,
std_classifier, path_here)
total_distances = []
total_distances_msd = []
std_distances = []
last_generations_values = []
logging.debug("Analysing Trajectories...")
for i in tqdm.tqdm(range(len(names))):
name = names[i]
# obtain info from the file
individuals = self.read_info(path_here + name)
if i == len(names) - 1:
for ind in individuals:
for el in ind.array:
last_generations_values.append(el)
msds = []
for ind in individuals:
msds.append(ind.MSD)
total_distances.append(np.mean(np.array(msds)))
std_distances.append(np.std(np.array(msds)))
# store the msd per trajectory
distance_per_trajectories = {}
for j in range(number_of_trajectories):
distances = []
for indiv in individuals:
if indiv.trajectoryID == pops.get_population(
j).tra.trajectoryID:
distances.append(indiv.MSD)
array = np.array(distances)
MSD = (np.sum(array)) / len(array)
distance_per_trajectories.update({j: MSD})
total_distances_msd.append(distance_per_trajectories)
# print graph msd per trajectory
self.print_graph_msd_per_trajectory(total_distances_msd,
path_here)
# print graph total msd
self.print_graph_msd_total(total_distance, std_distances,
path_here)
# save the last value
array = np.array(last_generations_values)
MSD = (np.sum(array)) / len(array)
with open(path_here + "/MSD.txt", "w") as text_file:
text_file.write(str(MSD))
def test_sanity_check_sum_of_bitmap(self):
image = Image([[[1, 1, 0], [2, 2, 0], [3, 3, 0]]], 32, 32)
self.assertEqual(32 * 32 - 3, np.sum(image.return_as_np()))
def meanAllAgents(old_path):
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
level=logging.DEBUG)
folders = how_many_fatherFolder(old_path)
dff = DataFrame(columns=['exp', 'trajectories', 'MSD'])
iii = 0
for experiemnt in folders:
logging.debug("Folder under analysis -> " + str(experiemnt))
name_experiement = str(experiemnt).replace("Experiment-tgcfs-",
"").replace("-ETH", "")
second_path = old_path + experiemnt + "/"
res = how_many_folder(second_path)
num_folder = len(res)
logging.debug("Folder to analise -> " + str(num_folder))
for el in res:
path = second_path + str(el) + "/"
tratt = str(el)
names = []
for i in os.listdir(path):
if os.path.isfile(
os.path.join(path, i)
) and 'trajectory-generate-aSs-' in i and ".zip" in i:
names.append(i)
names = sorted_nicely(names)
total_distances = []
numb = 0
logging.debug("Analysing Trajectories...")
for i in tqdm.tqdm(range(len(names))):
name = names[i]
numb += 1
# name = "trajectory-generatedPoints-" + str(numb) + "-" + str(numb) + ".zip"
trajectories_label, json_file, id_label = reanInfo(path + name)
# number = 0
# while number < len(id_label):
# real points
lat_real = []
lng_real = []
# generated points
lat_generated = []
lng_generated = []
label_real = []
label_generated = []
for labels in trajectories_label:
for el in json_file[labels]["real"]:
if el[0] not in lat_real:
lat_real.append(el[0])
lng_real.append(el[1])
label_real.append(json_file[labels]["id"])
for el in json_file[labels]["generated"]:
if el[0] not in lat_generated:
lat_generated.append(el[0])
lng_generated.append(el[1])
label_generated.append(json_file[labels]["id"])
distance_per_trajectories = {}
# now for every trajectory compute the distance of the generated distance
for i in range(len(label_real)):
index = [
j for j, x in enumerate(label_generated)
if x == label_real[i]
]
distances = []
for ind in index:
a = np.array((lat_real[i], lng_real[i]))
b = np.array((lat_generated[ind], lng_generated[ind]))
value = np.linalg.norm(a - b) * 100000
value = pow(value, 2)
distances.append(value)
array = np.array(distances)
MSD = (np.sum(array)) / len(array)
distance_per_trajectories.update({i: MSD})
total_distances.append(distance_per_trajectories)
#
# df = DataFrame(columns=['gen', 'tra', 'MSD'])
#
# x = []
# x = np.arange(0, len(total_distances))
# i = 0
# for el in total_distances:
# for k in el.keys():
# d = {"gen": i, "tra": k, "MSD": el[k]}
# dfs = DataFrame(data=d, index=[i])
# df = df.append(dfs)
# i += 1
# sns.set_style("darkgrid")
# df = df[df.columns].astype(float)
# g = sns.lmplot(x="gen", y="MSD", hue="tra", data=df, scatter_kws={"s": 1}, fit_reg=False)
last_line = total_distances[len(total_distances) - 1]
arr = []
for k in last_line.keys():
arr.append(last_line[k])
array = np.array(arr)
MSD = (np.sum(array)) / len(array)
logging.debug(MSD)
dd = {"exp": name_experiement, "trajectories": tratt, "MSD": MSD}
dfss = DataFrame(data=dd, index=[iii])
iii += 1
dff = dff.append(dfss)
# df.plot(x='gen', y='MSD')
# sns.lmplot(x="gen", y="MSD", hue="tra", data=df)
# a = df.loc[df['tra'] == 0]
# ax = a.plot(x='gen', y='MSD', kind='scatter', label="0")
# for i in range(1, 5):
# a = df.loc[df['tra'] == i]
# a.plot(x='gen', y='MSD', ax=ax, kind='scatter',label=i)
# g.set(ylim=(0, 300))
# for j in range(5):
# a = df.loc[df['tra'] == j]
# a.plot(x='gen', y='MSD', ylim=(0,0.00000007))
# plt.figure(0)
# sns.set_style("darkgrid")
# plt.errorbar(x, mean, std)
# plt.errorbar(x, min)
# plt.errorbar(x, max_value)
# # plt.plot(median)
# plt.legend(("mean Difference", "min Difference", "max Difference"))
# plt.xlabel("Generation")
# plt.ylabel("Distance (metres) point generated with real point")
# plt.legend(("Max Distance", "Min Distance", "Median Distance"))
# save_name = path + 'msd.png'
# plt.savefig(save_name, dpi=500, facecolor='w', edgecolor='w', orientation='portrait', papertype=None,
# format=None, transparent=False, bbox_inches=None, pad_inches=0.1, frameon=None)
# plt.close()
# logging.debug("Graph saved!")
# os.system("rm movie.mp4")
# os.system("ffmpeg -f image2 -r 2 -i _tmp%05d.png -vcodec mpeg4 -y movie.mp4")
# os.system("rm _tmp*.png")
# logging.debug("End Program")
sns.factorplot(x="exp",
y="MSD",
hue="trajectories",
data=dff,
kind="bar",
palette="muted")
plt.show()
from sklearn.neighbors import KNeighborsClassifier
from sklearn.neighbors import KNeighborsRegressor
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
from pandas import np
import matplotlib.pyplot as plt
X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
lasso = Lasso().fit(X_train, y_train)
lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)
print("lr.coef_: {}".format(lasso.coef_))
print("lr.intercept_: {}".format(lasso.intercept_))
print("Правильность на обучающем наборе: {:.2f}".format(lasso.score(X_train, y_train)))
print("Правильность на контрольном наборе: {:.2f}".format(lasso.score(X_test, y_test)))
print("Кол-во исп. признаков: {:.2f}".format(np.sum(lasso.coef_ != 0)))
print("\nalpha=0.1, max_iter=100000:")
print("Правильность на обучающем наборе: {:.2f}".format(lasso001.score(X_train, y_train)))
print("Правильность на контрольном наборе: {:.2f}".format(lasso001.score(X_test, y_test)))
print("Кол-во исп. признаков: {:.2f}".format(np.sum(lasso001.coef_ != 0)))
lasso00001 = Lasso(alpha=0.0001, max_iter=100000).fit(X_train, y_train)
print("\nalpha=0.0001, max_iter=100000:")
print("Правильность на обучающем наборе: {:.2f}".format(lasso00001.score(X_train, y_train)))
print("Правильность на контрольном наборе: {:.2f}".format(lasso00001.score(X_test, y_test)))
print("Кол-во исп. признаков: {:.2f}".format(np.sum(lasso00001.coef_ != 0)))
plt.plot(lasso.coef_, 's', label="Ридж регрессия alpha=1")
plt.plot(lasso001.coef_, 's', label="Ридж регрессия alpha=10")
plt.plot(lasso00001.coef_, 's', label="Ридж регрессия alpha=0.1")
