• K-means聚类算法Python实现及绘图
2021-11-03 23:03:18

2021年美赛A题真菌种群K-means聚类算法Python实现及绘图

import random
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import math

# calculate the euler distance
def calcDis(dataSet, centroids, k):
clalist = []
for data in dataSet:
diff = np.tile(data, (k,
1)) - centroids
squaredDiff = diff ** 2
squaredDist = np.sum(squaredDiff, axis=1)
distance = squaredDist ** 0.5
clalist.append(distance)
clalist = np.array(clalist)
return clalist

# calculate the centroids
def classify(dataSet, centroids, k):
# calculate the distance between the samples and centroids
clalist = calcDis(dataSet, centroids, k)
# Grouping the samples and recalculate the centroids
minDistIndices = np.argmin(clalist, axis=1)
newCentroids = pd.DataFrame(dataSet).groupby(
minDistIndices).mean()
newCentroids = newCentroids.values

changed = newCentroids - centroids

return changed, newCentroids

def kmeans(dataSet, k):
centroids = random.sample(dataSet, k)

# renew the centroids until there is no change
changed, newCentroids = classify(dataSet, centroids, k)
while np.any(changed != 0):
changed, newCentroids = classify(dataSet, newCentroids, k)

centroids = sorted(newCentroids.tolist())

cluster = []
clalist = calcDis(dataSet, centroids, k)
minDistIndices = np.argmin(clalist, axis=1)
for i in range(k):
cluster.append([])
for i, j in enumerate(minDistIndices):
cluster[j].append(dataSet[i])

return centroids, cluster

def createDataSet():
# mt = df1['MT'].values
# dr = df1['DR'].values
# length = len(dr)
# ary1 = []
# for i in range(length):
#     ary1.append([mt[i],dr[i]])
# rate2 = df2['rate.0.5'].values
# ranking = df2['ranking'].values
# wnw2 = df2['water.niche.width'].values
# length2 = len(rate2)
ary2 = []
rate3 = df3['extension rate'].values
wnw3 = df3['water.niche.width'].values
length3 = len(rate3)
for i in range(length3):
ary2.append([rate3[i], wnw3[i]])
return ary2

def a_plot(k, cluster):
xlist = []
ylist = []
data_list = cluster[k]
length = len(data_list)
for j in range(0, length):
xlist.append(data_list[j][0])
ylist.append(data_list[j][1])
return xlist, ylist

def eluer(centroids, cluster, k):
i = 0
j = 0
dis = []
for i in range(0, k):
l = 0
length = len(cluster[i])
for j in range(length):
point = cluster[i][j]
l += math.sqrt((point[0] - centroids[i][0]) ** 2 + (point[1] - centroids[i][1]) ** 2)
dis.append(l)

return dis

if __name__ == '__main__':
k = 3
i = 0
dataset = createDataSet()
centroids, cluster = kmeans(dataset, k)
dis = eluer(centroids, cluster, k)
print('距离为：%s' % dis)
print('质心为：%s' % centroids)
print('集群为：%s' % cluster)
x_list = []
y_list = []
fig_1 = plt.figure()
for i in range(0, k):
x_list, y_list = a_plot(i, cluster)
color1 = ["g", "b", "r", 'k', 'y']
color2 = ["c", 'm', 'k', 'g', 'r']
style1 = ['v', 'o', '*', '>', '1']
label_list = ['survival', 'ordinary', 'aggressive']
str1 = color1[i]
str2 = color2[i]
ax_1.scatter(x_list, y_list, color=str1, marker=style1[i], label=label_list[i])
ax_1.grid()
# plt.scatter(centroids[i][0], centroids[i][1], color=str2, marker=style1[i])
print(centroids[i][0], centroids[i][1])
ax_1.set_xlabel('Extension Rate', size='14')
ax_1.set_ylabel('Moisture Niche Width', size='14')
ax_1.legend()
plt.savefig("fungi classification")
print('Saved')
plt.show()
cr = df2['ranking'].values
er = df2['extension'].values
fig = plt.figure(2)
temx = []
temy = []
for m in range(10):
temx.append(er[m])
temy.append(cr[m])
ax.scatter(temx, temy, color='g', marker='v', label='survival')
print(temx)
temx = []
temy = []
for t in range(9):
temx.append(er[t+10])
temy.append(cr[t+10])
ax.scatter(temx, temy, color='b', marker='o', label='ordinary')
print(temx)
temx = []
temy = []
for y in range(15):
temx.append(er[y+19])
temy.append(cr[y+19])
ax.scatter(temx, temy, color='r', marker='*', label='aggressive')
print(temx)

