自己初学Python过程中的问题

2021.4.15

 

1.本来应该用Anaconda Prompt，但是用成了Anaconda Powershell Prompt.

2.一开始在Anaconda Prompt里面总是没办法切换至Anaconda 安装的文件夹，试了几个路径也不对，后来发现是 没有在Anaconda Navigator里面看oop的路径。

3.以上就是在Anaconda Prompt中安装sklearn、numpy等模块（安装好的时候跳出来两个DEBUG,不确定是否为报错）

然后我看了一下把Anaconda 换到国内镜像源，发现cmd中不能使用pip

1. 然后问题就变成 “如何能使pip在cmd中运行起来，并由此检验是否能运行阿里云的镜像源”

查找了很多方法，主要的解决方向是“通过在高级配置中对PATH做增添，从而使其能运行Python”

但是反复尝试更改设置、添加路径都不成功。甚至都研究起来怎么让系统在用Anaconda 里面自带的Python的时候，不要warning, 尝试做了，仍不成功。

 

这一个问题困扰了我几个小时。

最终我觉得，还是应该重装一个单独的Python,因为Anaconda 里面自带的Python仅仅只是一个应用程序，下面没有文件夹，导致通过在高级配置中对PATH做增添时压根无法识别路径，而且这一应用程序下面也并未包含pip的组件。

于是又单独下了Python 2.7,并终于在cmd 里面运行pip时不再弹出“不是内外部命令”，而是提供了pip 的命令菜单。如下图所示。

 

于是我兴冲冲地跟着B站上面的视频，输入以下命令：pip install numpy（安装numpy模块）

可惜天不遂人愿，他真的又在报错：

 

查询了一下，说是因为pip的版本太低，遂又升级pip,输入命令:python -m pip install --upgrade pip

结果依旧是报错：'python' 不是内部或外部命令，也不是可运行的程序或批处理文件。

又去搜了几种解决方案，依旧报同样的错。

后来终于发现，它是因为不能在C盘路径下运行“python”命令，然后赶快cd 到F盘里面（好像是因为如果在C盘下面跑，需要以管理员身份运行），命令如下：

 

C:\Users\lenovo>cd F:\Python

 

C:\Users\lenovo>f: \

 

F:\Python>python -m pip install --upgrade pip（升级pip版本）

 

终于升级OK，如下图：

 

 

 

然后又开始测试它能不能从阿里云的镜像源下载组件：

 

F:\Python>pip install numpy

 

终于成功了！

 

 

 

可以从Looking in indexes: http://mirrors.aliyun.com/pypi/simple/ 看出，确实是在阿里云的库里面下的！！

 

终于完成了把Anaconda 换到国内镜像源。

 

1. 更换国内pip源，遇到问题：'conda' 不是内部或外部命令，也不是可运行的程序

原因：升级win10之后，没有把anaconda的路径添加到环境变量。

解决办法：

（1.找到Anaconda在电脑里的路径，比如：’D:\anaconda‘ 和’D:\anaconda\Scripts‘，添加到path中。

（2.具体操作方法：右键 我的电脑–属性–高级系统设置–高级–环境变量–用户变量（仅限该用户）/系统变量（所有用户）–path–编辑–新建（把路径加进去）。

（3.回到cmd中再次执行上述语句（如果依然报错，可以关掉cmd，重新进入试试哦）。

 

另外，如果要安装或升级python里用到的包，都可以用’conda update/install ***‘语句操作。

 

1. Anaconda创建虚拟环境报错 CondaHTTPError: HTTP 000 CONNECTION FAILED for url An HTTP error occurred when try

最终解决方案：

 时隔一天，在摸索和学习Anaconda其他模块是，发现，是楼主安装Anaconda后，环境变量配的有问题，

 

需要配置3个路径：

anacoda配置环境变量：

 

至少包括Anaconda、Anaconda/Scripts、Anaconda/Library/bin三个目录 ！！！

 

E:\Anacoda3\Library\bin

 

E:\Anacoda3\Scripts

 

E:\Anacoda3\（这里一定要注意别少打最后一个斜杠）

（这里E:\Anacoda3\是楼主安装anoconda的位置）

 

 

成功截图如上，可以看到，我们已经找到了一个安装包，以后就可以从清华的源里面下载，下载速度会快很多。

 

7.

Anaconda 搜索conda search  --full --name python，

报错：An unexpected error has occurred.Conda has prepared the above report.

 

我就开始看报的错误，一一尝试

 

后面发现这个地方，抱着试一试的态度，打开一看 .condarc，啥都没有，反正也没有删除算了，

 

 

然后再次打开，居然就能够用了，模块的安装也能正常了。

 

1. 安装TensorFlow，主要注意两点。一是TensorFlow版本与Python版本的问题，二是注意，要安装GPU版本的TensorFlow，就必须安装CUDA和CUdnn.

https://b23.tv/7or5Ow  B站安装tensorflow视频

