#ML #Python Iris 数据集

#ML #Python 接下来安装一点用于数据分析的东西

pip3 install --user --compile -U pandas matplotlib sklearn

如果有权限你也可以去掉 --user flag，-U 的意思是如果有的话安装更新
我们使用 Python 3，当然，要是有 IPython 和 Spyder 这种为数据分析 REPL 优化的东西就更好了，不过下面直接用 IPython3

现代机器学习算法主要包含概念学习、规则学习、基于解释学习、基于实例学习、遗传学习、强化学习、贝叶丝学习、神经网络、决策树等分类，当然我也不是很清楚都有啥大区别，反正就是数据分析就对了。

然后函数式编程一般有以下特征 #FP
+ 闭包、高阶函数、函数作为值
+ 基于 Lambda calculus、柯里化(currying)
+ 纯函数无副作用、引用透明、惰性求值
+ 模式匹配，递归作为程序控制基本方式
.... 跑题了，打住。

机器学习某度词条里说是”机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。“

其实你记住，无非就是数学的统计、概率、函数、微积分，然后加上计算机科学的算法、软件工程什么的最多了，其他的我们这些渣渣也用不到。

然后我现在”尤其“喜欢神经网络，不过很可惜还没有入门😑 不是因为神经网络复杂（一般我们手动会讨论的基本都是些小网络和网络结构什么的，然后还会讨论学习算法，神经元基本模型本身并不复杂）

在等待下载的时候可以先定义几个函数，首先我们要用 sklearn 里实现的 linear regression 学习实现
我可不擅长黑箱教学是̶因̶为̶话̶太̶多̶的̶缘̶故̶么̶

说起来这个教程居然还提到了 Python 有 Complex numbers（数学上的复数，包含实数和虚数单位）算是『惊喜』吗？

然后我们有了算法输入了（按照某学姐的说法，神经网络就是一个带有未知参数的程序，那机器学习的很多算法也差不多，这里是有仨输入仨未知系数一输出的数学函数，我们的学习算法会”猜“一个最优化的系数组）
那先按某个比率 k 切分学习数据和测试数据来的，定义函数 splitTrainingTestData



from pandas import DataFrame

def splitTrainingTestData(ts: DataFrame, kratio: int = 60) -> (DataFrame, DataFrame):


  assert kraito <= 100, "kratio must be valid integral percentage"  
  (txs, drs) = ts.values.tolist(), round(100 / kratio)
  training = txs[::drs]; testset = [x for x in txs if x not in training]
  return training, testset

... 刚才把 kraito 放到 ts 前面去了，Haskell 写多了的结果... （柯里化）
有点秀而且华而不实甚至有问题（跑）其实实践中不应该这么做，但是这里不是实践，所以推荐大家打开思路去实现算法
然后考虑一下最后的验证，测试预测准确率的函数 verifyRegressionAccuracy
当然，为了优雅性这时候可以给表格加上头（header）了，就是在它的第一行写上 x,y,z,w... 就是给数据列命名

def verifyRegressionAccuracy(ts: DataFrame, emax: float = 0.1, npredict = 'predict', ntruth = 'real') -> float:
  predicteds, truths = ts[npredict], ts[ntruth]
  acceptables = [t for (i, t) in enumerate(predicteds) if abs(t - truths[i]) <emax]
  return len(acceptables) / len(predicteds)
    

总之就是先弄出 acceptable result 然后 len 取分数啦
然后简单 play 一下，Python 表达起来也很方便

+ （书上的例子）Pip 已安装软件包

from pandas import DataFrame
from pkg_resources import working_set
import re

dists = [(d.project_name, d.version) for d in working_set]
pkgs = DataFrame()
pkgs['name'] = [n for (n, _) in dists]
pkgs['version'] = [v for (_, v) in dists]

pkgs.tail(5)
pkgs.sort_values('version').head(10)
pkgs.describe()

pkgs['version'].describe()
pkgs['version'].map(lambda v: int(re.sub('rc|dev|\.','', v))).astype(int)

隐隐约约会感受到 Python 的确是数据处理很方便，有不少遍历语法（slice 和复制的 [:] 下标、list comprehension [... for ... in ... if ...]）
但是！在其他新兴的编程语言（比如 Kotlin）里！这些功能基本都是可以直接用面向对象多态重载、运算符重载、高阶函数定义出来的！ 🤔

+ 简单的数据折线图(plot)

from matplotlib import pyplot as plot
from pandas import Series
from math import sin