ax.set_xlabel('Extension Rate', size='14')
ax.set_ylabel('Competitive Ranking', size='14')
ax.legend()
ax.grid()
plt.savefig('ER-CR')

plt.show()



结果图

更多相关内容
• 今天说K-means聚类算法，但是必须要先理解聚类和分类的区别，很多业务人员在日常分析时候不是很严谨，混为一谈，其实二者有本质的区别。 分类其实是从特定的数据中挖掘模式，作出判断的过程。比如Gmail邮箱里有垃圾...
• 1 K-means算法 实际上，无论是从算法思想，还是具体实现上，K-means算法是一种很简单的算法。它属于无监督分类，通过按照一定的方式度量样本之间的相似度，通过迭代更新聚类中心，当聚类中心不再移动或移动差值小于...
• k-means聚类算法 k-means是发现给定数据集的k个簇的算法，也就是将数据集聚合为k类的算法。 算法过程如下： 1）从N个文档随机选取K个文档作为质心 2）对剩余的每个文档测量其到每个质心的距离，并把它归到最近的质心...
• 基于 K-means 聚类算法的图像区域分割，首先从数据样本种选取K个点作为初始聚类中心，其次计算各个样本到聚类的距离，把样本归到离它最近的那个聚类中心所在的累，计算新形成的每个聚类的数据对象的平均值来得到新的...
• 一、背景 1.项目描述 你拥有一个超市(Supermarket Mall)。通过会员卡，你用有一些关于你的客户的基本数据，如客户ID，年龄，性别，年收入和消费...Annual Income (k\$) 年收入，单位为千美元 Spending Score (1-100)
• 深大计软_最优化方法_实验1：K-Means聚类Python实现手写数字图像MNIST分类
• 本文为大家分享了Python机器学习之K-Means聚类的实现代码，供大家参考，具体内容如下 1.K-Means聚类原理 K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其...
• k-means算法实际上就是通过计算不同样本间的距离来判断他们的相近关系的，相近的就会放到同一个类别中去。 1.首先我们需要选择一个k值，也就是我们希望把数据分成多少类，这里k值的选择对结果的影响很大，Ng的课说的...
• 该文档为数据挖掘中常用的分类算法K-means均值聚类算法，包含源码+详细步骤
• 包括K-Means，二分K-Means算法，谱聚类算法，高斯混合聚类算法等常用聚类算法实现，并且有注释解释代码、
• 主要介绍了k-means 聚类算法Python实现代码,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
• 该程序实现了 K-Means 聚类算法。 该程序旨在与“/.data”目录中的“data.txt”文件一起运行。 如果要使用不同的文件名，则需要相应地更新代码。 构建和执行指令 从命令行构建和执行运行命令python kmeans.py 。 ...
• 孤立点分析在审计疑点发现中的应用探讨——基于K-Means聚类算法Python实现.pdf
• 针对高维数据聚类中K-means算法无法有效抑制噪声特征、实现不规则形状聚类的缺点,提出一种基于目标点特征选择和去除的改进K-均值聚类算法.该算法使用闵可夫斯基规度作为评价距离进行目标点的分类,增设权重调节参数...
• K-MEANS算法是输入聚类个数k，以及包含 n个数据对象的数据库，输出满足方差最小标准k聚类的一种算法k-means 算法接受输入量 k ；然后将n个数据对象划分为 k聚类以便使得所获得的聚类满足：同一聚类中的对象...
• K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成的，因此把得到紧凑且独立的簇作为最终目标。 本代码提供...
• python写的一个k-means聚类算法的实现，测试数据在压缩包的data.txt中，结果通过图示的方法进行直观展示。
• k-means聚类算法是一种经典的基于距离的聚类算法，它的基本思想就是先指定需要划分的簇的个数k，在数据集中选取k个数据作为初始的聚类中心，接着计算这k个聚类中心与其他数据之间存在的距离，根据最近邻原则，划分簇...