Tips:
1. 安装CUDA的前提条件是你的GPU必须是英伟达的。
2. 安装CUDA10.0.130版本前需要先将N卡驱动更新至411.31及以上(如不清楚当前版本，可在N卡驱动面板查取)。
3. 安装过程中，必须要先安装Visual Studio，再安装CUDA，最后再安装Cudnn，顺序不能打乱哦～
 

辅助参考CSDN文章：

win10下CUDA和CUDNN的安装

https://blog.csdn.net/u011473714/article/details/95042856?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%AE%89%E8%A3%85%E4%BA%86CUDA%E5%90%8E%E6%89%BE%E4%B8%8D%E5%88%B0cudnn%E5%8E%8B%E7%BC%A9%E5%8C%85&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-3-95042856.first_rank_v2_pc_rank_v29

 

   

  

我自己的Python是3.8.0的，安装TensorFlow的时候，它自己默认成了最新的TensorFlow2.4.1，反正跑import tensorflow就有问题，查了一下，建议是降低到2.3.0，然后我就从阿里云里面下了个2.3.0（代码忘记保存了，随便搜一下就有）

 

这里吐槽一下清华源，pip一直在超时，而且下载速度也不如阿里云。

 

然后反正安装完TensorFlow，用import tensorflow一直在显示

       

就是找不到cudart64_110.dll

这里，我之前看人说，cudart64_110代表要装CUDA11.0，不过当时学姐装的是10.1,我就跟着装CUDA 10.1 了，后面也没啥问题，不知道是不是都可。

 

重点：为了解决TensorFlow就是找不到cudart64_110.dll的问题我开始装CUDA10.1，但是安装过程中，必须要先安装Visual Studio2019，再安装CUDA10.1，最后再安装Cudnn，顺序不能打乱.

 

Cudnn版本要和CUDA10.1匹配，官网下载的时候有明显提示的。

 

具体安装过程不难，看B站&学姐文档&CSDN可以解决。

 

1. 从Github上down了一个averages的代码，在PyCharm上面跑，一开始报错没有numpy模块，后来我直接在PyCharm上install了numpy，然后又开始报其他错误。

解决方法：无，那个代码太复杂，我也看不懂。

 

1. 关于简单平均

经过上个代码摧残，我果断从Pycharm换到了Spyder,然后在Github上面，把关键词，从average,换成了average mean，然后找到了挺简单那种计算平均的代码。

一个特别搞笑的error:

  

我试了很多种输入方法，用逗号隔开呀，用一个空格隔开呀之类的，后来发现...他是要一个一个输入，不能像C语言那样，就直接一串数字。

 

这一种代码附在下方：

import os

os.system('cls')

 

