精华内容
下载资源
问答
  • 人工智能指纹识别程序和原理图 #include<reg52.h> #include<intrins.h> #defineucharunsignedchar #defineuintunsignedint #defineDbusP0 #definebuffer1ID0x01 #definebuffer2ID0x02 #definequeren0x88 #...
  • 本章将会教你如何编写、保存与运行 Python 程序。通过 Python 来运行的你的程序有两种方法——使用交互式解释器提示符或直接运行一个源代码文件。我们将了解如何使用他们二者的功能。使用解释器提示符在你的操作系统...

    be2bc4fa7570fd2a4787466bca4d2bf7.png

    接下来我们将看见如何在 Python 中运行一个传统的“Hello World”程序。

    本章将会教你如何编写、保存与运行 Python 程序。

    通过 Python 来运行的你的程序有两种方法——使用交互式解释器提示符或直接运行一个源代码文件。我们将了解如何使用他们二者的功能。

    使用解释器提示符

    在你的操作系统中打开终端(Terminal)程序(正如我们先前在 安装 章节所讨论过的那样)然后通过输入 python3 并按下 [enter] 键来打开 Python 提示符(Python Prompt)。

    当你启动 Python 后,你会看见在你能开始输入内容的地方出现了 >>> 。这个被称作 Python 解释器提示符(Python Interpreter Prompt)

    在 Python 解释器提示符,输入:

    print("Hello World")

    在输入完成后按下 [enter] 键。你将会看到屏幕上打印出 Hello World 字样。

    下面是一个在 Mac OS X 电脑上你能够看见的结果的示例。有关 Python 软件的细节将会因为你使用的电脑而有所不同,但是从提示符(如 >>> )开始部分应该是相同的,而不会受到操作系统的影响。

    > python3
    Python 3.5.1 (default, Jan 14 2016, 06:54:11)
    [GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> print("Hello World")
    Hello World

    你自然会注意到,Python 会立即给你输出了一行结果!你刚才所输入的便是一句独立的 Python 语句 。我们使用 print (不必太过惊讶)命令来打印你所提供的信息。在这里,我们提供了文本 Hello World ,然后它便被迅速地打印到了屏幕上。

    如何退出解释器提示符

    如果你正在使用一款 GNU/Linux 或 OS X 上的 Shell 程序,你可以通过按下 [ctrl + d] 组合键或是输入 exit() (注意:要记住要包含括号 ())并敲下 [enter] 来退出解释器提示符。

    如果你使用的是 Windows 命令提示符,可以按下 [ctrl + z] 组合键并敲击 [enter] 键来退出。

    选择一款编辑器

    要想创建我们的 Python 源代码文件,我们需要一款能够让你输入并保存代码的编辑器软件。

    如果你正在使用 Windows 系统,不要用记事本——这是一个很糟糕的选择,因为它没有语法加亮功能,同样重要的另一个原因是,它不支持文本缩进功能,这一功能我们之后将会了解它究竟有多重要。而一款好的编辑器能够自动帮你完成这一工作。

    如果你已是一名经验丰富的程序员,那你一定在用 Vim 或 Emacs 了。无需多言,它们都是最强大的编辑器之一,用它们来编写你的 Python 程序自是受益颇多。

    PyCharm

    PyCharm是一款能够对你编写 Python 程序的工作有所帮助的免费编辑器。

    当你打开 PyCharm 时,你会看见如下界面,点击 Create New Project

    32774a78475b5620829d77e5805802d8.png

    选择 Pure Python

    0d1e2896202e6c12d210924604d70182.png

    将你的项目路径位置中的 untitled 更改为 helloworld ,你所看到的界面细节应该类似于下方这番:

    c45c7b915b6f52fa0239773859325b86.png

    点击 Create 按钮。

    对侧边栏中的 helloworld 右击选中,并选择 New -> Python File

    3a13ca2e17ec7ce907e79e20db4689bc.png

    你会被要求输入名字,现在输入 hello

    78898762099ea195cdf4eacfa982c766.png

    现在你便可以看见一个新的文件已为你开启:

    387d1a01310b48b29cf5390a6b036748.png

    删除那些已存在的内容,现在由你自己输入以下代码:

    print("hello world")

    现在右击你所输入的内容(无需选中文本),然后点击 Run 'hello'

    0083173a5fdd417a20db6fc22fd5cdd2.png

    此刻你将会看到你的程序所输出的内容(它所打印出来的内容):

    6466ac11b86b6b8cd42c4a387eeedee6.png

    虽然只是刚开始的几个步骤,但从今以后,每当我们要求你创建一个新的文件时,记住只需在 helloworld 上右击并选择 -> New -> Python File 并继续如上所述步骤一般输入内容并运行即可。

    如果你正在使用 PyCharm,我们已经讨论过如何从源文件中运行它了。

    对于其它编辑器,打开一个新文件名将其命名为 hello.py ,然后输入如下内容:

    +

    print("hello world")

    你应当将文件保存到哪里?保存到任何你知道其位置与路径的文件夹。如果你不了解这句话是什么意思,那就创建一个新文件夹并用这一路径来保存并运行你所有的 Python 程序:

    • Mac OS X 上的 /tmp/py
    • GNU/Linux 上的 /tmp/py
    • Windows 上的 C:py

    要想创建上述文件夹(在你正在使用的操作系统上),你可以在终端上使用 mkdir 命令,如 mkdir /tmp/py

    重要提示:你需要经常确认并确保你为文件赋予了 .py 扩展名,例如 foo.py

    尝试 着 第一个 Python 源程序

    源码

    print("a") 
    print("b") 
    print("c") 

    将源代码保存到:d:/python_exec/mypy01.py

    在 IDLE 中单击 F5 或者 run-->run module 执行这个源程序。

    第一个 Python 程序中需要注意的小要点:

    1. 不要在程序中,行开头处增加空格。空格在 Python 中有缩进的含义。

    2. 符号都是英文符号,不是中文。比如:(,”

    程序基本格式

    1. 恰当的空格,缩进问题

    (1) 逻辑行首的空白(空格和制表符)用来决定逻辑行的缩进层次,从而用来决定语句

    的分组。

    (2) 语句从新行的第一列开始。

    (3) 缩进风格统一:

    • 每个缩进层次使用 单个制表符 或四个空格(IDE 会自动将制表符设置成 4 个空格)
    • Python 用缩进而不是{}表示程序块

    2. Python 区分大小写

    3. 注释

    (1) 行注释

    每行注释前加#号。当解释器看到#,则忽略这一行#后面的内容

    (2) 段注释

    使用三个连续单引号(''')。当解释看到''',则会扫描到下一个''',然后忽略他们之间的内容。

    开始学习图形化程序设计

    为了让初学者更加容易接受编程,我们这里先从海龟画图开始讲解。这样,大家在不接触其他编程概念时,就能开始做出一些简单的效果。

    提高兴趣,寓教于乐。

    >>> import turtle #导入 turtle 模块

    >>> turtle.showturtle() #显示箭头

    >>> turtle.write("张三") #写字符串

    >>> turtle.forward(300) #前进 300 像素

    >>> turtle.color("red") #画笔颜色改为 red

    >>> turtle.left(90) #箭头左转 90 度

    >>> turtle.forward(300)

    >>> turtle.goto(0,50) #去坐标(0,50)

    >>> turtle.goto(0,0)

    >>> turtle.penup() #抬笔。这样,路径就不会画出来

    >>> turtle.goto(0,300)

    >>> turtle.pendown() #下笔。这样,路径就会画出来

    >>> turtle.circle(100) #画圆

    源码:

    import turtle 
    turtle.width(10) 
    turtle.color("blue") 
    turtle.circle(50) 
    turtle.color("black") 
    turtle.penup() 
    turtle.goto(120,0) 
    turtle.pendown() 
    turtle.circle(50) 
    turtle.color("red") 
    turtle.penup() 
    turtle.goto(240,0)
    turtle.pendown() 
    turtle.circle(50) 
    turtle.color("yellow") 
    turtle.penup() 
    turtle.goto(60,-50) 
    turtle.pendown() 
    turtle.circle(50) 
    turtle.color("green") 
    turtle.penup() 
    turtle.goto(180,-50) 
    turtle.pendown() 
    turtle.circle(50) 

    运行结果:

    205d56c51f1b3e01dcc72c587006164c.png
    展开全文
  • 今天Perfect正式公开了第一个TensorFlow Swift服务器的源代码,详细内容可以在本页链接下载:Perfect ...本源代码展示了如何在服务器端使用Perfect TensorFlow开发Swift 应用,并实现人工智能图像识别的网络服务。

    Get Involed with Perfect!

    Star Perfect On Github Join the Perfect Slack

    Swift 3.1 Swift 4.0 Platforms OS X | Linux License Apache PerfectlySoft Twitter Slack Status

    今天Perfect正式公开了第一个TensorFlow Swift服务器的源代码,详细内容可以在本页链接下载:

    Perfect TensorFlow 机器视觉演示程序github.com/PerfectExamples/Perfect-TensorFlow-Demo-Vision

    本源代码展示了如何在服务器端使用Perfect TensorFlow开发Swift 应用,并实现人工智能图像识别的网络服务。如果您还不熟悉Perfect软件框架,请首先尝试 Perfect 模板服务器

    本项目的主要目的是展示Perfect TensorFlow Swift的服务器端实现。

    Swift 兼容性说明

    本项目目前使用 Swift 3.1 或者 Swift 4.0 工具链编译,可以在macOS / Ubuntu上使用。

    编译运行

    运行以下命令可以运行本示例程序并在8080端口创建服务器:

    git clone https://github.com/PerfectExamples/Perfect-TensorFlow-Demo-Vision.git
    cd Perfect-TensorFlow-Demo-Vision
    ./install.sh
    ./.build/debug/PerfectTensorFlowDemo

    应该能够看到以下输出:

    [INFO] Starting HTTP server localhost on 0.0.0.0:8080

    意味着服务器已经准备好,请访问 http://localhost:8080/ 查看演示主页,您可以如下图所示上载一个本地图片考验计算机是否能够识别,或者甚至可以用鼠标手绘一个草图来测试计算机视觉识别能力。下面的例子是上载了一个信封✉️的照片,然后服务器识别返回给客户端,用英语问这是不是一个信封,并列出了可能是信封的概率::

    识别一个信封

    组合键control-c可以停止服务器运行。

    服务器API

    本项目的目标是制作这样的一个服务器,在调用根目录/recog函数API之后,客户端可以给服务器用POST表单发送一张图片,然后服务器对图像内容进行识别,识别完成之后返回给客户端一个json字符串,其中内容就是识别图像内容的结果;即如果图像内容是一个闹钟⏰,则回复字符串{“value”:”clock”}。

    识别一个手绘闹钟

    简介

    本样例代码使用了一个预先训练好的机器视觉模型(数学家万岁,搞人工神经网络的数学家万岁万岁万万岁!):
    (http://arxiv.org/abs/1512.00567).

    您可以将人工神经网络模型文件加载到一个Perfect TensorFlow Session对象,像这样:

    let g = try TF.Graph()
    let def = try TF.GraphDef(serializedData: model)
    try g.import(definition: def)

    连同模型一起下载的还有一个已知物体的名单(英文)文件:

    try fTag.open(.read)
    let lines = try fTag.readString()
    tags = lines.utf8.split(separator: 10).map { String(describing: $0) }
    // 字符串数组变量应该看起来像这样:
    // tags = ["dummy", "kit fox", "English setter", "Siberian husky" ...]

    一旦从客户端收到图片后,服务器会将图片内容正规化:

      public func constructAndExecuteGraphToNormalizeImage(_ g: TF.Graph, imageBytes: Data) throws -> TF.Tensor {
        let H:Int32 = 224
        let W:Int32 = 224
        let mean:Float = 117
        let scale:Float = 1
        let input = try g.constant(name: "input2", value: imageBytes)
        let batch = try g.constant( name: "make_batch", value: Int32(0))
        let scale_v = try g.constant(name: "scale", value: scale)
        let mean_v = try g.constant(name: "mean", value: mean)
        let size = try g.constantArray(name: "size", value: [H,W])
        let jpeg = try g.decodeJpeg(content: input, channels: 3)
        let cast = try g.cast(value: jpeg, dtype: TF.DataType.dtFloat)
        let images = try g.expandDims(input: cast, dim: batch)
        let resizes = try g.resizeBilinear(images: images, size: size)
        let subbed = try g.sub(x: resizes, y: mean_v)
        let output = try g.div(x: subbed, y: scale_v)
        let s = try g.runner().fetch(TF.Operation(output)).run()
        guard s.count > 0 else { throw TF.Panic.INVALID }
        return s[0]
      }//end normalize

    然后就可以跑一下TensorFlow的会话输出:

    let result = try g.runner().feed("input", tensor: image).fetch("output").run()

    结果是一个概率数组,其长度与名单吻合,用于预测名单中每一个对象可能的概率。因此只要找出数组中最大概率就可以获得图像被“识别”的结果:

    public func match(_ g: TF.Graph, image: Data) throws -> (Int, Int) {
        let normalized = try constructAndExecuteGraphToNormalizeImage(imageBytes: image)
        let possibilities = try executeInceptionGraph(image: normalized)
        guard let m = possibilities.max(), let i = possibilities.index(of: m) else {
          throw TF.Panic.INVALID
        }//end guard
        return (i, Int(m * 100))
      }

    最后一步就是把概率索引转换为对象名称,然后发给客户端:

    let tag = tags[result.0]
          let p = result.1
          response.setHeader(.contentType, value: "text/json")
            .appendBody(string: 
            "{\"value\": \"Is it a \(tag)? (Possibility: \(p)%)\"}")
            .completed()

    大功告成!就是这样简单!

    当然,如果您仍然觉得服务器配置和部署比较麻烦,那么请访问Perfect官网perfect.org,下载Perfect Assistant 2.0 ,即软件助手2.0版本,即可实现Swift函数库和预装人工智能服务器整体打包管理、编译、部署一条龙,目前支持亚马逊弹性计算和谷歌应用引擎,还将陆续增加更多服务器部署方案选择,这样您就可以随时改进自己的程序应用,逐步增加人工智能和神经网络、以及机器深度学习的新功能啦!

    展开全文
  • {"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,...社区覆盖了云计算、大数据、人工智能、IoT、云原生、数据库、微服务、安全、开发与运维9大技术领域。","link1":...

    {"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,"count":4}]},"card":[{"des":"阿里技术人对外发布原创技术内容的最大平台;社区覆盖了云计算、大数据、人工智能、IoT、云原生、数据库、微服务、安全、开发与运维9大技术领域。","link1":"https://developer.aliyun.com/group/?spm=a2c6h.12883283.1377930.25.7287201c9RKTCi&groupType=other","link":"https://developer.aliyun.com/","icon":"https://img.alicdn.com/tfs/TB1TlXBEkT2gK0jSZPcXXcKkpXa-200-200.png","btn2":"开发者藏经阁","tip":"打通开发者成长路径,学习中心 。全线阿里云技术大牛公开课,立即查看","btn1":"技术与产品技术圈","link2":"https://developer.aliyun.com/topic/ebook?spm=a2c6h.12883283.1362932.15.7287201c9RKTCi","title":"阿里云开发者社区"}],"search":[{"txt":"学习中心","link":"https://developer.aliyun.com/learning?spm=a2c6h.13788135.1364563.41.299f5f24exe3IS"},{"txt":"技能测试中心 ","link":"https://developer.aliyun.com/exam?spm=a2c6h.13716002.1364563.42.6cac18a3JWCM5U"},{"txt":"开发者云 ","link":"https://developer.aliyun.com/adc/?spm=a2c6h.13716002.1364563.59.6b0818a3DV0vzN"},{"txt":"在线编程 ","link":"https://developer.aliyun.com/coding?spm=5176.13257455.1364563.57.701e7facHvqi5r"},{"txt":"学习中心 ","link":"https://developer.aliyun.com/learning?spm=a2c6h.12883283.1364563.41.5f1f201c5CLDCC"},{"txt":"高校计划 ","link":"https://developer.aliyun.com/adc/college/?spm=a2c6h.13716002.1364563.58.6cac18a3JWCM5U"}],"countinfo":{"search":{"length_pc":0,"length":0},"card":{"length_pc":0,"length":0}}}

    {"$env":{"JSON":{}},"$page":{"env":"production"},"$context":{"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,"count":4}]},"card":[{"des":"阿里技术人对外发布原创技术内容的最大平台;社区覆盖了云计算、大数据、人工智能、IoT、云原生、数据库、微服务、安全、开发与运维9大技术领域。","link1":"https://developer.aliyun.com/group/?spm=a2c6h.12883283.1377930.25.7287201c9RKTCi&groupType=other","link":"https://developer.aliyun.com/","icon":"https://img.alicdn.com/tfs/TB1TlXBEkT2gK0jSZPcXXcKkpXa-200-200.png","btn2":"开发者藏经阁","tip":"打通开发者成长路径,学习中心 。全线阿里云技术大牛公开课,立即查看","btn1":"技术与产品技术圈","link2":"https://developer.aliyun.com/topic/ebook?spm=a2c6h.12883283.1362932.15.7287201c9RKTCi","title":"阿里云开发者社区"}],"search":[{"txt":"学习中心","link":"https://developer.aliyun.com/learning?spm=a2c6h.13788135.1364563.41.299f5f24exe3IS"},{"txt":"技能测试中心 ","link":"https://developer.aliyun.com/exam?spm=a2c6h.13716002.1364563.42.6cac18a3JWCM5U"},{"txt":"开发者云 ","link":"https://developer.aliyun.com/adc/?spm=a2c6h.13716002.1364563.59.6b0818a3DV0vzN"},{"txt":"在线编程 ","link":"https://developer.aliyun.com/coding?spm=5176.13257455.1364563.57.701e7facHvqi5r"},{"txt":"学习中心 ","link":"https://developer.aliyun.com/learning?spm=a2c6h.12883283.1364563.41.5f1f201c5CLDCC"},{"txt":"高校计划 ","link":"https://developer.aliyun.com/adc/college/?spm=a2c6h.13716002.1364563.58.6cac18a3JWCM5U"}],"countinfo":{"search":{"length_pc":0,"length":0},"card":{"length_pc":0,"length":0}}}}

    展开全文
  • 如何人工智能预测股票(完整答案)

    千次阅读 2020-05-19 13:22:31
    前言 十分钟实现人工智能股价预测,是一个深度学习的练习项目。其通过机器学习算法,根据过去几年与某只股票相关的K线走势、...在编写人工智能程序之前,我们需要分析人类是怎样决定如何投资的。 有过炒股经历的人会

    前言
    十分钟实现人工智能股价预测,是一个深度学习的练习项目。其通过机器学习算法,根据过去几年与某只股票相关的K线走势、公司相关报道的情感分析作为数据集,通过训练来得到可以预测股价的机器学习模型,并用该模型对股价进行预测。
    本项目使用几种不同的算法(线性回归、神经网络和随机森林)对股票进行预测,并对各自的效果进行比较。
    运行本项目需要Python编程的基础,理解本项目的代码则需要对机器学习的相关知识。

    自然人是如何投资股市的
    在编写人工智能的程序之前,我们需要分析人类是怎样决定如何投资的。
    有过炒股经历的人会更快地理解。投资股市的目的是盈利,因此在决定购买哪只股票之前我们会查阅与该公司相关的信息,搜索最近甚至之前与该公司有关的新闻,逛逛炒股方面的贴吧,看看微博上面与该公司有关的消息。如果这个公司的前景明朗(正面报道很多),那么投资该股票的回报率也许会高一些。

    此外,投资股市,还需要会看各种数据,如K线等。有时我们看到某只股票持续走低,并且有上涨的势头了,也许此时是最佳的购入时机,因为该股票有很大可能会触底反弹了。
    通过上述分析,我们明确了训练这样的一个机器学习模型需要哪些数据:
    1、股价数据
    2、对该股票(公司)的情感数据

    获取历史数据并简单处理
    数据对于机器学习十分重要。没有合适的数据,我们就无法训练机器学习模型,从而使其可以进行相应地预测。
    在该项目中,我们需要获取2部分的数据。1:股价数据,2:情感数据。对于处理股价数据,我们需要
    对于股价数据,需要使用Pandas进行分析。对于情感数据则使用NLTK(Natural Language Toolkit)来进行处理。

    关于Pandas的使用入门,我曾写过一篇教程:从零开始机器学习-8 五分钟学会Pandas

    首先,我们导入相应地Python包。

    import numpy as np
    import pandas as pd
    import unicodedata
    import matplotlib.pyplot as plt
    from datetime import datetime, timedelta

    from nltk.sentiment.vader import SentimentIntensityAnalyzer

    from treeinterpreter import treeinterpreter as ti
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.linear_model import LogisticRegression
    from sklearn.neural_network import MLPClassifier
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    然后再读取往年的股价的数据,对其处理并生成Pandas的DataFrame格式。

    df_stocks = pd.read_pickle(‘data/pickled_ten_year_filtered_data.pkl’)
    df_stocks[‘prices’] = df_stocks[‘adj close’].apply(np.int64)
    df_stocks = df_stocks[[‘prices’, ‘articles’]]
    df_stocks[‘articles’] = df_stocks[‘articles’].map(lambda x: x.lstrip(’.-’))
    1
    2
    3
    4
    注:此处的数据是已经序列化成为文件的Python对象。
    通过

    print(df_stocks)
    1
    来查看我们的df_stocks DataFrame对象。其输出如下:

            prices                                           articles
    

    2007-01-01 12469 What Sticks from '06. Somalia Orders Islamist…
    2007-01-02 12472 Heart Health: Vitamin Does Not Prevent Death …
    2007-01-03 12474 Google Answer to Filling Jobs Is an Algorithm…
    2007-01-04 12480 Helping Make the Shift From Combat to Commerc…
    2007-01-05 12398 Rise in Ethanol Raises Concerns About Corn as…
    2007-01-06 12406 A Status Quo Secretary General. Best Buy and …
    2007-01-07 12414 THE COMMON APPLICATION; Typo.com. Jumbo Bonus…
    … … …
    2016-12-31 19762 Terrorist Attack at Nightclub in Istanbul Kill…

    [3653 rows x 2 columns]

    Process finished with exit code 0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    可以看到,我们已经成功获取到了股票的股价以及相关的文章的内容,下一步我们开始对股票情感数据与股价数据联合起来进行分析处理。
    先将df_stocks中的price Series独立出来,成为一个单独的DataFrame对象。因为我们对股票数据进行分析,并且不想破坏原DataFrame。在独立出来Price之后,我们再添加几个新的Series,接下来就是使用NLTK对文章进行情感分析了。

    df = df_stocks[[‘prices’]].copy()

    df[“compound”] = ‘’#合成
    df[“neg”] = ‘’#负面
    df[“neu”] = ‘’#中立
    df[“pos”] = ‘’#积极
    1
    2
    3
    4
    5
    6
    我们使用NLTK的情感强度分析器对文章情感进行分析。并将情感的强度写入新独立出来的DataFrame df中。其中neg Series用来存放该新闻的负面指数,neu Series用来存放该新闻的中立指数,pos Series用来存放该新闻的正面(积极)指数,Compound用来存放该新闻的合成(将neg neu pos结合)指数。

    nltk.download(‘vader_lexicon’)
    sid = SentimentIntensityAnalyzer()
    for date, row in df_stocks.T.iteritems():
    try:
    sentence = unicodedata.normalize(‘NFKD’, df_stocks.loc[date, ‘articles’])
    ss = sid.polarity_scores(sentence)
    df.at[date, ‘compound’] = ss[‘compound’]
    df.at[date, ‘neg’] = ss[‘neg’]
    df.at[date, ‘neu’] = ss[‘neu’]
    df.at[date, ‘pos’] = ss[‘pos’]
    except TypeError:
    print(df_stocks.loc[date, ‘articles’])
    print(date)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    其输出如下:

    [nltk_data] Downloading package vader_lexicon to
    [nltk_data] C:…\nltk_data…
    [nltk_data] Package vader_lexicon is already up-to-date!
    prices compound neg neu pos
    2007-01-01 12469 -0.9814 0.159 0.749 0.093
    2007-01-02 12472 -0.8179 0.114 0.787 0.099
    2007-01-03 12474 -0.9993 0.198 0.737 0.065
    … … … … … …
    2016-12-28 19833 0.2869 0.128 0.763 0.108
    2016-12-29 19819 -0.9789 0.138 0.764 0.097
    2016-12-30 19762 -0.995 0.168 0.734 0.098
    2016-12-31 19762 -0.2869 0.173 0.665 0.161

    [3653 rows x 5 columns]

    Process finished with exit code 0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    得到上述输出之后,我们便成功地获得了历史文章的情感分析数据。

    划分数据集
    从上面的输出,我们可以看到开始时间是2007年1月1日,而结束时间是2016年12月31日。我们以8:2的比例来划分训练集与测试集。

    train_start_date = ‘2007-01-01’
    train_end_date = ‘2014-12-31’
    test_start_date = ‘2015-01-01’
    test_end_date = ‘2016-12-31’
    train = df.ix[train_start_date : train_end_date]
    test = df.ix[test_start_date:test_end_date]
    1
    2
    3
    4
    5
    6
    对df进行划分完成之后,再新建一个对每个时间点情感评分的List,并将训练集与测试集的数据加入其中。

    sentiment_score_list = []

    for date, row in train.T.iteritems():
    sentiment_score = np.asarray([df.loc[date, ‘neg’], df.loc[date, ‘pos’]])
    sentiment_score_list.append(sentiment_score)
    numpy_df_train = np.asarray(sentiment_score_list)

    sentiment_score_list = []
    for date, row in train.T.iteritems():
    sentiment_score = np.asarray([df.loc[date, ‘neg’], df.loc[date, ‘pos’]])
    sentiment_score_list.append(sentiment_score)
    numpy_df_train = np.asarray(sentiment_score_list)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    由于我们程序预测的目标是股价,因此y标签也就是股价。

    y_train = pd.DataFrame(train[‘prices’])
    y_test = pd.DataFrame(test[‘prices’])
    1
    2
    使用随机森林算法对股价进行预测
    使用Scikit Learn封装好了的的随机森林算法对股票进行预测。

    rf = RandomForestRegressor()
    rf.fit(numpy_df_train, y_train)

    #print(rf.feature_importances_)
    prediction, bias, contributions = ti.predict(rf, numpy_df_test)
    print(preditcion)
    1
    2
    3
    4
    5
    6
    在看到控制台有输出之后,如果输出正确则证明使用随机森林算法对股票预测成功了。为了更加直观地观察我们的预测与实际情况有多少偏差,则需要使用Matplotlib来进行绘图。

    #Matplot
    idx = pd.date_range(test_start_date, test_end_date)
    predictions_df = pd.DataFrame(data=prediction[0:731], index=idx, columns=[‘prices’])
    print(predictions_df)
    predictions_plot = predictions_df.plot()

    fig = y_test.plot(ax=predictions_plot).get_figure()

    ax = predictions_df.rename(columns={“Price”: “Predicted Price”}).plot(title=‘Random Forest Predict Stock Price’)
    ax.set_xlabel(“Date”)
    ax.set_ylabel(“Price”)
    fig = y_test.rename(columns={“Price”: “Actual Price”}).plot(ax=ax).get_figure()
    fig.savefig(“RF_noSmoothing.png”)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    通过上述代码,我们绘制了没有平滑的随机森林算法预测的股价走势,并保存为”RF_noSmoothing.png”。

    上图中蓝色的折线是预测的股价,而橙色的折现是真实的股票走势。很明显我们的预测与实际产生了巨大的偏差,因此我们需要对数据进行进一步处理,将股价加上一个常数来表示测试时的闭市股价。

    temp_date = test_start_date
    average_last_5_days_test = 0
    total_days = 10
    for i in range(total_days):
    average_last_5_days_test += test.loc[temp_date, ‘prices’]
    temp_date = datetime.strptime(temp_date, “%Y-%m-%d”).date()
    difference = temp_date + timedelta(days=1)
    temp_date = difference.strftime(’%Y-%m-%d’)
    average_last_5_days_test = average_last_5_days_test / total_days
    print(average_last_5_days_test)

    temp_date = test_start_date
    average_upcoming_5_days_predicted = 0
    for i in range(total_days):
    average_upcoming_5_days_predicted += predictions_df.loc[temp_date, ‘prices’]
    temp_date = datetime.strptime(temp_date, “%Y-%m-%d”).date()
    difference = temp_date + timedelta(days=1)
    temp_date = difference.strftime(’%Y-%m-%d’)
    print(temp_date)
    average_upcoming_5_days_predicted = average_upcoming_5_days_predicted / total_days
    print(average_upcoming_5_days_predicted)
    difference_test_predicted_prices = average_last_5_days_test - average_upcoming_5_days_predicted
    print(difference_test_predicted_prices)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    predictions_df[‘prices’] = predictions_df[‘prices’] + difference_test_predicted_prices
    1
    再次使用Matplotlib对修正过后的预测进行绘图。

    RF plot aligned

    ax = predictions_df.rename(columns={“prices”: “predicted_price”}).plot(title=‘Random Forest Predict Stock Price Aligned’)
    ax.set_xlabel(“Dates”)
    ax.set_ylabel(“Stock Prices”)
    fig = y_test.rename(columns={“prices”: “actual_price”}).plot(ax = ax).get_figure()
    fig.savefig(“RF_aligned.png”)
    1
    2
    3
    4
    5
    6

    通过对预测数据进行修正,我们发现预测折线开始向实际折线靠拢了,但预测折线上下抖动太过明显,因此需要对其进行平滑处理。在平滑处理方面,我们使用Pandas的EWMA(Exponentially Weighted Moving-Average,指数加权移动平均值的控制图)方法来进行。

    Pandas EWMA

    predictions_df[‘ewma’] = pd.ewma(predictions_df[“prices”], span=60, freq=“D”).mean()

    predictions_df[‘ewm’] =
    predictions_df[“prices”].ewm(span=60, min_periods=0, freq=‘D’, adjust=True, ignore_na=False).mean()

    predictions_df[‘actual_value’] = test[‘prices’]

    predictions_df[‘actual_value_ewma’] = pd.ewma(predictions_df[“actual_value”], span=60, freq=“D”).mean()

    predictions_df[‘actual_value_ewm’] =
    predictions_df[“actual_value”].ewm(span=60, min_periods=0, freq=‘D’, adjust=True, ignore_na=False).mean()
    predictions_df.columns = [‘predicted_price’, ‘average_predicted_price’, ‘actual_price’, ‘average_actual_price’]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    再次对我们随机森林算法预测的结果进行绘图。

    RF smoothed

    predictions_plot = predictions_df.plot(title=‘Random Forest Predict Stock Price Aligned and Smoothed’)
    predictions_plot.set_xlabel(“Dates”)
    predictions_plot.set_ylabel(“Stock Prices”)
    fig = predictions_plot.get_figure()
    fig.savefig(“RF_smoothed.png”)
    1
    2
    3
    4
    5
    6

    我们可以看到,随机森林算法并没有很好地拟合股票走势的曲线。上图中,绿色和红色的是实际股票的走势。而橙色的平滑后的预测走势与最后部分真实股票的走向甚至相反。
    让我们只绘制平滑后的实际股市走势与预测走势的折现。

    只绘制平滑后的实际股市走势与预测走势的折现

    predictions_df_average = predictions_df[[‘Average_predicted_price’, ‘Average_actual_price’]]
    predictions_plot = predictions_df_average.plot(title=‘Random Forest Predict Stock Price Aligned and Smoothed’)
    predictions_plot.set_xlabel(“Dates”)
    predictions_plot.set_ylabel(“Prices”)
    fig = predictions_plot.get_figure()
    fig.savefig(“RF_smoothed_and_actual_price.png”)
    1
    2
    3
    4
    5
    6
    7

    很明显,随机森林算法的预测效果并没有理想中的那么好。那么下一步,我们将尝试使用最普遍的线性回归模型来进行预测。

    使用线性回归算法对股价进行预测
    线性回归模型具有效率高的特点,我的“从零开始机器学习”系列文章中从零开始机器学习-10 TensorFlow的基本使用方法便是以线性回归为例子讲的TensorFlow使用方法。
    这里我们使用线性回归模型进行预测的过程不再赘述。

    def LR_prediction():
    years = [2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016]
    prediction_list = []
    for year in years:
    # 划分训练集测试集
    train_start_date = str(year) + ‘-01-01’
    train_end_date = str(year) + ‘-10-31’
    test_start_date = str(year) + ‘-11-01’
    test_end_date = str(year) + ‘-12-31’
    train = df.ix[train_start_date: train_end_date]
    test = df.ix[test_start_date:test_end_date]

        # 计算情感分数
        sentiment_score_list = []
        for date, row in train.T.iteritems():
            sentiment_score = np.asarray(
                [df.loc[date, 'compound'], df.loc[date, 'neg'], df.loc[date, 'neu'], df.loc[date, 'pos']])
            sentiment_score_list.append(sentiment_score)
        numpy_df_train = np.asarray(sentiment_score_list)
    
        sentiment_score_list = []
        for date, row in test.T.iteritems():
            sentiment_score = np.asarray(
                [df.loc[date, 'compound'], df.loc[date, 'neg'], df.loc[date, 'neu'], df.loc[date, 'pos']])
            sentiment_score_list.append(sentiment_score)
        numpy_df_test = np.asarray(sentiment_score_list)
    
        # 线性回归模型
        lr = LogisticRegression()
        lr.fit(numpy_df_train, train['prices'])
    
        prediction = lr.predict(numpy_df_test)
        prediction_list.append(prediction)
        idx = pd.date_range(test_start_date, test_end_date)
        predictions_df_list = pd.DataFrame(data=prediction[0:], index=idx, columns=['prices'])
    
        difference_test_predicted_prices = offset_value(test_start_date, test, predictions_df_list)
        # 对齐
        predictions_df_list['prices'] = predictions_df_list['prices'] + difference_test_predicted_prices
        predictions_df_list
    
        # 平滑
        predictions_df_list['ewm'] = predictions_df_list["prices"].ewm(span=10,freq='D').mean()
        predictions_df_list['actual_value'] = test['prices']
        predictions_df_list['actual_value_ewma'] = predictions_df_list["actual_value"].ewm(span=10, freq='D').mean()
        # 更改Series名称
        predictions_df_list.columns = ['predicted_price', 'average_predicted_price', 'actual_price',
                                       'average_actual_price']
        predictions_df_list.plot()
        predictions_df_list_average = predictions_df_list[['average_predicted_price', 'average_actual_price']]
        predictions_df_list_average.plot()
    
        # 只绘制平滑后的实际股市走势与预测走势的折现
        predictions_plot = predictions_df_list_average.plot(title='Linear Regression Predict Stock Price Aligned and Smoothed')
        predictions_plot.set_xlabel("Dates")
        predictions_plot.set_ylabel("Prices")
        fig = predictions_plot.get_figure()
        fig.savefig("LR_smoothed_and_actual_price.png")
    
        plt.show()
    

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60

    通过对所有输出的图(针对很长的时间,分段预测并绘图)的观察,我们可以看到线性回归的预测甚至要比随机森林要好一些,但是并不能给我们太多的参考价值。

    使用神经网络算法对股价进行预测
    关于神经网络相关的知识,我的“从零开始机器学习”系列文章中讲到。
    下面是使用Scikit Learn的MLP(多层感知机)对股价进行预测的代码:

    def MLP_prediction():
    years = [2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016]
    prediction_list = []
    for year in years:
    # 分割数据集与测试集
    train_start_date = str(year) + ‘-01-01’
    train_end_date = str(year) + ‘-10-31’
    test_start_date = str(year) + ‘-11-01’
    test_end_date = str(year) + ‘-12-31’
    train = df.ix[train_start_date: train_end_date]
    test = df.ix[test_start_date:test_end_date]

        # 计算情感分数
        sentiment_score_list = []
        for date, row in train.T.iteritems():
            sentiment_score = np.asarray(
                [df.loc[date, 'compound'], df.loc[date, 'neg'], df.loc[date, 'neu'], df.loc[date, 'pos']])
            sentiment_score_list.append(sentiment_score)
        numpy_df_train = np.asarray(sentiment_score_list)
    
        sentiment_score_list = []
        for date, row in test.T.iteritems():
            sentiment_score = np.asarray(
                [df.loc[date, 'compound'], df.loc[date, 'neg'], df.loc[date, 'neu'], df.loc[date, 'pos']])
            sentiment_score_list.append(sentiment_score)
        numpy_df_test = np.asarray(sentiment_score_list)
    
        # 创建MLP模型
        mlpc = MLPClassifier(hidden_layer_sizes=(100, 200, 100), activation='relu',
                             solver='lbfgs', alpha=0.005, learning_rate_init=0.001, shuffle=False)  # span = 20 # best 1
        mlpc.fit(numpy_df_train, train['prices'])
        prediction = mlpc.predict(numpy_df_test)
    
        prediction_list.append(prediction)
        idx = pd.date_range(test_start_date, test_end_date)
        predictions_df_list = pd.DataFrame(data=prediction[0:], index=idx, columns=['prices'])
    
        difference_test_predicted_prices = offset_value(test_start_date, test, predictions_df_list)
        predictions_df_list['prices'] = predictions_df_list['prices'] + difference_test_predicted_prices
        predictions_df_list
    
        # 平滑
        predictions_df_list['ewma'] = predictions_df_list["prices"].ewm(span=20, freq='D').mean()
        predictions_df_list['actual_value'] = test['prices']
        predictions_df_list['actual_value_ewma'] = predictions_df_list["actual_value"].ewm(span=20, freq='D').mean()
    
        predictions_df_list.columns = ['predicted_price', 'average_predicted_price', 'actual_price',
                                       'average_actual_price']
        predictions_df_list.plot()
        predictions_df_list_average = predictions_df_list[['average_predicted_price', 'average_actual_price']]
        predictions_df_list_average.plot()
    
        plt.show()
    

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53

    通过对预测效果之间的观察,我们发现神经网络预测的效果最好,这是因为神经网络具有强大的表示能力。关于神经网络的相关知识,可以参考文章从零开始机器学习-16 初探神经网络(Neural Network)和从零开始机器学习-17 神经网络的训练过程。

    结语
    人工智能的应用近些年来愈加广泛。因为计算力和数据的爆发,机器学习也迎来了极大的发展。
    本文以对股票的预测为引,展示了机器学习在Data Science方面的强大能力。在生活中,我们可以通过选择合适的算法,编写如微博情感分析、聊天机器人、图像识别、语音识别、天气预测等便及生活的人工智能应用。

    展开全文
  • 如何编写爬虫程序?现如今,随着人工智能时代呼声渐起,以及国家政策的大力扶持,Python得到广泛的应用,Python开发人员也成为了IT界的新贵。作为Python最基础的应用之一,网络爬虫程序是每一个初学Python的人必须...
  • 人工智能是一个热门话题,如今人们都在为此津津乐道,但是如何向那些技术不熟练的人解释呢?如果一个小学生问你,你如何向他阐述人工智能呢? 一些人工智能算法本质上是一种仿生学,如人工神经网络、蚁群算法、...
  • 虽然哥也是一媒体人,但黑起自己的行业来是丝毫不会手软的,假设你现在是一家媒体的IT部门人员,这家媒体每天做的最多,最重要的工作就是从别的网站复制文章过来,然后加一些...于是你决定自己编写一个程序,帮助...
  • 功能需求和用户案例为软件应用程序创建了蓝图。 一组好的需求可以在将业务构想转换为工作代码时简化开发人员的工作。 团队花费大量时间来收集用户故事并将其组织到需求中,以指导开发人员编写代码,但是通常会遗漏...
  • 曾经有人这样说过,人工智能就是一段极具玄幻色彩的“程序”。显而易见的是,这句话不仅说的很对,而且把重点也极其精确的定位到了“编程”上。(拒绝反驳,拒绝杠精!)那么,“编程”又是什么?所谓的“程序”又是...
  • 在上周末,编写了解"13球单球异重"的java程序,并将算法推广到了N个球,13个球需要3步找出答案,3279个球需要8步可以找到答案,解题所需步骤是 log3 (2*N/3)+1,需要安装jre.天平机器人原题12只大小相同的球,其中一只 球...
  • 文章讲的是复杂的人工智能如何用大数据来创造之说,不当电脑根据程序编写的明确要求遵循系列指令,比如IBM在1954年发展的将俄语翻译为英语的程序,人可以轻易理解为什么软件会用一个词代替另一个词。但谷歌翻译在...
  • 分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 问题总是以“什么是死锁?”开始 当两个或多个线程在等待彼此释放所需的资源...
  • 网络爬虫人工智能与大数据给python编程语言带来前所未有的生命力。网络数据抓取是python的基本应用之一。今日头条已经开始布局手机终端搜索引擎业务。当前主要搜索引擎都采取爬虫技术采集互联网数据。其中google的...
  • 目录请先看前言1 人工智能1.1 科普1.2 基础知识1.2.3 神经网络如何判断自己预测得是否准确1.2.4 神经网络是如何进行学习的...教你编写第一个人工智能程序1.3 初级神经网络1.3.1 浅层神经网络1.3.2 如何计算浅层神...
  • 来到2017年, Python已经跃居成为最受欢迎的编程语言,尤其是在大数据分析、量化交易以及人工智能等领域。俗话说工欲善其事,必先利其器,既然Python如此的火,该用什么开发工具来进行高效得开发呢?这个问题可能...
  • 我学习了Python编程语言结构,以编写基于类的基本结构构建了集成类,类方法和类实例的程序,这些结构包括:输入法处理,2D精灵操作和动画,碰撞检测,游戏物理和基本人工智能。 此python代码询问您叫什么名字,并...
  • 章安装1.1如何安装Python31.1.1在Windows上安装31.1.2在MacOS上安装51.1.3在Linux上安装51.1.4在树莓派上安装81.2编写和运行程序81.2.1在Windows上使用8章安装1.1如何安装Python31.1.1在Windows上安装31.1.2在MacOS...
  • Python和人工智能什么关系?学Python可以做什么?近年来,Python成为最受企业和开发人员欢迎的编程语言之一,很多人疑惑Python为什么如此受欢迎,学习Python可以做什么...用Python语言编写程序的时候无需考虑诸如如何
  • Fiber使您可以编写在计算机群集级别上运行的程序,而无需深入研究计算机群集的详细信息。 很容易学习。 Fiber提供了与您熟悉的Python标准库相同的API。 如果您知道如何使用多重处理,则可以使用Fiber对计算机集群...
  • 前言之前本号就有一篇...今天我们更进一步,编写程序让这个智障电脑可以自己与自己不断玩这个"拿石子"游戏,最终学会如何赢得这个游戏。不仅如此,我们还可以通过这个训练后的电脑玩家得知这个游戏的必胜秘诀(文末...
  • 目录一、实验目的二、实验的硬件、软件平台三、实验内容及步骤实验过程安装prolog(Ubuntu)如何启动用prolog解决汉诺塔问题运行如下:总结 一、实验目的 熟悉PROLOG的运行环境,进行PROLOG的基本编程练习; 了解...
  • 我们来看看这两个例子:编写解决问题的程序是非常困难的,比如在杂乱的场景中,在新的照明条件下从新的角度来识别三维物体。我们不知道要如何通过代码来解决这个问题,因为这个识别过程在大脑中完成
  • 这两天在优达学城上学习了谷歌无人驾驶汽车最基本的定位原理,编写了一个简单的python程序,理解了带有传感器的汽车,如何在事先已知的地图中运动时确定自身的位置。虽然只是很简单的数学原理,但是人嘛,活着总是...
  • 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。 提示:以下是本篇文章正文内容,下面案例可供参考 一、pandas是什么? 新建一个工程...
  • 由于人工智能浪潮的兴起,这些天来,用户已经期望应用既智能又知道使用背景的情况。 IBM Watson提供了各种与自然语言相关的服务,您可以使用这些服务来创建此类应用程序。 例如,您可以使用其自然语言理解服务从...
  • 如何开始使用python

    万次阅读 多人点赞 2019-08-15 16:24:09
    python是一门编程语言,被广泛用于编写人工智能程序! 我们可以使用Jupyter notebook这个工具来进行python编程。Jupyter notebook是值得一学的,因为对于一个团队来说交流是很重要的,当你想要向团队或领导阐述你...
  • python是一门编程语言,被广泛用于编写人工智能程序!我们可以使用Jupyter notebook这个工具来进行python编程。Jupyter notebook是值得一学的,因为对于一个团队来说交流是很重要的,当你想要向团队或领导阐述你的...
  • python是一门编程语言,被广泛用于编写人工智能程序!我们可以使用Jupyter notebook这个工具来进行python编程。Jupyter notebook是值得一学的,因为对于一个团队来说交流是很重要的,当你想要向团队或领导阐述你的...
  • 人工智能 人工智能已经进入各种各样的组织和公司,但是,到底是一个福音还是禁令的问题,暂时还是人们讨论的范畴。尽管人工智能程序实在1958年编写的,但是,近年来它已经出现了大幅的增长。S...

空空如也

空空如也

1 2 3 4 5
收藏数 98
精华内容 39
关键字:

如何编写人工智能程序