k-means聚类算法是一种经典的基于距离的聚类算法，它的基本思想就是先指定需要划分的簇的个数k，在数据集中选取k个数据作为初始的聚类中心，接着计算这k个聚类中心与其他数据之间存在的距离，根据最近邻原则，划分簇并继续调整，分别对新的聚类中心进行计算，直到算法收敛或者到达指定的迭代次数，算法流程如下：

算法流程图：

Python实现

import torch
import random
import numpy as np
from sklearn import datasets

def kmeans(data, N_way, iteration):
# data : N*S, N为样本数，S为特征维数,tensor
# N_way : 类别数
#iteration:迭代次数

#初始化 N_way个聚类中心
N = data.shape[0]
index = range(N)
C = data[random.sample(index, N_way),:]        #C*S,C为类别，N为样本
D = torch.zeros(N_way, N)               #样本和类中心的距离矩阵

count = 0

while True:

G = torch.zeros(N_way, N)     #类别硬化分矩阵，每行一个类别，每列一个样本
P = torch.zeros(N_way, N)     #距离按列归一化矩阵，可用作软分类
#计算各个样本到各类的距离，及所属的类别
for i in range(N_way):
c_i = C[i,:]
c_i = c_i.unsqueeze(0).expand(N, -1)
d = (c_i - data)*(c_i - data)
d = d.sum(dim=1)
D[i,:] = d
for i in range(N):
P[:,i] = D[:, i]/D[:, i].sum()
index = torch.min(D[:, i], 0)[1]
G[index, i] = 1

#更新类中心
C = torch.mm(G,data)
N = []   #每个簇样本数
for i in range(N_way):
num = len(torch.nonzero(G[i, :]))
C[i, :] = C[i, :]/num
N.append(num)
#判断是否满足终止条件
if(count>iteration):
break
count += 1
return C,G,P

if __name__ == '__main__':
n_sample, n_feature = iris.data.shape
data = iris.data
data = data.astype(np.float32)
data = torch.from_numpy(data)
C,G,P = kmeans(data,3,100)
label = iris.target
count = 0
for i in range(150):
pre = torch.max(P[:,i],0)[1]
print(pre)
if pre==label[i]:
count += 1

print(count)

展开全文
• 本节内容：本节内容是根据上学期所上的模式识别课程的作业整理而来，第一道题目是Kmeans聚类算法，数据集是Iris(鸢尾花的数据集)，分类数k是3，数据维数是4。 关于聚类  聚类算法是这样的一种算法：给定样本数据...
• 基于Canopy K-means的中文文本聚类算法.pdf
• K-means聚类算法的学习笔记. 首先,聚类算法是一种未知标签的情况下进行的一种分类,无监督学习 关于K-means的算法网上也有许多介绍,主要记录一下自己的想法.以数模国赛2017年B为例 1.首先碰到的问题是,有一堆的...

K-means聚类算法的学习笔记.

• 首先,聚类算法是一种未知标签的情况下进行的一种分类,无监督学习
• 关于K-means的算法网上也有许多介绍,主要记录一下自己的想法.以数模国赛2017年B为例

1.首先碰到的问题是,有一堆的经纬度,怎么将这堆经纬度归类呢?从以下的图中其实可以观察到,主要为四类,东莞,佛山,广州,深圳.那么初始可以定义有四类.

2.然后就是怎么归类的问题,我认为还是比较容易理解的.我们可以选取四个中心点,然后所有点里面,离哪个中心点近就归为中心点那类,然后就可以得到四类点.然后我们再将类中的点求个平均值,得到新的中心点,继续分类.循环这个过程,直到中心点不再变换,或者达到最大迭代次数(有些函数不收敛)
需要注意两点:

• 初始中心点的选取非常重要,如果两个中心点挨的近了那就非常影响结果.
• 关于近的这个问题,指距离,而距离有很多种,常用的欧式距离,曼哈顿距离.