number1 = int(input("How many numbers does your arithmetic mean have? ")

//询问会输入几个数字

total_sum = 0                 //令总和为0

for n in range (number1):     //循环相加

    number2 = float(input("Number: "))//输入待求平均值的数字

    total_sum += number2             //数字之和

result = total_sum / number1        //求平均值

print("The result is", result)     //输出平均值

input()

 

不过，如果待求平均值的数字个数很多，这样输入就很麻烦了，但是我在Github上没看到很多用Python来实现算术平均的。

 

还找到另一个算法，也是要一个个输入：

# Finding averages of a list

 

list = []

counter = True

 

while counter == True:

    print("Welcome to the average calculator. Press Q to quit")

    nums = input("Enter a number: ")

    if nums == "Q":

        counter = False

    else:

        nums = int(nums)

        list.append(nums)  //append() 方法用于在列表末尾添加新的对象。

 

def avglist(list):

    return sum(list) / len(list)        //定义了求平均数的函数，就是用列表中数字之和除以列表的长度

 

list_avg = avglist(list)

 

print("The average of your list is " + str(list_avg) + ".")

print("Thank you for using this simple script!")

 

这种代码比第一种好的地方在于，我不需要提前知道你有几个数字，就是一直输入，当你输入Q的时候，我就知道结束了，并返回平均值。缺点仍然是你无法输入一串数字。

 

然后我就去了CSDN,找找看有没有解决的方法：

找到了如下代码：

 

#coding=utf-8

#Version: python3.6.0

#Tools: Pycharm 2017.3.2

_author_ = ' Hermione'

 

nums=input().split()

numlist=[int(n) for n in nums]

m=sum(numlist)

n=len(numlist)

avg=int(m)/int(n)

print(int(avg))

 

是可以直接输入一串数字的：

 

 

自己决定再加两个print:

#coding=utf-8

#Version: python3.6.0

#Tools: Pycharm 2017.3.2

_author_ = ' Hermione'

print("Welcome to the average calculator.\n")

print("Please enter some numbers:")

nums=input().split()

numlist=[int(n) for n in nums]

m=sum(numlist)

n=len(numlist)

avg=int(m)/int(n)

print("\nThe average of your list is ",avg)

 

稍微再改了下最后一句输出，让输出值不是整数，结果如图：

 

 

但是这个还是有个问题，好像只能计算整数的平均值。

当我输入：

22.3 44.5 66.7

 

会直接报错：

Traceback (most recent call last):

 

  File "C:\Users\lenovo\.spyder-py3\temp.py", line 16, in

numlist=[int(n) for n in nums]

 

  File "C:\Users\lenovo\.spyder-py3\temp.py", line 16, in

    numlist=[int(n) for n in nums]

 

ValueError: invalid literal for int() with base 10: '22.3'

 

在用pthon写脚本得过程中，发生错误，ValueError: invalid literal for int() with base 10，这种错误是值的类型转换错误，int()函数是可以将字符串转换为整形，但是这个字符串如果是带小数的，比如‘470.00’,这个时候如果你再用int(‘470.00’)转换的话，就会出现上面报的错误。

 

解决办法：这个时候可以用float()函数处理这个问题，在你不确定这个字符串是整形还是浮点数得情况下，用float（）比较好，这样可以避免出现错误。

float(str)函数将符合浮点型的规定的字符串转换成float型的。

 

修改以后的代码：

#coding=utf-8

#Version: python3.6.0

#Tools: Pycharm 2017.3.2

_author_ = ' Hermione'

print("Welcome to the average calculator.\n")

print("Please enter some numbers:")

nums=input().split()

numlist=[float(n) for n in nums]

m=sum(numlist)

n=len(numlist)

avg=float(m)/int(n)

print("\nThe average of your list is ",avg)

 

结果如图：

 

芜湖~

根据之前已经看过的理论知识：

简单平均法是根据已有的t个观察值Y1、Y2 ...Yt,通过简单平均来预测第t+1期的数值。

设时间序列已有t期观察值Y1、Y2 ...Yt，则第t+1期的预测值Ft+1为：

Ft+1= 

到t+1期之后，就有t+1个观察值Y1、Y2 ...Yt、Yt+1,即可以得到第t+1期的预测误差et+1:

 (误差=实际观察值-预测值)

同理可得，t+2期预测值Ft+2为：

Ft+2= 

[要记得把t+1期的实际观察值加进去，同时最前面的系数也要改]

 

最后一个代码应该能完成模型要求。

 

 

1. Python中 sys.argv[]的用法简明解释 https://www.cnblogs.com/aland-1415/p/6613449.html

 

因为找的关于指数平均里面的代码里面有sys.argv[]函数，导致根本搞不懂那个代码在干嘛，所以开始跟着上述链接学习sys.argv[]函数。

sys.argv[]说白了就是一个从程序外部获取参数的桥梁，这个“外部”很关键，所以那些试图从代码来说明它作用的解释一直没看明白。因为我们从外部取得的参数可以是多个，所以获得的是一个列表（list)，也就是说sys.argv其实可以看作是一个列表，所以才能用[]提取其中的元素。其第一个元素是程序本身，随后才依次是外部给予的参数,下面我们通过一个极简单的test.py程序的运行结果来说明它的用法。

1 #test.py

2

3 import sys

4 a=sys.argv[0]

5 print(a)

将test.py保存在c盘的根目录下。

在程序中找到 ‘运行’->点击->输入"cmd"->回车键   进入控制台命令窗口（如下图），先输入cd c:\   (作用是将命令路径改到c盘根目录)，然后输入test.py运行我们刚刚写的程序：

  

得到的结果是C:\test.py，这就是0指代码（即此.py程序）本身的意思。

然后我们将代码中0改为1 :

a=sys.argv[1]

保存后，再从控制台窗口运行，这次我们加上一个参数，输入：test.py what

  

 得到的结果就是我们输入的参数what，看到这里你是不是开始明白了呢。

那我们再把代码修改一下：

a=sys.argv[2：]

保存后，再从控制台窗台运行程序，这次多加几个参数，以空格隔开:

test.py a b c d e f

  

得到的结果为[‘b’, ’c’, ’d’, ’e’, ’f’]

应该大彻大悟了吧。Sys.argv[ ]其实就是一个列表，里边的项为用户输入的参数，关键就是要明白这参数是从程序外部输入的，而非代码本身的什么地方，要想看到它的效果就应该将程序保存了，从外部来运行程序并给出参数。

 

 

补充另一个CDDN上的解释：argv[0]代表模块文件名、argv[1]代表传入的第一个命令行参数

详解：argv是sys模块的一个全局变量，也称sys模块的一个属性！argv本身为一个list类型的对象，该对象持有的第1个元素是命令行中传入的模块名、从第2个元素开始（含），均为命令行中传入的参数！

注意：argv持有的每个元素的类型均为str（字符串）

举个例子

python temp.py a b c d

说明：命令行运行temp.py模块，同时传入4个参数：a、b、c、d

sys.argv == ["temp.py","a","b","c","d"]  #sys.argv是持有5个元素的list对象