然后一个简单的 sin series, 很经典吧？

xs = range(0,200, 3)

很可惜没有使用 float 的 range... 也罢

ys = [sin(x) for x in xs]

但是数据不容易看见，谁对着那堆数字有感觉啊！
数据可视化！

plot.style.available ... 看看可以有啥绘图风格

plot.style.use('Solarize_Light2')

然后

Series(ys).plot()
或者
plot.plot(ys)

均可，之后可以选择 plot.show() （貌似没有用）
和 plot.savefig('path.png')


—

然后可以开始了

from pandas import Series, read_csv

iris = read_csv('Iris.csv', encoding='utf-8', parse_dates=[], index_col=False)

然后我们就有了 Iris 数据集的工作实例(working set)（跑

先看看
In [39]: iris.describe()
Out[39]:

                x           y           z
count  150.000000  150.000000  150.000000
mean     5.843333    3.057333    3.758000
std      0.828066    0.435866    1.765298
min      4.300000    2.000000    1.000000
25%      5.100000    2.800000    1.600000
50%      5.800000    3.000000    4.350000
75%      6.400000    3.300000    5.100000
max      7.900000    4.400000    6.900000

count 是整个列表的求和
mean 是平均值、std 是方差
min， max 肯定都知道
50% 是中位数，其他 ?% 依此类推
In [40]:

iris['w'].value_counts()

Out[40]:

versicolor    50
virginica     50
setosa        50
Name: w, dtype: int64

In [43]:

iris.tail(5)

Out[43]:

       x    y    z          w
145  6.7  3.0  5.2  virginica
146  6.3  2.5  5.0  virginica
147  6.5  3.0  5.2  virginica
148  6.2  3.4  5.4  virginica
149  5.9  3.0  5.1  virginica

好了，已经说明问题了，现在我们要根据 f(x,y,z) 和它的结果 w 学习 f 这个曲线

不过有一个问题，就是 w 不是数值怎么量化，那我们就先看看按 0, 1, 2, ... 『文本矢量化』分会有怎么样的结果（怎么感觉和以前我把 Unification 当成泛化(Generalization) 的时候一样）

iris['id'] = Series().astype(int)



def vectorize(w,i, cname='w', cid='id', iris=iris): iris.loc[iris[cname]== w, cid] = i

In [3]: vectorize('setosa', 0)

In [4]: iris.head(5)
Out[4]:

     x    y    z       w   id
0  5.1  3.5  1.4  setosa  0.0
1  4.9  3.0  1.4  setosa  0.0
2  4.7  3.2  1.3  setosa  0.0
3  4.6  3.1  1.5  setosa  0.0
4  5.0  3.6  1.4  setosa  0.0

vectorize('versicolor', 1)
vectorize('virginica', 2)

OK, 这就是”矢“量化
iris.to_csv('Iris_vectorized.csv', index=False)

print (open('Iris_vectorized.csv').read())

In [17]: iris['id'].value_counts()
Out[17]:

2.0    50
1.0    50
0.0    50
Name: id, dtype: int64

然后进行数据预处理切分，之前的算法因为还有点偏差所以就不用了

from sklearn.model_selection import train_test_split

切分数据

iris_ds = iris.copy()

trainset, testset, trainsetid, testsetid = train_test_split(iris_ds, iris_ds['id'], train_size = 0.6)

del trainset['w']

trainset.describe()
trainsetid.describe()

就不填 random_state 了
然后直接用 sklearn 的算法学习

from sklearn.linear_model import LinearRegression
from math import floor

lreg = LinearRegression()
lreg.fit(trainset, trainsetid)

我们刚才”学习“了这些数据，看看我们能得到什么：

In [50]: testset.head(3)
Out[50]:

      x    y    z           w   id
91  6.1  3.0  4.6  versicolor  1.0
73  6.1  2.8  4.7  versicolor  1.0
79  5.7  2.6  3.5  versicolor  1.0

预测一下（”下面“都是 numpy 高性能计算的，这还有一层封装... 不过 pandas 也够了）

testset_truth = testset['w']
del testset['w']

—
testset['predict'] = lreg.predict(testset)

然后手工看看结果

value_map = {-1: 'setosa', 0: 'setosa', 1: 'versicolor', 2: 'virginica'}

testset['guess'] = testset['predict'].map(lambda x: value_map[floor(x)])
testset['w'] = testset_truth

🤔

分类的准确性有点可怕...：