3.代码实现,以下为代码实现,前者为我自己的实现(可能有一定漏洞)后者调用了sklearn的API(比较好)
本来是想对自己实现的代码进行一定的改进的…不过用过API后成为了放弃思考的废人.
在本次选取中,我碰到的一个问题是,我选取了四个点,但是在聚类的时候,有一个点会不变(也就是前面提到的,初始值的问题,当然也可能是我代码存在漏洞了)

import openpyxl
import math
import copy
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
'C:\\Users\\83599\\Desktop\\数模2017\\excel\\附件12数据合集.xlsx')

table = excel['Sheet1']

weidu = []
jingdu = []

for row in range(2, 837):
weidu.append(table.cell(row=row, column=2).value)
jingdu.append(table.cell(row=row, column=3).value)

# cen = [[0, 0] for i in range(3)]
cen = [[weidu[0], jingdu[0]], [weidu[1], jingdu[1]], [weidu[2], jingdu[2]]]
# cen =[[23.1235,113.2757],[22.6414,114.0689],[22.9159,113.8294]]

means = [[] for i in range(len(cen))]

flag = False
while not flag:
means = [[] for i in range(len(cen))]
for i in range(len(weidu)):
min = 1000000
index = 0
for j in range(len(cen)):
temp = (cen[j][0] - weidu[i])**2 + (cen[j][1] - jingdu[i])**2
temp = math.sqrt(temp)
if(temp < min):
min = temp
index = j
means[index].append([weidu[i], jingdu[i]])
# print(means[1])
temp_cen = copy.deepcopy(cen)
for i in range(len(cen)):
sum_jindu = 0
sum_weidu = 0
if len(means[i]) != 0:
for t in range(len(means[i])):
sum_jindu += means[i][t][1]
sum_weidu += means[i][t][0]
cen[i] = [sum_weidu/len(means[i]), sum_jindu/len(means[i])]
# print(cen)

flag = True
for i in range(len(cen)):
if temp_cen[i][0] != cen[i][0] or temp_cen[i][1] != cen[i][1]:
flag = False
break

color = ['b', 'r', 'g']
x = [[] for i in range(len(cen))]
y = [[] for i in range(len(cen))]

for i in range(len(means)):
for j in range(len(means[i])):
x[i].append(means[i][j][0])
y[i].append(means[i][j][1])

for i in range(len(cen)):
plt.scatter(y[i], x[i], c=color[i])
plt.scatter(cen[i][1], cen[i][0], marker='x', c='black')

plt.show()


然后下面就是喜闻乐见的调api时间

import openpyxl
import math
import copy
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
'C:\\Users\\83599\\Desktop\\数模2017\\excel\\附件12数据合集.xlsx')

table = excel['Sheet1']

weidu = []
jingdu = []

for row in range(2, 837):
weidu.append(table.cell(row=row, column=2).value)
jingdu.append(table.cell(row=row, column=3).value)

X=[]

for i in range(len(jingdu)):
X.append([jingdu[i],weidu[i]])
#将列表转换成数组会便于处理
X = np.array(X)
module = KMeans(n_clusters=3, random_state=9)
y_pred =module.fit_predict(X)
cen = module.cluster_centers_
print(module.cluster_centers_)
plt.scatter(X[:, 0], X[:, 1], c=y_pred)
plt.scatter(cen[:, 0], cen[:, 1], c='black',marker='x')

plt.show()

展开全文
• 上述代码是利用python内置的k-means聚类算法对鸢尾花数据的聚类效果展示，注意在运行该代码时需要采用pip或者其他方式为自己的python安装sklearn以及iris扩展包，其中X = iris.data[:]表示我们采用了鸢尾花数据的四...
• python实现k-means聚类，利用的库有numpy sklearn,利用matplot绘图
• 　1、使用 K-means 模型进行聚类，尝试使用不同的类别个数 K，并分析聚类结果。 ​　2、按照 8:2 的比例随机将数据划分为训练集和测试集，至少尝试 3 个不同的 K 值，并画出不同 K 下 的聚类结果，及不同模型在训练...
• Python实现k均值聚类算法_K-Means聚类算法 若想快速了解k均值聚类算法_K-Means聚类算法，可参考这位大佬的文章，通俗易懂：k均值聚类算法考试例题_K-Means聚类算法，作者：weixin_39789792 感谢这位博主。 本篇...