sys.argv[0]  == "temp.py"   #第1个元素为模块名“temp.py”

sys.argv[1] == "a"               #第2个元素为"a"

sys.argv[2] == "b"               #第3个元素为"b"

sys.argv[3] == "c"               #第4个元素为"c"

sys.argv[4] == "d"               #第5个元素为"d"

 

4.26晚更新：跟着上述过程走，sys.argv[]函数是sys.argv[0]的时候没问题，执行sys.argv[1]，报错IndexError: list index out of range问题

 

结果发现输的命令不对。。。

应该输入 python test.py what

 

   

并且最后把代码修改成：

a=sys.argv[2：]

保存后，再从控制台窗台运行程序，这次多加几个参数，以空格隔开:

test.py a b c d e f

结果如图：

 

成功啦~也就是再次强调一下Sys.argv[ ]其实就是一个列表，里边的项为用户输入的参数，关键就是要明白这参数是从程序外部输入的，而非代码本身的什么地方，要想看到它的效果就应该将程序保存了，从外部来运行程序并给出参数。

 

于是我就开始调用之前那个在Github上面down下来的代码：如图

命令：python exponentially_weighted_avg.py

 

 

因为没看懂代码，先乱输了几个

如果是输入 a b c,结果是a乘以c减去b

 

然后到输四个数字，我就看不出了。

 

估计还是得回去老老实实看懂代码。

 

11.关于指数平滑法

exponentially_weighted_avg.py的代码如下：

import sys

#first arg is the weight, a; the next are the values

 

a = float(sys.argv[1]) #first arg in sys.argv is the file name也就是说：sys.argv持有的第1个元素（即sys.argv[0]）是命令行中传入的模块名，

sys.argv持有的第2个元素（即sys.argv[1]）才是权重a。

running_avg = float(sys.argv[2]) //sys.argv持有的第3个元素（即sys.argv[2]）是用户待处理数据。

//即代码作者所言：First user arg: the weight "a"

Subsequent user args: the samples of the data set to be averaged

for n in range(3,len(sys.argv)):

//for i in range什么意思:for循环可以遍历任何序列的元素，如逐个输出字符串、列表、字典或元组等中的元素。它是一种迭代循环机制。通俗点说，就是把这个循环中的第一个元素到最后一个元素依次访问一次，并把访问到的元素供执行语句使用。

//range(start,end) 默认步长为1，因为sys.argv持有的第3个元素开始，（即sys.argv[2]），才是用户待处理数据。所以这行代码中，range的start是3。

running_avg = a*float(sys.argv[n]) + (1-a)*running_avg

print(running_avg)

 

//这是for循环下面待执行的函数

//回头来看理论模型：一次指数平滑法

一次指数平滑法又称单一指数平滑法，只有一个平滑系数，且观察值离预测时期越久远，权数变得越小。一次指数预测公式为：

 

Ft+1=aYt+(1-a)Ft

 

式中，Ft+1是第t+1期的预测值，即本期（t期）的平滑值St ；

Yt是第t期的实际观测值；

Ft是第t期的预测值，即上期的平滑值St-1 ；

a是平滑系数，范围（0,1）【不取边界值】。

即：第t+1期预测值是第t期实际观测值和第t期的预测值的加权平均。

 

理解一下：一次指数预测公式为：

 

Ft+1=aYt+(1-a)Ft

 

代码中是running_avg = a*float(sys.argv[n]) + (1-a)*running_avg

 

我们设F1=Y1（设第1期的预测值等于第1期的实际观测值），

则第2期的预测值F2=aY1+(1-a)F1=Y1

第3期的预测值F3=aY2+(1-a)F2=aY2+(1-a)Y1

 

考虑到n是从3循环至最后用户输入的最后一个值，有：

不妨假设 用户输入的参数为：0.5 1 2 3 4，程序运行结果是3.125

注意一下：输入的第一个数字是有范围限制滴：0~1,而且不可以取0~1

 

那么，

n=3,F1=Y1=1

n=4,F2=F2=aY1+(1-a)F1=Y1=1

n=5,F3=aY2+(1-a)F2=aY2+(1-a)Y1=0.5*2+0.5*1=1.5     n=6,F4=aY3+(1-a)F3=aY3+(1-a)aY2+(1-a)2Y1=0.5*3+0.5*0.5*2+0.5*0.5*1=2.25

N=7,F5=aY4+(1-a)F4=aY4+(1-a)[aY3+(1-a)aY2+(1-a)2Y1] =aY4+(1-a)aY3+(1-a)2aY2+(1-a)3Y1=0.5*4+0.5*0.5*3+0.5*0.5*0.5*2+0.5*0.5*0.5*1

=3.125!!!

和程序上跑出来的一模一样！！！

开心~

 

Emmm,我觉得这个代码挺好滴，就不再继续看别的代码了，稍微修改一下输出：

原代码附下：

 

 

import sys