看来线性回归也... 😟 不过很可惜，verifyRegressionAccuracy 只支持数值表项，看来只能另外写准确率判断了：

errors = testset[testset['w'] != testset['guess']]

In [32]: len(errors) / len(testset) * 100
Out[32]: 8.333333333333332

8.3% 的错误率！

— Question: 同一个 linearreg，那原作者分类的准确率为啥那么低

因为我的『向量化』是 one-hot encoding （独热码编码）的啊！

如果我写完全等价的实践（1,2,3 + round），你猜准确率又是怎么样的？

首先我们的回归结果是转换为文字形式的，试试数值形式：

from pandas import Series, read_csv
iris = read_csv('Iris.csv', encoding='utf-8', parse_dates=[], index_col=False)
iris['id'] = Series().astype(int)

—

def vectorize(w,i, cname='w', cid='id', iris=iris): iris.loc[iris[cname]== w, cid] = i
vectorize('setosa', 0); vectorize('versicolor', 1); vectorize('virginica', 2)

from sklearn.model_selection import train_test_split
iris_ds = iris.copy()

trainset, testset, trainsetid, testsetid = train_test_split(iris_ds, iris_ds['id'], train_size = 0.6)
del trainset['w'], trainset['id']

—

from sklearn.linear_model import LinearRegression
from math import floor

lreg = LinearRegression()
lreg.fit(trainset, trainsetid)

testset_truthw, testset_truthid = testset['w'], testset['id']
del testset['w'], testset['id']
testset['predict'] = lreg.predict(testset)
testset['id'] = testset_truthid

—

from pandas import DataFrame

def verifyRegressionAccuracy(ts: DataFrame, emax: float = 0.1, npredict = 'predict', ntruth = 'real') -> float:
predicteds, truths = ts[npredict], ts[ntruth]
acceptables = [t for (r, t) in zip(truths, predicteds) if abs(t - r) <emax]
return (len(acceptables) / len(predicteds)) *100



verifyRegressionAccuracy(testset, 1.0, 'predict', 'id')

结果是误差 100% 在 1.0 以内。[1]

== 然后再试一次：

vectorize('setosa', 1); vectorize('versicolor', 2); vectorize('virginica', 3)
iris_ds = iris.copy()

trainset, testset, trainsetid, testsetid = train_test_split(iris_ds, iris_ds['id'], train_size = 0.6)



del trainset['w'], trainset['id']

lreg = LinearRegression()
lreg.fit(trainset, trainsetid)

testset_truthw, testset_truthid = testset['w'], testset['id']
del testset['w'], testset['id']

testset['predict'] = lreg.predict(testset)
testset['id'] = testset_truthid

— 修改后的逻辑
In [14]: verifyRegressionAccuracy(testset, 1.0, 'predict', 'id')
Out[14]: 100.0
我们的依然是 100%，然后 0.1 的误差是 48%

然后使用独到的 1,2,3,... 序列：
In [23]: verifyRegressionAccuracy(testset, 1.0, 'predict', 'id')
Out[23]: 100.0 然后 0.1 的误差是 45%

🥺 打脸了。好像完全可以算在误差内嘛...

— 实际情况

所谓打脸是因为我不知道作者要『矢量回归』还 map 了一次 round
至于 round 之后的误差（即使 round 的结果和之前绝对值线性距离计算的也有很大关系...）... 嘻嘻 🌝

testset['predict'] = testset['predict'].map(round)
verifyRegressionAccuracy(testset, 1, 'predict', 'id')

结果是 96%... 好像又是差不多，欸奇怪了 🤔 真实无解
—
[1]: 后来发现，我在训练的时候忘记删掉了 id 参数... 它好像找到了一个作弊的方式 🤪
虽然比较辣鸡的算法显然也不能把 id 的系数提高到多少... 但是线性回归或许可以猜出来？

#book 这里 http://www.broadview.com.cn/book/4937

服了，博文视点上没有代码下载。看来此问题真实无解，难不成是我用的 Sklearn 太新了？

皮了一下午，那么就继续吧....
此书我寒假要找时间吐槽的，但是现在显然没有时间关心它
此书我已经看完了，剩下的内容也都已经阅读。

用 Sklearn 之类的框架做机器学习并不困难，只要你有点基础知识就可以，作者也说了，算法细节？呵呵

我们先用一个小数据集测试一下被抽象化的每个算法对预测的准确率，然后直接选好模型（虽然比较死，就是基于 Panda 数据表格的，差一点都不行，计算机视觉也不能搞）就开始上线... 然后... 就没有然后了