## Python实现k均值聚类算法_K-Means聚类算法

若想快速了解k均值聚类算法_K-Means聚类算法，可参考这位大佬的文章，通俗易懂：k均值聚类算法考试例题_K-Means聚类算法，作者：weixin_39789792
感谢这位博主。

本篇博客仅作为自用笔记，如有侵权联系删除。

## 代码详细

注意：
质心k的坐标取值不能取的太离谱，比如三个质心中有一个质心的坐标离样本数据中所有坐标都很远，就会导致列表sse_k1(或k2、k3)中无数据，便使len(sse_kx(x为1、2、3))=0,报错：ZeroDivisionError: division by zero

import pylab as pl

def square_Euclid(x, y):
"""
计算欧几里得距离：
若是两个平面上的点，即（x1，y1），和（x2，y2），那这俩点距离即√( (x1-x2)^2+(y1-y2)^2）；
如果是三维空间中的点，则为√( (x1-x2)^2+(y1-y2)^2+(z1-z2)^2 。
"""
return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2

# 初始化各个点
num_x = []
num_y = []
fl = open('data01.txt')  # 点数据存放在data01.txt中
curLine = line.strip().split()

num_x.append(float(curLine[0]))
num_y.append(float(curLine[1]))

# 初始化三个质心，经过聚类得到三个分组
k1 = [-1.7, 1]
k2 = [-0.5, 0.5]
k3 = [1, 2]

# 定义三个簇
sse_k1 = []
sse_k2 = []
sse_k3 = []

n = len(num_x)
while True:
sse_k1 = []
sse_k2 = []
sse_k3 = []
for i in range(n):
square_E1 = square_Euclid(k1, [num_x[i], num_y[i]])
square_E2 = square_Euclid(k2, [num_x[i], num_y[i]])
square_E3 = square_Euclid(k3, [num_x[i], num_y[i]])

num_min = min(square_E1, square_E2, square_E3)

# 聚类
if num_min == square_E1:
sse_k1.append(i)
elif num_min == square_E2:
sse_k2.append(i)
elif num_min == square_E3:
sse_k3.append(i)

# 求坐标平均值，以确定新的质心(更新质心坐标)
k1_x = sum([num_x[i] for i in sse_k1]) / len(sse_k1)
k1_y = sum([num_y[i] for i in sse_k1]) / len(sse_k1)

k2_x = sum([num_x[i] for i in sse_k2]) / len(sse_k2)
k2_y = sum([num_y[i] for i in sse_k2]) / len(sse_k2)

k3_x = sum([num_x[i] for i in sse_k3]) / len(sse_k3)
k3_y = sum([num_y[i] for i in sse_k3]) / len(sse_k3)

# 只要有质心的坐标发生改变，则更新质心坐标；若三个质心均无变化，则判定以收敛，聚类结束，退出循环
if k1 != [k1_x, k1_y] or k2 != [k2_x, k2_y] or k3 != [k3_x, k3_y]:
k1 = [k1_x, k1_y]
k2 = [k2_x, k2_y]
k3 = [k3_x, k3_y]
else:
break

# 取聚类后的点坐标
kv1_x = [num_x[i] for i in sse_k1]
kv1_y = [num_y[i] for i in sse_k1]

kv2_x = [num_x[i] for i in sse_k2]
kv2_y = [num_y[i] for i in sse_k2]

kv3_x = [num_x[i] for i in sse_k3]
kv3_y = [num_y[i] for i in sse_k3]

pl.plot(kv1_x, kv1_y, '+')
pl.plot(kv2_x, kv2_y, '.')
pl.plot(kv3_x, kv3_y, '^')

# 坐标系大小依样本数据值范围而定
pl.xlim(-2, 2.5)
pl.ylim(-1, 2.5)
pl.show()



## 所用样本数据

在.py文件所在文件下创建data01.txt文本文档,并将以下数据存入