#first arg is the weight, a; the next are the values

 

a = float(sys.argv[1]) #first arg in sys.argv is the file name

running_avg = float(sys.argv[2])

 

for n in range(3,len(sys.argv)):

       running_avg = a*float(sys.argv[n]) + (1-a)*running_avg

 

print(running_avg)

 

自己修改一下：

import sys

#first arg is the weight, a; the next are the values

print("\nWelcome to the average calculator.")

 

a = float(sys.argv[1]) #first arg in sys.argv is the file name

running_avg = float(sys.argv[2])

 

for n in range(3,len(sys.argv)):

       running_avg = a*float(sys.argv[n]) + (1-a)*running_avg

 

print("\nThe Exponentially-Weighted-Average of your list is ",running_avg)

 

输出结果如图：

 

 

 

即得到了一次指数平滑法的输出结果。且通过这个小小的例子，我们也清晰的感受到了观察值离预测时期越久远，权数变得越小。

而且我们本身就是要用一组数据预测下一个值，所以中间值不需要输出。

 

 

下面的部分是研究移动平均：

 

12.清华源又开始抽风了，下个chainer都报错

再次换到阿里云：

(base) C:\Users\lenovo>activate oop

(oop) C:\Users\lenovo>cd F:\Anaconda\envs\oop

(oop) C:\Users\lenovo>F:

(oop)F:\Anaconda\envs\oop>

python -m pip install -i http://mirrors.aliyun.com/pypi/simple/ chainer

 

4.28更新：最后一行可以直接用pip install chainer

我今天直接用pip下载包的时候，的确是用阿里云的镜像源，然后突然记起培宁以前说过pip安装是通过 pip.ini找安装源的，conda是从.condarc找安装源的
而pip.ini 的配置文件里面写的恰好是阿里云的镜像源地址
kkkk，我懂了，只要用pip命令，就是走阿里云的。

真的好讨厌清华源。。。

 

就OK了。

 

后续更新1：这个没安装到Anaconda环境下面，不知为何。

所以又去找了一下解决方法：

一、创建一个环境

二、切换一个已创建的环境

 

代码如下（示例）：

 

conda activate torch_demo

 

如图，从base环境切换到crs环境（一个新建的环境）

三、安装指定版本的包   切换镜像源下载

 

代码如下（示例）：

 

    conda install tensorflow-gpu==2.0.0

    pip install torch==0.4.0

 

conda没有搜索到该包的话，可以换成pip。

切换镜像源安装各种包：

 

用pip管理工具安装库文件时，默认使用国外的源文件，因此在国内的下载速度会比较慢，可能只有50KB/s。幸好，国内的一些顶级科研机构已经给我们准备好了各种镜像，下载速度可达2MB/s。

其中，比较常用的国内镜像包括：

 

（1）阿里云 http://mirrors.aliyun.com/pypi/simple/

（2）豆瓣http://pypi.douban.com/simple/

（3）清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/

（4）中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

（5）华中科技大学http://pypi.hustunique.com/

 

 设置方法：（以清华镜像为例，其它镜像同理）

 

（1）临时使用：