然后书本上面还有一些其他算法（比如 kNN）的例子，可以自己去 Sklearn 那里看，教程很详细，先溜了。

#Python #ML #machl #data #JavaScript 想看 Python 机器学习的从这里开始 👆
基本的 Iris 数据集线性回归分类入门

还是 sin wave 之类的数据，matplotlib 可以这么用：


from math import sin, cos, tan
from numpy import arange, array

from matplotlib import pyplot
from pandas import DataFrame, Series

xs = arange(0, 100, 0.1)
sinys = [sin(x) for x in xs]
cosys = [cos(x) for x in xs]
tanys = [tan(x) for x in xs]

plot.style.use('Solarize_Light2')

DataFrame(array([[xs], [sinys], [cosys], [tanys]]), columns = 'x sin(x) cos(x) tan(x)'.split())... 不行

def kv(name): return (name, globals()[name])
func_tab = DataFrame.from_items(dict(kv(xs), kv(sinys), kv(cosys), kv(tanys)))... 不行

waves = DataFrame()
waves['x'] = xs
waves['sin(x)'] = sinys; waves['cos(x)'] = cosys; waves['tan(x)'] = tanys

waves.index.name = 'x'
waves.plot(title='Triangle waves')

就可以得到好看的折线图了，并且非常容易使用

Pandas 的 DataFrame 就是字面意义上的数据框：一打可能有名字(index)的数据序列(pandas.Series)
只需要使用 EDSL（内部领域专属语言）操作它的实例就可以快速获得好看的数据图了，不需要不断去 plot 啊 add seris 再设置 xlabel ylabel 啊，都被良好封装（styles, chart type）了

上面本频道也有过 Ruby + GNUPlot 的版本

说到 tan，tanh 函数（双曲函数和三角函数有一定关系）因为其独特的性质也被人工神经网络当作激活函数。激活函数在神经元被传入信号的时候处理产生一个输出，继续正向传播。人工神经网络在回归的时候不需要运行激活函数，但是学习的时候必须运行激活函数。对于梯度下降学习算法来说，激活函数在其值域上必须是可导的，但是我不是很了解这些东西...

#Kotlin 求大佬解答

这里是 expression.getValueArgument(2)!!
这里是

@TypedIntrinsic(IntrinsicType.WORKER_EXECUTE)

public fun <T1, T2> execute(mode: TransferMode, producer: () -> T1, @VolatileLambda job: (T1) -> T2): Future<T2>

所以我很奇怪为什么它会说

if (irCallableReference?.getArguments().isNotEmpty() ?:false) context.reportCompilationError

显然有参数啊... 难不成 Lambda 的参数还不一样？还分隐式参数和显式参数？

Konan 的 Interop 参数配置： #Kotlin

defFile pkg target

linkerOpts compilerOpts

headers includeDirs linkFiles

dumpParameters

这里可以看到更多

https://github.com/Trumeet/Desktop #Kotlin 看起来比较简单，我也想默写一个（部分不默写，比如 bitflags）

这次我会用一点面向对象（Mixins）

写完了，但是没有用，好像花了两个小时... 一部分时间是处理 Gradle build 的，熟悉插件，然后 Gradle 也不熟练，也就是能用一点 plugin configuration 和 sourceset.... 很菜的

这里直接 identity(null) 是因为 Secured 抽象类已经处理好了这部分状态不需要再去关心

好像没有使用 Mixin... 因为那个的确是比较麻烦（有可能还要用 CGLib 什么的）
然后这里也的确没啥东西需要 Mixin 的，何况那个抽象类的方法都是 protected 的，从外面看也很像 Mixin 了

Commit 明确了一下 parameter 和返回值的传递，都是没有用处的值

那我再写一个（求别喷为什么不干有意义的事情）

[DuangSUSE@duangsuse]~/Projects% jar tf Yuuta\ \(2\).jar|head -n4
META-INF/MANIFEST.MF
META-INF/
Base64AndDDoS.class
org/
[DuangSUSE@duangsuse]~/Projects% javap -cp Yuuta\ \(2\).jar Base64AndDDoS
Compiled from "Base64AndDDoS.java"
public class Base64AndDDoS {
public Base64AndDDoS();
public static void main(java.lang.String[]) throws java.io.IOException, java.lang.InterruptedException;
}
... 看起来还是不如直接用 Python 之类的写（当然文本处理推荐 Perl）

不过为了方便学习 OkIO, OkHttp 就写点吧...