-0.113523119722435 0.305566317246824
-0.0363280337139859 0.110677855003451
0.113494507689856 0.285179031884109
-0.00383816850385252 0.670778674827114
-0.180363593046200 0.394837771823933
0.295367728543231 -0.355182535548782
-0.0296566442720039 0.228722511660635
-0.0930361342677474 0.154377592930645
-0.159633545380951 1.03286272700827
-0.609370592744484 0.0100246598182464
0.164875043625935 0.107920610145671
-0.649661855983650 -0.0264148180075531
-0.0853301136043781 0.194929464533097
-0.0869727732803104 -0.166019322253363
0.267258237150858 0.318664851557507
-0.876324515282669 0.578412914115882
0.290320777421500 0.0269704554131184
-0.164202641138215 -0.0216061750617156
-0.408886348765266 -0.178183406834480
-0.00275690297052195 -0.149757266490323
-0.230897603220972 0.202729565016547
-0.289768125501838 0.299373894453753
0.565273947293806 -0.112025265465832
-0.259434375270518 -0.183038062076565
-0.0622055869197436 0.0178584309105331
-0.281488166956539 -0.282493439656289
0.288003999490542 0.354832178282382
-0.00387861254715821 0.245338598261617
0.0230259610960932 0.304367839506965
0.297069520513791 0.398694925851779
0.213528795047459 -0.0341268311839215
0.248545070529365 -0.182513241920946
-0.674431824833610 0.166219624024427
0.0695478578554150 0.364281641067673
1.52144323033782 1.56356334395462
1.54901744911605 1.44082824131763
1.72628026225810 0.999267392962595
1.34339405843162 1.54435051334828
1.63076888391605 0.822969713727122
1.24625402720513 1.50291563943267
1.49966193305128 1.43962200220279
0.806148334745612 1.59798616598320
1.73765675194197 0.801038214866100
0.688725193167526 1.18560461303177
1.31503430771996 1.25566460922217
1.14051881393761 1.28173391148891
0.883497444350820 1.52712829138676
1.35619761199096 1.47157896393621
-1.41400896645106 1.03490557492282
-1.46921827418174 0.691733912712829
-1.06733046906236 0.945293131396786
-0.789899047908273 1.04583303354796
-0.922550939191143 1.39310184834662
-0.918965347657051 1.44432139992464
-1.03616345036068 1.00166612828372
-1.07715160762591 1.51189230738663
-1.01283275702248 1.46105578965393
-1.48079534886488 1.21031313607727
-0.986518252032434 0.949195019118798
-1.62901492888985 1.53208781532487
-1.05432664597088 1.20897843449092
-1.51323198856773 0.929507861004623
-1.55689740607725 1.32978015955565
-1.39341270591838 1.41557221811715
-1.66195228414799 0.787792125905413
-1.24494832523794 1.84020927229746
-0.898778729417616 0.570410077321060
-1.32885894876685 0.732892764435160
-1.09324537986321 1.63706883409855
-1.19875924554585 1.35282905121539
-0.866788557380931 1.11436578620945
-1.30006378262166 1.25366700524127
-1.15735442373393 1.48126320709162
-0.469640188642725 0.975507100878317
-0.887529056287694 1.54350983044641
-1.54530712190787 1.47051092229069
-0.895890659992745 1.23572220775434
-1.54226615688700 1.31046627190501
-1.24686714416393 1.05116769432966
-1.18900045601094 1.35740905869805
-1.65786095402519 1.03723338930851
-1.37644334323617 1.08018136201292
-1.00479602718570 0.921073237322932
-0.958390570797860 1.56536899409517
-0.761574879786032 1.24176101803965
-1.56925161923031 1.04223861195863
-0.979085655811513 1.46432198217887
-1.14713536403328 1.08846006315455
-0.853944089636229 1.39103904734476

展开全文
• 本文实例讲述了Python实现的KMeans聚类算法。分享给大家供大家参考，具体如下： 菜鸟一枚，编程初学者，最近想使用Python3实现几个简单的机器学习分析方法，记录一下自己的学习过程。 关于KMeans算法本身就不做介绍...
• ax.set_title('K-means') for i in range(k): pts = data[np.nonzero(b[:, 0].A == i)[0], :] ax.scatter(np.matrix(data[:, 0]).A[0], np.matrix(data[:, 1]).A[0], marker='o', s=90, color='b', alpha=0.2) ...

...