可以在使用pip的时候，加上参数-i和镜像地址(如

https://pypi.tuna.tsinghua.edu.cn/simple)，

例如：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas，这样就会从清华镜像安装pandas库。

 

2）永久修改，一劳永逸：

（a）Linux下，修改 ~/.pip/pip.conf (没有就创建一个文件夹及文件。文件夹要加“.”，表示是隐藏文件夹)

内容如下：

 

[global]

index-url = https://pypi.tuna.tsinghua.edu.cn/simple

[install]

trusted-host = https://pypi.tuna.tsinghua.edu.cn

 

或：

 

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

 

(b) windows下，直接在user目录中创建一个pip目录，如：C:\Users\xx\pip，然后新建文件pip.ini，即 %HOMEPATH%\pip\pip.ini，在pip.ini文件中输入以下内容（以豆瓣镜像为例）：

 

[global]

index-url = http://pypi.douban.com/simple

[install]

trusted-host = pypi.douban.com

 

 

后续更新2：培宁说：清华源全一点，但是阿里源快，一般都用阿里源的pip，conda除了创建虚拟环境一般不用。也就是说，conda本来就对国内环境不是很友好,一开始我用conda就不太好。

 

一开始就直接pip install xxx就可以了。

我再去跑一下。

 

1. 跑F:\A_code_of_LIQIN\Exponential_Moving_Average_1里面的 example.py的时候，一直报错：

File "F:\A_code_of_LIQIN\Exponential Moving Average\example.py", line 2, in

    import chainer

ModuleNotFoundError: No module named 'chainer'

一开始的确是因为我自己在Anaconda下面没有安装chainer模块，但是安装好以后，还是继续报错，就很离谱。

去CSDN上瞄了一眼：

https://blog.csdn.net/lq_qingqing/article/details/51320969?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161950734416780255225425%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161950734416780255225425&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-51320969.first_rank_v2_pc_rank_v29&utm_term=ModuleNotFoundError%3A+No+module+named+%27chainer%27

以及

https://blog.csdn.net/jdbc/article/details/80351833?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&dist_request_id=1332048.21269.16195256800160217&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control

除了常见的问题，切记程序名字不要和包的名字一样

我自己的问题是：该模块已经安装，但是没有安装到python的搜索路径下

于是添加了两行代码：

import sys

sys.path.append("f:\Anaconda\envs\oop\Lib\site-packages")

//这是我安装chainer模块的路径

就OK 了。

然后又报错：File "F:\A_code_of_LIQIN\Exponential Moving Average\example.py", line 6, in

    from exponential_moving_average import ExponentialMovingAverage

ModuleNotFoundError: No module named 'exponential_moving_average'

 

估计还是路径的问题，遂添加语句

sys.path.append("F:\A_code_of_LIQIN\Exponential_Moving_Average_1")

因为from exponential_moving_average import ExponentialMovingAverage这行代码，就是example.py要从exponential_moving_average.py里面调用module named 'exponential_moving_average'。

也成功解决了，代码运行截图：

 

反正还是看不懂输出的代码是啥意思。

这个代码应该是指数移动平均算法，我看不太懂，故决定先看看比较简单的。

来自CSDN:

Python中滑动平均算法（Moving Average）方案：

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import numpy as np

# 等同于MATLAB中的smooth函数，但是平滑窗口必须为奇数。

# yy = smooth(y) smooths the data in the column vector y ..

# The first few elements of yy are given by

# yy(1) = y(1)

# yy(2) = (y(1) + y(2) + y(3))/3

# yy(3) = (y(1) + y(2) + y(3) + y(4) + y(5))/5

# yy(4) = (y(2) + y(3) + y(4) + y(5) + y(6))/5

# ...

def smooth(a,WSZ):

# a:原始数据，NumPy 1-D array containing the data to be smoothed

# 必须是1-D的，如果不是，请使用 np.ravel()或者np.squeeze()转化

# WSZ: smoothing window size needs, which must be odd number,

# as in the original MATLAB implementation

out0 = np.convolve(a,np.ones(WSZ,dtype=int),"valid")/WSZ

r = np.arange(1,WSZ-1,2)

start = np.cumsum(a[:WSZ-1])[::2]/r

stop = (np.cumsum(a[:-WSZ:-1])[::2]/r)[::-1]

return np.concatenate(( start , out0, stop ))

# another one，边缘处理的不好

"""

def movingaverage(data, window_size):

window = np.ones(int(window_size))/float(window_size)

return np.convolve(data, window, "same")

"""

# another one，速度更快

# 输出结果 不与原始数据等长，假设原数据为m，平滑步长为t，则输出数据为m-t+1

"""

def movingaverage(data, window_size):

cumsum_vec = np.cumsum(np.insert(data, 0, 0))

ma_vec = (cumsum_vec[window_size:] - cumsum_vec[:-window_size]) / window_size

return ma_vec

"""

这个代码在Spyder上面跑的有问题，在报错，明天再看吧，今天太困了。

 

今天残留的疑问：加权移动平均和指数移动平均是不是就是一个玩意？

明天还是从简单移动平均开始看吧，直接上指数移动平均看不懂。而且我总感觉指数移动平均，就是指数平均。。。

 

4.28更新：去CSDN上面瞄了一眼，

（Tensorflow之六）滑动平均模型ExponentialMovingAverage

https://blog.csdn.net/abiggg/article/details/78946007?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control&dist_request_id=1619571077077_09333&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-1.control

模型：

mn=decay∗mn−1+(1−decay)∗an=decayn−1∗a1+decayn−2∗(1−decay)+...+(1−decay)∗an

指数移动平均，不是指数平均

一般而言，为了使模型趋于收敛，会选择decay为接近1的数，例如：
decay = 0.99;
那么：

m1=a1

m2=0.99∗a1+0.01∗a2

m3=0.99∗m2+0.01∗a3=0.992∗a1+0.01∗0.99∗a2+0.01∗a3
我们发现初始值对后面影响非常大，若初始值与真实值偏差较大时，函数收敛速度非常慢；为了解决该问题，tensorflow提供了num_updates参数来动态设置decay的大小；

decay=min{DECAY,1+num_updates10+num_updates}

我觉得CSDN上的代码指定都有那大病，怎么改都改不对，可能是因为作者用的tensorflow的版本是1.X，就报一些奇奇怪怪的错误，改都改不对。

算了，还是去Github吧。

 

 

1. 去Github上down了一个简单移动平均的代码

forked from 0701pawan/Simple_moving_average

跑起来是没得问题的（Github真好TAT），而且只有30多行，下午过来看吧。

 

import pandas as pd

from alpha_vantage.timeseries import TimeSeries

from alpha_vantage.techindicators import TechIndicators

//alpha_vantage Python模块从alphavantageapi获取股票数据

api_key = 'MQH3XTZ53ASTQ7EA'

### Setting api_key ####

//api_key就类似一个通行证那种

ts = TimeSeries(key=api_key, output_format='pandas')

##### This helps us to set output format as pandas data frame ####

 

data_ts, meta_data_ts = ts.get_intraday(symbol='MSFT', interval='1min', outputsize='full')

 #### This will take set interval at what time we need take closing stock price###

 

period = 60

#Setting period

 

ti = TechIndicators(key=api_key, output_format='pandas')

##### This helps us to set output format as pandas data frame ####

 

data_ti, meta_data_ti = ti.get_sma(symbol='MSFT', interval='1min', time_period=period, series_type='close')

##### This will take set interval and period at what which we want to calculate the SMA ####

#####这将设置我们想要计算SMA的设定间隔和周期####

 

df1 = data_ti

df2 = data_ts['4. close'].iloc[period-1::]

###### This helps in showing only the last closing price at which period ends ####

### This helps in setting the output format ####

###这有助于设置输出格式####

 

df2.index = df1.index

 

total_df = pd.concat([df1, df2], axis=1)//这个好像是数据拼接

print(total_df)   

问题是，我没咋看到他这个移动平均在哪一行算的，感觉是单纯用来获取数据。

 

 

1. 在Github上面down的那些代码，大多数都是用来计算股票数据的，不太适用。我觉得问题13~14没太多用处。

在CSDN上面找了新的代码：移动平均指数平滑python实现

https://blog.csdn.net/weixin_45389639/article/details/105968141?utm_term=python%E5%AE%9E%E7%8E%B0%E7%A7%BB%E5%8A%A8%E5%B9%B3%E5%9D%87%E5%80%BC&utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduweb~default-4-105968141&spm=3001.4430

 

可以实现移动平均，代码如下：

import numpy as np

 

def Move_average(list, n): //定义Move_average函数，参数为list和n

 

list = np.convolve(lis, np.ones(n) / n, mode='valid')

//numpy.convolve函数，见下面分析

    print("移动平均: ", list)

    return list

 

def Std(list):

 

    std = np.std(list)

    print("标准差:", std)

 

def Smoothing_factor(list1, list2, n, nums):

 

    T=1.0

    a = 2*list1[-1]-list2[-1]

    b = 2/(n-1)*list1[-1]-list2[-1]

    print("平滑系数a，b分别为: ", a, b)

    X = a+b*T

    print("第%d期的预测值为:" %(nums+1), X)

 

if __name__ == '__main__':

 

    nums = 8

    n = 3

    lis = []

    lis2 = []

 

    for i in range(0, nums):

        lis.append(np.random.randint(100))

 

    lis.sort()

    print("原始列表为: ", lis)

    lis = Move_average(lis, n)

    Std(lis)

    lis2 = Move_average(lis, n)

    Smoothing_factor(lis, lis2, n, nums)

  运行截图如下：

 

                                

下面研究一下代码：

1.滑动平均概念

滑动平均滤波法（又称递推平均滤波法），是把连续取N个采样值看成一个队列 ，队列的长度固定为N ，每次采样到一个新数据放入队尾,并扔掉原来队首的一次数据.(先进先出原则) 把队列中的N个数据进行算术平均运算,就可获得新的滤波结果。N值的选取：流量，N=12；压力：N=4；液面，N=4~12；温度，N=1~4

优点： 对周期性干扰有良好的抑制作用，平滑度高 适用于高频振荡的系统

缺点： 灵敏度低 对偶然出现的脉冲性干扰的抑制作用较差 不易消除由于脉冲干扰所引起的采样值偏差 不适用于脉冲干扰比较严重的场合 比较浪费RAM。

2.解决思路

可以发现滑动平均滤波法计算很类似与一维卷积的工作原理，滑动平均的N就对应一维卷积核大小（长度）。

步长会有些区别，滑动平均滤波法滑动步长为1，而一维卷积步长可以自定义。还有区别就是一维卷积的核参数是需要更新迭代的，而滑动平均滤波法核参数都是一。

我们应该怎么利用这个相似性呢？其实也很简单，只需要把一维卷积核大小（长度）和N相等，步长设置为1，核参数都初始为1就可以了。由于一维卷积具备速度快，然后我们就可以使用一维卷积来实现这个功能了，快速高效。

使用深度学习框架实现这个功能是否有些大材小用了？是有些大材小用了，因为这里使用卷积的核参数不用更新，其实没必要使用复杂的深度学习框架，如果Numpy中可以实现这些功能就更简单方便了。

说干就干，经过查找发现Numpy.convolve可以实现我们想要的功能。

 

3.Numpy.convolve介绍

numpy.convolve(a, v, mode=‘full’)

参数：

a:(N,)输入的一维数组

v:(M,)输入的第二个一维数组

mode:{‘full’, ‘valid’, ‘same’}参数可选

‘full’　默认值，返回每一个卷积值，长度是N+M-1,在卷积的边缘处，信号不重叠，存在边际效应。

‘same’　返回的数组长度为max(M, N),边际效应依旧存在。

‘valid’ 　返回的数组长度为max(M,N)-min(M,N)+1,此时返回的是完全重叠的点。边缘的点无效。

和一维卷积参数类似，a就是被卷积数据，v是卷积核大小。

 

4.算法实现def np_move_avg(a,n,mode="same"):

return(np.convolve(a, np.ones((n,))/n, mode=mode))

而我（TLQ）在CSDN上找的代码中，这一行的实现方式是：

list = np.convolve(lis, np.ones(n) / n, mode='valid')

return list

也就是说lis是输入的第一个一维数组，mode选择‘valid’ ，即返回的数组长度为max(M,N)-min(M,N)+1,此时返回的是完全重叠的点。边缘的点无效。

 

原理说明

运行平均值是卷积数学运算的一个例子。对于运行平均值，沿着输入滑动窗口并计算窗口内容的平均值。对于离散的1D信号，卷积是相同的，除了代替计算任意线性组合的平均值，即将每个元素乘以相应的系数并将结果相加。那些系数，一个用于窗口中的每个位置，有时称为卷积核。现在，N值的算术平均值是(x_1 + x_2 + ... + x_N) / N，所以相应的内核是(1/N, 1/N, ..., 1/N)，这正是我们通过使用得到的np.ones((N,))/N。

 

对上述代码做一个逐句理解：

import numpy as np //引入numpy模块

def Move_average(list, n)://开始定义Move_average函数，参数为list和n

    list = np.convolve(lis, np.ones(n) / n, mode='valid')

    print("移动平均: ", list)

return list //参数list就是我们得到的移动平均值

以我得到的运行截图为例：

 

因为这个代码中设置的n=3,即每次移动间隔均为n=3,

(8+8+77)÷3=31

(8+77+78)÷3=54.3333333

(77+78+81)÷3=78.6666667

以此类推。可以得到list中的全部数组。

 

def Std(list):

    std = np.std(list)

    print("标准差:", std)//计算得到的移动平均值list数组的标准差

 

def Smoothing_factor(list1, list2, n, nums):

//定义Smoothing_factor函数，参数为list1, list2, n, nums

//虽然没看懂这个函数的定义，但是这坨代码的意思就是，计算出平滑系数a,b(我没查到平滑系数的定义)，并且根据平滑系数得到下一期的预测值。

//后面调用了Smoothing_factor(lis, lis2, n, nums)，也就是说，原始数据列表lis是list1,后面又来了个lis2 = Move_average(lis, n)，也就是说，lis2是原始数据列表lis经过移动平均函数Move_average后，得到的存储移动平均值的列表。

 

    T=1.0

    a = 2*list1[-1]-list2[-1]

    b = 2/(n-1)*list1[-1]-list2[-1]

    print("平滑系数a，b分别为: ", a, b)

    X = a+b*T

    print("第%d期的预测值为:" %(nums+1), X)

 

if __name__ == '__main__':

 

    nums = 8 //原始数据的个数

    n = 3 //移动间隔

    lis = [] //原始列表lis

    lis2 = [] //存储移动平均值的列表

    for i in range(0, nums):

        lis.append(np.random.randint(100))

//函数numpy.random.randint(low, high=None, size=None, dtype='l')

函数的作用是，返回一个随机整型数，范围从低（包括）到高（不包括），即[low, high)。

 

lis.sort()

// sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。具体解释见：https://www.runoob.com/python/att-list-sort.html

//排序很重要，要不然会乱

 

    print("原始列表为: ", lis)

    lis = Move_average(lis, n)//对原始列表lis做移动平均，并将得到的做完一次移动平均的数组重新赋值给lis

    Std(lis)//计算得到的移动平均值数组的标准差

    lis2 = Move_average(lis, n)//把原始列表lis做第一次移动平均得到的数组再做第二次移动平均，并存储到lis2，以供后续计算平滑系数

Smoothing_factor(lis, lis2, n, nums)

 

  

我标红框框那个实际上是第二次移动平均的值

（31+54.3333333+78.6666667）÷3=54.66666667

(54.3333333+78.6666667+80.66666667)÷3=71.22222222

其他类推

 

1. 一篇讲移动平均讲的很好的文章（有代码）

https://blog.csdn.net/tz_zs/article/details/78341306

    

1. 开会以后学姐们建议看一些整体的代码（可参考股票之类的），关于我负责的部分（简单平均、指数平滑、移动平均），我准备下一步工作就是去看在一个整体流程中涉及的这些部分。

 

在Github&CSDN上面其实并没有很多关于简单平均的例子，（也是因为一般分析一些实际例子不太会单纯用简单算术平均）