├── ARIMA ├── ARIMA.py ├── Demo.ipynb └── README.md ├── BaiduImageDownload ├── Demo.ipynb ├── Download.py ├── README.md └── example.png ├── Demo.ipynb ├── GM11 ├── Demo.ipynb ├── GM11.py └── README.md ├── MoranI ├── Demo.ipynb ├── MoranI.py ├── README.md └── 莫兰散点图.png └── README.md /ARIMA/ARIMA.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import os 3 | import pandas as pd 4 | import numpy as np 5 | import statsmodels.api as sm 6 | from statsmodels.graphics.tsaplots import plot_acf, plot_pacf 7 | from statsmodels.tsa.stattools import adfuller 8 | from statsmodels.tsa import arima_model 9 | from statsmodels.stats.diagnostic import acorr_ljungbox 10 | import warnings 11 | warnings.filterwarnings("ignore") 12 | 13 | 14 | def ARIMA(series,n): 15 | ''' 16 | 只讨论一阶差分的ARIMA模型，预测，数字索引从1开始 17 | series:时间序列 18 | n:需要往后预测的个数 19 | ''' 20 | series = np.array(series) 21 | series = pd.Series(series.reshape(-1)) 22 | currentDir = os.getcwd()#当前工作路径 23 | #一阶差分数据 24 | fd = series.diff(1)[1:] 25 | plot_acf(fd).savefig(currentDir+'/一阶差分自相关图.png') 26 | plot_pacf(fd).savefig(currentDir+'/一阶差分偏自相关图.png') 27 | #一阶差分单位根检验 28 | unitP = adfuller(fd)[1] 29 | if unitP>0.05: 30 | unitAssess = '单位根检验中p值为%.2f，大于0.05，认为该一阶差分序列判断为非平稳序列'%(unitP) 31 | #print('单位根检验中p值为%.2f，大于0.05，认为该一阶差分序列判断为非平稳序列'%(unitP)) 32 | else: 33 | unitAssess = '单位根检验中p值为%.2f，小于0.05，认为该一阶差分序列判断为平稳序列'%(unitP) 34 | #print('单位根检验中p值为%.2f，小于0.05，认为该一阶差分序列判断为平稳序列'%(unitP)) 35 | #白噪声检验 36 | noiseP = acorr_ljungbox(fd, lags=1)[-1] 37 | if noiseP<=0.05: 38 | noiseAssess = '白噪声检验中p值为%.2f，小于0.05，认为该一阶差分序列为非白噪声'%noiseP 39 | #print('白噪声检验中p值为%.2f，小于0.05，认为该一阶差分序列为非白噪声'%noiseP) 40 | else: 41 | noiseAssess = '白噪声检验中%.2f，大于0.05，认为该一阶差分序列为白噪声'%noiseP 42 | #print('白噪声检验中%.2f，大于0.05，认为该一阶差分序列为白噪声'%noiseP) 43 | #BIC准则确定p、q值 44 | pMax = int(series.shape[0]/10)# 一般阶数不超过length/10 45 | qMax = pMax# 一般阶数不超过length/10 46 | bics = list() 47 | for p in range(pMax + 1): 48 | tmp = list() 49 | for q in range(qMax + 1): 50 | try: 51 | tmp.append(arima_model.ARIMA(series, (p, 1, q)).fit().bic) 52 | except Exception as e: 53 | #print(str(e)) 54 | tmp.append(1e+10)#加入一个很大的数 55 | bics.append(tmp) 56 | bics = pd.DataFrame(bics) 57 | p, q = bics.stack().idxmin() 58 | #print('BIC准则下确定p,q为%s,%s'%(p,q)) 59 | #建模 60 | model = arima_model.ARIMA(series,order=(p, 1, q)).fit() 61 | predict = model.forecast(n)[0] 62 | return { 63 | 'model':{'value':model,'desc':'模型'}, 64 | 'unitP':{'value':unitP,'desc':unitAssess}, 65 | 'noiseP':{'value':noiseP[0],'desc':noiseAssess}, 66 | 'p':{'value':p,'desc':'AR模型阶数'}, 67 | 'q':{'value':q,'desc':'MA模型阶数'}, 68 | 'params':{'value':model.params,'desc':'模型系数'}, 69 | 'predict':{'value':predict,'desc':'往后预测%d个的序列'%(n)} 70 | } 71 | 72 | if __name__ == "__main__": 73 | data = data = np.array([1.2,2.2,3.1,4.5,5.6,6.7,7.1,8.2,9.6,10.6,11,12.4,13.5,14.7,15.2]) 74 | x = data[0:10]#输入数据 75 | y = data[10:]#需要预测的数据 76 | result = ARIMA(x,len(y))#预测结果,一阶差分偏自相关图,一阶差分自相关图 77 | predict = result['predict']['value'] 78 | predict = np.round(predict,1) 79 | print('真实值:',y) 80 | print('预测值:',predict) 81 | print(result) 82 | 83 | -------------------------------------------------------------------------------- /ARIMA/Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### 准备数据" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 2, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "data = np.array([1.2,2.2,3.1,4.5,5.6,6.7,7.1,8.2,9.6,10.6,11,12.4,13.5,14.7,15.2])#总数据\n", 18 | "x = data[0:10]#输入数据\n", 19 | "y = data[10:]#需要预测的数据" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "### 进行预测" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 3, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "真实值: [11. 12.4 13.5 14.7 15.2]\n", 39 | "预测值: [11.6 12.6 13.6 14.7 15.7]\n", 40 | "{'model': {'value': , 'desc': '模型'}, 'unitP': {'value': nan, 'desc': '单位根检验中p值为nan，小于0.05，认为该一阶差分序列判断为平稳序列'}, 'noiseP': {'value': 0.6529831163341508, 'desc': '白噪声检验中0.65，大于0.05，认为该一阶差分序列为白噪声'}, 'p': {'value': 0, 'desc': 'AR模型阶数'}, 'q': {'value': 1, 'desc': 'MA模型阶数'}, 'params': {'value': const 1.035152\n", 41 | "ma.L1.D.y -1.000000\n", 42 | "dtype: float64, 'desc': '模型系数'}, 'predict': {'value': array([11.56646462, 12.60161613, 13.63676764, 14.67191915, 15.70707066]), 'desc': '往后预测5个的序列'}}\n" 43 | ] 44 | }, 45 | { 46 | "data": { 47 | "image/png": "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\n", 48 | "text/plain": [ 49 | "
" 50 | ] 51 | }, 52 | "metadata": {}, 53 | "output_type": "display_data" 54 | }, 55 | { 56 | "data": { 57 | "image/png": "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\n", 58 | "text/plain": [ 59 | "
" 60 | ] 61 | }, 62 | "metadata": {}, 63 | "output_type": "display_data" 64 | } 65 | ], 66 | "source": [ 67 | "from ARIMA import ARIMA\n", 68 | "result = ARIMA(x,len(y))#预测结果,一阶差分偏自相关图,一阶差分自相关图\n", 69 | "predict = result['predict']['value']\n", 70 | "predict = np.round(predict,1)\n", 71 | "print('真实值:',y)\n", 72 | "print('预测值:',predict)\n", 73 | "print(result)" 74 | ] 75 | } 76 | ], 77 | "metadata": { 78 | "kernelspec": { 79 | "display_name": "Python 3", 80 | "language": "python", 81 | "name": "python3" 82 | }, 83 | "language_info": { 84 | "codemirror_mode": { 85 | "name": "ipython", 86 | "version": 3 87 | }, 88 | "file_extension": ".py", 89 | "mimetype": "text/x-python", 90 | "name": "python", 91 | "nbconvert_exporter": "python", 92 | "pygments_lexer": "ipython3", 93 | "version": "3.6.5" 94 | } 95 | }, 96 | "nbformat": 4, 97 | "nbformat_minor": 2 98 | } 99 | -------------------------------------------------------------------------------- /ARIMA/README.md: -------------------------------------------------------------------------------- 1 | # 描述 2 | 实现ARIMA模型，进行统计验证 3 | # 函数接口 4 | 输入：原始序列，预测个数 5 | 输出：预测结果，包括预测序列、白噪声检验、单根检验、一阶差分自相关图、一阶差分偏自相关图 6 | -------------------------------------------------------------------------------- /BaiduImageDownload/Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### 设置参数，不需要重定尺寸的话resize可不填" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "from Download import download\n", 17 | "keyWord = \"电子琴\"#关键词\n", 18 | "imgNumber = 10#数量\n", 19 | "resize = (64,64)#重定尺寸，若不填则维持原尺寸" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "### 调用函数下载图片，图片文件夹保存在Download.py同级目录，图片名是md5组成，所以不会有重复" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "key:电子琴 goal:10 finish:1\n", 39 | "key:电子琴 goal:10 finish:2\n", 40 | "key:电子琴 goal:10 finish:3\n", 41 | "key:电子琴 goal:10 finish:4\n", 42 | "key:电子琴 goal:10 finish:5\n", 43 | "key:电子琴 goal:10 finish:6\n", 44 | "key:电子琴 goal:10 finish:6\n", 45 | "key:电子琴 goal:10 finish:7\n", 46 | "key:电子琴 goal:10 finish:8\n", 47 | "key:电子琴 goal:10 finish:9\n", 48 | "key:电子琴 goal:10 finish:10\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "download(keyWord,imgNumber,resize)" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "### 结果展示 " 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 3, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "text/html": [ 71 | "" 72 | ], 73 | "text/plain": [ 74 | "" 75 | ] 76 | }, 77 | "metadata": {}, 78 | "output_type": "display_data" 79 | } 80 | ], 81 | "source": [ 82 | "%%html\n", 83 | "" 84 | ] 85 | } 86 | ], 87 | "metadata": { 88 | "kernelspec": { 89 | "display_name": "Python 3", 90 | "language": "python", 91 | "name": "python3" 92 | }, 93 | "language_info": { 94 | "codemirror_mode": { 95 | "name": "ipython", 96 | "version": 3 97 | }, 98 | "file_extension": ".py", 99 | "mimetype": "text/x-python", 100 | "name": "python", 101 | "nbconvert_exporter": "python", 102 | "pygments_lexer": "ipython3", 103 | "version": "3.6.5" 104 | } 105 | }, 106 | "nbformat": 4, 107 | "nbformat_minor": 2 108 | } 109 | -------------------------------------------------------------------------------- /BaiduImageDownload/Download.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import hashlib 3 | import requests 4 | import json 5 | import cv2 6 | import os 7 | 8 | #更改工作路径到当前 9 | curDir = os.path.dirname(os.path.abspath(__file__)) 10 | #os.chdir(curDir) 11 | 12 | def evalMd5(sentence,charset='utf8'): 13 | ''' 14 | 计算一段字符串的md5 15 | :param sentence: 字符串 16 | :param charset: 字符集 17 | :return: md5值 18 | ''' 19 | #将字符串编码成bytes 20 | if type(sentence) != bytes: 21 | sentence = sentence.encode(charset) 22 | md5 = hashlib.md5(sentence).hexdigest() 23 | return md5 24 | 25 | def resizeImg(oldPath,size,newPath): 26 | ''' 27 | 重定图片尺寸 28 | :param oldPath: 图片路径 29 | :param size: 重定大小 30 | :param newPath: 图片保存路径 31 | :return: None 32 | ''' 33 | oldPath = oldPath.replace('\\','/') 34 | newPath = newPath.replace('\\','/') 35 | oldImg = cv2.imdecode(np.fromfile(oldPath,dtype=np.uint8),-1) 36 | try: 37 | newImg = cv2.resize(oldImg,size,) #为图片重新指定尺寸 38 | cv2.imwrite(newPath,newImg) 39 | cv2.imencode('.'+newPath.split('.')[-1],newImg)[1].tofile(newPath) 40 | except: 41 | #图片格式不对发生错误，删除 42 | os.remove(oldPath) 43 | 44 | def download(keyWord,imgNumber,imgSize=None): 45 | ''' 46 | 下载图片到关键词文件夹 47 | :param keyWord: 关键词 48 | :param imgNumber: 图片数量 49 | :param imgSize: 图片重定大小 50 | :return: None 51 | ''' 52 | #创建关键词文件夹 53 | dirname = os.path.join(curDir,keyWord) 54 | if not os.path.exists(dirname): 55 | os.mkdir(dirname) 56 | #开始爬图片 57 | url = 'https://image.baidu.com/search/acjson'#图片网址 58 | same = 0#重复下载数 59 | error = 0#错误数 60 | passNum = 0#无链接数 61 | for i in range(30,30*10000+30,30): 62 | param = { 63 | 'tn': 'resultjson_com','ipn': 'rj', 64 | 'ct': 201326592, 65 | 'is': '', 66 | 'fp': 'result', 67 | 'queryWord': keyWord, 68 | 'cl': 2, 69 | 'lm': -1, 70 | 'ie': 'utf-8', 71 | 'oe': 'utf-8', 72 | 'adpicid': '', 73 | 'st': -1, 74 | 'z': '', 75 | 'ic': 0, 76 | 'word': keyWord, 77 | 's': '', 78 | 'se': '', 79 | 'tab': '', 80 | 'width': '', 81 | 'height': '', 82 | 'face': 0, 83 | 'istype': 2, 84 | 'qc': '', 85 | 'nc': 1, 86 | 'fr': '', 87 | 'pn': i, 88 | 'rn': 30, 89 | 'gsm': '1e', 90 | '1488942260214': '' 91 | } 92 | #所有图片地址列表 93 | data = requests.get(url,params=param).text.replace('\\','\\\\') 94 | try: 95 | data = json.loads(data)['data'] 96 | except: 97 | #json数据可能不合法,直接跳过 98 | error += 1 99 | if error >=20: 100 | return None 101 | continue 102 | 103 | for item in data: 104 | imgUrl = item.get("middleURL")#图片地址 105 | if passNum>=20: 106 | return None 107 | if imgUrl is None: 108 | passNum+=1 109 | continue 110 | suffix = imgUrl.split('.')[-1]#图片后缀 111 | imgContent = requests.get(imgUrl).content#图片内容 112 | imgMd5 = evalMd5(imgContent)#图片md5 113 | imgPath = os.path.join(dirname,'%s.%s'%(imgMd5,suffix))#图片路径 114 | oldFinish = len(os.listdir(dirname)) 115 | open(imgPath, 'wb').write(imgContent)#写入 116 | #重定尺寸 117 | if imgSize: 118 | resizeImg(imgPath,imgSize,imgPath) 119 | newFinish = len(os.listdir(dirname)) 120 | print('key:%s goal:%d finish:%d'%(keyWord,imgNumber,newFinish)) 121 | #图片数达标,退出 122 | if newFinish >= imgNumber: 123 | return None 124 | #重复下载图片达到100次，说明已经下载完所有图片，退出 125 | if newFinish == oldFinish: 126 | same+=1 127 | if same >= 20: 128 | return 129 | 130 | if __name__ == "__main__": 131 | for keyWord in ['机器人']: 132 | download(keyWord,imgNumber,imgSize) -------------------------------------------------------------------------------- /BaiduImageDownload/README.md: -------------------------------------------------------------------------------- 1 | # 描述 2 | 批量下载百度图片，可设置数量、关键词、重定图片大小，程序自动创建关键词文件夹将图片下载到文件夹中，图片名由MD5组成 3 | # 环境 4 | python3 5 | # 展示 6 | 关键词:电子琴 7 | 数量:10 8 | 重定大小:(64,64) 9 | ![Alt text](https://github.com/LiuChen-China/PythonFunctions/blob/master/BaiduImageDownload/example.png) 10 | -------------------------------------------------------------------------------- /BaiduImageDownload/example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LiuChen-China/PythonFunctions/f1151bd23f89a9856bddc4cb05906383eeefe915/BaiduImageDownload/example.png -------------------------------------------------------------------------------- /Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### 这只是个占位文件" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "### 各Demo测试先进入到各项目文件夹可查看" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": {}, 21 | "outputs": [ 22 | { 23 | "name": "stdout", 24 | "output_type": "stream", 25 | "text": [ 26 | "我只是个占位文件呀，你为啥要进来看我~\n" 27 | ] 28 | } 29 | ], 30 | "source": [ 31 | "print('我只是个占位文件呀，你为啥要进来看我~')" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 2, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "name": "stdout", 41 | "output_type": "stream", 42 | "text": [ 43 | "看够了赶紧出去┭┮﹏┭┮\n" 44 | ] 45 | } 46 | ], 47 | "source": [ 48 | "print('看够了赶紧出去┭┮﹏┭┮')" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 5, 54 | "metadata": {}, 55 | "outputs": [ 56 | { 57 | "name": "stdout", 58 | "output_type": "stream", 59 | "text": [ 60 | "还看！！！逼我弄一个语法错误吓吓你~\n" 61 | ] 62 | } 63 | ], 64 | "source": [ 65 | "print('还看！！！逼我弄一个语法错误吓吓你~')" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 6, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "ename": "SyntaxError", 75 | "evalue": "invalid syntax (, line 1)", 76 | "output_type": "error", 77 | "traceback": [ 78 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m Fuck!!!\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" 79 | ] 80 | } 81 | ], 82 | "source": [ 83 | "Fuck!!!" 84 | ] 85 | } 86 | ], 87 | "metadata": { 88 | "kernelspec": { 89 | "display_name": "Python 3", 90 | "language": "python", 91 | "name": "python3" 92 | }, 93 | "language_info": { 94 | "codemirror_mode": { 95 | "name": "ipython", 96 | "version": 3 97 | }, 98 | "file_extension": ".py", 99 | "mimetype": "text/x-python", 100 | "name": "python", 101 | "nbconvert_exporter": "python", 102 | "pygments_lexer": "ipython3", 103 | "version": "3.6.5" 104 | } 105 | }, 106 | "nbformat": 4, 107 | "nbformat_minor": 2 108 | } 109 | -------------------------------------------------------------------------------- /GM11/Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### 准备数据" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 3, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "import numpy as np\n", 17 | "data = np.array([1.2,2.2,3.1,4.5,5.6,6.7,7.1,8.2,9.6,10.6,11,12.4,13.5,14.7,15.2])#总数据\n", 18 | "x = data[0:10]#输入数据\n", 19 | "y = data[10:]#需要预测的数据" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "### 进行预测" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 4, 32 | "metadata": {}, 33 | "outputs": [ 34 | { 35 | "name": "stdout", 36 | "output_type": "stream", 37 | "text": [ 38 | "真实值: [11. 12.4 13.5 14.7 15.2]\n", 39 | "预测值: [13.1 15.4 17.9 21. 24.5]\n", 40 | "{'a': {'value': -0.15593384339023364, 'desc': '发展系数'}, 'b': {'value': 2.7961956194257107, 'desc': '灰色作用量'}, 'predict': {'value': array([13.13683292, 15.35365877, 17.94457149, 20.97269783, 24.5118171 ]), 'desc': '往后预测5个的序列'}, 'C': {'value': 0.04855650314239575, 'desc': '后验差比<=0.35，模型精度等级为好'}}\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "from GM11 import GM11\n", 46 | "result = GM11(x,len(y))#预测结果,一阶差分偏自相关图,一阶差分自相关图\n", 47 | "predict = result['predict']['value']\n", 48 | "predict = np.round(predict,1)\n", 49 | "print('真实值:',y)\n", 50 | "print('预测值:',predict)\n", 51 | "print(result)" 52 | ] 53 | } 54 | ], 55 | "metadata": { 56 | "kernelspec": { 57 | "display_name": "Python 3", 58 | "language": "python", 59 | "name": "python3" 60 | }, 61 | "language_info": { 62 | "codemirror_mode": { 63 | "name": "ipython", 64 | "version": 3 65 | }, 66 | "file_extension": ".py", 67 | "mimetype": "text/x-python", 68 | "name": "python", 69 | "nbconvert_exporter": "python", 70 | "pygments_lexer": "ipython3", 71 | "version": "3.6.5" 72 | } 73 | }, 74 | "nbformat": 4, 75 | "nbformat_minor": 2 76 | } 77 | -------------------------------------------------------------------------------- /GM11/GM11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import matplotlib.pyplot as plt 3 | import pandas as pd 4 | import numpy as np 5 | 6 | def GM11(x,n): 7 | ''' 8 | 灰色预测 9 | x：序列，numpy对象 10 | n:需要往后预测的个数 11 | ''' 12 | x1 = x.cumsum()#一次累加 13 | z1 = (x1[:len(x1) - 1] + x1[1:])/2.0#紧邻均值 14 | z1 = z1.reshape((len(z1),1)) 15 | B = np.append(-z1,np.ones_like(z1),axis=1) 16 | Y = x[1:].reshape((len(x) - 1,1)) 17 | #a为发展系数 b为灰色作用量 18 | [[a],[b]] = np.dot(np.dot(np.linalg.inv(np.dot(B.T, B)), B.T), Y)#计算参数 19 | result = (x[0]-b/a)*np.exp(-a*(n-1))-(x[0]-b/a)*np.exp(-a*(n-2)) 20 | S1_2 = x.var()#原序列方差 21 | e = list()#残差序列 22 | for index in range(1,x.shape[0]+1): 23 | predict = (x[0]-b/a)*np.exp(-a*(index-1))-(x[0]-b/a)*np.exp(-a*(index-2)) 24 | e.append(x[index-1]-predict) 25 | S2_2 = np.array(e).var()#残差方差 26 | C = S2_2/S1_2#后验差比 27 | if C<=0.35: 28 | assess = '后验差比<=0.35，模型精度等级为好' 29 | elif C<=0.5: 30 | assess = '后验差比<=0.5，模型精度等级为合格' 31 | elif C<=0.65: 32 | assess = '后验差比<=0.65，模型精度等级为勉强' 33 | else: 34 | assess = '后验差比>0.65，模型精度等级为不合格' 35 | #预测数据 36 | predict = list() 37 | for index in range(x.shape[0]+1,x.shape[0]+n+1): 38 | predict.append((x[0]-b/a)*np.exp(-a*(index-1))-(x[0]-b/a)*np.exp(-a*(index-2))) 39 | predict = np.array(predict) 40 | return { 41 | 'a':{'value':a,'desc':'发展系数'}, 42 | 'b':{'value':b,'desc':'灰色作用量'}, 43 | 'predict':{'value':result,'desc':'第%d个预测值'%n}, 44 | 'C':{'value':C,'desc':assess}, 45 | 'predict':{'value':predict,'desc':'往后预测%d个的序列'%(n)}, 46 | } 47 | 48 | if __name__ == "__main__": 49 | data = np.array([1.2,2.2,3.1,4.5,5.6,6.7,7.1,8.2,9.6,10.6,11,12.4,13.5,14.7,15.2]) 50 | x = data[0:10]#输入数据 51 | y = data[10:]#需要预测的数据 52 | result = GM11(x,len(y)) 53 | predict = result['predict']['value'] 54 | predict = np.round(predict,1) 55 | print('真实值:',y) 56 | print('预测值:',predict) 57 | print(result) 58 | -------------------------------------------------------------------------------- /GM11/README.md: -------------------------------------------------------------------------------- 1 | # 描述 2 | 实现灰色预测，计算后验差比 3 | # 函数接口 4 | 输入：原始序列、预测个数 5 | 输出：预测序列、后验差比、模型描述 6 | -------------------------------------------------------------------------------- /MoranI/Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## 导入moranI模块" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "from MoranI import moranI\n", 17 | "import numpy as np" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## 测试" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 2, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "name": "stdout", 34 | "output_type": "stream", 35 | "text": [ 36 | "{'I': {'value': 0.4583333333333333, 'desc': '全局moran指数'}, 'ZI_N': {'value': 2.5944877065862784, 'desc': '正太分布假设下检验数'}, 'ZI_R': {'value': 2.2860533202446978, 'desc': '随机分布假设下检验数'}, 'Ii': {'value': array([0.41666667, 0.24305556, 0.24305556, 0.97222222, 0.41666667]), 'desc': '局部moran指数'}, 'ZIi': {'value': array([-0.15523011, -0.80202221, -0.80202221, 1.91450463, -0.15523011]), 'desc': '局部检验数'}, 'img': {'path': 'D:\\\\桌面\\\\PythonFunctions\\\\MoranI\\\\莫兰散点图.png', 'desc': '莫兰散点图路径'}}\n" 37 | ] 38 | }, 39 | { 40 | "data": { 41 | "image/png": "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\n", 42 | "text/plain": [ 43 | "
" 44 | ] 45 | }, 46 | "metadata": {}, 47 | "output_type": "display_data" 48 | } 49 | ], 50 | "source": [ 51 | "#权重矩阵,函数会在内部进行标准化\n", 52 | "w = [\n", 53 | " [0,1,1,0,0],\n", 54 | " [1,0,1,1,0],\n", 55 | " [1,1,0,1,0],\n", 56 | " [0,1,1,0,1],\n", 57 | " [0,0,0,1,0]\n", 58 | " ]\n", 59 | "w = np.array(w)\n", 60 | "#观测值矩阵\n", 61 | "x = [[8,6,6,3,2]]\n", 62 | "x = np.array(x)\n", 63 | "print(moranI(w,x))" 64 | ] 65 | } 66 | ], 67 | "metadata": { 68 | "kernelspec": { 69 | "display_name": "Python 3", 70 | "language": "python", 71 | "name": "python3" 72 | }, 73 | "language_info": { 74 | "codemirror_mode": { 75 | "name": "ipython", 76 | "version": 3 77 | }, 78 | "file_extension": ".py", 79 | "mimetype": "text/x-python", 80 | "name": "python", 81 | "nbconvert_exporter": "python", 82 | "pygments_lexer": "ipython3", 83 | "version": "3.6.5" 84 | } 85 | }, 86 | "nbformat": 4, 87 | "nbformat_minor": 2 88 | } 89 | -------------------------------------------------------------------------------- /MoranI/MoranI.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import matplotlib.pyplot as plt 3 | import numpy as np 4 | import os 5 | 6 | def moranI(W,X): 7 | ''' 8 | W:空间权重矩阵 9 | X:观测值矩阵 10 | 归一化空间权重矩阵后进行moran检验，实例https://bbs.pinggu.org/thread-3568074-1-1.html 11 | ''' 12 | W = np.array(W) 13 | X = np.array(X) 14 | X = X.reshape(1,-1) 15 | W = W/W.sum(axis=1)#归一化 16 | n = W.shape[0]#空间单元数 17 | Z = X - X.mean()#离差阵 18 | S0 = W.sum() 19 | S1 = 0 20 | for i in range(n): 21 | for j in range(n): 22 | S1 += 0.5*(W[i,j]+W[j,i])**2 23 | S2 = 0 24 | for i in range(n): 25 | S2 += (W[i,:].sum()+W[:,i].sum())**2 26 | #全局moran指数 27 | I = np.dot(Z,W) 28 | I = np.dot(I,Z.T) 29 | I = n/S0*I/np.dot(Z,Z.T) 30 | #在正太分布假设下的检验数 31 | EI_N = -1/(n-1) 32 | VARI_N = (n**2*S1-n*S2+3*S0**2)/(S0**2*(n**2-1))-EI_N**2 33 | ZI_N = (I-EI_N)/(VARI_N**0.5) 34 | #在随机分布假设下检验数 35 | EI_R = -1/(n-1) 36 | b2 = 0 37 | for i in range(n): 38 | b2 += n*Z[0,i]**4 39 | b2 = b2/((Z*Z).sum()**2) 40 | VARI_R = n*((n**2-3*n+3)*S1-n*S2+3*S0**2)-b2*((n**2-n)*S1-2*n*S2+6*S0**2) 41 | VARI_R = VARI_R/(S0**2*(n-1)*(n-2)*(n-3))-EI_R**2 42 | ZI_R = (I-EI_R)/(VARI_R**0.5) 43 | #计算局部moran指数 44 | Ii = list() 45 | for i in range(n): 46 | Ii_ = n*Z[0,i] 47 | Ii__ = 0 48 | for j in range(n): 49 | Ii__ += W[i,j]*Z[0,j] 50 | Ii_ = Ii_*Ii__/((Z*Z).sum()) 51 | Ii.append(Ii_) 52 | Ii = np.array(Ii) 53 | #局部检验数 54 | ZIi = list() 55 | EIi = Ii.mean() 56 | VARIi = Ii.var() 57 | for i in range(n): 58 | ZIi_ = (Ii[i]-EIi)/(VARIi**0.5) 59 | ZIi.append(ZIi_) 60 | ZIi = np.array(ZIi) 61 | #moran散点图 62 | #用来正常显示中文标签 63 | plt.rcParams['font.sans-serif']=['SimHei'] 64 | #用来正常显示负号 65 | plt.rcParams['axes.unicode_minus']=False 66 | fig = plt.figure() 67 | ax = fig.add_subplot(1,1,1) 68 | ax.spines['top'].set_color('none') 69 | ax.spines['right'].set_color('none') 70 | ax.xaxis.set_ticks_position('bottom') 71 | ax.spines['bottom'].set_position(('data', 0)) 72 | ax.yaxis.set_ticks_position('left') 73 | ax.spines['left'].set_position(('data', 0)) 74 | WZ = np.dot(Z,W) 75 | ax.scatter(Z,WZ,c='k') 76 | x1 = range(int(Z.min()),int(Z.max()+1)) 77 | y1 = range(int(Z.min()),int(Z.max()+1)) 78 | ax.plot(x1,y1,'k--',label='x=y') 79 | x2 = list(range(int(Z.min()),int(Z.max()+1))) 80 | y2 = np.array(x2)*I[0][0] 81 | ax.plot(x2,y2,'k-',label='I*x=y') 82 | ax.legend(loc='upper right') 83 | imgPath = os.path.join(os.getcwd(),'莫兰散点图.png') 84 | #ax.set_title('莫兰散点图') 85 | fig.savefig(imgPath) 86 | return { 87 | 'I':{'value':I[0,0],'desc':'全局moran指数'}, 88 | 'ZI_N':{'value':ZI_N[0,0],'desc':'正太分布假设下检验数'}, 89 | 'ZI_R':{'value':ZI_R[0,0],'desc':'随机分布假设下检验数'}, 90 | 'Ii':{'value':Ii,'desc':'局部moran指数'}, 91 | 'ZIi':{'value':ZIi,'desc':'局部检验数'}, 92 | 'img':{'path':imgPath,'desc':'莫兰散点图路径'} 93 | } 94 | 95 | 96 | if __name__ == "__main__": 97 | w = [ 98 | [0,1,1,0,0], 99 | [1,0,1,1,0], 100 | [1,1,0,1,0], 101 | [0,1,1,0,1], 102 | [0,0,0,1,0] 103 | ] 104 | w = np.array(w) 105 | x = [ 106 | [8,6,6,3,2] 107 | ] 108 | x = np.array(x) 109 | print(moranI(w,x)) -------------------------------------------------------------------------------- /MoranI/README.md: -------------------------------------------------------------------------------- 1 | # 描述 2 | 计算moran's I指数(莫兰指数)，接口函数是MoranI.py中的moranI函数，输入为W(空间权重矩阵) X(观测值矩阵)，输出为全局moran's I指数，局部指数，莫兰散点图，全局检验数，局部检验数 3 | # 环境 4 | python3 5 | # 莫兰散点图 6 | ![Alt text](https://github.com/LiuChen-China/PythonFunctions/blob/master/MoranI/%E8%8E%AB%E5%85%B0%E6%95%A3%E7%82%B9%E5%9B%BE.png) 7 | -------------------------------------------------------------------------------- /MoranI/莫兰散点图.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/LiuChen-China/PythonFunctions/f1151bd23f89a9856bddc4cb05906383eeefe915/MoranI/莫兰散点图.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # PythonFunction 2 | 一些常用的Python功能型接口 3 | # 功能列表 4 | + 批量下载百度图片，可选重定图片尺寸 5 | + 空间统计-计算moran指数(莫兰指数) 6 | + ARIMA模型 7 | + 灰色预测(GM11) 8 | --------------------------------------------------------------------------------